pi-subagents 0.58.0 → 0.59.0

package/src/runs/background/notify.ts

@@ -15,9 +15,22 @@ import {
 	resolveCompletionBatchConfig,
 } from "./completion-batcher.ts";
 import { SUBAGENT_ASYNC_COMPLETE_EVENT, SUBAGENT_FOREGROUND_COMPLETE_EVENT, type ParallelHandoffReference, type ScheduleOrigin, type SubagentState } from "../../shared/types.ts";
+import { safeTerminalText } from "../../shared/display-text.ts";
+import { resolveSubagentResultStatus } from "../../intercom/result-intercom.ts";
 import { isUnexplainedProcessSignal } from "../shared/process-signal.ts";
 import type { ResultDeliveryOwnership } from "./result-delivery-ownership.ts";
 
+export interface SubagentNotifyChildOutput {
+	workflowKey?: string;
+	runId?: string;
+	agent?: string;
+	status: string;
+	savedOutputPath?: string;
+	preview: string;
+	previewTruncated?: boolean;
+	previewUnavailableReason?: string;
+}
+
 export interface SubagentNotifyDetails {
 	agent: string;
 	status: "completed" | "failed" | "paused" | "stopped";
@@ -27,6 +40,7 @@ export interface SubagentNotifyDetails {
 	durationMs?: number;
 	workflowRunId?: string;
 	childRuns?: Array<{ runId: string; workflowKey?: string; agent?: string; status?: string }>;
+	childOutputs?: SubagentNotifyChildOutput[];
 	reconciledFromDetachedChild?: string;
 	sessionLabel?: string;
 	sessionValue?: string;
@@ -57,7 +71,14 @@ export interface CompletionNotification {
 		workflowKey?: string;
 		agent?: string;
 		status?: string;
+		state?: string;
 		success?: boolean;
+		output?: string;
+		structuredOutput?: unknown;
+		outputState?: "present" | "absent" | "unknown";
+		outputReference?: string | { path?: string };
+		artifactPaths?: { outputPath?: string };
+		detached?: boolean;
 		exitCode?: number | null;
 		processSignal?: string | null;
 		interrupted?: boolean;
@@ -100,6 +121,115 @@ export interface CompletionNotifier {
 	dispose(): void;
 }
 
+const CHILD_OUTPUT_PREVIEW_MAX_BYTES = 4 * 1024;
+const CHILD_OUTPUT_PREVIEW_COUNT = 8;
+const PREVIEW_TRUNCATION_MARKER = "...[preview truncated]";
+type CompletionChild = NonNullable<CompletionNotification["results"]>[number];
+
+function truncateUtf8Head(value: string, maxBytes: number): { text: string; truncated: boolean } {
+	const bytes = Buffer.from(value, "utf8");
+	if (bytes.length <= maxBytes) return { text: value, truncated: false };
+	const markerBytes = Buffer.byteLength(PREVIEW_TRUNCATION_MARKER, "utf8");
+	const contentBytes = Math.max(0, maxBytes - markerBytes);
+	let end = contentBytes;
+	while (end > 0 && (bytes[end]! & 0xc0) === 0x80) end -= 1;
+	return {
+		text: `${bytes.subarray(0, end).toString("utf8")}${PREVIEW_TRUNCATION_MARKER}`,
+		truncated: true,
+	};
+}
+
+function boundedSafeText(value: string, maxBytes = 1_024): string {
+	return truncateUtf8Head(safeTerminalText(value).replace(/\n/g, "\\n"), maxBytes).text;
+}
+
+function outputPathFromReference(value: CompletionChild["outputReference"]): string | undefined {
+	if (typeof value === "string" && value.trim()) return value.trim();
+	if (value && typeof value === "object" && typeof value.path === "string" && value.path.trim()) return value.path.trim();
+	return undefined;
+}
+
+function childSavedOutputPath(child: CompletionChild): string | undefined {
+	return outputPathFromReference(child.outputReference);
+}
+
+function childStatus(child: CompletionChild, workflowState?: string): string {
+	const knownStatus = child.status === "complete"
+		? "completed"
+		: child.status === "completed" || child.status === "failed" || child.status === "paused" || child.status === "stopped" || child.status === "detached"
+			? child.status
+		: undefined;
+	if (knownStatus) return knownStatus;
+	return resolveSubagentResultStatus({
+		success: child.success,
+		state: child.state ?? (child.success === undefined ? workflowState : undefined),
+		interrupted: child.interrupted,
+		detached: child.detached,
+		processSignal: child.processSignal,
+		timedOut: child.timedOut,
+		stopped: child.stopped,
+		turnBudgetExceeded: child.turnBudgetExceeded,
+		exitCode: typeof child.exitCode === "number" ? child.exitCode : undefined,
+	});
+}
+
+function structuredOutputText(value: unknown): string | undefined {
+	if (value === undefined) return undefined;
+	try {
+		const serialized = JSON.stringify(value, null, 2);
+		return typeof serialized === "string" ? serialized : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function childInlinePreview(child: CompletionChild): { preview?: string; truncated?: boolean; unavailableReason?: string } {
+	const output = typeof child.output === "string" ? child.output : "";
+	const outputReference = childSavedOutputPath(child);
+	const referenceOnly = Boolean(outputReference && output.trim().startsWith("Output saved to:"));
+	const raw = child.outputState === "absent" || referenceOnly ? structuredOutputText(child.structuredOutput) : output || structuredOutputText(child.structuredOutput);
+	if (!raw?.trim()) {
+		return { unavailableReason: referenceOnly ? "saved output is file-only" : "no safe inline output" };
+	}
+	const safe = safeTerminalText(raw);
+	if (!safe.trim()) return { unavailableReason: "no safe inline output" };
+	const bounded = truncateUtf8Head(safe, CHILD_OUTPUT_PREVIEW_MAX_BYTES);
+	return { preview: bounded.text, ...(bounded.truncated ? { truncated: true } : {}) };
+}
+
+function formatChildOutputBlock(children: SubagentNotifyChildOutput[] | undefined): string | undefined {
+	if (!children?.length) return undefined;
+	const lines = ["Child outputs:"];
+	for (let index = 0; index < children.length; index++) {
+		const child = children[index]!;
+		const key = child.workflowKey ? boundedSafeText(child.workflowKey) : "unavailable";
+		const runId = child.runId ? boundedSafeText(child.runId) : "unavailable";
+		const status = boundedSafeText(child.status) || "unavailable";
+		lines.push(`- key=${key} run=${runId} status=${status}`);
+		lines.push(`  Saved output: ${child.savedOutputPath ? boundedSafeText(child.savedOutputPath) : "unavailable"}`);
+		if (index >= CHILD_OUTPUT_PREVIEW_COUNT) {
+			lines.push("  Preview: unavailable (notice preview budget exceeded)");
+			continue;
+		}
+		if (!child.preview) {
+			lines.push(`  Preview: unavailable (${child.previewUnavailableReason ?? "no safe inline output"})`);
+			continue;
+		}
+		lines.push("  Preview:");
+		for (const line of child.preview.split("\n")) lines.push(`    | ${line}`);
+	}
+	if (children.length > CHILD_OUTPUT_PREVIEW_COUNT) {
+		lines.push(`- ${children.length - CHILD_OUTPUT_PREVIEW_COUNT} additional child preview(s) omitted by notice budget; child run metadata is retained below.`);
+	}
+	return lines.join("\n");
+}
+
+function formatResultPreview(details: SubagentNotifyDetails): string {
+	const summary = details.resultPreview.trim() ? details.resultPreview : "(no output)";
+	const childOutputs = formatChildOutputBlock(details.childOutputs);
+	return childOutputs ? `${summary}\n\n${childOutputs}` : summary;
+}
+
 function formatSessionLine(details: SubagentNotifyDetails): string | undefined {
 	if (!details.sessionValue) return undefined;
 	return details.sessionLabel ? `${details.sessionLabel}: ${details.sessionValue}` : details.sessionValue;
@@ -131,7 +261,7 @@ export function formatSingleCompletion(details: SubagentNotifyDetails): string {
 		"",
 		scheduleLine,
 		scheduleLine ? "" : undefined,
-		details.resultPreview.trim() ? details.resultPreview : "(no output)",
+		formatResultPreview(details),
 		details.handoffPath ? "" : undefined,
 		details.handoffPath ? `Parallel handoff: ${details.handoffPath}` : undefined,
 		correlationLines.length && !details.handoffPath ? "" : undefined,
@@ -218,7 +348,7 @@ export function formatGroupedCompletion(details: SubagentNotifyDetails[]): strin
 		if (!detail) continue;
 		const sessionLine = formatSessionLine(detail);
 		blocks.push(`${index + 1}. ${detail.agent}${detail.taskInfo ?? ""}${detail.scheduleOrigin ? ` — scheduled run from ${detail.scheduleOrigin.name ?? detail.scheduleOrigin.id} (schedule ${detail.scheduleOrigin.id})` : ""}`);
-		blocks.push(detail.resultPreview.trim() ? detail.resultPreview : "(no output)");
+		blocks.push(formatResultPreview(detail));
 		if (detail.handoffPath) blocks.push(`Parallel handoff: ${detail.handoffPath}`);
 		blocks.push(...formatCorrelationLines(detail));
 		if (sessionLine) blocks.push(sessionLine);
@@ -275,6 +405,7 @@ export function buildCompletionDetails(result: CompletionNotification): Subagent
 	const paused = !stopped && !result.success && (
 		result.exitCode === 0
 		|| result.state === "paused"
+		|| result.interrupted === true
 		|| summary.startsWith("Paused after interrupt.")
 	);
 	const status = stopped ? "stopped" : paused ? "paused" : result.success ? "completed" : "failed";
@@ -290,14 +421,34 @@ export function buildCompletionDetails(result: CompletionNotification): Subagent
 	const rawRunId = typeof result.runId === "string" ? result.runId : typeof result.id === "string" ? result.id : undefined;
 	const workflowRunId = (result.mode === "workflow" || agent === "workflow") && rawRunId ? rawRunId : undefined;
 	const childRuns = result.results?.flatMap((child) => {
-		if (typeof child.runId !== "string" || !child.runId.trim()) return [];
+		const runId = typeof child.runId === "string" && child.runId.trim() ? child.runId.trim() : undefined;
+		const workflowKey = typeof child.workflowKey === "string" && child.workflowKey.trim() ? child.workflowKey.trim() : undefined;
+		if (!runId && (!workflowRunId || !workflowKey)) return [];
 		return [{
-			runId: child.runId,
-			...(typeof child.workflowKey === "string" ? { workflowKey: child.workflowKey } : {}),
+			runId: runId ?? "unavailable",
+			...(workflowKey ? { workflowKey } : {}),
 			...(typeof child.agent === "string" ? { agent: child.agent } : {}),
-			...(typeof child.status === "string" ? { status: child.status } : {}),
+			status: childStatus(child, workflowRunId ? result.state : undefined),
 		}];
 	}) ?? [];
+	const childOutputs = workflowRunId && result.results?.length
+		? result.results.map((child) => {
+			const inline = childInlinePreview(child);
+			const workflowKey = typeof child.workflowKey === "string" && child.workflowKey.trim() ? child.workflowKey.trim() : undefined;
+			const runId = typeof child.runId === "string" && child.runId.trim() ? child.runId.trim() : undefined;
+			const savedOutputPath = childSavedOutputPath(child);
+			return {
+				...(workflowKey ? { workflowKey } : {}),
+				...(runId ? { runId } : {}),
+				...(typeof child.agent === "string" ? { agent: child.agent } : {}),
+				status: childStatus(child, result.state),
+				...(savedOutputPath ? { savedOutputPath } : {}),
+				...(inline.preview ? { preview: inline.preview } : { preview: "" }),
+				...(inline.truncated ? { previewTruncated: true } : {}),
+				...(inline.unavailableReason ? { previewUnavailableReason: inline.unavailableReason } : {}),
+			};
+		})
+		: undefined;
 	const reconciledFromDetachedChild = typeof result.reconciledFromDetachedChild === "string" ? result.reconciledFromDetachedChild : undefined;
 	const session =
 		result.shareUrl
@@ -322,6 +473,7 @@ export function buildCompletionDetails(result: CompletionNotification): Subagent
 		...(handoffPath ? { handoffPath } : {}),
 		...(workflowRunId ? { workflowRunId } : {}),
 		...(childRuns.length ? { childRuns } : {}),
+		...(childOutputs?.length ? { childOutputs } : {}),
 		...(reconciledFromDetachedChild ? { reconciledFromDetachedChild } : {}),
 		...(session ? { sessionLabel: session.label, sessionValue: session.value } : {}),
 	};

package/src/runs/background/result-files.ts

@@ -343,7 +343,8 @@ export function resultPayloadPathForMissionObserverRun(resultsDir: string, runId
 		if (!entry || entry.runId !== runId) return undefined;
 		return resultPayloadLocationFromIndex(resultsDir, entry)?.path;
 	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code !== "ENOENT" && !isUnaddressableResultCandidate(error)) console.error(`Ignoring invalid async result observer index for '${runId}':`, error);
+		const code = (error as NodeJS.ErrnoException).code;
+		if (code !== "ENOENT" && code !== "ENOTDIR" && !isUnaddressableResultCandidate(error)) console.error(`Ignoring invalid async result observer index for '${runId}':`, error);
 		return undefined;
 	}
 }

package/src/runs/background/result-watcher.ts

@@ -67,6 +67,7 @@ type ResultWatcherDeps = {
 
 type ResultFileChild = {
 	agent?: string;
+	sessionName?: string;
 	output?: string;
 	structuredOutput?: unknown;
 	outputState?: SubagentOutputState;
@@ -482,6 +483,7 @@ export function createResultWatcher(
 							: undefined;
 				return {
 					agent: result.agent ?? data.agent ?? `step-${index + 1}`,
+					...(result.sessionName ? { sessionName: result.sessionName } : {}),
 					status: resolveSubagentResultStatus({
 						success: result.success,
 						state: childState,

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

@@ -39,7 +39,7 @@ export function formatResumeFirstFailedRunDetail(run: AsyncRunSummary): string |
 }
 
 export function formatResumeFirstFailedRunsNote(runs: AsyncRunSummary[]): string {
-	const failedRuns = runs.filter((run) => run.state === "failed");
+	const failedRuns = runs.filter((run) => run.state === "failed" || run.state === "partial");
 	const detachGuidance = failedRuns
 		.map(formatIntercomDetachGuidance)
 		.filter((guidance): guidance is string => Boolean(guidance));

package/src/runs/background/retained-children.ts

@@ -27,7 +27,7 @@ export interface RetainedChild {
 }
 
 function isRetainedChildState(state: AsyncRunSummary["state"]): state is RetainedChildState {
-	return state === "complete" || state === "failed" || state === "paused" || state === "stopped";
+	return state === "complete" || state === "failed" || state === "partial" || state === "paused" || state === "stopped";
 }
 
 function isTerminalStepStatus(status: AsyncRunSummary["steps"][number]["status"]): boolean {

package/src/runs/background/run-status.ts

@@ -23,6 +23,7 @@ import { attachRootChildrenToSteps, findNestedRouteForRootId, projectNestedRegis
 import { readMissionBinding } from "../../missions/lifecycle.ts";
 import { formatWorkflowJsonPreview } from "../../workflows/scripted-workflow.ts";
 import { parseWorkflowChildSummary } from "../../workflows/workflow-child-summary.ts";
+import { formatWorkflowPreflightPlanSummary, formatWorkflowPreflightWarningSummary } from "../../workflows/workflow-preflight.ts";
 import { formatRunFanoutBudget, getRunFanoutBudgetSnapshot, readRunFanoutBudgetDescriptor } from "../shared/run-fanout-budget.ts";
 import { getExternalJobProvider } from "../../api/external-job-provider.ts";
 
@@ -64,13 +65,14 @@ function formatCapacityOwner(inspect: ActiveAsyncCapacityInspection): string[] {
 }
 
 function formatWorkflowDebug(status: AsyncStatus): string[] {
-	if (status.mode !== "workflow" && !status.parentWorkflowRunId && !status.workflowKey) return [];
+	if (status.mode !== "workflow" && !status.parentWorkflowRunId && !status.workflowKey && !status.lane) return [];
 	const lines = [
 		status.parentWorkflowRunId ? `Workflow parent: ${status.parentWorkflowRunId}${status.workflowKey ? ` (${status.workflowKey})` : ""}` : undefined,
 		status.mode === "workflow" ? `Workflow children: ${(status.steps ?? []).length}` : undefined,
+		status.lane ? `Lane: ${status.lane.key}${status.lane.mode ? ` (${status.lane.mode})` : ""}` : undefined,
 	].filter((line): line is string => line !== undefined);
 	for (const [index, step] of (status.steps ?? []).entries()) {
-		lines.push(`  ${index + 1}. key ${step.workflowKey ?? "n/a"} · ${step.agent} · ${step.status} · async ${step.async === undefined ? "unknown" : step.async ? "yes" : "no"}${step.runId ? ` · run ${step.runId}` : ""}`);
+		lines.push(`  ${index + 1}. key ${step.workflowKey ?? "n/a"} · ${runStatusStepDisplayName(step)} · ${step.status} · async ${step.async === undefined ? "unknown" : step.async ? "yes" : "no"}${step.runId ? ` · run ${step.runId}` : ""}${step.lane ? ` · lane ${step.lane.key}` : ""}${step.worktreePath ? ` · worktree ${step.worktreePath} · branch ${step.branch ?? "unknown"}` : ""}`);
 	}
 	return lines;
 }
@@ -88,6 +90,7 @@ function formatRunLifecycleDebug(input: { status: AsyncStatus; asyncDir: string;
 		`Mode: ${status.mode}`,
 		status.parentWorkflowRunId ? `Workflow parent: ${status.parentWorkflowRunId}` : undefined,
 		status.workflowKey ? `Workflow key: ${status.workflowKey}` : undefined,
+		status.lane ? `Lane: ${status.lane.key}${status.lane.mode ? ` (${status.lane.mode})` : ""}` : undefined,
 		`Status process terminal: ${formatProcessTerminal(overlayProcessTerminal)}`,
 		`Sidecar process terminal: ${formatProcessTerminal(sidecarProcessTerminal)}`,
 		...formatCapacityOwner(capacity),
@@ -152,7 +155,12 @@ function stepLineLabel(status: AsyncStatus, index: number): string {
 	return `Step ${index + 1}`;
 }
 
+function runStatusStepDisplayName(step: { agent: string; sessionName?: string; label?: string }): string {
+	return step.sessionName?.trim() || (step.label ? `${step.label} (${step.agent})` : step.agent);
+}
+
 function nestedRunDisplayName(run: NestedRunSummary): string {
+	if (run.sessionName?.trim()) return run.sessionName.trim();
 	if (run.agent) return run.agent;
 	if (run.agents?.length) return run.agents.join(", ");
 	return run.id;
@@ -197,7 +205,7 @@ function formatRememberedForegroundStatus(run: ForegroundResumeRun): string {
 	for (const child of run.children) {
 		const output = rememberedForegroundChildOutput(child).trim().split(/\r?\n/).find((line) => line.trim());
 		const parts = [
-			`${child.index + 1}. ${child.agent} ${child.status}`,
+			`${child.index + 1}. ${child.sessionName?.trim() || child.agent} ${child.status}`,
 			child.exitCode !== undefined ? `exit ${child.exitCode}` : undefined,
 			child.detachedReason ? `detached: ${child.detachedReason}` : undefined,
 			child.acceptance ? `acceptance: ${child.acceptance.status}` : undefined,
@@ -241,7 +249,7 @@ function formatRememberedForegroundTranscript(run: ForegroundResumeRun, options:
 	const lines = [
 		`Run: ${run.runId}`,
 		`State: ${child.status}`,
-		`Child: ${index} (${child.agent})`,
+		`Child: ${index} (${child.sessionName?.trim() || child.agent})`,
 		child.sessionFile ? `Session: ${child.sessionFile}` : undefined,
 		child.transcriptPath ? `Transcript: ${child.transcriptPath}` : undefined,
 		child.artifactPaths?.outputPath ? `Output: ${child.artifactPaths.outputPath}` : undefined,
@@ -277,7 +285,7 @@ function formatNestedExactStatus(rootRunId: string, run: NestedRunSummary): stri
 		for (const [index, step] of run.steps.entries()) {
 			const activity = step.status === "running" ? formatActivityLabel(step.lastActivityAt, step.activityState) : undefined;
 			const budget = step.turnBudget ? `, turn budget: ${step.turnBudget.turnCount}/${step.turnBudget.maxTurns}+${step.turnBudget.graceTurns} (${step.turnBudget.outcome})` : "";
-			lines.push(`  ${index + 1}. ${step.agent} ${step.status}${activity ? `, ${activity}` : ""}${budget}${step.error ? `, error: ${step.error}` : ""}`);
+			lines.push(`  ${index + 1}. ${step.sessionName?.trim() || step.agent} ${step.status}${activity ? `, ${activity}` : ""}${budget}${step.error ? `, error: ${step.error}` : ""}`);
 			lines.push(...formatNestedRunStatusLines(step.children, { indent: "    ", commandHints: true }));
 		}
 	}
@@ -504,6 +512,8 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 				statusActivityText ? `Activity: ${statusActivityText}` : undefined,
 				steeringText ? `Steering: ${steeringText}` : undefined,
 				`Mode: ${status.mode}`,
+				...(status.preflight ? [formatWorkflowPreflightPlanSummary(status.preflight)] : []),
+				...(status.workflow?.preflightWarnings?.length ? [formatWorkflowPreflightWarningSummary(status.workflow.preflightWarnings)] : []),
 				runFanoutBudget ? formatRunFanoutBudget(runFanoutBudget) : undefined,
 				status.parentWorkflowRunId ? `Workflow parent: ${status.parentWorkflowRunId}${status.workflowKey ? ` (${status.workflowKey})` : ""}` : undefined,
 				status.mode === "workflow" && workflowReturnPreview !== undefined ? `Return: ${workflowReturnPreview}` : undefined,
@@ -535,7 +545,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 				const errorText = step.error ? `, error: ${step.error}` : "";
 				const acceptanceText = step.acceptance?.status ? `, acceptance: ${step.acceptance.status}` : "";
 				const budgetText = step.turnBudget ? `, turn budget: ${step.turnBudget.turnCount}/${step.turnBudget.maxTurns}+${step.turnBudget.graceTurns} (${step.turnBudget.outcome})` : "";
-				const display = step.label ? `${step.label} (${step.agent})` : step.agent;
+				const display = runStatusStepDisplayName(step);
 				const phase = step.phase ? `[${step.phase}] ` : "";
 				lines.push(`${stepLineLabel(status, index)}: ${phase}${display} ${step.status}${modelText}${stepActivityText ? `, ${stepActivityText}` : ""}${steeringSuffix}${acceptanceText}${budgetText}${errorText}`);
 				if (step.runner?.type === "external-cli") {
@@ -608,7 +618,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 
 			const workflowChildren = parseWorkflowChildSummary(status.workflowChildren);
 			if (workflowChildren && workflowChildren.workflowRunId !== status.runId) throw new Error("workflowChildren.workflowRunId does not match async status runId.");
-			return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [], ...(workflowChildren ? { workflowChildren } : {}), ...(runFanoutBudget ? { runFanoutBudget } : {}), ...(processTerminal ? { lifecycleStatus: { processTerminal } } : {}) } };
+			return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [], ...(status.preflight ? { preflight: status.preflight } : {}), ...(status.workflow?.preflightWarnings?.length ? { preflightWarnings: status.workflow.preflightWarnings } : {}), ...(workflowChildren ? { workflowChildren } : {}), ...(runFanoutBudget ? { runFanoutBudget } : {}), ...(processTerminal ? { lifecycleStatus: { processTerminal } } : {}) } };
 		}
 	}
 
@@ -622,7 +632,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 		}
 		try {
 			const raw = fs.readFileSync(resultPath, "utf-8");
-			const data = JSON.parse(raw) as { id?: string; runId?: string; toolCallId?: string; agent?: string; success?: boolean; summary?: string; output?: string; exitCode?: number; state?: string; stopped?: boolean; timedOut?: boolean; turnBudgetExceeded?: boolean; processSignal?: string | null; sessionFile?: string; parallelHandoff?: { path?: string }; results?: Array<{ agent?: string; runId?: string; workflowKey?: string; output?: string; summary?: string; sessionFile?: string; state?: string; success?: boolean; exitCode?: number | null; stopped?: boolean; timedOut?: boolean; turnBudgetExceeded?: boolean; interrupted?: boolean; processSignal?: string | null }> };
+			const data = JSON.parse(raw) as { id?: string; runId?: string; toolCallId?: string; agent?: string; success?: boolean; summary?: string; output?: string; exitCode?: number; state?: string; stopped?: boolean; timedOut?: boolean; turnBudgetExceeded?: boolean; processSignal?: string | null; sessionFile?: string; parallelHandoff?: { path?: string }; results?: Array<{ agent?: string; sessionName?: string; runId?: string; workflowKey?: string; output?: string; summary?: string; sessionFile?: string; state?: string; success?: boolean; exitCode?: number | null; stopped?: boolean; timedOut?: boolean; turnBudgetExceeded?: boolean; interrupted?: boolean; processSignal?: string | null }> };
 			if (params.view === "transcript") {
 				try {
 					return { content: [{ type: "text", text: formatAsyncResultTranscript(data, resultPath, { index: params.index, lines: params.lines }) }], details: { mode: "single", results: [] } };

package/src/runs/background/scheduled-runs.ts

@@ -1,3 +1,4 @@
+import { spawnSync } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -11,6 +12,8 @@ import type { SubagentParamsLike } from "../foreground/subagent-executor.ts";
 import { validateExecutionAcceptance } from "../shared/acceptance.ts";
 import type { ResolvedSubagentCapabilityCeiling } from "../shared/capability-ceiling.ts";
 import { previewSimpleWorkflowRun } from "../../workflows/scripted-workflow.ts";
+import { resolveGitRepositoryIdentity } from "../../workflows/chat-progress.ts";
+import { getConfigDirName } from "../../shared/utils.ts";
 
 export const SCHEDULED_RUN_ACTIONS = [
 	"schedule.create",
@@ -142,11 +145,83 @@ function validateScheduleId(id: string): string {
 	return id;
 }
 
+function normalizedComparisonPath(value: string): string {
+	const absolute = path.resolve(value);
+	if (process.platform !== "win32") return absolute;
+	let normalized = absolute;
+	try { normalized = fs.realpathSync.native(absolute); } catch {}
+	normalized = normalized.replaceAll("/", "\\");
+	if (normalized.startsWith("\\\\?\\UNC\\")) normalized = `\\\\${normalized.slice(8)}`;
+	else if (normalized.startsWith("\\\\?\\")) normalized = normalized.slice(4);
+	normalized = path.win32.normalize(normalized).toLowerCase();
+	if (normalized.length > 3) normalized = normalized.replace(/[\\]+$/, "");
+	return normalized;
+}
+
 function pathWithin(root: string, candidate: string): boolean {
-	const relative = path.relative(root, candidate);
+	const relative = path.relative(normalizedComparisonPath(root), normalizedComparisonPath(candidate));
 	return relative === "" || (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
 }
 
+function resolveGitCommonDirForCheckout(checkoutRoot: string): string | undefined {
+	const gitPath = path.join(checkoutRoot, ".git");
+	try {
+		const stat = fs.statSync(gitPath);
+		if (stat.isDirectory()) return fs.realpathSync.native(gitPath);
+		if (!stat.isFile()) return undefined;
+		const match = /^gitdir:[ \t]*([^\r\n]+)$/i.exec(fs.readFileSync(gitPath, "utf-8").trim());
+		return match?.[1] ? fs.realpathSync.native(path.resolve(checkoutRoot, match[1])) : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function samePath(left: string, right: string): boolean {
+	return normalizedComparisonPath(left) === normalizedComparisonPath(right);
+}
+
+function resolveTrustedGitConfigRoot(checkoutRoot: string, commonDir: string): string | undefined {
+	const resolvedCommonDir = resolveGitCommonDirForCheckout(checkoutRoot);
+	if (!resolvedCommonDir || !samePath(resolvedCommonDir, commonDir)) return undefined;
+	const configRoot = path.join(checkoutRoot, getConfigDirName());
+	try {
+		const resolved = fs.realpathSync.native(configRoot);
+		return fs.statSync(resolved).isDirectory() && pathWithin(checkoutRoot, resolved) ? resolved : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function registeredGitWorktreeRoots(projectCwd: string): string[] {
+	const result = spawnSync("git", ["-C", projectCwd, "worktree", "list", "--porcelain"], { encoding: "utf-8", windowsHide: true });
+	if (result.status !== 0 || typeof result.stdout !== "string") return [];
+	const roots: string[] = [];
+	for (const line of result.stdout.split(/\r?\n/)) {
+		if (!line.startsWith("worktree ")) continue;
+		try { roots.push(fs.realpathSync.native(line.slice("worktree ".length).trim())); } catch {}
+	}
+	return roots;
+}
+
+function resolveSharedGitConfigRoot(projectCwd: string): string | undefined {
+	const repository = resolveGitRepositoryIdentity(projectCwd);
+	if (!repository) return undefined;
+	let projectConfigRoot: string;
+	try {
+		projectConfigRoot = fs.realpathSync.native(path.join(projectCwd, getConfigDirName()));
+	} catch {
+		return undefined;
+	}
+	// Git may report a separate-git-dir primary checkout as its common git
+	// directory, not as the checkout root. Without a registered checkout root,
+	// do not infer a shared config path from that unprovable layout.
+	for (const checkoutRoot of new Set(registeredGitWorktreeRoots(projectCwd))) {
+		const resolved = resolveTrustedGitConfigRoot(checkoutRoot, repository.commonDir);
+		if (resolved && samePath(resolved, projectConfigRoot)) return resolved;
+	}
+	return undefined;
+}
+
 function assertScheduleRoot(root: string, projectCwd: string | undefined, create: boolean): void {
 	if (!projectCwd) {
 		if (create) fs.mkdirSync(root, { recursive: true, mode: 0o700 });
@@ -154,7 +229,7 @@ function assertScheduleRoot(root: string, projectCwd: string | undefined, create
 	}
 	let projectPath: string;
 	try {
-		projectPath = fs.realpathSync(projectCwd);
+		projectPath = fs.realpathSync.native(projectCwd);
 	} catch (error) {
 		if (!create && (error as NodeJS.ErrnoException).code === "ENOENT") return;
 		throw error;
@@ -165,10 +240,14 @@ function assertScheduleRoot(root: string, projectCwd: string | undefined, create
 		if (parent === existing) break;
 		existing = parent;
 	}
-	if (!pathWithin(projectPath, fs.realpathSync(existing))) throw new Error(`Project schedule root '${root}' resolves outside the real project.`);
+	const existingPath = fs.realpathSync.native(existing);
+	const sharedGitConfigRoot = pathWithin(projectPath, existingPath) ? undefined : resolveSharedGitConfigRoot(projectCwd);
+	const isTrustedPath = (candidate: string): boolean => pathWithin(projectPath, candidate)
+		|| (sharedGitConfigRoot !== undefined && pathWithin(sharedGitConfigRoot, candidate));
+	if (!isTrustedPath(existingPath)) throw new Error(`Project schedule root '${root}' resolves outside the real project.`);
 	if (!create) return;
 	fs.mkdirSync(root, { recursive: true, mode: 0o700 });
-	if (!pathWithin(projectPath, fs.realpathSync(root))) throw new Error(`Project schedule root '${root}' resolves outside the real project.`);
+	if (!isTrustedPath(fs.realpathSync.native(root))) throw new Error(`Project schedule root '${root}' resolves outside the real project.`);
 }
 
 function scheduleDir(root: string, id: string, create = false, projectCwd?: string): string {
@@ -182,9 +261,9 @@ function scheduleDir(root: string, id: string, create = false, projectCwd?: stri
 		if (!create) return dir;
 		fs.mkdirSync(dir, { mode: 0o700 });
 	}
-	const rootPath = fs.realpathSync(root);
-	const dirPath = fs.realpathSync(dir);
-	if (dirPath !== path.join(rootPath, id)) throw new Error(`Schedule path '${dir}' escapes the project schedule root.`);
+	const rootPath = fs.realpathSync.native(root);
+	const dirPath = fs.realpathSync.native(dir);
+	if (!samePath(dirPath, path.join(rootPath, id))) throw new Error(`Schedule path '${dir}' escapes the project schedule root.`);
 	return dir;
 }
 

package/src/runs/background/stale-run-reconciler.ts

@@ -8,6 +8,7 @@ import { DIRS, type AsyncParallelGroupStatus, type AsyncStatus, type NestedRunSu
 import { resolveEffectiveThinking } from "../../shared/model-info.ts";
 import { normalizeParallelGroups } from "./parallel-groups.ts";
 import { nestedSummaryFromAsyncStatus, projectNestedEvents, resolveNestedAsyncDir, writeNestedEvent, type NestedRoute } from "../shared/nested-events.ts";
+import { assertWorkflowGraphHostSteps } from "../shared/host-step-status.ts";
 
 export type PidLiveness = "alive" | "dead" | "unknown";
 
@@ -24,6 +25,7 @@ interface StartedRunMetadata {
 	parallelGroups?: AsyncParallelGroupStatus[];
 	startedAt?: number;
 	sessionFile?: string;
+	sessionName?: string;
 }
 
 interface ReconcileAsyncRunOptions {
@@ -90,6 +92,7 @@ function appendJsonlBestEffort(filePath: string, payload: object): void {
 
 interface ResultChildOutcome {
 	agent?: string;
+	sessionName?: string;
 	success?: boolean;
 	error?: string;
 	sessionFile?: string;
@@ -101,7 +104,7 @@ interface ResultChildOutcome {
 }
 
 interface ResultRepairData {
-	state: "complete" | "failed" | "paused" | "stopped" | "rejected";
+	state: "complete" | "failed" | "partial" | "paused" | "stopped" | "rejected";
 	results?: ResultChildOutcome[];
 }
 
@@ -117,7 +120,7 @@ function regularFileExists(filePath: string): boolean {
 function readResultRepairData(resultPath: string): ResultRepairData | undefined {
 	try {
 		const data = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as { success?: boolean; state?: string; exitCode?: number; results?: unknown };
-		const state = data.success ? "complete" : data.state === "stopped" ? "stopped" : data.state === "rejected" ? "rejected" : data.state === "paused" || data.exitCode === 0 ? "paused" : "failed";
+		const state = data.success ? "complete" : data.state === "stopped" ? "stopped" : data.state === "rejected" ? "rejected" : data.state === "partial" ? "partial" : data.state === "paused" || data.exitCode === 0 ? "paused" : "failed";
 		const results = Array.isArray(data.results)
 			? data.results.map((entry, index) => {
 				if (!entry || typeof entry !== "object" || Array.isArray(entry)) return {};
@@ -157,8 +160,9 @@ function terminalStatusFromResult(status: AsyncStatus, resultPath: string, now:
 			endedAt: step.endedAt ?? now,
 			durationMs: step.startedAt !== undefined && step.durationMs === undefined ? Math.max(0, now - step.startedAt) : step.durationMs,
 			exitCode: step.exitCode ?? (state === "complete" || state === "paused" ? 0 : 1),
-			error: state === "failed" || state === "stopped" ? step.error ?? child?.error : step.error,
+			error: state === "failed" || state === "partial" || state === "stopped" ? step.error ?? child?.error : step.error,
 			stopped: state === "stopped" ? true : step.stopped,
+			sessionName: step.sessionName ?? child?.sessionName,
 			sessionFile: step.sessionFile ?? child?.sessionFile,
 			model,
 			thinking,
@@ -254,6 +258,7 @@ function buildFailedRepair(status: AsyncStatus, asyncDir: string, now: number, r
 			summary: message,
 			results: repairedSteps.map((step) => ({
 				agent: step.agent,
+				...(step.sessionName ? { sessionName: step.sessionName } : {}),
 				output: step.status === "complete" || step.status === "completed" ? "" : message,
 				error: step.status === "complete" || step.status === "completed" ? undefined : step.error ?? message,
 				success: step.status === "complete" || step.status === "completed",
@@ -290,7 +295,7 @@ function writeFailedRepair(asyncDir: string, status: AsyncStatus, resultPath: st
 }
 
 function terminal(state: AsyncStatus["state"]): boolean {
-	return state === "complete" || state === "failed" || state === "paused" || state === "stopped" || state === "rejected";
+	return state === "complete" || state === "failed" || state === "partial" || state === "paused" || state === "stopped" || state === "rejected";
 }
 
 function* nestedRuns(children: NestedRunSummary[] | undefined): Generator<NestedRunSummary> {
@@ -353,6 +358,7 @@ export function reconcileAsyncRun(asyncDir: string, options: ReconcileAsyncRunOp
 	const startedStatus = !status && options.startedRun ? buildStartedStatus(asyncDir, options.startedRun, now) : undefined;
 	const effectiveStatus = status ?? startedStatus;
 	if (!effectiveStatus) return { status: null, repaired: false };
+	assertWorkflowGraphHostSteps(effectiveStatus.workflowGraph, path.join(asyncDir, "status.json"), effectiveStatus.runId);
 	const statusPath = path.join(asyncDir, "status.json");
 	for (const [index, step] of (effectiveStatus.steps ?? []).entries()) {
 		const stepRecord = step as Record<string, unknown>;

package/src/runs/background/steering.ts

@@ -4,7 +4,6 @@ import { writePrivateAtomicJson } from "../../shared/atomic-json.ts";
 import type {
 	AsyncStatus,
 	ResolvedToolBudget,
-	ResolvedTurnBudget,
 	SteerActionResult,
 	SteeringRecoveryDescriptor,
 	SteeringRequestStatus,
@@ -195,26 +194,17 @@ export function readSteeringStatus(asyncDir: string): SteeringStatus | undefined
 }
 
 export function remainingSteeringRecoveryLimits(
-	descriptor: Pick<SteeringRecoveryDescriptor, "absoluteDeadlineAt" | "initialTurnBudget" | "initialToolBudget">,
-	status: Pick<AsyncStatus, "turnBudget" | "turnCount" | "toolBudget" | "toolCount">,
+	descriptor: Pick<SteeringRecoveryDescriptor, "absoluteDeadlineAt" | "initialToolBudget">,
+	status: Pick<AsyncStatus, "toolBudget" | "toolCount">,
 	now = Date.now(),
-): { timeoutMs?: number; absoluteDeadlineAt?: number; turnBudget?: ResolvedTurnBudget; toolBudget?: ResolvedToolBudget } {
-	const limits: { timeoutMs?: number; absoluteDeadlineAt?: number; turnBudget?: ResolvedTurnBudget; toolBudget?: ResolvedToolBudget } = {};
+): { timeoutMs?: number; absoluteDeadlineAt?: number; toolBudget?: ResolvedToolBudget } {
+	const limits: { timeoutMs?: number; absoluteDeadlineAt?: number; toolBudget?: ResolvedToolBudget } = {};
 	if (descriptor.absoluteDeadlineAt !== undefined) {
 		const timeoutMs = descriptor.absoluteDeadlineAt - now;
 		if (timeoutMs <= 0) throw new Error("Source run has no remaining deadline budget; it remains paused.");
 		limits.timeoutMs = timeoutMs;
 		limits.absoluteDeadlineAt = descriptor.absoluteDeadlineAt;
 	}
-	if (descriptor.initialTurnBudget) {
-		const consumed = status.turnBudget?.turnCount ?? status.turnCount ?? 0;
-		const totalRemaining = descriptor.initialTurnBudget.maxTurns + descriptor.initialTurnBudget.graceTurns - consumed;
-		if (totalRemaining <= 0) throw new Error("Source run has no remaining turn budget; it remains paused.");
-		const softRemaining = Math.max(0, descriptor.initialTurnBudget.maxTurns - consumed);
-		limits.turnBudget = softRemaining > 0
-			? { maxTurns: softRemaining, graceTurns: totalRemaining - softRemaining }
-			: { maxTurns: 1, graceTurns: totalRemaining - 1 };
-	}
 	if (descriptor.initialToolBudget) {
 		const consumed = status.toolBudget?.toolCount ?? status.toolCount ?? 0;
 		const hard = descriptor.initialToolBudget.hard - consumed;