pi-crew 0.9.68 → 0.10.2

package/src/runtime/subagent-manager.ts

@@ -25,11 +25,26 @@ export interface SubagentSpawnOptions {
 	/** Optional batch grouping id (Rule 1). Agents sharing a batchId coalesce
 	 * completion notifications into one. undefined => individual (default). */
 	batchId?: string;
+	/** WP-1/R1 (H6): owning team-run task id. Set by the one-shot Agent-tool
+	 * route once the run manifest resolves (taskId is only knowable after the
+	 * run is dispatched). undefined for unlinked/legacy spawns. */
+	taskId?: string;
+	/** WP-1/R1 (H6): ownership depth in the task tree (0 for a root one-shot).
+	 * Optional for back-compat; defaults to 0 at spawn. WP-5 owns depth
+	 * semantics for nested runs. */
+	depth?: number;
 }
 
 export interface SubagentRecord {
 	id: string;
 	runId?: string;
+	/** WP-1/R1 (H6): owning team-run task id (task ⇄ subagentId link).
+	 * Optional for back-compat — records without it render as today and steer
+	 * returns the existing "not linked" message (no throw). */
+	taskId?: string;
+	/** WP-1/R1 (H6): ownership depth (0 for root one-shot). Optional for
+	 * back-compat — legacy records without it render as today. */
+	depth?: number;
 	type: string;
 	description: string;
 	prompt: string;
@@ -144,6 +159,7 @@ const ALLOWED_RECORD_FIELDS = new Set([
 	"runId",
 	"cwd",
 	"taskId",
+	"depth",
 	"result",
 	"error",
 	"resultConsumed",
@@ -185,7 +201,13 @@ export function readPersistedSubagentRecord(cwd: string, id: string): SubagentRe
 	try {
 		const raw = JSON.parse(fs.readFileSync(persistedSubagentPath(cwd, id), "utf-8"));
 		return sanitizePersistedRecord(raw);
-	} catch {
+	} catch (error) {
+		// R17-B5: parse/read failures were fully silent, hiding lost records
+		// (see NEW-R3 note in savePersistedSubagentRecord). ENOENT stays quiet —
+		// a legitimately removed record (cancel) is not an error.
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+			logInternalError("subagent-manager.read-persisted", error, `id=${id}`, "warn");
+		}
 		return undefined;
 	}
 }
@@ -254,6 +276,8 @@ export class SubagentManager {
 			ownerSessionGeneration: options.ownerSessionGeneration,
 			ownerSessionId: options.ownerSessionId,
 			batchId: options.batchId,
+			taskId: options.taskId,
+			depth: options.depth ?? 0,
 		};
 		this.records.set(record.id, record);
 		this.cwdByRecord.set(record.id, options.cwd);

package/src/runtime/task-output-context.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { DEFAULT_OUTPUT_CONTEXT } from "../config/defaults.ts";
+import { getCrewEnv } from "../config/env-vars.ts";
 import { atomicWriteFile } from "../state/atomic-write.ts";
 import { writeArtifact } from "../state/stores/artifact-store.ts";
 import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../state/types.ts";
@@ -124,6 +125,13 @@ export interface ReadIfSmallTeeResult {
 	content: string;
 	/** Set only when tee was actually written (file size > 2× threshold + write succeeded). */
 	fullOutputPath?: string;
+	/** R10-1 (dep-context cache tee-safety): character length of the RAW file
+	 *  content BEFORE the truncation pipeline ran. Populated on every
+	 *  successful read; lets callers tell whether a cached no-tee read
+	 *  (`readIfSmall`) would have teed
+	 *  (length > TEE_THRESHOLD_MULTIPLIER × MAX_RESULT_INLINE_BYTES) without
+	 *  re-reading the file — no heuristics on the truncated body. */
+	originalLength?: number;
 }
 
 /**
@@ -211,9 +219,11 @@ export function readIfSmallWithTee(
 					},
 				}),
 			]);
-			return fullOutputPath ? { content: result.text, fullOutputPath } : { content: result.text };
+			return fullOutputPath
+				? { content: result.text, fullOutputPath, originalLength: content.length }
+				: { content: result.text, originalLength: content.length };
 		}
-		return { content };
+		return { content, originalLength: content.length };
 	} catch {
 		return undefined;
 	}
@@ -401,6 +411,12 @@ export function collectDependencyOutputContext(
 	tasks: TeamTaskState[],
 	task: TeamTaskState,
 	step: WorkflowStep,
+	/** R10-1 residual: per-run result-artifact read cache (same instance the
+	 *  closeout aggregation uses — created once in executeTeamRunCore, threaded
+	 *  SchedulerContext → baseInput → TaskRunnerInput). Optional: undefined
+	 *  keeps the previous uncached per-dep readIfSmallWithTee behavior
+	 *  byte-for-byte. NEVER pass a per-call cache instance. */
+	cache?: ResultArtifactReadCache,
 ): DependencyOutputContext {
 	const byStep = new Map(tasks.map((item) => [item.stepId, item]).filter((entry): entry is [string, TeamTaskState] => Boolean(entry[0])));
 	const byId = new Map(tasks.map((item) => [item.id, item]));
@@ -424,11 +440,19 @@ export function collectDependencyOutputContext(
 		.filter((item): item is TeamTaskState => Boolean(item))
 		.map((item) => {
 			const fullOutputPath = item.resultArtifact ? teePathForArtifact(manifest.artifactsRoot, task.id, item.id) : undefined;
+			// R10-1 residual: route the dep result read through the same per-run
+			// cache the closeout aggregation populated (readTaskResultArtifactWithTee).
+			// Without a cache this issues the identical readIfSmallWithTee call as
+			// before (byte-identical output); with one, a non-tee-band hit returns
+			// the memoized body while tee-band truncations still do the real read
+			// (tee file + fullOutputPath preserved per consumer).
 			const teeResult = item.resultArtifact
-				? readIfSmallWithTee(item.resultArtifact.path, {
-						baseDir: manifest.artifactsRoot,
-						...(fullOutputPath ? { tee: { fullOutputPath } } : {}),
-					})
+				? readTaskResultArtifactWithTee(
+						item.resultArtifact,
+						manifest.artifactsRoot,
+						fullOutputPath ? { fullOutputPath } : undefined,
+						cache,
+					)
 				: undefined;
 			const resultText = teeResult?.content;
 			const inlineBytes = resultText?.length ?? 0;
@@ -570,12 +594,209 @@ export function writeTaskInputsArtifact(
 	});
 }
 
-export function aggregateTaskOutputs(tasks: TeamTaskState[], manifest?: TeamRunManifest): string {
+/**
+ * R10-1: outcome of one aggregated result-artifact read (the pair of disk
+ * ops {@link aggregateTaskOutputs} performs per task: readIfSmall +
+ * containedExists). Cached as a unit so a cache hit replaces BOTH ops.
+ */
+export interface ResultArtifactReadOutcome {
+	/** Truncated body from readIfSmall; undefined when the read failed/missing. */
+	body: string | undefined;
+	/** containedExists() result for the same artifact path. */
+	exists: boolean;
+	/** R10-1 (dep-context tee-safety): character length of the raw file content
+	 *  at miss time. Present whenever the read succeeded; used by the
+	 *  dependency-context seam to decide whether a cache hit is byte-identical
+	 *  (no tee would have been written) or must fall through to a real
+	 *  readIfSmallWithTee. Undefined when the read failed. */
+	originalLength?: number;
+}
+
+/**
+ * R10-1: per-run memoization for result-artifact reads inside
+ * {@link aggregateTaskOutputs} (batch summary + group-join both aggregate the
+ * SAME settled batch every closeout — the second aggregation re-reads each
+ * `results/<taskId>.txt` from disk for no benefit).
+ *
+ * Cache key = artifact path + descriptor identity (`sizeBytes|contentHash`).
+ * writeArtifact computes both on every write (STATE-9: in-memory,
+ * post-redaction), so a retry that rewrites `results/<taskId>.txt` produces a
+ * NEW descriptor → new key → automatic miss. Descriptors missing BOTH fields
+ * bypass the cache entirely (cannot distinguish a rewrite from unchanged
+ * content). "Missing" outcomes are cached too (result artifacts use the
+ * default `retention: "run"` and are not pruned mid-run, so a miss is stable
+ * within a run). Path is used as-is (producer/taskId-keyed, stable absolute
+ * path from the manifest — no per-lookup realpath needed).
+ *
+ * Lifetime: one run (closure-level in executeTeamRunCore) — no cross-run
+ * leakage, no invalidation beyond the descriptor-identity key.
+ *
+ * Env bypass: `PI_CREW_DISABLE_RESULT_READ_CACHE=1` (read ONCE at creation)
+ * returns a cache whose lookups always miss — control mode for benches/tests
+ * that need the uncached behavior while still routing through the counting
+ * wrapper below.
+ */
+export interface ResultArtifactReadCache {
+	/** Cached outcome for the artifact identity, or undefined on miss/bypass. */
+	lookup(descriptor: ArtifactDescriptor): ResultArtifactReadOutcome | undefined;
+	/** Store an outcome. No-op when the descriptor lacks identity fields. */
+	store(descriptor: ArtifactDescriptor, outcome: ResultArtifactReadOutcome): void;
+}
+
+/**
+ * R10-1 test/bench counters for the result-artifact read path. Track disk ops
+ * ACTUALLY ISSUED through {@link readTaskResultArtifact} (incremented in the
+ * miss branch right before the real readIfSmall/containedExists calls) plus
+ * cache hits/misses. The disabled-control mode still routes through the
+ * counting wrapper (map simply not consulted) so cached-vs-uncached
+ * comparisons are honest.
+ */
+export interface ResultArtifactReadStats {
+	readFile: number;
+	exists: number;
+	hits: number;
+	misses: number;
+	reset(): void;
+}
+
+export const __test__resultReadStats: ResultArtifactReadStats = {
+	readFile: 0,
+	exists: 0,
+	hits: 0,
+	misses: 0,
+	reset() {
+		this.readFile = 0;
+		this.exists = 0;
+		this.hits = 0;
+		this.misses = 0;
+	},
+};
+
+function resultArtifactCacheKey(descriptor: ArtifactDescriptor): string | undefined {
+	if (descriptor.sizeBytes === undefined && descriptor.contentHash === undefined) return undefined;
+	return `${descriptor.path}|${descriptor.sizeBytes ?? ""}|${descriptor.contentHash ?? ""}`;
+}
+
+export function createResultArtifactReadCache(): ResultArtifactReadCache {
+	// Read once at creation — the bypass decision is fixed for the cache's
+	// (per-run) lifetime, matching PI_CREW_USE_BUNDLE-style one-shot env reads.
+	if (getCrewEnv("PI_CREW_DISABLE_RESULT_READ_CACHE") === "1") {
+		return {
+			lookup: () => undefined,
+			store: () => undefined,
+		};
+	}
+	const entries = new Map<string, ResultArtifactReadOutcome>();
+	return {
+		lookup(descriptor) {
+			const key = resultArtifactCacheKey(descriptor);
+			if (key === undefined) return undefined;
+			const hit = entries.get(key);
+			if (hit === undefined) {
+				__test__resultReadStats.misses += 1;
+				return undefined;
+			}
+			__test__resultReadStats.hits += 1;
+			return hit;
+		},
+		store(descriptor, outcome) {
+			const key = resultArtifactCacheKey(descriptor);
+			if (key !== undefined) entries.set(key, outcome);
+		},
+	};
+}
+
+/**
+ * Single read seam for {@link aggregateTaskOutputs}. Without a cache this is
+ * byte-for-byte the old behavior: readIfSmall + containedExists issued in the
+ * same order. With a cache, a hit returns the memoized pair (zero disk ops);
+ * a miss issues the same disk ops as the uncached path, counts them, and
+ * memoizes the outcome.
+ */
+function readTaskResultArtifact(
+	descriptor: ArtifactDescriptor,
+	baseDir: string | undefined,
+	cache: ResultArtifactReadCache | undefined,
+): ResultArtifactReadOutcome {
+	const cached = cache?.lookup(descriptor);
+	if (cached !== undefined) return cached;
+	__test__resultReadStats.readFile += 1;
+	__test__resultReadStats.exists += 1;
+	// readIfSmall is a thin wrapper over readIfSmallWithTee(...).content — the
+	// direct call is byte-identical and also captures originalLength (R10-1
+	// tee-safety metadata consumed by readTaskResultArtifactWithTee).
+	const raw = readIfSmallWithTee(descriptor.path, { baseDir });
+	const outcome: ResultArtifactReadOutcome = {
+		body: raw?.content,
+		exists: containedExists(descriptor.path, baseDir),
+		...(raw?.originalLength !== undefined ? { originalLength: raw.originalLength } : {}),
+	};
+	cache?.store(descriptor, outcome);
+	return outcome;
+}
+
+/**
+ * R10-1 residual: cached read seam for the dependency-context path
+ * ({@link collectDependencyOutputContext}). Mirrors {@link readTaskResultArtifact}
+ * while preserving the tee-recovery semantics of the direct
+ * `readIfSmallWithTee(path, { tee })` call it replaces:
+ *
+ * - A cache hit is reusable ONLY when the memoized read proves the uncached
+ *   call would NOT have teed: `originalLength` is known AND
+ *   `originalLength <= TEE_THRESHOLD_MULTIPLIER × MAX_RESULT_INLINE_BYTES`.
+ *   In that band readIfSmallWithTee().content is byte-identical to the
+ *   memoized body (same file, same truncation pipeline) and fullOutputPath is
+ *   unset, so returning the memoized body cannot change the rendered prompt.
+ * - A memoized read that FAILED (body undefined) is also returned as-is: the
+ *   direct readIfSmallWithTee would have thrown and returned undefined for
+ *   the same descriptor identity.
+ * - Otherwise (miss, bypass, or tee-band truncation) the real
+ *   readIfSmallWithTee runs — WITH tee, so the per-consumer
+ *   `tee/<taskId>-<depId>.full.txt` write and `fullOutputPath` survive — and
+ *   the disk ops are counted in `__test__resultReadStats` exactly like
+ *   readTaskResultArtifact's miss branch (honest cached-vs-bypass benches).
+ *   When a cache is provided the miss ALSO populates it with the SAME
+ *   outcome readTaskResultArtifact would have stored (body = teeResult.content
+ *   — byte-identical to readIfSmall's output since tee never alters content —
+ *   exists via containedExists, originalLength), so the next dep collect /
+ *   closeout aggregation hits. Truncation checks in later consumers use
+ *   originalLength, never heuristics on the truncated body.
+ */
+function readTaskResultArtifactWithTee(
+	descriptor: ArtifactDescriptor,
+	baseDir: string | undefined,
+	tee: TeeRecoveryOptions | undefined,
+	cache: ResultArtifactReadCache | undefined,
+): ReadIfSmallTeeResult | undefined {
+	const cached = cache?.lookup(descriptor);
+	if (cached !== undefined) {
+		if (cached.body === undefined) return undefined;
+		if (cached.originalLength !== undefined && cached.originalLength <= MAX_RESULT_INLINE_BYTES * TEE_THRESHOLD_MULTIPLIER) {
+			return { content: cached.body };
+		}
+	}
+	__test__resultReadStats.readFile += 1;
+	const result = readIfSmallWithTee(descriptor.path, { baseDir, ...(tee ? { tee } : {}) });
+	if (cache) {
+		// Populate with the outcome the closeout seam would have stored. The op
+		// order (read → existsSync) matches readTaskResultArtifact's miss branch.
+		__test__resultReadStats.exists += 1;
+		cache.store(descriptor, {
+			body: result?.content,
+			exists: containedExists(descriptor.path, baseDir),
+			...(result?.originalLength !== undefined ? { originalLength: result.originalLength } : {}),
+		});
+	}
+	return result;
+}
+
+export function aggregateTaskOutputs(tasks: TeamTaskState[], manifest?: TeamRunManifest, cache?: ResultArtifactReadCache): string {
 	return tasks
 		.map((task, index) => {
-			const body = task.resultArtifact ? readIfSmall(task.resultArtifact.path, manifest?.artifactsRoot) : undefined;
+			const read = task.resultArtifact ? readTaskResultArtifact(task.resultArtifact, manifest?.artifactsRoot, cache) : undefined;
+			const body = read?.body;
 			const hasBody = Boolean(body?.trim());
-			const expectedMissing = task.resultArtifact && !containedExists(task.resultArtifact.path, manifest?.artifactsRoot);
+			const expectedMissing = read ? !read.exists : undefined;
 			const status =
 				task.status === "skipped"
 					? "SKIPPED"

package/src/runtime/task-packet.ts

@@ -1,5 +1,6 @@
 import * as path from "node:path";
-import type { TaskPacket, TaskScope, TeamRunManifest, VerificationContract } from "../state/types.ts";
+import { freezeSpecSnapshot, loadSpecRecord } from "../state/stores/spec-store.ts";
+import type { SpecRecord, TaskPacket, TaskScope, TeamRunManifest, VerificationContract } from "../state/types.ts";
 import type { WorkflowStep } from "../workflows/workflow-config.ts";
 import { generateTaskHashId } from "./task-id.ts";
 
@@ -70,6 +71,10 @@ export function sanitizeTaskText(task: string): string {
 }
 
 export interface BuildTaskPacketInput {
+	/** T4/R6 (ADR-6 §2): workspace spec ids — loaded + FROZEN into the packet. */
+	specRefs?: string[];
+	/** T4/R6 (ADR-6 §7): strict mode — coverage AND machine-check (§4). */
+	specStrict?: boolean;
 	manifest: TeamRunManifest;
 	step: WorkflowStep;
 	taskId: string;
@@ -98,6 +103,20 @@ export function defaultVerificationContract(step: WorkflowStep): VerificationCon
 }
 
 export function buildTaskPacket(input: BuildTaskPacketInput): TaskPacket {
+	// T4/R6 (ADR-6 §1/§2): the ONLY packet-creation path is also the freeze
+	// point — specRefs load from the workspace store and freeze into immutable
+	// snapshots embedded in the packet (later spec edits never rewrite them).
+	// Round-1 review (fail-closed freeze): declared-but-unresolvable ids are
+	// kept on the packet as unresolvedSpecRefs instead of being dropped — the
+	// gate surfaces them (badge non-strict / failure strict), never a silent
+	// no-op. Snapshots freeze trust via the store at THIS moment.
+	const declaredSpecRefs = input.specRefs ?? [];
+	const resolvedRecords = declaredSpecRefs
+		.map((id) => loadSpecRecord(input.manifest.cwd, id))
+		.filter((r): r is SpecRecord => r !== undefined);
+	const specSnapshots = resolvedRecords.map((r) => freezeSpecSnapshot(r, input.manifest.cwd));
+	const unresolvedSpecRefs = declaredSpecRefs.filter((id) => !specSnapshots.some((s) => s.specId === id));
+
 	const scope = inferTaskScope(input.step);
 	const reads = input.step.reads === false ? [] : (input.step.reads ?? []);
 	const scopePath = reads.length === 1 ? reads[0] : reads.length > 1 ? reads.join(", ") : undefined;
@@ -112,6 +131,9 @@ export function buildTaskPacket(input: BuildTaskPacketInput): TaskPacket {
 
 	return {
 		objective: sanitizedTask.replaceAll("{goal}", sanitizedGoal),
+		...(declaredSpecRefs.length > 0 ? { specRefs: declaredSpecRefs, specSnapshots } : {}),
+		...(unresolvedSpecRefs.length > 0 ? { unresolvedSpecRefs } : {}),
+		...(input.specStrict === true ? { specStrict: true } : {}),
 		scope,
 		scopePath,
 		repo: path.basename(input.manifest.cwd) || input.manifest.cwd,

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

@@ -28,17 +28,21 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { loadConfig } from "../../config/config.ts";
+import { getCrewEnv } from "../../config/env-vars.ts";
 import { errors } from "../../errors.ts";
 import { appendEventAsync, appendEventBuffered } from "../../state/event-log/event-log.ts";
 import { writeArtifact } from "../../state/stores/artifact-store.ts";
+import { upsertOwnershipEntry } from "../../state/stores/ownership-map.ts";
 import type { ArtifactDescriptor, OperationTerminalEvidence, TeamRunManifest } from "../../state/types.ts";
+import { type FatalFsCause, failureCauseForAttempt } from "../../utils/fs-errno.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
 import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
 import type { ChildPiLifecycleEvent, ChildPiRunResult } from "../child-pi/child-pi.ts";
 import {
-	appendCrewAgentEvent,
-	appendCrewAgentOutput,
+	appendCrewAgentEventBuffered,
+	appendCrewAgentOutputBuffered,
 	emptyCrewAgentProgress,
+	flushCrewAgentRecordBuffer,
 	recordFromTask,
 	upsertCrewAgent,
 } from "../crew-agent-records.ts";
@@ -380,6 +384,9 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 	}
 	const logs: string[] = [];
 	let finalStderr = "";
+	// bug-026 sub-issue B: fatal-fs cause (enospc/edquot/emfile/enfile)
+	// derived per attempt from the attempt error / stderr tail.
+	let failureCause: FatalFsCause | undefined;
 	// One-shot: the re-resolve is a safety net for a chain that was computed
 	// before the registry was complete, not a retry loop of its own.
 	let reResolveUsed = false;
@@ -445,6 +452,12 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 			lastRunProgressPersistedAt = now;
 		}
 	};
+	// F7 (B1 battery 2026-08-18): one dispatch timestamp for the WHOLE attempt
+	// loop. A steer racing anywhere between task-dispatch and any attempt's
+	// onSpawn (including across the model-fallback respawn gap — observed live:
+	// steer at 15:59:11 wiped by attempt-1's truncate at 15:59:59) must survive
+	// the per-incarnation truncate; residue older than the dispatch is wiped.
+	const taskDispatchStartedAtMs = Date.now();
 	for (let i = 0; i < attemptModels.length; i++) {
 		// M1 fix: set transcript path per attempt to avoid mixing across fallback attempts.
 		transcriptPath = `${manifest.artifactsRoot}/transcripts/${task.id}.attempt-${i}.jsonl`;
@@ -549,10 +562,65 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 				steeringFile: resolveRealContainedPath(`${manifest.artifactsRoot}/steering`, `${task.id}.jsonl`),
 				onSpawn: (pid) => {
 					try {
+						// WP-1/R1 (H6): dispatch-time ownership writer — record the
+						// task ⇄ pid ⇄ artifactsDir leg of the ownership map as soon as
+						// a real worker spawns. The one-shot Agent-tool path fills the
+						// subagentId leg on the same taskId; the store merges per field
+						// under the run lock. Best-effort: never throws into the spawn
+						// path. onSpawn fires per spawn attempt (model-fallback loop), so
+						// the pid is overwritten with the latest attempt's live pid —
+						// correct, that is the worker steer targets.
+						try {
+							upsertOwnershipEntry(manifest, {
+								taskId: task.id,
+								runId: manifest.runId,
+								pid,
+								artifactsDir: manifest.artifactsRoot,
+								updatedAt: new Date().toISOString(),
+							});
+						} catch (err) {
+							logInternalError("task-runner.ownership-write", err, `pid=${pid}, taskId=${task.id}`);
+						}
 						({ task, tasks } = checkpointTask(manifest, tasks, task, "child-spawned", pid));
+						// Security review (T1/WP-1 round 1, security-1 replay fix): scope the
+						// steering file to ONE worker incarnation on EVERY spawn. Steering
+						// lines are id-less; each new worker process reads the file from
+						// byte 0 (prompt-runtime poll `lastOffset = 0`), so un-truncated
+						// files re-deliver every accumulated line — including stale steers
+						// written after the run went terminal — into the next spawn
+						// attempt's first-turn context. Best-effort; never throws.
+						// ACCEPTED TRADE-OFF (security review round 2): a steer appended
+						// directly by steer_subagent to a worker that dies BEFORE its 500ms
+						// poll reads it is lost when the respawn truncates here. The reliable
+						// cross-attempt channel is task.pendingSteers (survives in the task
+						// record and is re-appended after truncation); the direct file append
+						// is best-effort live-delivery only.
+						{
+							const steeringDir = `${manifest.artifactsRoot}/steering`;
+							try {
+								const safeSteeringPath = resolveRealContainedPath(steeringDir, `${task.id}.jsonl`);
+								// F7 fix: skip the truncate when the file's last write happened at or
+								// after THIS task's dispatch began — that is a live steer racing the
+								// spawn (observed live: "Steer delivered" + 0-byte file). Residue
+								// predating the dispatch (stale terminal-era steers) is still wiped.
+								// stat→truncate gap is microseconds; a steer landing inside it is
+								// lost — best-effort, same trade-off as before.
+								let racedSteerArrived = false;
+								try {
+									racedSteerArrived = fs.statSync(safeSteeringPath).mtimeMs >= taskDispatchStartedAtMs - 1;
+								} catch {
+									/* no file yet — nothing to truncate */
+								}
+								if (!racedSteerArrived) fs.writeFileSync(safeSteeringPath, "");
+							} catch (truncateErr) {
+								logInternalError("task-runner.steering-truncate", truncateErr, `taskId=${task.id}`);
+							}
+						}
 						if (task.pendingSteers?.length) {
 							const steeringDir = `${manifest.artifactsRoot}/steering`;
-							// Fire-and-forget async write for steering events
+							// Fire-and-forget async write for steering events (the file was
+							// truncated just above; this incarnation receives only its own
+							// pending steers).
 							void appendSteeringAsync(steeringDir, task.id, task.pendingSteers);
 							// RT-8: spread before clearing pendingSteers instead of mutating
 							// in place — preserves the immutable-snapshot invariant (the same
@@ -574,7 +642,10 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 					}).catch((error) => logInternalError("task-runner.lifecycle-event", error, `taskId=${task.id}, type=${event.type}`));
 				},
 				onStdoutLine: (line) => {
-					appendCrewAgentOutput(manifest, task.id, line);
+					// R10-5 (Wave 2B item 4): buffered — one appendFileSync per flush
+					// window instead of one per stdout line. Flushes at task boundary
+					// (finally below), process exit, 32-event cap, or 250ms window.
+					appendCrewAgentOutputBuffered(manifest, task.id, line);
 					persistHeartbeat();
 				},
 				onJsonEvent: (event) => {
@@ -585,7 +656,11 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 						// the full payload through); was dead on the old displayLine path.
 						const contact = supervisorContactFromEvent(event);
 						if (contact) recordSupervisorContact(manifest, { runId: manifest.runId, ...contact });
-						appendCrewAgentEvent(manifest, task.id, event);
+						// R10-5 (Wave 2B item 4): buffered agent-record sink — collapses the
+						// per-event stat+append fanout into one appendFileSync per flush
+						// window. Seqs are reserved at buffer time (no collisions); the
+						// run-level events.jsonl, steering, and result.md stay unbuffered.
+						appendCrewAgentEventBuffered(manifest, task.id, event);
 						if (collectedJsonEvents && event && typeof event === "object" && !Array.isArray(event))
 							collectedJsonEvents.push(event as Record<string, unknown>);
 						if (collectedJsonEvents && collectedJsonEvents.length > 1000) {
@@ -613,7 +688,7 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 						persistHeartbeat();
 						// Bug #3 fix: Write worker JSON events to background.log for debugging when running in background mode.
 						// This supplements the event log so developers can see what the child Pi worker produced.
-						if (process.env.PI_CREW_BACKGROUND_MODE === "1" && event) {
+						if (getCrewEnv("PI_CREW_BACKGROUND_MODE") === "1" && event) {
 							const bgLogPath = `${manifest.stateRoot}/background.log`;
 							const eventLine = typeof event === "object" && !Array.isArray(event) ? JSON.stringify(event) : String(event);
 							// Fire-and-forget async write for background log
@@ -650,6 +725,12 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 				},
 			});
 		} finally {
+			// R10-5 (Wave 2B item 4): task-boundary flush — land every buffered
+			// agent-record line from this attempt's callbacks before terminal
+			// state is derived/read. Runs on completion, failure, AND throw, so
+			// the persisted events/output after a task always match what the
+			// unbuffered implementation would have written.
+			flushCrewAgentRecordBuffer(manifest, task.id);
 			if (timeoutHandle) clearTimeout(timeoutHandle);
 			// W2 fix — release the listener so it doesn't leak. {once:true}
 			// only auto-removes when the listener FIRES; if the timeout
@@ -712,6 +793,13 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 		rawFinalText = childResult.rawFinalText;
 		intermediateFindings = childResult.intermediateFindings;
 		error = attemptErrorFor(childResult, parsedOutput, task.id);
+		// bug-026 sub-issue B: classify fatal fs errnos (ENOSPC/EDQUOT/EMFILE/
+		// ENFILE). During the 2026-08-15 disk-full window the errno only surfaced
+		// inside E007 stderr-tail strings, never as a raw errno object in the
+		// parent — so match the message text too. Recomputed every attempt;
+		// stamped on the task record immediately so a crash before loop exit
+		// still persists the cause. Only meaningful on failure.
+		failureCause = error ? failureCauseForAttempt(error, finalStderr) : undefined;
 		persistHeartbeat(true);
 		persistChildProgress({ type: "attempt_finished" }, true);
 		const attempt: ModelAttemptSummary = {
@@ -721,7 +809,11 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 			error,
 		};
 		modelAttempts.push(attempt);
-		task = { ...task, modelAttempts: [...modelAttempts] };
+		task = {
+			...task,
+			modelAttempts: [...modelAttempts],
+			...(failureCause ? { failureCause } : {}),
+		};
 		tasks = updateTask(tasks, task);
 		logs.push(
 			`MODEL ATTEMPT ${i + 1}: ${attempt.model}`,
@@ -791,6 +883,11 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 			error,
 		).message;
 	}
+	// bug-026 sub-issue B: reclassify after the E008 modelExhausted rewrite —
+	// its message embeds the last attempt's error (incl. stderr tails), so the
+	// errno survives the rewrite. Cleared on success (a task that recovered on
+	// retry is not an fs failure).
+	failureCause = error ? failureCauseForAttempt(error, finalStderr) : undefined;
 	// NEW-8 fix: register all attempt transcripts as artifacts, not just the used one.
 	// Earlier failed attempts' transcripts exist on disk but were invisible to the artifact system.
 	const successfulAttemptIndex = modelAttempts.findIndex((attempt) => attempt.success);
@@ -850,6 +947,7 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 	const fallbackReason = usedAttempt > 0 ? modelAttempts[usedAttempt - 1]?.error : undefined;
 	task = {
 		...task,
+		...(failureCause ? { failureCause } : {}),
 		modelRouting: {
 			requested: modelRoutingPlan.requested,
 			resolved: resolvedModel,
@@ -915,6 +1013,7 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 		modelAttempts,
 		parsedOutput,
 		finalStdout,
+		rawFinalText,
 		transcriptPath,
 		terminalEvidence,
 		startupEvidence,