pi-crew 0.9.32 → 0.9.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-crew",
-  "version": "0.9.32",
+  "version": "0.9.34",
   "description": "Pi extension for coordinated AI teams, workflows, worktrees, and async task orchestration",
   "author": "baphuongna",
   "license": "MIT",

package/src/extension/run-maintenance.ts

@@ -7,6 +7,7 @@ import { logInternalError } from "../utils/internal-error.ts";
 import { projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
 import { redactSecrets } from "../utils/redaction.ts";
 import { isSafePathId, resolveRealContainedPath } from "../utils/safe-paths.ts";
+import { cleanupRunWorktrees } from "../worktree/cleanup.ts";
 import { listRuns } from "./run-index.ts";
 
 export interface PruneRunsResult {
@@ -21,7 +22,14 @@ export interface PruneRunsOptions {
 }
 
 function isFinished(run: TeamRunManifest): boolean {
-	return run.status === "completed" || run.status === "failed" || run.status === "cancelled" || run.status === "blocked";
+	// P3: "blocked" is NOT a terminal status — the run is waiting on something
+	// (plan approval, mailbox reply, scheduler stall) and can transition to
+	// running/cancelled/failed (per TEAM_RUN_STATUS_TRANSITIONS). Pruning a
+	// blocked run destroys recoverable state (e.g. a plan the user needs to
+	// approve, or a mailbox wait the user needs to answer). Truly stuck
+	// blocked runs are handled by the stale-reconciler/crash-recovery, not
+	// by prune.
+	return run.status === "completed" || run.status === "failed" || run.status === "cancelled";
 }
 
 function isSafeToPrune(cwd: string, run: TeamRunManifest): boolean {
@@ -66,6 +74,26 @@ export function pruneFinishedRuns(cwd: string, keep: number, options: PruneRunsO
 			);
 			continue;
 		}
+		// P2: clean up git worktrees BEFORE deleting state. Worktrees live at
+		// <crewRoot>/state/worktrees/<runId>/ — a separate path from stateRoot
+		// (<crewRoot>/state/runs/<runId>/) and artifactsRoot, so fs.rmSync below
+		// does NOT touch them. Without this, every pruned worktree-using run
+		// leaks its worktree dir + git branch. cleanupRunWorktrees (no force)
+		// preserves dirty worktrees by writing a diff artifact and skipping
+		// the removal — in that case we skip the whole prune of this run so
+		// the user can recover (no silent data loss). Compare handleForget
+		// which calls cleanupRunWorktrees.
+		const worktreeCleanup = cleanupRunWorktrees(run, { signal: options.signal });
+		if (worktreeCleanup.preserved.length > 0) {
+			logInternalError(
+				"prune.worktree-preserved",
+				new Error(
+					`Skipping prune: ${worktreeCleanup.preserved.length} dirty worktree(s) preserved for recovery: ${worktreeCleanup.preserved.map((p) => p.path).join(", ")}`,
+				),
+				`runId=${run.runId}`,
+			);
+			continue;
+		}
 		fs.rmSync(run.stateRoot, { recursive: true, force: true });
 		fs.rmSync(run.artifactsRoot, { recursive: true, force: true });
 		removed.push(run.runId);

package/src/extension/team-tool/lifecycle-actions.ts

@@ -2,9 +2,12 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { removeGuidance } from "../../config/markers.ts";
 import { appendHookEvent, executeHook } from "../../hooks/registry.ts";
+import { killProcessPid } from "../../runtime/child-pi.ts";
+import { terminateLiveAgentsForRun } from "../../runtime/live-agent-manager.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { appendEvent } from "../../state/event-log.ts";
 import { loadRunManifestById } from "../../state/state-store.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
 import { projectCrewRoot, userCrewRoot, userPiRoot } from "../../utils/paths.ts";
 import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
 import { cleanupRunWorktrees } from "../../worktree/cleanup.ts";
@@ -217,6 +220,25 @@ export async function handleForget(params: TeamToolParamsValue, ctx: TeamContext
 			intent,
 		},
 	});
+	// P1: terminate live agents + kill the background runner BEFORE deleting state.
+	// Without this, forgetting a running run orphans those processes (separate
+	// process groups via setsid) which keep executing and consuming tokens after
+	// their state directory is gone. Mirrors handleCancel's cleanup.
+	await terminateLiveAgentsForRun(loaded.manifest.runId, "cancelled", appendEvent, loaded.manifest.eventsPath);
+	const asyncPid = loaded.manifest.async?.pid;
+	if (asyncPid !== undefined && asyncPid > 0) {
+		try {
+			killProcessPid(asyncPid);
+			appendEvent(loaded.manifest.eventsPath, {
+				type: "async.kill_requested",
+				runId: loaded.manifest.runId,
+				message: "Sent SIGTERM to background runner process (forget).",
+				data: { pid: asyncPid },
+			});
+		} catch (error) {
+			logInternalError("team-tool.handleForget.killAsync", error, `runId=${loaded.manifest.runId},pid=${asyncPid}`);
+		}
+	}
 	// Determine scope from manifest paths (project vs user-level runs)
 	const crewRoot = loaded.manifest.stateRoot.startsWith(userCrewRoot() + path.sep)
 		? userCrewRoot()

package/src/extension/team-tool.ts

@@ -314,6 +314,17 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 	if (!runCwd) return result(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "resume", status: "error" }, true);
 	const loaded = loadRunManifestById(runCwd, params.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	if (!loaded) return result(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "resume", status: "error" }, true);
+	// R1: foreign-ownership check — mirrors handleRetry/handleCancel. Without it,
+	// another session can resume (and re-execute) a run it doesn't own, racing
+	// the owning session.
+	const foreignRun = typeof loaded.manifest.ownerSessionId === "string" && loaded.manifest.ownerSessionId !== ctx.sessionId;
+	if (foreignRun && !params.force) {
+		return result(
+			`Run ${loaded.manifest.runId} belongs to another session. Use force: true to override.`,
+			{ action: "resume", status: "error", runId: loaded.manifest.runId },
+			true,
+		);
+	}
 	if (!loaded.manifest.workflow)
 		return result(`Run '${params.runId}' has no workflow to resume.`, { action: "resume", status: "error" }, true);
 	const agents = allAgents(discoverAgents(ctx.cwd));
@@ -324,8 +335,18 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 		direct?.workflow ?? allWorkflows(discoverWorkflows(ctx.cwd)).find((candidate) => candidate.name === loaded.manifest.workflow);
 	if (!workflow) return result(`Workflow '${loaded.manifest.workflow}' not found.`, { action: "resume", status: "error" }, true);
 	return await withRunLock(loaded.manifest, async () => {
+		// R2: re-read inside the lock so recovery + resetTasks reflect committed
+		// state, not the pre-lock snapshot. Between the pre-lock load and lock
+		// acquisition a task may have been cancelled (stale-reconciler) or
+		// completed (background runner); using the stale snapshot would reset
+		// running→queued and re-execute it (double execution: duplicate tokens +
+		// duplicate side effects). Sibling handlers (cancelOrphanedRuns,
+		// reconcileAllStaleRuns) re-read inside the lock for the same reason.
+		const fresh = loadRunManifestById(runCwd, loaded.manifest.runId);
+		const lockedManifest = fresh?.manifest ?? loaded.manifest;
+		const lockedTasks = fresh?.tasks ?? loaded.tasks;
 		const loadedConfig = loadConfig(ctx.cwd);
-		const recovered = recoverCheckpointedTasks(loaded.manifest, loaded.tasks);
+		const recovered = recoverCheckpointedTasks(lockedManifest, lockedTasks);
 		const resumeManifest = recovered.manifest;
 		const executedConfig = {
 			...effectiveRunConfig(loadedConfig.config, params.config),

package/src/observability/exporters/otlp-exporter.ts

@@ -38,12 +38,34 @@ export function validateEndpoint(endpoint: string): void {
 	// Reject IPv6 loopback and private
 	if (hostname.startsWith("[")) {
 		const bare = hostname.replace(/^\[|\]$/g, "");
-		if (bare === "::1") {
+		const lower = bare.toLowerCase();
+		if (lower === "::1") {
 			throw new Error(`OTLP endpoint must not target loopback address: ${endpoint}`);
 		}
-		if (bare.toLowerCase().startsWith("fd") || bare.toLowerCase().startsWith("fc")) {
+		// Unique Local Addresses (fc00::/7) — fd and fc prefixes
+		if (lower.startsWith("fd") || lower.startsWith("fc")) {
 			throw new Error(`OTLP endpoint must not target private IPv6 address: ${endpoint}`);
 		}
+		// Link-Local (fe80::/10) — fe8x, fe9x, feax, febx prefixes
+		if (lower.startsWith("fe8") || lower.startsWith("fe9") || lower.startsWith("fea") || lower.startsWith("feb")) {
+			throw new Error(`OTLP endpoint must not target IPv6 link-local address: ${endpoint}`);
+		}
+		// Site-Local (fec0::/10) — deprecated but still routable on misconfigured networks
+		if (lower.startsWith("fec") || lower.startsWith("fed") || lower.startsWith("fee") || lower.startsWith("fef")) {
+			throw new Error(`OTLP endpoint must not target IPv6 site-local address: ${endpoint}`);
+		}
+		// Multicast (ff00::/8) — prefix ff
+		if (lower.startsWith("ff")) {
+			throw new Error(`OTLP endpoint must not target IPv6 multicast address: ${endpoint}`);
+		}
+		// Unspecified address ::
+		if (lower === "::") {
+			throw new Error(`OTLP endpoint must not target IPv6 unspecified address: ${endpoint}`);
+		}
+		// IPv4-mapped IPv6 (::ffff:x.x.x.x)
+		if (lower.startsWith("::ffff:")) {
+			throw new Error(`OTLP endpoint must not target IPv4-mapped IPv6 address: ${endpoint}`);
+		}
 	}
 
 	// Reject IPv4 private/reserved ranges

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

@@ -5,7 +5,7 @@ import { resolveToolPolicy } from "../agents/agent-config.ts";
 import type { CrewRuntimeConfig } from "../config/config.ts";
 import { loadConfig } from "../config/config.ts";
 import { DEFAULT_LIVE_SESSION } from "../config/defaults.ts";
-import { appendEvent } from "../state/event-log.ts";
+import { appendEvent, appendEventFireAndForget } from "../state/event-log.ts";
 import type { TeamRunManifest, TeamTaskState, UsageState } from "../state/types.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { redactSecrets } from "../utils/redaction.ts";
@@ -676,7 +676,9 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 			customTools,
 		});
 		session = created.session;
-		appendEvent(input.manifest.eventsPath, {
+		// P7 (perf): fire-and-forget — return value not needed, blocks the
+		// event loop less than the sync appendEvent under file-lock contention.
+		appendEventFireAndForget(input.manifest.eventsPath, {
 			type: "live-session.session_created",
 			runId: input.manifest.runId,
 			taskId: input.task.id,
@@ -696,7 +698,8 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 			]);
 		} catch (bindError) {
 			const msg = bindError instanceof Error ? bindError.message : String(bindError);
-			appendEvent(input.manifest.eventsPath, {
+			// P7: fire-and-forget — return value not needed.
+			appendEventFireAndForget(input.manifest.eventsPath, {
 				type: "live-session.bind_extensions_error",
 				runId: input.manifest.runId,
 				taskId: input.task.id,
@@ -879,7 +882,8 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 
 		// Diagnostic: log prompt size and timing
 		const promptStart = Date.now();
-		appendEvent(input.manifest.eventsPath, {
+		// P7: fire-and-forget — return value not needed.
+		appendEventFireAndForget(input.manifest.eventsPath, {
 			type: "live-session.prompt_start",
 			runId: input.manifest.runId,
 			taskId: input.task.id,
@@ -896,7 +900,8 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 			await promptWithTimeout(session, effectivePrompt, sessionTimeoutMs, "Live-session");
 		} catch (promptError) {
 			const msg = promptError instanceof Error ? promptError.message : String(promptError);
-			appendEvent(input.manifest.eventsPath, {
+			// P7: fire-and-forget — return value not needed.
+			appendEventFireAndForget(input.manifest.eventsPath, {
 				type: "live-session.prompt_error",
 				runId: input.manifest.runId,
 				taskId: input.task.id,
@@ -916,7 +921,8 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 			}
 			throw promptError;
 		}
-		appendEvent(input.manifest.eventsPath, {
+		// P7: fire-and-forget — return value not needed.
+		appendEventFireAndForget(input.manifest.eventsPath, {
 			type: "live-session.prompt_done",
 			runId: input.manifest.runId,
 			taskId: input.task.id,

package/src/runtime/parallel-utils.ts

@@ -43,6 +43,11 @@ export function flattenSteps(steps: RunnerStep[]): RunnerSubagentStep[] {
 }
 
 export async function mapConcurrent<T, R>(items: T[], limit: number, fn: (item: T, i: number) => Promise<R>): Promise<R[]> {
+	// P12 (perf): single-item fast path. Skip the Promise.all + worker-pool
+	// setup when there's exactly one item — just call fn directly. Same return
+	// shape, no concurrency overhead, no micro-task allocation.
+	if (items.length === 1) return [await fn(items[0], 0)];
+	if (items.length === 0) return [];
 	const safeLimit = Math.max(1, Math.floor(limit) || 1);
 	const results: R[] = new Array(items.length);
 	let next = 0;

package/src/runtime/skill-instructions.ts

@@ -135,6 +135,8 @@ interface CachedSkillMarkdown {
 	path: string;
 	source: "project" | "package" | "project-pi" | "user-pi" | "project-agents" | "user-agents";
 	content: string;
+	/** Pre-computed compacted body (frontmatter stripped + truncated). Cached to avoid re-compaction on every render. */
+	compacted: string;
 	mtimeMs: number;
 	size: number;
 }
@@ -173,6 +175,7 @@ function readSkillMarkdown(
 			path: string;
 			source: "project" | "package" | "project-pi" | "user-pi" | "project-agents" | "user-agents";
 			content: string;
+			compacted: string;
 	  }
 	| undefined {
 	if (!isValidSkillName(name)) return undefined;
@@ -188,10 +191,12 @@ function readSkillMarkdown(
 			if (fs.lstatSync(contained).isSymbolicLink()) continue;
 			const filePath = resolveRealContainedPath(entry.root, relative);
 			const stat = fs.statSync(filePath);
+			const rawContent = fs.readFileSync(filePath, "utf-8");
 			return rememberSkill(cacheKey, {
 				path: filePath,
 				source: entry.source,
-				content: fs.readFileSync(filePath, "utf-8"),
+				content: rawContent,
+				compacted: compactSkillContent(rawContent),
 				mtimeMs: stat.mtimeMs,
 				size: stat.size,
 			});
@@ -296,7 +301,7 @@ export function renderSkillInstructions(
 		]
 			.filter(Boolean)
 			.join("\n");
-		const rawContent = compactSkillContent(loaded.content);
+		const rawContent = loaded.compacted;
 		// Wrap skill content with provenance markers to help LLMs distinguish skill instructions
 		const wrappedContent = `<!-- skill: ${safeName} -->\n${rawContent}\n<!-- end-skill: ${safeName} -->`;
 		const section = `${header}\n\n${wrappedContent}`;

package/src/runtime/task-graph-scheduler.ts

@@ -15,8 +15,24 @@ export interface TaskGraphIndex {
 	stepToTaskId: Map<string, string>;
 }
 
+/**
+ * P14 (perf): identity-keyed memoization for `buildTaskGraphIndex`. The 3
+ * data structures built here (doneSteps Set, idMap Map, stepToTaskId Map) are
+ * a function of the task list alone — if the caller passes the SAME array
+ * reference twice (e.g., across `refreshTaskGraphQueues` -> `getReadyTasks`
+ * rounds within one main-loop iteration before any new tasks land), we can
+ * reuse the cached index. The cache is invalidated naturally by a new array
+ * reference (e.g., the result of `markTaskRunning` / `markTaskDone`).
+ *
+ * Memozation is a WeakMap so a stale reference is collected when the array
+ * goes out of scope — no manual invalidation needed, no unbounded growth.
+ */
+const taskGraphIndexCache = new WeakMap<TeamTaskState[], TaskGraphIndex>();
+
 export function buildTaskGraphIndex(tasks: TeamTaskState[]): TaskGraphIndex {
-	return {
+	const cached = taskGraphIndexCache.get(tasks);
+	if (cached) return cached;
+	const fresh: TaskGraphIndex = {
 		doneSteps: new Set(
 			tasks
 				.filter((task) => task.status === "completed")
@@ -28,6 +44,18 @@ export function buildTaskGraphIndex(tasks: TeamTaskState[]): TaskGraphIndex {
 			tasks.map((task) => [task.stepId, task.id]).filter((entry): entry is [string, string] => entry[0] !== undefined),
 		),
 	};
+	taskGraphIndexCache.set(tasks, fresh);
+	return fresh;
+}
+
+/** Test/diagnostic helper — invalidate the WeakMap-backed index cache. Not
+ *  used by production code paths; the WeakMap self-invalidates when a tasks
+ *  array goes out of scope. Provided for parity with `clearStablePrefixCache`. */
+export function clearTaskGraphIndexCache(): void {
+	// WeakMap has no `.clear()`; rely on GC. Exposed as a no-op stub so callers
+	// that import `clearStablePrefixCache` (also a no-op stub for symmetry) can
+	// adopt a parallel API if needed in the future. Documented as no-op rather
+	// than removed so the API stays discoverable.
 }
 
 function taskById(tasks: TeamTaskState[]): Map<string, TeamTaskState> {
@@ -48,28 +76,31 @@ function dependencySatisfied(
 }
 
 function withQueue(task: TeamTaskState, index: TaskGraphIndex): TeamTaskState {
+	let resolvedQueue: "ready" | "blocked" | "running" | "done";
 	if (task.status === "queued") {
 		const isReady = dependencySatisfied(task, index.doneSteps, index.idMap, index.stepToTaskId);
-		return {
-			...task,
-			graph: task.graph ? { ...task.graph, queue: isReady ? "ready" : "blocked" } : task.graph,
-		};
+		resolvedQueue = isReady ? "ready" : "blocked";
+	} else if (task.status === "running") {
+		resolvedQueue = "running";
+	} else if (task.status === "completed" || task.status === "skipped" || task.status === "needs_attention") {
+		resolvedQueue = "done";
+	} else {
+		resolvedQueue = "blocked";
 	}
-	if (task.status === "running") {
-		return {
-			...task,
-			graph: task.graph ? { ...task.graph, queue: "running" } : task.graph,
-		};
-	}
-	if (task.status === "completed" || task.status === "skipped" || task.status === "needs_attention") {
-		return {
-			...task,
-			graph: task.graph ? { ...task.graph, queue: "done" } : task.graph,
-		};
+
+	// FIX (incremental task graph refresh): return the SAME task reference when
+	// the computed queue already matches task.graph.queue. This eliminates the
+	// per-task per-call spread allocation that previously ran on every
+	// refreshTaskGraphQueues invocation. Common case (queue unchanged from the
+	// previous refresh) is now allocation-free; reference-stable tasks also let
+	// downstream selectors skip re-rendering when queues haven't moved.
+	if (task.graph && task.graph.queue === resolvedQueue) {
+		return task;
 	}
+
 	return {
 		...task,
-		graph: task.graph ? { ...task.graph, queue: "blocked" } : task.graph,
+		graph: task.graph ? { ...task.graph, queue: resolvedQueue } : task.graph,
 	};
 }
 

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

@@ -75,6 +75,118 @@ export function renderOutputSchemaBlock(outputSchema: TaskOutputSchema): string
 	return lines.join("\n");
 }
 
+/**
+ * Expensive async sub-results that compose the stable prefix.
+ * These are cached per (cwd, step.task, runId) so parallel siblings
+ * in the same batch reuse them instead of recomputing.
+ */
+export interface StableComponents {
+	treeBlock: string;
+	suggestedFilesBlock: string;
+	knowledgeFragment: string;
+}
+
+const stableComponentCache = new Map<string, StableComponents>();
+
+// P9 (perf): cross-run cache for the I/O-heavy sub-results (workspace tree +
+// retrieval). The tree and retrieval don't depend on runId, only on (cwd, step).
+// A short-lived (TTL-bounded) cross-run cache lets sequential runs in the same
+// session amortize the cost: run #2 in cwd X with the same step text gets a
+// cache hit instead of redoing `buildWorkspaceTree` (which walks the FS) and
+// `runRetrievalCycle`. The TTL bounds staleness in long-lived sessions (e.g.,
+// the workspace may have changed between runs); a mtime check on the
+// .git/HEAD or workspace marker would be overkill for an already-bounded
+// perf win. The full per-run cache key still drives the fast path on a
+// hot batch (so concurrent siblings in the SAME run never re-do work).
+interface CachedStableIO {
+	treeBlock: string;
+	suggestedFilesBlock: string;
+	knowledgeFragment: string;
+	at: number;
+}
+const STABLE_IO_TTL_MS = 60_000; // 60s — short enough that long-lived sessions
+// re-warm on workspace drift; long enough that back-to-back runs share.
+const stableIOCache = new Map<string, CachedStableIO>();
+
+function stableIOCacheKey(cwd: string, stepTask: string): string {
+	return `${cwd}\u0001${stepTask}`;
+}
+
+function stablePrefixCacheKey(task: TeamTaskState, step: WorkflowStep, manifest: TeamRunManifest): string {
+	return `${task.cwd}|${step.task}|${manifest.runId}`;
+}
+
+/**
+ * Clear the stable prefix cache. Called at run end so the module-level cache
+ * (keyed by runId) does not grow unbounded across runs in a long-lived session.
+ * Also clears the cross-run I/O cache so workspace drift after long pauses is
+ * picked up immediately rather than after STABLE_IO_TTL_MS. Safe to call at
+ * any time; the next compute re-populates lazily.
+ */
+export function clearStablePrefixCache(): void {
+	stableComponentCache.clear();
+	stableIOCache.clear();
+}
+
+/**
+ * Compute (or return cached) expensive async sub-results that compose
+ * the stable prefix: workspace tree, file retrieval, knowledge fragment.
+ * Parallel siblings with the same cwd/step/run reuse the cached result.
+ */
+export async function computeStablePrefixComponents(
+	manifest: TeamRunManifest,
+	step: WorkflowStep,
+	task: TeamTaskState,
+	_agent?: AgentConfig,
+): Promise<StableComponents> {
+	// P9 fast path: per-(cwd, step, runId) cache hit \u2014 parallel siblings in the
+	// same batch share work with zero FS access.
+	const cacheKey = stablePrefixCacheKey(task, step, manifest);
+	const cached = stableComponentCache.get(cacheKey);
+	if (cached) return cached;
+
+	// P9 cross-run path: same (cwd, step.task) across different runIds share
+	// the I/O-heavy sub-results (tree, retrieval, knowledge) for STABLE_IO_TTL_MS.
+	// This is the second-level cache; on a hit we save 3 awaits + a FS walk.
+	const ioKey = stableIOCacheKey(task.cwd, step.task);
+	const ioCached = stableIOCache.get(ioKey);
+	const now = Date.now();
+	const ioFresh = ioCached && now - ioCached.at < STABLE_IO_TTL_MS;
+	if (ioFresh) {
+		const components: StableComponents = {
+			treeBlock: ioCached!.treeBlock,
+			suggestedFilesBlock: ioCached!.suggestedFilesBlock,
+			knowledgeFragment: ioCached!.knowledgeFragment,
+		};
+		stableComponentCache.set(cacheKey, components);
+		return components;
+	}
+
+	const tree = await buildWorkspaceTree(task.cwd);
+	const treeBlock = tree.rendered ? `# Workspace Structure\n${tree.rendered}` : "";
+
+	const retrieval = await runRetrievalCycle(step.task, manifest.goal, task.cwd);
+	const suggestedFilesBlock = renderSuggestedFilesSection(retrieval);
+
+	const knowledgeFragment = buildKnowledgeFragment(task.cwd, {
+		goal: manifest.goal,
+		taskText: step.task,
+		role: step.role,
+	});
+
+	const components: StableComponents = { treeBlock, suggestedFilesBlock, knowledgeFragment };
+	stableComponentCache.set(cacheKey, components);
+	// Populate the cross-run cache. Clamp size to avoid unbounded growth across
+	// long sessions with many distinct (cwd, step) combos.
+	stableIOCache.set(ioKey, { ...components, at: now });
+	while (stableIOCache.size > 256) {
+		const oldest = stableIOCache.keys().next().value;
+		if (oldest === undefined) break;
+		stableIOCache.delete(oldest);
+	}
+	return components;
+}
+
 export interface RenderedTaskPrompt {
 	/** Stable sections that rarely change between tasks of the same role/cwd. */
 	stablePrefix: string;
@@ -90,23 +202,16 @@ export async function renderTaskPrompt(
 	task: TeamTaskState,
 	agent?: AgentConfig,
 	skillBlock = "",
+	precomputedStableComponents?: StableComponents,
 ): Promise<RenderedTaskPrompt> {
 	const memoryBlock = agent?.memory
 		? buildMemoryBlock(agent.name, agent.memory, task.cwd, Boolean(agent.tools?.some((tool) => tool === "write" || tool === "edit")))
 		: "";
 
-	// Build workspace tree for stable context
-	const tree = await buildWorkspaceTree(task.cwd);
-	const treeBlock = tree.rendered ? `# Workspace Structure\n${tree.rendered}` : "";
-
-	// M3: run iterative file-retrieval AFTER the workspace tree is
-	// assembled and BEFORE the dynamic suffix is built, so the suggested
-	// files section lands in the stable prefix (next to the tree) and
-	// is visible to the worker before they start on the task. Never
-	// throws — the orchestrator falls back to in-memory heuristic when
-	// ripgrep is not installed.
-	const retrieval = await runRetrievalCycle(step.task, manifest.goal, task.cwd);
-	const suggestedFilesBlock = renderSuggestedFilesSection(retrieval);
+	// Use precomputed or cached stable components when available, avoiding
+	// redundant workspace tree, file retrieval, and knowledge fragment
+	// computation for parallel siblings in the same batch.
+	const stableComponents = precomputedStableComponents ?? (await computeStablePrefixComponents(manifest, step, task, agent));
 
 	// Stable prefix: role instructions, coordination, workspace tree — rarely changes
 	const stablePrefix = [
@@ -131,20 +236,16 @@ export async function renderTaskPrompt(
 		"",
 		coordinationBridgeInstructions(task),
 		"",
-		treeBlock,
+		stableComponents.treeBlock,
 		"",
-		suggestedFilesBlock,
+		stableComponents.suggestedFilesBlock,
 		"",
 		toolGuidanceBlock(agent),
 		"",
 		// O4: project knowledge (.crew/knowledge.md) — workers don't load the
 		// pi-crew extension (spawned with --no-extensions), so before_agent_start
 		// never fires for them. Inject here so every worker sees project knowledge.
-		buildKnowledgeFragment(task.cwd, {
-			goal: manifest.goal,
-			taskText: step.task,
-			role: step.role,
-		}),
+		stableComponents.knowledgeFragment,
 	]
 		.filter(Boolean)
 		.join("\n");

package/src/runtime/task-runner/state-helpers.ts

@@ -66,7 +66,24 @@ export function persistSingleTaskUpdate(
 				// overwrite our buffered write between our load and our (async)
 				// fsync, silently losing the intermediate update.
 				flushPendingAtomicWrites();
-				const latest = loadRunManifestById(manifest.cwd, manifest.runId)?.tasks ?? fallbackTasks;
+				// FIX (perf): on the first attempt, reuse the caller-supplied
+				// fallbackTasks directly instead of calling loadRunManifestById.
+				// The caller already obtained the latest tasks via
+				// loadRunManifestById and handed them in as fallbackTasks, so a
+				// second load here is pure waste — it's another statSync pair
+				// (manifest + tasks) plus a possible JSON.parse. The CAS check
+				// below (currentMtime !== baseMtime) catches any concurrent
+				// writer that committed between fallbackTasks capture and now;
+				// when that fires we fall into the retry path which DOES call
+				// loadRunManifestById to pull the fresh state from disk. So we
+				// only pay the disk-read cost on actual contention, not on the
+				// common single-writer happy path.
+				let latest: TeamTaskState[];
+				if (attempt === 0) {
+					latest = fallbackTasks;
+				} else {
+					latest = loadRunManifestById(manifest.cwd, manifest.runId)?.tasks ?? fallbackTasks;
+				}
 				merged = updateTask(latest, taskWithCheckpoint);
 
 				// F2: collapsed from 3 redundant statSync calls into 1. The previous

package/src/runtime/task-runner.ts

@@ -7,6 +7,7 @@ import { errors } from "../errors.ts";
 import { appendHookEvent, executeHook } from "../hooks/registry.ts";
 import { writeArtifact } from "../state/artifact-store.ts";
 import { appendEventAsync, appendEventBuffered, appendEventFireAndForget } from "../state/event-log.ts";
+import { withRunLockSync } from "../state/locks.ts";
 import { saveRunManifest } from "../state/state-store.ts";
 import { createTaskClaim } from "../state/task-claims.ts";
 import type {
@@ -158,6 +159,10 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		} as TeamTaskState;
 		let tasks = updateTask(input.tasks, task);
 		const runtimeKind = input.taskRuntimeOverride ?? input.runtimeKind ?? (input.executeWorkers ? "child-process" : "scaffold");
+		// A1-F7: Pre-compute whether yield-event collection is needed. For child-process
+		// workers (the common case) this is always false, so we skip allocating/accumulating
+		// collectedJsonEvents entirely — eliminating ~10KB memory waste per task.
+		const collectYieldEvents = runtimeKind !== "child-process" && (input.runtimeConfig?.yield?.enabled ?? DEFAULT_YIELD_CONFIG.enabled);
 		// FIX: Check signal before persisting state — if cancelled, skip the write.
 		if (input.signal?.aborted) {
 			const cancelReason = cancellationReasonFromSignal(input.signal);
@@ -293,7 +298,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		let finalStdout = "";
 		let transcriptPath: string | undefined;
 		let terminalEvidence: OperationTerminalEvidence[] = [];
-		const collectedJsonEvents: Record<string, unknown>[] = [];
+		const collectedJsonEvents: Record<string, unknown>[] | undefined = collectYieldEvents ? [] : undefined;
 
 		let startupEvidence = createStartupEvidence({
 			command: runtimeKind === "child-process" ? "pi" : runtimeKind === "live-session" ? "live-session" : "safe-scaffold",
@@ -502,9 +507,9 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 						// Errors are logged but processing continues so subsequent events still update state.
 						try {
 							appendCrewAgentEvent(manifest, task.id, event);
-							if (event && typeof event === "object" && !Array.isArray(event))
+							if (collectedJsonEvents && event && typeof event === "object" && !Array.isArray(event))
 								collectedJsonEvents.push(event as Record<string, unknown>);
-							if (collectedJsonEvents.length > 1000) {
+							if (collectedJsonEvents && collectedJsonEvents.length > 1000) {
 								collectedJsonEvents.splice(0, collectedJsonEvents.length - 1000);
 							}
 							// Accumulate lifetime usage via message_end events (survives compaction)
@@ -878,8 +883,8 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		// only applies to live-session workers where submit_result is injected by the
 		// runtime. Skipping yield detection for child-process prevents every child
 		// worker from incorrectly being marked needs_attention.
-		const yieldEnabled = runtimeKind !== "child-process" && (input.runtimeConfig?.yield?.enabled ?? DEFAULT_YIELD_CONFIG.enabled);
-		if (yieldEnabled && collectedJsonEvents.length > 0) {
+		const yieldEnabled = collectYieldEvents;
+		if (yieldEnabled && collectedJsonEvents && collectedJsonEvents.length > 0) {
 			if (hasYieldInOutput(collectedJsonEvents)) {
 				const yieldEvent = collectedJsonEvents.find((e) => isYieldEvent(e));
 				if (yieldEvent) {
@@ -1190,8 +1195,16 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 				...(patchArtifact ? [patchArtifact] : []),
 			],
 		};
-		saveRunManifest(manifest);
-		tasks = persistSingleTaskUpdate(manifest, tasks, task);
+		// NEW-C3: persist manifest + tasks atomically under the run lock. Without this,
+		// the unlocked saveRunManifest here races with the team-runner batch merge path
+		// (which writes the manifest under withRunLock) — a parallel batch could read a
+		// stale manifest and overwrite this task's freshly-written artifacts, silently
+		// losing them. persistSingleTaskUpdate is re-entrance-safe (runLockHeldByUs guard),
+		// so nesting it inside this lock is a no-op re-acquire, not a deadlock.
+		withRunLockSync(manifest, () => {
+			saveRunManifest(manifest);
+			tasks = persistSingleTaskUpdate(manifest, tasks, task);
+		});
 		upsertCrewAgent(manifest, recordFromTask(manifest, task, runtimeKind));
 		// Execute task_result hook before emitting terminal event
 		const hookReport = await executeHook("task_result", {