@bastani/atomic 0.9.5-alpha.8 → 0.9.5

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-single.ts

@@ -1,13 +1,12 @@
-import { randomUUID } from "node:crypto";
-import { APP_NAME } from "@bastani/atomic";
-import { ChainClarifyComponent, type ChainClarifyResult } from "./chain-clarify.ts";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { currentModelFullId, resolveModelCandidate } from "../shared/model-fallback.ts";
 import { collectKnownModelProviders, toModelInfo, type ModelInfo } from "../../shared/model-info.ts";
-import { discoverAvailableSkills, normalizeSkillInput } from "../../agents/skills.ts";
+import { normalizeSkillInput } from "../../agents/skills.ts";
+import { injectSingleProgressInstruction, resolveSingleProgress, writeInitialProgressFile } from "../../shared/settings.ts";
 import { recordRun } from "../shared/run-history.ts";
 import { getSingleResultOutput, compactForegroundDetails } from "../../shared/utils.ts";
 import { updateForegroundNestedProjection } from "../shared/nested-events.ts";
-import { resolveStepBehavior } from "../../shared/settings.ts";
 import {
 	INTERCOM_BRIDGE_MARKER,
 	resolveSubagentIntercomTarget,
@@ -29,7 +28,7 @@ import {
 	type SubagentToolResult,
 } from "../../shared/types.ts";
 import type { ExecutionContextData, ResolvedExecutorDeps } from "./subagent-executor-types.ts";
-import { createForegroundControlNotifier, maybeBuildForegroundIntercomReceipt, rememberForegroundRun } from "./subagent-executor-status.ts";
+import { createForegroundControlNotifier, maybeBuildForegroundIntercomReceipt, rememberForegroundRun, replaceForegroundRunChild } from "./subagent-executor-status.ts";
 
 function formatFailedSingleRunOutput(result: SingleResult, displayOutput: string): string {
 	const error = result.error || "Failed";
@@ -44,6 +43,15 @@ function formatFailedSingleRunOutput(result: SingleResult, displayOutput: string
 	return lines.join("\n");
 }
 
+function cleanupTransientProgress(progressDir: string | undefined, artifactsEnabled: boolean): void {
+	if (!progressDir || artifactsEnabled) return;
+	try {
+		fs.rmSync(progressDir, { recursive: true, force: true });
+	} catch {
+		// Scratch cleanup must never replace the child run's result or original error.
+	}
+}
+
 export async function runSinglePath(data: ExecutionContextData, deps: ResolvedExecutorDeps): Promise<SubagentToolResult> {
 	const {
 		params,
@@ -58,7 +66,6 @@ export async function runSinglePath(data: ExecutionContextData, deps: ResolvedEx
 		artifactConfig,
 		artifactsDir,
 		onUpdate,
-		sessionRoot,
 		controlConfig,
 	} = data;
 	const onControlEvent = createForegroundControlNotifier(data, deps);
@@ -78,96 +85,20 @@ export async function runSinglePath(data: ExecutionContextData, deps: ResolvedEx
 	const availableModels: ModelInfo[] = ctx.modelRegistry.getAvailable().map(toModelInfo);
 	const knownModelProviders = collectKnownModelProviders(ctx.modelRegistry);
 	let task = params.task ?? "";
-	let modelOverride: string | undefined = resolveModelCandidate(
+	const modelOverride: string | undefined = resolveModelCandidate(
 		(params.model as string | undefined) ?? agentConfig.model,
 		availableModels,
 		currentProvider,
 	);
-	let skillOverride: string[] | false | undefined = normalizeSkillInput(params.skill);
+	const skillOverride: string[] | false | undefined = normalizeSkillInput(params.skill);
 	const rawOutput = params.output !== undefined ? params.output : agentConfig.output;
-	let effectiveOutput = normalizeSingleOutputOverride(rawOutput, agentConfig.output);
+	const effectiveOutput = normalizeSingleOutputOverride(rawOutput, agentConfig.output);
 	const effectiveOutputMode = params.outputMode ?? "inline";
 	const depthPolicy = resolveSubagentDepthPolicy(ctx, deps.config.maxSubagentDepth);
 	const currentMaxSubagentDepth = depthPolicy.maxSubagentDepth;
 	const workflowStageSubagentGuard = depthPolicy.workflowStageSubagentGuard;
 	const maxSubagentDepth = resolveChildMaxSubagentDepth(currentMaxSubagentDepth, agentConfig.maxSubagentDepth);
-
-	if (params.clarify === true && ctx.hasUI) {
-		const behavior = resolveStepBehavior(agentConfig, { output: effectiveOutput, skills: skillOverride });
-		const availableSkills = discoverAvailableSkills(effectiveCwd);
-
-		const result = await ctx.ui.custom<ChainClarifyResult>(
-			(tui, theme, _kb, done) =>
-				new ChainClarifyComponent(
-					tui, theme,
-					[agentConfig],
-					[task],
-					task,
-					undefined,
-					[behavior],
-					availableModels,
-					currentProvider,
-					availableSkills,
-					done,
-					"single",
-				),
-			{ overlay: true, overlayOptions: { anchor: "center", width: 84, maxHeight: "80%" } },
-		);
-
-		if (!result || !result.confirmed) {
-			return { content: [{ type: "text", text: "Cancelled" }], details: { mode: "single", results: [] } };
-		}
-
-		task = result.templates[0]!;
-		const override = result.behaviorOverrides[0];
-		if (override?.model) modelOverride = override.model;
-		if (override?.output !== undefined) effectiveOutput = normalizeSingleOutputOverride(override.output, agentConfig.output);
-		if (override?.skills !== undefined) skillOverride = override.skills;
-
-		if (result.runInBackground) {
-			if (!deps.runtime.isAsyncAvailable()) {
-				return {
-					content: [{ type: "text", text: `Background mode requires upstream jiti for TypeScript execution but it could not be found. Ensure the ${APP_NAME}-subagents package dependencies are installed.` }],
-					isError: true,
-					details: { mode: "single" as const, results: [] },
-				};
-			}
-			const id = randomUUID();
-			const asyncCtx = {
-				pi: deps.pi,
-				cwd: ctx.cwd,
-				currentSessionId: deps.state.currentSessionId!,
-				currentModelProvider: ctx.model?.provider,
-				currentModel: currentModelFullId(ctx.model),
-			};
-			return deps.runtime.executeAsyncSingle(id, {
-				agent: params.agent!,
-				task: params.context === "fork" ? wrapForkTask(task) : task,
-				agentConfig,
-				ctx: asyncCtx,
-				availableModels,
-				knownModelProviders,
-				cwd: effectiveCwd,
-				maxOutput: params.maxOutput,
-				artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
-				artifactConfig,
-				shareEnabled,
-				sessionRoot,
-				sessionFile: sessionFileForIndex(0),
-				skills: skillOverride === false ? [] : skillOverride,
-				output: effectiveOutput,
-				outputMode: effectiveOutputMode,
-				modelOverride,
-				maxSubagentDepth,
-				workflowStageSubagentGuard,
-				worktreeSetupHook: deps.config.worktreeSetupHook,
-				worktreeSetupHookTimeoutMs: deps.config.worktreeSetupHookTimeoutMs,
-				controlConfig,
-				controlIntercomTarget: data.intercomBridge.active ? data.intercomBridge.orchestratorTarget : undefined,
-				childIntercomTarget: data.intercomBridge.active ? (agent, index) => resolveSubagentIntercomTarget(id, agent, index) : undefined,
-			});
-		}
-	}
+	const progress = resolveSingleProgress(agentConfig, params.progress, task);
 
 	if (params.context === "fork") {
 		task = wrapForkTask(task);
@@ -178,6 +109,13 @@ export async function runSinglePath(data: ExecutionContextData, deps: ResolvedEx
 	if (validationError) {
 		return { content: [{ type: "text", text: validationError }], isError: true, details: { mode: "single", results: [] } };
 	}
+	// Single-agent progress is isolated by run so the injected contract cannot
+	// overwrite a project's own progress.md or collide with another child.
+	const progressDir = progress ? path.join(artifactsDir, "progress", runId) : undefined;
+	if (progressDir) {
+		writeInitialProgressFile(progressDir);
+		task = injectSingleProgressInstruction(task, progressDir);
+	}
 	task = injectSingleOutputInstruction(task, outputPath);
 
 	let effectiveSkills: string[] | undefined;
@@ -222,37 +160,49 @@ export async function runSinglePath(data: ExecutionContextData, deps: ResolvedEx
 		}
 		: undefined;
 
-	const r = await deps.runtime.runSync(ctx.cwd, agents, params.agent!, task, {
-		cwd: effectiveCwd,
-		signal,
-		interruptSignal: interruptController.signal,
-		allowIntercomDetach: agentConfig.systemPrompt?.includes(INTERCOM_BRIDGE_MARKER) === true,
-		intercomEvents: deps.pi.events,
-		runId,
-		sessionDir: sessionDirForIndex(0),
-		sessionFile: sessionFileForIndex(0),
-		share: shareEnabled,
-		artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
-		artifactConfig,
-		maxOutput: params.maxOutput,
-		outputPath,
-		outputMode: effectiveOutputMode,
-		maxSubagentDepth,
-		workflowStageSubagentGuard,
-		onUpdate: forwardSingleUpdate,
-		controlConfig,
-		onControlEvent,
-		intercomSessionName: childIntercomTarget,
-		orchestratorIntercomTarget: data.intercomBridge.active ? data.intercomBridge.orchestratorTarget : undefined,
-		nestedRoute: foregroundControl?.nestedRoute,
-		index: 0,
-		modelOverride,
-		availableModels,
-		knownModelProviders,
-		preferredModelProvider: currentProvider,
-		currentModel: currentModelFullId(ctx.model),
-		skills: effectiveSkills,
-	});
+	let r: SingleResult;
+	try {
+		r = await deps.runtime.runSync(ctx.cwd, agents, params.agent!, task, {
+			cwd: effectiveCwd,
+			signal,
+			interruptSignal: interruptController.signal,
+			allowIntercomDetach: agentConfig.systemPrompt?.includes(INTERCOM_BRIDGE_MARKER) === true,
+			intercomEvents: deps.pi.events,
+			runId,
+			sessionDir: sessionDirForIndex(0),
+			sessionFile: sessionFileForIndex(0),
+			share: shareEnabled,
+			artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
+			artifactConfig,
+			maxOutput: params.maxOutput,
+			outputPath,
+			outputMode: effectiveOutputMode,
+			maxSubagentDepth,
+			workflowStageSubagentGuard,
+			onUpdate: forwardSingleUpdate,
+			controlConfig,
+			onControlEvent,
+			intercomSessionName: childIntercomTarget,
+			orchestratorIntercomTarget: data.intercomBridge.active ? data.intercomBridge.orchestratorTarget : undefined,
+			nestedRoute: foregroundControl?.nestedRoute,
+			onDetachedExit: (result) => {
+				cleanupTransientProgress(progressDir, artifactConfig.enabled);
+				if (result) replaceForegroundRunChild(deps.state, runId, 0, result);
+			},
+			index: 0,
+			modelOverride,
+			availableModels,
+			knownModelProviders,
+			preferredModelProvider: currentProvider,
+			currentModel: currentModelFullId(ctx.model),
+			skills: effectiveSkills,
+		});
+	} catch (error) {
+		cleanupTransientProgress(progressDir, artifactConfig.enabled);
+		throw error;
+	}
+	// Detached children still own this storage until their process closes.
+	if (!r.detached) cleanupTransientProgress(progressDir, artifactConfig.enabled);
 	if (foregroundControl?.currentIndex === 0) {
 		foregroundControl.interrupt = undefined;
 		foregroundControl.currentActivityState = r.progress?.activityState;

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-status.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI } from "@bastani/atomic";
-import { compactForegroundDetails, getSingleResultOutput } from "../../shared/utils.ts";
+import { compactForegroundDetails, compactForegroundResult, getSingleResultOutput } from "../../shared/utils.ts";
 import {
 	attachNestedChildrenToResultChildren,
 	buildSubagentResultIntercomPayload,
@@ -77,6 +77,39 @@ export function foregroundStatusResult(control: ForegroundControl): SubagentTool
 	return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "management", results: [] } };
 }
 
+export function retainedForegroundStatusResult(state: SubagentState, runId: string): SubagentToolResult | undefined {
+	const run = state.foregroundRuns?.get(runId);
+	if (!run) return undefined;
+	const statuses = run.children.map((child) => child.status);
+	const stateLabel = statuses.includes("detached") ? "detached"
+		: statuses.includes("failed") ? "failed"
+		: statuses.includes("paused") ? "paused"
+		: statuses.every((status) => status === "completed") ? "completed"
+		: statuses[0] ?? "unknown";
+	const lines = [`Run: ${run.runId}`, `State: ${stateLabel}`, `Mode: ${run.mode}`];
+	for (const child of run.children) {
+		lines.push(`Child ${child.index + 1}: ${child.agent} (${child.status})`);
+		const output = child.result ? getSingleResultOutput(child.result) : "";
+		if (output) lines.push(output);
+		else if (child.result?.error) lines.push(child.result.error);
+	}
+	return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "management", results: [] } };
+}
+
+const earlyDetachedResults = new WeakMap<SubagentState, Map<string, Map<number, SingleResult>>>();
+const MAX_EARLY_DETACHED_RUNS = 50;
+const MAX_EARLY_DETACHED_CHILDREN_PER_RUN = 50;
+
+
+function takeEarlyDetachedResult(state: SubagentState, runId: string, index: number): SingleResult | undefined {
+	const byRun = earlyDetachedResults.get(state);
+	const byIndex = byRun?.get(runId);
+	const result = byIndex?.get(index);
+	byIndex?.delete(index);
+	if (byIndex?.size === 0) byRun?.delete(runId);
+	return result;
+}
+
 export function rememberForegroundRun(state: SubagentState, input: { runId: string; mode: "single" | "parallel" | "chain"; cwd: string; results: SingleResult[] }): void {
 	state.foregroundRuns ??= new Map();
 	state.foregroundRuns.set(input.runId, {
@@ -84,12 +117,16 @@ export function rememberForegroundRun(state: SubagentState, input: { runId: stri
 		mode: input.mode,
 		cwd: input.cwd,
 		updatedAt: Date.now(),
-		children: input.results.map((result, index) => ({
-			agent: result.agent,
-			index,
-			status: resolveSubagentResultStatus({ exitCode: result.exitCode, interrupted: result.interrupted, detached: result.detached }),
-			...(result.sessionFile ? { sessionFile: result.sessionFile } : {}),
-		})),
+		children: input.results.map((originalResult, index) => {
+			const result = takeEarlyDetachedResult(state, input.runId, index) ?? originalResult;
+			return {
+				agent: result.agent,
+				index,
+				status: resolveSubagentResultStatus({ exitCode: result.exitCode, interrupted: result.interrupted, detached: result.detached }),
+				...(result.sessionFile ? { sessionFile: result.sessionFile } : {}),
+				result,
+			};
+		}),
 	});
 	while (state.foregroundRuns.size > 50) {
 		const oldest = [...state.foregroundRuns.values()].sort((left, right) => left.updatedAt - right.updatedAt)[0];
@@ -98,6 +135,41 @@ export function rememberForegroundRun(state: SubagentState, input: { runId: stri
 	}
 }
 
+export function replaceForegroundRunChild(state: SubagentState, runId: string, index: number, result: SingleResult): void {
+	const retainedResult = compactForegroundResult(result);
+	const run = state.foregroundRuns?.get(runId);
+	if (!run) {
+		let byRun = earlyDetachedResults.get(state);
+		if (!byRun) {
+			byRun = new Map();
+			earlyDetachedResults.set(state, byRun);
+		}
+		let byIndex = byRun.get(runId);
+		if (!byIndex) {
+			byIndex = new Map();
+			byRun.set(runId, byIndex);
+		}
+		byIndex.set(index, retainedResult);
+		while (byIndex.size > MAX_EARLY_DETACHED_CHILDREN_PER_RUN) {
+			const oldestIndex = byIndex.keys().next().value;
+			if (oldestIndex === undefined) break;
+			byIndex.delete(oldestIndex);
+		}
+		while (byRun.size > MAX_EARLY_DETACHED_RUNS) {
+			const oldestRun = byRun.keys().next().value;
+			if (oldestRun === undefined) break;
+			byRun.delete(oldestRun);
+		}
+		return;
+	}
+	const child = run.children.find((entry) => entry.index === index);
+	if (!child || child.status !== "detached") return;
+	child.status = resolveSubagentResultStatus({ exitCode: retainedResult.exitCode, interrupted: retainedResult.interrupted, detached: retainedResult.detached });
+	child.result = retainedResult;
+	if (retainedResult.sessionFile) child.sessionFile = retainedResult.sessionFile;
+	run.updatedAt = Date.now();
+}
+
 export function emitControlNotification(input: {
 	pi: ExtensionAPI;
 	controlConfig: ExecutionContextData["controlConfig"];

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-types.ts

@@ -37,7 +37,6 @@ export interface SubagentParamsLike {
 	worktree?: boolean;
 	context?: "fresh" | "fork";
 	async?: boolean;
-	clarify?: boolean;
 	share?: boolean;
 	control?: ControlConfig;
 	sessionDir?: string;
@@ -49,6 +48,8 @@ export interface SubagentParamsLike {
 	skill?: string | string[] | boolean;
 	output?: string | boolean;
 	outputMode?: "inline" | "file-only";
+	reads?: string[] | false;
+	progress?: boolean;
 	agentScope?: string;
 	chainDir?: string;
 }
@@ -92,7 +93,6 @@ export interface ExecutionContextData {
 	sessionFileForIndex: (idx?: number) => string | undefined;
 	artifactConfig: ArtifactConfig;
 	artifactsDir: string;
-	backgroundRequestedWhileClarifying: boolean;
 	effectiveAsync: boolean;
 	controlConfig: ResolvedControlConfig;
 	intercomBridge: IntercomBridgeState;

package/dist/builtin/subagents/src/runs/foreground/subagent-executor.ts

@@ -26,6 +26,7 @@ import { runSinglePath } from "./subagent-executor-single.ts";
 import {
 	foregroundStatusResult,
 	getForegroundControl,
+	retainedForegroundStatusResult,
 } from "./subagent-executor-status.ts";
 import type {
 	ExecutorDeps,
@@ -91,6 +92,8 @@ async function handleManagementRequest(input: {
 				if (resolved?.kind === "foreground") {
 					const foreground = getForegroundControl(deps.state, resolved.id);
 					if (foreground) return foregroundStatusResult(foreground);
+					const retained = retainedForegroundStatusResult(deps.state, resolved.id);
+					if (retained) return retained;
 				}
 			} catch (error) {
 				const message = error instanceof Error ? error.message : String(error);

package/dist/builtin/subagents/src/runs/shared/pi-args.ts

@@ -14,8 +14,8 @@ import { resolveMcpDirectToolNames } from "./mcp-direct-tool-allowlist.ts";
 import { STRUCTURED_OUTPUT_CAPTURE_ENV, STRUCTURED_OUTPUT_SCHEMA_ENV } from "./structured-output.ts";
 import type { JsonSchemaObject } from "../../shared/types.ts";
 import { MAX_SUBAGENT_NESTING_DEPTH } from "../../shared/types-runtime.ts";
+import { THINKING_LEVELS } from "../../shared/model-info.ts";
 
-const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
 const TASK_ARG_LIMIT = 8000;
 export const SUBAGENT_PARENT_MAX_DEPTH = MAX_SUBAGENT_NESTING_DEPTH;
 export const PROMPT_RUNTIME_EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "subagent-prompt-runtime.ts");
@@ -88,7 +88,7 @@ interface BuildPiArgsResult {
 export function applyThinkingSuffix(model: string | undefined, thinking: string | undefined): string | undefined {
 	if (!model || !thinking || thinking === "off") return model;
 	const colonIdx = model.lastIndexOf(":");
-	if (colonIdx !== -1 && THINKING_LEVELS.includes(model.substring(colonIdx + 1))) return model;
+	if (colonIdx !== -1 && THINKING_LEVELS.some((level) => level === model.substring(colonIdx + 1))) return model;
 	return `${model}:${thinking}`;
 }
 

package/dist/builtin/subagents/src/runs/shared/pi-spawn.ts

@@ -42,30 +42,73 @@ export interface PiSpawnDeps {
 	resolvePackageJson?: () => string;
 	resolvePackageEntry?: () => string;
 	piPackageRoot?: string;
+	statSync?: (filePath: string) => fs.Stats;
 }
 
-interface PiSpawnCommand {
+export type PiSpawnCwdValidationResult = { ok: true } | { ok: false; error: string };
+
+export function validatePiSpawnCwd(cwd: string, deps: PiSpawnDeps = {}): PiSpawnCwdValidationResult {
+	const statSync = deps.statSync ?? fs.statSync;
+	try {
+		const cwdStats = statSync(cwd);
+		if (!cwdStats.isDirectory()) return { ok: false, error: `cwd is not a directory: ${cwd}` };
+		return { ok: true };
+	} catch (error) {
+		const fsError = error as NodeJS.ErrnoException;
+		if (fsError.code === "ENOENT") return { ok: false, error: `cwd does not exist: ${cwd}` };
+		if (fsError.code === "ENOTDIR") return { ok: false, error: `cwd path contains a non-directory component: ${cwd}` };
+		const details = fsError.message ? ` (${fsError.message})` : "";
+		return { ok: false, error: `cwd is not accessible: ${cwd}${details}` };
+	}
+}
+
+export function formatPiSpawnError(error: Error, spawnSpec: PiSpawnCommand, cwd: string): string {
+	const spawnError = error as NodeJS.ErrnoException;
+	const message = error.message || String(error);
+	if (spawnError.code === "ENOENT") {
+		return `failed to spawn subagent runtime '${spawnSpec.command}' from cwd '${cwd}': runtime executable was not found or could not be launched (${message})`;
+	}
+	return `failed to spawn subagent runtime '${spawnSpec.command}' from cwd '${cwd}': ${message}`;
+}
+
+export interface PiSpawnCommand {
 	command: string;
 	args: string[];
 }
 
-function isRunnableNodeScript(filePath: string, existsSync: (filePath: string) => boolean): boolean {
+function isGenericBunRuntime(execPath: string, platform: NodeJS.Platform): boolean {
+	const pathImpl = platform === "win32" ? path.win32 : path;
+	const executableName = pathImpl.basename(execPath).toLowerCase();
+	return executableName === "bun" || executableName === "bun.exe";
+}
+
+function isRunnableCliScript(
+	filePath: string,
+	execPath: string,
+	platform: NodeJS.Platform,
+	existsSync: (filePath: string) => boolean,
+): boolean {
 	if (!existsSync(filePath)) return false;
-	return /\.(?:mjs|cjs|js)$/i.test(filePath);
+	if (/\.(?:mjs|cjs|js)$/i.test(filePath)) return true;
+	return /\.ts$/i.test(filePath) && isGenericBunRuntime(execPath, platform);
 }
 
-function normalizePath(filePath: string): string {
-	return path.isAbsolute(filePath) ? filePath : path.resolve(filePath);
+function normalizePath(filePath: string, platform: NodeJS.Platform): string {
+	const pathImpl = platform === "win32" ? path.win32 : path;
+	return pathImpl.isAbsolute(filePath) ? filePath : pathImpl.resolve(filePath);
 }
 
 export function resolvePiCliScript(deps: PiSpawnDeps = {}): string | undefined {
 	const existsSync = deps.existsSync ?? fs.existsSync;
 	const readFileSync = deps.readFileSync ?? ((filePath, encoding) => fs.readFileSync(filePath, encoding));
-	const argv1 = deps.argv1 ?? process.argv[1];
+	const platform = deps.platform ?? process.platform;
+	const execPath = deps.execPath ?? process.execPath;
+	const argv1 = Object.hasOwn(deps, "argv1") ? deps.argv1 : process.argv[1];
+	const pathImpl = platform === "win32" ? path.win32 : path;
 
 	if (argv1) {
-		const argvPath = normalizePath(argv1);
-		if (isRunnableNodeScript(argvPath, existsSync)) {
+		const argvPath = normalizePath(argv1, platform);
+		if (isRunnableCliScript(argvPath, execPath, platform, existsSync)) {
 			return argvPath;
 		}
 	}
@@ -73,12 +116,12 @@ export function resolvePiCliScript(deps: PiSpawnDeps = {}): string | undefined {
 	try {
 		const resolvePackageJson = deps.resolvePackageJson ?? (() => {
 			const root = deps.piPackageRoot ?? resolvePiPackageRoot();
-			if (root) return path.join(root, "package.json");
+			if (root) return pathImpl.join(root, "package.json");
 			const packageRoot = deps.resolvePackageEntry
 				? findPiPackageRootFromEntry(deps.resolvePackageEntry())
 				: resolveInstalledPiPackageRoot();
 			if (!packageRoot) throw new Error(`Could not resolve ${CODING_AGENT_PACKAGE} package root`);
-			return path.join(packageRoot, "package.json");
+			return pathImpl.join(packageRoot, "package.json");
 		});
 		const packageJsonPath = resolvePackageJson();
 		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8")) as {
@@ -89,8 +132,8 @@ export function resolvePiCliScript(deps: PiSpawnDeps = {}): string | undefined {
 			? binField
 			: binField?.[APP_NAME] ?? binField?.pi ?? Object.values(binField ?? {})[0];
 		if (!binPath) return undefined;
-		const candidate = path.resolve(path.dirname(packageJsonPath), binPath);
-		if (isRunnableNodeScript(candidate, existsSync)) {
+		const candidate = pathImpl.resolve(pathImpl.dirname(packageJsonPath), binPath);
+		if (isRunnableCliScript(candidate, execPath, platform, existsSync)) {
 			return candidate;
 		}
 	} catch {

package/dist/builtin/subagents/src/shared/artifacts.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getAgentConfigPaths } from "@bastani/atomic";
+import { appendToActiveEventWriter } from "./event-jsonl-writer.ts";
 import { TEMP_ARTIFACTS_DIR, type ArtifactPaths } from "./types.ts";
 const CLEANUP_MARKER_FILE = ".last-cleanup";
 
@@ -37,7 +38,26 @@ export function writeMetadata(filePath: string, metadata: object): void {
 }
 
 export function appendJsonl(filePath: string, line: string): void {
-	fs.appendFileSync(filePath, `${line}\n`);
+	if (!appendToActiveEventWriter(filePath, line)) fs.appendFileSync(filePath, `${line}\n`);
+}
+
+function cleanupOldArtifactEntry(entryPath: string, cutoff: number): void {
+	try {
+		const stat = fs.lstatSync(entryPath);
+		if (stat.isDirectory()) {
+			for (const child of fs.readdirSync(entryPath)) {
+				cleanupOldArtifactEntry(path.join(entryPath, child), cutoff);
+			}
+			if (fs.readdirSync(entryPath).length === 0 && stat.mtimeMs < cutoff) {
+				fs.rmSync(entryPath, { recursive: true, force: true });
+			}
+			return;
+		}
+		if (stat.mtimeMs < cutoff) fs.unlinkSync(entryPath);
+	} catch {
+		// Artifact cleanup is best-effort housekeeping. Skip entries that disappear
+		// or become unreadable while scanning so one bad entry does not block the rest.
+	}
 }
 
 export function cleanupOldArtifacts(dir: string, maxAgeDays: number): void {
@@ -56,16 +76,7 @@ export function cleanupOldArtifacts(dir: string, maxAgeDays: number): void {
 
 	for (const file of fs.readdirSync(dir)) {
 		if (file === CLEANUP_MARKER_FILE) continue;
-		const filePath = path.join(dir, file);
-		try {
-			const stat = fs.statSync(filePath);
-			if (stat.mtimeMs < cutoff) {
-				fs.unlinkSync(filePath);
-			}
-		} catch {
-			// Artifact cleanup is best-effort housekeeping. Skip files that disappear
-			// or become unreadable while scanning so one bad entry does not block the rest.
-		}
+		cleanupOldArtifactEntry(path.join(dir, file), cutoff);
 	}
 
 	fs.writeFileSync(markerPath, String(now));