pi-crew 0.10.2 → 0.10.4

package/src/runtime/goal-workflow/goal-loop-runner.ts

@@ -20,7 +20,7 @@ import { createRequire } from "node:module";
 import type { AgentConfig } from "../../agents/agent-config.ts";
 import { loadConfig } from "../../config/config.ts";
 import { effectiveRunConfig } from "../../extension/team-tool/config-patch.ts";
-import { appendEvent } from "../../state/event-log/event-log.ts";
+import { appendEventBuffered } from "../../state/event-log/event-log.ts";
 import { registerActiveRun, unregisterActiveRun } from "../../state/stores/active-run-registry.ts";
 import { collectRunMetrics } from "../../state/stores/run-metrics.ts";
 import { createRunManifest, saveRunTasks } from "../../state/stores/state-store.ts";
@@ -121,7 +121,7 @@ export const realGoalEvaluator = async (
 				const drift = compareSnapshot(snapshot.snapshot, current);
 				if (drift.length > 0) {
 					verificationCompromised = drift;
-					appendEvent(turnManifest.eventsPath, {
+					appendEventBuffered(turnManifest.eventsPath, {
 						type: "goal.verification_compromised",
 						runId: turnRunId,
 						data: {
@@ -129,7 +129,7 @@ export const realGoalEvaluator = async (
 							driftedFiles: drift,
 							phase: "T_snap",
 						},
-					});
+					}).catch((e) => logInternalError("goal-loop.buffered", e, "type=goal.verification_compromised phase=T_snap"));
 				}
 			} catch (error) {
 				logInternalError("goal-loop.integritySnap", error, `goalId=${goal.goalId} phase=T_snap`);
@@ -201,7 +201,7 @@ export const realGoalEvaluator = async (
 							const postDrift = compareSnapshot(snapshot.snapshot, post);
 							if (postDrift.length > 0) {
 								verificationCompromised = postDrift;
-								appendEvent(turnManifest.eventsPath, {
+								appendEventBuffered(turnManifest.eventsPath, {
 									type: "goal.verification_compromised",
 									runId: turnRunId,
 									data: {
@@ -209,7 +209,9 @@ export const realGoalEvaluator = async (
 										driftedFiles: postDrift,
 										phase: "T_verify_done",
 									},
-								});
+								}).catch((e) =>
+									logInternalError("goal-loop.buffered", e, "type=goal.verification_compromised phase=T_verify_done"),
+								);
 							}
 						} catch (error) {
 							logInternalError("goal-loop.integritySnap", error, `goalId=${goal.goalId} phase=T_verify_done`);
@@ -521,7 +523,7 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 	const workflow = resolveGoalTurnWorkflow(goal);
 	const agents = input.deps.discoverAgents(goal.cwd);
 
-	appendEvent(eventsPath, {
+	appendEventBuffered(eventsPath, {
 		type: "goal.loop_start",
 		runId: manifest.runId,
 		data: {
@@ -529,7 +531,7 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 			objective: goal.objective,
 			maxTurns: goal.maxTurns,
 		},
-	});
+	}).catch((e) => logInternalError("goal-loop.buffered", e, "type=goal.loop_start"));
 
 	// P1g (RFC v0.5 §P1g, cold-review #2 BLOCKING fix): acquire the workspace lock for the
 	// goal's lifetime. This serializes concurrent goals targeting the same cwd (workspaceMode:
@@ -545,14 +547,14 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 	} catch (error) {
 		logInternalError("goal-loop.workspaceLock", error, `goalId=${goal.goalId} cwd=${goal.cwd}`);
 		goal = safeSetStatus(store, goal.goalId, "blocked", goal, eventsPath);
-		appendEvent(eventsPath, {
+		appendEventBuffered(eventsPath, {
 			type: "goal.workspace_lock_failed",
 			runId: manifest.runId,
 			data: {
 				goalId: goal.goalId,
 				error: error instanceof Error ? error.message : String(error),
 			},
-		});
+		}).catch((e) => logInternalError("goal-loop.buffered", e, "type=goal.workspace_lock_failed"));
 		return { manifest, tasks: [], goalState: goal };
 	}
 
@@ -570,7 +572,7 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 			if (goal.budgetUnlimited !== true && goal.budgetTotal !== undefined && goal.budgetTotal > 0 && goal.budgetAbort !== undefined) {
 				if (goal.budgetUsed >= goal.budgetAbort * goal.budgetTotal) {
 					goal = safeSetStatus(store, goal.goalId, "budget_exceeded", goal, eventsPath);
-					appendEvent(eventsPath, {
+					appendEventBuffered(eventsPath, {
 						type: "goal.budget_warning",
 						runId: manifest.runId,
 						data: {
@@ -579,11 +581,11 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 							budgetTotal: goal.budgetTotal,
 							threshold: "abort",
 						},
-					});
+					}).catch((e) => logInternalError("goal-loop.buffered", e, "type=goal.budget_warning threshold=abort"));
 					break;
 				}
 				if (goal.budgetUsed >= (goal.budgetWarning ?? 0.8) * goal.budgetTotal) {
-					appendEvent(eventsPath, {
+					appendEventBuffered(eventsPath, {
 						type: "goal.budget_warning",
 						runId: manifest.runId,
 						data: {
@@ -592,12 +594,12 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 							budgetTotal: goal.budgetTotal,
 							threshold: "warning",
 						},
-					});
+					}).catch((e) => logInternalError("goal-loop.buffered", e, "type=goal.budget_warning threshold=warning"));
 				}
 			}
 
 			const turnIndex = goal.turnsUsed + 1;
-			appendEvent(eventsPath, {
+			appendEventBuffered(eventsPath, {
 				type: "goal.turn_start",
 				runId: manifest.runId,
 				data: {
@@ -605,7 +607,7 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 					turn: turnIndex,
 					maxTurns: goal.maxTurns,
 				},
-			});
+			}).catch((e) => logInternalError("goal-loop.buffered", e, "type=goal.turn_start"));
 
 			// ── TURN: fresh manifest per turn (G2) + executeTeamRun ──────────────────
 			const turnGoalText = composeGoalPrompt(goal);
@@ -630,7 +632,7 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 			// Fix round-6: re-check state AFTER patching (user may have paused/stopped in the inter-turn gap).
 			// Without this, a pause that lands between store.patch and executeTeamRun lets one extra turn run.
 			if (goal.state !== "running") {
-				appendEvent(eventsPath, {
+				appendEventBuffered(eventsPath, {
 					type: "goal.loop_end",
 					runId: manifest.runId,
 					data: {
@@ -638,7 +640,7 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 						state: goal.state,
 						reason: "state changed before turn spawn",
 					},
-				});
+				}).catch((e) => logInternalError("goal-loop.buffered", e, "type=goal.loop_end reason=state_changed"));
 				break;
 			}
 			registerActiveRun(created.manifest);
@@ -688,7 +690,7 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 			const turnStatus = turnResult.manifest.status;
 			if (turnStatus === "blocked" || turnStatus === "failed") {
 				goal = safeSetStatus(store, goal.goalId, "blocked", goal, eventsPath);
-				appendEvent(eventsPath, {
+				appendEventBuffered(eventsPath, {
 					type: "goal.turn_terminal_status",
 					runId: manifest.runId,
 					data: {
@@ -697,7 +699,7 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 						turnRunId: created.manifest.runId,
 						turnStatus,
 					},
-				});
+				}).catch((e) => logInternalError("goal-loop.buffered", e, "type=goal.turn_terminal_status"));
 				break;
 			}
 
@@ -735,7 +737,7 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 					eventsPath,
 				) ?? goal;
 
-			appendEvent(eventsPath, {
+			appendEventBuffered(eventsPath, {
 				type: "goal.turn_evaluated",
 				runId: manifest.runId,
 				data: {
@@ -744,9 +746,9 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 					achieved: verdict.achieved,
 					reason: verdict.reason,
 				},
-			});
+			}).catch((e) => logInternalError("goal-loop.buffered", e, "type=goal.turn_evaluated"));
 			if (!verdict.achieved && goal.nextTurnFeedback) {
-				appendEvent(eventsPath, {
+				appendEventBuffered(eventsPath, {
 					type: "goal.feedback_steered",
 					runId: manifest.runId,
 					data: {
@@ -754,7 +756,7 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 						turn: turnIndex,
 						feedback: goal.nextTurnFeedback,
 					},
-				});
+				}).catch((e) => logInternalError("goal-loop.buffered", e, "type=goal.feedback_steered"));
 			}
 
 			// ── STOP CONDITIONS (round-7: re-read disk before applying — external cancel/pause wins) ─
@@ -781,7 +783,7 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 				const stuck = store.compareAndSetStatus(goal.goalId, "running", "stuck", eventsPath);
 				if (stuck) {
 					goal = stuck;
-					appendEvent(eventsPath, {
+					appendEventBuffered(eventsPath, {
 						type: "goal.stuck",
 						runId: manifest.runId,
 						data: {
@@ -789,7 +791,7 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 							turn: goal.turnsUsed,
 							lastReasons: goal.verdicts.slice(-3).map((v) => v.reason.slice(0, 200)),
 						},
-					});
+					}).catch((e) => logInternalError("goal-loop.buffered", e, "type=goal.stuck"));
 					break;
 				}
 			}
@@ -811,7 +813,7 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 		} catch {
 			/* best-effort */
 		}
-		appendEvent(eventsPath, {
+		appendEventBuffered(eventsPath, {
 			type: "goal.loop_end",
 			runId: manifest.runId,
 			data: {
@@ -820,7 +822,7 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 				turnsUsed: goal.turnsUsed,
 				budgetUsed: goal.budgetUsed,
 			},
-		});
+		}).catch((e) => logInternalError("goal-loop.buffered", e, "type=goal.loop_end reason=normal"));
 	}
 
 	return { manifest, tasks: [], goalState: goal };

package/src/runtime/goal-workflow/goal-state-store.ts

@@ -81,6 +81,9 @@ export class GoalStore {
 			mkdirSync(dirname(path), { recursive: true });
 			atomicWriteJson(path, next);
 			if (eventsPath) {
+				// REVIEW FIX (2026-09-10): reverted M2b buffered conversion —
+				// goal.state_changed is read back synchronously by CAS tests and
+				// goal status display; low-frequency transition event.
 				appendEvent(eventsPath, {
 					type: "goal.state_changed",
 					runId: state.goalId,

package/src/runtime/heartbeat/heartbeat-watcher.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { NotificationDescriptor } from "../../extension/notification-router.ts";
 import type { MetricRegistry } from "../../observability/metric-registry.ts";
-import { appendEvent } from "../../state/event-log/event-log.ts";
+import { appendEventBuffered } from "../../state/event-log/event-log.ts";
 import { loadRunManifestById } from "../../state/stores/state-store.ts";
 import type { TeamRunManifest } from "../../state/types.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
@@ -175,7 +175,7 @@ export class HeartbeatWatcher {
 				this.lastLevel.set(key, level);
 				if (level === "dead" && previous !== "dead") {
 					this.opts.registry.counter("crew.heartbeat.dead_total", "Dead heartbeat detections").inc({ runId: run.runId });
-					appendEvent(loaded.manifest.eventsPath, {
+					appendEventBuffered(loaded.manifest.eventsPath, {
 						type: "crew.task.heartbeat_dead",
 						runId: run.runId,
 						taskId: task.id,
@@ -183,7 +183,7 @@ export class HeartbeatWatcher {
 						data: {
 							elapsedMs: Number.isFinite(elapsed) ? elapsed : undefined,
 						},
-					});
+					}).catch((e) => logInternalError("heartbeat_watcher.buffered", e, "type=crew.task.heartbeat_dead"));
 					// W9 fix — prefix title with short run label (first 8 chars of runId)
 					// so ambient notifications are scannable when multiple runs are
 					// in flight. Full runId remains in the notification object.

package/src/runtime/live-session/live-agent-manager.ts

@@ -119,15 +119,18 @@ export function registerLiveAgent(
 		const completed = [...liveAgents.entries()].find(([, h]) => h.activity.completedAtMs > 0);
 		if (completed) {
 			liveAgents.delete(completed[0]);
+			invalidateSortedLiveAgents();
 		} else {
 			const oldestKey = liveAgents.keys().next().value;
 			if (oldestKey !== undefined) {
 				logInternalError("live-agent-manager.cap", new Error(`liveAgents at cap ${MAX_LIVE_AGENTS}; evicting oldest ${oldestKey}`));
 				liveAgents.delete(oldestKey);
+				invalidateSortedLiveAgents();
 			}
 		}
 	}
 	liveAgents.set(input.agentId, handle);
+	invalidateSortedLiveAgents();
 	try {
 		if (eventLogFn && eventsPath)
 			eventLogFn(eventsPath, {
@@ -172,6 +175,7 @@ export function updateLiveAgentStatus(agentId: string, status: CrewAgentRecord["
 	if (!handle) return;
 	handle.status = status;
 	handle.updatedAt = new Date().toISOString();
+	invalidateSortedLiveAgents();
 }
 
 function safeDisposeLiveSession(handle: LiveAgentHandle): void {
@@ -198,6 +202,7 @@ export async function terminateLiveAgent(
 	if (!handle) return undefined;
 	handle.status = status;
 	handle.updatedAt = new Date().toISOString();
+	invalidateSortedLiveAgents();
 	try {
 		if (eventLogFn && eventsPath)
 			eventLogFn(eventsPath, {
@@ -220,6 +225,7 @@ export async function terminateLiveAgent(
 	} finally {
 		safeDisposeLiveSession(handle);
 		liveAgents.delete(handle.agentId); // Move AFTER abort completes to prevent race
+		invalidateSortedLiveAgents();
 	}
 	return handle;
 }
@@ -260,6 +266,7 @@ export function evictStaleLiveAgentHandles(now = Date.now()): number {
 			// Terminal handle — evict after grace period
 			if (age > STALE_HANDLE_MS) {
 				liveAgents.delete(agentId);
+				invalidateSortedLiveAgents();
 				safeDisposeLiveSession(handle);
 				evicted++;
 			}
@@ -289,6 +296,7 @@ export function evictStaleLiveAgentHandles(now = Date.now()): number {
 			const liveness = checkProcessLiveness(sessionPid);
 			if (!liveness.alive) {
 				liveAgents.delete(agentId);
+				invalidateSortedLiveAgents();
 				safeDisposeLiveSession(handle);
 				evicted++;
 			}
@@ -297,8 +305,24 @@ export function evictStaleLiveAgentHandles(now = Date.now()): number {
 	return evicted;
 }
 
+// PERF (2026-08-24): listLiveAgents is called 4-6x per render frame and used to
+// copy + sort with ICU localeCompare every call. ISO-8601 strings are fixed-width
+// and sort correctly with plain operators; the sorted array is memoized and
+// invalidated at every map mutation. NOTE: callers receive the SHARED memoized
+// array — never sort or mutate it in place; copy (slice/spread) first.
+let sortedLiveAgents: LiveAgentHandle[] | undefined;
+function invalidateSortedLiveAgents(): void {
+	sortedLiveAgents = undefined;
+}
 export function listLiveAgents(): LiveAgentHandle[] {
-	return [...liveAgents.values()].sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""));
+	if (!sortedLiveAgents) {
+		sortedLiveAgents = [...liveAgents.values()].sort((a, b) => {
+			const au = a.updatedAt ?? "";
+			const bu = b.updatedAt ?? "";
+			return au < bu ? 1 : au > bu ? -1 : 0;
+		});
+	}
+	return sortedLiveAgents;
 }
 
 export function listActiveLiveAgents(): LiveAgentHandle[] {
@@ -324,6 +348,7 @@ export async function steerLiveAgent(agentIdOrTaskId: string, message: string):
 	}
 	await handle.session.steer(message);
 	handle.updatedAt = new Date().toISOString();
+	invalidateSortedLiveAgents();
 	return handle;
 }
 
@@ -339,6 +364,7 @@ export async function followUpLiveAgent(agentIdOrTaskId: string, prompt: string)
 		expandPromptTemplates: false,
 	});
 	handle.updatedAt = new Date().toISOString();
+	invalidateSortedLiveAgents();
 	return handle;
 }
 
@@ -359,6 +385,7 @@ export async function resumeLiveAgent(agentIdOrTaskId: string, prompt: string):
 	});
 	handle.status = "completed";
 	handle.updatedAt = new Date().toISOString();
+	invalidateSortedLiveAgents();
 	return handle;
 }
 
@@ -377,6 +404,7 @@ export function trackLiveAgentToolStart(agentIdOrTaskId: string, toolName: strin
 	handle.activity.activeTools.set(toolName, toolName);
 	handle.activity.toolUses++;
 	handle.updatedAt = new Date().toISOString();
+	invalidateSortedLiveAgents();
 }
 
 /** G2: Track tool end for a live agent. */
@@ -394,6 +422,7 @@ export function trackLiveAgentTurnEnd(agentIdOrTaskId: string, compaction = fals
 	if (compaction) handle.activity.compactionCount++;
 	handle.activity.activeTools.clear();
 	handle.updatedAt = new Date().toISOString();
+	invalidateSortedLiveAgents();
 }
 
 /** G2: Track assistant response text. */
@@ -413,6 +442,7 @@ export function markLiveAgentCompleted(agentIdOrTaskId: string): void {
 
 export function clearLiveAgentsForTest(): void {
 	liveAgents.clear();
+	invalidateSortedLiveAgents();
 }
 
 /** Phase 7/G4: Send an IRC message to a specific live agent (DM).
@@ -427,6 +457,7 @@ export function sendIrcMessage(targetAgentId: string, message: IrcMessage): void
 	}
 	handle.pendingMessages.push(message);
 	handle.updatedAt = new Date().toISOString();
+	invalidateSortedLiveAgents();
 	// G4: Try non-blocking delivery via sendCustomMessage
 	const session = handle.session as Record<string, unknown>;
 	if (typeof session.sendCustomMessage === "function") {
@@ -467,6 +498,7 @@ export function broadcastIrcMessage(fromAgentId: string, message: IrcMessage): s
 		}
 		handle.pendingMessages.push(message);
 		handle.updatedAt = new Date().toISOString();
+		invalidateSortedLiveAgents();
 		// G4: Try non-blocking delivery
 		const session = handle.session as Record<string, unknown>;
 		if (typeof session.sendCustomMessage === "function") {
@@ -600,6 +632,7 @@ export async function respondAsBackground(
 			error: `Target '${targetAgentId}' has no message channel.`,
 		};
 	handle.updatedAt = new Date().toISOString();
+	invalidateSortedLiveAgents();
 
 	if (!awaitReply) return { ok: true, corrId };
 

package/src/runtime/live-session/live-control-realtime.ts

@@ -19,6 +19,16 @@ export function subscribeLiveControlRealtime(listener: Listener): () => void {
 	return () => listeners.delete(listener);
 }
 
+/**
+ * Task 26 (2026-08-24): poll-interval gate for live-session control polling.
+ * True while at least one realtime listener is registered — in that mode
+ * in-process control requests are delivered immediately and the file poll is
+ * only a cross-process fallback, so the poller can run slower.
+ */
+export function hasLiveControlRealtimeListeners(): boolean {
+	return listeners.size > 0;
+}
+
 export function liveControlRealtimeMessage(request: LiveAgentControlRequest): LiveControlRealtimeMessage {
 	return { type: "live-control", version: 1, request };
 }

package/src/runtime/live-session/live-session-runtime.ts

@@ -1,5 +1,3 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
 import type { AgentConfig } from "../../agents/agent-config.ts";
 import { resolveToolPolicy } from "../../agents/agent-config.ts";
 import type { CrewRuntimeConfig } from "../../config/config.ts";
@@ -11,6 +9,7 @@ import type { TeamRunManifest, TeamTaskState, UsageState } from "../../state/typ
 import { logInternalError } from "../../utils/internal-error.ts";
 import { redactSecrets } from "../../utils/redaction.ts";
 import type { WorkflowStep } from "../../workflows/workflow-config.ts";
+import { BoundedTail } from "../compaction/compact-stages/bounded-tail.ts";
 import { createIrcTool } from "../custom-tools/irc-tool.ts";
 import { createSubmitResultTool } from "../custom-tools/submit-result-tool.ts";
 import { buildMcpProxyFromSession } from "../mcp-proxy.ts";
@@ -28,7 +27,13 @@ import { readEnabledModelsPatterns } from "../model/model-scope.ts";
 import { isLiveSessionRuntimeAvailable } from "../model/runtime-resolver.ts";
 import { awaitRuntimeWarmup } from "../model/runtime-warmup.ts";
 import { liveAgentContext, registerLiveAgentModel, unregisterLiveAgentModel } from "../model/session-model.ts";
-import { eventToSidechainType, sidechainOutputPath, writeSidechainEntry } from "../output/sidechain-output.ts";
+import {
+	appendBatchedJsonlLine,
+	eventToSidechainType,
+	flushPendingSidechainWrites,
+	sidechainOutputPath,
+	writeSidechainEntry,
+} from "../output/sidechain-output.ts";
 // NOTE: buildMemoryBlock is intentionally NOT imported here. The agent memory
 // block is injected via renderTaskPrompt().full (the USER prompt), which is
 // shared by both the child-pi path (no system prompt) and the live-session
@@ -60,7 +65,7 @@ import {
 	trackLiveAgentTurnEnd,
 	updateLiveAgentStatus,
 } from "./live-agent-manager.ts";
-import { subscribeLiveControlRealtime } from "./live-control-realtime.ts";
+import { hasLiveControlRealtimeListeners, subscribeLiveControlRealtime } from "./live-control-realtime.ts";
 import { buildExtensionBridge } from "./live-extension-bridge.ts";
 import { collectLiveSessionHealth, formatLiveSessionDiagnostics } from "./live-session-health.ts";
 
@@ -178,20 +183,13 @@ type LiveSessionLike = {
 
 function appendTranscript(filePath: string | undefined, event: unknown): void {
 	if (!filePath) return;
-	// Fire-and-forget async write to avoid blocking the event loop.
-	// Transcript writes are best-effort telemetry — callers do not need to await.
-	void appendTranscriptAsync(filePath, event);
-}
-
-/** Async version of appendTranscript — fire-and-forget for non-blocking writes. */
-async function appendTranscriptAsync(filePath: string, event: unknown): Promise<void> {
-	try {
-		await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
-		const content = `${JSON.stringify(redactSecrets(event))}\n`;
-		await fs.promises.appendFile(filePath, content, "utf-8");
-	} catch (error) {
-		logInternalError("live-session.transcript-write-failed", error as Error, `path=${filePath}`);
-	}
+	// Task 26 (2026-08-24): serialize + redact at queue time, then route
+	// through the shared 50ms batched JSONL writer (one mkdir + appendFileSync
+	// per path per window instead of one async mkdir+appendFile PER streaming
+	// event). child-pi-transcript's batched writer is not generic over plain
+	// paths (ChildPiRunInput + artifactsRoot containment + re-redaction), so
+	// the identical map lives in sidechain-output.ts.
+	appendBatchedJsonlLine(filePath, `${JSON.stringify(redactSecrets(event))}\n`);
 }
 
 function asRecord(value: unknown): Record<string, unknown> | undefined {
@@ -630,6 +628,9 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 			message: event,
 			cwd: input.task.cwd,
 		});
+		// Task 26: the mock path returns before the try/finally below, so drain
+		// the batched writers here — tests read these files right after return.
+		flushPendingSidechainWrites();
 		if (isCurrent()) input.onEvent?.(event);
 		const stdout = `Mock live-session success for ${input.agent.name}${inherited}`;
 		if (isCurrent()) input.onOutput?.(stdout);
@@ -678,7 +679,13 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 	let unsubscribe: (() => void) | undefined;
 	let unsubscribeControlRealtime: (() => void) | undefined;
 	let controlTimer: ReturnType<typeof setInterval> | undefined;
-	let stdout = "";
+	// PERF (2026-08-24): unbounded string concat re-copies the whole transcript
+	// on every chunk; bounded tail keeps whatever the consumer actually reads.
+	// Consumer sizing: stdout becomes parsedOutput.finalText + the
+	// results/{taskId}.txt artifact — the same downstream consumers the
+	// child-pi path already caps at maxCaptureBytes (512 KiB) via BoundedTail,
+	// so we match that cap for parity (this is NOT a tail-only preview).
+	const stdoutTail = new BoundedTail();
 	let jsonEvents = 0;
 	const collectedJsonEvents: Record<string, unknown>[] | undefined = yieldEnabled ? [] : undefined;
 	const maxCollectedJsonEvents = 1000;
@@ -898,9 +905,18 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 			});
 		});
 		await pollControl();
-		controlTimer = setInterval(() => {
-			if (isCurrent()) void pollControl();
-		}, 500);
+		// PERF (2026-08-24): each poll does existsSync + readFileSync + JSON.parse
+		// of the whole control JSONL. With a realtime subscription active for this
+		// agent, in-process control requests (team-tool / cross-extension RPC
+		// publish) are delivered immediately and the poll only covers cross-process
+		// writers → 1000ms. Without realtime, the file poll is the sole delivery
+		// path → keep the faster 500ms cadence.
+		controlTimer = setInterval(
+			() => {
+				if (isCurrent()) void pollControl();
+			},
+			hasLiveControlRealtimeListeners() ? 1000 : 500,
+		);
 		let turnCount = 0;
 		let softLimitReached = false;
 		const maxTurns = input.runtimeConfig?.maxTurns;
@@ -953,7 +969,7 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 					input.onEvent?.(event);
 					const text = [...eventText(event), ...finalAssistantText(event)].join("\n");
 					if (text.trim()) {
-						stdout += `${text}\n`;
+						stdoutTail.push(`${text}\n`);
 						streamOut?.write(text + "\n");
 						trackLiveAgentResponseText(agentId, text);
 						input.onOutput?.(text);
@@ -1034,7 +1050,7 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 				return {
 					available: true,
 					exitCode: 1,
-					stdout: stdout.trim(),
+					stdout: stdoutTail.value().trim(),
 					stderr: msg,
 					jsonEvents,
 					error: msg,
@@ -1050,7 +1066,7 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 			data: {
 				elapsedMs: Date.now() - promptStart,
 				jsonEvents,
-				outputLength: stdout.length,
+				outputLength: stdoutTail.value().length,
 			},
 		});
 
@@ -1171,7 +1187,7 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 		return {
 			available: true,
 			exitCode: 0,
-			stdout: stdout.trim(),
+			stdout: stdoutTail.value().trim(),
 			stderr: created.modelFallbackMessage ?? "",
 			jsonEvents,
 			usage,
@@ -1205,7 +1221,7 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 		return {
 			available: true,
 			exitCode: 1,
-			stdout: stdout.trim(),
+			stdout: stdoutTail.value().trim(),
 			stderr: message,
 			jsonEvents,
 			error: message,
@@ -1220,6 +1236,10 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 		// H6: Unsubscribe listeners FIRST before clearing timer to prevent race
 		unsubscribe?.();
 		unsubscribeControlRealtime?.();
+		// Task 26 (2026-08-24): drain the batched sidechain/transcript writers
+		// now that no more session events can enqueue, so callers that read the
+		// files right after this task settles see complete content.
+		flushPendingSidechainWrites();
 		// Round 27 (BUG 4): remove the named abort listener to avoid leaking it
 		// on the shared AbortSignal across many live-session tasks.
 		if (onSignalAbort) input.signal?.removeEventListener("abort", onSignalAbort);