pi-subagents 0.31.1 → 0.33.0

package/src/shared/artifacts.ts

@@ -3,8 +3,22 @@ import * as path from "node:path";
 import { TEMP_ARTIFACTS_DIR, type ArtifactPaths } from "./types.ts";
 import { getAgentDir } from "./utils.ts";
 const CLEANUP_MARKER_FILE = ".last-cleanup";
+const PROJECT_ARTIFACT_ROOT = ".pi-subagents";
 
-export function getArtifactsDir(sessionFile: string | null): string {
+export function getProjectSubagentsDir(cwd: string): string {
+	return path.join(cwd, PROJECT_ARTIFACT_ROOT);
+}
+
+export function getProjectArtifactsDir(cwd: string): string {
+	return path.join(getProjectSubagentsDir(cwd), "artifacts");
+}
+
+export function getProjectChainRunsDir(cwd: string): string {
+	return path.join(getProjectSubagentsDir(cwd), "chain-runs");
+}
+
+export function getArtifactsDir(sessionFile: string | null, projectCwd?: string): string {
+	if (projectCwd) return getProjectArtifactsDir(projectCwd);
 	if (sessionFile) {
 		const sessionDir = path.dirname(sessionFile);
 		return path.join(sessionDir, "subagent-artifacts");
@@ -20,6 +34,7 @@ export function getArtifactPaths(artifactsDir: string, runId: string, agent: str
 		inputPath: path.join(artifactsDir, `${base}_input.md`),
 		outputPath: path.join(artifactsDir, `${base}_output.md`),
 		jsonlPath: path.join(artifactsDir, `${base}.jsonl`),
+		transcriptPath: path.join(artifactsDir, `${base}_transcript.jsonl`),
 		metadataPath: path.join(artifactsDir, `${base}_meta.json`),
 	};
 }

package/src/shared/atomic-json.ts

@@ -13,13 +13,26 @@ type AtomicJsonWriterOptions = {
 	wait?: (delayMs: number) => void;
 };
 
-const DEFAULT_RENAME_RETRY_DELAYS_MS = [10, 25, 50, 100, 200] as const;
+const DEFAULT_RENAME_RETRY_DELAYS_MS = [10, 25, 50, 100, 200, 500, 1000, 2000, 4000] as const;
 const RETRYABLE_RENAME_ERROR_CODES = new Set(["EACCES", "EBUSY", "EPERM"]);
+const WAIT_BUFFER = typeof SharedArrayBuffer !== "undefined" ? new SharedArrayBuffer(4) : undefined;
+const WAIT_VIEW = WAIT_BUFFER ? new Int32Array(WAIT_BUFFER) : undefined;
 
 function waitSync(delayMs: number): void {
+	if (delayMs <= 0) return;
+	if (WAIT_VIEW) {
+		try {
+			// writeAtomicJson is synchronous because callers often update status from sync callbacks.
+			// Atomics.wait gives Windows rename locks time to clear without burning CPU.
+			Atomics.wait(WAIT_VIEW, 0, 0, delayMs);
+			return;
+		} catch {
+			// Fall through to the portable busy wait below.
+		}
+	}
 	const end = Date.now() + delayMs;
 	while (Date.now() < end) {
-		// writeAtomicJson is synchronous because callers often update status from sync callbacks.
+		// Portable fallback for runtimes where Atomics.wait is unavailable.
 	}
 }
 

package/src/shared/child-transcript.ts

@@ -0,0 +1,212 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { Message } from "@earendil-works/pi-ai";
+import { extractTextFromContent, extractToolArgsPreview } from "./utils.ts";
+
+export const CHILD_TRANSCRIPT_ARTIFACT_VERSION = 1;
+const DEFAULT_MAX_CHILD_TRANSCRIPT_BYTES = 50 * 1024 * 1024;
+
+type ChildTranscriptSource = "foreground" | "async";
+type ChildTranscriptRecordType = "message" | "tool_start" | "tool_end" | "stdout" | "stderr" | "truncated";
+
+type ChildTranscriptMessage = Message & {
+	model?: string;
+	errorMessage?: string;
+	stopReason?: string;
+	usage?: unknown;
+};
+
+interface ChildTranscriptEvent {
+	type?: string;
+	message?: ChildTranscriptMessage;
+	toolName?: string;
+	args?: unknown;
+}
+
+interface ChildTranscriptWriterInput {
+	transcriptPath: string;
+	source: ChildTranscriptSource;
+	runId: string;
+	agent: string;
+	childIndex?: number;
+	cwd: string;
+	maxBytes?: number;
+}
+
+export interface ChildTranscriptWriter {
+	path: string;
+	writeInitialUserMessage(prompt: string): void;
+	writeChildEvent(event: ChildTranscriptEvent): void;
+	writeStdoutLine(line: string): void;
+	writeStderrLine(line: string): void;
+	writeStderrText(text: string): void;
+	getError(): string | undefined;
+}
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+function finiteNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function normalizeUsage(value: unknown): { input: number; output: number; cacheRead: number; cacheWrite: number; cost: number } | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const raw = value as Record<string, unknown>;
+	const rawCost = raw.cost;
+	const cost = rawCost && typeof rawCost === "object"
+		? finiteNumber((rawCost as { total?: unknown }).total) ?? 0
+		: finiteNumber(rawCost) ?? 0;
+	return {
+		input: finiteNumber(raw.input) ?? finiteNumber(raw.inputTokens) ?? 0,
+		output: finiteNumber(raw.output) ?? finiteNumber(raw.outputTokens) ?? 0,
+		cacheRead: finiteNumber(raw.cacheRead) ?? 0,
+		cacheWrite: finiteNumber(raw.cacheWrite) ?? 0,
+		cost,
+	};
+}
+
+function eventArgs(event: ChildTranscriptEvent): Record<string, unknown> {
+	return event.args && typeof event.args === "object" && !Array.isArray(event.args)
+		? event.args as Record<string, unknown>
+		: {};
+}
+
+export function createChildTranscriptWriter(input: ChildTranscriptWriterInput): ChildTranscriptWriter {
+	let bytesWritten = 0;
+	let writeError: string | undefined;
+	let truncated = false;
+	const maxBytes = input.maxBytes ?? DEFAULT_MAX_CHILD_TRANSCRIPT_BYTES;
+
+	const baseRecord = (recordType: ChildTranscriptRecordType) => {
+		const ts = Date.now();
+		return {
+			version: CHILD_TRANSCRIPT_ARTIFACT_VERSION,
+			recordType,
+			source: input.source,
+			runId: input.runId,
+			agent: input.agent,
+			...(input.childIndex !== undefined ? { childIndex: input.childIndex } : {}),
+			cwd: input.cwd,
+			ts,
+			timestamp: new Date(ts).toISOString(),
+		};
+	};
+
+	const writeTruncatedMarker = () => {
+		truncated = true;
+		const marker = `${JSON.stringify({
+			...baseRecord("truncated"),
+			maxBytes,
+			message: `Child transcript exceeded ${maxBytes} bytes; further records were omitted.`,
+		})}\n`;
+		const markerBytes = Buffer.byteLength(marker, "utf-8");
+		if (bytesWritten + markerBytes > maxBytes) return false;
+		try {
+			fs.appendFileSync(input.transcriptPath, marker, "utf-8");
+			bytesWritten += markerBytes;
+			return true;
+		} catch (error) {
+			writeError = `Failed to write child transcript '${input.transcriptPath}': ${errorMessage(error)}`;
+			return false;
+		}
+	};
+
+	const writeRecord = (record: Record<string, unknown>) => {
+		if (writeError || truncated) return;
+		const line = `${JSON.stringify(record)}\n`;
+		const bytes = Buffer.byteLength(line, "utf-8");
+		if (bytesWritten + bytes > maxBytes) {
+			writeTruncatedMarker();
+			return;
+		}
+		const markerProbe = `${JSON.stringify({
+			...baseRecord("truncated"),
+			maxBytes,
+			message: `Child transcript exceeded ${maxBytes} bytes; further records were omitted.`,
+		})}\n`;
+		if (bytesWritten + bytes + Buffer.byteLength(markerProbe, "utf-8") > maxBytes) {
+			writeTruncatedMarker();
+			return;
+		}
+		try {
+			fs.appendFileSync(input.transcriptPath, line, "utf-8");
+			bytesWritten += bytes;
+		} catch (error) {
+			writeError = `Failed to write child transcript '${input.transcriptPath}': ${errorMessage(error)}`;
+		}
+	};
+
+	try {
+		fs.mkdirSync(path.dirname(input.transcriptPath), { recursive: true });
+		fs.writeFileSync(input.transcriptPath, "", "utf-8");
+	} catch (error) {
+		writeError = `Failed to initialize child transcript '${input.transcriptPath}': ${errorMessage(error)}`;
+	}
+
+	const writeMessage = (sourceEventType: string, message: ChildTranscriptMessage) => {
+		const text = extractTextFromContent(message.content);
+		writeRecord({
+			...baseRecord("message"),
+			sourceEventType,
+			role: message.role,
+			...(text ? { text } : {}),
+			...(message.model ? { model: message.model } : {}),
+			...(message.stopReason ? { stopReason: message.stopReason } : {}),
+			...(message.errorMessage ? { errorMessage: message.errorMessage } : {}),
+			...(message.usage ? { usage: normalizeUsage(message.usage) } : {}),
+			message,
+		});
+	};
+
+	return {
+		path: input.transcriptPath,
+		writeInitialUserMessage(prompt: string) {
+			writeRecord({
+				...baseRecord("message"),
+				sourceEventType: "initial_prompt",
+				role: "user",
+				text: prompt,
+				message: { role: "user", content: [{ type: "text", text: prompt }] },
+			});
+		},
+		writeChildEvent(event: ChildTranscriptEvent) {
+			if ((event.type === "message_end" || event.type === "tool_result_end") && event.message) {
+				writeMessage(event.type, event.message);
+				return;
+			}
+			if (event.type === "tool_execution_start" && event.toolName) {
+				const args = eventArgs(event);
+				writeRecord({
+					...baseRecord("tool_start"),
+					sourceEventType: event.type,
+					toolName: event.toolName,
+					...(Object.keys(args).length > 0 ? { argsPreview: extractToolArgsPreview(args) } : {}),
+				});
+				return;
+			}
+			if (event.type === "tool_execution_end") {
+				writeRecord({
+					...baseRecord("tool_end"),
+					sourceEventType: event.type,
+					...(event.toolName ? { toolName: event.toolName } : {}),
+				});
+			}
+		},
+		writeStdoutLine(line: string) {
+			if (!line.trim()) return;
+			writeRecord({ ...baseRecord("stdout"), text: line });
+		},
+		writeStderrLine(line: string) {
+			if (!line.trim()) return;
+			writeRecord({ ...baseRecord("stderr"), text: line });
+		},
+		writeStderrText(text: string) {
+			for (const line of text.split(/\r?\n/)) this.writeStderrLine(line);
+		},
+		getError() {
+			return writeError;
+		},
+	};
+}

package/src/shared/fork-context.ts

@@ -1,27 +1,115 @@
+import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
+import * as path from "node:path";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
 
 type SubagentExecutionContext = "fresh" | "fork";
 
+interface BranchSessionEntry {
+	type: string;
+	id?: string;
+	parentId?: string | null;
+	timestamp?: string;
+	message?: {
+		role?: string;
+		content?: unknown;
+		provider?: string;
+		api?: string;
+		model?: string;
+	};
+	thinkingLevel?: string;
+}
+
+interface BranchSessionManager {
+	createBranchedSession(leafId: string): string | undefined;
+	getHeader?: () => BranchSessionEntry | null;
+	getEntries?: () => BranchSessionEntry[];
+}
+
 interface ForkableSessionManager {
 	getSessionFile(): string | undefined;
 	getLeafId(): string | null;
 	getSessionDir?(): string;
-	openSession?: (path: string, sessionDir?: string) => { createBranchedSession(leafId: string): string | undefined };
+	openSession?: (path: string, sessionDir?: string) => BranchSessionManager;
 }
 
 interface ForkContextResolverOptions {
-	openSession?: (path: string, sessionDir?: string) => { createBranchedSession(leafId: string): string | undefined };
+	openSession?: (path: string, sessionDir?: string) => BranchSessionManager;
+}
+
+interface ForkContextResolution {
+	sessionFile: string;
+	thinkingOverride?: "off";
 }
 
 interface ForkContextResolver {
 	sessionFileForIndex(index?: number): string | undefined;
+	thinkingOverrideForIndex(index?: number): "off" | undefined;
 }
 
 export function resolveSubagentContext(value: unknown): SubagentExecutionContext {
 	return value === "fork" ? "fork" : "fresh";
 }
 
+function isUnsafeAnthropicThinkingBlock(message: BranchSessionEntry["message"], block: unknown): boolean {
+	if (!message || !block || typeof block !== "object" || !("type" in block)) return false;
+	const provider = typeof message.provider === "string" ? message.provider.toLowerCase() : "";
+	const api = typeof message.api === "string" ? message.api.toLowerCase() : "";
+	const model = typeof message.model === "string" ? message.model.toLowerCase() : "";
+	const isAnthropic = provider === "anthropic" || api === "anthropic-messages" || model.startsWith("anthropic/");
+	if (block.type === "redacted_thinking") return true;
+	if (block.type !== "thinking" || !isAnthropic) return false;
+	const signature = "thinkingSignature" in block ? block.thinkingSignature : "signature" in block ? block.signature : undefined;
+	return block.redacted === true || (typeof signature === "string" && signature.length > 0);
+}
+
+function createEntryId(entries: BranchSessionEntry[]): string {
+	const ids = new Set(entries.map((entry) => entry.id).filter((id): id is string => typeof id === "string"));
+	for (let attempt = 0; attempt < 100; attempt++) {
+		const id = randomUUID().slice(0, 8);
+		if (!ids.has(id)) return id;
+	}
+	return randomUUID();
+}
+
+function appendThinkingOffEntry(entries: BranchSessionEntry[]): void {
+	const last = entries[entries.length - 1];
+	if (last?.type === "thinking_level_change" && last.thinkingLevel === "off") return;
+	const parent = [...entries].reverse().find((entry) => typeof entry.id === "string");
+	entries.push({
+		type: "thinking_level_change",
+		id: createEntryId(entries),
+		parentId: parent?.id ?? null,
+		timestamp: new Date().toISOString(),
+		thinkingLevel: "off",
+	});
+}
+
+function sanitizeUnsafeThinkingBlocks(entries: BranchSessionEntry[]): boolean {
+	let sanitized = false;
+	for (const entry of entries) {
+		if (entry.type !== "message" || entry.message?.role !== "assistant" || !Array.isArray(entry.message.content)) continue;
+		const filtered = entry.message.content.filter((block) => !isUnsafeAnthropicThinkingBlock(entry.message, block));
+		if (filtered.length === entry.message.content.length) continue;
+		entry.message.content = filtered;
+		sanitized = true;
+	}
+	if (sanitized) appendThinkingOffEntry(entries);
+	return sanitized;
+}
+
+function readSessionEntries(sessionFile: string): BranchSessionEntry[] {
+	const lines = fs.readFileSync(sessionFile, "utf-8").split("\n").filter((line) => line.trim().length > 0);
+	return lines.map((line, index) => {
+		try {
+			return JSON.parse(line) as BranchSessionEntry;
+		} catch (error) {
+			const cause = error instanceof Error ? error : new Error(String(error));
+			throw new Error(`Unable to inspect forked session ${sessionFile}: invalid JSONL on line ${index + 1}: ${cause.message}`, { cause });
+		}
+	});
+}
+
 export function createForkContextResolver(
 	sessionManager: ForkableSessionManager,
 	requestedContext: unknown,
@@ -30,6 +118,7 @@ export function createForkContextResolver(
 	if (resolveSubagentContext(requestedContext) !== "fork") {
 		return {
 			sessionFileForIndex: () => undefined,
+			thinkingOverrideForIndex: () => undefined,
 		};
 	}
 
@@ -47,30 +136,52 @@ export function createForkContextResolver(
 		?? sessionManager.openSession
 		?? ((file: string, dir?: string) => SessionManager.open(file, dir));
 	const sessionDir = sessionManager.getSessionDir?.();
-	const cachedSessionFiles = new Map<number, string>();
+	const cachedResolutions = new Map<number, ForkContextResolution>();
 
-	return {
-		sessionFileForIndex(index = 0): string | undefined {
-			const cached = cachedSessionFiles.get(index);
-			if (cached) return cached;
-			try {
-				if (!fs.existsSync(parentSessionFile)) {
-					throw new Error(`Parent session file does not exist: ${parentSessionFile}. Pi has not persisted enough history to fork yet.`);
-				}
-				const sourceManager = openSession(parentSessionFile, sessionDir);
-				const sessionFile = sourceManager.createBranchedSession(leafId);
-				if (!sessionFile) {
-					throw new Error("Session manager did not return a forked session file.");
+	const resolveFork = (index = 0): ForkContextResolution => {
+		const cached = cachedResolutions.get(index);
+		if (cached) return cached;
+		try {
+			if (!fs.existsSync(parentSessionFile)) {
+				throw new Error(`Parent session file does not exist: ${parentSessionFile}. Pi has not persisted enough history to fork yet.`);
+			}
+			const sourceManager = openSession(parentSessionFile, sessionDir);
+			const sessionFile = sourceManager.createBranchedSession(leafId);
+			if (!sessionFile) {
+				throw new Error("Session manager did not return a forked session file.");
+			}
+			let thinkingOverride: "off" | undefined;
+			if (!fs.existsSync(sessionFile)) {
+				const header = sourceManager.getHeader?.();
+				const entries = sourceManager.getEntries?.();
+				if (!header || !entries) {
+					throw new Error(`Session manager returned a forked session file that does not exist and cannot be persisted by fallback: ${sessionFile}`);
 				}
-				if (!fs.existsSync(sessionFile)) {
-					throw new Error(`Session manager returned a forked session file that does not exist: ${sessionFile}`);
+				if (sanitizeUnsafeThinkingBlocks(entries)) thinkingOverride = "off";
+				fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
+				fs.writeFileSync(sessionFile, `${[header, ...entries].map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf-8");
+			} else {
+				const entries = readSessionEntries(sessionFile);
+				if (sanitizeUnsafeThinkingBlocks(entries)) {
+					thinkingOverride = "off";
+					fs.writeFileSync(sessionFile, `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf-8");
 				}
-				cachedSessionFiles.set(index, sessionFile);
-				return sessionFile;
-			} catch (error) {
-				const cause = error instanceof Error ? error : new Error(String(error));
-				throw new Error(`Failed to create forked subagent session: ${cause.message}`, { cause });
 			}
+			const resolution = { sessionFile, ...(thinkingOverride ? { thinkingOverride } : {}) };
+			cachedResolutions.set(index, resolution);
+			return resolution;
+		} catch (error) {
+			const cause = error instanceof Error ? error : new Error(String(error));
+			throw new Error(`Failed to create forked subagent session: ${cause.message}`, { cause });
+		}
+	};
+
+	return {
+		sessionFileForIndex(index = 0): string | undefined {
+			return resolveFork(index).sessionFile;
+		},
+		thinkingOverrideForIndex(index = 0): "off" | undefined {
+			return resolveFork(index).thinkingOverride;
 		},
 	};
 }

package/src/shared/settings.ts

@@ -6,7 +6,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentConfig } from "../agents/agents.ts";
 import { normalizeSkillInput } from "../agents/skills.ts";
-import { CHAIN_RUNS_DIR, type AcceptanceInput, type JsonSchemaObject, type OutputMode } from "./types.ts";
+import { CHAIN_RUNS_DIR, type AcceptanceInput, type JsonSchemaObject, type OutputMode, type ToolBudgetConfig } from "./types.ts";
 const CHAIN_DIR_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
 const INITIAL_PROGRESS_CONTENT = "# Progress\n\n## Status\nIn Progress\n\n## Tasks\n\n## Files Changed\n\n## Notes\n";
 
@@ -55,6 +55,7 @@ export interface SequentialStep {
 	progress?: boolean;
 	skill?: string | string[] | false;
 	model?: string;
+	toolBudget?: ToolBudgetConfig;
 	acceptance?: AcceptanceInput;
 }
 
@@ -74,6 +75,7 @@ export interface ParallelTaskItem {
 	progress?: boolean;
 	skill?: string | string[] | false;
 	model?: string;
+	toolBudget?: ToolBudgetConfig;
 	acceptance?: AcceptanceInput;
 }