pi-crew 0.9.42 → 0.9.44

package/src/runtime/compact-stages/tail-capture-stage.ts

@@ -59,7 +59,7 @@ export class TailCaptureStage implements ICompactStage {
 			// never contains a partial multi-byte sequence.
 			if (Buffer.byteLength(text, "utf-8") <= this.maxBytes) return text;
 			let tail = text.slice(Math.max(0, text.length - this.maxBytes));
-			while (Buffer.byteLength(tail, "utf-8") > this.maxBytes) tail = tail.slice(1024);
+			while (Buffer.byteLength(tail, "utf-8") > this.maxBytes) tail = tail.slice(0, -1);
 			return this.marker ? `${this.marker}\n${tail}` : tail;
 		}
 		// Char cap mode.

package/src/runtime/dwf-state-store.ts

@@ -28,6 +28,11 @@ export interface DwfCheckpointState {
 	logs: string[]; // capped copy (≤1000); the events log (dwf.log) is the durable source of truth
 	spent: number; // budget accumulator (round-14 P1-2)
 	agentCount: number;
+	/** PERS-1: per-agent-call idempotency cache. Maps a deterministic call ID to the
+	 *  cached result so a DWF resume skips already-completed agent calls (avoids
+	 *  duplicating artifacts/mailbox/tokens). Uses Record (not Map) for JSON
+	 *  serialization safety. */
+	completedAgentCalls?: Record<string, { text: string; usage?: { input: number; output: number } }>;
 	updatedAt: string;
 }
 

package/src/runtime/dynamic-workflow-context.ts

@@ -35,6 +35,7 @@ import { logInternalError } from "../utils/internal-error.ts";
 import { cleanupAgentWorktreeAsync, prepareAgentWorktreeAsync } from "../worktree/worktree-manager.ts";
 import { runChildPi } from "./child-pi.ts";
 import type { DwfCheckpointState } from "./dwf-state-store.ts";
+import { withWorkerSlot } from "./global-worker-cap.ts";
 import { mapConcurrent } from "./parallel-utils.ts";
 import { parsePiJsonOutput } from "./pi-json-output.ts";
 import { renderPlanTemplate } from "./plan-templates.ts";
@@ -269,6 +270,11 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 		logs: opts.resumedState ? [...opts.resumedState.logs].slice(0, 1000) : [],
 		args: opts.args ?? {},
 	};
+	// PERS-1: per-agent-call idempotency cache. Hydrated from resumedState so a DWF
+	// resume skips already-completed agent calls (avoids duplicating artifacts/mailbox/tokens).
+	// Uses Record (not Map) for JSON serialization safety.
+	const completedAgentCalls: Record<string, { text: string; usage?: { input: number; output: number } }> =
+		opts.resumedState?.completedAgentCalls ?? {};
 	// round-14 P1-2: frozen budget surface. The closures read wfState.spent so the
 	// object stays live after Object.freeze(ctx). total is a snapshot primitive.
 	const budget = Object.freeze({
@@ -290,10 +296,35 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 			// regardless of which return/throw path is taken.
 			let worktreePath: string | undefined;
 			let worktreeBranch: string | undefined;
+			// BDG-2: declared before the try so the catch block can un-reserve on failure.
+			const ESTIMATE = 4096;
+			let reserved = false;
 			try {
-				// round-14 P1-2: budget check BEFORE spawning. When the per-workflow token
-				// budget is exhausted, reject the call without consuming a child worker.
-				if (budget.total !== null && budget.remaining() <= 0) {
+				// PERS-1: per-agent-call idempotency. Compute a deterministic call ID
+				// from the call arguments and check if this call was already completed
+				// (e.g. during a previous run before a crash). If so, return the cached
+				// result without re-spawning the agent.
+				const callId = JSON.stringify({
+					role: call.role,
+					agent: call.agent,
+					prompt: call.prompt,
+					model: call.model,
+					schema: call.schema ? "yes" : "no",
+				});
+				const cached = completedAgentCalls[callId];
+				if (cached) {
+					return {
+						ok: true,
+						text: cached.text,
+						usage: cached.usage,
+						durationMs: 0,
+					};
+				}
+
+				// BDG-2: reserve-then-adjust budget. Before spawning, estimate the cost and
+				// reserve it by adding to wfState.spent. This prevents N concurrent calls from
+				// all seeing the same remaining budget and overspending.
+				if (budget.total !== null && budget.remaining() < ESTIMATE) {
 					return {
 						ok: false,
 						text: "",
@@ -301,6 +332,10 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 						durationMs: 0,
 					};
 				}
+				// Reserve the estimate before spawning.
+				wfState.spent += ESTIMATE;
+				reserved = true;
+
 				const agentConfig = resolveAgentForRole(call.role, {
 					explicitAgent: call.agent,
 					team: opts.team,
@@ -353,20 +388,25 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 					}
 				}
 
-				const childResult = await runChildPi({
-					cwd: agentCwd,
-					task,
-					agent: effectiveAgent,
-					model: call.model ?? opts.modelOverride ?? agentConfig.model,
-					skillPaths: undefined, // skills resolved via agent config + team-role plumbing
-					maxTurns: call.maxTurns,
-					graceTurns: call.graceTurns,
-					signal: opts.signal,
-					artifactsRoot: manifest.artifactsRoot,
-					runId: manifest.runId,
-					role: call.role ?? call.agent,
-				});
+				const childResult = await withWorkerSlot(() =>
+					runChildPi({
+						cwd: agentCwd,
+						task,
+						agent: effectiveAgent,
+						model: call.model ?? opts.modelOverride ?? agentConfig.model,
+						skillPaths: undefined, // skills resolved via agent config + team-role plumbing
+						maxTurns: call.maxTurns,
+						graceTurns: call.graceTurns,
+						signal: opts.signal,
+						artifactsRoot: manifest.artifactsRoot,
+						runId: manifest.runId,
+						role: call.role ?? call.agent,
+					}),
+				);
 				if (childResult.exitCode !== 0 || childResult.error) {
+					// BDG-2: un-reserve the estimate on spawn failure.
+					wfState.spent -= ESTIMATE;
+					reserved = false;
 					return {
 						ok: false,
 						text: "",
@@ -376,8 +416,10 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 				}
 				const parsed = parsePiJsonOutput(childResult.stdout);
 				// round-14 P1-2: accumulate this run's token usage into the workflow budget.
-				// Covers both the success and schema-mismatch paths (both report parsed.usage).
-				wfState.spent += (parsed.usage?.input ?? 0) + (parsed.usage?.output ?? 0);
+				// BDG-2: adjust the reserve — subtract the estimate, add the actual usage.
+				// This correctly reduces spent when actualUsage < ESTIMATE.
+				wfState.spent += (parsed.usage?.input ?? 0) + (parsed.usage?.output ?? 0) - ESTIMATE;
+				reserved = false;
 				let text = parsed.finalText ?? "";
 				// Round-11 test fix: parsePiJsonOutput only extracts text from pi event stream
 				// ({type:"message_end", message:{role:"assistant", content:[...]}}). When the
@@ -400,6 +442,7 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 					producer: "dynamic-workflow",
 				});
 				if (call.schema !== undefined && !extracted.structured) {
+					// BDG-2: un-reserve was already done above (reserved = false after adjust).
 					return {
 						ok: false,
 						text,
@@ -409,6 +452,11 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 						durationMs: Date.now() - started,
 					};
 				}
+				// PERS-1: cache the successful result for idempotency on resume.
+				completedAgentCalls[callId] = {
+					text,
+					usage: { input: parsed.usage?.input ?? 0, output: parsed.usage?.output ?? 0 },
+				};
 				return {
 					ok: true,
 					text,
@@ -418,6 +466,8 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 					durationMs: Date.now() - started,
 				};
 			} catch (error) {
+				// BDG-2: un-reserve the estimate on failure (only if still reserved).
+				if (reserved) wfState.spent -= ESTIMATE;
 				logInternalError("dynamic-workflow-context.agent", error, `runId=${manifest.runId}`);
 				return {
 					ok: false,
@@ -450,6 +500,7 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 							logs: wfState.logs.slice(0, 1000),
 							spent: wfState.spent,
 							agentCount,
+							completedAgentCalls,
 							updatedAt: new Date().toISOString(),
 						});
 					} catch (checkpointError) {
@@ -709,6 +760,12 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 		get: () => agentCount,
 		enumerable: false,
 	});
+	// PERS-1: completedAgentCalls is read-only from the runner; the agent() method
+	// is the only writer. Exposed so getWorkflowCheckpoint() can include it.
+	Object.defineProperty(ctx, "__completedAgentCalls", {
+		get: () => completedAgentCalls,
+		enumerable: false,
+	});
 	return ctx;
 }
 
@@ -757,6 +814,9 @@ export function getWorkflowCheckpoint(ctx: WorkflowCtx): DwfCheckpointState {
 		logs: logs ?? [],
 		spent: ctx.budget.spent(),
 		agentCount: (ctx as unknown as { __agentCount?: number }).__agentCount ?? 0,
+		completedAgentCalls:
+			(ctx as unknown as { __completedAgentCalls?: Record<string, { text: string; usage?: { input: number; output: number } }> })
+				.__completedAgentCalls ?? {},
 		updatedAt: new Date().toISOString(),
 	};
 }

package/src/runtime/dynamic-workflow-runner.ts

@@ -19,6 +19,7 @@
 
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { transformSync } from "esbuild";
 import { writeArtifact } from "../state/artifact-store.ts";
 import { appendEvent } from "../state/event-log.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
@@ -113,7 +114,11 @@ async function loadWorkflowModule(scriptPath: string): Promise<DynamicWorkflowSc
 	// raw .dwf.ts file. This is the same source jiti will execute.
 	const scriptSource = readFileSync(scriptPath, "utf-8");
 	if (isDeterminismCheckEnabled()) {
-		assertDeterministicScript(scriptSource);
+		// DISC-1: acorn can only parse JavaScript, not TypeScript. Real .dwf.ts files
+		// contain type annotations/imports that cause a silent parse error, so the
+		// determinism check never runs. Transpile to JS via esbuild first.
+		const js = transformSync(scriptSource, { loader: "ts", format: "esm" }).code;
+		assertDeterministicScript(js);
 	}
 	// jiti is the same loader async-runner.ts uses (resolveTypeScriptLoader). We require it
 	// lazily so this module stays importable in environments without jiti (type-only consumers).
@@ -166,9 +171,16 @@ export async function runDynamicWorkflow(input: RunDynamicWorkflowInput): Promis
 		});
 	}
 
+	// ERR-1: Create a timeout AbortController so we can abort spawned children on script timeout.
+	// Combine the input signal with the timeout controller's signal so EITHER source
+	// (external abort OR our timeout) propagates to runChildPi via the ctx.
+	// AbortSignal.any is available since Node 20.3 — the project requires Node 20+.
+	const timeoutController = new AbortController();
+	const combinedSignal = AbortSignal.any([signal, timeoutController.signal]);
+
 	const ctx = makeWorkflowCtx(manifest, {
 		concurrency: input.concurrency ?? workflow.maxConcurrency ?? 4,
-		signal,
+		signal: combinedSignal,
 		team: input.team,
 		modelOverride: input.modelOverride,
 		tokenBudget: input.tokenBudget ?? workflow.maxTokenBudget,
@@ -200,6 +212,10 @@ export async function runDynamicWorkflow(input: RunDynamicWorkflowInput): Promis
 		let timeoutHandle: NodeJS.Timeout | undefined;
 		const timeoutPromise = new Promise<never>((_, reject) => {
 			timeoutHandle = setTimeout(() => {
+				// ERR-1: abort the timeout controller so the abort propagates to
+				// runChildPi (via the combined signal passed to makeWorkflowCtx),
+				// which kills spawned children instead of letting them run.
+				timeoutController.abort();
 				reject(
 					new Error(
 						`Dynamic workflow script timed out after ${SCRIPT_TIMEOUT_MS}ms. The script may have spawned a child process that did not exit. Check for spawn/exec calls without proper stdio handling.`,

package/src/runtime/goal-evaluator.ts

@@ -188,7 +188,9 @@ function tryParseDirectVerdict(stdout: string): { achieved: boolean; reason: str
  * Returns a GoalVerdict. On any failure (non-zero exit, non-JSON, invalid shape),
  * returns a `BLOCKED:`-prefixed verdict so the loop stops (§0c C6 fallback).
  */
-export async function evaluateGoal(input: EvaluateGoalInput): Promise<GoalVerdict> {
+export async function evaluateGoal(
+	input: EvaluateGoalInput,
+): Promise<{ verdict: GoalVerdict; judgeUsage?: { totalTokens: number; inputTokens?: number; outputTokens?: number } }> {
 	const agent = synthesizeJudgeAgentConfig();
 	const task = buildJudgeTask(input);
 	const evaluatedAt = new Date().toISOString();
@@ -212,12 +214,15 @@ export async function evaluateGoal(input: EvaluateGoalInput): Promise<GoalVerdic
 		});
 
 		if (result.exitCode !== 0 || result.error) {
-			return blockedVerdict(
-				input.turn,
-				input.model,
-				evaluatedAt,
-				`judge spawn failed (exit=${result.exitCode}): ${result.error ?? result.stderr.slice(0, 200)}`,
-			);
+			return {
+				verdict: blockedVerdict(
+					input.turn,
+					input.model,
+					evaluatedAt,
+					`judge spawn failed (exit=${result.exitCode}): ${result.error ?? result.stderr.slice(0, 200)}`,
+				),
+				judgeUsage: undefined,
+			};
 		}
 
 		const parsed = parsePiJsonOutput(result.stdout);
@@ -231,16 +236,22 @@ export async function evaluateGoal(input: EvaluateGoalInput): Promise<GoalVerdic
 		const direct = !finalText.trim() ? tryParseDirectVerdict(result.stdout) : undefined;
 		if (direct) {
 			return {
-				turn: input.turn,
-				achieved: direct.achieved,
-				reason: direct.reason,
-				evidenceRefs: direct.evidenceRefs,
-				evaluatorModel: input.model,
-				evaluatedAt,
+				verdict: {
+					turn: input.turn,
+					achieved: direct.achieved,
+					reason: direct.reason,
+					evidenceRefs: direct.evidenceRefs,
+					evaluatorModel: input.model,
+					evaluatedAt,
+				},
+				judgeUsage: undefined,
 			};
 		}
 		if (!finalText.trim()) {
-			return blockedVerdict(input.turn, input.model, evaluatedAt, "judge produced no output");
+			return {
+				verdict: blockedVerdict(input.turn, input.model, evaluatedAt, "judge produced no output"),
+				judgeUsage: undefined,
+			};
 		}
 
 		const extracted = extractStructuredResult(finalText);
@@ -252,27 +263,48 @@ export async function evaluateGoal(input: EvaluateGoalInput): Promise<GoalVerdic
 				})
 			: undefined;
 		if (!data || typeof data.achieved !== "boolean" || typeof data.reason !== "string") {
-			return blockedVerdict(input.turn, input.model, evaluatedAt, `judge output not valid verdict JSON: ${truncate(finalText, 200)}`);
+			return {
+				verdict: blockedVerdict(
+					input.turn,
+					input.model,
+					evaluatedAt,
+					`judge output not valid verdict JSON: ${truncate(finalText, 200)}`,
+				),
+				judgeUsage: undefined,
+			};
 		}
 		const evidenceRefs = Array.isArray(data.evidenceRefs)
 			? data.evidenceRefs.filter((r): r is string => typeof r === "string")
 			: undefined;
+		const judgeUsage = parsed.usage
+			? {
+					totalTokens: (parsed.usage.input ?? 0) + (parsed.usage.output ?? 0),
+					inputTokens: parsed.usage.input,
+					outputTokens: parsed.usage.output,
+				}
+			: undefined;
 		return {
-			turn: input.turn,
-			achieved: data.achieved,
-			reason: data.reason,
-			evidenceRefs,
-			evaluatorModel: input.model,
-			evaluatedAt,
+			verdict: {
+				turn: input.turn,
+				achieved: data.achieved,
+				reason: data.reason,
+				evidenceRefs,
+				evaluatorModel: input.model,
+				evaluatedAt,
+			},
+			judgeUsage,
 		};
 	} catch (error) {
 		logInternalError("goal-evaluator.evaluateGoal", error, `turn=${input.turn}`);
-		return blockedVerdict(
-			input.turn,
-			input.model,
-			evaluatedAt,
-			`judge threw: ${error instanceof Error ? error.message : String(error)}`,
-		);
+		return {
+			verdict: blockedVerdict(
+				input.turn,
+				input.model,
+				evaluatedAt,
+				`judge threw: ${error instanceof Error ? error.message : String(error)}`,
+			),
+			judgeUsage: undefined,
+		};
 	}
 }
 

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

@@ -66,21 +66,29 @@ export const stubGoalEvaluator = async (
 	_m?: import("../state/types.ts").TeamRunManifest,
 	_t?: import("../state/types.ts").TeamTaskState[],
 	_s?: AbortSignal,
-): Promise<GoalVerdict> => ({
-	turn: goal.turnsUsed,
-	achieved: false,
-	reason: `not-achieved: stub evaluator (P0). Turn ${goal.turnsUsed}/${goal.maxTurns} completed; P1 will judge against objective + verification.`,
-	evaluatorModel: "stub",
-	evaluatedAt: new Date().toISOString(),
+): Promise<GoalEvaluatorResult> => ({
+	verdict: {
+		turn: goal.turnsUsed,
+		achieved: false,
+		reason: `not-achieved: stub evaluator (P0). Turn ${goal.turnsUsed}/${goal.maxTurns} completed; P1 will judge against objective + verification.`,
+		evaluatorModel: "stub",
+		evaluatedAt: new Date().toISOString(),
+	},
+	judgeUsage: undefined,
 });
 
+export type GoalEvaluatorResult = {
+	verdict: GoalVerdict;
+	judgeUsage?: { totalTokens: number; inputTokens?: number; outputTokens?: number };
+};
+
 export type GoalEvaluatorFn = (
 	goal: GoalLoopState,
 	turnRunId: string,
 	turnManifest: import("../state/types.ts").TeamRunManifest,
 	turnTasks: import("../state/types.ts").TeamTaskState[],
 	signal: AbortSignal,
-) => Promise<GoalVerdict>;
+) => Promise<GoalEvaluatorResult>;
 
 /**
  * Production evaluator (P1): bundles turn evidence + calls the LLM judge.
@@ -94,7 +102,7 @@ export const realGoalEvaluator = async (
 	turnManifest: import("../state/types.ts").TeamRunManifest,
 	turnTasks: import("../state/types.ts").TeamTaskState[],
 	signal: AbortSignal,
-): Promise<GoalVerdict> => {
+): Promise<GoalEvaluatorResult> => {
 	const transcriptPath = deriveTranscriptPath(turnManifest.artifactsRoot, turnTasks);
 	// Fix round-7 F1: execute verification commands (if configured) so the judge has real evidence.
 	// Previously bundleEvidence received `undefined` — the judge was told commands "MUST pass"
@@ -676,17 +684,38 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 				logInternalError("goal-loop.saveTurnTasks", error, `turnRunId=${created.manifest.runId}`);
 			}
 
+			// GL-1: if the turn ended in blocked/failed status, stop the loop without spawning the judge.
+			// Previously the loop continued to evaluateGoal on blocked/failed turns, burning maxTurns.
+			const turnStatus = turnResult.manifest.status;
+			if (turnStatus === "blocked" || turnStatus === "failed") {
+				goal = safeSetStatus(store, goal.goalId, "blocked", goal, eventsPath);
+				appendEvent(eventsPath, {
+					type: "goal.turn_terminal_status",
+					runId: manifest.runId,
+					data: {
+						goalId: goal.goalId,
+						turn: turnIndex,
+						turnRunId: created.manifest.runId,
+						turnStatus,
+					},
+				});
+				break;
+			}
+
 			// ── BUDGET accumulation (§0c C2: collectRunMetrics) ──────────────────────
-			const updatedBudget = accumulateBudget(goal, created.manifest.runId);
+			const turnBudget = accumulateBudget(goal, created.manifest.runId);
 
 			// ── EVALUATE (P1: real LLM judge; pass turn manifest + tasks for transcript lookup) ──
-			const verdict = await evaluator(
-				{ ...goal, budgetUsed: updatedBudget },
+			const { verdict, judgeUsage } = await evaluator(
+				{ ...goal, budgetUsed: turnBudget },
 				created.manifest.runId,
 				turnResult.manifest,
 				turnResult.tasks,
 				signal,
 			);
+			// BDG-1: accumulate judge token usage into budget alongside the turn's worker tokens.
+			const judgeTokens = judgeUsage?.totalTokens ?? 0;
+			const updatedBudget = turnBudget + judgeTokens;
 			const historyEntry = {
 				runId: created.manifest.runId,
 				outcome: verdict.achieved ? "achieved" : "not-achieved",

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

@@ -268,6 +268,24 @@ export function evictStaleLiveAgentHandles(now = Date.now()): number {
 			// before evicting. Only evict if the process is dead, to avoid evicting
 			// slow-but-alive agents.
 			const sessionPid = (handle.session as Record<string, unknown>)?.pid as number | undefined;
+			if (sessionPid === undefined) {
+				// In-process live-session agents have no pid — the Pi SDK returns
+				// in-process objects, not child processes. checkProcessLiveness(undefined)
+				// returns {alive:false} which would wrongly evict a running agent.
+				// Check session-level activity signals first. If the session is
+				// actively streaming or has pending messages, it is alive — skip.
+				// Otherwise, rely on the idle timeout alone: do NOT dispose just
+				// because pid is undefined.
+				const session = handle.session as Record<string, unknown>;
+				const isStreaming = session?.isStreaming === true;
+				const pendingCount = (session?.pendingMessageCount as number | undefined) ?? 0;
+				if (isStreaming || pendingCount > 0) {
+					// Session is active — skip eviction.
+					continue;
+				}
+				// No activity signals and no pid — do NOT evict based on PID liveness.
+				continue;
+			}
 			const liveness = checkProcessLiveness(sessionPid);
 			if (!liveness.alive) {
 				liveAgents.delete(agentId);

package/src/runtime/pi-json-output.ts

@@ -55,7 +55,8 @@ function extractUsage(value: unknown): ParsedPiUsage | undefined {
 		turns: numberField(obj, ["turns", "turnCount", "turn_count"]),
 	};
 	if (Object.values(direct).some((entry) => entry !== undefined)) return direct;
-	for (const key of ["usage", "tokenUsage", "tokens", "stats"]) {
+	// Pi --mode json nests usage under message for message_end / turn_end events.
+	for (const key of ["usage", "message", "tokenUsage", "tokens", "stats"]) {
 		const nested = extractUsage(obj[key]);
 		if (nested) return nested;
 	}

package/src/runtime/pi-spawn.ts

@@ -189,7 +189,13 @@ function resolvePiCliScript(): string | undefined {
 	const argv1 = process.argv[1];
 	if (argv1) {
 		const argvPath = path.isAbsolute(argv1) ? argv1 : path.resolve(argv1);
-		if (isRunnableNodeScript(argvPath)) return argvPath;
+		// Only trust argv1 if we can confirm the current process is running from
+		// the pi-coding-agent package directory. Otherwise, when pi-crew is invoked
+		// from a standalone test script (process.argv[1] = test script path),
+		// resolvePiCliScript would incorrectly return the test script as the pi
+		// CLI. resolvePiPackageRoot walks up from argv1 looking for a package.json
+		// named @earendil-works/pi-coding-agent or @mariozechner/pi-coding-agent.
+		if (resolvePiPackageRoot() && isRunnableNodeScript(argvPath)) return argvPath;
 	}
 
 	// npm-global package dirs derived from `npm root -g` — placed BEFORE the

package/src/runtime/run-coalesced-task-group.ts

@@ -5,8 +5,10 @@ import { saveRunTasksAsync, updateRunStatus } from "../state/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import type { WorkflowStep } from "../workflows/workflow-config.ts";
 import { runChildPi } from "./child-pi.ts";
+import { DEFAULT_RETRY_POLICY, executeWithRetry } from "./retry-executor.ts";
 import { permissionForRole } from "./role-permission.ts";
 import type { CrewRuntimeMode } from "./runtime-resolver.ts";
+import { sanitizeTaskText } from "./task-packet.ts";
 import { splitCoalescedOutput } from "./task-runner/output-splitter.ts";
 import { mergeArtifacts } from "./team-runner-artifacts.ts";
 import { createWorkerHeartbeat, touchWorkerHeartbeat } from "./worker-heartbeat.ts";
@@ -101,15 +103,21 @@ export async function runCoalescedTaskGroup(input: CoalescedTaskGroupInput): Pro
 			}
 		}, 15_000);
 		try {
-			const result = await runChildPi({
-				cwd: firstTask.cwd,
-				task: combinedPrompt,
-				agent,
-				signal,
-				excludeContextBash: true,
-				maxTurns: 5,
-				onJsonEvent: (e) => input.onJsonEvent?.(firstTask.id, manifest.runId, e),
-			});
+			const result = await executeWithRetry(
+				async () => {
+					return await runChildPi({
+						cwd: firstTask.cwd,
+						task: combinedPrompt,
+						agent,
+						signal,
+						excludeContextBash: true,
+						maxTurns: 5,
+						onJsonEvent: (e) => input.onJsonEvent?.(firstTask.id, manifest.runId, e),
+					});
+				},
+				DEFAULT_RETRY_POLICY,
+				{ signal },
+			);
 			rawOutput = result.rawFinalText ?? result.stdout ?? "";
 			success = result.exitStatus?.exitCode === 0;
 		} catch (err) {
@@ -193,7 +201,7 @@ async function buildCoalescedPrompt(
 				`### Task ${idx + 1} of ${groupTasks.length} (id: ${task.id})`,
 				`Step: ${step.id}`,
 				`Role: ${step.role}`,
-				`Task: ${step.task.replaceAll("{goal}", manifest.goal)}`,
+				`Task: ${sanitizeTaskText(step.task.replaceAll("{goal}", manifest.goal))}`,
 			].join("\n");
 		})
 		.join("\n\n---\n\n");

package/src/runtime/task-runner/prompt-builder.ts

@@ -4,7 +4,7 @@ import type { TaskOutputSchema, TeamRunManifest, TeamTaskState } from "../../sta
 import type { WorkflowStep } from "../../workflows/workflow-config.ts";
 import { buildMemoryBlock } from "../agent-memory.ts";
 import { permissionForRole } from "../role-permission.ts";
-import { HANDOFF_TEMPLATE, renderTaskPacket } from "../task-packet.ts";
+import { HANDOFF_TEMPLATE, renderTaskPacket, sanitizeTaskText } from "../task-packet.ts";
 import { buildWorkspaceTree } from "../workspace-tree.ts";
 import { renderSuggestedFilesSection, runRetrievalCycle } from "./retrieval-orchestrator.ts";
 
@@ -267,7 +267,7 @@ export async function renderTaskPrompt(
 		memoryBlock,
 		task.taskPacket?.outputSchema ? renderOutputSchemaBlock(task.taskPacket.outputSchema) : "",
 		"Task:",
-		step.task.replaceAll("{goal}", manifest.goal),
+		sanitizeTaskText(step.task.replaceAll("{goal}", manifest.goal)),
 		"",
 		"When your task is complete, structure your final output using this handoff template:",
 		HANDOFF_TEMPLATE,

package/src/runtime/team-runner.ts

@@ -9,7 +9,7 @@ import type { MetricRegistry } from "../observability/metric-registry.ts";
 import { PluginRegistry } from "../plugins/plugin-registry.ts";
 import { NextJsPlugin, VitePlugin, VitestPlugin } from "../plugins/plugins/index.ts";
 import { hashArtifactContent as hashContent, writeArtifact } from "../state/artifact-store.ts";
-import { atomicWriteFile } from "../state/atomic-write.ts";
+import { atomicWriteFile, flushPendingAtomicWrites } from "../state/atomic-write.ts";
 import { appendEvent, appendEventAsync, appendEventBuffered, appendEventFireAndForget, flushEventLogBuffer } from "../state/event-log.ts";
 import { HealthStore } from "../state/health-store.ts";
 import { withRunLock } from "../state/locks.ts";
@@ -1615,6 +1615,11 @@ async function executeTeamRunCore(
 		// Read committed manifest from disk inside the lock so artifact merge is based
 		// on committed state, not in-memory state that may differ from disk.
 		const mergeResult = await withRunLock(manifest, async () => {
+			// NEW-D1: flush any pending coalesced atomic writes before reading from
+			// disk. Without this, a worker's async manifest save (coalesced by
+			// atomic-write) may not be committed yet, causing a lost-update on the
+			// merge read. flushPendingAtomicWrites forces all queued writes to disk.
+			flushPendingAtomicWrites();
 			const disk = loadRunManifestById(manifest.cwd, manifest.runId);
 			const diskManifest = disk?.manifest ?? manifest;
 			const diskArtifacts = diskManifest.artifacts;

package/src/state/event-log.ts

@@ -998,6 +998,7 @@ export function appendEventBuffered(eventsPath: string, event: AppendTeamEvent,
 				});
 			}, bufferMs);
 			bufferedTimers.set(eventsPath, timer);
+			timer.unref();
 		}
 	});
 }