pi-crew 0.10.2 → 0.10.4

package/src/runtime/manifest-cache.ts

@@ -29,6 +29,16 @@ interface CachedManifest {
 	mtimeMs: number;
 	size: number;
 	loadedAtMs: number;
+	/**
+	 * PERF (task-23a): timestamp of the last real statSync of this manifest.
+	 * parseManifestIfChanged() skips the stat entirely while the entry is
+	 * younger than the stat TTL (default 250ms), so back-to-back list() /
+	 * listActive() scans do not re-stat every manifest on every 500ms list
+	 * TTL expiry. Bounded staleness: a manifest change is picked up at most
+	 * statTtlMs late on the scan path (watcher-driven refreshes bypass this
+	 * with forceStat).
+	 */
+	statCheckedAtMs: number;
 }
 
 interface CachedList {
@@ -41,9 +51,16 @@ export interface ManifestCacheOptions {
 	debounceMs?: number;
 	watch?: boolean;
 	maxEntries?: number;
+	/**
+	 * PERF (task-23a): how long a cached manifest skips re-statting on scan
+	 * (default 250ms). Exposed mainly so tests can pin the window
+	 * deterministically.
+	 */
+	statTtlMs?: number;
 }
 
 const DEFAULT_TTL_MS = 500;
+const DEFAULT_STAT_TTL_MS = 250;
 
 interface ParsedEntry {
 	runId: string;
@@ -101,13 +118,30 @@ function validateManifestForRoot(root: string, runId: string, manifest: TeamRunM
 	}
 }
 
-function parseManifestIfChanged(root: string, runId: string, filePath: string, previous?: CachedManifest): CachedManifest | undefined {
+function parseManifestIfChanged(
+	root: string,
+	runId: string,
+	filePath: string,
+	previous?: CachedManifest,
+	forceStat = false,
+	statTtlMs = DEFAULT_STAT_TTL_MS,
+): CachedManifest | undefined {
+	if (!forceStat && previous && Date.now() - previous.statCheckedAtMs < statTtlMs) {
+		// PERF (task-23a): stat'ed very recently and not forcibly invalidated —
+		// the stat (and any parse behind it) cannot have changed the verdict.
+		// This bounds per-scan stat cost to ~1/statTtlMs per manifest instead
+		// of one per list() TTL expiry.
+		return previous;
+	}
 	let stat: fs.Stats;
 	try {
 		stat = fs.statSync(filePath);
 	} catch {
 		return undefined;
 	}
+	if (previous) {
+		previous.statCheckedAtMs = Date.now();
+	}
 	if (previous && previous.mtimeMs === stat.mtimeMs && previous.size === stat.size) {
 		// P1-9: the manifest file is unchanged, so its recorded paths and their
 		// containment verdict are unchanged too — skip the ~10-syscall
@@ -123,6 +157,7 @@ function parseManifestIfChanged(root: string, runId: string, filePath: string, p
 		mtimeMs: stat.mtimeMs,
 		size: stat.size,
 		loadedAtMs: Date.now(),
+		statCheckedAtMs: Date.now(),
 	};
 }
 
@@ -135,25 +170,54 @@ function listRunRoots(cwd: string): string[] {
 	return [...roots];
 }
 
+// PERF (2026-08-24, task-23b): list()/listActive() re-readdir'd every run
+// root on each 500ms TTL expiry. A runs root's own mtimeMs only changes when
+// direct entries (run dirs) are added/removed/renamed — exactly and only when
+// the listing must refresh — so the fully-mapped ParsedEntry[] is cached
+// against it. Manifest rewrites happen one level down (inside a run dir) and
+// never touch the root's mtime; they are picked up by the per-run stat in
+// parseManifestIfChanged. Caching the MAPPED entries (not just the raw names)
+// also skips the manifestPathForRun resolution (realpath + O_NOFOLLOW
+// ancestor walk, ~10 syscalls per run) for unchanged listings: an unchanged
+// root now costs a single statSync instead of existsSync + readdir + N walks.
+const DIR_LIST_CACHE_MAX_ROOTS = 64;
+const dirListCache = new Map<string, { mtimeMs: number; entries: ParsedEntry[] }>();
+
 function collectRoots(root: string): ParsedEntry[] {
-	if (!fs.existsSync(root)) return [];
+	let mtimeMs: number;
+	try {
+		mtimeMs = fs.statSync(root).mtimeMs;
+	} catch {
+		return [];
+	}
+	const cached = dirListCache.get(root);
+	if (cached && cached.mtimeMs === mtimeMs) {
+		return cached.entries;
+	}
 	let entries: string[];
 	try {
 		entries = fs.readdirSync(root);
 	} catch {
 		return [];
 	}
-	return entries
+	const mapped = entries
 		.filter((entry) => entry.length > 0 && isSafePathId(entry))
 		.map((entry) => ({
 			runId: entry,
 			path: manifestPathForRun(root, entry),
 		}))
 		.filter((entry): entry is ParsedEntry => entry.path !== undefined);
+	// Bounded growth: the map is module-scoped and shared across cache
+	// instances (tests, multi-project sessions); roots are few, but stale
+	// tempdir roots from finished tests would otherwise linger forever.
+	if (dirListCache.size >= DIR_LIST_CACHE_MAX_ROOTS) dirListCache.clear();
+	dirListCache.set(root, { mtimeMs, entries: mapped });
+	return mapped;
 }
 
 export function createManifestCache(cwd: string, options: ManifestCacheOptions = {}): ManifestCache {
 	const ttlMs = options.debounceMs ?? DEFAULT_TTL_MS;
+	const statTtlMs = options.statTtlMs ?? DEFAULT_STAT_TTL_MS;
 	const maxEntries = options.maxEntries ?? DEFAULT_CACHE.manifestMaxEntries;
 	const roots = listRunRoots(cwd);
 	const manifestIndex = new Map<string, CachedManifest>();
@@ -198,7 +262,7 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 		const activeEntry = activeRunEntries().find((entry) => entry.runId === runId);
 		if (activeEntry) {
 			const activeRoot = path.dirname(activeEntry.stateRoot);
-			const parsed = parseManifestIfChanged(activeRoot, runId, activeEntry.manifestPath, cached);
+			const parsed = parseManifestIfChanged(activeRoot, runId, activeEntry.manifestPath, cached, false, statTtlMs);
 			if (parsed) {
 				manifestIndex.set(runId, parsed);
 				return parsed;
@@ -207,7 +271,7 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 		for (const root of rootsToCheck) {
 			const manifestPath = manifestPathForRun(root, runId);
 			if (!manifestPath) continue;
-			const parsed = parseManifestIfChanged(root, runId, manifestPath, cached);
+			const parsed = parseManifestIfChanged(root, runId, manifestPath, cached, false, statTtlMs);
 			if (parsed) {
 				if (!cached || parsed.mtimeMs !== cached.mtimeMs || parsed.size !== cached.size) {
 					manifestIndex.set(runId, parsed);
@@ -223,13 +287,21 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 	}
 
 	/**
-	 * NOTE (RT-F10): This function performs a full FS scan + JSON.parse of all
-	 * manifests on every TTL expiry (default 500ms). This is a known performance
-	 * tradeoff: fs.watch provides real-time invalidation (see constructor above)
-	 * so the TTL cache is only consulted when the watcher fires, but the list()
-	 * call itself still re-reads all entries to pick up changes. Incremental
-	 * updates via fs.watch-driven delta tracking are planned for a future
-	 * iteration to avoid the full scan on each expiry.
+	 * NOTE (RT-F10, updated 2026-08-24): the original "full FS scan +
+	 * JSON.parse on every TTL expiry" cost is now layered:
+	 *   1. collectRoots() reuses a cached dir listing keyed by the runs root's
+	 *      own mtimeMs — one statSync per root replaces existsSync + readdir +
+	 *      the per-run manifestPathForRun resolution when no run dir was
+	 *      added/removed/renamed.
+	 *   2. parseManifestIfChanged() skips the per-manifest stat for statTtlMs
+	 *      (default 250ms) after the last check, so scans re-stat each run at
+	 *      most ~4x/sec regardless of how often the list TTL lapses.
+	 *   3. JSON.parse only happens when mtime+size actually changed.
+	 * What remains per 500ms expiry: one stat per runs root, one stat per run
+	 * whose stat TTL lapsed, and the in-memory merge + sort. fs.watch events
+	 * that carry a filename refresh just that run (forceStat) and expire the
+	 * list caches immediately instead of triggering a wholesale refresh (see
+	 * handleWatchEvent below).
 	 */
 	function list(limit = DEFAULT_CACHE.manifestMaxEntries): TeamRunManifest[] {
 		const now = Date.now();
@@ -249,7 +321,7 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 			if (entry.runId.length === 0) continue;
 			let cached = manifestIndex.get(entry.runId);
 			const root = path.dirname(path.dirname(entry.path));
-			const parsed = parseManifestIfChanged(root, entry.runId, entry.path, cached);
+			const parsed = parseManifestIfChanged(root, entry.runId, entry.path, cached, false, statTtlMs);
 			if (parsed) {
 				cached = parsed;
 				manifestIndex.set(entry.runId, cached);
@@ -258,7 +330,11 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 		}
 
 		const runs = [...unique.values()].filter((value): value is CachedManifest => value !== undefined).map((value) => value.manifest);
-		const sorted = runs.sort((a, b) => (b.createdAt ?? "").localeCompare(a.createdAt ?? ""));
+		// PERF (task-23d): ISO-8601 createdAt strings are fixed-width and sort
+		// correctly with plain comparison — no locale machinery per compare.
+		const sorted = runs.sort((a, b) =>
+			(b.createdAt ?? "") < (a.createdAt ?? "") ? -1 : (b.createdAt ?? "") > (a.createdAt ?? "") ? 1 : 0,
+		);
 		const limited = sorted.slice(0, Math.max(0, limit));
 		if (manifestIndex.size > maxEntries) {
 			const removeCount = manifestIndex.size - maxEntries;
@@ -324,7 +400,7 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 			if (entry.runId.length === 0) continue;
 			let cached = manifestIndex.get(entry.runId);
 			const root = path.dirname(path.dirname(entry.path));
-			const parsed = parseManifestIfChanged(root, entry.runId, entry.path, cached);
+			const parsed = parseManifestIfChanged(root, entry.runId, entry.path, cached, false, statTtlMs);
 			if (parsed) {
 				cached = parsed;
 				manifestIndex.set(entry.runId, cached);
@@ -339,12 +415,47 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 		return running.slice(0, cap);
 	}
 
+	// PERF (task-23c): the runs-root watcher reports the direct child that
+	// changed in `filename` (a run dir added/removed/renamed — the watcher is
+	// non-recursive, so manifest rewrites one level down never reach it).
+	// Refresh ONLY that run — forceStat bypasses the statTtlMs skip so a
+	// just-checked run still re-stats — and expire the list caches so the
+	// next list()/listActive() re-collects roots and re-sorts. Events without
+	// a usable filename (null, Buffer, non-run-id names like ".DS_Store")
+	// fall back to the wholesale debounced refresh.
+	function handleWatchEvent(root: string, filename: string | Buffer | null): void {
+		if (typeof filename !== "string" || !isSafePathId(filename)) {
+			scheduleListRefresh();
+			return;
+		}
+		const manifestPath = manifestPathForRun(root, filename);
+		if (manifestPath) {
+			const parsed = parseManifestIfChanged(
+				root,
+				filename,
+				manifestPath,
+				manifestIndex.get(filename),
+				/* forceStat */ true,
+				statTtlMs,
+			);
+			if (parsed) {
+				manifestIndex.set(filename, parsed);
+			} else {
+				// Run dir (or its manifest) is gone — drop the cached entry so
+				// the next scan does not serve a stale manifest.
+				manifestIndex.delete(filename);
+			}
+		}
+		listCache.clear();
+		invalidateListActive();
+	}
+
 	if (options.watch ?? true) {
 		for (const root of roots) {
 			const watcher = watchWithErrorHandler(
 				root,
-				() => {
-					scheduleListRefresh();
+				(_eventType, filename) => {
+					handleWatchEvent(root, filename);
 				},
 				() => {
 					scheduleListRefresh();

package/src/runtime/model/pi-args.ts

@@ -2,7 +2,6 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentConfig } from "../../agents/agent-config.ts";
-import { resolveToolPolicy } from "../../agents/agent-config.ts";
 import { atomicWriteFile } from "../../state/atomic-write.ts";
 import { packageRoot, userPiRoot } from "../../utils/paths.ts";
 
@@ -17,7 +16,9 @@ const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
 // dist/ entry points.
 const PROMPT_RUNTIME_EXTENSION_PATH = path.join(packageRoot(), "src", "prompt", "prompt-runtime.ts");
 const TASK_ARG_LIMIT = 8000;
-const DEFAULT_MAX_CREW_DEPTH = 2;
+// D8 spec v0.7 — nested mở (default 4 depth levels: child→child→child→child);
+// cap giữ để chống runaway recursion từ config lỗi hoặc intentional abuse.
+const DEFAULT_MAX_CREW_DEPTH = 4;
 
 // Track every temp dir created in this process so we can clean them up
 // even if the parent is killed before child-pi.ts cleanup runs.
@@ -278,71 +279,62 @@ export function buildPiWorkerArgs(input: BuildPiWorkerArgsInput): BuildPiWorkerA
 		args.push("--thinking", effectiveThinking);
 	}
 
-	// Apply role-based tool restrictions (from role-tools.ts)
-	// F1 unify (v0.8.0): the tool policy is resolved by the shared
-	// `resolveToolPolicy` helper (same code as the live-session path), so the
-	// two spawn paths agree. Before this, child-pi used role-config
-	// authoritative and ignored `agent.disallowedTools`; live-session used
-	// frontmatter authoritative and ignored role-config. Now:
-	//   - allowlist precedence is source-aware (builtin → role authoritative;
-	//     user/project → frontmatter authoritative)
-	//   - denylist is additive (role excludeTools + agent disallowedTools merged)
-	const policy = resolveToolPolicy(input.agent, input.role);
-	const explicitTools = policy.tools;
-	const excludeTools = policy.excludeTools;
-
-	// §0c C6: agent.disableTools (Pi `--no-tools`) fully disables all tools. Used by
-	// capability-locked agents (e.g. the goal-judge) that must have NO agency.
-	// MUST come before any --tools/--exclude-tools so it wins (Pi applies last-wins).
-	// An empty `tools:[]` is INSUFFICIENT because the length-check below skips it.
+	// D5 (spec v0.7 §6): default loadout = FULL session (như main session).
+	// --no-extensions/--no-skills/--tools CHỈ xuất hiện khi agent .md khai explicit.
+	// "message" MUST stay in CONTROL_TOOLS: it is registered by prompt-runtime
+	// behind the PI_CREW_MSG_ENABLED dormant-env gate (child-pi-spawn.ts sets it
+	// unconditionally), but pi's --tools allowlist filters the tool SURFACE — a
+	// control tool missing here is invisible to every frontmatter-pinned worker
+	// (battery 2026-09-10: message dead for all builtin roles since f843e14a).
+	const CONTROL_TOOLS = ["ask", "delegate", "message"] as const;
 	if (input.agent.disableTools === true) {
-		args.push("--no-tools");
+		args.push("--no-tools"); // capability-locked agents giữ hành vi (goal-judge)
 	} else {
-		if (explicitTools?.length) args.push("--tools", explicitTools.join(","));
-		if (excludeTools?.length) args.push("--exclude-tools", excludeTools.join(","));
-	}
-	// Always add --no-extensions before --extension to prevent user extensions from being auto-loaded.
-	// User extensions in ~/.pi/agent/extensions/ may fail due to missing dependencies.
-	args.push("--no-extensions");
-	if (input.agent.extensions !== undefined) {
-		// F1 (v0.7.9): apply `excludeExtensions` denylist (case-insensitive
-		// basename match) BEFORE the trusted PROMPT_RUNTIME_EXTENSION_PATH is
-		// prepended. The prompt-runtime is a pi-crew internal and is never
-		// excludable. Unknown names in the denylist are tolerated (logged
-		// would be nice but this path is sync and minimal — keeping parity
-		// with the rest of the agent loader's best-effort semantics).
-		const excluded = new Set((input.agent.excludeExtensions ?? []).map((name) => path.basename(name).toLowerCase()));
-		let allowed = input.agent.extensions.filter((ext) => !excluded.has(path.basename(ext).toLowerCase()));
-		// SEC-1: Defense-in-depth — deny untrusted project-sourced extensions
-		// unless explicitly trusted via PI_CREW_TRUST_PROJECT_AGENT_EXTENSIONS=1.
-		// Even if parseAgentFile missed the strip (e.g., agent was constructed
-		// at runtime), buildPiWorkerArgs must never emit --extension
-		// <attacker-path> for a project / project-pi agent. Both `project`
-		// (.crew/agents/) and `project-pi` (.pi/agents/) are repo-adjacent /
-		// untrusted sources. Only the trusted PROMPT_RUNTIME_EXTENSION_PATH is
-		// allowed through.
-		const extEnv = input.env ?? process.env;
-		if (
-			(input.agent.source === "project" || input.agent.source === "project-pi") &&
-			extEnv.PI_CREW_TRUST_PROJECT_AGENT_EXTENSIONS !== "1"
-		) {
-			allowed = allowed.filter((ext) => path.resolve(ext) === path.resolve(PROMPT_RUNTIME_EXTENSION_PATH));
+		// AgentConfig.tools is string[] (parseToolsField normalizes the
+		// frontmatter CSV), but inline/runtime-constructed agents may still
+		// carry the raw CSV string — normalize both.
+		const rawTools: unknown = input.agent.tools;
+		const declared =
+			typeof rawTools === "string"
+				? rawTools
+						.split(",")
+						.map((t) => t.trim())
+						.filter(Boolean)
+				: Array.isArray(rawTools)
+					? rawTools.map((t) => String(t).trim()).filter(Boolean)
+					: [];
+		if (declared.length > 0) {
+			const allow = new Set<string>([...declared, ...CONTROL_TOOLS]);
+			args.push("--tools", [...allow].join(","));
 		}
-		// ADR-5 §8 (governed nesting, T3/WP-5 step 8): every spawn this builder
-		// produces runs at depth > 0 (workers are depth 1, delegate grandchildren
-		// are 2+; currentCrewDepth(base)+1 is ALWAYS >= 1) — the extension list
-		// is an unconditional ALLOWLIST: only the trusted
-		// PROMPT_RUNTIME_EXTENSION_PATH passes, REGARDLESS OF SOURCE. User-sourced
-		// agent declarations can no longer inject extensions into sub-agents
-		// (SEC-1's project-only strip left user/builtin declarations unfiltered —
-		// the audit's untested hole). The denylist + SEC-1 strip above remain as
-		// defense-in-depth; the allowlist is authoritative.
-		allowed = [];
-		for (const extension of [PROMPT_RUNTIME_EXTENSION_PATH, ...allowed]) args.push("--extension", extension);
-	} else {
-		args.push("--extension", PROMPT_RUNTIME_EXTENSION_PATH);
+		// declared rỗng → KHÔNG truyền --tools (full default toolset — pattern
+		// buildSubagentToolAllowlist của pi-interactive-subagents index.ts:809-811).
+		// B2 (fix round 1): `disallowedTools:` frontmatter is a
+		// declaration-driven denylist (opt-in like `tools:`) — NOT the
+		// role-based policy D5 removed.
+		const disallowed = (input.agent.disallowedTools ?? []).map((t) => t.trim()).filter(Boolean);
+		if (disallowed.length > 0) args.push("--exclude-tools", [...new Set(disallowed)].join(","));
+	}
+	// prompt-runtime extension luôn nạp (hạ tầng phối hợp — không phải cắt xén).
+	args.push("--extension", PROMPT_RUNTIME_EXTENSION_PATH);
+	// SEC-1 (fix round 1): DECLARED extensions from untrusted sources
+	// (project / project-pi / dynamic) are stripped unless the operator opts
+	// in via PI_CREW_TRUST_PROJECT_AGENT_EXTENSIONS=1. Auto-discovery stays
+	// open (D5) — this only filters explicit `extensions:` declarations.
+	const extEnv = input.env ?? process.env;
+	const untrustedSource = input.agent.source === "project" || input.agent.source === "project-pi" || input.agent.source === "dynamic";
+	let declaredExtensions = input.agent.extensions ?? [];
+	if (untrustedSource && extEnv.PI_CREW_TRUST_PROJECT_AGENT_EXTENSIONS !== "1") {
+		declaredExtensions = [];
 	}
-	if (!input.agent.inheritSkills) args.push("--no-skills");
+	// F1 (v0.7.9): excludeExtensions denylist (case-insensitive basename
+	// match) applies to the declared list AFTER the SEC-1 strip. The
+	// prompt-runtime is a pi-crew internal and is never excludable.
+	const excluded = new Set((input.agent.excludeExtensions ?? []).map((name) => path.basename(name).toLowerCase()));
+	declaredExtensions = declaredExtensions.filter((ext) => !excluded.has(path.basename(ext).toLowerCase()));
+	for (const ext of declaredExtensions) args.push("--extension", ext);
+	// KHÔNG còn --no-extensions (extension discovery hoạt động như main session).
+	if (input.agent.inheritSkills === false) args.push("--no-skills");
 	for (const skillPath of input.skillPaths ?? []) args.push("--skill", skillPath);
 
 	let tempDir: string | undefined;
@@ -380,12 +372,14 @@ export function buildPiWorkerArgs(input: BuildPiWorkerArgsInput): BuildPiWorkerA
 			// main session (the lesson from an accidental `kill` of a live main session).
 			PI_CREW_KIND: "subagent",
 			PI_CREW_INHERIT_PROJECT_CONTEXT: input.agent.inheritProjectContext ? "1" : "0",
-			PI_CREW_INHERIT_SKILLS: input.agent.inheritSkills ? "1" : "0",
+			// B1 (fix round 1): match the argv `=== false` semantics — undefined
+			// inheritSkills means INHERIT (D5 default), not "0".
+			PI_CREW_INHERIT_SKILLS: input.agent.inheritSkills === false ? "0" : "1",
 			PI_CREW_DEPTH: String(parentDepth + 1),
 			PI_CREW_MAX_DEPTH: String(maxDepth),
 			PI_CREW_ROLE: input.agent.name,
 			PI_TEAMS_INHERIT_PROJECT_CONTEXT: input.agent.inheritProjectContext ? "1" : "0",
-			PI_TEAMS_INHERIT_SKILLS: input.agent.inheritSkills ? "1" : "0",
+			PI_TEAMS_INHERIT_SKILLS: input.agent.inheritSkills === false ? "0" : "1",
 			PI_TEAMS_DEPTH: String(parentDepth + 1),
 			PI_TEAMS_MAX_DEPTH: String(maxDepth),
 			PI_TEAMS_ROLE: input.agent.name,

package/src/runtime/output/sidechain-output.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { logInternalError } from "../../utils/internal-error.ts";
 import { redactSecrets } from "../../utils/redaction.ts";
 import { isSafePathId } from "../../utils/safe-paths.ts";
 
@@ -12,15 +13,69 @@ export interface SidechainEntry {
 	cwd: string;
 }
 
+// ── Batched JSONL writer (Task 26, 2026-08-24) ──────────────────────────
+// PERF (2026-08-24): the old writeSidechainEntry did one mkdirSync +
+// appendFileSync + full redaction clone PER STREAMING EVENT (message_update
+// fires per chunk). Batch per path on a 50ms unref'd timer like
+// child-pi-transcript; redaction + serialization still run per event at
+// queue time, and the flush does ONE mkdir + append per path per window.
+interface PendingJsonlBatch {
+	lines: string[];
+	timer: NodeJS.Timeout;
+}
+const pendingJsonlBatches = new Map<string, PendingJsonlBatch>();
+const JSONL_FLUSH_MS = 50;
+
+function queueJsonlLine(filePath: string, line: string): void {
+	const pending = pendingJsonlBatches.get(filePath);
+	if (pending) {
+		pending.lines.push(line);
+		return;
+	}
+	const timer = setTimeout(() => flushJsonlBatch(filePath), JSONL_FLUSH_MS);
+	timer.unref();
+	pendingJsonlBatches.set(filePath, { lines: [line], timer });
+}
+
+function flushJsonlBatch(filePath: string): void {
+	const pending = pendingJsonlBatches.get(filePath);
+	if (!pending) return;
+	pendingJsonlBatches.delete(filePath);
+	clearTimeout(pending.timer);
+	try {
+		fs.mkdirSync(path.dirname(filePath), { recursive: true });
+		fs.appendFileSync(filePath, pending.lines.join(""), "utf-8");
+	} catch (error) {
+		logInternalError("sidechain-output.flush", error as Error, `path=${filePath}`);
+	}
+}
+
 export function writeSidechainEntry(filePath: string, entry: Omit<SidechainEntry, "isSidechain" | "timestamp">): void {
-	fs.mkdirSync(path.dirname(filePath), { recursive: true });
-	fs.appendFileSync(
-		filePath,
-		`${JSON.stringify(redactSecrets({ isSidechain: true, timestamp: new Date().toISOString(), ...entry }))}\n`,
-		"utf-8",
-	);
+	queueJsonlLine(filePath, `${JSON.stringify(redactSecrets({ isSidechain: true, timestamp: new Date().toISOString(), ...entry }))}\n`);
 }
 
+/**
+ * Append one pre-serialized JSONL line through the shared batched writer.
+ * Task 26: the live-session transcript append routes through the same
+ * per-path 50ms batching as sidechain output. child-pi-transcript's batched
+ * writer was NOT reused — it takes a ChildPiRunInput and enforces
+ * artifactsRoot containment + a second redaction pass (redactJsonLine over
+ * the already-redacted line), so it is not generic over plain paths.
+ */
+export function appendBatchedJsonlLine(filePath: string, line: string): void {
+	queueJsonlLine(filePath, line);
+}
+
+/** @internal — flush on session teardown / process exit so files are complete. */
+export function flushPendingSidechainWrites(): void {
+	for (const filePath of [...pendingJsonlBatches.keys()]) flushJsonlBatch(filePath);
+}
+
+// The batch timers are unref'd, so a naturally-draining event loop can exit
+// with unflushed telemetry. Same exit-hook pattern as atomic-write.ts and
+// crew-agent-records.ts (sync-only work, safe inside "exit").
+process.on("exit", () => flushPendingSidechainWrites());
+
 export function sidechainOutputPath(stateRoot: string, taskId: string): string {
 	if (!isSafePathId(taskId)) throw new Error(`Invalid taskId: ${taskId}`);
 	return path.join(stateRoot, "agents", taskId, "sidechain.output.jsonl");

package/src/runtime/plan-replan.ts

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

package/src/runtime/process/proc-stat.ts

@@ -0,0 +1,46 @@
+/**
+ * proc-stat.ts — THE single `/proc/<pid>/stat` field parser.
+ *
+ * Three consumers previously hand-rolled the same paren-aware split (the
+ * surface spawn's parent starttime capture, the worker-side parent-guard, and
+ * the zombie scanner's ppid/starttime read). A divergence between them is not
+ * cosmetic: the spawn writes `PI_CREW_PARENT_START_TIME` from field 22, and
+ * the worker kills itself when that value stops matching — so both sides MUST
+ * index identically. comm (field 2) may contain spaces AND ')' characters,
+ * hence everything up to the LAST ")" is skipped, never a naive whitespace
+ * split.
+ *
+ * Layout after the comm field: rest[0] = state, rest[1] = ppid, …
+ * rest[STARTTIME_INDEX] = starttime (field 22, clock ticks since boot).
+ */
+
+/** Field 22 (starttime) minus the two consumed by the comm cut = index 19. */
+export const PROC_STAT_STARTTIME_INDEX = 19;
+/** Field 3 (state) → first entry after the comm cut. */
+export const PROC_STAT_STATE_INDEX = 0;
+/** Field 4 (ppid) → second entry after the comm cut. */
+export const PROC_STAT_PPID_INDEX = 1;
+
+/**
+ * Fields of a `/proc/<pid>/stat` line AFTER the comm column (paren-aware).
+ * Returns undefined when the buffer has no closing paren at all.
+ */
+export function fieldsAfterComm(stat: string): string[] | undefined {
+	const lastParen = stat.lastIndexOf(")");
+	if (lastParen === -1) return undefined;
+	return stat
+		.slice(lastParen + 1)
+		.trim()
+		.split(/\s+/);
+}
+
+/**
+ * Raw starttime ticks (field 22) as a string, for byte-exact comparison with
+ * the value the spawner recorded. undefined when absent/unparseable.
+ */
+export function procStartTimeTicks(stat: string): string | undefined {
+	const fields = fieldsAfterComm(stat);
+	if (!fields) return undefined;
+	const raw = fields[PROC_STAT_STARTTIME_INDEX];
+	return raw && Number.isFinite(Number(raw)) ? raw : undefined;
+}