pi-subagents 0.65.1 → 0.67.0

package/src/shared/fork-context.ts

@@ -1,8 +1,12 @@
-import { randomUUID } from "node:crypto";
+// Forking a parent transcript into a child must drop Anthropic's signed and redacted
+// thinking blocks: a thinking signature is bound to the session that produced it and
+// cannot be replayed into a branch. Stripping them is required; disabling the child's
+// thinking is not. Pi >= 0.85.0 recovers from signed-thinking mismatches on the
+// transport, so a sanitized transcript is safe to resume with thinking enabled and the
+// child keeps the level it asked for, reasoning fresh from its first turn.
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
-import { findModelInfo, type ModelInfo } from "./model-info.ts";
 
 type SubagentExecutionContext = "fresh" | "fork";
 
@@ -19,7 +23,6 @@ interface BranchSessionEntry {
 		api?: string;
 		model?: string;
 	};
-	thinkingLevel?: string;
 }
 
 interface BranchSessionManager {
@@ -39,20 +42,11 @@ interface ForkContextResolverOptions {
 	openSession?: (path: string, sessionDir?: string) => BranchSessionManager;
 	/** Rewrite a created fork before its path can be used to spawn a child. */
 	pruneSession?: (sessionFile: string) => Promise<void>;
-	/** Decide per child index whether a sanitized transcript must also disable the child's
-	 * thinking. Defaults to true (the pre-existing conservative behavior) when omitted. */
-	forceThinkingOffForIndex?: (index: number) => boolean;
-}
-
-interface ForkContextResolution {
-	sessionFile: string;
-	thinkingOverride?: "off";
 }
 
 interface ForkContextResolver {
 	prepareSessionForIndex(index?: number): Promise<void>;
 	sessionFileForIndex(index?: number): string | undefined;
-	thinkingOverrideForIndex(index?: number): "off" | undefined;
 }
 
 export function resolveSubagentContext(value: unknown): SubagentExecutionContext {
@@ -101,20 +95,6 @@ export function canPreferForkFromSnapshot(input: PreferredForkSnapshot): boolean
 	}
 }
 
-/** Decide whether a resolved child model uses Anthropic's provider or message API, which
- * requires the sanitized fork to disable thinking. Unknown models stay conservative. */
-export function forkedChildRequiresThinkingOff(
-	model: string | undefined,
-	availableModels?: ModelInfo[],
-	preferredProvider?: string,
-): boolean {
-	if (!model) return true;
-	const info = findModelInfo(model, availableModels, preferredProvider);
-	if (!info) return true;
-	return info.provider.toLowerCase() === "anthropic"
-		|| info.api?.toLowerCase() === "anthropic-messages";
-}
-
 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() : "";
@@ -128,28 +108,6 @@ function isUnsafeAnthropicThinkingBlock(message: BranchSessionEntry["message"],
 	return record.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) {
@@ -183,7 +141,6 @@ export function createForkContextResolver(
 		return {
 			prepareSessionForIndex: async () => {},
 			sessionFileForIndex: () => undefined,
-			thinkingOverrideForIndex: () => undefined,
 		};
 	}
 
@@ -217,12 +174,12 @@ export function createForkContextResolver(
 		path.basename(parentSessionFile, ".jsonl"),
 		"forks",
 	);
-	const cachedResolutions = new Map<number, ForkContextResolution>();
+	const cachedSessionFiles = new Map<number, string>();
 	const preparedIndexes = new Set<number>();
 	const preparationPromises = new Map<number, Promise<void>>();
 
-	const resolveFork = (index = 0): ForkContextResolution => {
-		const cached = cachedResolutions.get(index);
+	const resolveFork = (index = 0): string => {
+		const cached = cachedSessionFiles.get(index);
 		if (cached) return cached;
 		try {
 			if (!fs.existsSync(parentSessionFile)) {
@@ -233,34 +190,23 @@ export function createForkContextResolver(
 			if (!sessionFile) {
 				throw new Error("Session manager did not return a forked session file.");
 			}
-			const forceThinkingOff = (sanitized: boolean): boolean =>
-				sanitized && (options.forceThinkingOffForIndex?.(index) ?? true);
-			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 (forceThinkingOff(sanitizeUnsafeThinkingBlocks(entries))) {
-					appendThinkingOffEntry(entries);
-					thinkingOverride = "off";
-				}
+				sanitizeUnsafeThinkingBlocks(entries);
 				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)) {
-					if (forceThinkingOff(true)) {
-						appendThinkingOffEntry(entries);
-						thinkingOverride = "off";
-					}
 					fs.writeFileSync(sessionFile, `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf-8");
 				}
 			}
-			const resolution = { sessionFile, ...(thinkingOverride ? { thinkingOverride } : {}) };
-			cachedResolutions.set(index, resolution);
-			return resolution;
+			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 });
@@ -269,11 +215,11 @@ export function createForkContextResolver(
 
 	return {
 		async prepareSessionForIndex(index = 0): Promise<void> {
-			const resolution = resolveFork(index);
+			const sessionFile = resolveFork(index);
 			if (!options.pruneSession || preparedIndexes.has(index)) return;
 			let preparation = preparationPromises.get(index);
 			if (!preparation) {
-				preparation = options.pruneSession(resolution.sessionFile).then(() => {
+				preparation = options.pruneSession(sessionFile).then(() => {
 					preparedIndexes.add(index);
 				});
 				preparationPromises.set(index, preparation);
@@ -284,10 +230,7 @@ export function createForkContextResolver(
 			if (options.pruneSession && !preparedIndexes.has(index)) {
 				throw new Error(`Pruned fork session ${index} was used before pruning completed.`);
 			}
-			return resolveFork(index).sessionFile;
-		},
-		thinkingOverrideForIndex(index = 0): "off" | undefined {
-			return resolveFork(index).thinkingOverride;
+			return resolveFork(index);
 		},
 	};
 }

package/src/shared/launch-contract.ts

@@ -1,10 +1,13 @@
 import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import type { AgentConfig } from "../agents/agents.ts";
+import type { PiLaunchToolPlan } from "../runs/shared/child-tool-plan.ts";
 import type { ExtensionBindings } from "../runs/shared/extension-bindings.ts";
 
 export const AGENT_DEFINITION_PROJECTION_VERSION = 1 as const;
-export const LAUNCH_BINDING_PROJECTION_VERSION = 1 as const;
+// v2: the Intercom bridge prompt and tools are part of the binding on every
+// path, and the bridge text no longer names the parent session.
+export const LAUNCH_BINDING_PROJECTION_VERSION = 2 as const;
 
 function stableJson(value: unknown): string {
 	if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
@@ -75,8 +78,9 @@ export function projectAgentDefinition(agent: AgentConfig): Record<string, unkno
 	};
 }
 
+/** Digest of the parsed definition; a runtime overlay that already captured it wins over re-hashing the overlaid copy. */
 export function agentDefinitionDigest(agent: AgentConfig): string {
-	return stableJsonDigest(projectAgentDefinition(agent));
+	return agent.definitionDigest ?? stableJsonDigest(projectAgentDefinition(agent));
 }
 
 export interface LaunchBindingInput {
@@ -136,3 +140,62 @@ export function projectLaunchBinding(input: LaunchBindingInput): Record<string,
 export function launchBindingDigest(input: LaunchBindingInput): string {
 	return stableJsonDigest(projectLaunchBinding(input));
 }
+
+type LaunchBindingPromptMode = Pick<LaunchBindingInput, "systemPromptMode" | "inheritProjectContext" | "inheritGlobalContext" | "inheritSkills">;
+
+/**
+ * Who the child is: the launched agent, or the identity a persisted step
+ * already captured when a runner recomputes the binding per model attempt.
+ */
+export type LaunchBindingIdentity =
+	| { agent: AgentConfig }
+	| ({ definitionDigest: string } & LaunchBindingPromptMode);
+
+export type LaunchBindingSource = LaunchBindingIdentity
+	& Pick<LaunchBindingInput, "fast" | "thinking" | "skills" | "outputPath" | "outputMode" | "structuredOutputSchema" | "extensionBindings">
+	& {
+		task: string;
+		modelCandidates: string[];
+		/** Effective child system prompt before runtime acceptance prose. */
+		systemPrompt: string;
+		toolPlan: Pick<PiLaunchToolPlan, "effectiveToolAllowlist" | "excludeTools" | "extensionArgs" | "effectiveMcpTools">;
+	};
+
+export interface LaunchBinding {
+	definitionDigest: string;
+	launchContractDigest: string;
+}
+
+/**
+ * Assemble launch identity from resolved preflight or execution inputs.
+ * The stable projection omits undefined optional fields.
+ */
+export function resolveLaunchBinding(source: LaunchBindingSource): LaunchBinding {
+	const identity = "agent" in source ? {
+		definitionDigest: agentDefinitionDigest(source.agent),
+		systemPromptMode: source.agent.systemPromptMode,
+		inheritProjectContext: source.agent.inheritProjectContext,
+		inheritGlobalContext: source.agent.inheritGlobalContext,
+		inheritSkills: source.agent.inheritSkills,
+	} : source;
+	return {
+		definitionDigest: identity.definitionDigest,
+		launchContractDigest: launchBindingDigest({
+			...identity,
+			task: source.task,
+			modelCandidates: source.modelCandidates,
+			fast: source.fast,
+			thinking: source.thinking || undefined,
+			systemPrompt: source.systemPrompt,
+			skills: source.skills,
+			tools: source.toolPlan.effectiveToolAllowlist,
+			excludeTools: source.toolPlan.excludeTools.length > 0 ? source.toolPlan.excludeTools : undefined,
+			extensions: source.toolPlan.extensionArgs,
+			mcpDirectTools: source.toolPlan.effectiveMcpTools,
+			outputPath: source.outputPath || undefined,
+			outputMode: source.outputMode,
+			structuredOutputSchema: source.structuredOutputSchema || undefined,
+			extensionBindings: source.extensionBindings || undefined,
+		}),
+	};
+}

package/src/shared/opencode-session-headers.ts

@@ -0,0 +1,30 @@
+import type { Api, Model, ProviderHeaders } from "@earendil-works/pi-ai";
+
+const OPENCODE_HOST = "opencode.ai";
+
+function matchesOpenCodeHost(baseUrl: string): boolean {
+	try {
+		return new URL(baseUrl).hostname === OPENCODE_HOST;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * OpenCode session-routing headers for internal subagent model calls.
+ *
+ * Pi's own session path emits these from coding-agent's provider-attribution
+ * merge, but subagent-internal calls (watchdog review, permission arbiter,
+ * task-mutation arbiter, prompt audit) stream through bare Agents that bypass
+ * that path. Without them OpenCode falls back to client-IP affinity and loses
+ * prompt-cache routing (see pi issue #4847). Returns undefined for every other
+ * provider so non-OpenCode requests stay byte-identical.
+ */
+export function opencodeSessionHeaders(
+	model: Pick<Model<Api>, "provider" | "baseUrl">,
+	sessionId: string | undefined,
+): ProviderHeaders | undefined {
+	if (!sessionId) return undefined;
+	if (model.provider !== "opencode" && model.provider !== "opencode-go" && !matchesOpenCodeHost(model.baseUrl)) return undefined;
+	return { "x-opencode-session": sessionId, "x-opencode-client": "pi" };
+}