pi-crew 0.9.7 → 0.9.9

package/src/runtime/process-lifecycle.ts

@@ -0,0 +1,481 @@
+/**
+ * Owned-process lifecycle abstraction (P0 item #3).
+ *
+ * Distilled and adapted from gajae-code's `runtime/process-lifecycle.ts`.
+ *
+ * Two complementary primitives:
+ *
+ *   F1(a) {@link spawnOwnedProcess} / {@link OwnedProcess} — wraps a
+ *         `child_process.spawn` child with explicit ownership: escalating
+ *         (SIGTERM → grace → SIGKILL) teardown, idempotent `dispose()`, bounded
+ *         `awaitExit()`, abort-signal wiring, and postmortem registration so
+ *         an owned child can never outlive its owner.
+ *
+ *   F1(b) {@link registerResourceOwner} — a generic postmortem registry for
+ *         NON-process resources (timers, sockets, Workers, VM contexts) with
+ *         `disposeAllOwners()` / `disposeOwner(name)`.
+ *
+ * ╔═══════════════════════════════════════════════════════════════════════════╗
+ * ║  IMPORTANT — INCREMENTAL, NOT FULL MIGRATION                              ║
+ * ║  pi-crew ALREADY has sophisticated kill logic in child-pi.ts              ║
+ * ║  (killProcessTree, escalating SIGTERM→grace→SIGKILL, hard-kill timer,    ║
+ * ║  post-exit stdio guard) and async-runner.ts does detached/setsid spawns.  ║
+ * ║  Those paths are NOT rewritten here. This module provides a clean         ║
+ * ║  ownership primitive for NEW code paths that need guaranteed teardown     ║
+ * ║  without re-implementing the escalation dance each time.                  ║
+ * ╚═══════════════════════════════════════════════════════════════════════════╝
+ *
+ * Cross-platform: on Windows there is no SIGTERM; teardown uses
+ * `taskkill /F /T /PID` escalation directly (force-kill the whole tree).
+ * See `.crew/knowledge.md` gotchas: BSD/Windows signal handling differs.
+ */
+import { spawn, type ChildProcess, type SpawnOptions } from "node:child_process";
+import { logInternalError } from "../utils/internal-error.ts";
+
+// ── tunables ──────────────────────────────────────────────────────────────────
+
+const DEFAULT_GRACEFUL_MS = 2_000;
+/** Hard cap on how long dispose() waits after SIGKILL before giving up, so a
+ *  wedged/unkillable child can never block shutdown forever. */
+const SIGKILL_REAP_CAP_MS = 2_000;
+/** After the root child exits on its own, how long to wait for the process
+ *  group to drain before deregistering. Clean servers drain immediately. */
+const ROOT_EXIT_DRAIN_MS = 250;
+
+const isPosix = process.platform !== "win32";
+
+const delay = (ms: number): Promise<void> =>
+	new Promise((resolve) => {
+		setTimeout(resolve, Math.max(0, ms));
+	});
+
+/** Poll `predicate` until true or `timeoutMs` elapses. Returns the final value. */
+async function pollUntil(predicate: () => boolean, timeoutMs: number, intervalMs = 20): Promise<boolean> {
+	if (predicate()) return true;
+	const deadline = Date.now() + Math.max(0, timeoutMs);
+	while (Date.now() < deadline) {
+		await delay(Math.min(intervalMs, Math.max(0, deadline - Date.now())));
+		if (predicate()) return true;
+	}
+	return predicate();
+}
+
+/** Whether a POSIX process group still has any member (zombies count as alive). */
+function groupAlive(pgid: number): boolean {
+	try {
+		process.kill(-pgid, 0);
+		return true;
+	} catch (err) {
+		// EPERM => the group exists but we cannot signal it; treat as alive.
+		return (err as NodeJS.ErrnoException).code === "EPERM";
+	}
+}
+
+// ── F1(a) OwnedProcess ────────────────────────────────────────────────────────
+
+/** Options for {@link spawnOwnedProcess}. */
+export interface SpawnOwnedOptions {
+	cwd?: string;
+	env?: Record<string, string | undefined>;
+	/** stdin mode passed through to the child. Defaults to `"ignore"`. */
+	stdin?: "pipe" | "ignore";
+	/** When aborted, the owned process tree is disposed (escalating kill). */
+	signal?: AbortSignal;
+	/** Grace period (ms) between SIGTERM and SIGKILL on dispose. Default 2000. */
+	gracefulMs?: number;
+	/**
+	 * Spawn the child as its own process-group leader so the whole descendant
+	 * tree can be signalled on dispose. Defaults to `true` on POSIX. Has no
+	 * effect on Windows, where teardown falls back to single-process kill.
+	 */
+	processGroup?: boolean;
+	/** Label used in diagnostics. */
+	name?: string;
+	/** Extra SpawnOptions merged in (e.g. windowsHide). */
+	extraOptions?: SpawnOptions;
+}
+
+/** Result of a bounded {@link OwnedProcess.awaitExit}. */
+export interface AwaitExitResult {
+	/** `true` when the process has exited; `false` when the timeout fired first. */
+	exited: boolean;
+	/** Exit code if known, else `null`. */
+	code: number | null;
+}
+
+/** Exit callback signature for {@link OwnedProcess.onExit}. */
+export type OwnedExitCallback = (code: number | null, signal: NodeJS.Signals | null) => void;
+
+/**
+ * A spawned child process owned by the runtime with guaranteed teardown.
+ *
+ * Implemented as a class so callers retain a strong handle and so `dispose()`
+ * can be idempotent (concurrent/repeated calls return the same in-flight
+ * promise). Never throws from `dispose()` / `awaitExit()`.
+ */
+export class OwnedProcess {
+	readonly child: ChildProcess;
+	readonly pid: number | undefined;
+	/** Process-group id (POSIX detached only); `undefined` on Windows / opt-out. */
+	readonly pgid: number | undefined;
+	private readonly gracefulMs: number;
+	private readonly name: string | undefined;
+	private disposed = false;
+	private disposePromise: Promise<void> | undefined;
+	private deregistered = false;
+	/** Terminal once teardown/reconciliation has confirmed the group is gone. */
+	private terminated = false;
+	private exitPromise: Promise<{ code: number | null; signal: NodeJS.Signals | null }>;
+	private exitCallbacks = new Set<OwnedExitCallback>();
+	private onAbort: (() => void) | undefined;
+	private readonly abortSignal: AbortSignal | undefined;
+
+	constructor(child: ChildProcess, opts: SpawnOwnedOptions, registerSelf: (owner: OwnedProcess) => () => void) {
+		this.child = child;
+		this.pid = child.pid;
+		this.gracefulMs = opts.gracefulMs ?? DEFAULT_GRACEFUL_MS;
+		this.name = opts.name;
+		this.abortSignal = opts.signal;
+
+		const useGroup = (opts.processGroup ?? true) && isPosix;
+		// On POSIX with `detached`, the child is its own process-group leader,
+		// so the group id equals its pid.
+		this.pgid = useGroup ? child.pid : undefined;
+
+		this.exitPromise = new Promise((resolve) => {
+			child.once("exit", (code, signal) => {
+				resolve({ code: code, signal: signal });
+				for (const cb of this.exitCallbacks) {
+					try {
+						cb(code, signal);
+					} catch (err) {
+						logInternalError("owned-process.onExit-callback", err, this.name ? `name=${this.name}` : undefined);
+					}
+				}
+			});
+		});
+
+		// Register for postmortem cleanup and wire abort.
+		const deregister = registerSelf(this);
+		this.deregisterFn = deregister;
+
+		// When the root exits on its own (not via dispose), reconcile ownership
+		// by the *group*: after a short drain window, deregister if the group is
+		// empty, otherwise reap the owned group (no child outlives its owner).
+		void this.exitPromise
+			.then(() => {
+				if (this.disposed) return; // dispose() owns deregistration
+				if (this.pgid === undefined) {
+					this.deregisterInternal();
+					return;
+				}
+				void (async () => {
+					const drained = await pollUntil(() => !groupAlive(this.pgid!), ROOT_EXIT_DRAIN_MS);
+					if (this.disposed) return;
+					if (drained) {
+						this.deregisterInternal();
+						return;
+					}
+					// Root exited but the owned group still has descendants: reap them.
+					await this.dispose();
+				})();
+			})
+			.catch(() => undefined);
+
+		if (this.abortSignal) {
+			if (this.abortSignal.aborted) {
+				void this.dispose();
+			} else {
+				this.onAbort = () => void this.dispose();
+				this.abortSignal.addEventListener("abort", this.onAbort, { once: true });
+			}
+		}
+	}
+
+	private deregisterFn: () => void = () => {};
+
+	/** `true` once `dispose()` has started. */
+	get isDisposed(): boolean {
+		return this.disposed;
+	}
+
+	/**
+	 * Register a callback invoked exactly once when the root child exits.
+	 * If the child has already exited, the callback is invoked synchronously
+	 * with the cached exit info. Returns an unsubscribe function.
+	 */
+	onExit(callback: OwnedExitCallback): () => void {
+		this.exitCallbacks.add(callback);
+		// If already exited, the exitPromise is resolved; fire immediately.
+		// We race to detect resolution without awaiting.
+		let settled = false;
+		this.exitPromise.then((info) => {
+			if (settled) return; // callback may have been removed
+			if (this.exitCallbacks.has(callback)) {
+				try {
+					callback(info.code, info.signal);
+				} catch (err) {
+					logInternalError("owned-process.onExit-immediate", err, this.name ? `name=${this.name}` : undefined);
+				}
+			}
+		});
+		return () => {
+			settled = true;
+			this.exitCallbacks.delete(callback);
+		};
+	}
+
+	/**
+	 * Wait for the root child to exit, optionally bounded by `timeoutMs`.
+	 * With no timeout it resolves only when the child exits. Never rejects.
+	 */
+	async awaitExit(opts?: { timeoutMs?: number }): Promise<AwaitExitResult> {
+		const exitResult = this.exitPromise.then((info) => ({ exited: true as const, code: info.code }));
+		if (opts?.timeoutMs === undefined) return exitResult;
+		let timer: ReturnType<typeof setTimeout> | undefined;
+		const timeout = new Promise<AwaitExitResult>((resolve) => {
+			timer = setTimeout(
+				() => resolve({ exited: false, code: this.child.exitCode }),
+				Math.max(0, opts.timeoutMs!),
+			);
+		});
+		try {
+			return await Promise.race([exitResult, timeout]);
+		} finally {
+			if (timer) clearTimeout(timer);
+		}
+	}
+
+	/** Signal the process tree with `signal` (group-aware on POSIX). */
+	private signalTree(signal: NodeJS.Signals): void {
+		const pid = this.child.pid;
+		if (pid === undefined) return;
+		if (this.pgid !== undefined) {
+			try {
+				process.kill(-this.pgid, signal);
+				return;
+			} catch {
+				/* group already gone */
+			}
+			return;
+		}
+		try {
+			this.child.kill(signal);
+		} catch {
+			/* already gone */
+		}
+	}
+
+	private deregisterInternal(): void {
+		if (this.deregistered) return;
+		this.deregistered = true;
+		this.terminated = true;
+		this.deregisterFn();
+		if (this.onAbort && this.abortSignal) {
+			this.abortSignal.removeEventListener("abort", this.onAbort);
+			this.onAbort = undefined;
+		}
+	}
+
+	/**
+	 * Idempotently terminate the owned process *group*: SIGTERM the group, wait
+	 * `gracefulMs`, then SIGKILL, polling liveness throughout. On Windows,
+	 * escalate directly to taskkill /F /T /PID. Removes the abort listener and
+	 * deregisters from the live-owner set only after teardown has completed.
+	 * Repeated/concurrent calls return the same in-flight promise. Never throws.
+	 */
+	dispose(): Promise<void> {
+		// Already terminal: never re-probe a recycled pgid.
+		if (this.terminated) {
+			this.disposed = true;
+			if (!this.disposePromise) this.disposePromise = Promise.resolve();
+			return this.disposePromise;
+		}
+		if (this.disposePromise) return this.disposePromise;
+		this.disposed = true;
+		if (this.onAbort && this.abortSignal) {
+			this.abortSignal.removeEventListener("abort", this.onAbort);
+			this.onAbort = undefined;
+		}
+		this.disposePromise = (async () => {
+			try {
+				if (!isPosix) {
+					await this.disposeWindows();
+					return;
+				}
+				if (this.pgid !== undefined) {
+					// Group ownership: reap until the whole group is gone, even if
+					// the root has already exited (it may have backgrounded children).
+					if (!groupAlive(this.pgid)) return;
+					this.signalTree("SIGTERM");
+					if (await pollUntil(() => !groupAlive(this.pgid!), this.gracefulMs)) return;
+					this.signalTree("SIGKILL");
+					if (!(await pollUntil(() => !groupAlive(this.pgid!), SIGKILL_REAP_CAP_MS))) {
+						console.warn(`[pi-crew] owned process group still alive after SIGKILL (name=${this.name ?? "?"}, pgid=${this.pgid})`);
+					}
+					return;
+				}
+				// Single-process fallback (processGroup:false).
+				if (this.child.exitCode !== null) return;
+				this.signalTree("SIGTERM");
+				if ((await this.awaitExit({ timeoutMs: this.gracefulMs })).exited) return;
+				this.signalTree("SIGKILL");
+				await this.awaitExit({ timeoutMs: SIGKILL_REAP_CAP_MS });
+			} catch (err) {
+				logInternalError("owned-process.dispose", err, this.name ? `name=${this.name}` : undefined);
+			} finally {
+				// Deregister only after teardown completes so a postmortem firing
+				// mid-grace still sees the owner.
+				this.deregisterInternal();
+			}
+		})();
+		return this.disposePromise;
+	}
+
+	/** Windows teardown: no SIGTERM; escalate to taskkill /F /T /PID. */
+	private async disposeWindows(): Promise<void> {
+		const pid = this.child.pid;
+		if (pid === undefined) return;
+		if (this.child.exitCode !== null) return;
+		// First try a graceful taskkill (no /F), then escalate to /F /T.
+		const tryTaskkill = (force: boolean): Promise<void> =>
+			new Promise((resolve) => {
+				const args = ["/T", "/PID", String(pid), ...(force ? ["/F"] : [])];
+				const tk = spawn("taskkill", args, { stdio: "ignore", windowsHide: true });
+				tk.on("error", () => resolve());
+				tk.on("exit", () => resolve());
+			});
+		await tryTaskkill(false);
+		if ((await this.awaitExit({ timeoutMs: this.gracefulMs })).exited) return;
+		await tryTaskkill(true);
+		await this.awaitExit({ timeoutMs: SIGKILL_REAP_CAP_MS });
+	}
+}
+
+// ── live-owner set + postmortem ───────────────────────────────────────────────
+
+const liveOwners = new Set<OwnedProcess>();
+let ownedPostmortemRegistered = false;
+
+function ensureOwnedPostmortem(): void {
+	if (ownedPostmortemRegistered) return;
+	ownedPostmortemRegistered = true;
+	// Register a process-exit handler that disposes every live owned process.
+	// We wire both beforeExit (event-loop empty) and exit (synchronous final).
+	const drain = async (): Promise<void> => {
+		await Promise.all([...liveOwners].map((owner) => owner.dispose().catch(() => undefined)));
+	};
+	process.once("beforeExit", () => {
+		void drain().catch(() => undefined);
+	});
+}
+
+/**
+ * Spawn a child process owned by the runtime. The returned {@link OwnedProcess}
+ * is registered for postmortem cleanup and tears down its whole process group
+ * on dispose/abort.
+ *
+ * NOTE: this is for NEW ownership-scoped spawns. Do NOT use it to replace
+ * child-pi.ts's runChildPi (which has its own battle-tested escalation logic)
+ * or async-runner.ts's intentionally-detached background spawns.
+ */
+export function spawnOwnedProcess(command: string, args: readonly string[] = [], opts: SpawnOwnedOptions = {}): OwnedProcess {
+	ensureOwnedPostmortem();
+	const useGroup = (opts.processGroup ?? true) && isPosix;
+	const spawnOpts: SpawnOptions = {
+		cwd: opts.cwd,
+		env: opts.env as NodeJS.ProcessEnv | undefined,
+		stdio: [opts.stdin ?? "ignore", "pipe", "pipe"],
+		detached: useGroup,
+		windowsHide: true,
+		...opts.extraOptions,
+	};
+	const child = spawn(command, args as string[], spawnOpts);
+	const owner = new OwnedProcess(child, opts, (self) => {
+		liveOwners.add(self);
+		return () => {
+			liveOwners.delete(self);
+		};
+	});
+	return owner;
+}
+
+/** Number of currently live owned processes. Exposed for leak assertions/tests. */
+export function liveOwnedProcessCount(): number {
+	return liveOwners.size;
+}
+
+/** Dispose every live owned process. For owner-scoped teardown and tests. */
+export async function disposeAllOwnedProcesses(): Promise<void> {
+	await Promise.all([...liveOwners].map((owner) => owner.dispose().catch(() => undefined)));
+}
+
+// ── F1(b) generic resource owners ─────────────────────────────────────────────
+
+type ResourceDisposer = () => void | Promise<void>;
+
+const resourceOwners = new Map<string, ResourceDisposer>();
+let resourcePostmortemRegistered = false;
+
+function ensureResourcePostmortem(): void {
+	if (resourcePostmortemRegistered) return;
+	resourcePostmortemRegistered = true;
+	process.once("beforeExit", () => {
+		void disposeAllOwners().catch(() => undefined);
+	});
+}
+
+/**
+ * Register a non-process resource for postmortem/fatal-exit cleanup.
+ *
+ * Idempotent by `name`: re-registering the same name replaces the prior
+ * disposer (last wins). Returns an unregister function that removes the owner
+ * only while it is still the active registration for that name.
+ */
+export function registerResourceOwner(name: string, disposer: ResourceDisposer): () => void {
+	resourceOwners.set(name, disposer);
+	ensureResourcePostmortem();
+	let unregistered = false;
+	return () => {
+		if (unregistered) return;
+		unregistered = true;
+		if (resourceOwners.get(name) === disposer) {
+			resourceOwners.delete(name);
+		}
+	};
+}
+
+/** Number of registered resource owners. Exposed for leak assertions/tests. */
+export function resourceOwnerCount(): number {
+	return resourceOwners.size;
+}
+
+/**
+ * Run and clear every registered resource disposer. Attempts all disposers even
+ * if some throw, then surfaces the failures as an `AggregateError` so callers
+ * can distinguish "all closed" from "a resource may still be alive".
+ */
+export async function disposeAllOwners(): Promise<void> {
+	const disposers = [...resourceOwners.values()];
+	resourceOwners.clear();
+	const errors: unknown[] = [];
+	for (const disposer of disposers) {
+		try {
+			await disposer();
+		} catch (err) {
+			errors.push(err);
+		}
+	}
+	if (errors.length > 0) {
+		throw new AggregateError(errors, `${errors.length} resource disposer(s) failed during teardown`);
+	}
+}
+
+/** Dispose a single named resource owner. Returns true if it was registered. */
+export async function disposeOwner(name: string): Promise<boolean> {
+	const disposer = resourceOwners.get(name);
+	if (!disposer) return false;
+	resourceOwners.delete(name);
+	await disposer();
+	return true;
+}

package/src/runtime/subagent-manager.ts

@@ -27,6 +27,9 @@ export interface SubagentSpawnOptions {
 	skill?: string | string[] | false;
 	maxTurns?: number;
 	ownerSessionGeneration?: number;
+	/** Optional batch grouping id (Rule 1). Agents sharing a batchId coalesce
+	 * completion notifications into one. undefined => individual (default). */
+	batchId?: string;
 }
 
 export interface SubagentRecord {
@@ -45,6 +48,8 @@ export interface SubagentRecord {
 	skill?: string | string[] | false;
 	background: boolean;
 	ownerSessionGeneration?: number;
+	/** Batch grouping id (Rule 1). undefined => individual notification. */
+	batchId?: string;
 	stuckNotified?: boolean;
 	blockedAt?: number;
 	promise?: Promise<void>;
@@ -255,6 +260,7 @@ export class SubagentManager {
 			skill: options.skill,
 			background: options.background,
 			ownerSessionGeneration: options.ownerSessionGeneration,
+			batchId: options.batchId,
 		};
 		this.records.set(record.id, record);
 		this.cwdByRecord.set(record.id, options.cwd);

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

@@ -4,6 +4,7 @@ import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../stat
 import { writeArtifact } from "../state/artifact-store.ts";
 import { resolveRealContainedPath } from "../utils/safe-paths.ts";
 import type { WorkflowStep } from "../workflows/workflow-config.ts";
+import { pruneToolOutputs, type ToolResultEntry, type FileEditEvent, DEFAULT_PRUNE_CONFIG } from "./tool-output-pruner.ts";
 
 export interface DependencyContextEntry {
 	taskId: string;
@@ -30,20 +31,36 @@ function containedExists(filePath: string, baseDir?: string): boolean {
 	}
 }
 
-function readIfSmall(filePath: string, maxBytes = 24_000, baseDir?: string): string | undefined {
+/**
+ * L4 output-handling: single consistent threshold for all artifact reads.
+ * Sized from real data (27 result artifacts: max 9226 bytes; 100% < 16KB).
+ * 32KB gives 2x headroom over the largest observed real output while still
+ * bounding memory. Larger than the old inconsistent per-call-site values
+ * (24K/40K/80K) which truncated the same artifact differently depending on
+ * which code path read it.
+ */
+const MAX_RESULT_INLINE_BYTES = 32_000;
+
+function readIfSmall(filePath: string, baseDir?: string): string | undefined {
+	const maxBytes = MAX_RESULT_INLINE_BYTES;
 	try {
 		const safePath = baseDir ? resolveRealContainedPath(baseDir, filePath) : filePath;
 		const stat = fs.statSync(safePath);
 		if (stat.size > maxBytes) {
-			// Use bounded read to avoid loading entire file into memory
-			const buf = Buffer.alloc(maxBytes);
+			// L4: head + tail instead of head-only. Keeps closing markdown
+			// structure (code fences, headings) instead of leaving them truncated.
+			const head = Math.floor(maxBytes * 0.75);
+			const tail = maxBytes - head;
+			const headBuf = Buffer.alloc(head);
+			const tailBuf = Buffer.alloc(tail);
 			const fd = fs.openSync(safePath, "r");
 			try {
-				fs.readSync(fd, buf, 0, maxBytes, 0);
+				fs.readSync(fd, headBuf, 0, head, 0);
+				fs.readSync(fd, tailBuf, 0, tail, stat.size - tail);
 			} finally {
 				fs.closeSync(fd);
 			}
-			return `${buf.toString("utf-8")}\n\n...(truncated ${stat.size - maxBytes} bytes)`;
+			return `${headBuf.toString("utf-8")}\n\n...[pi-crew truncated ${stat.size - maxBytes} bytes, head+tail preserved]...\n${tailBuf.toString("utf-8")}`;
 		}
 		return fs.readFileSync(safePath, "utf-8");
 	} catch {
@@ -95,11 +112,56 @@ function aggregateUsage(task: TeamTaskState): DependencyContextEntry["usage"] {
 	return { inputTokens, outputTokens, durationMs };
 }
 
+/**
+ * Apply staleness-aware pruning to shared reads before they are injected
+ * into a downstream worker's prompt. Converts shared reads to generic
+ * {@link ToolResultEntry}s (toolName="read") and file edits from dependency
+ * artifacts, then delegates to {@link pruneToolOutputs}. Superseded reads
+ * (same base file re-read, or file edited by a later dependency) are replaced
+ * with compact digest notices, reducing context bloat.
+ *
+ * OPT-IN: the default prune config protects recent results and only fires
+ * when minimum-savings hysteresis is met, so small/unique reads pass through
+ * unchanged.
+ */
+function pruneSharedReads(
+	reads: Array<{ name: string; path: string; content: string }>,
+	dependencies: DependencyContextEntry[],
+): Array<{ name: string; path: string; content: string }> {
+	if (reads.length === 0) return reads;
+	// Convert shared reads to tool result entries (ordered oldest → newest
+	// by position in the reads array — earlier entries are "older").
+	const entries: ToolResultEntry[] = reads.map((read, index) => ({
+		id: `shared-read-${index}`,
+		toolName: "read",
+		target: read.path,
+		content: read.content,
+	}));
+	// Collect file edit events from dependency artifacts produced to shared/.
+	// A dependency that wrote a shared file after an earlier read invalidates
+	// that read (the content is now stale relative to the latest version).
+	const sharedRoot = path.resolve("shared");
+	const fileEdits: FileEditEvent[] = [];
+	for (let depIndex = 0; depIndex < dependencies.length; depIndex++) {
+		const dep = dependencies[depIndex]!;
+		const produced = dep.artifactsProduced ?? [];
+		for (const artifact of produced) {
+			if (typeof artifact !== "string") continue;
+			// Map artifact path to shared-relative and check against read targets.
+			fileEdits.push({ target: path.resolve(sharedRoot, artifact), index: reads.length + depIndex });
+		}
+	}
+	const pruned = pruneToolOutputs(entries, DEFAULT_PRUNE_CONFIG);
+	if (pruned.prunedCount === 0) return reads;
+	// Map pruned entries back to the shared-read shape.
+	return pruned.results.map((entry, index) => ({ ...reads[index]!, content: entry.content }));
+}
+
 export function collectDependencyOutputContext(manifest: TeamRunManifest, tasks: TeamTaskState[], task: TeamTaskState, step: WorkflowStep): 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]));
 	const dependencies = task.dependsOn.map((dep) => byStep.get(dep) ?? byId.get(dep)).filter((item): item is TeamTaskState => Boolean(item)).map((item) => {
-		const resultText = item.resultArtifact ? readIfSmall(item.resultArtifact.path, 24_000, manifest.artifactsRoot) : undefined;
+		const resultText = item.resultArtifact ? readIfSmall(item.resultArtifact.path, manifest.artifactsRoot) : undefined;
 		return {
 			taskId: item.id,
 			role: item.role,
@@ -111,10 +173,15 @@ export function collectDependencyOutputContext(manifest: TeamRunManifest, tasks:
 			usage: aggregateUsage(item),
 		};
 	});
-	const sharedReads = (step.reads === false ? [] : step.reads ?? []).map((name) => {
+	const rawSharedReads = (step.reads === false ? [] : step.reads ?? []).map((name) => {
 		const filePath = sharedPath(manifest, name);
-		return { name, path: filePath, content: readIfSmall(filePath, 24_000, path.resolve(manifest.artifactsRoot, "shared")) ?? "" };
+		return { name, path: filePath, content: readIfSmall(filePath, path.resolve(manifest.artifactsRoot, "shared")) ?? "" };
 	}).filter((item) => item.content.trim().length > 0);
+	// Apply staleness-aware pruning to shared reads: drops superseded reads
+	// (same file re-read with different selectors) and replaces stale large
+	// outputs with compact digest notices before injecting into the worker
+	// prompt. OPT-IN: default config protects recent results.
+	const sharedReads = pruneSharedReads(rawSharedReads, dependencies);
 	return { dependencies, sharedReads };
 }
 
@@ -139,7 +206,7 @@ export function renderDependencyOutputContext(context: DependencyOutputContext):
 export function writeTaskSharedOutput(manifest: TeamRunManifest, step: WorkflowStep, task: TeamTaskState): ArtifactDescriptor | undefined {
 	if (step.output === false) return undefined;
 	const name = safeSharedName(step.output || `${task.id}.md`);
-	const source = task.resultArtifact ? readIfSmall(task.resultArtifact.path, 80_000, manifest.artifactsRoot) : undefined;
+	const source = task.resultArtifact ? readIfSmall(task.resultArtifact.path, manifest.artifactsRoot) : undefined;
 	if (!source) return undefined;
 	return writeArtifact(manifest.artifactsRoot, {
 		kind: "metadata",
@@ -160,7 +227,7 @@ export function writeTaskInputsArtifact(manifest: TeamRunManifest, task: TeamTas
 
 export function aggregateTaskOutputs(tasks: TeamTaskState[], manifest?: TeamRunManifest): string {
 	return tasks.map((task, index) => {
-		const body = task.resultArtifact ? readIfSmall(task.resultArtifact.path, 40_000, manifest?.artifactsRoot) : undefined;
+		const body = task.resultArtifact ? readIfSmall(task.resultArtifact.path, manifest?.artifactsRoot) : undefined;
 		const hasBody = Boolean(body?.trim());
 		const expectedMissing = task.resultArtifact && !containedExists(task.resultArtifact.path, manifest?.artifactsRoot);
 		const status = task.status === "skipped"