pi-subagents 0.69.0 → 0.70.0

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

@@ -1,157 +0,0 @@
-import type { AgentProgress, ForegroundChildControl, ForegroundRunControl } from "../../shared/types.ts";
-import { registerLivePromptAudit, removeLivePromptAudit, type PromptAuditRerunContract } from "./prompt-audit.ts";
-
-interface BeginForegroundChildInput {
-	index: number;
-	agent: string;
-	description?: string;
-	authoredTask: string;
-	effectivePrompt: string;
-	cwd?: string;
-	outputPath?: string;
-	rerun?: PromptAuditRerunContract;
-	model?: string;
-	thinking?: string;
-	interrupt: () => boolean;
-	detach?: () => boolean;
-	steer?: ForegroundChildControl["steer"];
-}
-
-function copyProgress(target: ForegroundChildControl, progress: AgentProgress | undefined): void {
-	if (!progress) return;
-	target.sessionName = progress.sessionName;
-	target.currentActivityState = progress.activityState;
-	target.lastActivityAt = progress.lastActivityAt;
-	target.currentTool = progress.currentTool;
-	target.currentToolStartedAt = progress.currentToolStartedAt;
-	target.currentPath = progress.currentPath;
-	target.turnCount = progress.turnCount;
-	target.tokens = progress.tokens;
-	target.inputTokens = progress.inputTokens;
-	target.outputTokens = progress.outputTokens;
-	target.window = progress.window;
-	target.windowPeak = progress.windowPeak;
-	target.model = progress.model;
-	target.thinking = progress.thinking;
-	target.toolCount = progress.toolCount;
-}
-
-function syncCurrentChild(control: ForegroundRunControl, child: ForegroundChildControl): void {
-	control.currentAgent = child.agent;
-	control.sessionName = child.sessionName;
-	control.currentIndex = child.index;
-	control.description = child.description;
-	control.currentActivityState = child.currentActivityState;
-	control.lastActivityAt = child.lastActivityAt;
-	control.currentTool = child.currentTool;
-	control.currentToolStartedAt = child.currentToolStartedAt;
-	control.currentPath = child.currentPath;
-	control.turnCount = child.turnCount;
-	control.tokens = child.tokens;
-	control.inputTokens = child.inputTokens;
-	control.outputTokens = child.outputTokens;
-	control.window = child.window;
-	control.windowPeak = child.windowPeak;
-	control.model = child.model;
-	control.thinking = child.thinking;
-	control.toolCount = child.toolCount;
-	control.interrupt = child.interrupt;
-	control.detach = child.detach;
-	control.steer = child.steer;
-	control.updatedAt = child.updatedAt;
-}
-
-function clearCurrentChild(control: ForegroundRunControl): void {
-	control.currentAgent = undefined;
-	control.sessionName = undefined;
-	control.currentIndex = undefined;
-	control.currentActivityState = undefined;
-	control.lastActivityAt = undefined;
-	control.currentTool = undefined;
-	control.currentToolStartedAt = undefined;
-	control.currentPath = undefined;
-	control.turnCount = undefined;
-	control.tokens = undefined;
-	control.inputTokens = undefined;
-	control.outputTokens = undefined;
-	control.window = undefined;
-	control.windowPeak = undefined;
-	control.model = undefined;
-	control.thinking = undefined;
-	control.toolCount = undefined;
-	control.interrupt = undefined;
-	control.detach = undefined;
-	control.steer = undefined;
-}
-
-export function retainForegroundSchedulingOwner(control: ForegroundRunControl): void {
-	control.schedulingOwners = (control.schedulingOwners ?? 0) + 1;
-	control.updatedAt = Date.now();
-}
-
-export function settleForegroundSchedulingOwner(control: ForegroundRunControl): void {
-	control.schedulingOwners = Math.max(0, (control.schedulingOwners ?? 0) - 1);
-	control.updatedAt = Date.now();
-}
-
-export function foregroundSchedulingSettled(control: ForegroundRunControl): boolean {
-	return (control.schedulingOwners ?? 0) === 0;
-}
-
-export function beginForegroundChild(control: ForegroundRunControl, input: BeginForegroundChildInput): void {
-	const now = Date.now();
-	const child: ForegroundChildControl = {
-		index: input.index,
-		agent: input.agent,
-		...(input.description ? { description: input.description } : {}),
-		startedAt: now,
-		updatedAt: now,
-		...(input.model ? { model: input.model } : {}),
-		...(input.thinking ? { thinking: input.thinking } : {}),
-	};
-	child.interrupt = () => {
-		if (!input.interrupt()) return false;
-		child.currentActivityState = undefined;
-		child.updatedAt = Date.now();
-		syncCurrentChild(control, child);
-		return true;
-	};
-	if (input.detach) {
-		child.detach = () => {
-			if (!input.detach?.()) return false;
-			child.currentActivityState = undefined;
-			child.updatedAt = Date.now();
-			syncCurrentChild(control, child);
-			return true;
-		};
-	}
-	if (input.steer) child.steer = input.steer;
-	control.activeChildren ??= new Map();
-	control.activeChildren.set(input.index, child);
-	registerLivePromptAudit(control, input.index, input.authoredTask, input.effectivePrompt, {
-		...(input.cwd ? { cwd: input.cwd } : {}),
-		...(input.outputPath ? { outputPath: input.outputPath } : {}),
-		...(input.rerun ? { rerun: input.rerun } : {}),
-	});
-	syncCurrentChild(control, child);
-}
-
-export function updateForegroundChild(control: ForegroundRunControl, index: number, progress: AgentProgress | undefined): void {
-	const child = control.activeChildren?.get(index);
-	if (!child) return;
-	copyProgress(child, progress);
-	child.updatedAt = Date.now();
-	syncCurrentChild(control, child);
-}
-
-export function finishForegroundChild(control: ForegroundRunControl, index: number): void {
-	removeLivePromptAudit(control, index);
-	control.activeChildren?.delete(index);
-	if (control.currentIndex === index) {
-		const next = [...(control.activeChildren?.values() ?? [])]
-			.sort((left, right) => right.updatedAt - left.updatedAt || left.index - right.index)[0];
-		if (next) syncCurrentChild(control, next);
-		else clearCurrentChild(control);
-	}
-	control.updatedAt = Date.now();
-}

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

@@ -1,163 +0,0 @@
-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 { writePrivateAtomicJson } from "../../shared/atomic-json.ts";
-import { utf8Tail } from "../../shared/utf8.ts";
-import { validateAcceptanceInput } from "../shared/acceptance.ts";
-import { validateModelResponseAliases } from "../../shared/model-response-aliases.ts";
-
-export const MAX_REMEMBERED_FOREGROUND_RUNS = 50;
-const HISTORY_VERSION = 1;
-const MAX_INLINE_OUTPUT_BYTES = 64 * 1024;
-const MAX_RESUME_CONTRACT_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.sessionName ? { sessionName: child.sessionName } : {}),
-		...(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.resumeContract ? { resumeContract: child.resumeContract } : {}),
-		...(child.launchContractDigest ? { launchContractDigest: child.launchContractDigest } : {}),
-		...(child.extensionBindings ? { extensionBindings: child.extensionBindings } : {}),
-		...(child.requiredExtensions ? { requiredExtensions: child.requiredExtensions } : {}),
-		...(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 isRestorableResumeContract(value: unknown): boolean {
-	if (value === undefined) return true;
-	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-	try {
-		if (Buffer.byteLength(JSON.stringify(value), "utf8") > MAX_RESUME_CONTRACT_BYTES) return false;
-		validateModelResponseAliases((value as ForegroundResumeChild["resumeContract"])?.modelResponseAliases);
-	} catch {
-		return false;
-	}
-	const contract = value as NonNullable<ForegroundResumeChild["resumeContract"]>;
-	if (Object.keys(contract).some((key) => !["modelResponseAliases", "outputSchema", "agentContract", "acceptance", "output", "outputMode"].includes(key))) return false;
-	if (contract.outputSchema !== undefined && contract.outputSchema !== false && (!contract.outputSchema || typeof contract.outputSchema !== "object" || Array.isArray(contract.outputSchema))) return false;
-	if (contract.agentContract !== undefined && (!contract.agentContract || typeof contract.agentContract !== "object" || Array.isArray(contract.agentContract) || contract.agentContract.version !== 1)) return false;
-	if (validateAcceptanceInput(contract.acceptance).length > 0) return false;
-	if (contract.output !== undefined && typeof contract.output !== "string" && typeof contract.output !== "boolean") return false;
-	return contract.outputMode === undefined || contract.outputMode === "inline" || contract.outputMode === "file-only";
-}
-
-function compactRun(run: ForegroundResumeRun): ForegroundResumeRun | undefined {
-	if (!run.sessionId) return undefined;
-	if (run.children.length === 0 || !run.children.every((child) => isRestorableForegroundStatus(child.status) && isRestorableResumeContract(child.resumeContract))) 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"
-			&& isRestorableResumeContract((child as Partial<ForegroundResumeChild>).resumeContract)
-			&& 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);
-	writePrivateAtomicJson(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/src/runs/foreground/prompt-audit.ts

@@ -1,178 +0,0 @@
-import type { Agent, StreamFn, ThinkingLevel } from "@earendil-works/pi-agent-core";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { ProviderHeaders } from "@earendil-works/pi-ai";
-import { agentStreamOptions } from "../../shared/agent-stream-options.ts";
-import { opencodeSessionHeaders } from "../../shared/opencode-session-headers.ts";
-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 = NonNullable<ExtensionContext["model"]>;
-
-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?: ProviderHeaders; 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 [{ Agent }, { convertToLlm }, { streamSimple }] = await Promise.all([
-		import("@earendil-works/pi-agent-core"),
-		import("@earendil-works/pi-coding-agent"),
-		import("@earendil-works/pi-ai/compat"),
-	]);
-	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 sessionId = input.ctx.sessionManager.getSessionId();
-	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: { ...opencodeSessionHeaders(nextModel, sessionId), ...(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,
-		...agentStreamOptions(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);
-}