pi-subagents 0.45.2 → 0.46.0

package/src/runs/background/wait-subscriptions.ts

@@ -4,6 +4,7 @@ import { randomUUID } from "node:crypto";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { listAsyncRuns, type AsyncRunSummary } from "./async-status.ts";
 import { formatResumeFirstFailedRunDetail } from "./resume-guidance.ts";
+import { readCompletionReplay } from "./completion-replay.ts";
 import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import {
 	DIRS,
@@ -14,6 +15,7 @@ import {
 	SUBAGENT_FOREGROUND_COMPLETE_EVENT,
 	SUBAGENT_RESULT_INTERCOM_EVENT,
 	type SubagentState,
+	type WaitCompletion,
 	type WaitSubscriptionRecord,
 } from "../../shared/types.ts";
 
@@ -104,7 +106,7 @@ export function createWaitSubscriptionManager(
 		unresolvedRestoredForegroundTokens.delete(record.token);
 	};
 
-	const settle = (record: WaitSubscriptionRecord, outcome: string, detail: string) => {
+	const settle = (record: WaitSubscriptionRecord, outcome: string, detail: string, completion?: WaitCompletion) => {
 		if (disposed || state.currentSessionId !== record.sessionId) return;
 		try {
 			remove(record);
@@ -117,7 +119,12 @@ export function createWaitSubscriptionManager(
 				customType: "subagent-wait-subscription",
 				content: `Wait subscription ${record.token} fired for run ${record.runId}: ${outcome}. ${detail}`,
 				display: true,
-				details: { token: record.token, runId: record.runId, outcome },
+				details: {
+					token: record.token,
+					runId: record.runId,
+					outcome,
+					...(completion ? { completions: [completion] } : {}),
+				},
 			}, { triggerTurn: true });
 		} catch (error) {
 			console.error(`Failed to deliver wait subscription '${record.token}' after clearing it:`, error);
@@ -167,7 +174,15 @@ export function createWaitSubscriptionManager(
 			return;
 		}
 		if (run.state !== "queued" && run.state !== "running") {
-			settle(record, run.state === "complete" ? "completed" : run.state, formatResumeFirstFailedRunDetail(run) ?? "Inspect the run status for its final output.");
+			let completion: WaitCompletion | undefined;
+			try {
+				completion = readCompletionReplay(resultsDir, record.runId, { sessionId: record.sessionId, now: now() })?.completion;
+			} catch (error) {
+				console.error(`Failed to read completion replay for wait subscription '${record.token}':`, error);
+			}
+			const detail = formatResumeFirstFailedRunDetail(run) ?? "Inspect the run status for its final output.";
+			const archiveDetail = completion?.archivePath ? ` Completion archive: ${completion.archivePath}.` : "";
+			settle(record, run.state === "complete" ? "completed" : run.state, `${detail}${archiveDetail}`, completion);
 		}
 	};
 

package/src/runs/foreground/execution.ts

@@ -8,6 +8,7 @@ import * as path from "node:path";
 import type { Message } from "@earendil-works/pi-ai";
 import type { AgentConfig } from "../../agents/agents.ts";
 import { appendAgentRefinementOverlay } from "../../agents/agent-refinements.ts";
+import { alignForkedSessionCwd } from "../../shared/fork-context.ts";
 import {
 	ensureArtifactsDir,
 	formatOutputArtifactContent,
@@ -1416,6 +1417,9 @@ async function runSyncCompletion(
 	const acceptancePrompt = formatAcceptancePrompt(effectiveAcceptance, { reportOptional: isAgentContractV1(options.agentContract) });
 	const taskWithAcceptance = acceptancePrompt ? `${task}\n${acceptancePrompt}` : task;
 	const sessionEnabled = Boolean(options.sessionFile || options.sessionDir) || shareEnabled;
+	if (options.context === "fork" && options.sessionFile && existsSync(options.sessionFile)) {
+		alignForkedSessionCwd(options.sessionFile, options.cwd ?? runtimeCwd);
+	}
 	const skillNames = options.skills ?? agent.skills ?? [];
 	const skillCwd = options.cwd ?? runtimeCwd;
 	const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(

package/src/runs/foreground/foreground-history.ts

@@ -0,0 +1,137 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ForegroundResumeChild, ForegroundResumeRun, SubagentState } from "../../shared/types.ts";
+import { DIRS } from "../../shared/types.ts";
+import { writeAtomicJson } from "../../shared/atomic-json.ts";
+import { utf8Tail } from "../../shared/utf8.ts";
+
+export const MAX_REMEMBERED_FOREGROUND_RUNS = 50;
+const HISTORY_VERSION = 1;
+const MAX_INLINE_OUTPUT_BYTES = 64 * 1024;
+
+interface ForegroundHistoryIndex {
+	version: 1;
+	runs: ForegroundResumeRun[];
+}
+
+function historyPath(resultsDir: string): string {
+	return path.join(resultsDir, "foreground-history.json");
+}
+
+function boundedTail(value: string): string {
+	return utf8Tail(value, MAX_INLINE_OUTPUT_BYTES).text;
+}
+
+function compactChild(child: ForegroundResumeChild): ForegroundResumeChild {
+	const outputPath = child.artifactPaths?.outputPath ?? child.savedOutputPath;
+	return {
+		agent: child.agent,
+		index: child.index,
+		...(child.context ? { context: child.context } : {}),
+		...(child.sessionFile ? { sessionFile: child.sessionFile } : {}),
+		...(child.model ? { model: child.model } : {}),
+		...(child.thinking ? { thinking: child.thinking } : {}),
+		status: child.status,
+		...(child.activityState ? { activityState: child.activityState } : {}),
+		...(child.lastActivityAt !== undefined ? { lastActivityAt: child.lastActivityAt } : {}),
+		...(child.currentTool ? { currentTool: child.currentTool } : {}),
+		...(child.currentToolStartedAt !== undefined ? { currentToolStartedAt: child.currentToolStartedAt } : {}),
+		...(child.currentPath ? { currentPath: child.currentPath } : {}),
+		...(child.turnCount !== undefined ? { turnCount: child.turnCount } : {}),
+		...(child.tokens !== undefined ? { tokens: child.tokens } : {}),
+		...(child.toolCount !== undefined ? { toolCount: child.toolCount } : {}),
+		...(child.exitCode !== undefined ? { exitCode: child.exitCode } : {}),
+		...(child.error ? { error: child.error } : {}),
+		...(!outputPath && child.finalOutput ? { finalOutput: boundedTail(child.finalOutput) } : {}),
+		...(child.outputState ? { outputState: child.outputState } : {}),
+		...(child.outputMode ? { outputMode: child.outputMode } : {}),
+		...(child.savedOutputPath ? { savedOutputPath: child.savedOutputPath } : {}),
+		...(child.outputSaveError ? { outputSaveError: child.outputSaveError } : {}),
+		...(child.artifactPaths ? { artifactPaths: child.artifactPaths } : {}),
+		...(child.transcriptPath ? { transcriptPath: child.transcriptPath } : {}),
+		...(child.transcriptError ? { transcriptError: child.transcriptError } : {}),
+		...(child.acceptance ? { acceptance: child.acceptance } : {}),
+		...(child.launchContractDigest ? { launchContractDigest: child.launchContractDigest } : {}),
+		...(child.capabilityCeiling ? { capabilityCeiling: child.capabilityCeiling } : {}),
+		...(child.updatedAt !== undefined ? { updatedAt: child.updatedAt } : {}),
+	};
+}
+
+function isRestorableForegroundStatus(status: unknown): status is ForegroundResumeChild["status"] {
+	return status === "completed" || status === "failed" || status === "paused" || status === "stopped";
+}
+
+function compactRun(run: ForegroundResumeRun): ForegroundResumeRun | undefined {
+	if (!run.sessionId) return undefined;
+	if (run.children.length === 0 || !run.children.every((child) => isRestorableForegroundStatus(child.status))) return undefined;
+	return {
+		runId: run.runId,
+		mode: run.mode,
+		cwd: run.cwd,
+		sessionId: run.sessionId,
+		updatedAt: run.updatedAt,
+		children: run.children.map(compactChild),
+	};
+}
+
+function readIndex(resultsDir: string): ForegroundHistoryIndex {
+	const filePath = historyPath(resultsDir);
+	if (!fs.existsSync(filePath)) return { version: HISTORY_VERSION, runs: [] };
+	try {
+		const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8")) as unknown;
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return { version: HISTORY_VERSION, runs: [] };
+		const record = parsed as Partial<ForegroundHistoryIndex>;
+		if (record.version !== HISTORY_VERSION || !Array.isArray(record.runs)) return { version: HISTORY_VERSION, runs: [] };
+		return { version: HISTORY_VERSION, runs: record.runs.filter(isRestorableRun) };
+	} catch {
+		return { version: HISTORY_VERSION, runs: [] };
+	}
+}
+
+function isRestorableRun(value: unknown): value is ForegroundResumeRun {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const run = value as Partial<ForegroundResumeRun>;
+	return typeof run.runId === "string" && Boolean(run.runId)
+		&& (run.mode === "single" || run.mode === "parallel" || run.mode === "chain")
+		&& typeof run.cwd === "string" && Boolean(run.cwd)
+		&& typeof run.sessionId === "string" && Boolean(run.sessionId)
+		&& typeof run.updatedAt === "number" && Number.isFinite(run.updatedAt)
+		&& Array.isArray(run.children)
+		&& run.children.length > 0
+		&& run.children.every((child) => Boolean(child && typeof child === "object" && !Array.isArray(child)
+			&& typeof (child as Partial<ForegroundResumeChild>).agent === "string"
+			&& typeof (child as Partial<ForegroundResumeChild>).index === "number"
+			&& isRestorableForegroundStatus((child as Partial<ForegroundResumeChild>).status)));
+}
+
+function sortAndBound(runs: ForegroundResumeRun[], limit: number): ForegroundResumeRun[] {
+	return [...runs].sort((left, right) => right.updatedAt - left.updatedAt).slice(0, limit);
+}
+
+export function persistForegroundRunHistory(state: SubagentState, options: { resultsDir?: string; limit?: number } = {}): void {
+	const resultsDir = options.resultsDir ?? DIRS.results;
+	const limit = options.limit ?? MAX_REMEMBERED_FOREGROUND_RUNS;
+	const existing = readIndex(resultsDir);
+	const merged = new Map(existing.runs.map((run) => [run.runId, run]));
+	for (const run of state.foregroundRuns?.values() ?? []) {
+		const compact = compactRun(run);
+		if (compact) merged.set(compact.runId, compact);
+	}
+	const runs = sortAndBound([...merged.values()], limit);
+	writeAtomicJson(historyPath(resultsDir), { version: HISTORY_VERSION, runs });
+}
+
+export function restoreForegroundRunHistory(state: SubagentState, options: { resultsDir?: string; sessionId?: string | null; limit?: number } = {}): number {
+	const sessionId = options.sessionId ?? state.currentSessionId;
+	if (!sessionId) return 0;
+	const index = readIndex(options.resultsDir ?? DIRS.results);
+	const runs = sortAndBound(index.runs.filter((run) => run.sessionId === sessionId), options.limit ?? MAX_REMEMBERED_FOREGROUND_RUNS);
+	state.foregroundRuns ??= new Map();
+	let restored = 0;
+	for (const run of runs) {
+		if (state.foregroundRuns.has(run.runId)) continue;
+		state.foregroundRuns.set(run.runId, run);
+		restored += 1;
+	}
+	return restored;
+}