pi-crew 0.9.33 → 0.9.35

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

@@ -88,6 +88,30 @@ export interface StableComponents {
 
 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}`;
 }
@@ -95,10 +119,13 @@ function stablePrefixCacheKey(task: TeamTaskState, step: WorkflowStep, manifest:
 /**
  * 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.
- * Safe to call at any time; the next compute re-populates lazily.
+ * 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();
 }
 
 /**
@@ -112,10 +139,29 @@ export async function computeStablePrefixComponents(
 	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}` : "";
 
@@ -130,6 +176,14 @@ export async function computeStablePrefixComponents(
 
 	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;
 }
 

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/tail-read.ts

@@ -4,10 +4,22 @@ import * as fs from "node:fs";
  * Read the tail of a file, capped at maxBytes.
  * If the file exceeds maxBytes, reads only the last maxBytes and snaps
  * to the nearest newline boundary to avoid partial JSONL lines.
+ *
+ * Falls back to `fallbackContent` when the file is missing OR empty. The
+ * empty-file case matters because `appendTranscript` is fire-and-forget
+ * async in the mock path (commit e316a36) — the file is created on disk
+ * (existsSync returns true) before the actual write completes, so a
+ * subsequent tail-read can observe size=0. Returning "" in that case would
+ * silently drop the mock's stdout, breaking downstream parsers that depend
+ * on a non-empty transcript (e.g. adaptive-plan JSON extraction in
+ * implementation-fanout.test.ts). Falling back to `fallbackContent` keeps
+ * the existing fallback semantics: "if the file isn't usable, use what
+ * the caller already has."
  */
 export function tailReadWithLineSnap(filePath: string, maxBytes: number, fallbackContent: string): string {
 	if (!fs.existsSync(filePath)) return fallbackContent;
 	const stat = fs.statSync(filePath);
+	if (stat.size === 0) return fallbackContent;
 	if (stat.size <= maxBytes) return fs.readFileSync(filePath, "utf-8");
 	const fd = fs.openSync(filePath, "r");
 	try {

package/src/runtime/task-runner.ts

@@ -7,8 +7,8 @@ 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 { withRunLock } from "../state/locks.ts";
+import { saveRunManifestAsync } from "../state/state-store.ts";
 import { createTaskClaim } from "../state/task-claims.ts";
 import type {
 	ArtifactDescriptor,
@@ -83,6 +83,36 @@ import {
 // Register the submit_result tool handler so subprocess events can extract yield data.
 registerYieldTool();
 
+/** Async helper for writing steering events — fire-and-forget for non-blocking writes. */
+async function appendSteeringAsync(steeringDir: string, taskId: string, steers: string[]): Promise<void> {
+	try {
+		await fs.promises.mkdir(steeringDir, { recursive: true });
+		const steeringPath = `${steeringDir}/${taskId}.jsonl`;
+		const lines = steers
+			.map(
+				(msg) =>
+					JSON.stringify({
+						type: "steer",
+						message: msg,
+						ts: new Date().toISOString(),
+					}) + "\n",
+			)
+			.join("");
+		await fs.promises.appendFile(steeringPath, lines, "utf-8");
+	} catch (error) {
+		logInternalError("task-runner.steering-write-failed", error as Error, `taskId=${taskId}`);
+	}
+}
+
+/** Async helper for writing background logs — fire-and-forget for non-blocking writes. */
+async function appendBackgroundLogAsync(bgLogPath: string, eventLine: string): Promise<void> {
+	try {
+		await fs.promises.appendFile(bgLogPath, `${eventLine}\n`, "utf-8");
+	} catch (error) {
+		logInternalError("task-runner.background-log-write-failed", error as Error, `path=${bgLogPath}`);
+	}
+}
+
 export interface TaskRunnerInput {
 	manifest: TeamRunManifest;
 	tasks: TeamTaskState[];
@@ -413,7 +443,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 				// Ensure transcripts/ subdirectory exists before child-pi appends
 				// to it. appendTranscript uses O_APPEND (no mkdir) for security,
 				// so the caller must create the directory.
-				fs.mkdirSync(path.join(manifest.artifactsRoot, "transcripts"), {
+				await fs.promises.mkdir(path.join(manifest.artifactsRoot, "transcripts"), {
 					recursive: true,
 				});
 				const model = attemptModels[i];
@@ -460,18 +490,8 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 							({ task, tasks } = checkpointTask(manifest, tasks, task, "child-spawned", pid));
 							if (task.pendingSteers?.length) {
 								const steeringDir = `${manifest.artifactsRoot}/steering`;
-								fs.mkdirSync(steeringDir, { recursive: true });
-								const steeringPath = `${steeringDir}/${task.id}.jsonl`;
-								for (const msg of task.pendingSteers) {
-									fs.appendFileSync(
-										steeringPath,
-										JSON.stringify({
-											type: "steer",
-											message: msg,
-											ts: new Date().toISOString(),
-										}) + "\n",
-									);
-								}
+								// Fire-and-forget async write for steering events
+								void appendSteeringAsync(steeringDir, task.id, task.pendingSteers);
 								task.pendingSteers = [];
 								tasks = persistSingleTaskUpdate(manifest, tasks, task);
 							}
@@ -533,7 +553,8 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 								const bgLogPath = `${manifest.stateRoot}/background.log`;
 								const eventLine =
 									typeof event === "object" && !Array.isArray(event) ? JSON.stringify(event) : String(event);
-								fs.appendFileSync(bgLogPath, `${eventLine}\n`);
+								// Fire-and-forget async write for background log
+								void appendBackgroundLogAsync(bgLogPath, eventLine);
 							}
 							// Always keep in-memory agentProgress fresh (cheap) so the UI/events see
 							// the latest progress, but THROTTLE the disk persist. Previously this
@@ -1201,9 +1222,9 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		// 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);
+		tasks = await withRunLock(manifest, async () => {
+			await saveRunManifestAsync(manifest);
+			return persistSingleTaskUpdate(manifest, tasks, task);
 		});
 		upsertCrewAgent(manifest, recordFromTask(manifest, task, runtimeKind));
 		// Execute task_result hook before emitting terminal event