pi-cohort 7.3.1 → 7.4.1

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [7.4.1] - 2026-10-19
+
+### Fixed
+- Non-BLOCKED file-only failures and save errors return an artifact pointer or an explicit not-preserved reason instead of the child reply inline; BLOCKED handoffs and inline mode are unchanged. (#24)
+
+## [7.4.0] - 2026-10-19
+
+### Added
+- Chains can use `{outputs.name.treePath}` in a later child's `cwd` to review a worktree task's base commit plus captured patch in a lazy detached checkout. Trees are shared per named output and cleaned up at chain end; only `treePath` output references are allowed in `cwd`, and not on `worktree: true` steps.
+
+### Fixed
+- Children with both acceptance and `outputSchema` are instructed to write their acceptance report before calling `structured_output`, so both contracts can be satisfied.
+
 ## [7.3.1] - 2026-10-18
 
 ### Fixed

package/README.md

@@ -126,8 +126,8 @@ subagent({ async: false, chain: [
       { agent: "implementer", as: "impl_2", task: "Implement task 2", outputSchema: statusSchema },
     ], worktree: true, stopOn: { path: "/status", in: ["NEEDS_CONTEXT", "BLOCKED"] } },
   { parallel: [
-      { agent: "spec-reviewer", as: "sr_1", task: "Review {outputs.impl_1.patchPath}", outputSchema: verdictSchema },
-      { agent: "spec-reviewer", as: "sr_2", task: "Review {outputs.impl_2.patchPath}", outputSchema: verdictSchema },
+      { agent: "spec-reviewer", as: "sr_1", cwd: "{outputs.impl_1.treePath}", acceptance: { level: "attested" }, task: "Review {outputs.impl_1.patchPath}", outputSchema: verdictSchema },
+      { agent: "spec-reviewer", as: "sr_2", cwd: "{outputs.impl_2.treePath}", acceptance: { level: "attested" }, task: "Review {outputs.impl_2.patchPath}", outputSchema: verdictSchema },
     ], stopOn: { path: "/verdict", in: ["FAIL"] } },
 ]})
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-cohort",
-  "version": "7.3.1",
+  "version": "7.4.1",
   "description": "Delegate Pi work to focused child agents: code review, scouting, implementation, parallel audits, saved chains, and background jobs.",
   "author": "Jacek Juraszek",
   "license": "MIT",

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

@@ -446,13 +446,16 @@ export function executeAsyncChain(
 			...(s.model ? { model: s.model } : {}),
 		};
 	};
-	const buildSeqStep = (s: SequentialStep, sessionFile?: string, behaviorCwd?: string, progressPrecreated = false, resolvedBehavior?: ResolvedStepBehavior, isolatedLeaf?: { runDir: string; index: number }) => {
+	const buildSeqStep = (s: SequentialStep, sessionFile?: string, behaviorCwd?: string, progressPrecreated = false, resolvedBehavior?: ResolvedStepBehavior, isolatedLeaf?: { runDir: string; index: number }, groupCwd?: string) => {
 		const a = agents.find((x) => x.name === s.agent)!;
-		const stepCwd = resolveChildCwd(runnerCwd, s.cwd);
-		const instructionCwd = behaviorCwd ?? stepCwd;
+		const effectiveCwd = s.cwd ?? groupCwd;
+		const templatedCwd = effectiveCwd?.includes("{outputs.");
+		const stepCwd = templatedCwd ? effectiveCwd : resolveChildCwd(runnerCwd, effectiveCwd);
+		const preparationCwd = templatedCwd ? runnerCwd : stepCwd;
+		const instructionCwd = behaviorCwd ?? preparationCwd;
 		const behavior = suppressProgressForReadOnlyTask(resolvedBehavior ?? resolveStepBehavior(a, buildStepOverrides(s), chainSkills), s.task, originalTask);
 		const skillNames = behavior.skills === false ? [] : behavior.skills;
-		const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(skillNames, stepCwd, ctx.cwd);
+		const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(skillNames, preparationCwd, ctx.cwd);
 		if (missingSkills.includes("pi-cohort")) throw new UnavailableSubagentSkillError(UNAVAILABLE_SUBAGENT_SKILL_ERROR);
 
 		let systemPrompt = a.systemPrompt?.trim() ?? "";
@@ -536,13 +539,14 @@ export function executeAsyncChain(
 	try {
 		steps = chain.map((s, stepIndex) => {
 			if (isParallelStep(s)) {
+				const groupCwd = s.cwd?.includes("{outputs.") ? runnerCwd : resolveChildCwd(runnerCwd, s.cwd);
 				const parallelBehaviors = s.parallel.map((task) => {
 					const agent = agents.find((candidate) => candidate.name === task.agent)!;
 					return suppressProgressForReadOnlyTask(resolveStepBehavior(agent, buildStepOverrides(task), chainSkills), task.task, originalTask);
 				});
 				const progressPrecreated = parallelBehaviors.some((behavior) => behavior.progress);
 				if (progressPrecreated) {
-					if (!s.worktree) writeInitialProgressFile(runnerCwd);
+					if (!s.worktree) writeInitialProgressFile(groupCwd);
 					progressInstructionCreated = true;
 				}
 				return {
@@ -550,7 +554,7 @@ export function executeAsyncChain(
 						let behaviorCwd: string | undefined;
 						if (s.worktree) {
 							try {
-								behaviorCwd = resolveExpectedWorktreeAgentCwd(runnerCwd, `${id}-s${stepIndex}`, taskIndex);
+								behaviorCwd = resolveExpectedWorktreeAgentCwd(groupCwd, `${id}-s${stepIndex}`, taskIndex);
 							} catch {
 								behaviorCwd = undefined;
 							}
@@ -562,8 +566,10 @@ export function executeAsyncChain(
 							progressPrecreated,
 							parallelBehaviors[taskIndex],
 							s.worktree ? { runDir: path.join(asyncDir, `step-${stepIndex}`), index: taskIndex } : undefined,
+							s.cwd,
 						);
 					}),
+					cwd: s.cwd,
 					concurrency: s.concurrency,
 					failFast: s.failFast,
 					worktree: s.worktree,

package/src/runs/background/subagent-runner.ts

@@ -7,7 +7,7 @@ import type { Message } from "@earendil-works/pi-ai";
 import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import { appendJsonl, getArtifactPaths } from "../../shared/artifacts.ts";
 import { getPiSpawnCommand, parsePiRuntime, PiRuntimeLaunchError, type PiRuntimeIdentity } from "../shared/pi-spawn.ts";
-import { captureSingleOutputSnapshot, finalizeSingleOutput, formatSavedOutputReference, resolveSingleOutput, type SingleOutputSnapshot } from "../shared/single-output.ts";
+import { captureSingleOutputSnapshot, finalizeSingleOutput, formatFileOnlyFailure, formatSavedOutputReference, resolveSingleOutput, type SingleOutputSnapshot } from "../shared/single-output.ts";
 import {
 	type ActivityState,
 	type ArtifactConfig,
@@ -46,14 +46,14 @@ import {
 	MAX_PARALLEL_CONCURRENCY,
 } from "../shared/parallel-utils.ts";
 import { buildPiArgs, cleanupTempDir, runDirEnv } from "../shared/pi-args.ts";
-import { ChainOutputValidationError, outputEntryFromAsyncResult, resolveOutputReferences } from "../shared/chain-outputs.ts";
+import { ChainOutputValidationError, TreeRegistry, outputEntryFromAsyncResult, resolveOutputReferences } from "../shared/chain-outputs.ts";
 import { buildStopRecord, evaluateStopCondition } from "../shared/stop-conditions.ts";
 import { createStructuredOutputRuntime, readStructuredOutput } from "../shared/structured-output.ts";
 import { collectDynamicResults, DynamicFanoutError, materializeDynamicParallelStep, validateDynamicCollection } from "../shared/dynamic-fanout.ts";
 import { nestedSummaryFromAsyncStatus, writeNestedEvent } from "../shared/nested-events.ts";
 import { formatModelAttemptNote, isRetryableModelFailure } from "../shared/model-fallback.ts";
 import { attachPostExitStdioGuard, trySignalChild } from "../../shared/post-exit-stdio-guard.ts";
-import { detectSubagentError, extractTextFromContent, extractToolArgsPreview, getFinalOutput } from "../../shared/utils.ts";
+import { detectSubagentError, extractTextFromContent, extractToolArgsPreview, getFinalOutput, resolveChildCwd } from "../../shared/utils.ts";
 import { blockedLine, evaluateCompletionMutationGuard } from "../shared/completion-guard.ts";
 import {
 	createMutatingFailureState,
@@ -70,6 +70,7 @@ import { parseSessionTokens } from "../../shared/session-tokens.ts";
 import type { TokenUsage } from "../../shared/types.ts";
 import {
 	cleanupWorktrees,
+	removeTrees,
 	createWorktrees,
 	diffWorktrees,
 	findWorktreeTaskCwdConflict,
@@ -570,6 +571,7 @@ function writeRunLog(
 export interface SingleStepContext {
 	previousOutput: string;
 	outputs?: ChainOutputMap;
+	trees?: TreeRegistry;
 	placeholder: string;
 	cwd: string;
 	sessionEnabled: boolean;
@@ -612,10 +614,20 @@ export async function runSingleStep(
 	acceptance?: import("../../shared/types.ts").AcceptanceLedger;
 	executionSurface?: ExecutionSurfaceResult;
 }> {
+	let childCwd: string;
+	const placeholderRegex = new RegExp(ctx.placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g");
+	let task = step.task.replace(placeholderRegex, () => ctx.previousOutput);
+	try {
+		childCwd = resolveChildCwd(ctx.cwd, resolveOutputReferences(step.cwd ?? ctx.cwd, ctx.outputs ?? {}, ctx.trees));
+		task = resolveOutputReferences(task, ctx.outputs ?? {}, ctx.trees);
+	} catch (error) {
+		if (!(error instanceof ChainOutputValidationError)) throw error;
+		return { agent: step.agent, output: error.message, exitCode: 1, error: error.message, sessionFile: step.sessionFile };
+	}
 	let backendSelection: import("../../execution-backend/selection.ts").ExecutionBackendSelectionResult;
 	try {
 		backendSelection = await selectConfiguredExecutionBackend({
-			cwd: step.cwd ?? ctx.cwd,
+			cwd: childCwd,
 			userConfig: { executionBackend: ctx.executionBackendConfig?.userPreference },
 			preparation: ctx.executionBackendCoordinator,
 		});
@@ -635,17 +647,9 @@ export async function runSingleStep(
 	const effectiveStructuredOutput = step.structuredOutput ?? (step.structuredOutputSchema
 		? createStructuredOutputRuntime(step.structuredOutputSchema, path.join(path.dirname(ctx.outputFile), "structured-output"))
 		: undefined);
-	const placeholderRegex = new RegExp(ctx.placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g");
-	let task = step.task.replace(placeholderRegex, () => ctx.previousOutput);
-	try {
-		task = resolveOutputReferences(task, ctx.outputs ?? {});
-	} catch (error) {
-		if (!(error instanceof ChainOutputValidationError)) throw error;
-		return { agent: step.agent, output: error.message, exitCode: 1, error: error.message, sessionFile: step.sessionFile };
-	}
 	const taskForCompletionGuard = task;
 	if (step.effectiveAcceptance) {
-		const acceptancePrompt = formatAcceptancePrompt(step.effectiveAcceptance);
+		const acceptancePrompt = formatAcceptancePrompt(step.effectiveAcceptance, { structuredOutput: Boolean(effectiveStructuredOutput) });
 		if (acceptancePrompt) task = `${task}\n${acceptancePrompt}`;
 	}
 	const sessionEnabled = Boolean(step.sessionFile) || ctx.sessionEnabled;
@@ -689,7 +693,7 @@ export async function runSingleStep(
 				runId: ctx.id,
 				childId: `${step.agent}-${ctx.flatIndex}`,
 				backend: selection.backend,
-				cwd: step.cwd ?? ctx.cwd,
+				cwd: childCwd,
 				title: step.agent,
 				signal: ownerController.signal,
 			});
@@ -735,7 +739,7 @@ export async function runSingleStep(
 					extensions: step.extensions,
 					systemPrompt: step.systemPrompt,
 					systemPromptMode: step.systemPromptMode,
-					cwd: step.cwd ?? ctx.cwd,
+					cwd: childCwd,
 					promptFileStem: step.agent,
 					runId: ctx.id,
 					childAgentName: step.agent,
@@ -760,7 +764,7 @@ export async function runSingleStep(
 							attemptId: `${ctx.id}-${ctx.flatIndex}-attempt-${index}`,
 							args,
 							environment: mergedEnv,
-							cwd: step.cwd ?? ctx.cwd,
+							cwd: childCwd,
 							sessionFile: attemptSessionFile,
 							interruptSignal: interruptController.signal,
 							onChildEvent: ctx.onChildEvent,
@@ -881,7 +885,7 @@ export async function runSingleStep(
 			extensions: step.extensions,
 			systemPrompt: step.systemPrompt,
 			systemPromptMode: step.systemPromptMode,
-			cwd: step.cwd ?? ctx.cwd,
+			cwd: childCwd,
 			promptFileStem: step.agent,
 			runId: ctx.id,
 			childAgentName: step.agent,
@@ -897,7 +901,7 @@ export async function runSingleStep(
 		try {
 			run = await runPiStreaming(
 				args,
-				step.cwd ?? ctx.cwd,
+				childCwd,
 				ctx.outputFile,
 				env,
 				ctx.runtime,
@@ -1003,6 +1007,8 @@ export async function runSingleStep(
 	let acceptanceCanFailRun = false;
 	let effectiveFinalExitCode = resolvedOutput.saveError ? 1 : finalResult?.exitCode ?? 1;
 	let effectiveFinalError = finalResult?.error;
+	let preservedAt: string | undefined;
+	let notPreservedReason = "artifact output disabled";
 	if (resolvedOutput.saveError) {
 		effectiveFinalError = effectiveFinalError
 			? `${effectiveFinalError}\n${resolvedOutput.saveError}`
@@ -1014,7 +1020,7 @@ export async function runSingleStep(
 			? await evaluateAcceptance({
 				acceptance: step.effectiveAcceptance,
 				output: outputForAcceptance,
-				cwd: step.cwd ?? ctx.cwd,
+				cwd: childCwd,
 			})
 			: undefined;
 		const acceptanceFailure = acceptance ? acceptanceFailureMessage(acceptance) : undefined;
@@ -1033,7 +1039,14 @@ export async function runSingleStep(
 
 	if (artifactPaths && ctx.artifactConfig?.enabled !== false) {
 		if (ctx.artifactConfig?.includeOutput !== false) {
-			fs.writeFileSync(artifactPaths.outputPath, output, "utf-8");
+			try {
+				fs.writeFileSync(artifactPaths.outputPath, output, "utf-8");
+				preservedAt = artifactPaths.outputPath;
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				notPreservedReason = `artifact write failed: ${message}`;
+				throw error;
+			}
 		}
 		if (ctx.artifactConfig?.includeMetadata !== false) {
 			fs.writeFileSync(
@@ -1059,11 +1072,14 @@ export async function runSingleStep(
 		effectiveFinalError = effectiveFinalError ? `${effectiveFinalError}\n${message}` : message;
 	}
 
+	const outputBeforeExternalFinalization = outputForSummary;
+	let externalOutputPersisted = false;
 	// Native runs have runPiStreaming write outputFile live; external runs persist it
 	// before their surface can be destructively closed as delivered.
 	if (externalOwner) {
 		try {
 			fs.writeFileSync(ctx.outputFile, outputForSummary, "utf-8");
+			externalOutputPersisted = true;
 		} catch (error) {
 			const message = safeExternalFailure("output persistence", error);
 			effectiveFinalExitCode = 1;
@@ -1086,6 +1102,30 @@ export async function runSingleStep(
 		executionSurface = { handle: finishResult.handle, retained: finishResult.retained };
 	}
 
+	if (step.outputMode === "file-only"
+		&& (effectiveFinalExitCode !== 0 || resolvedOutput.saveError)
+		&& !blockedLine(effectiveFinalError ?? "")) {
+		const pointer = formatFileOnlyFailure({
+			outputPath: step.outputPath,
+			saveError: resolvedOutput.saveError,
+			...(preservedAt !== undefined ? { preservedAt } : { notPreservedReason }),
+		});
+		outputForSummary = attemptNotes.length > 0
+			? `${attemptNotes.join("\n")}\n\n${pointer}`
+			: pointer;
+	}
+
+	// finish can turn a saved success into a failure after the pre-close log write.
+	if (externalOutputPersisted && outputForSummary !== outputBeforeExternalFinalization) {
+		try {
+			fs.writeFileSync(ctx.outputFile, outputForSummary, "utf-8");
+		} catch (error) {
+			const message = safeExternalFailure("output persistence", error);
+			effectiveFinalExitCode = 1;
+			effectiveFinalError = effectiveFinalError ? `${effectiveFinalError}\n${message}` : message;
+		}
+	}
+
 	return {
 		agent: step.agent,
 		output: outputForSummary,
@@ -1204,8 +1244,9 @@ function prepareParallelTaskRun(
 	cwd: string,
 	worktreeSetup: WorktreeSetup | undefined,
 	taskIndex: number,
+	groupCwd?: string,
 ): { taskForRun: SubagentStep; taskCwd: string } {
-	if (!worktreeSetup) return { taskForRun: task, taskCwd: cwd };
+	if (!worktreeSetup) return { taskForRun: { ...task, cwd: task.cwd ?? groupCwd }, taskCwd: cwd };
 	return {
 		taskForRun: { ...task, cwd: undefined },
 		taskCwd: worktreeSetup.worktrees[taskIndex]!.agentCwd,
@@ -1251,6 +1292,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 	const overallStartTime = Date.now();
 	const shareEnabled = config.share === true;
 	const asyncDir = config.asyncDir;
+	const trees = new TreeRegistry(asyncDir);
 	const executionBackendConfig = config.executionBackends ?? {
 		protocolVersion: 1 as const,
 		registrations: [],
@@ -1669,7 +1711,6 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 		if (interrupted || statusPayload.state !== "running") return;
 		interrupted = true;
 		const now = Date.now();
-		statusPayload.state = "paused";
 		currentActivityState = undefined;
 		statusPayload.activityState = undefined;
 		statusPayload.lastUpdate = now;
@@ -1683,11 +1724,6 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 			}
 		}
 		writeStatusPayload();
-		appendJsonl(eventsPath, JSON.stringify({
-			type: "subagent.run.paused",
-			ts: now,
-			runId: id,
-		}));
 		activeChildInterrupt?.();
 	};
 	process.on(ASYNC_INTERRUPT_SIGNAL, interruptRunner);
@@ -1705,6 +1741,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 
 	let flatIndex = 0;
 
+	try {
 	for (let stepIndex = 0; stepIndex < steps.length; stepIndex++) {
 		if (interrupted) break;
 		const step = steps[stepIndex];
@@ -1884,6 +1921,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 				const singleResult = await runSingleStep(task, {
 					previousOutput, placeholder, cwd, sessionEnabled,
 					outputs,
+					trees,
 					sessionDir: config.sessionDir ? path.join(config.sessionDir, `dynamic-${stepIndex}-${taskIdx}`) : undefined,
 					artifactsDir, artifactConfig, id,
 					flatIndex: fi, flatStepCount: Math.max(statusPayload.steps.length, 1),
@@ -2022,13 +2060,14 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 
 		if (isParallelGroup(step)) {
 			const group = step;
+			const groupCwd = group.cwd?.includes("{outputs.") ? group.cwd : resolveChildCwd(cwd, group.cwd);
 			const concurrency = group.concurrency ?? MAX_PARALLEL_CONCURRENCY;
 			const failFast = group.failFast ?? false;
 			const groupStartFlatIndex = flatIndex;
 			let aborted = false;
 			let worktreeSetup: WorktreeSetup | undefined;
 			if (group.worktree) {
-				const worktreeTaskCwdConflict = findWorktreeTaskCwdConflict(group.parallel, cwd);
+				const worktreeTaskCwdConflict = findWorktreeTaskCwdConflict(group.parallel, groupCwd);
 				if (worktreeTaskCwdConflict) {
 					const failedAt = Date.now();
 					markParallelGroupSetupFailure({
@@ -2036,7 +2075,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 						results,
 						group,
 						groupStartFlatIndex,
-						setupError: formatWorktreeTaskCwdConflict(worktreeTaskCwdConflict, cwd),
+						setupError: formatWorktreeTaskCwdConflict(worktreeTaskCwdConflict, groupCwd),
 						failedAt,
 						statusPath,
 						eventsPath,
@@ -2048,7 +2087,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 					break;
 				}
 				try {
-					worktreeSetup = createWorktrees(cwd, `${id}-s${stepIndex}`, group.parallel.length, {
+					worktreeSetup = createWorktrees(groupCwd, `${id}-s${stepIndex}`, group.parallel.length, {
 						agents: group.parallel.map((task) => task.agent),
 						setupHook: config.worktreeSetupHook
 							? { hookPath: config.worktreeSetupHook, timeoutMs: config.worktreeSetupHookTimeoutMs }
@@ -2076,7 +2115,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 			}
 
 			try {
-				if (group.worktree) ensureParallelProgressFile(cwd, group);
+				if (group.worktree) ensureParallelProgressFile(groupCwd, group);
 				const groupStartTime = Date.now();
 				markParallelGroupRunning({
 					statusPayload,
@@ -2133,11 +2172,12 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 						const taskSessionDir = config.sessionDir
 							? path.join(config.sessionDir, `parallel-${fi}`)
 							: undefined;
-						const { taskForRun, taskCwd } = prepareParallelTaskRun(task, cwd, worktreeSetup, taskIdx);
+						const { taskForRun, taskCwd } = prepareParallelTaskRun(task, cwd, worktreeSetup, taskIdx, group.cwd);
 
 						const singleResult = await runSingleStep(taskForRun, {
 							previousOutput, placeholder, cwd: taskCwd, sessionEnabled,
 							outputs,
+							trees,
 							sessionDir: taskSessionDir,
 							artifactsDir, artifactConfig, id,
 							flatIndex: fi, flatStepCount: flatSteps.length,
@@ -2247,7 +2287,12 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 						agent: parallelResults[t]!.agent,
 						output: parallelResults[t]!.output,
 						structuredOutput: parallelResults[t]!.structuredOutput,
-					}, stepIndex, patchInfoForDiff(diffs[t]));
+					}, stepIndex, worktreeSetup ? {
+						...patchInfoForDiff(diffs[t]),
+						taskIndex: t,
+						baseCommit: worktreeSetup.baseCommit,
+						repoCwd: worktreeSetup.cwd,
+					} : undefined);
 				}
 				statusPayload.outputs = outputs;
 				if (!interrupted && group.stopOn) {
@@ -2310,6 +2355,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 			const singleResult = await runSingleStep(seqStep, {
 				previousOutput, placeholder, cwd, sessionEnabled,
 				outputs,
+				trees,
 				sessionDir: config.sessionDir ? path.join(config.sessionDir, `parallel-${flatIndex}`) : undefined,
 				artifactsDir, artifactConfig, id,
 				flatIndex, flatStepCount: flatSteps.length,
@@ -2423,6 +2469,18 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 		}
 	}
 
+	} finally {
+		removeTrees(trees.created);
+	}
+
+	if (interrupted) {
+		const pausedAt = Date.now();
+		statusPayload.state = "paused";
+		statusPayload.lastUpdate = pausedAt;
+		writeStatusPayload();
+		appendJsonl(eventsPath, JSON.stringify({ type: "subagent.run.paused", ts: pausedAt, runId: id }));
+	}
+
 	let summary = results.map((r) => `${r.agent}:\n${r.output}`).join("\n\n");
 	let truncated = false;