@selesai/code 0.8.3 → 0.8.5

package/dist/extensions/pi-subagents/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;
+}

package/dist/extensions/pi-subagents/src/runs/foreground/prompt-audit.ts

@@ -0,0 +1,171 @@
+import { Agent, type StreamFn, type ThinkingLevel } from "@earendil-works/pi-agent-core";
+import { convertToLlm, type ExtensionContext } from "@selesai/code";
+import { streamSimple } from "@earendil-works/pi-ai/compat";
+import type { Model } from "@earendil-works/pi-ai";
+import type { ForegroundRunControl } from "../../shared/types.ts";
+export type PromptAuditView = "authored" | "runtime" | "effective";
+
+export interface PromptAuditRerunContract {
+	params: Record<string, unknown>;
+}
+
+export interface LivePromptAudit {
+	authoredTask: string;
+	runtimeAdditions: string;
+	finalEffectivePrompt: string;
+	cwd?: string;
+	outputPath?: string;
+	rerun?: PromptAuditRerunContract;
+}
+
+const livePrompts = new WeakMap<ForegroundRunControl, Map<number, LivePromptAudit>>();
+
+type RegistryModel = Model<any>;
+
+function fullModelId(model: Pick<RegistryModel, "provider" | "id">): string {
+	return `${model.provider}/${model.id}`;
+}
+
+function textContent(value: unknown): string {
+	if (typeof value === "string") return value;
+	if (!Array.isArray(value)) return "";
+	return value.map((item) => item && typeof item === "object" && (item as { type?: unknown }).type === "text" ? String((item as { text?: unknown }).text ?? "") : "").join("");
+}
+
+function finalAssistantText(agent: Agent): string {
+	for (let index = agent.state.messages.length - 1; index >= 0; index--) {
+		const message = agent.state.messages[index];
+		if (message && typeof message === "object" && (message as { role?: unknown }).role === "assistant") {
+			return textContent((message as { content?: unknown }).content).trim();
+		}
+	}
+	return "";
+}
+
+async function resolveRewriteAuth(ctx: ExtensionContext, model: RegistryModel): Promise<{ apiKey?: string; headers?: Record<string, string>; env?: Record<string, string> }> {
+	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+	if (auth.ok === false) throw new Error(`Prompt redo model auth failed for ${fullModelId(model)}: ${auth.error}`);
+	return {
+		...(auth.apiKey ? { apiKey: auth.apiKey } : {}),
+		...(auth.headers ? { headers: auth.headers } : {}),
+		...(auth.env ? { env: auth.env } : {}),
+	};
+}
+
+export async function rewritePromptWithGuidance(input: {
+	ctx: ExtensionContext;
+	authoredTask: string;
+	runtimeAdditions: string;
+	finalEffectivePrompt: string;
+	guidance: string;
+	signal?: AbortSignal;
+	streamFn?: StreamFn;
+}): Promise<string> {
+	const model = input.ctx.model;
+	if (!model) throw new Error("Prompt redo needs the current session model to rewrite the authored task.");
+	const auth = await resolveRewriteAuth(input.ctx, model);
+	const registeredProvider = (input.ctx.modelRegistry as {
+		getRegisteredProviderConfig?: (provider: string) => { api?: string; streamSimple?: StreamFn } | undefined;
+	}).getRegisteredProviderConfig?.(model.provider);
+	const baseStreamFn = input.streamFn ?? (registeredProvider?.streamSimple && registeredProvider.api === model.api
+		? registeredProvider.streamSimple
+		: streamSimple);
+	const streamFn: StreamFn = (nextModel, context, streamOptions) => baseStreamFn(nextModel, context, {
+		...streamOptions,
+		...(auth.apiKey ? { apiKey: auth.apiKey } : {}),
+		env: auth.env || streamOptions?.env ? { ...(auth.env ?? {}), ...(streamOptions?.env ?? {}) } : undefined,
+		headers: { ...(streamOptions?.headers ?? {}), ...(auth.headers ?? {}) },
+	});
+	const ctxThinking = (input.ctx as { getThinkingLevel?: () => ThinkingLevel }).getThinkingLevel?.();
+	const agent = new Agent({
+		initialState: {
+			systemPrompt: [
+				"Rewrite one subagent authored task from Prompt Audit context.",
+				"Return only the revised authored task text.",
+				"Do not add Markdown fences, explanations, labels, or commentary.",
+				"Preserve the original intent unless the guidance explicitly changes it.",
+				"Do not include runtime additions unless they are needed as ordinary task context.",
+			].join("\n"),
+			model,
+			thinkingLevel: ctxThinking ?? "off",
+			tools: [],
+		},
+		convertToLlm,
+		streamFn,
+		getApiKey: (providerName) => providerName === model.provider ? auth.apiKey : undefined,
+		toolExecution: "sequential",
+	});
+	const abort = () => agent.abort();
+	input.ctx.signal?.addEventListener("abort", abort, { once: true });
+	input.signal?.addEventListener("abort", abort, { once: true });
+	try {
+		await agent.prompt([
+			"Guidance from the human:",
+			input.guidance.trim(),
+			"",
+			"Authored task:",
+			input.authoredTask,
+			"",
+			"Runtime additions for context only:",
+			input.runtimeAdditions,
+			"",
+			"Final effective prompt for context only:",
+			input.finalEffectivePrompt,
+		].join("\n"));
+	} finally {
+		input.ctx.signal?.removeEventListener("abort", abort);
+		input.signal?.removeEventListener("abort", abort);
+	}
+	const rewritten = finalAssistantText(agent);
+	if (!rewritten) throw new Error("Prompt redo rewrite returned an empty prompt.");
+	return rewritten;
+}
+
+function runtimeAdditions(authoredTask: string, effectivePrompt: string): string {
+	if (!authoredTask) return effectivePrompt;
+	const authoredIndex = effectivePrompt.indexOf(authoredTask);
+	if (authoredIndex < 0) return "(runtime additions unavailable)";
+	const before = effectivePrompt.slice(0, authoredIndex).trim();
+	const after = effectivePrompt.slice(authoredIndex + authoredTask.length).trim();
+	return [before, after].filter(Boolean).join("\n\n") || "(none)";
+}
+
+export function registerLivePromptAudit(
+	control: ForegroundRunControl,
+	index: number,
+	authoredTask: string,
+	effectivePrompt: string,
+	metadata: { cwd?: string; outputPath?: string; rerun?: PromptAuditRerunContract } = {},
+): void {
+	let prompts = livePrompts.get(control);
+	if (!prompts) {
+		prompts = new Map();
+		livePrompts.set(control, prompts);
+	}
+	prompts.set(index, {
+		authoredTask,
+		runtimeAdditions: runtimeAdditions(authoredTask, effectivePrompt),
+		finalEffectivePrompt: effectivePrompt,
+		...(metadata.cwd ? { cwd: metadata.cwd } : {}),
+		...(metadata.outputPath ? { outputPath: metadata.outputPath } : {}),
+		...(metadata.rerun ? { rerun: metadata.rerun } : {}),
+	});
+}
+
+export function updateLiveEffectivePrompt(control: ForegroundRunControl, index: number, effectivePrompt: string): void {
+	const prompt = livePrompts.get(control)?.get(index);
+	if (!prompt) return;
+	prompt.finalEffectivePrompt = effectivePrompt;
+	prompt.runtimeAdditions = runtimeAdditions(prompt.authoredTask, effectivePrompt);
+}
+
+export function getLivePromptAudit(control: ForegroundRunControl, index: number): LivePromptAudit | undefined {
+	return livePrompts.get(control)?.get(index);
+}
+
+export function removeLivePromptAudit(control: ForegroundRunControl, index: number): void {
+	const prompts = livePrompts.get(control);
+	if (!prompts) return;
+	prompts.delete(index);
+	if (prompts.size === 0) livePrompts.delete(control);
+}