@selesai/code 0.13.40 → 0.14.3

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

@@ -1,4 +1,4 @@
-import { spawnSync } from "node:child_process";
+import { execFile } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -6,7 +6,10 @@ import { randomUUID } from "node:crypto";
 import { Worker } from "node:worker_threads";
 import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import type { AsyncStatus } from "../../shared/types.ts";
-import { MISSION_BINDING_FILE } from "../../missions/lifecycle.ts";
+import { readMissionBinding, type MissionLaunchBinding } from "../../missions/lifecycle.ts";
+import { MissionNotFoundError, readMission } from "../../missions/store.ts";
+import type { MissionStatus } from "../../missions/types.ts";
+import { REVIVAL_ORIGIN_FILE } from "../../workflows/workflow-revival.ts";
 import { ACTIVE_RUN_INDEX_DIR } from "./active-run-index.ts";
 import { encodeIndexSegment } from "./index-segment.ts";
 import { reconcileAsyncRun } from "./stale-run-reconciler.ts";
@@ -26,6 +29,8 @@ const RUN_TOMBSTONE_MARKERS_DIR = "async-retention-run-tombstones";
 const LOCK_STALE_MS = 24 * 60 * 60 * 1000;
 const RUN_MODES = new Set<AsyncStatus["mode"]>(["single", "parallel", "chain", "workflow"]);
 const TERMINAL_STATES = new Set<AsyncStatus["state"]>(["complete", "failed", "stopped", "rejected"]);
+// Mirrors TERMINAL_MISSION_STATUSES in src/missions/store.ts, which keeps it private.
+const TERMINAL_MISSION_STATUSES = new Set<MissionStatus>(["completed", "failed", "cancelled"]);
 const RESULT_TIMESTAMP_FIELDS = ["endedAt", "completedAt", "createdAt", "writtenAt", "expiresAt", "timestamp"] as const;
 
 interface RetentionCursor {
@@ -93,7 +98,7 @@ export interface AsyncRetentionOptions {
 	hostname?: string;
 	processStartIdentity?: string;
 	isProcessAlive?: (pid: number) => boolean | undefined;
-	getProcessStartIdentity?: (pid: number) => string | undefined;
+	getProcessStartIdentity?: (pid: number) => Promise<string | undefined>;
 	lstatSync?: typeof fs.lstatSync;
 	signal?: AbortSignal;
 	discoveryWorkerUrl?: URL;
@@ -210,6 +215,25 @@ function missionObserverIndexExists(resultsDir: string, runId: string): boolean
 	return fs.existsSync(path.join(resultsDir, "result-index", "observers", "mission", `${encodeIndexSegment(runId)}.json`));
 }
 
+// The retention window doubles as a terminal mission's grace period. Unreadable references and
+// pending syncs are kept because the watcher needs the run's binding to retry.
+function missionReferenceBlocksReclaim(runDir: string, resultsDir: string, runId: string): boolean {
+	if (missionObserverIndexExists(resultsDir, runId)) return true;
+	let binding: MissionLaunchBinding | undefined;
+	try {
+		binding = readMissionBinding(runDir);
+	} catch {
+		return true;
+	}
+	if (!binding) return false;
+	try {
+		const mission = readMission(binding.location, binding.missionId);
+		return !TERMINAL_MISSION_STATUSES.has(mission.status);
+	} catch (error) {
+		return !(error instanceof MissionNotFoundError);
+	}
+}
+
 function runTombstoneMarkerPath(maintenanceRoot: string, runId: string): string {
 	return path.join(maintenanceRoot, RUN_TOMBSTONE_MARKERS_DIR, `${encodeIndexSegment(runId)}.json`);
 }
@@ -294,8 +318,10 @@ function runSkipReason(input: {
 	if (activeMarkerExists(input.asyncDirRoot, status.runId)) return "active-index";
 	if (!TERMINAL_STATES.has(status.state)) return "non-terminal";
 	if (status.mode === "workflow" || status.parentWorkflowRunId || status.workflowKey) return "workflow-reference";
+	// A revived workflow child is a link in its key's revival chain; deleting it would cut off later revivals.
+	if (fs.existsSync(path.join(runDir, REVIVAL_ORIGIN_FILE))) return "workflow-reference";
 	if (hasNestedReferences(status)) return "nested-reference";
-	if (fs.existsSync(path.join(runDir, MISSION_BINDING_FILE)) || missionObserverIndexExists(input.resultsDir, status.runId)) return "mission-reference";
+	if (missionReferenceBlocksReclaim(runDir, input.resultsDir, status.runId)) return "mission-reference";
 	if (hasUnresolvedRunHandoff(runDir, status)) return "handoff-reference";
 	if (hasResumableContract(runDir, status)) return "resumable";
 	const timestamp = statusTimestamp(status, runDir);
@@ -320,16 +346,16 @@ function readCursor(root: string): RetentionCursor {
 	return value?.version === 1 ? value as unknown as RetentionCursor : { version: 1 };
 }
 
-let currentProcessStartIdentity: string | undefined | null = null;
+let currentProcessStartIdentity: Promise<string | undefined> | undefined;
 
-function processStartIdentity(pid: number): string | undefined {
+function processStartIdentity(pid: number): Promise<string | undefined> {
 	// Foreign PIDs can be reused while this process lives, so resolve them afresh.
 	if (pid !== process.pid) return computeProcessStartIdentity(pid);
-	if (currentProcessStartIdentity === null) currentProcessStartIdentity = computeProcessStartIdentity(pid);
+	currentProcessStartIdentity ??= computeProcessStartIdentity(pid);
 	return currentProcessStartIdentity;
 }
 
-function computeProcessStartIdentity(pid: number): string | undefined {
+async function computeProcessStartIdentity(pid: number): Promise<string | undefined> {
 	if (process.platform === "linux") {
 		try {
 			const stat = fs.readFileSync(`/proc/${pid}/stat`).toString("utf8");
@@ -342,8 +368,12 @@ function computeProcessStartIdentity(pid: number): string | undefined {
 		}
 	}
 	if (process.platform === "win32") {
-		const result = spawnSync("powershell.exe", ["-NoProfile", "-Command", `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").CreationDate`], { encoding: "utf-8", windowsHide: true });
-		const started = result.status === 0 ? result.stdout.trim() : "";
+		// PowerShell takes ~0.5 s to start; a synchronous spawn would freeze the TUI.
+		const started = await new Promise<string>((resolve) => {
+			execFile("powershell.exe", ["-NoProfile", "-Command", `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").CreationDate`], { encoding: "utf-8", windowsHide: true, timeout: 5_000 }, (error, stdout) => {
+				resolve(error ? "" : stdout.trim());
+			});
+		});
 		return started ? `win:${started}` : undefined;
 	}
 	return undefined;
@@ -375,7 +405,7 @@ function parseLockOwner(lockDir: string): RetentionLockOwner | undefined {
 	return owner as unknown as RetentionLockOwner;
 }
 
-function staleLock(lockDir: string, now: number, options: Required<Pick<AsyncRetentionOptions, "hostname" | "isProcessAlive" | "getProcessStartIdentity">>): { stale: boolean; token?: string } {
+async function staleLock(lockDir: string, now: number, options: Required<Pick<AsyncRetentionOptions, "hostname" | "isProcessAlive" | "getProcessStartIdentity">>): Promise<{ stale: boolean; token?: string }> {
 	const owner = parseLockOwner(lockDir);
 	if (!owner) {
 		try {
@@ -388,7 +418,7 @@ function staleLock(lockDir: string, now: number, options: Required<Pick<AsyncRet
 	const alive = options.isProcessAlive(owner.pid);
 	if (alive === false) return { stale: true, token: owner.token };
 	if (alive === true && owner.processStartIdentity) {
-		const currentIdentity = options.getProcessStartIdentity(owner.pid);
+		const currentIdentity = await options.getProcessStartIdentity(owner.pid);
 		if (currentIdentity !== undefined && currentIdentity !== owner.processStartIdentity) return { stale: true, token: owner.token };
 	}
 	return { stale: now - owner.startedAt >= LOCK_STALE_MS, token: owner.token };
@@ -410,10 +440,10 @@ function createLockDirectory(lockDir: string, owner: RetentionLockOwner): boolea
 	}
 }
 
-function acquireRetentionLock(lockDir: string, owner: RetentionLockOwner, options: Required<Pick<AsyncRetentionOptions, "hostname" | "isProcessAlive" | "getProcessStartIdentity">>): boolean {
+async function acquireRetentionLock(lockDir: string, owner: RetentionLockOwner, options: Required<Pick<AsyncRetentionOptions, "hostname" | "isProcessAlive" | "getProcessStartIdentity">>): Promise<boolean> {
 	for (let attempt = 0; attempt < 4; attempt += 1) {
 		if (createLockDirectory(lockDir, owner)) return true;
-		const stale = staleLock(lockDir, owner.startedAt, options);
+		const stale = await staleLock(lockDir, owner.startedAt, options);
 		if (!stale.stale) return false;
 		const staleKey = (stale.token ?? owner.token).replace(/[^A-Za-z0-9._-]/g, "-");
 		const tombstone = `${lockDir}.stale-${staleKey}`;
@@ -661,7 +691,7 @@ export async function cleanupAsyncRetention(options: AsyncRetentionOptions): Pro
 	const pid = options.pid ?? process.pid;
 	const hostname = options.hostname ?? os.hostname();
 	const getProcessStartIdentity = options.getProcessStartIdentity ?? processStartIdentity;
-	const currentProcessStartIdentity = options.processStartIdentity ?? getProcessStartIdentity(pid) ?? (pid === process.pid ? `runtime:${Math.round(Date.now() - process.uptime() * 1000)}` : undefined);
+	const currentProcessStartIdentity = options.processStartIdentity ?? await getProcessStartIdentity(pid) ?? (pid === process.pid ? `runtime:${Math.round(Date.now() - process.uptime() * 1000)}` : undefined);
 	const lockOwner: RetentionLockOwner = { version: 1, token: lockToken, pid, hostname, startedAt: currentTime, ...(currentProcessStartIdentity ? { processStartIdentity: currentProcessStartIdentity } : {}) };
 	const lockOptions = { hostname, isProcessAlive: options.isProcessAlive ?? processIsAlive, getProcessStartIdentity };
 	const result: AsyncRetentionResult = {
@@ -698,7 +728,7 @@ export async function cleanupAsyncRetention(options: AsyncRetentionOptions): Pro
 		return true;
 	};
 	fs.mkdirSync(maintenanceRoot, { recursive: true });
-	if (!acquireRetentionLock(lockDir, lockOwner, lockOptions)) {
+	if (!await acquireRetentionLock(lockDir, lockOwner, lockOptions)) {
 		increment(result.skipped, "lock-busy");
 		return finish();
 	}
@@ -909,4 +939,4 @@ export async function cleanupAsyncRetention(options: AsyncRetentionOptions): Pro
 	} finally {
 		try { releaseRetentionLock(lockDir, lockToken); } catch { /* a stale lock blocks the next pass safely */ }
 	}
-}
+}

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

@@ -26,6 +26,7 @@ import { workflowGraphStageNodes } from "../shared/workflow-graph.ts";
 import { formatTimeoutRecoveryLines, projectTimeoutRecovery } from "../shared/mutation-evidence.ts";
 import { formatWorkflowChecklistText, projectWorkflowChecklist } from "../../workflows/workflow-checklist.ts";
 import type { RawDrainStatusObserver } from "../shared/readonly-drain-observation.ts";
+import { childWatchdogProgressForModel } from "../../watchdog/child-status.ts";
 
 interface AsyncRunStepSummary {
 	index: number;
@@ -48,6 +49,7 @@ interface AsyncRunStepSummary {
 	structured?: boolean;
 	status: AsyncJobStep["status"];
 	runner?: AsyncJobStep["runner"];
+	externalProcess?: AsyncJobStep["externalProcess"];
 	activityState?: ActivityState;
 	lastActivityAt?: number;
 	currentTool?: string;
@@ -66,7 +68,7 @@ interface AsyncRunStepSummary {
 	model?: string;
 	contextLimit?: number;
 	thinking?: string;
-	attemptedModels?: string[];
+	requestedModel?: string;
 	sessionFile?: string;
 	transcriptPath?: string;
 	error?: string;
@@ -348,6 +350,7 @@ function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string
 			...(step.structured ? { structured: step.structured } : {}),
 			status: step.status,
 			...(step.runner ? { runner: step.runner } : {}),
+			...(step.externalProcess ? { externalProcess: step.externalProcess } : {}),
 			...(stepActivityState ? { activityState: stepActivityState } : {}),
 			...(stepLastActivityAt ? { lastActivityAt: stepLastActivityAt } : {}),
 			...(step.currentTool ? { currentTool: step.currentTool } : {}),
@@ -367,7 +370,7 @@ function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string
 			...(step.contextLimit !== undefined ? { contextLimit: step.contextLimit } : {}),
 			...(step.thinking ? { thinking: step.thinking } : {}),
 			...(step.thinkingCeiling ? { thinkingCeiling: step.thinkingCeiling } : {}),
-			...(step.attemptedModels ? { attemptedModels: step.attemptedModels } : {}),
+			...(step.requestedModel ? { requestedModel: step.requestedModel } : {}),
 			...(step.sessionFile ? { sessionFile: step.sessionFile } : {}),
 			...(step.transcriptPath ? { transcriptPath: step.transcriptPath } : {}),
 			...(step.error ? { error: step.error } : {}),
@@ -387,7 +390,7 @@ function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string
 			...(step.execution ? { execution: step.execution } : {}),
 			...(step.review ? { review: step.review } : {}),
 			...(step.effects ? { effects: step.effects } : {}),
-			...(step.watchdog ? { watchdog: step.watchdog } : {}),
+			...(step.watchdog ? { watchdog: childWatchdogProgressForModel(step.watchdog) } : {}),
 			...(step.processTerminal ? { processTerminal: sanitizeProcessTerminal(step.processTerminal, { runId: status.runId, runnerProcessInstanceId: step.processTerminal.runnerProcessInstanceId }, `${path.join(asyncDir, "status.json")} step ${index}`) } : {}),
 			...(timeoutRecovery ? { timeoutRecovery } : {}),
 			...(step.capabilityCeiling ? { capabilityCeiling: step.capabilityCeiling } : {}),
@@ -545,6 +548,14 @@ export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions
 		const asyncDir = path.join(asyncDirRoot, entry);
 		let status: (AsyncStatus & { cwd?: string }) | null;
 		try {
+			// Reconciliation can rewrite state; session-scoped discovery does not own foreign runs.
+			if (options.sessionId !== undefined) {
+				const stored = readStatus(asyncDir);
+				if (stored && stored.sessionId !== options.sessionId) {
+					observeStatus?.(stored);
+					continue;
+				}
+			}
 			const reconciliation = options.reconcile === false
 				? undefined
 				: reconcileAsyncRun(asyncDir, { resultsDir: options.resultsDir, kill: options.kill, now: options.now }, observeStatus);
@@ -567,7 +578,9 @@ export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions
 		}
 		if (activeEntries.has(entry) && !isActiveAsyncState(status.state)) {
 			const processTerminal = readProcessTerminal(asyncDir, { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId });
-			if (processTerminal?.state === "observed" || (activeRunMarkerAgeMs(asyncDir, options.now?.()) ?? 0) > DEFAULT_STALE_TERMINAL_ACTIVE_MARKER_MS) releaseActiveRunIndex(asyncDir);
+			if (processTerminal?.state === "observed" || (activeRunMarkerAgeMs(asyncDir, options.now?.()) ?? 0) > DEFAULT_STALE_TERMINAL_ACTIVE_MARKER_MS) {
+				updateActiveRunIndex(asyncDir, status.state, status.toolCallId, { terminalIndexBeforeRelease: true });
+			}
 		}
 		if (status.displayDismissedAt !== undefined) continue;
 		// Filter before the nested-route lookup: the lookup builds an index over
@@ -761,4 +774,4 @@ export function formatAsyncRunList(runs: AsyncRunSummary[], heading = "Active as
 		lines.push("");
 	}
 	return lines.join("\n").trimEnd();
-}
+}

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

@@ -1,13 +1,13 @@
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import { snapshotBackgroundWork } from "../../api/background-work.ts";
-import { DIRS, type Details, type SubagentState } from "../../shared/types.ts";
+import type { Details, SubagentState } from "../../shared/types.ts";
 import { listAsyncRuns } from "./async-status.ts";
 import type { ReadonlyDrainObservation } from "../shared/readonly-drain-observation.ts";
-import { waitForSubagents, type SubagentWaitDeps, type SubagentWaitParams, type WaitEventBus } from "./subagent-wait.ts";
+import { waitForSubagents, waitRunScopes, type SubagentWaitDeps, type SubagentWaitParams, type WaitEventBus } from "./subagent-wait.ts";
 
 export const DEFAULT_AUTO_DRAIN_TIMEOUT_MS = 30 * 60 * 1000;
 
-export interface AutoDrainDeps {
+export interface AutoDrainDeps extends Pick<SubagentWaitDeps, "asyncDirRoot" | "resultsDir" | "nestedRootRunId"> {
 	state: SubagentState;
 	events?: WaitEventBus;
 	timeoutMs?: number;
@@ -18,36 +18,43 @@ export interface AutoDrainDeps {
 		deps: SubagentWaitDeps,
 	) => Promise<AgentToolResult<Details>>;
 	hasWork?: (sessionId: string, nowMs: number) => boolean;
+	hasPendingSupervisorRequest?: () => boolean;
 }
 
 function resultText(value: AgentToolResult<Details>): string {
 	return value.content.map((part) => part.type === "text" ? part.text : "").join(" ").trim();
 }
 
-function hasOutstandingWork(sessionId: string, nowMs: number, observation?: ReadonlyDrainObservation): boolean {
-	const asyncRuns = listAsyncRuns(DIRS.async, {
+function hasOutstandingWork(deps: AutoDrainDeps, sessionId: string, nowMs: number, observation?: ReadonlyDrainObservation): boolean {
+	const asyncRuns = waitRunScopes(deps).flatMap(({ asyncDirRoot, resultsDir }) => listAsyncRuns(asyncDirRoot, {
 		states: ["queued", "running"],
 		sessionId,
-		resultsDir: DIRS.results,
+		resultsDir,
 		now: () => nowMs,
-	}, observation?.status);
-	return asyncRuns.length > 0 || snapshotBackgroundWork(sessionId, nowMs).items.length > 0;
+		includeNested: false,
+	}, observation?.status));
+	const detachedForeground = [...(deps.state.foregroundRuns?.values() ?? [])].some((run) =>
+		run.sessionId === sessionId && run.children.some((child) => child.status === "detached")
+	);
+	return asyncRuns.length > 0 || snapshotBackgroundWork(sessionId, nowMs).items.length > 0 || detachedForeground;
 }
 
 /** Drain all work owned by the current headless session, including work added while draining. */
 export async function drainOutstandingWork(deps: AutoDrainDeps, observation?: ReadonlyDrainObservation): Promise<void> {
 	const sessionId = deps.state.currentSessionId;
-	observation?.begin(sessionId, !deps.hasWork && !deps.wait && !deps.now);
+	observation?.begin(sessionId, !deps.hasWork && !deps.wait && !deps.now && !deps.hasPendingSupervisorRequest);
 	try {
 		if (!sessionId) throw new Error("Cannot auto-drain background work without an active session identity.");
 		const now = deps.now ?? Date.now;
 		const timeoutMs = deps.timeoutMs ?? DEFAULT_AUTO_DRAIN_TIMEOUT_MS;
 		if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new Error("Auto-drain timeoutMs must be a positive finite number.");
 		const deadlineAt = now() + timeoutMs;
-		const hasWork = deps.hasWork ?? (observation ? (id: string, time: number) => hasOutstandingWork(id, time, observation) : hasOutstandingWork);
+		const hasWork = deps.hasWork ?? ((id: string, time: number) => hasOutstandingWork(deps, id, time, observation));
 		const wait = deps.wait ?? waitForSubagents;
 
 		while (true) {
+			if (deps.state.currentSessionId !== sessionId) throw new Error("Auto-drain stopped because the active session changed.");
+			if (deps.hasPendingSupervisorRequest?.()) break;
 			const work = hasWork(sessionId, now());
 			observation?.predicate(work);
 			if (!work) break;
@@ -60,20 +67,26 @@ export async function drainOutstandingWork(deps: AutoDrainDeps, observation?: Re
 				undefined,
 				{
 					state: deps.state,
+					asyncDirRoot: deps.asyncDirRoot,
+					resultsDir: deps.resultsDir,
+					nestedRootRunId: deps.nestedRootRunId,
 					events: deps.events,
 					now,
 					stopOnAttention: false,
 					failOnFailedRuns: true,
 					failOnAttention: true,
+					hasPendingSupervisorRequest: deps.hasPendingSupervisorRequest,
 				},
 			);
 			if (waitResult.isError) {
 				throw new Error(`Auto-drain failed for session '${sessionId}': ${resultText(waitResult) || "bg_wait returned an error without details"}.`);
 			}
+			if (waitResult.details.wait?.reason === "supervisor_request") break;
+			if (deps.hasPendingSupervisorRequest?.()) break;
 		}
 		observation?.complete();
 	} catch (error) {
 		observation?.deny();
 		throw error;
 	}
-}
+}

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

@@ -0,0 +1,78 @@
+import * as fs from "node:fs";
+import { readStatus } from "../../shared/utils.ts";
+import { workflowAwaitedAsyncResultPath } from "./async-execution.ts";
+import { waitForImportedAsyncRoot, type ImportedAsyncRootResult } from "./chain-root-attachment.ts";
+import { currentPidNamespaceScope } from "./pid-namespace.ts";
+import { resultPayloadPathForSessionRun } from "./result-files.ts";
+import { checkPidLiveness } from "./stale-run-reconciler.ts";
+
+type ExistingAsyncRunOutcome =
+	| { status: "settled"; result: ImportedAsyncRootResult }
+	| { status: "unavailable"; reason: string };
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+/** Read-only probe: the runner is gone while status still says it is active and no result was published. */
+function runnerExitedWithoutResult(asyncDir: string, runId: string, resultPath: string): boolean {
+	const status = readStatus(asyncDir);
+	if (!status || (status.state !== "running" && status.state !== "queued") || typeof status.pid !== "number") return false;
+	const observedScope = currentPidNamespaceScope();
+	if (status.pidNamespaceScope !== undefined && status.pidNamespaceScope !== observedScope) return false;
+	const pidScopeVerified = status.pidNamespaceScope !== undefined && status.pidNamespaceScope === observedScope;
+	if (checkPidLiveness(status.pid, undefined, pidScopeVerified) !== "dead") return false;
+	return !fs.existsSync(resultPath) && !(status.sessionId && resultPayloadPathForSessionRun(asyncDir, status.sessionId, runId));
+}
+
+/**
+ * Waits for an existing workflow-awaited async child, identified by its async
+ * directory and exact run id, and returns its published result without
+ * launching, consuming, or rewriting anything. Anything short of a published
+ * result file for that exact run is `unavailable`. Rejects with the signal's
+ * reason when aborted.
+ */
+export async function awaitExistingAsyncRun(asyncDir: string, runId: string, signal: AbortSignal): Promise<ExistingAsyncRunOutcome> {
+	signal.throwIfAborted();
+	let status: ReturnType<typeof readStatus>;
+	try {
+		status = readStatus(asyncDir);
+	} catch (error) {
+		return { status: "unavailable", reason: `Async status for run '${runId}' is unreadable: ${errorMessage(error)}` };
+	}
+	if (!status) return { status: "unavailable", reason: `No async status exists for run '${runId}' at ${asyncDir}.` };
+	if (status.runId !== runId) return { status: "unavailable", reason: `Async status at ${asyncDir} belongs to run '${status.runId}', not '${runId}'.` };
+	// The launcher's initial status has no workflow identity until the runner starts, so only the
+	// mode is checked here; a run that does not publish to the workflow result path stays unavailable.
+	if (status.mode !== "single") return { status: "unavailable", reason: `Async run '${runId}' is not a single-agent run.` };
+	const resultPath = workflowAwaitedAsyncResultPath(asyncDir);
+	let runnerExited = false;
+	let completed: ImportedAsyncRootResult;
+	try {
+		completed = await waitForImportedAsyncRoot({ runId, asyncDir, resultPath, index: 0 }, {
+			shouldAbort: () => signal.aborted || (runnerExited = runnerExitedWithoutResult(asyncDir, runId, resultPath)),
+		});
+	} catch (error) {
+		signal.throwIfAborted();
+		return { status: "unavailable", reason: `Could not await async run '${runId}': ${errorMessage(error)}` };
+	}
+	signal.throwIfAborted();
+	if (runnerExited) return { status: "unavailable", reason: `Async runner for run '${runId}' exited without publishing a result.` };
+	// Only a parsed result file carries importedPublication; status-derived fallbacks do not.
+	if (!completed.importedPublication) return { status: "unavailable", reason: `Async run '${runId}' ended without a result file at ${resultPath}.` };
+	return { status: "settled", result: completed };
+}
+
+/**
+ * Renames the published result to a file owned by `claimant`. Only one of several
+ * concurrent importers can win the rename; the others get undefined and launch fresh.
+ */
+export function claimWorkflowAwaitedResult(asyncDir: string, claimant: string): string | undefined {
+	const claimedPath = `${workflowAwaitedAsyncResultPath(asyncDir)}.${claimant}.claimed`;
+	try {
+		fs.renameSync(workflowAwaitedAsyncResultPath(asyncDir), claimedPath);
+		return claimedPath;
+	} catch {
+		return undefined;
+	}
+}

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

@@ -0,0 +1,66 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createJiti } from "jiti";
+import * as piCore from "@earendil-works/pi-agent-core";
+import * as piAi from "@earendil-works/pi-ai/compat";
+import * as piTui from "@earendil-works/pi-tui";
+import * as sdk from "@selesai/code";
+import * as typebox from "typebox";
+import * as typeboxCompile from "typebox/compile";
+import * as typeboxValue from "typebox/value";
+import { installRunnerHttpDispatcher } from "./runner-http-dispatcher.ts";
+import { runConfiguredSubagent, validateSubagentRunConfig } from "./subagent-runner-bootstrap.ts";
+import { getAgentDir } from "../../shared/utils.ts";
+
+/**
+ * Pi's extension loader supplies the embedded SDK. Bare Bun/Node cannot replace
+ * it: an apparent import success can be an auto-installed, different SDK.
+ * Await the configured runner inside extension initialization so the outer Pi
+ * session/RPC loop never starts. Exit only after shared disposal/lease release.
+ * Derived from xz-dev's PR #2049, commit 910807bfefcf9ee41d73fa25ec86dcd75ab8f4b2.
+ */
+export default async function runBinaryBootstrap(): Promise<never> {
+	const configPath = process.env.SELESAI_SUBAGENT_RUNNER_CONFIG;
+	delete process.env.SELESAI_SUBAGENT_RUNNER_CONFIG;
+	try {
+		if (!configPath || !path.isAbsolute(configPath)) throw new Error("Missing absolute SELESAI_SUBAGENT_RUNNER_CONFIG path");
+		const rawConfig: unknown = JSON.parse(fs.readFileSync(configPath, "utf8"));
+		validateSubagentRunConfig(rawConfig);
+		const config = rawConfig;
+		try {
+			fs.unlinkSync(configPath);
+		} catch {
+			// Temp-config cleanup is best effort, as in the Node entrypoint.
+		}
+		// Pi applies httpIdleTimeoutMs to its dispatcher only after extension
+		// factories return; this factory never does, so install the runner's own.
+		installRunnerHttpDispatcher({ agentDir: getAgentDir(), cwd: process.cwd() });
+		await runConfiguredSubagent(config, {
+			loadPiCodingAgent: async () => sdk,
+			loadExecutionModule: async () => {
+				// Native Bun imports bypass Pi's Jiti virtual peers in the compiled host.
+				const jiti = createJiti(import.meta.url, {
+					tryNative: false,
+					moduleCache: false,
+					virtualModules: {
+						"@earendil-works/pi-agent-core": piCore,
+						"@earendil-works/pi-ai": piAi,
+						"@earendil-works/pi-ai/compat": piAi,
+						"@earendil-works/pi-tui": piTui,
+						"@selesai/code": sdk,
+						typebox,
+						"typebox/compile": typeboxCompile,
+						"typebox/value": typeboxValue,
+					},
+				});
+				const runner = `./subagent-runner${path.extname(fileURLToPath(import.meta.url))}`;
+				return jiti.import<typeof import("./subagent-runner.ts")>(runner);
+			},
+		});
+		process.exit(0);
+	} catch (error) {
+		console.error("Subagent binary runner error:", error);
+		process.exit(1);
+	}
+}

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

@@ -0,0 +1,90 @@
+import { createRequire } from "node:module";
+import type { Temporal } from "@js-temporal/polyfill";
+
+const require = createRequire(import.meta.url);
+let cachedTemporal: typeof Temporal | undefined;
+
+function getTemporal(): typeof Temporal {
+	return cachedTemporal ??= (require("@js-temporal/polyfill") as typeof import("@js-temporal/polyfill")).Temporal;
+}
+
+export const CALENDAR_WEEKDAYS = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"] as const;
+export type CalendarWeekday = typeof CALENDAR_WEEKDAYS[number];
+export type CalendarRule = { every: "day" | "week"; at: string; timezone: string; on?: CalendarWeekday[] };
+export type CalendarOccurrence = { nextLocalDate: string; nextRunAt: string };
+export type CalendarTrigger = CalendarRule & CalendarOccurrence & { kind: "calendar" };
+const SEARCH_DAYS = 32;
+
+export function normalizeCalendarRule(input: { every?: unknown; at?: unknown; timezone?: unknown; on?: unknown }): CalendarRule {
+	if (input.every !== "day" && input.every !== "week") throw new Error("Calendar every must be 'day' or 'week'.");
+	if (typeof input.at !== "string" || !/^(?:[01]\d|2[0-3]):[0-5]\d$/.test(input.at)) throw new Error("Calendar at must use HH:mm (00:00-23:59).");
+	if (typeof input.timezone !== "string" || !input.timezone.trim() || /^[+-]/.test(input.timezone.trim())) throw new Error("Calendar timezone requires an IANA name, such as 'Asia/Taipei', or 'UTC'.");
+	let timezone: string;
+	try { timezone = new Intl.DateTimeFormat("en", { timeZone: input.timezone.trim() }).resolvedOptions().timeZone; }
+	catch { throw new Error(`Invalid calendar timezone '${input.timezone}'. Use an IANA name or 'UTC'.`); }
+	if (input.every === "day") {
+		if (input.on !== undefined) throw new Error("Daily schedules do not accept on; use every:'week' with a weekday array.");
+		return { every: "day", at: input.at, timezone };
+	}
+	if (!Array.isArray(input.on) || input.on.length === 0 || input.on.some((day) => !CALENDAR_WEEKDAYS.includes(day))) throw new Error("Weekly on must be a non-empty array of mon/tue/wed/thu/fri/sat/sun.");
+	const selected = input.on;
+	return { every: "week", at: input.at, timezone, on: CALENDAR_WEEKDAYS.filter((day) => selected.includes(day)) };
+}
+
+function localDate(value: string): Temporal.PlainDate {
+	if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) throw new Error("Calendar nextLocalDate must use YYYY-MM-DD.");
+	return getTemporal().PlainDate.from(value, { overflow: "reject" });
+}
+
+function referenceDate(rule: CalendarRule, reference: number): Temporal.PlainDate {
+	return getTemporal().Instant.fromEpochMilliseconds(reference).toZonedDateTimeISO(rule.timezone).toPlainDate();
+}
+
+function occurrence(rule: CalendarRule, date: Temporal.PlainDate): CalendarOccurrence | undefined {
+	if (rule.every === "week" && !rule.on!.includes(CALENDAR_WEEKDAYS[date.dayOfWeek - 1]!)) return undefined;
+	const requested = date.toPlainDateTime(rule.at);
+	const zoned = requested.toZonedDateTime(rule.timezone, { disambiguation: "earlier" });
+	// Skip nonexistent times/dates. A repeated time uses its first instant only.
+	if (!zoned.toPlainDateTime().equals(requested)) return undefined;
+	return { nextLocalDate: date.toString(), nextRunAt: new Date(zoned.epochMilliseconds).toISOString() };
+}
+
+export function nextCalendarOccurrence(rule: CalendarRule, after: number, minimumDate?: string): CalendarOccurrence {
+	let date = referenceDate(rule, after);
+	if (minimumDate && getTemporal().PlainDate.compare(date, localDate(minimumDate)) < 0) date = localDate(minimumDate);
+	for (let i = 0; i < SEARCH_DAYS; i++, date = date.add({ days: 1 })) {
+		const candidate = occurrence(rule, date);
+		if (candidate && Date.parse(candidate.nextRunAt) > after) return candidate;
+	}
+	throw new Error("No valid calendar occurrence within 32 local dates; check the timezone and rule.");
+}
+
+export function latestCalendarOccurrence(rule: CalendarRule, now: number, minimumDate: string): CalendarOccurrence | undefined {
+	const floor = localDate(minimumDate);
+	let date = referenceDate(rule, now);
+	for (let i = 0; i < SEARCH_DAYS; i++, date = date.subtract({ days: 1 })) {
+		if (getTemporal().PlainDate.compare(date, floor) < 0) return undefined;
+		const candidate = occurrence(rule, date);
+		if (candidate && Date.parse(candidate.nextRunAt) <= now) return candidate;
+	}
+	throw new Error("No valid calendar occurrence within 32 local dates; check the timezone and rule.");
+}
+
+export function calendarDateAfter(rule: CalendarRule, consumedAt: number, pendingDate: string): string {
+	const consumed = referenceDate(rule, consumedAt);
+	const pending = localDate(pendingDate);
+	return (getTemporal().PlainDate.compare(consumed, pending) > 0 ? consumed : pending).add({ days: 1 }).toString();
+}
+
+/** Re-resolve the pending date using current timezone data, without consulting its UTC cache. */
+export function restoreCalendarTrigger(input: CalendarTrigger): CalendarTrigger {
+	const rule = normalizeCalendarRule(input);
+	let date = localDate(input.nextLocalDate);
+	if (rule.every === "week" && !rule.on!.includes(CALENDAR_WEEKDAYS[date.dayOfWeek - 1]!)) throw new Error("Calendar nextLocalDate is outside the selected weekdays.");
+	if (typeof input.nextRunAt !== "string" || !Number.isFinite(Date.parse(input.nextRunAt))) throw new Error("Calendar nextRunAt must be a valid timestamp.");
+	for (let i = 0; i < SEARCH_DAYS; i++, date = date.add({ days: 1 })) {
+		const candidate = occurrence(rule, date);
+		if (candidate) return { kind: "calendar", ...rule, ...candidate };
+	}
+	throw new Error("No valid pending calendar occurrence within 32 local dates.");
+}

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

@@ -177,7 +177,7 @@ function statusStepForTask(task: RunnerSubagentStep): StatusStep {
 		model: task.model,
 		...(task.contextLimit !== undefined ? { contextLimit: task.contextLimit } : {}),
 		thinking: task.thinking,
-		attemptedModels: task.modelCandidates && task.modelCandidates.length > 0 ? task.modelCandidates : task.model ? [task.model] : undefined,
+		requestedModel: task.requestedModel,
 		recentTools: [],
 		recentOutput: [],
 	};
@@ -318,4 +318,4 @@ export function appendRunnerStepsToStatus(input: {
 	input.status.pendingAppends = input.pendingAppends ?? 0;
 	input.status.lastUpdate = input.now ?? Date.now();
 	return { addedChainSteps, addedFlatSteps };
-}
+}