pi-crew 0.1.41 → 0.1.43

package/src/runtime/background-runner.ts

@@ -1,53 +1,53 @@
-import { allAgents, discoverAgents } from "../agents/discover-agents.ts";
-import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
-import { appendEvent } from "../state/event-log.ts";
-import { loadRunManifestById, updateRunStatus } from "../state/state-store.ts";
-import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
-import { loadConfig } from "../config/config.ts";
-import { executeTeamRun } from "./team-runner.ts";
-import { resolveCrewRuntime } from "./runtime-resolver.ts";
-import { directTeamAndWorkflowFromRun } from "./direct-run.ts";
-import { expandParallelResearchWorkflow } from "./parallel-research.ts";
-import { writeAsyncStartMarker } from "./async-marker.ts";
-
-function argValue(name: string): string | undefined {
-	const index = process.argv.indexOf(name);
-	if (index === -1) return undefined;
-	return process.argv[index + 1];
-}
-
-async function main(): Promise<void> {
-	const cwd = argValue("--cwd");
-	const runId = argValue("--run-id");
-	if (!cwd || !runId) throw new Error("Usage: background-runner.ts --cwd <cwd> --run-id <runId>");
-
-	const loaded = loadRunManifestById(cwd, runId);
-	if (!loaded) throw new Error(`Run '${runId}' not found.`);
-	let { manifest, tasks } = loaded;
-	appendEvent(manifest.eventsPath, { type: "async.started", runId: manifest.runId, data: { pid: process.pid } });
-	writeAsyncStartMarker(manifest, { pid: process.pid, startedAt: new Date().toISOString() });
-
-	try {
-		const agents = allAgents(discoverAgents(cwd));
-		const direct = directTeamAndWorkflowFromRun(manifest, tasks, agents);
-		const team = direct?.team ?? allTeams(discoverTeams(cwd)).find((candidate) => candidate.name === manifest.team);
-		if (!team) throw new Error(`Team '${manifest.team}' not found.`);
-		const baseWorkflow = direct?.workflow ?? allWorkflows(discoverWorkflows(cwd)).find((candidate) => candidate.name === manifest.workflow);
-		if (!baseWorkflow) throw new Error(`Workflow '${manifest.workflow ?? ""}' not found.`);
-		const workflow = expandParallelResearchWorkflow(baseWorkflow, cwd);
-		const loadedConfig = loadConfig(cwd);
-		const runtime = await resolveCrewRuntime(loadedConfig.config);
-		const executeWorkers = runtime.kind !== "scaffold";
-		const result = await executeTeamRun({ manifest, tasks, team, workflow, agents, executeWorkers, limits: loadedConfig.config.limits, runtime, runtimeConfig: loadedConfig.config.runtime });
-		manifest = result.manifest;
-		tasks = result.tasks;
-		appendEvent(manifest.eventsPath, { type: "async.completed", runId: manifest.runId, data: { status: manifest.status, tasks: tasks.length } });
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		manifest = updateRunStatus(manifest, "failed", message);
-		appendEvent(manifest.eventsPath, { type: "async.failed", runId: manifest.runId, message });
-		process.exitCode = 1;
-	}
-}
-
-await main();
+import { allAgents, discoverAgents } from "../agents/discover-agents.ts";
+import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
+import { appendEvent } from "../state/event-log.ts";
+import { loadRunManifestById, updateRunStatus } from "../state/state-store.ts";
+import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
+import { loadConfig } from "../config/config.ts";
+import { executeTeamRun } from "./team-runner.ts";
+import { resolveCrewRuntime } from "./runtime-resolver.ts";
+import { directTeamAndWorkflowFromRun } from "./direct-run.ts";
+import { expandParallelResearchWorkflow } from "./parallel-research.ts";
+import { writeAsyncStartMarker } from "./async-marker.ts";
+
+function argValue(name: string): string | undefined {
+	const index = process.argv.indexOf(name);
+	if (index === -1) return undefined;
+	return process.argv[index + 1];
+}
+
+async function main(): Promise<void> {
+	const cwd = argValue("--cwd");
+	const runId = argValue("--run-id");
+	if (!cwd || !runId) throw new Error("Usage: background-runner.ts --cwd <cwd> --run-id <runId>");
+
+	const loaded = loadRunManifestById(cwd, runId);
+	if (!loaded) throw new Error(`Run '${runId}' not found.`);
+	let { manifest, tasks } = loaded;
+	appendEvent(manifest.eventsPath, { type: "async.started", runId: manifest.runId, data: { pid: process.pid } });
+	writeAsyncStartMarker(manifest, { pid: process.pid, startedAt: new Date().toISOString() });
+
+	try {
+		const agents = allAgents(discoverAgents(cwd));
+		const direct = directTeamAndWorkflowFromRun(manifest, tasks, agents);
+		const team = direct?.team ?? allTeams(discoverTeams(cwd)).find((candidate) => candidate.name === manifest.team);
+		if (!team) throw new Error(`Team '${manifest.team}' not found.`);
+		const baseWorkflow = direct?.workflow ?? allWorkflows(discoverWorkflows(cwd)).find((candidate) => candidate.name === manifest.workflow);
+		if (!baseWorkflow) throw new Error(`Workflow '${manifest.workflow ?? ""}' not found.`);
+		const workflow = expandParallelResearchWorkflow(baseWorkflow, cwd);
+		const loadedConfig = loadConfig(cwd);
+		const runtime = await resolveCrewRuntime(loadedConfig.config);
+		const executeWorkers = runtime.kind !== "scaffold";
+		const result = await executeTeamRun({ manifest, tasks, team, workflow, agents, executeWorkers, limits: loadedConfig.config.limits, runtime, runtimeConfig: loadedConfig.config.runtime });
+		manifest = result.manifest;
+		tasks = result.tasks;
+		appendEvent(manifest.eventsPath, { type: "async.completed", runId: manifest.runId, data: { status: manifest.status, tasks: tasks.length } });
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		manifest = updateRunStatus(manifest, "failed", message);
+		appendEvent(manifest.eventsPath, { type: "async.failed", runId: manifest.runId, message });
+		process.exitCode = 1;
+	}
+}
+
+await main();

package/src/runtime/child-pi.ts

@@ -69,7 +69,7 @@ function killProcessTree(pid: number | undefined, child?: ChildProcess): void {
 			}
 			childHardKillTimers.delete(pid);
 		}, HARD_KILL_MS);
-		hardKillTimer.unref?.();
+		hardKillTimer.unref();
 		child?.once("exit", () => clearHardKillTimer(pid));
 		childHardKillTimers.set(pid, hardKillTimer);
 	} catch (error) {
@@ -318,7 +318,7 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 						logInternalError("child-pi.response-timeout-term", error, `pid=${child.pid}`);
 					}
 				}, responseTimeoutMs);
-				noResponseTimer.unref?.();
+				noResponseTimer.unref();
 			};
 			const clearNoResponseTimer = (): void => {
 				if (noResponseTimer) clearTimeout(noResponseTimer);
@@ -352,9 +352,9 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 								logInternalError("child-pi.final-drain-kill", error, `pid=${child.pid}`);
 							}
 						}, hardKillMs);
-						hardKillTimer.unref?.();
+						hardKillTimer.unref();
 					}, finalDrainMs);
-					finalDrainTimer.unref?.();
+					finalDrainTimer.unref();
 				},
 			});
 

package/src/runtime/completion-guard.ts

@@ -1,99 +1,103 @@
-import * as fs from "node:fs";
-
-export interface CompletionMutationGuardInput {
-	role: string;
-	taskText?: string;
-	transcriptPath?: string;
-	stdout?: string;
-}
-
-export interface CompletionMutationGuardResult {
-	expectedMutation: boolean;
-	observedMutation: boolean;
-	reason?: "no_mutation_observed";
-	observedTools: string[];
-}
-
-const MUTATING_ROLES = new Set(["executor", "test-engineer"]);
-const MUTATING_TOOLS = new Set(["edit", "write", "multi_edit", "apply_patch"]);
-const READ_ONLY_COMMANDS = /^(pwd|ls|dir|cat|type|sed|grep|rg|find|git\s+(status|diff|log|show|branch|remote|rev-parse|ls-files)|npm\s+(test|run\s+(typecheck|check|lint|test|ci))|node\s+--test)\b/i;
-const MUTATING_COMMANDS = /\b(rm\s+-|del\s+|erase\s+|mv\s+|move\s+|cp\s+|copy\s+|mkdir\b|touch\b|git\s+(add|commit|push|reset|clean|checkout|switch|merge|rebase|stash)|npm\s+(install|i|uninstall|publish|version)|pnpm\s+(add|install|remove)|yarn\s+(add|install|remove)|python\b.*>|node\b.*>|echo\b.*>|Set-Content|Out-File)\b/i;
-const READ_ONLY_HINTS = /\b(read-only|no edits?|do not edit|không sửa|khong sua|chỉ đọc|chi doc|plan only|chỉ lập plan|review only|audit only)\b/i;
-
-function asRecord(value: unknown): Record<string, unknown> | undefined {
-	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
-}
-
-function commandText(value: unknown): string {
-	const record = asRecord(value);
-	if (!record) return typeof value === "string" ? value : "";
-	for (const key of ["command", "cmd", "script", "input"]) {
-		const raw = record[key];
-		if (typeof raw === "string") return raw;
-	}
-	return JSON.stringify(record);
-}
-
-function isMutatingTool(tool: string, args: unknown): boolean {
-	const normalized = tool.toLowerCase();
-	if (MUTATING_TOOLS.has(normalized)) return true;
-	if (normalized === "bash" || normalized === "shell" || normalized === "powershell") {
-		const command = commandText(args).trim();
-		if (!command || READ_ONLY_COMMANDS.test(command)) return false;
-		return MUTATING_COMMANDS.test(command);
-	}
-	return false;
-}
-
-function collectToolCallsFromEvent(event: unknown): Array<{ tool: string; args?: unknown }> {
-	const record = asRecord(event);
-	if (!record) return [];
-	const calls: Array<{ tool: string; args?: unknown }> = [];
-	const directTool = record.toolName ?? record.name ?? record.tool;
-	if (typeof directTool === "string" && (record.type === "tool_execution_start" || record.type === "toolCall" || record.type === "tool_call")) {
-		calls.push({ tool: directTool, args: record.args ?? record.input });
-	}
-	const content = Array.isArray(record.content) ? record.content : asRecord(record.message)?.content;
-	if (Array.isArray(content)) {
-		for (const part of content) {
-			const item = asRecord(part);
-			if (!item) continue;
-			const tool = item.name ?? item.toolName ?? item.tool;
-			if (typeof tool === "string" && (item.type === "toolCall" || item.type === "tool_call" || item.type === "tool_execution_start")) calls.push({ tool, args: item.input ?? item.args });
-		}
-	}
-	return calls;
-}
-
-function transcriptText(input: CompletionMutationGuardInput): string {
-	if (input.transcriptPath && fs.existsSync(input.transcriptPath)) return fs.readFileSync(input.transcriptPath, "utf-8");
-	return input.stdout ?? "";
-}
-
-export function expectsImplementationMutation(input: Pick<CompletionMutationGuardInput, "role" | "taskText">): boolean {
-	if (!MUTATING_ROLES.has(input.role)) return false;
-	return !READ_ONLY_HINTS.test(input.taskText ?? "");
-}
-
-export function evaluateCompletionMutationGuard(input: CompletionMutationGuardInput): CompletionMutationGuardResult {
-	const expectedMutation = expectsImplementationMutation(input);
-	const observedTools: string[] = [];
-	let observedMutation = false;
-	const text = transcriptText(input);
-	for (const line of text.split("\n")) {
-		const trimmed = line.trim();
-		if (!trimmed) continue;
-		let event: unknown;
-		try { event = JSON.parse(trimmed); } catch { continue; }
-		for (const call of collectToolCallsFromEvent(event)) {
-			observedTools.push(call.tool);
-			if (isMutatingTool(call.tool, call.args)) observedMutation = true;
-		}
-	}
-	return {
-		expectedMutation,
-		observedMutation,
-		observedTools,
-		...(expectedMutation && !observedMutation ? { reason: "no_mutation_observed" as const } : {}),
-	};
-}
+import * as fs from "node:fs";
+
+export interface CompletionMutationGuardInput {
+	role: string;
+	taskText?: string;
+	transcriptPath?: string;
+	stdout?: string;
+}
+
+export interface CompletionMutationGuardResult {
+	expectedMutation: boolean;
+	observedMutation: boolean;
+	reason?: "no_mutation_observed";
+	observedTools: string[];
+}
+
+const MUTATING_ROLES = new Set(["executor", "test-engineer"]);
+const MUTATING_TOOLS = new Set(["edit", "write", "multi_edit", "apply_patch", "replace_in_file", "insert", "delete_files", "create_file", "overwrite", "patch"]);
+const READ_ONLY_COMMANDS = /^(pwd|ls|dir|cat|type|sed|grep|rg|find|git\s+(status|diff|log|show|branch|remote|rev-parse|ls-files)|npm\s+(test|run\s+(typecheck|check|lint|test|ci))|node\s+--test)\b/i;
+const MUTATING_COMMANDS = /\b(rm\s+-|del\s+|erase\s+|mv\s+|move\s+|cp\s+|copy\s+|mkdir\b|touch\b|git\s+(add|commit|push|reset|clean|checkout|switch|merge|rebase|stash)|npm\s+(install|i|uninstall|publish|version)|pnpm\s+(add|install|remove)|yarn\s+(add|install|remove)|python\b.*>|node\b.*>|echo\b.*>|Set-Content|Out-File|sed\s+-i|tee\b|dd\b.*of=|wget\b.*-O|curl\b.*-o)\b/i;
+const READ_ONLY_HINTS = /\b(read-only|no edits?|do not edit|không sửa|khong sua|chỉ đọc|chi doc|plan only|chỉ lập plan|review only|audit only)\b/i;
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+}
+
+function commandText(value: unknown): string {
+	const record = asRecord(value);
+	if (!record) return typeof value === "string" ? value : "";
+	for (const key of ["command", "cmd", "script", "input"]) {
+		const raw = record[key];
+		if (typeof raw === "string") return raw;
+	}
+	return JSON.stringify(record);
+}
+
+function isMutatingTool(tool: string, args: unknown): boolean {
+	const normalized = tool.toLowerCase();
+	if (MUTATING_TOOLS.has(normalized)) return true;
+	if (normalized === "bash" || normalized === "shell" || normalized === "powershell") {
+		const command = commandText(args).trim();
+		if (!command) return false;
+		// Check mutating patterns first: sed -i is mutating even though plain sed is read-only.
+		if (MUTATING_COMMANDS.test(command)) return true;
+		if (READ_ONLY_COMMANDS.test(command)) return false;
+		// If the command doesn't match either list, treat unknown bash calls as potentially mutating.
+		return true;
+	}
+	return false;
+}
+
+function collectToolCallsFromEvent(event: unknown): Array<{ tool: string; args?: unknown }> {
+	const record = asRecord(event);
+	if (!record) return [];
+	const calls: Array<{ tool: string; args?: unknown }> = [];
+	const directTool = record.toolName ?? record.name ?? record.tool;
+	if (typeof directTool === "string" && (record.type === "tool_execution_start" || record.type === "toolCall" || record.type === "tool_call")) {
+		calls.push({ tool: directTool, args: record.args ?? record.input });
+	}
+	const content = Array.isArray(record.content) ? record.content : asRecord(record.message)?.content;
+	if (Array.isArray(content)) {
+		for (const part of content) {
+			const item = asRecord(part);
+			if (!item) continue;
+			const tool = item.name ?? item.toolName ?? item.tool;
+			if (typeof tool === "string" && (item.type === "toolCall" || item.type === "tool_call" || item.type === "tool_execution_start")) calls.push({ tool, args: item.input ?? item.args });
+		}
+	}
+	return calls;
+}
+
+function transcriptText(input: CompletionMutationGuardInput): string {
+	if (input.transcriptPath && fs.existsSync(input.transcriptPath)) return fs.readFileSync(input.transcriptPath, "utf-8");
+	return input.stdout ?? "";
+}
+
+export function expectsImplementationMutation(input: Pick<CompletionMutationGuardInput, "role" | "taskText">): boolean {
+	if (!MUTATING_ROLES.has(input.role)) return false;
+	return !READ_ONLY_HINTS.test(input.taskText ?? "");
+}
+
+export function evaluateCompletionMutationGuard(input: CompletionMutationGuardInput): CompletionMutationGuardResult {
+	const expectedMutation = expectsImplementationMutation(input);
+	const observedTools: string[] = [];
+	let observedMutation = false;
+	const text = transcriptText(input);
+	for (const line of text.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		let event: unknown;
+		try { event = JSON.parse(trimmed); } catch { continue; }
+		for (const call of collectToolCallsFromEvent(event)) {
+			observedTools.push(call.tool);
+			if (isMutatingTool(call.tool, call.args)) observedMutation = true;
+		}
+	}
+	return {
+		expectedMutation,
+		observedMutation,
+		observedTools,
+		...(expectedMutation && !observedMutation ? { reason: "no_mutation_observed" as const } : {}),
+	};
+}

package/src/runtime/concurrency.ts

@@ -44,7 +44,7 @@ export function resolveBatchConcurrency(input: ResolveBatchConcurrencyInput): Ba
 	else source = "workflow";
 	const hardCap = positiveInteger(input.hardCap) ?? DEFAULT_CONCURRENCY.hardCap;
 	const maxConcurrent = input.allowUnboundedConcurrency ? requested : Math.min(requested, hardCap);
-	const readyCount = Math.max(0, Math.trunc(input.readyCount));
+	const readyCount = Math.max(0, Math.trunc(Number.isFinite(input.readyCount) ? input.readyCount : 0));
 	const cappedReason = maxConcurrent < requested ? `;capped:${hardCap}` : "";
 	const unboundedReason = input.allowUnboundedConcurrency && requested > hardCap ? `;unbounded:${hardCap}` : "";
 	return {

package/src/runtime/crash-recovery.ts

@@ -51,6 +51,7 @@ export async function applyRecoveryPlan(plan: RecoveryPlan, ctx: Pick<ExtensionC
 export function declineRecoveryPlan(plan: RecoveryPlan, ctx: Pick<ExtensionContext, "cwd">): void {
 	const loaded = loadRunManifestById(ctx.cwd, plan.runId);
 	if (!loaded) throw new Error(`Run '${plan.runId}' not found.`);
-	updateRunStatus(loaded.manifest, "cancelled", "interrupted-not-resumed");
+	// Log the event first — if appendEvent fails, state remains consistent.
 	appendEvent(loaded.manifest.eventsPath, { type: "crew.run.recovery_declined", runId: plan.runId, message: "Interrupted run was not resumed.", data: { recoveredFromSeq: plan.lastEventSeq } });
+	updateRunStatus(loaded.manifest, "cancelled", "interrupted-not-resumed");
 }

package/src/runtime/crew-agent-runtime.ts

@@ -1,58 +1,58 @@
-import type { TeamTaskStatus } from "../state/contracts.ts";
-import type { CrewActivityState, ModelRoutingState, UsageState } from "../state/types.ts";
-
-export type CrewRuntimeKind = "scaffold" | "child-process" | "live-session";
-export type CrewAgentStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "stopped";
-
-export interface CrewAgentRecentTool {
-	tool: string;
-	args?: string;
-	endedAt: string;
-}
-
-export interface CrewAgentProgress {
-	currentTool?: string;
-	currentToolArgs?: string;
-	currentToolStartedAt?: string;
-	recentTools: CrewAgentRecentTool[];
-	recentOutput: string[];
-	toolCount: number;
-	tokens?: number;
-	turns?: number;
-	durationMs?: number;
-	lastActivityAt?: string;
-	activityState?: CrewActivityState;
-	failedTool?: string;
-}
-
-export interface CrewAgentRecord {
-	id: string;
-	runId: string;
-	taskId: string;
-	agent: string;
-	role: string;
-	runtime: CrewRuntimeKind;
-	status: CrewAgentStatus;
-	startedAt: string;
-	completedAt?: string;
-	resultArtifactPath?: string;
-	transcriptPath?: string;
-	statusPath?: string;
-	eventsPath?: string;
-	outputPath?: string;
-	toolUses?: number;
-	jsonEvents?: number;
-	model?: string;
-	routing?: ModelRoutingState;
-	usage?: UsageState;
-	progress?: CrewAgentProgress;
-	error?: string;
-}
-
-export function taskStatusToAgentStatus(status: TeamTaskStatus): CrewAgentStatus {
-	if (status === "completed") return "completed";
-	if (status === "failed") return "failed";
-	if (status === "cancelled" || status === "skipped") return "cancelled";
-	if (status === "running") return "running";
-	return "queued";
-}
+import type { TeamTaskStatus } from "../state/contracts.ts";
+import type { CrewActivityState, ModelRoutingState, UsageState } from "../state/types.ts";
+
+export type CrewRuntimeKind = "scaffold" | "child-process" | "live-session";
+export type CrewAgentStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "stopped";
+
+export interface CrewAgentRecentTool {
+	tool: string;
+	args?: string;
+	endedAt: string;
+}
+
+export interface CrewAgentProgress {
+	currentTool?: string;
+	currentToolArgs?: string;
+	currentToolStartedAt?: string;
+	recentTools: CrewAgentRecentTool[];
+	recentOutput: string[];
+	toolCount: number;
+	tokens?: number;
+	turns?: number;
+	durationMs?: number;
+	lastActivityAt?: string;
+	activityState?: CrewActivityState;
+	failedTool?: string;
+}
+
+export interface CrewAgentRecord {
+	id: string;
+	runId: string;
+	taskId: string;
+	agent: string;
+	role: string;
+	runtime: CrewRuntimeKind;
+	status: CrewAgentStatus;
+	startedAt: string;
+	completedAt?: string;
+	resultArtifactPath?: string;
+	transcriptPath?: string;
+	statusPath?: string;
+	eventsPath?: string;
+	outputPath?: string;
+	toolUses?: number;
+	jsonEvents?: number;
+	model?: string;
+	routing?: ModelRoutingState;
+	usage?: UsageState;
+	progress?: CrewAgentProgress;
+	error?: string;
+}
+
+export function taskStatusToAgentStatus(status: TeamTaskStatus): CrewAgentStatus {
+	if (status === "completed") return "completed";
+	if (status === "failed") return "failed";
+	if (status === "cancelled" || status === "skipped") return "cancelled";
+	if (status === "running") return "running";
+	return "queued";
+}

package/src/runtime/deadletter.ts

@@ -2,6 +2,8 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { TeamRunManifest } from "../state/types.ts";
 
+import { logInternalError } from "../utils/internal-error.ts";
+
 export type DeadletterReason = "max-retries" | "heartbeat-dead" | "manual";
 
 export interface DeadletterEntry {
@@ -18,14 +20,22 @@ export function deadletterPath(manifest: TeamRunManifest): string {
 }
 
 export function appendDeadletter(manifest: TeamRunManifest, entry: DeadletterEntry): void {
-	fs.mkdirSync(manifest.stateRoot, { recursive: true });
-	fs.appendFileSync(deadletterPath(manifest), `${JSON.stringify(entry)}\n`, "utf-8");
+	try {
+		fs.mkdirSync(manifest.stateRoot, { recursive: true });
+		fs.appendFileSync(deadletterPath(manifest), `${JSON.stringify(entry)}\n`, "utf-8");
+	} catch (error) {
+		logInternalError("deadletter.append", error, `taskId=${entry.taskId}`);
+	}
 }
 
-export function readDeadletter(manifest: TeamRunManifest): DeadletterEntry[] {
+export function readDeadletter(manifest: TeamRunManifest, maxEntries = 1000): DeadletterEntry[] {
 	const filePath = deadletterPath(manifest);
 	if (!fs.existsSync(filePath)) return [];
-	return fs.readFileSync(filePath, "utf-8").split(/\r?\n/).filter(Boolean).flatMap((line) => {
+	// Read last maxEntries lines only to limit memory.
+	const raw = fs.readFileSync(filePath, "utf-8");
+	const lines = raw.split(/\r?\n/).filter(Boolean);
+	const tail = lines.slice(-maxEntries);
+	return tail.flatMap((line) => {
 		try {
 			const parsed = JSON.parse(line) as DeadletterEntry;
 			return parsed && typeof parsed.taskId === "string" && typeof parsed.runId === "string" ? [parsed] : [];

package/src/runtime/direct-run.ts

@@ -1,35 +1,35 @@
-import type { AgentConfig } from "../agents/agent-config.ts";
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import type { TeamConfig } from "../teams/team-config.ts";
-import type { WorkflowConfig } from "../workflows/workflow-config.ts";
-
-export function isDirectRun(manifest: Pick<TeamRunManifest, "team" | "workflow">): boolean {
-	return manifest.workflow === "direct-agent";
-}
-
-export function directTeamAndWorkflowFromRun(manifest: TeamRunManifest, tasks: TeamTaskState[], agents: AgentConfig[]): { team: TeamConfig; workflow: WorkflowConfig } | undefined {
-	if (!isDirectRun(manifest)) return undefined;
-	const firstTask = tasks[0];
-	const agentName = firstTask?.agent ?? (manifest.team.replace(/^direct-/, "") || "executor");
-	const agent = agents.find((candidate) => candidate.name === agentName);
-	const role = firstTask?.role ?? "agent";
-	const stepId = firstTask?.stepId ?? "01_agent";
-	return {
-		team: {
-			name: manifest.team,
-			description: `Direct subagent run for ${agentName}`,
-			source: "builtin",
-			filePath: "<generated>",
-			roles: [{ name: role, agent: agentName, description: agent?.description }],
-			defaultWorkflow: "direct-agent",
-			workspaceMode: manifest.workspaceMode,
-		},
-		workflow: {
-			name: manifest.workflow ?? "direct-agent",
-			description: `Direct task for ${agentName}`,
-			source: "builtin",
-			filePath: "<generated>",
-			steps: [{ id: stepId, role, task: "{goal}", model: firstTask?.model }],
-		},
-	};
-}
+import type { AgentConfig } from "../agents/agent-config.ts";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import type { TeamConfig } from "../teams/team-config.ts";
+import type { WorkflowConfig } from "../workflows/workflow-config.ts";
+
+export function isDirectRun(manifest: Pick<TeamRunManifest, "team" | "workflow">): boolean {
+	return manifest.workflow === "direct-agent";
+}
+
+export function directTeamAndWorkflowFromRun(manifest: TeamRunManifest, tasks: TeamTaskState[], agents: AgentConfig[]): { team: TeamConfig; workflow: WorkflowConfig } | undefined {
+	if (!isDirectRun(manifest)) return undefined;
+	const firstTask = tasks[0];
+	const agentName = firstTask?.agent ?? (manifest.team.replace(/^direct-/, "") || "executor");
+	const agent = agents.find((candidate) => candidate.name === agentName);
+	const role = firstTask?.role ?? "agent";
+	const stepId = firstTask?.stepId ?? "01_agent";
+	return {
+		team: {
+			name: manifest.team,
+			description: `Direct subagent run for ${agentName}`,
+			source: "builtin",
+			filePath: "<generated>",
+			roles: [{ name: role, agent: agentName, description: agent?.description }],
+			defaultWorkflow: "direct-agent",
+			workspaceMode: manifest.workspaceMode,
+		},
+		workflow: {
+			name: manifest.workflow ?? "direct-agent",
+			description: `Direct task for ${agentName}`,
+			source: "builtin",
+			filePath: "<generated>",
+			steps: [{ id: stepId, role, task: "{goal}", model: firstTask?.model }],
+		},
+	};
+}