pi-crew 0.10.2 → 0.10.4

package/src/extension/registration/team-tool.ts

@@ -18,17 +18,13 @@ import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
 // Team tool handler — lazy-loaded because team-tool.ts imports many modules
 import type { handleTeamTool as HandleTeamToolFn } from "../team-tool.ts";
 
-let _cachedHandleTeamTool: typeof HandleTeamToolFn | undefined;
 async function handleTeamTool(
 	params: Parameters<typeof HandleTeamToolFn>[0],
 	ctx: Parameters<typeof HandleTeamToolFn>[1],
 ): Promise<ReturnType<typeof HandleTeamToolFn>> {
-	if (!_cachedHandleTeamTool) {
-		// LAZY: team-tool.ts imports many modules — defer until first use.
-		const mod = await import("../team-tool.ts");
-		_cachedHandleTeamTool = mod.handleTeamTool;
-	}
-	return _cachedHandleTeamTool(params, ctx);
+	// LAZY: team-tool.ts imports many modules — defer until first use.
+	const mod = await import("../team-tool.ts");
+	return mod.handleTeamTool(params, ctx);
 }
 
 import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
@@ -147,6 +143,52 @@ export function detectUnrecognizedParams(schema: TObject, params: unknown): stri
 	].join("\n");
 }
 
+// PERF (2026-08-24): cheap read actions (status/summary/events/get/list) re-rendered
+// the widget + powerbar after every call; the event bus and render tick already
+// reflect run-state changes. Refresh only on actions that mutate run state
+// outside the watched files. Names mirror the five domain dispatcher tables in
+// src/schema/team-tool-schema.ts (RUN/STATUS/CONTROL/MANAGE/AUTOMATE). Actions
+// whose effect depends on sub-params (api: approve-plan/agent-control/mailbox;
+// plans: approve/reject; anchor/auto-summarize/auto_boomerang: set/clear/toggle;
+// config/autonomy: show vs write) are included — a redundant refresh on their
+// read sub-actions is cheap, a missed refresh after a write leaves stale UI.
+const MUTATING_ACTIONS = new Set([
+	// run domain
+	"run",
+	"parallel",
+	"orchestrate",
+	"resume",
+	"retry",
+	"steer",
+	"goal",
+	"plans",
+	// control domain
+	"cancel",
+	"invalidate",
+	"respond",
+	"cleanup",
+	"prune",
+	"forget",
+	// manage domain
+	"create",
+	"update",
+	"delete",
+	"init",
+	"config",
+	"autonomy",
+	"settings",
+	"workflow-create",
+	"workflow-save",
+	"workflow-delete",
+	"import",
+	// automate domain
+	"schedule",
+	"anchor",
+	"auto-summarize",
+	"auto_boomerang",
+	"api",
+]);
+
 export function registerTeamTool(pi: ExtensionAPI, deps: RegisterTeamToolDeps): void {
 	const tool: ToolDefinition = {
 		name: "team",
@@ -229,11 +271,13 @@ export function registerTeamTool(pi: ExtensionAPI, deps: RegisterTeamToolDeps):
 						timestamp: Date.now(),
 					});
 				}
-				const config = loadConfig(toolCtx.cwd).config.ui;
-				const cache = deps.getManifestCache(toolCtx.cwd);
-				const snapshotCache = deps.getRunSnapshotCache?.(toolCtx.cwd);
-				updateCrewWidget(toolCtx, deps.widgetState, config, cache, snapshotCache);
-				updatePiCrewPowerbar(pi.events, toolCtx.cwd, config, cache, snapshotCache, toolCtx);
+				if (MUTATING_ACTIONS.has(resolved.action ?? "list")) {
+					const config = loadConfig(toolCtx.cwd).config.ui;
+					const cache = deps.getManifestCache(toolCtx.cwd);
+					const snapshotCache = deps.getRunSnapshotCache?.(toolCtx.cwd);
+					updateCrewWidget(toolCtx, deps.widgetState, config, cache, snapshotCache);
+					updatePiCrewPowerbar(pi.events, toolCtx.cwd, config, cache, snapshotCache, toolCtx);
+				}
 				return output;
 			} finally {
 				signal?.removeEventListener("abort", abort);

package/src/extension/registration/ui.ts

@@ -27,15 +27,10 @@ import type { CrewWidgetState } from "../../ui/widget/index.ts";
 import { stopCrewWidget, updateCrewWidget } from "../../ui/widget/index.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
 
-/** Cached live-run-sidebar constructor (lazy-loaded on first overlay open). */
-let _cachedLiveRunSidebar: typeof LiveRunSidebarType | undefined;
 async function importLiveRunSidebar(): Promise<typeof LiveRunSidebarType> {
-	if (!_cachedLiveRunSidebar) {
-		// LAZY: defer LiveRunSidebar import until the user opens a sidebar overlay.
-		const mod = await import("../../ui/live-run-sidebar.ts");
-		_cachedLiveRunSidebar = mod.LiveRunSidebar;
-	}
-	return _cachedLiveRunSidebar;
+	// LAZY: defer LiveRunSidebar import until the user opens a sidebar overlay.
+	const mod = await import("../../ui/live-run-sidebar.ts");
+	return mod.LiveRunSidebar;
 }
 
 /** Mutable state owned by register.ts. */

package/src/extension/registration/viewers.ts

@@ -8,17 +8,10 @@ import { asCrewTheme } from "../../ui/theme-adapter.ts";
 // Lazy-loaded: DurableTranscriptViewer is 658ms — only needed for /crew transcript command
 import type { DurableTranscriptViewer as DurableTranscriptViewerType } from "../../ui/transcript-viewer.ts";
 
-let _cachedViewer: typeof DurableTranscriptViewerType | undefined;
-let _viewerPromise: Promise<typeof DurableTranscriptViewerType> | undefined;
 async function getViewer(): Promise<typeof DurableTranscriptViewerType> {
-	if (_cachedViewer) return _cachedViewer;
-	if (!_viewerPromise) {
-		_viewerPromise = import("../../ui/transcript-viewer.ts").then((mod) => {
-			_cachedViewer = mod.DurableTranscriptViewer;
-			return mod.DurableTranscriptViewer;
-		});
-	}
-	return _viewerPromise;
+	// LAZY: DurableTranscriptViewer is 658ms — only needed for /crew transcript.
+	const mod = await import("../../ui/transcript-viewer.ts");
+	return mod.DurableTranscriptViewer;
 }
 
 export async function selectAgentTask(

package/src/extension/team-manager-command.ts

@@ -3,17 +3,13 @@ import { listRuns } from "./run-index.ts";
 // Lazy-loaded: team-tool.ts pulls in entire runtime chain.
 import type { handleTeamTool as HandleTeamToolFn } from "./team-tool.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: team-tool.ts pulls in the entire runtime chain.
-		const mod = await import("./team-tool.ts");
-		_cachedHandleTeamTool = mod.handleTeamTool;
-	}
-	return _cachedHandleTeamTool(params, ctx);
+	// LAZY: team-tool.ts pulls in the entire runtime chain.
+	const mod = await import("./team-tool.ts");
+	return mod.handleTeamTool(params, ctx);
 }
 
 import { isToolError, textFromToolResult } from "./tool-result.ts";

package/src/extension/team-tool/api/agent-control.ts

@@ -22,7 +22,8 @@ import {
 	appendSteeringMessage,
 	appendSteeringMessageAsync,
 } from "../../../state/coordination/mailbox.ts";
-import { appendEvent } from "../../../state/event-log/event-log.ts";
+import { appendEvent, appendEventBuffered } from "../../../state/event-log/event-log.ts";
+import { logInternalError } from "../../../utils/internal-error.ts";
 import type { ApiOperationHandler } from "./handler-context.ts";
 
 export const handleNudgeAgent: ApiOperationHandler = (hctx) => {
@@ -54,13 +55,19 @@ export const handleNudgeAgent: ApiOperationHandler = (hctx) => {
 		priority: "normal",
 		data: { source: "nudge-agent" },
 	});
-	appendEvent(loaded.manifest.eventsPath, {
-		type: "agent.nudged",
-		runId: loaded.manifest.runId,
-		taskId: agent.taskId,
-		message: messageText,
-		data: { agentId: agent.id, mailboxMessageId: message.id },
-	});
+	// Read-your-writes (CI 2026-09-11, phase8 integration): the nudge caller
+	// reads events.jsonl synchronously right after dispatch — sync appendEvent.
+	try {
+		appendEvent(loaded.manifest.eventsPath, {
+			type: "agent.nudged",
+			runId: loaded.manifest.runId,
+			taskId: agent.taskId,
+			message: messageText,
+			data: { agentId: agent.id, mailboxMessageId: message.id },
+		});
+	} catch (e) {
+		logInternalError("api.agent-control.append", e, "type=agent.nudged");
+	}
 	ctx.events?.emit?.("crew.mailbox.message", {
 		runId: loaded.manifest.runId,
 		id: message.id,
@@ -314,7 +321,7 @@ export const handleLiveAgentControl: ApiOperationHandler = async (hctx) => {
 						: undefined;
 			publishLiveControlRealtime(request);
 			ctx.events?.emit?.("pi-crew:live-control", liveControlRealtimeMessage(request));
-			appendEvent(loaded.manifest.eventsPath, {
+			appendEventBuffered(loaded.manifest.eventsPath, {
 				type: "agent.control.queued",
 				runId: loaded.manifest.runId,
 				taskId: agent.taskId,
@@ -324,7 +331,7 @@ export const handleLiveAgentControl: ApiOperationHandler = async (hctx) => {
 					mailboxMessageId: mailboxMessage?.id,
 					realtime: true,
 				},
-			});
+			}).catch((e) => logInternalError("api.agent-control.buffered", e, "type=agent.control.queued"));
 			return result(JSON.stringify({ queued: true, request, mailboxMessage }, null, 2), {
 				action: "api",
 				status: "ok",

package/src/extension/team-tool/api/heartbeat.ts

@@ -8,8 +8,9 @@
 import { touchWorkerHeartbeat } from "../../../runtime/heartbeat/worker-heartbeat.ts";
 import { isTerminalTaskStatus } from "../../../state/contracts.ts";
 import { withRunLockSync } from "../../../state/coordination/locks.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";
 import { RUN_NOT_FOUND_HINT } from "../run-not-found.ts";
 import type { ApiOperationHandler } from "./handler-context.ts";
 
@@ -79,12 +80,12 @@ export const handleWriteHeartbeat: ApiOperationHandler = (hctx) => {
 			);
 			const tasks = fresh.tasks.map((item) => (item.id === freshTask.id ? { ...item, heartbeat } : item));
 			saveRunTasks(fresh.manifest, tasks);
-			appendEvent(fresh.manifest.eventsPath, {
+			appendEventBuffered(fresh.manifest.eventsPath, {
 				type: "worker.heartbeat",
 				runId: fresh.manifest.runId,
 				taskId: freshTask.id,
 				data: { ...heartbeat },
-			});
+			}).catch((e) => logInternalError("api.heartbeat.buffered", e, "type=worker.heartbeat"));
 			return result(JSON.stringify(heartbeat, null, 2), {
 				action: "api",
 				status: "ok",

package/src/extension/team-tool/api/mailbox.ts

@@ -16,7 +16,8 @@ import {
 	readMailboxMessage,
 	validateMailbox,
 } from "../../../state/coordination/mailbox.ts";
-import { appendEvent } from "../../../state/event-log/event-log.ts";
+import { appendEvent, appendEventBuffered } from "../../../state/event-log/event-log.ts";
+import { logInternalError } from "../../../utils/internal-error.ts";
 import type { ApiOperationHandler } from "./handler-context.ts";
 
 export const handleReadMailbox: ApiOperationHandler = (hctx) => {
@@ -129,11 +130,11 @@ export const handleSendMessage: ApiOperationHandler = (hctx) => {
 			// run-lock callback. Sync append (byte-identical to pre-extract
 			// api.ts) so consumers reading eventsPath immediately after the
 			// call see the event — async fire-and-forget would race.
-			appendEvent(loaded.manifest.eventsPath, {
+			appendEventBuffered(loaded.manifest.eventsPath, {
 				type: "mailbox.message",
 				runId: loaded.manifest.runId,
 				data: { id: message.id, direction, from, to },
-			});
+			}).catch((e) => logInternalError("api.mailbox.buffered", e, "type=mailbox.message"));
 			ctx.events?.emit?.("crew.mailbox.message", {
 				runId: loaded.manifest.runId,
 				id: message.id,
@@ -185,26 +186,38 @@ export const handleAckMessage: ApiOperationHandler = (hctx) => {
 		return withRunLockSync(loaded.manifest, () => {
 			const message = readMailboxMessage(loaded.manifest, messageId);
 			const delivery = acknowledgeMailboxMessage(loaded.manifest, messageId);
-			appendEvent(loaded.manifest.eventsPath, {
-				type: "mailbox.acknowledged",
-				runId: loaded.manifest.runId,
-				data: { messageId },
-			});
-			if (message?.data?.kind === "group_join" && typeof message.data.requestId === "string") {
+			// Read-your-writes (CI 2026-09-11, phase4 integration): the ack API
+			// returns and callers/tests read events.jsonl synchronously right after —
+			// buffered append flushes later (bufferMs window), so the events were
+			// missing at read. Sync appendEvent (base behavior, b6eba80f pattern).
+			try {
 				appendEvent(loaded.manifest.eventsPath, {
-					type: "agent.group_join.acknowledged",
+					type: "mailbox.acknowledged",
 					runId: loaded.manifest.runId,
-					message: "Group join delivery acknowledged via mailbox ack.",
-					data: {
-						requestId: message.data.requestId,
-						messageId,
-						batchId: message.data.batchId,
-						partial: message.data.partial,
-						acknowledgedAt: delivery.updatedAt,
-						acknowledgedBy: "leader",
-					},
-					metadata: { provenance: "api" },
+					data: { messageId },
 				});
+			} catch (e) {
+				logInternalError("api.mailbox.append", e, "type=mailbox.acknowledged");
+			}
+			if (message?.data?.kind === "group_join" && typeof message.data.requestId === "string") {
+				try {
+					appendEvent(loaded.manifest.eventsPath, {
+						type: "agent.group_join.acknowledged",
+						runId: loaded.manifest.runId,
+						message: "Group join delivery acknowledged via mailbox ack.",
+						data: {
+							requestId: message.data.requestId,
+							messageId,
+							batchId: message.data.batchId,
+							partial: message.data.partial,
+							acknowledgedAt: delivery.updatedAt,
+							acknowledgedBy: "leader",
+						},
+						metadata: { provenance: "api" },
+					});
+				} catch (e) {
+					logInternalError("api.mailbox.append", e, "type=agent.group_join.acknowledged");
+				}
 			}
 			ctx.events?.emit?.("crew.mailbox.acknowledged", {
 				runId: loaded.manifest.runId,

package/src/extension/team-tool/api/plan-approval.ts

@@ -8,7 +8,7 @@
 import { terminateLiveAgentsForRun } from "../../../runtime/live-session/live-agent-manager.ts";
 import { currentCrewRole, permissionForRole } from "../../../runtime/role-permission.ts";
 import { withRunLock } from "../../../state/coordination/locks.ts";
-import { appendEvent } from "../../../state/event-log/event-log.ts";
+import { appendEvent, appendEventBuffered } from "../../../state/event-log/event-log.ts";
 import { getCurrentPlanRecord, setPlanApproval } from "../../../state/stores/plan-store.ts";
 import { loadRunManifestById, saveRunManifestAsync, saveRunTasks, updateRunStatus } from "../../../state/stores/state-store.ts";
 import { logInternalError } from "../../../utils/internal-error.ts";
@@ -68,13 +68,13 @@ export const handleApprovePlan: ApiOperationHandler = async (hctx) => {
 			// plan id+version. Pre-v2 runs without a PlanRecord skip silently.
 			const currentRecord = getCurrentPlanRecord(manifest);
 			if (currentRecord) setPlanApproval(manifest, { status: "approved", planVersion: currentRecord.version, by: "api" });
-			appendEvent(manifest.eventsPath, {
+			appendEventBuffered(manifest.eventsPath, {
 				type: "plan.approved",
 				runId: manifest.runId,
 				taskId: approval.planTaskId,
 				message: "Adaptive implementation plan approved; resume the run to execute mutating tasks.",
 				metadata: { provenance: "api" },
-			});
+			}).catch((e) => logInternalError("api.plan-approval.buffered", e, "type=plan.approved"));
 			return result(JSON.stringify(manifest.planApproval, null, 2), {
 				action: "api",
 				status: "ok",
@@ -150,13 +150,13 @@ export const handleCancelPlan: ApiOperationHandler = async (hctx) => {
 			const denyRecord = getCurrentPlanRecord(manifest);
 			if (denyRecord) setPlanApproval(manifest, { status: "rejected", planVersion: denyRecord.version, by: "api" });
 			saveRunTasks(manifest, tasks);
-			appendEvent(manifest.eventsPath, {
+			appendEventBuffered(manifest.eventsPath, {
 				type: "plan.cancelled",
 				runId: manifest.runId,
 				taskId: approval.planTaskId,
 				message: "Adaptive implementation plan was cancelled.",
 				metadata: { provenance: "api" },
-			});
+			}).catch((e) => logInternalError("api.plan-approval.buffered", e, "type=plan.cancelled"));
 			manifest = updateRunStatus(manifest, "cancelled", "Plan approval was cancelled.");
 			void terminateLiveAgentsForRun(manifest.runId, "cancelled", appendEvent, manifest.eventsPath).catch((error) =>
 				logInternalError("team-tool.cancel-plan.terminate", error, `runId=${manifest.runId}`),

package/src/extension/team-tool/api/task-claims.ts

@@ -16,9 +16,10 @@
 import { canTransitionTaskStatus, isTeamTaskStatus } from "../../../state/contracts.ts";
 import { withRunLockSync } from "../../../state/coordination/locks.ts";
 import { claimTask, releaseTaskClaim, transitionClaimedTaskStatus } from "../../../state/coordination/task-claims.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 type { TeamTaskState } from "../../../state/types.ts";
+import { logInternalError } from "../../../utils/internal-error.ts";
 import { RUN_NOT_FOUND_HINT } from "../run-not-found.ts";
 import type { ApiHandlerContext, ApiOperationHandler } from "./handler-context.ts";
 
@@ -92,7 +93,7 @@ export const handleClaimTask: ApiOperationHandler = (ctx) => {
 			const updatedTask = claimTask(freshTask, owner);
 			const tasks = fresh.tasks.map((item) => (item.id === freshTask.id ? updatedTask : item));
 			saveRunTasks(fresh.manifest, tasks);
-			appendEvent(fresh.manifest.eventsPath, {
+			appendEventBuffered(fresh.manifest.eventsPath, {
 				type: "task.claimed",
 				runId: fresh.manifest.runId,
 				taskId: freshTask.id,
@@ -101,7 +102,7 @@ export const handleClaimTask: ApiOperationHandler = (ctx) => {
 					token: "[REDACTED]",
 					leasedUntil: updatedTask.claim?.leasedUntil,
 				},
-			});
+			}).catch((e) => logInternalError("api.task-claims.buffered", e, "type=task.claimed"));
 			return result(JSON.stringify(updatedTask.claim, null, 2), {
 				action: "api",
 				status: "ok",
@@ -162,12 +163,12 @@ export const handleReleaseTaskClaim: ApiOperationHandler = (ctx) => {
 			const updatedTask = releaseTaskClaim(freshTask, owner, token);
 			const tasks = fresh.tasks.map((item) => (item.id === freshTask.id ? updatedTask : item));
 			saveRunTasks(fresh.manifest, tasks);
-			appendEvent(fresh.manifest.eventsPath, {
+			appendEventBuffered(fresh.manifest.eventsPath, {
 				type: "task.claim_released",
 				runId: fresh.manifest.runId,
 				taskId: freshTask.id,
 				data: { owner },
-			});
+			}).catch((e) => logInternalError("api.task-claims.buffered", e, "type=task.claim_released"));
 			return result(JSON.stringify(updatedTask, null, 2), {
 				action: "api",
 				status: "ok",
@@ -241,12 +242,12 @@ export const handleTransitionTaskStatus: ApiOperationHandler = (ctx) => {
 			const updatedTask = transitionClaimedTaskStatus(freshTask, owner, token, to);
 			const tasks = fresh.tasks.map((item) => (item.id === freshTask.id ? updatedTask : item));
 			saveRunTasks(fresh.manifest, tasks);
-			appendEvent(fresh.manifest.eventsPath, {
+			appendEventBuffered(fresh.manifest.eventsPath, {
 				type: "task.status_transitioned",
 				runId: fresh.manifest.runId,
 				taskId: freshTask.id,
 				data: { owner, status: to },
-			});
+			}).catch((e) => logInternalError("api.task-claims.buffered", e, "type=task.status_transitioned"));
 			return result(JSON.stringify(updatedTask, null, 2), {
 				action: "api",
 				status: "ok",

package/src/extension/team-tool/cancel.ts

@@ -392,6 +392,12 @@ export async function handleCancel(params: TeamToolParamsValue, ctx: TeamContext
 		}
 		ctx.abortForegroundRun?.(fresh.manifest.runId);
 		for (const taskId of abortResult.abortedIds) {
+			// REVIEW FIX (2026-09-10): reverted M2b buffered conversion. Although
+			// task.cancelled is a TERMINAL type (buffered terminal path bypasses
+			// the 20ms buffer), that path still resolves via a microtask chain
+			// (flushPromise.then(appendEvent)) — NOT same-tick. Cancel tests and
+			// the immediately-following updateRunStatus reader need same-tick
+			// durability, so plain sync appendEvent (base behavior).
 			appendEvent(fresh.manifest.eventsPath, {
 				type: "task.cancelled",
 				runId: fresh.manifest.runId,