pi-cohort 5.3.2 → 5.3.4

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [Unreleased]
+
+## [5.3.4] - 2026-09-07
+
+### Fixed
+
+- A fanout lead no longer loses its own `subagent` call/result before its next turn: the child-context filter now only strips `subagent` history inherited from a forked parent (captured at `session_start`), not the child's own delegation made during its own session. Previously a deterministic provider would see the delegation as never having happened and repeat it instead of finishing.
+
+## [5.3.3] - 2026-09-07
+
+### Fixed
+
+- Nested foreground delegation no longer crashes when a grandchild reports cost progress because child-safe state now initializes the required grand-total accumulator. ([#13](https://github.com/jjuraszek/pi-cohort/issues/13))
+
 ## [5.3.2] - 2026-09-06
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-cohort",
-  "version": "5.3.2",
+  "version": "5.3.4",
   "description": "Delegate Pi work to focused child agents: code review, scouting, implementation, parallel audits, saved chains, and background jobs.",
   "author": "Jacek Juraszek",
   "license": "MIT",

package/src/extension/fanout-child.ts

@@ -13,6 +13,7 @@ import { SubagentParams } from "./schemas.ts";
 import { loadConfig } from "./config.ts";
 import { deriveForwardedFlags } from "../runs/shared/forward-flags.ts";
 import type { Details, SubagentState } from "../shared/types.ts";
+import { emptyGrandTotal } from "./grand-total.ts";
 
 function getSubagentSessionRoot(parentSessionFile: string | null): string {
 	if (parentSessionFile) {
@@ -32,6 +33,7 @@ function createChildSafeState(): SubagentState {
 		baseCwd: "",
 		currentSessionId: null,
 		asyncJobs: new Map(),
+		grandTotal: emptyGrandTotal(),
 		foregroundRuns: new Map(),
 		foregroundControls: new Map(),
 		lastForegroundControlId: null,

package/src/runs/shared/subagent-prompt-runtime.ts

@@ -115,34 +115,44 @@ function isParentOnlySubagentMessage(message: unknown): boolean {
 		&& PARENT_ONLY_CUSTOM_MESSAGE_TYPES.has(m.customType);
 }
 
-function isSubagentToolResultMessage(message: unknown): boolean {
-	const m = message as { role?: string; toolName?: string };
-	return m?.role === "toolResult" && m.toolName === "subagent";
+function isSubagentToolResultMessage(message: unknown, inheritedToolCallIds: ReadonlySet<string>): boolean {
+	const m = message as { role?: string; toolName?: string; toolCallId?: string };
+	if (m?.role !== "toolResult" || m.toolName !== "subagent") return false;
+	return typeof m.toolCallId === "string" && inheritedToolCallIds.has(m.toolCallId);
 }
 
-function isSubagentToolCallBlock(block: unknown): boolean {
-	const b = block as { type?: string; name?: string };
-	return b?.type === "toolCall" && b.name === "subagent";
+function isInheritedSubagentToolCallBlock(block: unknown, inheritedToolCallIds: ReadonlySet<string>): boolean {
+	const b = block as { type?: string; name?: string; id?: string };
+	if (b?.type !== "toolCall" || b.name !== "subagent") return false;
+	return typeof b.id === "string" && inheritedToolCallIds.has(b.id);
 }
 
-function stripAssistantSubagentToolCallBlocks(message: unknown): unknown | undefined {
+function stripAssistantSubagentToolCallBlocks(message: unknown, inheritedToolCallIds: ReadonlySet<string>): unknown | undefined {
 	const m = message as { role?: string; content?: unknown };
 	if (m?.role !== "assistant" || !Array.isArray(m.content)) return message;
-	const filteredContent = m.content.filter((block) => !isSubagentToolCallBlock(block));
+	const filteredContent = m.content.filter((block) => !isInheritedSubagentToolCallBlock(block, inheritedToolCallIds));
 	if (filteredContent.length === m.content.length) return message;
 	if (filteredContent.length === 0) return undefined;
 	return { ...m, content: filteredContent };
 }
 
-export function stripParentOnlySubagentMessages(messages: unknown[]): unknown[] {
+/**
+ * Strips parent-only orchestration artifacts from a child's context.
+ *
+ * `inheritedToolCallIds` distinguishes history inherited from a forked parent
+ * session (ids captured before the child's own first turn) from the child's
+ * own `subagent` calls/results made during its own session - only the former
+ * is stripped.
+ */
+export function stripParentOnlySubagentMessages(messages: unknown[], inheritedToolCallIds: ReadonlySet<string>): unknown[] {
 	let changed = false;
 	const filtered: unknown[] = [];
 	for (const message of messages) {
-		if (isParentOnlySubagentMessage(message) || isSubagentToolResultMessage(message)) {
+		if (isParentOnlySubagentMessage(message) || isSubagentToolResultMessage(message, inheritedToolCallIds)) {
 			changed = true;
 			continue;
 		}
-		const stripped = stripAssistantSubagentToolCallBlocks(message);
+		const stripped = stripAssistantSubagentToolCallBlocks(message, inheritedToolCallIds);
 		if (stripped === undefined) {
 			changed = true;
 			continue;
@@ -153,6 +163,19 @@ export function stripParentOnlySubagentMessages(messages: unknown[]): unknown[]
 	return changed ? filtered : messages;
 }
 
+function collectSubagentToolCallIds(entries: readonly unknown[]): Set<string> {
+	const ids = new Set<string>();
+	for (const entry of entries) {
+		const e = entry as { type?: string; message?: { role?: string; content?: unknown } };
+		if (e?.type !== "message" || e.message?.role !== "assistant" || !Array.isArray(e.message.content)) continue;
+		for (const block of e.message.content) {
+			const b = block as { type?: string; name?: string; id?: string };
+			if (b?.type === "toolCall" && b.name === "subagent" && typeof b.id === "string") ids.add(b.id);
+		}
+	}
+	return ids;
+}
+
 export default function registerSubagentPromptRuntime(pi: ExtensionAPI): void {
 	const structuredOutputPath = process.env[STRUCTURED_OUTPUT_CAPTURE_ENV];
 	const structuredSchemaPath = process.env[STRUCTURED_OUTPUT_SCHEMA_ENV];
@@ -192,11 +215,21 @@ export default function registerSubagentPromptRuntime(pi: ExtensionAPI): void {
 		});
 	}
 
-	const onRuntimeEvent = pi.on as unknown as (event: string, handler: (event: unknown) => unknown) => void;
-	onRuntimeEvent("context", (event: { messages: unknown[] }) => {
-		const messages = stripParentOnlySubagentMessages(event.messages);
-		if (messages === event.messages) return undefined;
-		return { messages };
+	let inheritedSubagentToolCallIds: ReadonlySet<string> = new Set<string>();
+	const onRuntimeEvent = pi.on as unknown as (
+		event: string,
+		handler: (event: unknown, ctx?: { sessionManager?: { getBranch(): unknown[] } }) => unknown,
+	) => void;
+	onRuntimeEvent("session_start", (_event: unknown, ctx?: { sessionManager?: { getBranch(): unknown[] } }) => {
+		// Establishes the inherited/own boundary once, before the child's own first turn: any
+		// `subagent` call already in the branch at this point came from the (forked) parent.
+		inheritedSubagentToolCallIds = collectSubagentToolCallIds(ctx?.sessionManager?.getBranch() ?? []);
+	});
+	onRuntimeEvent("context", (event: unknown) => {
+		const { messages } = event as { messages: unknown[] };
+		const stripped = stripParentOnlySubagentMessages(messages, inheritedSubagentToolCallIds);
+		if (stripped === messages) return undefined;
+		return { messages: stripped };
 	});
 
 	onRuntimeEvent("before_agent_start", async (event: { systemPrompt: string }) => {