pi-crew 0.10.3 → 0.10.4

package/src/runtime/foreground-control.ts

@@ -149,6 +149,11 @@ export function writeForegroundInterruptRequest(
 					/* no pid file — fall through to sleep */
 				}
 				// Brief sleep to avoid CPU spinning
+				// WI-7.3 (M7 spec §5): kept sync. Making this async would force
+				// requestForegroundControl() + its caller chain async (10+
+				// callers in message-tool/lifecycle paths). 10ms spin per
+				// iteration is bounded by the 5s timeout above (max ~500 iters
+				// = 5s total worst-case block, matching the lock-timeout).
 				sleepSync(10);
 			}
 		}
@@ -180,12 +185,20 @@ export function writeForegroundInterruptRequest(
 		};
 		fs.mkdirSync(path.dirname(controlPath), { recursive: true });
 		atomicWriteFile(controlPath, `${JSON.stringify({ requests: [...requests, request] }, null, 2)}\n`);
-		appendEvent(manifest.eventsPath, {
-			type: "foreground.interrupt_requested",
-			runId: manifest.runId,
-			message: reason,
-			data: { requestId: request.id, controlPath },
-		});
+		// Read-your-writes (CI 2026-09-11, phase6 integration): for a fresh
+		// manifest this may be the FIRST event — buffered append leaves
+		// events.jsonl nonexistent at the sync read right after (ENOENT).
+		// Sync appendEvent (base behavior, b6eba80f pattern).
+		try {
+			appendEvent(manifest.eventsPath, {
+				type: "foreground.interrupt_requested",
+				runId: manifest.runId,
+				message: reason,
+				data: { requestId: request.id, controlPath },
+			});
+		} catch (e) {
+			logInternalError("foreground_control.append", e, "type=foreground.interrupt_requested");
+		}
 		return request;
 	} finally {
 		releaseLock();

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

@@ -687,6 +687,10 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 			// Idempotency: same phase title → no event, no state change.
 			if (title === phaseState.currentPhase) return;
 			// Close out the previous open phase BEFORE the new one opens.
+			// REVIEW FIX (2026-09-10): reverted M2a buffered conversion — phase
+			// transitions are low-frequency AND read back synchronously (tests,
+			// checkpoint resume; dwf-setresult rounds 12/14/18 assert the events
+			// file immediately after the run).
 			if (phaseState.currentPhase !== undefined) {
 				appendEvent(manifest.eventsPath, {
 					type: "dwf.phase_completed",
@@ -710,6 +714,7 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 					);
 				}
 			}
+			// REVIEW FIX (2026-09-10): reverted M2a buffered conversion — see phase_completed.
 			appendEvent(manifest.eventsPath, {
 				type: "dwf.phase_started",
 				runId: manifest.runId,
@@ -724,6 +729,7 @@ export function makeWorkflowCtx(manifest: TeamRunManifest, opts: MakeWorkflowCtx
 			if (wfState.logs.length < 1000) {
 				wfState.logs.push(text);
 			}
+			// REVIEW FIX (2026-09-10): reverted M2a buffered conversion — see phase().
 			appendEvent(manifest.eventsPath, {
 				type: "dwf.log",
 				runId: manifest.runId,

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

@@ -154,6 +154,9 @@ export async function runDynamicWorkflow(input: RunDynamicWorkflowInput): Promis
 	// code execution. Default-deny project workflows unless the user explicitly opts in via
 	// PI_CREW_TRUST_PROJECT_DWF=1. Builtin and user workflows proceed without restriction.
 	if (workflow.source === "project" && getCrewEnv("PI_CREW_TRUST_PROJECT_DWF") !== "1") {
+		// REVIEW FIX (2026-09-10): DWF lifecycle events reverted from M2a
+		// buffered conversion — runner sites are read back synchronously
+		// (dwf-setresult tests, resume flow, status display after run end).
 		appendEvent(eventsPath, {
 			type: "dwf.trust_denied",
 			runId: manifest.runId,

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/model/pi-args.ts

@@ -281,7 +281,12 @@ export function buildPiWorkerArgs(input: BuildPiWorkerArgsInput): BuildPiWorkerA
 
 	// D5 (spec v0.7 §6): default loadout = FULL session (như main session).
 	// --no-extensions/--no-skills/--tools CHỈ xuất hiện khi agent .md khai explicit.
-	const CONTROL_TOOLS = ["ask", "delegate"] as const;
+	// "message" MUST stay in CONTROL_TOOLS: it is registered by prompt-runtime
+	// behind the PI_CREW_MSG_ENABLED dormant-env gate (child-pi-spawn.ts sets it
+	// unconditionally), but pi's --tools allowlist filters the tool SURFACE — a
+	// control tool missing here is invisible to every frontmatter-pinned worker
+	// (battery 2026-09-10: message dead for all builtin roles since f843e14a).
+	const CONTROL_TOOLS = ["ask", "delegate", "message"] as const;
 	if (input.agent.disableTools === true) {
 		args.push("--no-tools"); // capability-locked agents giữ hành vi (goal-judge)
 	} else {

package/src/runtime/plan-replan.ts

@@ -111,6 +111,8 @@ export function sweepDroppedPlanItems(initialManifest: TeamRunManifest, initialT
 							: t,
 					);
 					cancelledTaskIds.push(task.id);
+					// REVIEW FIX (2026-09-10): reverted M2b buffered conversion —
+					// sweep tests read plan.item.dropped events synchronously.
 					appendEvent(fresh.manifest.eventsPath, {
 						type: "plan.item.dropped",
 						runId,
@@ -127,6 +129,7 @@ export function sweepDroppedPlanItems(initialManifest: TeamRunManifest, initialT
 					if (!appendSteeringAdvisory(fresh.manifest, task.id)) continue;
 					tasks = tasks.map((t) => (t.id === task.id ? { ...t, replanDroppedAt: new Date().toISOString() } : t));
 					advisedTaskIds.push(task.id);
+					// REVIEW FIX (2026-09-10): reverted M2b buffered conversion — see above.
 					appendEvent(fresh.manifest.eventsPath, {
 						type: "plan.item.dropped",
 						runId,

package/src/runtime/stale-reconciler.ts

@@ -270,10 +270,35 @@ function isTaskHeartbeatStale(task: TeamTaskState, now: number): boolean {
 	// Compute elapsed from both sources and use the fresher (minimum) one,
 	// mirroring heartbeat-watcher logic: if either source has recent activity,
 	// the task is not stale even if the other is stale.
-	const heartbeatAge = Number.isFinite(heartbeatAt) ? now - heartbeatAt : Infinity;
-	const activityAge = Number.isFinite(activityAt) ? now - activityAt : Infinity;
+	const heartbeatAge = Number.isFinite(heartbeatAt) ? now - heartbeatAt : Number.MAX_SAFE_INTEGER;
+	const activityAge = Number.isFinite(activityAt) ? now - activityAt : Number.MAX_SAFE_INTEGER;
 	const elapsed = Math.min(heartbeatAge, activityAge);
-	return elapsed > NO_PID_HEARTBEAT_STALE_MS;
+	if (elapsed <= NO_PID_HEARTBEAT_STALE_MS) return false;
+	// F1 part 2 (battery 2026-09-10, live evidence run team_20260910171307): a
+	// surface worker's recorder only flushes at turn boundaries — one slow LLM
+	// turn (observed: 6.7min) freezes lastSeenAt/lastActivityAt while the worker
+	// process is alive and mid-turn. The heartbeat-watcher already has a
+	// PID-liveness gate for exactly this ("alive → downgrade dead→stale"); the
+	// reconciler MUST apply the same gate before repairing, or it kills healthy
+	// runs at the 5-minute mark mid-turn. A truly dead pid still repairs as before.
+	const taskPid = task.heartbeat?.pid ?? task.checkpoint?.childPid;
+	const pidAlive = taskPid ? checkProcessLiveness(taskPid).alive : false;
+	if (taskPid && pidAlive) return false;
+	if (process.env.PI_CREW_DEBUG_STALE === "1") {
+		// F1 forensic (battery 2026-09-10): sidecar log of every STALE verdict so
+		// live repros can show exactly what the reconciler saw (pid present? alive?
+		// elapsed?) — the reconciler may run in ANY host process, hence a fixed
+		// sidecar path instead of console.
+		try {
+			fs.appendFileSync(
+				"/tmp/pi-crew-f1-debug.log",
+				`${JSON.stringify({ ts: new Date().toISOString(), taskId: task.id, status: task.status, taskPid, pidAlive, heartbeatAge, activityAge, hbLastSeen: task.heartbeat?.lastSeenAt })}\n`,
+			);
+		} catch {
+			/* best-effort forensic log */
+		}
+	}
+	return true;
 }
 
 /**

package/src/runtime/supervisor-contact.ts

@@ -22,6 +22,9 @@ export function recordSupervisorContact(manifest: TeamRunManifest, payload: Omit
 		timestamp: new Date().toISOString(),
 	};
 	try {
+		// REVIEW FIX (2026-09-10): reverted M2b buffered conversion —
+		// supervisor.contact events are read back synchronously (tests +
+		// contact-history display); low-frequency by design.
 		appendEvent(manifest.eventsPath, {
 			type: "supervisor.contact",
 			runId: manifest.runId,

package/src/runtime/task-runner/child-executor.ts

@@ -723,6 +723,39 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 						logInternalError("task-runner.on-json-event", err as Error, `taskId=${task.id}`);
 					}
 				},
+				onSurfaceActivity: (event) => {
+					// F1 fix (battery 2026-09-10): surface workers have no stdout pipe, so
+					// onJsonEvent/onStdoutLine never fire and task liveness state starves.
+					// Reuses the SAME throttled persisters as the stdout path:
+					// persistHeartbeat (1s) touches lastSeenAt + persists task state;
+					// persistChildProgress (coalesced) appends task.progress to the RUN
+					// event log - a DIFFERENT file than the per-agent log being tailed, so
+					// no watch->append loop. NEVER call appendCrewAgentEventBuffered here:
+					// the worker already wrote this event to the tailed file itself.
+					try {
+						const pidFromStart = event?.type === "worker.started" && typeof event.pid === "number" ? event.pid : undefined;
+						if (pidFromStart !== undefined) {
+							// Surface pid was previously never persisted into task state - the
+							// heartbeat-watcher PID-liveness gate (alive -> downgrade dead->stale)
+							// had nothing to check. Pin it once from the worker.started self-report.
+							task = {
+								...task,
+								heartbeat: touchWorkerHeartbeat(task.heartbeat ?? createWorkerHeartbeat(task.id), {
+									pid: pidFromStart,
+								}),
+							};
+						}
+						task = {
+							...task,
+							agentProgress: applyAgentProgressEvent(task.agentProgress ?? emptyCrewAgentProgress(), event, task.startedAt),
+						};
+						tasks = updateTask(tasks, task);
+						persistHeartbeat();
+						persistChildProgress(event);
+					} catch (err) {
+						logInternalError("task-runner.on-surface-activity", err as Error, `taskId=${task.id}`);
+					}
+				},
 			});
 		} finally {
 			// R10-5 (Wave 2B item 4): task-boundary flush — land every buffered

package/src/runtime/team-runner.ts

@@ -8,7 +8,7 @@ import { appendHookEvent, executeHook } from "../hooks/registry.ts";
 import type { MetricRegistry } from "../observability/metric-registry.ts";
 import { atomicWriteFile } from "../state/atomic-write.ts";
 import { canTransitionRunStatus } from "../state/contracts.ts";
-import { appendEvent, appendEventAsync, flushEventLogBuffer } from "../state/event-log/event-log.ts";
+import { appendEvent, appendEventAsync, appendEventBuffered, flushEventLogBuffer } from "../state/event-log/event-log.ts";
 import { hashArtifactContent as hashContent, writeArtifact } from "../state/stores/artifact-store.ts";
 import { loadRunManifestById, saveRunManifestAsync, saveRunTasksAsync, updateRunStatus } from "../state/stores/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
@@ -426,7 +426,7 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 				);
 			}
 		}
-		appendEvent(manifest.eventsPath, {
+		appendEventBuffered(manifest.eventsPath, {
 			type: "run.goal_achievement",
 			runId: manifest.runId,
 			message: gaApplied.manifest.goalAchievementNote ?? "",
@@ -436,7 +436,7 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 				reason: gaAssessment.reason,
 				signals: gaAssessment.signals,
 			},
-		});
+		}).catch((e) => logInternalError("team-runner.buffered", e, "type=run.goal_achievement"));
 		if (gaApplied.downgraded)
 			logInternalError(
 				"team-runner.goalAchievement.falseGreen",

package/src/state/stores/ownership-map.ts

@@ -26,7 +26,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { logInternalError } from "../../utils/internal-error.ts";
-import { atomicWriteJson, flushPendingAtomicWrites } from "../atomic-write.ts";
+import { atomicWriteJson } from "../atomic-write.ts";
 import { withRunLockSync } from "../coordination/locks.ts";
 import type { TeamRunManifest } from "../types.ts";
 
@@ -100,9 +100,10 @@ export function readOwnershipMap(manifest: TeamRunManifest): OwnershipMapFile {
 export function upsertOwnershipEntry(manifest: TeamRunManifest, entry: OwnershipEntry): void {
 	try {
 		withRunLockSync(manifest, () => {
-			// Defeat the atomic-write coalescer's stale-read window: force any
-			// pending buffered write for THIS file to land before we reload.
-			flushPendingAtomicWrites(ownershipMapPath(manifest));
+			// REVIEW FIX (2026-09-10): reverted WI-2.2's coalesced conversion (and
+			// its flush-before-reload guard). The map is small, written at spawn /
+			// steer frequency (not a hot loop), and round-trip readers expect
+			// read-your-writes immediately after upsert returns.
 			const fresh = readOwnershipMap(manifest);
 			const prev = fresh.entries[entry.taskId] ?? {};
 			const merged: OwnershipEntry = {

package/src/state/stores/plan-store.ts

@@ -74,6 +74,13 @@ export function getCurrentPlanRecord(manifest: TeamRunManifest): PlanRecord | un
 function writePlanFile(manifest: TeamRunManifest, revisions: PlanRecord[]): void {
 	const file: PlanFile = { version: 1, revisions };
 	fs.mkdirSync(path.dirname(planFilePath(manifest)), { recursive: true });
+	// REVIEW FIX (2026-09-10): reverted WI-2.2's coalesced conversion.
+	// `loadPlanRecords` is the PUBLIC read API and every caller expects
+	// read-your-writes (getCurrentPlanRecord, plan-replan, handleStatus); a
+	// 50ms coalesce window made the mutators' own reload-inside-lock read
+	// stale state (lost-update) and broke plan-store.test.ts 11/15. Plan
+	// writes are low-frequency (revision append / linkage / approval) — the
+	// coalesce win is negligible. Same exclusion rule as status.ts A2/A4.
 	atomicWriteJson(planFilePath(manifest), file);
 }
 
@@ -141,6 +148,10 @@ export function appendPlanRevision(manifest: TeamRunManifest, record: PlanRecord
 		revisions.push(record);
 		writePlanFile(manifest, revisions);
 		const dropped = record.items.filter((i) => i.status === "dropped").length;
+		// REVIEW FIX (2026-09-10): reverted M2b buffered conversion — plan lifecycle
+		// events are low-frequency and consumers (plan-store tests, status display)
+		// expect read-your-writes; also removes the policy-A catch (sync errors
+		// propagate to the producer inside the lock, as at base).
 		appendEvent(manifest.eventsPath, {
 			type: record.version === 1 ? "plan.created" : "plan.revised",
 			runId: manifest.runId,
@@ -199,6 +210,7 @@ export function setPlanApproval(
 		// ADR-4 §9: events for approval MUTATIONS. `pending` emits none — the
 		// request surface (ensurePlanApprovalRequested) appends its own
 		// plan.approval_required event.
+		// REVIEW FIX (2026-09-10): reverted M2b buffered conversion — see above.
 		if (approval.status !== "pending") {
 			appendEvent(manifest.eventsPath, {
 				type: approval.status === "approved" ? "plan.approved" : "plan.rejected",

package/src/state/stores/state-store.ts

@@ -502,6 +502,11 @@ export function saveRunManifest(manifest: TeamRunManifest): void {
 	// which is always safe.
 	invalidateRunCache(manifest.stateRoot);
 	const manifestPath = path.join(manifest.stateRoot, "manifest.json");
+	// REVIEW FIX (2026-09-10): reverted WI-2.2's coalesced conversion —
+	// saveRunManifest is a SYNCHRONOUS persist by name/contract (tests assert
+	// it, broker loadRunManifestById is a cross-process reader, and the
+	// statSync-based cache repopulation below needs the real post-write
+	// mtime/size). The 50ms coalesce window broke all three.
 	atomicWriteJson(manifestPath, manifest);
 	// FIX: Re-populate cache with actual mtime/size so loadRunManifestById
 	// doesn't miss the cache on next read. Without this, every load until

package/src/ui/powerbar-publisher.ts

@@ -41,13 +41,9 @@ function hasPowerbarConsumer(events: EventBus): boolean {
 	}
 }
 
-function setStatusFallback(ctx: StatusContext, text: string | undefined): void {
-	try {
-		if (ctx?.hasUI) ctx.ui?.setStatus?.("pi-crew", text);
-	} catch (error) {
-		logInternalError("powerbar.statusFallback", error);
-	}
-}
+// setStatusFallback removed (WI-5.1 / docs/decisions/2026-09-10): 0 callers,
+// function was deliberately-unused; crew-widget owns the "pi-crew" status
+// bar surface (see test/unit/ui/powerbar-publisher.test.ts:227).
 
 function safeEmit(events: EventBus, event: string, data: unknown): void {
 	try {

package/src/ui/run-action-dispatcher.ts

@@ -3,25 +3,22 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { handleTeamTool as HandleTeamToolFn } from "../extension/team-tool.ts";
 import type { MetricRegistry } from "../observability/metric-registry.ts";
 
-let _cachedHandleTeamTool: typeof HandleTeamToolFn | undefined;
 async function handleTeamTool(
 	params: Parameters<typeof HandleTeamToolFn>[0],
 	ctx: Parameters<typeof HandleTeamToolFn>[1],
 ): Promise<Awaited<ReturnType<typeof HandleTeamToolFn>>> {
-	if (!_cachedHandleTeamTool) {
-		// LAZY: avoid pulling team-tool.ts (and its entire runtime chain) into module load.
-		const mod = await import("../extension/team-tool.ts");
-		_cachedHandleTeamTool = mod.handleTeamTool;
-	}
-	return _cachedHandleTeamTool(params, ctx);
+	// LAZY: avoid pulling team-tool.ts (and its entire runtime chain) into module load.
+	const mod = await import("../extension/team-tool.ts");
+	return mod.handleTeamTool(params, ctx);
 }
 
 import { isToolError, textFromToolResult } from "../extension/tool-result.ts";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
 import { exportDiagnostic } from "../runtime/diagnostic-export.ts";
 import type { MailboxDirection, MailboxMessage } from "../state/coordination/mailbox.ts";
-import { appendEvent } from "../state/event-log/event-log.ts";
+import { appendEventBuffered } from "../state/event-log/event-log.ts";
 import { loadRunManifestById, saveRunTasks } from "../state/stores/state-store.ts";
+import { logInternalError } from "../utils/internal-error.ts";
 
 export interface RunActionResult {
 	ok: boolean;
@@ -141,12 +138,12 @@ export async function dispatchKillStaleWorkers(ctx: ExtensionContext, runId: str
 			};
 		});
 		saveRunTasks(loaded.manifest, tasks);
-		appendEvent(loaded.manifest.eventsPath, {
+		appendEventBuffered(loaded.manifest.eventsPath, {
 			type: "worker.kill_stale",
 			runId,
 			message: `Marked ${count} stale worker heartbeat(s) dead.`,
 			data: { count },
-		});
+		}).catch((e) => logInternalError("run_action_dispatcher.buffered", e, "type=worker.kill_stale"));
 		return {
 			ok: true,
 			message: `Marked ${count} stale worker heartbeat(s) dead.`,

package/src/ui/settings-overlay.ts

@@ -345,7 +345,10 @@ const EFFECTIVE_DEFAULTS: Record<string, unknown> = {
 	"ui.dashboardPlacement": "center",
 	"ui.dashboardWidth": 72,
 	"ui.autoOpenDashboard": false,
-	"ui.widgetPlacement": "aboveEditor",
+	// G17 sync (2026-09-10 review): canonical DEFAULT_UI.widgetPlacement =
+	// "bottom" (defaults.ts / install.mjs / project-init) — was drifted
+	// "aboveEditor" in this duplicated EFFECTIVE_DEFAULTS map.
+	"ui.widgetPlacement": "bottom",
 	"autonomous.enabled": true,
 	"autonomous.injectPolicy": true,
 	"autonomous.preferAsyncForLongTasks": false,