pi-cohort 5.1.2 → 5.2.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## [5.2.0] - 2026-09-01
+
+### Added
+
+- `runner.log` diagnostics for the detached async runner: captures the
+  runner's stdout/stderr, spawn-time jiti revalidation, and enriched failure
+  messages that append the log's tail; the run dir is also exported to the
+  child as `PI_SUBAGENT_RUN_DIR` and echoed on an `Async dir:` start line.
+- Builtin `monitor` persona: watches an already-started job (async run dir,
+  PID, log, or probe command), reports progress deltas on a cadence, and
+  flags stalls, plus SKILL.md guidance to pair it with long-running async
+  jobs.
+
+## [5.1.3] - 2026-08-18
+
+### Fixed
+
+- Foreground control notices are steered to a turn boundary while the session
+  is streaming instead of splicing into an open tool cycle (which corrupted
+  the session with a duplicated `tool_use_id`); idle delivery still appends
+  without triggering a turn. (#7)
+
+### Changed
+
+- `dir` no longer advertised by the subagent tool schema (follows `runId`,
+  #5) - still accepted at runtime for async status/resume, `id` preferred.
+
 ## [5.1.2] - 2026-08-07
 
 ### Changed

package/README.md

@@ -101,7 +101,7 @@ Full reference: agent/chain authoring in [doc/agents-and-chains.md](doc/agents-a
 | Term | Meaning |
 |---|---|
 | Subagent | A focused child Pi session with one job and (by default) a fresh context. |
-| Agent (persona) | A markdown file with frontmatter defining a specialist: `scout`, `planner`, `worker`, `reviewer`, `context-builder`, `oracle`, `delegate`. Full table: [doc/agents-and-chains.md](doc/agents-and-chains.md#builtin-agents-in-plain-english). |
+| Agent (persona) | A markdown file with frontmatter defining a specialist: `scout`, `planner`, `worker`, `reviewer`, `context-builder`, `oracle`, `delegate`, `monitor`. Full table: [doc/agents-and-chains.md](doc/agents-and-chains.md#builtin-agents-in-plain-english). |
 | Chain | A saved or inline sequence of agent steps, with fan-out/fan-in support. |
 | Fresh vs. forked context | Fresh = clean slate; forked = a real branch of the parent's session history. |
 | Recursion guard | Depth cap on nested delegation so a child can only fan out if explicitly allowed. |
@@ -142,6 +142,10 @@ Optional companions:
 
 See [CHANGELOG.md](CHANGELOG.md) for shipped work in progress.
 
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) - issues follow a Context / Problem / Idea / Acceptance Criteria template; PRs run the [pi-gauntlet](https://github.com/jjuraszek/pi-gauntlet) workflow (one-liners exempt from ceremony, never from keeping docs truthful).
+
 ## Support
 
 If `pi-cohort` is useful, consider [buying me a coffee](https://buymeacoffee.com/jjurasszek).

package/agents/monitor.md

@@ -0,0 +1,26 @@
+---
+name: monitor
+description: Watches a job you already started - not for doing the work. Reports progress deltas on a cadence, flags stalls, exits when the job ends.
+tools: read, bash
+thinking: low
+completionGuard: false
+---
+
+You observe a job someone else runs. Never execute, restart, or modify it.
+
+The task names your target: an absolute async run dir (preferred - read its status.json, tail output logs and runner.log), a PID (POSIX: ps -p <pid>; Windows: tasklist /FI "PID eq <pid>"), a log file (tail), or a probe command. If the target is already terminated at your first check, report that and exit. If it is unreadable, report "cannot observe target: <reason>" and exit - never guess, never loop.
+
+Write your trail to $PI_SUBAGENT_RUN_DIR/trail.md. If that variable is unset, create a directory with mktemp -d and write there. Never write under the workspace.
+
+Loop:
+1. Record your start time. Run the first check immediately, before any sleep.
+2. Each cycle: check the target is alive, collect progress (new log lines, counts, phases, best-effort ETA), and compose a one-line delta vs the previous cycle.
+3. Append the delta with a timestamp to the trail.
+4. If contact_supervisor is available, send the delta with reason "progress_update".
+5. Sleep the cadence interval in chunks of <= 5 minutes, then repeat.
+
+Cadence: every 15 minutes unless the task sets another interval.
+
+Stall: no growth in the watched log and no change in status.json lastUpdate since the previous cycle. Judge stall only by the signals your target has; a signal that does not exist never counts as change. Report it as "no output for <interval>, possible stall". After two consecutive silent cycles, escalate with contact_supervisor reason "need_decision". Never report "still working" without evidence.
+
+Exit: when the target reaches a terminal state, send a final summary and end - the summary is your run result. Stop 24h after your recorded start time even if the target lives. Without contact_supervisor, the trail and final summary are the record; behave identically otherwise.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-cohort",
-  "version": "5.1.2",
+  "version": "5.2.0",
   "description": "Delegate Pi work to focused child agents: code review, scouting, implementation, parallel audits, saved chains, and background jobs.",
   "author": "Jacek Juraszek",
   "license": "MIT",
@@ -36,8 +36,8 @@
   "scripts": {
     "check:agents-core": "node scripts/check-agents-core.mjs",
     "test": "npm run test:unit",
-    "test:unit": "node --experimental-strip-types --test test/unit/*.test.ts",
-    "test:integration": "node --experimental-transform-types --import ./test/support/register-loader.mjs --test test/integration/*.test.ts",
+    "test:unit": "node --test test/unit/*.test.ts",
+    "test:integration": "node --import ./test/support/register-loader.mjs --test test/integration/*.test.ts",
     "test:all": "npm run check:agents-core && npm run test:unit && npm run test:integration"
   },
   "pi": {

package/skills/pi-cohort/SKILL.md

@@ -351,6 +351,19 @@ subagent({ action: "doctor" })
 
 Humans can use `/cohort-doctor` for the same read-only report. It checks runtime paths, discovery counts, async support, current session context, and intercom bridge state.
 
+Long-running job hygiene:
+
+- The job's task must instruct it to emit observable progress as it works (log lines, counts, phase names; best-effort ETA). A silent long job is a defect.
+- Pair the job with a monitor dispatch, giving it the absolute async dir from the `Async dir:` line of the start message:
+
+```typescript
+subagent({ agent: "worker", async: true, task: "<long job - emit progress lines as you work>" })
+  -> Async: worker [R]  Async dir: <D>
+subagent({ agent: "monitor", async: true, task: "Watch async run R at <D>. Report every 15m. Stop when it ends." })
+```
+
+- Live 15m reports require the pi-intercom bridge; without it the monitor's trail and final summary are post-hoc records.
+
 ### Subagent control
 
 Subagent control is the runtime visibility and intervention layer for delegated runs. It is separate from lifecycle status. Lifecycle status says whether a child is `queued`, `running`, `paused`, `complete`, or `failed`. Activity reporting is factual: it tracks the last observed activity time and the current tool when known. It does not pretend to know that a child is truly stuck.

package/src/extension/control-notices.ts

@@ -39,6 +39,7 @@ function deliverControlNotice(input: {
 	pi: Pick<ExtensionAPI, "sendMessage">;
 	visibleControlNotices: Set<string>;
 	details: SubagentControlMessageDetails;
+	isIdle: () => boolean;
 }): void {
 	const childIntercomTarget = controlNoticeTarget(input.details);
 	const key = controlNotificationKey(input.details.event, childIntercomTarget);
@@ -52,7 +53,7 @@ function deliverControlNotice(input: {
 			display: true,
 			details: { ...input.details, childIntercomTarget, noticeText },
 		},
-		{ triggerTurn: input.details.source !== "foreground" },
+		{ triggerTurn: input.details.source !== "foreground" || !input.isIdle() },
 	);
 }
 
@@ -72,8 +73,9 @@ export function handleSubagentControlNotice(input: {
 	foregroundDelayMs?: number;
 }): void {
 	if (!input.details?.event || input.details.event.type === "active_long_running") return;
+	const isIdle = () => input.state.lastUiContext?.isIdle() ?? false;
 	if (input.details.source !== "foreground") {
-		deliverControlNotice(input);
+		deliverControlNotice({ ...input, isIdle });
 		return;
 	}
 
@@ -85,7 +87,7 @@ export function handleSubagentControlNotice(input: {
 	const timer = setTimeout(() => {
 		pending.delete(timerKey);
 		if (!isForegroundNoticeStillActionable(input.state, input.details)) return;
-		deliverControlNotice(input);
+		deliverControlNotice({ ...input, isIdle });
 	}, input.foregroundDelayMs ?? 1000);
 	timer.unref?.();
 	pending.set(timerKey, timer);

package/src/extension/index.ts

@@ -183,10 +183,13 @@ function parseSubagentNotifyContent(content: string): SubagentNotifyDetails | un
 }
 
 class SubagentControlNoticeComponent implements Component {
-	constructor(
-		private readonly details: SubagentControlMessageDetails,
-		private readonly theme: ExtensionContext["ui"]["theme"],
-	) {}
+	private readonly details: SubagentControlMessageDetails;
+	private readonly theme: ExtensionContext["ui"]["theme"];
+
+	constructor(details: SubagentControlMessageDetails, theme: ExtensionContext["ui"]["theme"]) {
+		this.details = details;
+		this.theme = theme;
+	}
 
 	invalidate(): void {}
 

package/src/extension/schemas.ts

@@ -259,9 +259,6 @@ export const SubagentParams = Type.Object({
 	id: Type.Optional(Type.String({
 		description: "Run id/prefix for status/interrupt/resume."
 	})),
-	dir: Type.Optional(Type.String({
-		description: "Async run dir for status/resume."
-	})),
 	index: Type.Optional(Type.Integer({ minimum: 0, description: "Zero-based index for per-child actions." })),
 	message: Type.Optional(Type.String({ description: "Follow-up message for resume." })),
 	// Chain identifier for management (can't reuse 'chain' — that's the execution array)

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

@@ -88,7 +88,20 @@ function resolveJitiCliPath(): string | undefined {
 	return undefined;
 }
 
-const jitiCliPath = resolveJitiCliPath();
+export function createJitiCliResolver(deps: { resolve?: () => string | undefined; exists?: (p: string) => boolean } = {}): () => string | undefined {
+	const resolve = deps.resolve ?? resolveJitiCliPath;
+	const exists = deps.exists ?? ((p: string) => fs.existsSync(p));
+	let cached = resolve();
+	return () => {
+		if (cached && exists(cached)) return cached;
+		cached = resolve();
+		if (cached && exists(cached)) return cached;
+		cached = undefined;
+		return undefined;
+	};
+}
+
+const ensureJitiCliPath = createJitiCliResolver();
 
 interface AsyncExecutionContext {
 	pi: ExtensionAPI;
@@ -172,13 +185,60 @@ export function formatAsyncStartedMessage(headline: string): string {
  * Check if jiti is available for async execution
  */
 export function isAsyncAvailable(): boolean {
-	return jitiCliPath !== undefined;
+	return ensureJitiCliPath() !== undefined;
+}
+
+/**
+ * Spawn a detached process with stderr/stdout captured to <asyncDir>/runner.log.
+ * Falls back to ignored stdio if the log file cannot be opened; the parent always
+ * closes its copy of the fd, on every exit path.
+ */
+export function spawnDetachedWithLog(command: string, args: string[], cwd: string, asyncDir: string, spawnImpl: typeof spawn = spawn): { pid?: number; error?: string } {
+	let fd: number | undefined;
+	try {
+		try {
+			fd = fs.openSync(path.join(asyncDir, "runner.log"), "a");
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			console.error(`[pi-cohort] could not open runner.log in ${asyncDir}: ${message}`);
+		}
+		const proc = spawnImpl(command, args, {
+			cwd,
+			detached: true,
+			stdio: fd === undefined ? "ignore" : ["ignore", fd, fd],
+			windowsHide: true,
+		});
+		proc.on("error", (error) => {
+			console.error(`[pi-cohort] async spawn failed: ${error.message}`);
+		});
+		if (typeof proc.pid !== "number") {
+			return { error: `async runner did not produce a pid for cwd: ${cwd}` };
+		}
+		proc.unref();
+		return { pid: proc.pid };
+	} finally {
+		if (fd !== undefined) {
+			try {
+				fs.closeSync(fd);
+			} catch {
+				// parent-side close failure never misreports a launched child
+			}
+		}
+	}
 }
 
 /**
  * Spawn the async runner process
  */
-function spawnRunner(cfg: object, suffix: string, cwd: string): { pid?: number; error?: string } {
+export function spawnRunner(
+	cfg: object,
+	suffix: string,
+	cwd: string,
+	asyncDir: string,
+	deps: { ensureJiti?: () => string | undefined; spawnImpl?: typeof spawn } = {},
+): { pid?: number; error?: string } {
+	const ensureJiti = deps.ensureJiti ?? ensureJitiCliPath;
+	const jitiCliPath = ensureJiti();
 	if (!jitiCliPath) {
 		return { error: "upstream jiti for TypeScript execution could not be found; ensure package dependencies are installed" };
 	}
@@ -197,20 +257,15 @@ function spawnRunner(cfg: object, suffix: string, cwd: string): { pid?: number;
 	fs.writeFileSync(cfgPath, JSON.stringify(cfg));
 	const runner = path.join(path.dirname(fileURLToPath(import.meta.url)), "subagent-runner.ts");
 
-	const proc = spawn(process.execPath, [jitiCliPath, runner, cfgPath], {
-		cwd,
-		detached: true,
-		stdio: "ignore",
-		windowsHide: true,
-	});
-	proc.on("error", (error) => {
-		console.error(`[pi-cohort] async spawn failed: ${error.message}`);
-	});
-	if (typeof proc.pid !== "number") {
-		return { error: `async runner did not produce a pid for cwd: ${cwd}` };
-	}
-	proc.unref();
-	return { pid: proc.pid };
+	return spawnDetachedWithLog(process.execPath, [jitiCliPath, runner, cfgPath], cwd, asyncDir, deps.spawnImpl ?? spawn);
+}
+
+/**
+ * Build the headline shown at the top of an async start message, e.g.
+ * "Async single: my-agent [run-id]\nAsync dir: /tmp/...".
+ */
+export function asyncStartHeadline(prefix: string, id: string, asyncDir: string): string {
+	return `${prefix} [${id}]\nAsync dir: ${asyncDir}`;
 }
 
 function formatAsyncStartError(mode: SubagentRunMode, message: string): AsyncExecutionResult {
@@ -503,6 +558,7 @@ export function executeAsyncChain(
 			},
 			id,
 			runnerCwd,
+			asyncDir,
 		);
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
@@ -603,7 +659,7 @@ export function executeAsyncChain(
 		.join(" -> ");
 
 	return {
-		content: [{ type: "text", text: formatAsyncStartedMessage(`Async ${resultMode}: ${chainDesc} [${id}]`) }],
+		content: [{ type: "text", text: formatAsyncStartedMessage(asyncStartHeadline(`Async ${resultMode}: ${chainDesc}`, id, asyncDir)) }],
 		details: { mode: resultMode, runId: id, results: [], asyncId: id, asyncDir, workflowGraph },
 	};
 }
@@ -738,6 +794,7 @@ export function executeAsyncSingle(
 			},
 			id,
 			runnerCwd,
+			asyncDir,
 		);
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
@@ -796,7 +853,7 @@ export function executeAsyncSingle(
 	}
 
 	return {
-		content: [{ type: "text", text: formatAsyncStartedMessage(`Async: ${agent} [${id}]`) }],
+		content: [{ type: "text", text: formatAsyncStartedMessage(asyncStartHeadline(`Async: ${agent}`, id, asyncDir)) }],
 		details: { mode: "single", runId: id, results: [], asyncId: id, asyncDir },
 	};
 }

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

@@ -7,7 +7,7 @@ import { readStatus } from "../../shared/utils.ts";
 import { attachRootChildrenToSteps, findNestedRouteForRootId, projectNestedRegistryForRoot } from "../shared/nested-events.ts";
 import { formatNestedRunStatusLines } from "../shared/nested-render.ts";
 import { flatToLogicalStepIndex, normalizeParallelGroups } from "./parallel-groups.ts";
-import { reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.ts";
+import { readRunnerLogTail, reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.ts";
 
 interface AsyncRunStepSummary {
 	index: number;
@@ -64,6 +64,7 @@ export interface AsyncRunSummary {
 	sessionFile?: string;
 	nestedChildren?: NestedRunSummary[];
 	nestedWarnings?: string[];
+	diagnostic?: string;
 }
 
 interface AsyncRunListOptions {
@@ -218,6 +219,29 @@ function sortRuns(runs: AsyncRunSummary[]): AsyncRunSummary[] {
 	});
 }
 
+const PRE_STATUS_CRASH_GRACE_MS = 10_000;
+
+function summarizePreStatusCrash(asyncDir: string, now: number): AsyncRunSummary | undefined {
+	const log = readRunnerLogTail(asyncDir);
+	if (!log.tail) return undefined;
+	let startedAt: number;
+	try {
+		startedAt = fs.statSync(asyncDir).mtimeMs;
+	} catch {
+		return undefined;
+	}
+	if (now - startedAt < PRE_STATUS_CRASH_GRACE_MS) return undefined;
+	return {
+		id: path.basename(asyncDir),
+		asyncDir,
+		state: "failed",
+		mode: "single",
+		startedAt,
+		steps: [],
+		diagnostic: `Runner log tail (${log.path}):\n${log.tail}`,
+	};
+}
+
 export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions = {}): AsyncRunSummary[] {
 	let entries: string[];
 	try {
@@ -237,7 +261,11 @@ export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions
 			? undefined
 			: reconcileAsyncRun(asyncDir, { resultsDir: options.resultsDir, kill: options.kill, now: options.now });
 		const status = (reconciliation?.status ?? readStatus(asyncDir)) as (AsyncStatus & { cwd?: string }) | null;
-		if (!status) continue;
+		if (!status) {
+			const crashed = summarizePreStatusCrash(asyncDir, options.now?.() ?? Date.now());
+			if (crashed && (!allowedStates || allowedStates.has(crashed.state))) runs.push(crashed);
+			continue;
+		}
 		const nestedWarnings: string[] = [];
 		try {
 			const nestedRoute = findNestedRouteForRootId(status.runId || path.basename(asyncDir));
@@ -329,6 +357,7 @@ export function formatAsyncRunList(runs: AsyncRunSummary[], heading = "Active as
 		const outputPath = formatAsyncRunOutputPath(run);
 		if (outputPath) lines.push(`  output: ${shortenPath(outputPath)}`);
 		if (run.sessionFile) lines.push(`  session: ${shortenPath(run.sessionFile)}`);
+		if (run.diagnostic) for (const diagLine of run.diagnostic.split("\n")) lines.push(`  ${diagLine}`);
 		lines.push("");
 	}
 	return lines.join("\n").trimEnd();

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

@@ -10,7 +10,7 @@ import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts
 import { resolveAsyncRunLocation } from "./async-resume.ts";
 import { resolveSubagentRunId } from "./run-id-resolver.ts";
 import { flatToLogicalStepIndex, normalizeParallelGroups } from "./parallel-groups.ts";
-import { reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.ts";
+import { readRunnerLogTail, reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.ts";
 import { attachRootChildrenToSteps, findNestedRouteForRootId, projectNestedRegistryForRoot, type NestedRunResolutionScope } from "../shared/nested-events.ts";
 
 interface RunStatusParams {
@@ -238,6 +238,8 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			}
 			if (fs.existsSync(logPath)) lines.push(`Log: ${logPath}`);
 			if (fs.existsSync(eventsPath)) lines.push(`Events: ${eventsPath}`);
+			const runnerLogPath = path.join(asyncDir, "runner.log");
+			if (fs.existsSync(runnerLogPath)) lines.push(`Runner log: ${runnerLogPath}`);
 
 			return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [] } };
 		}
@@ -264,6 +266,18 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 		}
 	}
 
+	if (asyncDir) {
+		const log = readRunnerLogTail(asyncDir);
+		const text = log.tail
+			? `Status file not found.\nRunner log tail (${log.path}):\n${log.tail}`
+			: `Status file not found.\nRunner log (empty or missing): expected at ${log.path}`;
+		return {
+			content: [{ type: "text", text }],
+			isError: true,
+			details: { mode: "single", results: [] },
+		};
+	}
+
 	return {
 		content: [{ type: "text", text: "Status file not found." }],
 		isError: true,

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

@@ -164,10 +164,35 @@ function buildStartedStatus(asyncDir: string, startedRun: StartedRunMetadata, no
 	};
 }
 
+export function readRunnerLogTail(asyncDir: string, maxBytes = 4096, maxLines = 20): { path: string; tail?: string } {
+	const logPath = path.join(asyncDir, "runner.log");
+	try {
+		const stat = fs.statSync(logPath);
+		if (stat.size === 0) return { path: logPath };
+		const fd = fs.openSync(logPath, "r");
+		try {
+			const length = Math.min(stat.size, maxBytes);
+			const buffer = Buffer.alloc(length);
+			fs.readSync(fd, buffer, 0, length, Math.max(0, stat.size - maxBytes));
+			const lines = buffer.toString("utf-8").split("\n").filter((line) => line.trim() !== "");
+			const tail = lines.slice(-maxLines).join("\n");
+			return tail ? { path: logPath, tail } : { path: logPath };
+		} finally {
+			fs.closeSync(fd);
+		}
+	} catch {
+		return { path: logPath };
+	}
+}
+
 function buildFailedRepair(status: AsyncStatus, asyncDir: string, now: number, reason?: string): { status: AsyncStatus; result: object; message: string } {
 	const runId = status.runId || path.basename(asyncDir);
 	const pid = typeof status.pid === "number" ? status.pid : "unknown";
 	const message = reason ?? `Async runner process ${pid} exited or disappeared before writing a result. Marked run failed by stale-run reconciliation.`;
+	const log = readRunnerLogTail(asyncDir);
+	const enrichedMessage = log.tail
+		? `${message}\nRunner log tail (${log.path}):\n${log.tail}`
+		: `${message}\nRunner log (empty or missing): expected at ${log.path}`;
 	const steps = status.steps?.length ? status.steps : [{ agent: "subagent", status: "running" as const }];
 	const repairedSteps = steps.map((step) => step.status === "running" || step.status === "pending"
 		? {
@@ -177,7 +202,7 @@ function buildFailedRepair(status: AsyncStatus, asyncDir: string, now: number, r
 			endedAt: step.endedAt ?? now,
 			durationMs: step.startedAt !== undefined && step.durationMs === undefined ? Math.max(0, now - step.startedAt) : step.durationMs,
 			exitCode: step.exitCode ?? 1,
-			error: step.error ?? message,
+			error: step.error ?? enrichedMessage,
 		}
 		: step);
 	const repairedStatus: AsyncStatus = {
@@ -191,18 +216,18 @@ function buildFailedRepair(status: AsyncStatus, asyncDir: string, now: number, r
 	const resultAgent = repairedSteps[status.currentStep ?? 0]?.agent ?? repairedSteps[0]?.agent ?? "subagent";
 	return {
 		status: repairedStatus,
-		message,
+		message: enrichedMessage,
 		result: {
 			id: runId,
 			agent: resultAgent,
 			mode: status.mode,
 			success: false,
 			state: "failed",
-			summary: message,
+			summary: enrichedMessage,
 			results: repairedSteps.map((step) => ({
 				agent: step.agent,
-				output: step.status === "complete" || step.status === "completed" ? "" : message,
-				error: step.status === "complete" || step.status === "completed" ? undefined : step.error ?? message,
+				output: step.status === "complete" || step.status === "completed" ? "" : enrichedMessage,
+				error: step.status === "complete" || step.status === "completed" ? undefined : step.error ?? enrichedMessage,
 				success: step.status === "complete" || step.status === "completed",
 				model: step.model,
 				attemptedModels: step.attemptedModels,

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

@@ -44,7 +44,7 @@ import {
 	aggregateParallelOutputs,
 	MAX_PARALLEL_CONCURRENCY,
 } from "../shared/parallel-utils.ts";
-import { buildPiArgs, cleanupTempDir } from "../shared/pi-args.ts";
+import { buildPiArgs, cleanupTempDir, runDirEnv } from "../shared/pi-args.ts";
 import { outputEntryFromAsyncResult, resolveOutputReferences } from "../shared/chain-outputs.ts";
 import { createStructuredOutputRuntime, readStructuredOutput } from "../shared/structured-output.ts";
 import { collectDynamicResults, DynamicFanoutError, materializeDynamicParallelStep, validateDynamicCollection } from "../shared/dynamic-fanout.ts";
@@ -967,6 +967,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 	const overallStartTime = Date.now();
 	const shareEnabled = config.share === true;
 	const asyncDir = config.asyncDir;
+	Object.assign(process.env, runDirEnv(asyncDir));
 	const statusPath = path.join(asyncDir, "status.json");
 	const eventsPath = path.join(asyncDir, "events.jsonl");
 	const logPath = path.join(asyncDir, `subagent-log-${id}.md`);

package/src/runs/shared/pi-args.ts

@@ -13,6 +13,7 @@ const FANOUT_CHILD_EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.
 export const SUBAGENT_CHILD_ENV = "PI_SUBAGENT_CHILD";
 export const SUBAGENT_ORCHESTRATOR_TARGET_ENV = "PI_SUBAGENT_ORCHESTRATOR_TARGET";
 export const SUBAGENT_RUN_ID_ENV = "PI_SUBAGENT_RUN_ID";
+export const SUBAGENT_RUN_DIR_ENV = "PI_SUBAGENT_RUN_DIR";
 export const SUBAGENT_CHILD_AGENT_ENV = "PI_SUBAGENT_CHILD_AGENT";
 export const SUBAGENT_CHILD_INDEX_ENV = "PI_SUBAGENT_CHILD_INDEX";
 export const SUBAGENT_FANOUT_CHILD_ENV = "PI_SUBAGENT_FANOUT_CHILD";
@@ -68,6 +69,10 @@ interface BuildPiArgsResult {
 	tempDir?: string;
 }
 
+export function runDirEnv(asyncDir: string): Record<string, string> {
+	return { [SUBAGENT_RUN_DIR_ENV]: asyncDir };
+}
+
 export function applyThinkingSuffix(model: string | undefined, thinking: string | undefined): string | undefined {
 	if (!model || !thinking || thinking === "off") return model;
 	const colonIdx = model.lastIndexOf(":");