@selesai/code 0.8.3 → 0.8.5

package/dist/extensions/pi-subagents/src/runs/background/result-watcher.ts

@@ -20,13 +20,16 @@ import {
 } from "../../intercom/result-intercom.ts";
 import { projectNestedRegistryForRoot, sanitizeSummary } from "../shared/nested-events.ts";
 import { resolveWatchPath } from "../../shared/utils.ts";
+import { recordWaitCompletion } from "./wait-completions.ts";
+import { MISSION_BINDING_FILE, syncMissionFromAsyncCompletion } from "../../missions/lifecycle.ts";
 import type { CompletionNotifier, CompletionNotification } from "./notify.ts";
 
 const WATCHER_RESTART_DELAY_MS = 3000;
 const POLL_INTERVAL_MS = 3000;
+const HEALTHY_SCAN_INTERVAL_MS = 60_000;
 const RETRY_DELAY_MS = 100;
 
-type ResultWatcherFs = Pick<typeof fs, "existsSync" | "readFileSync" | "unlinkSync" | "readdirSync" | "mkdirSync" | "realpathSync" | "watch">;
+type ResultWatcherFs = Pick<typeof fs, "existsSync" | "readFileSync" | "unlinkSync" | "readdirSync" | "mkdirSync" | "realpathSync" | "statSync" | "watch">;
 
 type ResultWatcherTimers = {
 	setTimeout: typeof setTimeout;
@@ -41,6 +44,10 @@ type ResultWatcherDeps = {
 	notifier?: Pick<CompletionNotifier, "deliver">;
 	/** Receives persisted completions before active-session delivery filtering. */
 	observeCompletion?: (result: CompletionNotification & { runId: string }) => void;
+	/** Returns cross-session run ids that the completion observer currently owns. */
+	observedCompletionRunIds?: () => Iterable<string>;
+	/** Parses a relevant result payload after its lightweight identity check. */
+	parseResult?: (raw: string) => ResultFileData;
 	/** External grouped-result transport. Disable when native completion notifications own delivery. */
 	deliverIntercomResults?: boolean;
 };
@@ -74,6 +81,33 @@ type ResultFileData = CompletionNotification & {
 	parallelHandoff?: ParallelHandoffReference;
 };
 
+type ResultFileIdentity = {
+	sessionId?: string;
+	runId?: string;
+	asyncDir?: string;
+};
+
+function jsonStringProperty(raw: string, property: string): string | undefined {
+	const matches = raw.matchAll(new RegExp(`"${property}"\\s*:\\s*("(?:\\\\.|[^"\\\\])*")`, "g"));
+	let encoded: string | undefined;
+	for (const match of matches) encoded = match[1];
+	if (!encoded) return undefined;
+	try {
+		const value = JSON.parse(encoded) as unknown;
+		return typeof value === "string" && value ? value : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function resultFileIdentity(raw: string, file: string): ResultFileIdentity {
+	return {
+		sessionId: jsonStringProperty(raw, "sessionId"),
+		runId: file.replace(/\.json$/i, ""),
+		asyncDir: jsonStringProperty(raw, "asyncDir"),
+	};
+}
+
 function sanitizeNestedResultChildren(value: unknown, resultPath: string, label: string): NestedRunSummary[] | undefined {
 	if (value === undefined) return undefined;
 	if (!Array.isArray(value)) {
@@ -119,11 +153,14 @@ export function createResultWatcher(
 	const fsApi = deps.fs ?? fs;
 	const timers = deps.timers ?? { setTimeout, clearTimeout, setInterval, clearInterval };
 	const notifier = deps.notifier ?? { deliver: async () => true };
+	const parseResult = deps.parseResult ?? ((raw: string) => JSON.parse(raw) as ResultFileData);
 	const deliverIntercomResults = deps.deliverIntercomResults !== false;
 	const pendingTriggerTurn = new Map<string, boolean>();
 	const processing = new Set<string>();
+	const identityCache = new Map<string, { signature: string; identity: ResultFileIdentity }>();
 	let deliveryActive = true;
 	let deliveryEpoch = 0;
+	let resultScanTimer: ReturnType<typeof setInterval> | null = null;
 	// The sole in-memory ownership lease. It is acquired for one active session
 	// and revoked before the watcher, queues, or callbacks are torn down.
 	let activeSessionId: string | null = null;
@@ -140,14 +177,58 @@ export function createResultWatcher(
 		state.resultFileCoalescer.schedule(file, delayMs);
 	};
 
+	const inspectResult = (file: string): ResultFileIdentity | undefined => {
+		const resultPath = path.join(resultsDir, file);
+		try {
+			const stat = fsApi.statSync(resultPath);
+			const signature = `${stat.size}:${stat.mtimeMs}`;
+			const cached = identityCache.get(file);
+			if (cached?.signature === signature) return cached.identity;
+			const identity = resultFileIdentity(fsApi.readFileSync(resultPath, "utf-8"), file);
+			identityCache.set(file, { signature, identity });
+			return identity;
+		} catch (error) {
+			identityCache.delete(file);
+			if (!isNotFound(error)) console.error(`Failed to inspect subagent result file '${resultPath}':`, error);
+			return undefined;
+		}
+	};
+
+	const observedRunIds = (): ReadonlySet<string> => {
+		try {
+			return new Set(deps.observedCompletionRunIds?.() ?? []);
+		} catch (error) {
+			console.error("Failed to inspect observed subagent completion ids:", error);
+			return new Set();
+		}
+	};
+
+	const shouldProcessResult = (file: string, observed?: ReadonlySet<string>): boolean => {
+		const identity = inspectResult(file);
+		if (!identity) return false;
+		// Missing identity stays on the normal parser path so malformed or legacy
+		// files keep their existing diagnostics and compatibility behavior.
+		if (!identity.sessionId) return true;
+		if (identity.sessionId === state.currentSessionId) return true;
+		if (identity.asyncDir && fsApi.existsSync(path.join(identity.asyncDir, MISSION_BINDING_FILE))) return true;
+		if (identity.runId && (observed ?? observedRunIds()).has(identity.runId)) return true;
+		return Boolean(deps.observeCompletion && !deps.observedCompletionRunIds);
+	};
+
 	const handleResult = async (file: string, triggerTurn: boolean) => {
 		const resultPath = path.join(resultsDir, file);
 		if (processing.has(file) || !fsApi.existsSync(resultPath)) return;
+		if (!shouldProcessResult(file)) return;
 		processing.add(file);
 		try {
-			const data = JSON.parse(fsApi.readFileSync(resultPath, "utf-8")) as ResultFileData;
+			const data = parseResult(fsApi.readFileSync(resultPath, "utf-8"));
 			if (typeof data.sessionId !== "string" || !data.sessionId) return;
 			const runId = data.runId ?? data.id ?? file.replace(/\.json$/i, "");
+			try {
+				syncMissionFromAsyncCompletion({ ...data, runId });
+			} catch (error) {
+				console.error(`Mission completion sync failed for '${resultPath}':`, error);
+			}
 			try {
 				deps.observeCompletion?.({ ...data, runId });
 			} catch (error) {
@@ -155,6 +236,12 @@ export function createResultWatcher(
 			}
 			const epoch = deliveryEpoch;
 			if (!ownsSession(data.sessionId, epoch)) return;
+			// Recorded before dedupe and before the unlink below so subagent_wait can
+			// use the in-memory record or its bounded durable replay after cleanup.
+			recordWaitCompletion(state, runId, data, Date.now(), completionTtlMs, {
+				resultsDir,
+				sessionId: data.sessionId,
+			});
 			const hasExplicitNestedChildren = data.nestedChildren !== undefined;
 			let nestedChildren = compactNestedResultChildren(sanitizeNestedResultChildren(data.nestedChildren, resultPath, "nestedChildren"));
 			if (!nestedChildren?.length && !hasExplicitNestedChildren) {
@@ -175,6 +262,7 @@ export function createResultWatcher(
 				if (!ownsSession(data.sessionId, epoch) || !fsApi.existsSync(resultPath)) return;
 				try {
 					fsApi.unlinkSync(resultPath);
+					identityCache.delete(file);
 				} catch (error) {
 					if (!isNotFound(error)) {
 						console.error(`Failed to remove delivered subagent result '${resultPath}'; will retry:`, error);
@@ -300,6 +388,7 @@ export function createResultWatcher(
 			if (!ownsSession(data.sessionId, epoch) || !fsApi.existsSync(resultPath)) return;
 			try {
 				fsApi.unlinkSync(resultPath);
+				identityCache.delete(file);
 			} catch (error) {
 				if (!isNotFound(error)) {
 					console.error(`Failed to remove delivered subagent result '${resultPath}'; will retry:`, error);
@@ -324,15 +413,23 @@ export function createResultWatcher(
 			const triggerTurn = options.triggerTurn !== false;
 			fsApi.readdirSync(resultsDir)
 				.filter((f) => f.endsWith(".json"))
-				.forEach((file) => scheduleResult(file, triggerTurn));
+				.forEach((file) => {
+					if (shouldProcessResult(file)) scheduleResult(file, triggerTurn);
+				});
 		} catch (error) {
 			if (!isNotFound(error)) console.error(`Failed to scan subagent result directory '${resultsDir}':`, error);
 		}
 	};
 
+	const clearResultScan = () => {
+		if (resultScanTimer) timers.clearInterval(resultScanTimer);
+		resultScanTimer = null;
+	};
+
 	const startPolling = (reason: unknown) => {
 		state.watcher?.close();
 		state.watcher = null;
+		clearResultScan();
 		if (state.watcherRestartTimer) return;
 		console.error(`Subagent result watcher for '${resultsDir}' fell back to polling because native fs.watch is unavailable (${errorCode(reason) ?? "unknown error"}).`);
 		primeExistingResults();
@@ -341,6 +438,7 @@ export function createResultWatcher(
 	};
 
 	const scheduleRestart = () => {
+		clearResultScan();
 		if (state.watcherRestartTimer) return;
 		state.watcherRestartTimer = timers.setTimeout(() => {
 			state.watcherRestartTimer = null;
@@ -368,10 +466,16 @@ export function createResultWatcher(
 		}
 		try {
 			const watchDir = resolveWatchPath(resultsDir, fsApi.realpathSync.native);
-			state.watcher = fsApi.watch(watchDir, (event, file) => {
-				if (event !== "rename" || !file) return;
+			state.watcher = fsApi.watch(watchDir, (_event, file) => {
+				if (!file) {
+					primeExistingResults();
+					return;
+				}
 				const fileName = file.toString();
-				if (fileName.endsWith(".json")) scheduleResult(fileName, true);
+				if (fileName.endsWith(".json")) {
+					identityCache.delete(fileName);
+					scheduleResult(fileName, true);
+				}
 			});
 			state.watcher.on("error", (error) => {
 				if (shouldPoll(error)) return startPolling(error);
@@ -381,6 +485,8 @@ export function createResultWatcher(
 				scheduleRestart();
 			});
 			state.watcher.unref?.();
+			resultScanTimer = timers.setInterval(primeExistingResults, HEALTHY_SCAN_INTERVAL_MS);
+			resultScanTimer.unref?.();
 		} catch (error) {
 			if (shouldPoll(error)) return startPolling(error);
 			console.error(`Failed to start subagent result watcher for '${resultsDir}':`, error);
@@ -400,9 +506,11 @@ export function createResultWatcher(
 			timers.clearInterval(state.watcherRestartTimer);
 		}
 		state.watcherRestartTimer = null;
+		clearResultScan();
 		state.resultFileCoalescer.clear();
 		pendingTriggerTurn.clear();
 		processing.clear();
+		identityCache.clear();
 	};
 
 	return { startResultWatcher, primeExistingResults, stopResultWatcher };

package/dist/extensions/pi-subagents/src/runs/background/resume-guidance.ts

@@ -0,0 +1,33 @@
+import * as fs from "node:fs";
+import type { AsyncRunSummary } from "./async-status.ts";
+
+export function formatAsyncReviveCommand(run: AsyncRunSummary): string | undefined {
+	const step = run.steps.find((candidate) => candidate.status === "failed" && candidate.sessionFile && fs.existsSync(candidate.sessionFile));
+	if (!step) {
+		if (run.steps.length === 1 && run.sessionFile && fs.existsSync(run.sessionFile)) {
+			return `subagent({ action: "resume", id: "${run.id}", message: "Continue from the persisted child session and report the result." })`;
+		}
+		return undefined;
+	}
+	const index = run.steps.length === 1 ? "" : `, index: ${step.index}`;
+	return `subagent({ action: "resume", id: "${run.id}"${index}, message: "Continue from the persisted child session and report the result." })`;
+}
+
+export function formatResumeFirstFailedRunDetail(run: AsyncRunSummary): string | undefined {
+	if (run.state !== "failed") return undefined;
+	const command = formatAsyncReviveCommand(run);
+	if (!command) return undefined;
+	return `Resume-first: failed run "${run.id}" has a persisted child session. Revive the original run with ${command} before reporting failure or launching a replacement. Launch a replacement only if revive fails or the user explicitly asks for one.`;
+}
+
+export function formatResumeFirstFailedRunsNote(runs: AsyncRunSummary[]): string {
+	const resumable = runs
+		.filter((run) => run.state === "failed")
+		.map((run) => ({ run, command: formatAsyncReviveCommand(run) }))
+		.filter((entry): entry is { run: AsyncRunSummary; command: string } => Boolean(entry.command));
+	if (resumable.length === 0) return "";
+	const guidance = resumable.length === 1
+		? `failed run "${resumable[0]!.run.id}" has a persisted child session. Revive the original run with ${resumable[0]!.command}`
+		: `${resumable.length} failed runs have persisted child sessions. Inspect status and revive each original run before retrying`;
+	return ` Resume-first: ${guidance} before reporting failure or launching a replacement. Launch a replacement only if revive fails or the user explicitly asks for one.`;
+}

package/dist/extensions/pi-subagents/src/runs/background/retained-children.ts

@@ -0,0 +1,68 @@
+import * as fs from "node:fs";
+import { listAsyncRuns } from "./async-status.ts";
+import type { TokenUsage } from "../../shared/types.ts";
+
+const MAX_RETAINED_CHILDREN = 10;
+const MAX_TASK_SUMMARY_LENGTH = 120;
+
+export interface RetainedChild {
+	runId: string;
+	parentRunId?: string;
+	agent: string;
+	taskSummary: string;
+	completedAt: number;
+	sessionPath: string;
+	tokenTotals?: TokenUsage;
+}
+
+function retainedSessionFile(sessionFile: string | undefined): sessionFile is string {
+	if (!sessionFile?.endsWith(".jsonl")) return false;
+	try {
+		const stat = fs.lstatSync(sessionFile);
+		return stat.isFile() && !stat.isSymbolicLink();
+	} catch {
+		return false;
+	}
+}
+
+function boundedTaskSummary(value: string | undefined): string {
+	const normalized = value?.replace(/\s+/g, " ").trim() ?? "";
+	return normalized.length > MAX_TASK_SUMMARY_LENGTH
+		? `${normalized.slice(0, MAX_TASK_SUMMARY_LENGTH - 1)}…`
+		: normalized;
+}
+
+export function listRetainedChildren(asyncDirRoot: string, sessionId: string): RetainedChild[] {
+	return listAsyncRuns(asyncDirRoot, { sessionId, states: ["complete"], reconcile: false })
+		.flatMap((run) => {
+			if (!run.parentWorkflowRunId || run.steps.length !== 1) return [];
+			const step = run.steps[0]!;
+			if ((step.status !== "complete" && step.status !== "completed") || !retainedSessionFile(step.sessionFile ?? run.sessionFile)) return [];
+			const completedAt = run.endedAt;
+			if (completedAt === undefined) return [];
+			return [{
+				runId: run.id,
+				...(run.parentWorkflowRunId ? { parentRunId: run.parentWorkflowRunId } : {}),
+				agent: step.agent,
+				taskSummary: boundedTaskSummary(step.description),
+				completedAt,
+				sessionPath: step.sessionFile ?? run.sessionFile!,
+				...(step.tokens ?? run.totalTokens ? { tokenTotals: step.tokens ?? run.totalTokens } : {}),
+			}];
+		})
+		.sort((left, right) => right.completedAt - left.completedAt)
+		.slice(0, MAX_RETAINED_CHILDREN);
+}
+
+export function formatRetainedChildren(children: RetainedChild[]): string {
+	if (children.length === 0) return "No completed retained children in the active parent session.";
+	return [
+		`Completed retained children (newest first, last ${MAX_RETAINED_CHILDREN}):`,
+		...children.flatMap((child) => [
+			`- ${child.runId} | ${child.agent} | ${new Date(child.completedAt).toISOString()}`,
+			`  task: ${child.taskSummary || "(no task summary)"}`,
+			`  session: ${child.sessionPath}`,
+			...(child.tokenTotals ? [`  tokens: input ${child.tokenTotals.input}, output ${child.tokenTotals.output}, total ${child.tokenTotals.total}`] : []),
+		]),
+	].join("\n");
+}

package/dist/extensions/pi-subagents/src/runs/background/run-id-resolver.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { DIRS, type SubagentState } from "../../shared/types.ts";
+import { readStatus } from "../../shared/utils.ts";
 import { findAsyncRunPrefixMatches, type AsyncRunLocation } from "./async-resume.ts";
 import { assertSafeNestedId, findNestedRunMatchesById, type NestedRoute, type NestedRunMatch, type NestedRunResolutionScope } from "../shared/nested-events.ts";
 
@@ -27,6 +28,70 @@ function exactAsyncLocation(id: string, asyncDirRoot: string, resultsDir: string
 	};
 }
 
+type AsyncRunMatch = { id: string; location: AsyncRunLocation };
+
+type WorkflowResultIdentity = {
+	id?: string;
+	runId?: string;
+	toolCallId?: string;
+};
+
+function readWorkflowResultIdentity(resultPath: string): WorkflowResultIdentity | undefined {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as unknown;
+	} catch {
+		return undefined;
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
+	const record = parsed as Record<string, unknown>;
+	return {
+		...(typeof record.id === "string" ? { id: record.id } : {}),
+		...(typeof record.runId === "string" ? { runId: record.runId } : {}),
+		...(typeof record.toolCallId === "string" ? { toolCallId: record.toolCallId } : {}),
+	};
+}
+
+function directoryEntries(root: string): string[] {
+	try {
+		return fs.readdirSync(root);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
+		throw error;
+	}
+}
+
+function resultPathFor(resultsDir: string, runId: string): string | null {
+	const resultPath = path.join(resultsDir, `${runId}.json`);
+	return fs.existsSync(resultPath) ? resultPath : null;
+}
+
+function toolCallIdMatches(value: string | undefined, query: string, options: { prefix?: boolean }): boolean {
+	if (value === undefined) return false;
+	return options.prefix === true ? value.startsWith(query) : value === query;
+}
+
+function toolCallIdAsyncLocations(toolCallId: string, asyncDirRoot: string, resultsDir: string, options: { prefix?: boolean } = {}): AsyncRunMatch[] {
+	const byId = new Map<string, AsyncRunLocation>();
+	for (const entry of directoryEntries(asyncDirRoot)) {
+		const asyncDir = path.join(asyncDirRoot, entry);
+		const status = readStatus(asyncDir);
+		if (!status || !toolCallIdMatches(status.toolCallId, toolCallId, options)) continue;
+		const runId = status.runId || entry;
+		byId.set(runId, { asyncDir, resultPath: resultPathFor(resultsDir, runId), resolvedId: runId });
+	}
+	for (const entry of directoryEntries(resultsDir)) {
+		if (!entry.endsWith(".json")) continue;
+		const resultPath = path.join(resultsDir, entry);
+		const identity = readWorkflowResultIdentity(resultPath);
+		if (!identity || !toolCallIdMatches(identity.toolCallId, toolCallId, options)) continue;
+		const runId = identity.runId ?? identity.id ?? entry.slice(0, -".json".length);
+		const asyncDir = path.join(asyncDirRoot, runId);
+		byId.set(runId, { asyncDir: fs.existsSync(asyncDir) ? asyncDir : null, resultPath, resolvedId: runId });
+	}
+	return [...byId.entries()].map(([id, location]) => ({ id, location }));
+}
+
 function foregroundIds(state: SubagentState | undefined): string[] {
 	if (!state) return [];
 	const remembered = state.currentSessionId
@@ -73,6 +138,9 @@ export function resolveSubagentRunId(id: string, deps: ResolveSubagentRunIdDeps
 	if (hasExactForegroundId(deps.state, id)) return { kind: "foreground", id };
 	const exactAsync = exactAsyncLocation(id, asyncDirRoot, resultsDir);
 	if (exactAsync) return { kind: "async", id, location: exactAsync };
+	const exactToolCallIdMatches = toolCallIdAsyncLocations(id, asyncDirRoot, resultsDir);
+	if (exactToolCallIdMatches.length > 1) throw new Error(`Subagent tool-call id '${id}' is ambiguous across async runs. Use the returned asyncId instead.`);
+	if (exactToolCallIdMatches[0]) return { kind: "async", id: exactToolCallIdMatches[0].id, location: exactToolCallIdMatches[0].location };
 	const exactNested = findNestedRunMatchesById(id, nestedScope ? { scope: nestedScope } : {});
 	if (exactNested.length > 1) throw new Error(`Nested run id '${id}' is ambiguous across authorized registries. Provide the full id after stale registries are cleaned up.`);
 	if (exactNested[0]) return { kind: "nested", id, match: exactNested[0] };
@@ -84,6 +152,9 @@ export function resolveSubagentRunId(id: string, deps: ResolveSubagentRunIdDeps
 	for (const match of asyncPrefixMatches(id, asyncDirRoot, resultsDir)) {
 		matches.push({ kind: "async", id: match.id, location: match.location });
 	}
+	for (const match of toolCallIdAsyncLocations(id, asyncDirRoot, resultsDir, { prefix: true })) {
+		matches.push({ kind: "async", id: match.id, location: match.location });
+	}
 	for (const match of findNestedRunMatchesById(id, nestedScope ? { prefix: true, scope: nestedScope } : { prefix: true })) {
 		matches.push({ kind: "nested", id: match.run.id, match });
 	}

package/dist/extensions/pi-subagents/src/runs/background/run-status.ts

@@ -7,6 +7,7 @@ import { formatNestedRunStatusLines } from "../shared/nested-render.ts";
 import { formatModelThinking } from "../../shared/formatters.ts";
 import { formatActivityLabel } from "../../shared/status-format.ts";
 import { DIRS, type AsyncStatus, type Details, type ForegroundResumeRun, type NestedRunSummary, type SteeringStatus, type SubagentState } from "../../shared/types.ts";
+import { readStatus } from "../../shared/utils.ts";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
 import { resolveSubagentResultStatus } from "../../intercom/result-intercom.ts";
 import { readProcessTerminal, sanitizeProcessTerminal } from "./process-terminal.ts";
@@ -18,6 +19,7 @@ import { reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-
 import { attachRootChildrenToSteps, findNestedRouteForRootId, projectNestedRegistryForRoot, type NestedRunResolutionScope } from "../shared/nested-events.ts";
 import { readMissionBinding } from "../../missions/lifecycle.ts";
 import { formatWorkflowJsonPreview } from "../../workflows/scripted-workflow.ts";
+import { formatRunFanoutBudget, getRunFanoutBudgetSnapshot, readRunFanoutBudgetDescriptor } from "../shared/run-fanout-budget.ts";
 
 interface RunStatusParams {
 	action?: string;
@@ -315,6 +317,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 	}
 
 	if (asyncDir) {
+		const diskStatus = readStatus(asyncDir);
 		let reconciliation;
 		try {
 			reconciliation = reconcileAsyncRun(asyncDir, { resultsDir, kill: deps.kill, now: deps.now });
@@ -327,6 +330,22 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			};
 		}
 		const status = reconciliation.status;
+		if (!status && diskStatus?.displayDismissedAt !== undefined) {
+			if (params.view === "transcript") {
+				if (currentSessionId && diskStatus.sessionId !== currentSessionId) {
+					return {
+						content: [{ type: "text", text: "Transcript view is only available for async runs owned by the current session." }],
+						isError: true,
+						details: { mode: "single", results: [] },
+					};
+				}
+				return { content: [{ type: "text", text: formatAsyncRunTranscript(diskStatus, asyncDir, { index: params.index, lines: params.lines, sessionRoots: deps.sessionRoots }) }], details: { mode: "single", results: [] } };
+			}
+			return {
+				content: [{ type: "text", text: `Run: ${diskStatus.runId}\nState: display-dismissed\nDismissed: ${new Date(diskStatus.displayDismissedAt).toISOString()}\nNo running work was terminated.` }],
+				details: { mode: "single", results: [] },
+			};
+		}
 		const effectiveRunId = status?.runId ?? resolvedId ?? "unknown";
 		const logPath = path.join(asyncDir, `subagent-log-${effectiveRunId}.md`);
 		const eventsPath = path.join(asyncDir, "events.jsonl");
@@ -371,6 +390,8 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			const steeringText = formatSteeringSummary(status);
 			const processTerminal = readProcessTerminal(asyncDir, { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId })
 				?? sanitizeProcessTerminal(status.processTerminal, { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId }, path.join(asyncDir, "status.json"));
+			const runFanoutBudgetDescriptor = readRunFanoutBudgetDescriptor(asyncDir);
+			const runFanoutBudget = runFanoutBudgetDescriptor ? getRunFanoutBudgetSnapshot(runFanoutBudgetDescriptor) : status.runFanoutBudget;
 			let missionId: string | undefined;
 			try {
 				missionId = readMissionBinding(asyncDir)?.missionId;
@@ -382,6 +403,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			const workflowEmitPreview = status.workflow?.emits.length ? formatWorkflowJsonPreview(status.workflow.emits.at(-1), 240) : undefined;
 			const lines = [
 				`Run: ${status.runId}`,
+				status.toolCallId ? `Tool call: ${status.toolCallId}` : undefined,
 				missionId ? `Mission: ${missionId}` : undefined,
 				`State: ${status.state}`,
 				processTerminal ? `Process terminal: ${processTerminal.state}${processTerminal.reason ? ` (${processTerminal.reason})` : ""}` : undefined,
@@ -391,6 +413,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 				statusActivityText ? `Activity: ${statusActivityText}` : undefined,
 				steeringText ? `Steering: ${steeringText}` : undefined,
 				`Mode: ${status.mode}`,
+				runFanoutBudget ? formatRunFanoutBudget(runFanoutBudget) : undefined,
 				status.parentWorkflowRunId ? `Workflow parent: ${status.parentWorkflowRunId}${status.workflowKey ? ` (${status.workflowKey})` : ""}` : undefined,
 				status.mode === "workflow" && workflowReturnPreview !== undefined ? `Return: ${workflowReturnPreview}` : undefined,
 				status.mode === "workflow" && workflowEmitPreview !== undefined ? `Latest emit: ${workflowEmitPreview}` : undefined,
@@ -447,14 +470,14 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			if (fs.existsSync(logPath)) lines.push(`Log: ${logPath}`);
 			if (fs.existsSync(eventsPath)) lines.push(`Events: ${eventsPath}`);
 
-			return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [], ...(processTerminal ? { lifecycleStatus: { processTerminal } } : {}) } };
+			return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [], ...(runFanoutBudget ? { runFanoutBudget } : {}), ...(processTerminal ? { lifecycleStatus: { processTerminal } } : {}) } };
 		}
 	}
 
 	if (resultPath) {
 		try {
 			const raw = fs.readFileSync(resultPath, "utf-8");
-			const data = JSON.parse(raw) as { id?: string; runId?: string; agent?: string; success?: boolean; summary?: string; output?: string; exitCode?: number; state?: string; stopped?: boolean; timedOut?: boolean; turnBudgetExceeded?: boolean; processSignal?: string | null; sessionFile?: string; parallelHandoff?: { path?: string }; results?: Array<{ agent?: string; output?: string; summary?: string; sessionFile?: string; state?: string; success?: boolean; exitCode?: number | null; stopped?: boolean; timedOut?: boolean; turnBudgetExceeded?: boolean; interrupted?: boolean; processSignal?: string | null }> };
+			const data = JSON.parse(raw) as { id?: string; runId?: string; toolCallId?: string; agent?: string; success?: boolean; summary?: string; output?: string; exitCode?: number; state?: string; stopped?: boolean; timedOut?: boolean; turnBudgetExceeded?: boolean; processSignal?: string | null; sessionFile?: string; parallelHandoff?: { path?: string }; results?: Array<{ agent?: string; output?: string; summary?: string; sessionFile?: string; state?: string; success?: boolean; exitCode?: number | null; stopped?: boolean; timedOut?: boolean; turnBudgetExceeded?: boolean; interrupted?: boolean; processSignal?: string | null }> };
 			if (params.view === "transcript") {
 				try {
 					return { content: [{ type: "text", text: formatAsyncResultTranscript(data, resultPath, { index: params.index, lines: params.lines }) }], details: { mode: "single", results: [] } };
@@ -479,7 +502,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 				? "stopped"
 				: data.success ? "complete" : data.state === "paused" || data.exitCode === 0 ? "paused" : "failed";
 			const runId = data.runId ?? data.id ?? resolvedId;
-			const lines = [`Run: ${runId}`, `State: ${status}`, `Result: ${resultPath}`];
+			const lines = [`Run: ${runId}`, data.toolCallId ? `Tool call: ${data.toolCallId}` : undefined, `State: ${status}`, `Result: ${resultPath}`].filter((line): line is string => Boolean(line));
 			if (data.parallelHandoff?.path) lines.push(`Parallel handoff: ${data.parallelHandoff.path}`);
 			const children = Array.isArray(data.results) ? data.results : data.agent ? [{ agent: data.agent, sessionFile: data.sessionFile }] : [];
 			lines.push(formatResumeGuidance(runId, children, data.sessionFile, { stopped: status === "stopped" }));

package/dist/extensions/pi-subagents/src/runs/background/scheduled-runs.ts

@@ -3,12 +3,14 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { ExtensionContext } from "@selesai/code";
+import { getProjectSubagentsDir } from "../../shared/artifacts.ts";
 import { writePrivateAtomicJson } from "../../shared/atomic-json.ts";
 import { shortenPath } from "../../shared/formatters.ts";
 import type { AsyncStatus, Details, ExtensionConfig } from "../../shared/types.ts";
 import type { SubagentParamsLike } from "../foreground/subagent-executor.ts";
 import { validateExecutionAcceptance } from "../shared/acceptance.ts";
 import type { ResolvedSubagentCapabilityCeiling } from "../shared/capability-ceiling.ts";
+import { previewSimpleWorkflowRun } from "../../workflows/scripted-workflow.ts";
 
 export const SCHEDULED_RUN_ACTIONS = [
 	"schedule.create",
@@ -34,7 +36,7 @@ export type ScheduleRunState = "running" | "skipped" | "missed" | "completed" |
 export type ScheduleTrigger =
 	| { kind: "once"; at: string; nextRunAt?: string }
 	| { kind: "interval"; every: string; everyMs: number; anchorAt: string; nextRunAt: string };
-export type ScheduleTarget = { workflowScript: string } | { agent: string; task?: string };
+export type ScheduleTarget = { workflowScript: string };
 
 export interface ScheduleRecord {
 	schemaVersion: 1;
@@ -86,7 +88,7 @@ export function scheduledRunsEnabled(config: ExtensionConfig): boolean {
 }
 
 export function scheduledRunStorePath(cwd: string, _sessionId?: string, root?: string): string {
-	if (!root) return path.join(path.resolve(cwd), ".pi-subagents", "schedules");
+	if (!root) return path.join(getProjectSubagentsDir(path.resolve(cwd)), "schedules");
 	const projectKey = createHash("sha256").update(path.resolve(cwd)).digest("hex").slice(0, 20);
 	return path.join(root, projectKey);
 }
@@ -188,6 +190,14 @@ function readJson(file: string, label: string): unknown {
 	}
 }
 
+function parseScheduleTarget(value: unknown, file: string): ScheduleTarget {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Schedule record '${file}' has invalid trigger or target.`);
+	const target = value as { workflowScript?: unknown; agent?: unknown; task?: unknown };
+	if (typeof target.workflowScript === "string" && target.workflowScript.trim()) return { workflowScript: target.workflowScript.trim() };
+	if (target.agent !== undefined || target.task !== undefined) throw new Error(`Schedule record '${file}' uses a removed legacy agent target; recreate it with target.workflowScript.`);
+	throw new Error(`Schedule record '${file}' requires a workflowScript target.`);
+}
+
 function parseSchedule(value: unknown, file: string): ScheduleRecord {
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Schedule record '${file}' must be a JSON object.`);
 	const record = value as Partial<ScheduleRecord>;
@@ -200,10 +210,7 @@ function parseSchedule(value: unknown, file: string): ScheduleRecord {
 	} else if (record.trigger.kind === "interval") {
 		if (typeof record.trigger.every !== "string" || typeof record.trigger.everyMs !== "number" || typeof record.trigger.anchorAt !== "string" || typeof record.trigger.nextRunAt !== "string") throw new Error(`Schedule record '${file}' has an invalid interval trigger.`);
 	} else throw new Error(`Schedule record '${file}' has an unsupported trigger.`);
-	const workflow = "workflowScript" in record.target && typeof record.target.workflowScript === "string";
-	const agent = "agent" in record.target && typeof record.target.agent === "string";
-	if (workflow === agent) throw new Error(`Schedule record '${file}' has an invalid target.`);
-	return record as ScheduleRecord;
+	return { ...record, target: parseScheduleTarget(record.target, file) } as ScheduleRecord;
 }
 
 class ScheduleStore {
@@ -304,27 +311,25 @@ function textResult(text: string, schedules?: ScheduleRecord[], runs?: ScheduleR
 }
 
 function targetLabel(target: ScheduleTarget): string {
-	return "workflowScript" in target ? "workflowScript" : `agent ${target.agent}`;
+	const preview = previewSimpleWorkflowRun(target.workflowScript);
+	return preview?.agent ? `workflowScript -> agent ${preview.agent}` : "workflowScript (dynamic)";
 }
 
 function sanitizeTarget(params: SubagentParamsLike): { target?: ScheduleTarget; error?: string } {
-	if (params.tasks || params.chain) return { error: "Recurring schedules support workflowScript or one agent/task target, not legacy tasks or chain inputs." };
-	const hasWorkflow = typeof params.workflowScript === "string" && params.workflowScript.trim().length > 0;
-	const hasAgent = typeof params.agent === "string" && params.agent.trim().length > 0;
-	if (hasWorkflow === hasAgent) return { error: "schedule.create requires exactly one target: workflowScript or agent with optional task." };
+	if (params.tasks || params.chain) return { error: "Recurring schedules require workflowScript; legacy tasks and chain inputs are unsupported." };
+	if (params.agent !== undefined || params.task !== undefined) return { error: "schedule.create requires workflowScript. Use workflowScript: \"return runs.run('main', { agent, task })\"." };
+	if (typeof params.workflowScript !== "string" || !params.workflowScript.trim()) return { error: "schedule.create requires a non-empty workflowScript." };
 	if (params.context === "fork") return { error: "Scheduled runs require fresh context." };
 	if (params.async === false) return { error: "Scheduled runs are always async." };
-	if (params.clarify === true) return { error: "Scheduled runs cannot open clarify UI." };
 	const acceptanceErrors = validateExecutionAcceptance(params as Parameters<typeof validateExecutionAcceptance>[0]);
 	if (acceptanceErrors.length) return { error: acceptanceErrors.join(" ") };
-	return hasWorkflow ? { target: { workflowScript: params.workflowScript!.trim() } } : { target: { agent: params.agent!.trim(), ...(params.task === undefined ? {} : { task: params.task }) } };
+	return { target: { workflowScript: params.workflowScript.trim() } };
 }
 
 function executionParams(schedule: ScheduleRecord): SubagentParamsLike {
 	return {
 		...schedule.target,
 		async: true,
-		clarify: false,
 		context: "fresh",
 		cwd: schedule.cwd,
 		mission: false,
@@ -401,6 +406,29 @@ export class ScheduledRunManager {
 		}
 	}
 
+	observedCompletionRunIds(): Set<string> {
+		const runIds = new Set<string>();
+		for (const store of this.stores.values()) {
+			let ids: string[];
+			try {
+				ids = store.ids();
+			} catch (error) {
+				console.error(`Failed to inspect schedule store '${store.root}' during async completion discovery:`, error);
+				continue;
+			}
+			for (const id of ids) {
+				try {
+					for (const run of store.history(id)) {
+						if (run.state === "running" && run.asyncId) runIds.add(run.asyncId);
+					}
+				} catch (error) {
+					console.error(`Failed to inspect schedule '${id}' in '${store.root}' during async completion discovery:`, error);
+				}
+			}
+		}
+		return runIds;
+	}
+
 	handleAsyncCompletion(payload: unknown): void {
 		if (!payload || typeof payload !== "object") return;
 		const data = payload as { id?: unknown; runId?: unknown; success?: unknown; state?: unknown; summary?: unknown };