pi-subagents 0.8.2 → 0.8.3

package/schemas.ts

@@ -11,6 +11,7 @@ export const TaskItem = Type.Object({
 	agent: Type.String(), 
 	task: Type.String(), 
 	cwd: Type.Optional(Type.String()),
+	model: Type.Optional(Type.String({ description: "Override model for this task (e.g. 'google/gemini-3-pro')" })),
 	skill: Type.Optional(SkillOverride),
 });
 
@@ -71,13 +72,13 @@ export const SubagentParams = Type.Object({
 	})),
 	// Agent/chain configuration for create/update (nested to avoid conflicts with execution fields)
 	config: Type.Optional(Type.Any({
-		description: "Agent or chain config for create/update. Agent: name, description, scope ('user'|'project', default 'user'), systemPrompt, model, tools (comma-separated), skills (comma-separated), thinking, output, reads, progress. Chain: name, description, scope, steps (array of {agent, task?, output?, reads?, model?, skills?, progress?}). Presence of 'steps' creates a chain instead of an agent."
+		description: "Agent or chain config for create/update. Agent: name, description, scope ('user'|'project', default 'user'), systemPrompt, model, tools (comma-separated), extensions (comma-separated), skills (comma-separated), thinking, output, reads, progress. Chain: name, description, scope, steps (array of {agent, task?, output?, reads?, model?, skills?, progress?}). Presence of 'steps' creates a chain instead of an agent."
 	})),
 	tasks: Type.Optional(Type.Array(TaskItem, { description: "PARALLEL mode: [{agent, task}, ...]" })),
 	chain: Type.Optional(Type.Array(ChainItem, { description: "CHAIN mode: sequential pipeline where each step's response becomes {previous} for the next. Use {task}, {previous}, {chain_dir} in task templates." })),
-	chainDir: Type.Optional(Type.String({ description: "Persistent directory for chain artifacts. Default: /tmp/pi-chain-runs/ (auto-cleaned after 24h)" })),
+	chainDir: Type.Optional(Type.String({ description: "Persistent directory for chain artifacts. Default: <tmpdir>/pi-chain-runs/ (auto-cleaned after 24h)" })),
 	async: Type.Optional(Type.Boolean({ description: "Run in background (default: false, or per config)" })),
-	agentScope: Type.Optional(Type.String({ description: "Agent discovery scope: 'user', 'project', or 'both' (default: 'user')" })),
+	agentScope: Type.Optional(Type.String({ description: "Agent discovery scope: 'user', 'project', or 'both' (default: 'both'; project wins on name collisions)" })),
 	cwd: Type.Optional(Type.String()),
 	maxOutput: MaxOutputSchema,
 	artifacts: Type.Optional(Type.Boolean({ description: "Write debug artifacts (default: true)" })),
@@ -89,7 +90,7 @@ export const SubagentParams = Type.Object({
 	// Clarification TUI
 	clarify: Type.Optional(Type.Boolean({ description: "Show TUI to preview/edit before execution (default: true for chains, false for single/parallel). Implies sync mode." })),
 	// Solo agent overrides
-	output: Type.Optional(Type.Any({ description: "Override output file for single agent (string), or false to disable (uses agent default if omitted)" })),
+	output: Type.Optional(Type.Any({ description: "Override output file for single agent (string), or false to disable (uses agent default if omitted). Absolute paths are used as-is; relative paths resolve against cwd." })),
 	skill: Type.Optional(SkillOverride),
 	model: Type.Optional(Type.String({ description: "Override model for single agent (e.g. 'anthropic/claude-sonnet-4')" })),
 });

package/settings.ts

@@ -3,11 +3,12 @@
  */
 
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentConfig } from "./agents.js";
 import { normalizeSkillInput } from "./skills.js";
 
-const CHAIN_RUNS_DIR = "/tmp/pi-chain-runs";
+const CHAIN_RUNS_DIR = path.join(os.tmpdir(), "pi-chain-runs");
 const CHAIN_DIR_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
 
 // =============================================================================
@@ -358,6 +359,8 @@ export interface ParallelTaskResult {
 	output: string;
 	exitCode: number;
 	error?: string;
+	outputTargetPath?: string;
+	outputTargetExists?: boolean;
 }
 
 /**
@@ -368,7 +371,20 @@ export function aggregateParallelOutputs(results: ParallelTaskResult[]): string
 	return results
 		.map((r, i) => {
 			const header = `=== Parallel Task ${i + 1} (${r.agent}) ===`;
-			return `${header}\n${r.output}`;
+			const hasTextOutput = Boolean(r.output?.trim());
+			const status = r.exitCode !== 0
+				? `⚠️ FAILED (exit code ${r.exitCode})${r.error ? `: ${r.error}` : ""}`
+				: r.error
+					? `⚠️ WARNING: ${r.error}`
+					: !hasTextOutput && r.outputTargetPath && r.outputTargetExists === false
+						? `⚠️ EMPTY OUTPUT (expected output file missing: ${r.outputTargetPath})`
+						: !hasTextOutput && !r.outputTargetPath
+							? "⚠️ EMPTY OUTPUT (no textual response returned)"
+							: "";
+			const body = status
+				? (hasTextOutput ? `${status}\n${r.output}` : status)
+				: r.output;
+			return `${header}\n${body}`;
 		})
 		.join("\n\n");
 }

package/single-output.ts

@@ -0,0 +1,55 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export function resolveSingleOutputPath(
+	output: string | false | undefined,
+	runtimeCwd: string,
+	requestedCwd?: string,
+): string | undefined {
+	if (typeof output !== "string" || !output) return undefined;
+	if (path.isAbsolute(output)) return output;
+	const baseCwd = requestedCwd
+		? (path.isAbsolute(requestedCwd) ? requestedCwd : path.resolve(runtimeCwd, requestedCwd))
+		: runtimeCwd;
+	return path.resolve(baseCwd, output);
+}
+
+export function injectSingleOutputInstruction(task: string, outputPath: string | undefined): string {
+	if (!outputPath) return task;
+	return `${task}\n\n---\n**Output:** Write your findings to: ${outputPath}`;
+}
+
+export function persistSingleOutput(
+	outputPath: string | undefined,
+	fullOutput: string,
+): { savedPath?: string; error?: string } {
+	if (!outputPath) return {};
+	try {
+		fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+		fs.writeFileSync(outputPath, fullOutput, "utf-8");
+		return { savedPath: outputPath };
+	} catch (err) {
+		return { error: err instanceof Error ? err.message : String(err) };
+	}
+}
+
+export function finalizeSingleOutput(params: {
+	fullOutput: string;
+	truncatedOutput?: string;
+	outputPath?: string;
+	exitCode: number;
+}): { displayOutput: string; savedPath?: string; saveError?: string } {
+	let displayOutput = params.truncatedOutput || params.fullOutput;
+	if (params.outputPath && params.exitCode === 0) {
+		const save = persistSingleOutput(params.outputPath, params.fullOutput);
+		if (save.savedPath) {
+			displayOutput += `\n\n📄 Output saved to: ${save.savedPath}`;
+			return { displayOutput, savedPath: save.savedPath };
+		}
+		if (save.error) {
+			displayOutput += `\n\n⚠️ Failed to save output to: ${params.outputPath}\n${save.error}`;
+			return { displayOutput, saveError: save.error };
+		}
+	}
+	return { displayOutput };
+}

package/skills.ts

@@ -5,12 +5,24 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { loadSkills, type Skill } from "@mariozechner/pi-coding-agent";
+
+export type SkillSource =
+	| "project"
+	| "user"
+	| "project-package"
+	| "user-package"
+	| "project-settings"
+	| "user-settings"
+	| "extension"
+	| "builtin"
+	| "unknown";
 
 export interface ResolvedSkill {
 	name: string;
 	path: string;
 	content: string;
-	source: "project" | "user";
+	source: SkillSource;
 }
 
 interface SkillCacheEntry {
@@ -18,9 +30,35 @@ interface SkillCacheEntry {
 	skill: ResolvedSkill;
 }
 
+interface CachedSkillEntry {
+	name: string;
+	filePath: string;
+	source: SkillSource;
+	description?: string;
+	order: number;
+}
+
 const skillCache = new Map<string, SkillCacheEntry>();
 const MAX_CACHE_SIZE = 50;
 
+let loadSkillsCache: { cwd: string; skills: CachedSkillEntry[]; timestamp: number } | null = null;
+const LOAD_SKILLS_CACHE_TTL_MS = 5000;
+
+const CONFIG_DIR = ".pi";
+const AGENT_DIR = path.join(os.homedir(), ".pi", "agent");
+
+const SOURCE_PRIORITY: Record<SkillSource, number> = {
+	project: 700,
+	"project-settings": 650,
+	"project-package": 600,
+	user: 300,
+	"user-settings": 250,
+	"user-package": 200,
+	extension: 150,
+	builtin: 100,
+	unknown: 0,
+};
+
 function stripSkillFrontmatter(content: string): string {
 	const normalized = content.replace(/\r\n/g, "\n");
 	if (!normalized.startsWith("---")) return normalized;
@@ -31,27 +69,187 @@ function stripSkillFrontmatter(content: string): string {
 	return normalized.slice(endIndex + 4).trim();
 }
 
-export function resolveSkillPath(
-	skillName: string,
-	cwd: string,
-): { path: string; source: "project" | "user" } | undefined {
-	const projectPath = path.resolve(cwd, ".pi", "skills", skillName, "SKILL.md");
-	if (fs.existsSync(projectPath)) {
-		return { path: projectPath, source: "project" };
+function isWithinPath(filePath: string, dir: string): boolean {
+	const relative = path.relative(dir, filePath);
+	return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function getPackageSkillPaths(packageRoot: string): string[] {
+	const pkgJsonPath = path.join(packageRoot, "package.json");
+	try {
+		const content = fs.readFileSync(pkgJsonPath, "utf-8");
+		const pkg = JSON.parse(content);
+		const piSkills = pkg?.pi?.skills;
+		if (!Array.isArray(piSkills)) return [];
+		return piSkills
+			.filter((s: unknown) => typeof s === "string")
+			.map((s: string) => path.resolve(packageRoot, s));
+	} catch {
+		return [];
 	}
+}
+
+function collectPackageSkillPaths(cwd: string): string[] {
+	const dirs = [
+		path.join(cwd, CONFIG_DIR, "npm", "node_modules"),
+		path.join(AGENT_DIR, "npm", "node_modules"),
+	];
+	const results: string[] = [];
 
-	const userPath = path.join(os.homedir(), ".pi", "agent", "skills", skillName, "SKILL.md");
-	if (fs.existsSync(userPath)) {
-		return { path: userPath, source: "user" };
+	for (const dir of dirs) {
+		if (!fs.existsSync(dir)) continue;
+		let entries: fs.Dirent[];
+		try {
+			entries = fs.readdirSync(dir, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+
+		for (const entry of entries) {
+			if (entry.name.startsWith(".")) continue;
+			if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+
+			if (entry.name.startsWith("@")) {
+				const scopeDir = path.join(dir, entry.name);
+				let scopeEntries: fs.Dirent[];
+				try {
+					scopeEntries = fs.readdirSync(scopeDir, { withFileTypes: true });
+				} catch {
+					continue;
+				}
+				for (const scopeEntry of scopeEntries) {
+					if (scopeEntry.name.startsWith(".")) continue;
+					if (!scopeEntry.isDirectory() && !scopeEntry.isSymbolicLink()) continue;
+					const pkgRoot = path.join(scopeDir, scopeEntry.name);
+					results.push(...getPackageSkillPaths(pkgRoot));
+				}
+				continue;
+			}
+
+			const pkgRoot = path.join(dir, entry.name);
+			results.push(...getPackageSkillPaths(pkgRoot));
+		}
 	}
 
-	return undefined;
+	return results;
+}
+
+function collectSettingsSkillPaths(cwd: string): string[] {
+	const results: string[] = [];
+	const settingsFiles = [
+		{ file: path.join(cwd, CONFIG_DIR, "settings.json"), base: path.join(cwd, CONFIG_DIR) },
+		{ file: path.join(AGENT_DIR, "settings.json"), base: AGENT_DIR },
+	];
+
+	for (const { file, base } of settingsFiles) {
+		try {
+			const content = fs.readFileSync(file, "utf-8");
+			const settings = JSON.parse(content);
+			const skills = settings?.skills;
+			if (!Array.isArray(skills)) continue;
+			for (const entry of skills) {
+				if (typeof entry !== "string") continue;
+				let resolved = entry;
+				if (resolved.startsWith("~/")) {
+					resolved = path.join(os.homedir(), resolved.slice(2));
+				} else if (!path.isAbsolute(resolved)) {
+					resolved = path.resolve(base, resolved);
+				}
+				results.push(resolved);
+			}
+		} catch {}
+	}
+
+	return results;
+}
+
+function buildSkillPaths(cwd: string): string[] {
+	const defaultSkillPaths = [
+		path.join(cwd, CONFIG_DIR, "skills"),
+		path.join(AGENT_DIR, "skills"),
+	];
+	const packagePaths = collectPackageSkillPaths(cwd);
+	const settingsPaths = collectSettingsSkillPaths(cwd);
+	return [...new Set([...defaultSkillPaths, ...packagePaths, ...settingsPaths])];
+}
+
+function inferSkillSource(rawSource: unknown, filePath: string, cwd: string): SkillSource {
+	const source = typeof rawSource === "string" ? rawSource : "";
+	const projectRoot = path.resolve(cwd, CONFIG_DIR);
+	const isProjectScoped = isWithinPath(filePath, projectRoot);
+	const isUserScoped = isWithinPath(filePath, AGENT_DIR);
+
+	if (source === "project") return "project";
+	if (source === "user") return "user";
+	if (source === "settings") {
+		if (isProjectScoped) return "project-settings";
+		if (isUserScoped) return "user-settings";
+		return "unknown";
+	}
+	if (source === "package") {
+		if (isProjectScoped) return "project-package";
+		if (isUserScoped) return "user-package";
+		return "unknown";
+	}
+	if (source === "extension") return "extension";
+	if (source === "builtin") return "builtin";
+
+	if (isProjectScoped) return "project";
+	if (isUserScoped) return "user";
+	return "unknown";
+}
+
+function chooseHigherPrioritySkill(existing: CachedSkillEntry | undefined, candidate: CachedSkillEntry): CachedSkillEntry {
+	if (!existing) return candidate;
+	const existingPriority = SOURCE_PRIORITY[existing.source] ?? 0;
+	const candidatePriority = SOURCE_PRIORITY[candidate.source] ?? 0;
+	if (candidatePriority > existingPriority) return candidate;
+	if (candidatePriority < existingPriority) return existing;
+	return candidate.order < existing.order ? candidate : existing;
+}
+
+function getCachedSkills(cwd: string): CachedSkillEntry[] {
+	const now = Date.now();
+	if (loadSkillsCache && loadSkillsCache.cwd === cwd && now - loadSkillsCache.timestamp < LOAD_SKILLS_CACHE_TTL_MS) {
+		return loadSkillsCache.skills;
+	}
+
+	const skillPaths = buildSkillPaths(cwd);
+	const loaded = loadSkills({ cwd, skillPaths, includeDefaults: false });
+	const dedupedByName = new Map<string, CachedSkillEntry>();
+
+	for (let i = 0; i < loaded.skills.length; i++) {
+		const skill = loaded.skills[i] as Skill;
+		const entry: CachedSkillEntry = {
+			name: skill.name,
+			filePath: skill.filePath,
+			source: inferSkillSource((skill as { source?: unknown }).source, skill.filePath, cwd),
+			description: skill.description,
+			order: i,
+		};
+		const current = dedupedByName.get(entry.name);
+		dedupedByName.set(entry.name, chooseHigherPrioritySkill(current, entry));
+	}
+
+	const skills = [...dedupedByName.values()].sort((a, b) => a.order - b.order);
+	loadSkillsCache = { cwd, skills, timestamp: now };
+	return skills;
+}
+
+export function resolveSkillPath(
+	skillName: string,
+	cwd: string,
+): { path: string; source: SkillSource } | undefined {
+	const skills = getCachedSkills(cwd);
+	const skill = skills.find((s) => s.name === skillName);
+	if (!skill) return undefined;
+	return { path: skill.filePath, source: skill.source };
 }
 
 export function readSkill(
 	skillName: string,
 	skillPath: string,
-	source: "project" | "user",
+	source: SkillSource,
 ): ResolvedSkill | undefined {
 	try {
 		const stat = fs.statSync(skillPath);
@@ -123,84 +321,27 @@ export function normalizeSkillInput(
 	if (input === false) return false;
 	if (input === true || input === undefined) return undefined;
 	if (Array.isArray(input)) {
-		// Deduplicate while preserving order
 		return [...new Set(input.map((s) => s.trim()).filter((s) => s.length > 0))];
 	}
-	// Deduplicate while preserving order
 	return [...new Set(input.split(",").map((s) => s.trim()).filter((s) => s.length > 0))];
 }
 
-function isDirectory(p: string): boolean {
-	try {
-		return fs.statSync(p).isDirectory();
-	} catch {
-		return false;
-	}
-}
-
 export function discoverAvailableSkills(cwd: string): Array<{
 	name: string;
-	source: "project" | "user";
+	source: SkillSource;
 	description?: string;
 }> {
-	const skills: Array<{ name: string; source: "project" | "user"; description?: string }> = [];
-	const seen = new Set<string>();
-
-	const scanDir = (dir: string, source: "project" | "user") => {
-		if (!fs.existsSync(dir)) return;
-
-		try {
-			const entries = fs.readdirSync(dir, { withFileTypes: true });
-			for (const entry of entries) {
-				const fullPath = path.join(dir, entry.name);
-
-				const isDir = entry.isDirectory() || (entry.isSymbolicLink() && isDirectory(fullPath));
-				if (!isDir) continue;
-
-				const skillPath = path.join(fullPath, "SKILL.md");
-				if (!fs.existsSync(skillPath)) continue;
-
-				if (source === "project" || !seen.has(entry.name)) {
-					let description: string | undefined;
-					try {
-						const content = fs.readFileSync(skillPath, "utf-8");
-						if (content.startsWith("---")) {
-							const endIndex = content.indexOf("\n---", 3);
-							if (endIndex !== -1) {
-								const fmBlock = content.slice(0, endIndex);
-								const match = fmBlock.match(/description:\s*(.+)/);
-								if (match) {
-									let desc = match[1].trim();
-									if (
-										(desc.startsWith("\"") && desc.endsWith("\"")) ||
-										(desc.startsWith("'") && desc.endsWith("'"))
-									) {
-										desc = desc.slice(1, -1);
-									}
-									description = desc;
-								}
-							}
-						}
-					} catch {}
-
-					if (source === "project" && seen.has(entry.name)) {
-						const idx = skills.findIndex((s) => s.name === entry.name);
-						if (idx !== -1) skills.splice(idx, 1);
-					}
-
-					skills.push({ name: entry.name, source, description });
-					seen.add(entry.name);
-				}
-			}
-		} catch {}
-	};
-
-	scanDir(path.join(os.homedir(), ".pi", "agent", "skills"), "user");
-	scanDir(path.resolve(cwd, ".pi", "skills"), "project");
-
-	return skills.sort((a, b) => a.name.localeCompare(b.name));
+	const skills = getCachedSkills(cwd);
+	return skills
+		.map((s) => ({
+			name: s.name,
+			source: s.source,
+			description: s.description,
+		}))
+		.sort((a, b) => a.name.localeCompare(b.name));
 }
 
 export function clearSkillCache(): void {
 	skillCache.clear();
+	loadSkillsCache = null;
 }

package/subagent-runner.ts

@@ -5,6 +5,8 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { pathToFileURL } from "node:url";
 import { appendJsonl, getArtifactPaths } from "./artifacts.js";
+import { getPiSpawnCommand } from "./pi-spawn.js";
+import { persistSingleOutput } from "./single-output.js";
 import {
 	type ArtifactConfig,
 	type ArtifactPaths,
@@ -20,9 +22,11 @@ interface SubagentStep {
 	cwd?: string;
 	model?: string;
 	tools?: string[];
+	extensions?: string[];
 	mcpDirectTools?: string[];
 	systemPrompt?: string | null;
 	skills?: string[];
+	outputPath?: string;
 }
 
 interface SubagentRunConfig {
@@ -104,7 +108,8 @@ function runPiStreaming(
 	return new Promise((resolve) => {
 		const outputStream = fs.createWriteStream(outputFile, { flags: "w" });
 		const spawnEnv = { ...process.env, ...(env ?? {}), ...getSubagentDepthEnv() };
-		const child = spawn("pi", args, { cwd, stdio: ["ignore", "pipe", "pipe"], env: spawnEnv });
+		const spawnSpec = getPiSpawnCommand(args);
+		const child = spawn(spawnSpec.command, spawnSpec.args, { cwd, stdio: ["ignore", "pipe", "pipe"], env: spawnEnv });
 		let stdout = "";
 
 		child.stdout.on("data", (chunk: Buffer) => {
@@ -337,19 +342,27 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 			} catch {}
 			args.push("--session-dir", config.sessionDir);
 		}
-		if (step.model) args.push("--model", step.model);
+		// Use --models (not --model) because pi CLI silently ignores --model
+		// without a companion --provider flag. --models resolves the provider
+		// automatically via resolveModelScope. See: #8
+		if (step.model) args.push("--models", step.model);
+		const toolExtensionPaths: string[] = [];
 		if (step.tools?.length) {
 			const builtinTools: string[] = [];
-			const extensionPaths: string[] = [];
 			for (const tool of step.tools) {
 				if (tool.includes("/") || tool.endsWith(".ts") || tool.endsWith(".js")) {
-					extensionPaths.push(tool);
+					toolExtensionPaths.push(tool);
 				} else {
 					builtinTools.push(tool);
 				}
 			}
 			if (builtinTools.length > 0) args.push("--tools", builtinTools.join(","));
-			for (const extPath of extensionPaths) args.push("--extension", extPath);
+		}
+		if (step.extensions !== undefined) {
+			args.push("--no-extensions");
+			for (const extPath of step.extensions) args.push("--extension", extPath);
+		} else {
+			for (const extPath of toolExtensionPaths) args.push("--extension", extPath);
 		}
 
 		let tmpDir: string | null = null;
@@ -392,6 +405,19 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 
 		const output = (result.stdout || "").trim();
 		previousOutput = output;
+		let outputForSummary = output;
+		if (step.outputPath && result.exitCode === 0) {
+			const persisted = persistSingleOutput(step.outputPath, output);
+			if (persisted.savedPath) {
+				outputForSummary = output
+					? `${output}\n\n📄 Output saved to: ${persisted.savedPath}`
+					: `📄 Output saved to: ${persisted.savedPath}`;
+			} else if (persisted.error) {
+				outputForSummary = output
+					? `${output}\n\n⚠️ Failed to save output to: ${step.outputPath}\n${persisted.error}`
+					: `⚠️ Failed to save output to: ${step.outputPath}\n${persisted.error}`;
+			}
+		}
 
 		const cumulativeTokens = config.sessionDir ? parseSessionTokens(config.sessionDir) : null;
 		const stepTokens: TokenUsage | null = cumulativeTokens
@@ -407,7 +433,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 
 		const stepResult: StepResult = {
 			agent: step.agent,
-			output,
+			output: outputForSummary,
 			success: result.exitCode === 0,
 			artifactPaths,
 		};

package/types.ts

@@ -2,6 +2,8 @@
  * Type definitions for the subagent extension
  */
 
+import * as os from "node:os";
+import * as path from "node:path";
 import type { Message } from "@mariozechner/pi-ai";
 
 // ============================================================================
@@ -237,8 +239,8 @@ export const DEFAULT_ARTIFACT_CONFIG: ArtifactConfig = {
 
 export const MAX_PARALLEL = 8;
 export const MAX_CONCURRENCY = 4;
-export const RESULTS_DIR = "/tmp/pi-async-subagent-results";
-export const ASYNC_DIR = "/tmp/pi-async-subagent-runs";
+export const RESULTS_DIR = path.join(os.tmpdir(), "pi-async-subagent-results");
+export const ASYNC_DIR = path.join(os.tmpdir(), "pi-async-subagent-runs");
 export const WIDGET_KEY = "subagent-async";
 export const POLL_INTERVAL_MS = 250;
 export const MAX_WIDGET_JOBS = 4;