pi-crew 0.9.16 → 0.9.18

package/src/runtime/coalesce-tasks.ts

@@ -0,0 +1,268 @@
+/**
+ * coalesce-tasks.ts — micro-task coalescing for scheduler batching (M6).
+ *
+ * Implements the workflow-level `coalesceMicroTasks` opt-in (plan §11
+ * decision #7): default = false; when true, multiple ready tasks sharing
+ * `role` and `cwd` are grouped into a single "coalesced task group" so the
+ * scheduler dispatches ONE worker call instead of N. Trades individual task
+ * observability for fewer cold-starts when many small tasks of the same kind
+ * are queued simultaneously.
+ *
+ * Safety guards (per plan §5 M6):
+ *   - Only groups tasks that share role + cwd (so the grouped worker can use
+ *     a single worker prompt without per-task permission prompts).
+ *   - Tasks that declare a non-false `output` are NEVER coalesced with
+ *     another task that has the same write path (write-write conflict).
+ *   - When the flag is off or the list is empty, returns the input list
+ *     unchanged (no-op for production; zero overhead).
+ *
+ * Real-dispatch (v0.9.17+ follow-up, see m6-real-dispatch-design.md):
+ *   - MVP only coalesces READ_ONLY roles (permissionForRole === "read_only").
+ *     This eliminates write-path conflicts, worktree concerns, and mutation
+ *     guards. Use case: parallel-research with 4 explorers → 1 worker.
+ *   - MVP rejects coalescing when any step has: worktree: true, preStepScript,
+ *     verify: true, or non-false output. These are per-step concerns that
+ *     don't compose in a single multi-task worker.
+ *   - maxGroupSize cap (default 5) prevents context-budget overflow when
+ *     grouping many micro-tasks into one worker prompt.
+ */
+
+import type { TeamTaskState } from "../state/types.ts";
+import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
+import { permissionForRole } from "./role-permission.ts";
+
+/** Default cap on group size to prevent context-budget overflow. */
+export const DEFAULT_MAX_GROUP_SIZE = 5;
+
+/** Default cap on combined estimated prompt size (bytes). Conservative
+ *  estimate — real prompt includes the stable prefix (~5KB) plus per-task
+ *  sections. 100KB matches the budget heuristic in the design doc
+ *  (m6-real-dispatch-design.md §R4). */
+export const DEFAULT_MAX_GROUP_BYTES = 100_000;
+
+export interface CoalescedGroup {
+	/** Stable id derived from the group membership; deterministic for tests. */
+	id: string;
+	role: string;
+	cwd: string;
+	/** Tasks to be coalesced into one worker invocation, in input order. */
+	tasks: TeamTaskState[];
+}
+
+/**
+ * Group ready tasks by (role, cwd) while respecting write-path safety.
+ *
+ * Returns an array of `CoalescedGroup`. Each group contains tasks that:
+ *   - share the same role and cwd
+ *   - have NO write-path conflict with any other task in the group
+ *
+ * Singletons (groups with one task) are preserved — the caller can decide
+ * whether to dispatch them as-is or skip the coalesce entirely.
+ *
+ * If `enabled` is false, returns `[]` (signal to the caller to skip
+ * coalescing — use the original list).
+ */
+export function planCoalescedGroups(
+	readyTaskIds: string[],
+	tasks: TeamTaskState[],
+	workflow: WorkflowConfig,
+	enabled: boolean,
+	maxGroupSize: number = DEFAULT_MAX_GROUP_SIZE,
+	maxGroupBytes: number = DEFAULT_MAX_GROUP_BYTES,
+): CoalescedGroup[] {
+	if (!enabled || readyTaskIds.length === 0) return [];
+	const taskById = new Map<string, TeamTaskState>(tasks.map((task) => [task.id, task]));
+	const stepById = new Map<string, WorkflowStep>(workflow.steps.map((step) => [step.id, step]));
+
+	// Bucket: key = `${role}\0${cwd}` → task list preserving input order
+	const buckets = new Map<string, TeamTaskState[]>();
+	for (const taskId of readyTaskIds) {
+		const task = taskById.get(taskId);
+		if (!task || !task.stepId) continue;
+		const step = stepById.get(task.stepId);
+		if (!step) continue;
+
+		// MVP constraint (real-dispatch safety): only coalesce READ_ONLY roles.
+		// Writing roles (executor, writer, implementer) require per-step hooks
+		// (worktree, preStepScript, verify) that don't compose in one worker.
+		if (permissionForRole(task.role) !== "read_only") continue;
+
+		// MVP constraint: reject if step has any per-step concern that
+		// doesn't compose in a multi-task worker. These flags set up side
+		// effects per-task that can't be combined.
+		if (step.worktree) continue;
+		if (step.preStepScript) continue;
+		if (step.verify) continue;
+		if (step.output !== undefined && step.output !== false && step.output !== "") continue;
+
+		const key = `${task.role}\0${task.cwd}`;
+		const list = buckets.get(key);
+		if (list) list.push(task);
+		else buckets.set(key, [task]);
+	}
+
+	// Within each bucket, split further by write-path safety (groups of tasks
+	// that all have distinct write outputs), cap at maxGroupSize, AND cap
+	// combined estimated prompt size at maxGroupBytes. This addresses
+	// design-doc risk R4 (context-budget overflow): a worker handling N
+	// micro-tasks with large dependency contexts could exceed the model's
+	// context window. The byte cap is a heuristic, not a guarantee — the
+	// actual prompt includes rendered workspace trees and skill blocks too.
+	const groups: CoalescedGroup[] = [];
+	for (const [key, bucketTasks] of buckets) {
+		const [role, cwd] = key.split("\0");
+		const subgroups = splitByWriteSafety(bucketTasks, stepById);
+		for (const subgroup of subgroups) {
+			// Chunk by BOTH count and bytes. Greedy: keep adding tasks while
+			// adding the next one wouldn't exceed either limit. When a
+			// single task exceeds the byte limit by itself (rare), include
+			// it anyway as a singleton group so it's at least eligible.
+			let chunkStart = 0;
+			let chunkBytes = 0;
+			for (let i = 0; i < subgroup.length; i += 1) {
+				const task = subgroup[i]!;
+				const step = task.stepId ? stepById.get(task.stepId) : undefined;
+				const taskSize = estimateTaskPromptSize(task, step);
+				const wouldBeCount = i - chunkStart + 1;
+				const wouldBeBytes = chunkBytes + taskSize;
+				const overCount = wouldBeCount > maxGroupSize;
+				const overBytes = i > chunkStart && wouldBeBytes > maxGroupBytes;
+				if ((overCount || overBytes) && i > chunkStart) {
+					// Flush current chunk as a group.
+					const slice = subgroup.slice(chunkStart, i);
+					groups.push(buildGroup(slice, role, cwd));
+					chunkStart = i;
+					chunkBytes = taskSize;
+				} else {
+					chunkBytes += taskSize;
+				}
+			}
+			// Flush final chunk.
+			if (chunkStart < subgroup.length) {
+				const slice = subgroup.slice(chunkStart);
+				groups.push(buildGroup(slice, role, cwd));
+			}
+		}
+	}
+	return groups;
+}
+
+function buildGroup(tasks: TeamTaskState[], role: string, cwd: string): CoalescedGroup {
+	return {
+		id: tasks.length === 1 ? tasks[0]!.id : tasks.map((t) => t.id).join("+"),
+		role,
+		cwd,
+		tasks,
+	};
+}
+
+/**
+ * Estimate the prompt-bytes contribution of a single task within a
+ * coalesced group. The actual prompt is much larger (workspace tree,
+ * skill block, dependency context) but the task-specific contribution
+ * is roughly proportional to the step's task text + a fixed per-task
+ * overhead for delimiters and headers.
+ */
+function estimateTaskPromptSize(task: TeamTaskState, step: WorkflowStep | undefined): number {
+	const taskText = step?.task?.length ?? 0;
+	const packetEstimate = 500; // task packet / scope / verification estimate
+	const delimiterOverhead = 200; // `<<<TASK_RESULT:id>>>` + section header
+	return taskText + packetEstimate + delimiterOverhead;
+}
+
+/**
+ * Split a bucket of tasks into write-safe subgroups: a subgroup may include
+ * tasks only if no two of them have the same `step.output`.
+ *
+ * Greedy: first task always goes to current group; subsequent tasks join the
+ * current group only if they don't conflict with any already-in-group member.
+ * Otherwise, they start (and extend) the next subgroup.
+ */
+function splitByWriteSafety(bucketTasks: TeamTaskState[], stepById: Map<string, WorkflowStep>): TeamTaskState[][] {
+	const result: TeamTaskState[][] = [];
+	for (const task of bucketTasks) {
+		const step = task.stepId ? stepById.get(task.stepId) : undefined;
+		const writePath = step?.output;
+		let placed = false;
+		for (const group of result) {
+			let conflict = false;
+			for (const other of group) {
+				const otherStep = other.stepId ? stepById.get(other.stepId) : undefined;
+				if (typeof writePath === "string" && typeof otherStep?.output === "string" && writePath === otherStep.output) {
+					conflict = true;
+					break;
+				}
+			}
+			if (!conflict) {
+				group.push(task);
+				placed = true;
+				break;
+			}
+		}
+		if (!placed) result.push([task]);
+	}
+	return result;
+}
+
+/**
+ * Flatten a list of `CoalescedGroup` back into a flat task-id list (one entry
+ * per group). For a group of N tasks, this returns N task IDs in order. When
+ * M6 is enabled upstream, the caller can use this to count "effective ready
+ * units" (groups vs raw tasks).
+ */
+export function flattenGroupIds(groups: CoalescedGroup[]): string[] {
+	return groups.flatMap((group) => group.tasks.map((task) => task.id));
+}
+
+/**
+ * Find the coalesced group that contains the given task ID.
+ * Returns undefined if the task is not in any group (e.g., it was excluded
+ * by MVP constraints or wasn't part of the coalesced set).
+ *
+ * Used by the team-runner dispatch loop to look up a task's group metadata
+ * (role, cwd, group ID, sibling task IDs) when iterating the flat ready
+ * list and discovering which tasks should be batched together.
+ */
+export function findGroupContainingTask(groups: CoalescedGroup[], taskId: string): CoalescedGroup | undefined {
+	for (const group of groups) {
+		if (group.tasks.some((task) => task.id === taskId)) return group;
+	}
+	return undefined;
+}
+
+/**
+ * Expand a list of task IDs into a list of dispatch units, where each unit
+ * is either a single task (for singletons / non-coalescable tasks) or a
+ * CoalescedGroup (for multi-task batches). The returned units can be fed
+ * directly into mapConcurrent.
+ *
+ * Tasks not present in any coalesced group are returned as singleton units.
+ */
+export type DispatchUnit = { kind: "singleton"; taskId: string } | { kind: "group"; group: CoalescedGroup };
+
+export function buildDispatchUnits(readyTaskIds: string[], coalescedGroups: CoalescedGroup[]): DispatchUnit[] {
+	const groupByTaskId = new Map<string, CoalescedGroup>();
+	for (const group of coalescedGroups) {
+		if (group.tasks.length < 2) continue; // singletons handled separately
+		for (const task of group.tasks) {
+			groupByTaskId.set(task.id, group);
+		}
+	}
+	const visited = new Set<string>();
+	const units: DispatchUnit[] = [];
+	// First pass: emit groups (one unit per group, in input order)
+	for (const taskId of readyTaskIds) {
+		const group = groupByTaskId.get(taskId);
+		if (!group) continue;
+		if (visited.has(group.id)) continue;
+		visited.add(group.id);
+		for (const t of group.tasks) visited.add(t.id);
+		units.push({ kind: "group", group });
+	}
+	// Second pass: emit singletons (and tasks whose group is size 1)
+	for (const taskId of readyTaskIds) {
+		if (visited.has(taskId)) continue;
+		units.push({ kind: "singleton", taskId });
+	}
+	return units;
+}

package/src/runtime/code-summary.ts

@@ -23,17 +23,21 @@ export interface SummaryResult {
 }
 
 export interface SummaryOptions {
-	minBodyLines?: number;    // default 4
+	minBodyLines?: number; // default 4
 	minCommentLines?: number; // default 6
 }
 
 // ── Language detection ──
 
 const EXT_MAP: ReadonlyMap<string, string> = new Map([
-	[".ts", "typescript"], [".tsx", "typescript"],
-	[".js", "javascript"], [".jsx", "javascript"],
-	[".mjs", "javascript"], [".cjs", "javascript"],
-	[".py", "python"], [".rs", "rust"],
+	[".ts", "typescript"],
+	[".tsx", "typescript"],
+	[".js", "javascript"],
+	[".jsx", "javascript"],
+	[".mjs", "javascript"],
+	[".cjs", "javascript"],
+	[".py", "python"],
+	[".rs", "rust"],
 ]);
 
 export function detectLanguage(filePath: string): string | null {
@@ -44,7 +48,10 @@ export function detectLanguage(filePath: string): string | null {
 
 // ── Internal range helpers ──
 
-interface Range { start: number; end: number; }
+interface Range {
+	start: number;
+	end: number;
+}
 
 function mergeRanges(ranges: Range[]): Range[] {
 	if (ranges.length === 0) return [];
@@ -73,8 +80,12 @@ function findBraceRanges(lines: string[], openPattern: RegExp, minBody: number):
 		const start = i;
 		for (let j = i; j < lines.length; j++) {
 			for (const ch of lines[j]) {
-				if (ch === "{") { depth++; foundOpen = true; }
-				else if (ch === "}") { depth--; }
+				if (ch === "{") {
+					depth++;
+					foundOpen = true;
+				} else if (ch === "}") {
+					depth--;
+				}
 			}
 			if (foundOpen && depth <= 0) {
 				if (j - start - 1 >= minBody) ranges.push({ start: start + 1, end: j - 1 });
@@ -107,12 +118,14 @@ function blockCommentRanges(lines: string[], minComment: number): Range[] {
 	let i = 0;
 	while (i < lines.length) {
 		const idx = lines[i].indexOf("/*");
-		if (idx === -1 || lines[i].includes("*/", idx + 2)) { i++; continue; }
+		if (idx === -1 || lines[i].includes("*/", idx + 2)) {
+			i++;
+			continue;
+		}
 		const openLine = i;
 		let j = i + 1;
 		while (j < lines.length && !lines[j].includes("*/")) j++;
-		if (j < lines.length && j - openLine - 1 >= minComment)
-			ranges.push({ start: openLine + 1, end: j - 1 });
+		if (j < lines.length && j - openLine - 1 >= minComment) ranges.push({ start: openLine + 1, end: j - 1 });
 		i = j + 1;
 	}
 	return ranges;
@@ -125,10 +138,17 @@ const PY_IMPORT_RE = /^\s*(import\s|from\s+\S+\s+import\s)/;
 
 function importGroupRanges(lines: string[], pattern: RegExp): Range[] {
 	const groups: Array<{ start: number; end: number }> = [];
-	let gs = -1, last = -1;
+	let gs = -1,
+		last = -1;
 	for (let i = 0; i < lines.length; i++) {
-		if (pattern.test(lines[i])) { if (gs === -1) gs = i; last = i; }
-		else if (gs !== -1 && i > last) { groups.push({ start: gs, end: last }); gs = -1; last = -1; }
+		if (pattern.test(lines[i])) {
+			if (gs === -1) gs = i;
+			last = i;
+		} else if (gs !== -1 && i > last) {
+			groups.push({ start: gs, end: last });
+			gs = -1;
+			last = -1;
+		}
 	}
 	if (gs !== -1) groups.push({ start: gs, end: last });
 	const ranges: Range[] = [];
@@ -146,7 +166,8 @@ function pythonRanges(lines: string[], minBody: number): Range[] {
 		const m = /^(\s*)(async\s+)?def\s/.exec(lines[i]) || /^(\s*)class\s/.exec(lines[i]);
 		if (!m) continue;
 		const base = m[1].length;
-		let bs = -1, be = -1;
+		let bs = -1,
+			be = -1;
 		for (let j = i + 1; j < lines.length; j++) {
 			if (lines[j].trim() === "") continue;
 			const indent = lines[j].length - lines[j].trimStart().length;
@@ -180,22 +201,26 @@ function rustRanges(lines: string[], minBody: number): Range[] {
 
 function fullResult(language: string | null, totalLines: number, code: string): SummaryResult {
 	return {
-		language, totalLines, elided: false,
+		language,
+		totalLines,
+		elided: false,
 		segments: [{ kind: "kept", startLine: 1, endLine: totalLines, text: code }],
 		rendered: code,
 	};
 }
 
-export function summarizeCode(
-	code: string,
-	language: string | null,
-	options?: SummaryOptions,
-): SummaryResult {
+export function summarizeCode(code: string, language: string | null, options?: SummaryOptions): SummaryResult {
 	const minBody = options?.minBodyLines ?? 4;
 	const minComment = options?.minCommentLines ?? 6;
 
 	if (!code || code.trim() === "") {
-		return { language, totalLines: 0, elided: false, segments: [], rendered: "" };
+		return {
+			language,
+			totalLines: 0,
+			elided: false,
+			segments: [],
+			rendered: "",
+		};
 	}
 
 	const lines = code.split("\n");
@@ -227,13 +252,27 @@ export function summarizeCode(
 	let cursor = 0;
 	for (const r of ranges) {
 		if (cursor < r.start) {
-			segments.push({ kind: "kept", startLine: cursor + 1, endLine: r.start, text: lines.slice(cursor, r.start).join("\n") });
+			segments.push({
+				kind: "kept",
+				startLine: cursor + 1,
+				endLine: r.start,
+				text: lines.slice(cursor, r.start).join("\n"),
+			});
 		}
-		segments.push({ kind: "elided", startLine: r.start + 1, endLine: r.end + 1 });
+		segments.push({
+			kind: "elided",
+			startLine: r.start + 1,
+			endLine: r.end + 1,
+		});
 		cursor = r.end + 1;
 	}
 	if (cursor < totalLines) {
-		segments.push({ kind: "kept", startLine: cursor + 1, endLine: totalLines, text: lines.slice(cursor).join("\n") });
+		segments.push({
+			kind: "kept",
+			startLine: cursor + 1,
+			endLine: totalLines,
+			text: lines.slice(cursor).join("\n"),
+		});
 	}
 
 	// Render
@@ -243,5 +282,11 @@ export function summarizeCode(
 		else parts.push(`  ... ${seg.endLine - seg.startLine + 1} lines elided ...`);
 	}
 
-	return { language, totalLines, elided: true, segments, rendered: parts.join("\n") };
+	return {
+		language,
+		totalLines,
+		elided: true,
+		segments,
+		rendered: parts.join("\n"),
+	};
 }

package/src/runtime/compact-stages/index.ts

@@ -5,9 +5,19 @@
  * `../../runtime/compact-stages/`) rather than reaching into individual
  * stage files, so internal refactors do not break the public surface.
  */
-export { AnsiStripStage, ANSI_STRIP_STAGE } from "./ansi-strip-stage.ts";
-export { BlankCollapseStage, BLANK_COLLAPSE_STAGE } from "./blank-collapse-stage.ts";
-export { DeduplicateStage, DEDUPLICATE_STAGE } from "./deduplicate-stage.ts";
-export { TruncationStage, type TruncationMarkerConfig } from "./truncation-stage.ts";
+export { ANSI_STRIP_STAGE, AnsiStripStage } from "./ansi-strip-stage.ts";
+export {
+	BLANK_COLLAPSE_STAGE,
+	BlankCollapseStage,
+} from "./blank-collapse-stage.ts";
+export { DEDUPLICATE_STAGE, DeduplicateStage } from "./deduplicate-stage.ts";
 export { HeadSnapStage, type HeadSnapStageConfig } from "./head-snap-stage.ts";
-export { TailCaptureStage, TAIL_CAPTURE_STREAM_STAGE, type TailCaptureStageConfig } from "./tail-capture-stage.ts";
+export {
+	TAIL_CAPTURE_STREAM_STAGE,
+	TailCaptureStage,
+	type TailCaptureStageConfig,
+} from "./tail-capture-stage.ts";
+export {
+	type TruncationMarkerConfig,
+	TruncationStage,
+} from "./truncation-stage.ts";

package/src/runtime/compact-stages/tail-capture-stage.ts

@@ -42,7 +42,9 @@ export class TailCaptureStage implements ICompactStage {
 		const hasChars = typeof config.maxChars === "number";
 		const hasBytes = typeof config.maxBytes === "number";
 		if (hasChars === hasBytes) {
-			throw new Error(`TailCaptureStage requires exactly one of maxChars or maxBytes (got chars=${config.maxChars} bytes=${config.maxBytes})`);
+			throw new Error(
+				`TailCaptureStage requires exactly one of maxChars or maxBytes (got chars=${config.maxChars} bytes=${config.maxBytes})`,
+			);
 		}
 		if (hasChars && (config.maxChars as number) <= 0) throw new Error(`TailCaptureStage: maxChars must be > 0, got ${config.maxChars}`);
 		if (hasBytes && (config.maxBytes as number) <= 0) throw new Error(`TailCaptureStage: maxBytes must be > 0, got ${config.maxBytes}`);
@@ -69,4 +71,7 @@ export class TailCaptureStage implements ICompactStage {
 }
 
 /** Singleton: char-cap tail capture with no marker (for `stream-preview.ts` textBuffer). */
-export const TAIL_CAPTURE_STREAM_STAGE = new TailCaptureStage({ maxChars: 16_384, id: "tail-capture-stream" });
+export const TAIL_CAPTURE_STREAM_STAGE = new TailCaptureStage({
+	maxChars: 16_384,
+	id: "tail-capture-stream",
+});

package/src/runtime/compact-stages/truncation-stage.ts

@@ -41,7 +41,10 @@ export class TruncationStage implements ICompactStage {
 	private readonly marker: TruncationMarkerConfig;
 	constructor(
 		maxChars: number,
-		opts: { preserveImportant?: boolean; marker?: Partial<TruncationMarkerConfig> } = {},
+		opts: {
+			preserveImportant?: boolean;
+			marker?: Partial<TruncationMarkerConfig>;
+		} = {},
 	) {
 		if (!Number.isFinite(maxChars) || maxChars <= 0) {
 			throw new Error(`TruncationStage: maxChars must be a positive finite number, got ${maxChars}`);

package/src/runtime/compaction-summary.ts

@@ -5,13 +5,18 @@
  * Distilled from pi-autoresearch's compaction-summary pattern.
  */
 
-class GiantLineFallbackError extends Error { constructor() { super("GIANT_LINE_FALLBACK"); this.name = "GiantLineFallbackError"; } }
+class GiantLineFallbackError extends Error {
+	constructor() {
+		super("GIANT_LINE_FALLBACK");
+		this.name = "GiantLineFallbackError";
+	}
+}
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { readJsonFile } from "../state/atomic-write.ts";
 import type { TeamEvent } from "../state/event-log.ts";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 
 /** Maximum number of events to read from the tail of events.jsonl. */
 const MAX_TAIL_EVENTS = 100;
@@ -57,7 +62,10 @@ function readTailLines(filePath: string, maxLines: number): string[] {
 		// For small files, just read everything
 		if (fileSize <= TAIL_MAX_READ) {
 			const content = fs.readFileSync(filePath, "utf-8");
-			return content.split("\n").filter((line) => line.trim().length > 0).slice(-maxLines);
+			return content
+				.split("\n")
+				.filter((line) => line.trim().length > 0)
+				.slice(-maxLines);
 		}
 
 		// For large files, read only the last chunk.
@@ -98,7 +106,10 @@ function readTailLines(filePath: string, maxLines: number): string[] {
 			const stat = fs.statSync(filePath);
 			if (stat.size > MAX_FALLBACK_READ) return [];
 			const content = fs.readFileSync(filePath, "utf-8");
-			return content.split("\n").filter((line) => line.trim().length > 0).slice(-maxLines);
+			return content
+				.split("\n")
+				.filter((line) => line.trim().length > 0)
+				.slice(-maxLines);
 		}
 		return [];
 	}
@@ -212,9 +223,7 @@ export function buildCompactionSummary(stateRoot: string): string {
 	}
 
 	// Section: Recent Task Results
-	const completedTasks = tasks
-		.filter((t) => t.status === "completed" || t.status === "failed")
-		.slice(-MAX_RECENT_RESULTS);
+	const completedTasks = tasks.filter((t) => t.status === "completed" || t.status === "failed").slice(-MAX_RECENT_RESULTS);
 
 	if (completedTasks.length > 0) {
 		sections.push("");
@@ -242,9 +251,7 @@ export function buildCompactionSummary(stateRoot: string): string {
 
 	// Section: Next Steps (pending/queued tasks)
 	const pendingStatuses = new Set(["queued", "waiting", "running"]);
-	const pendingTasks = tasks.filter(
-		(t) => pendingStatuses.has(t.status),
-	);
+	const pendingTasks = tasks.filter((t) => pendingStatuses.has(t.status));
 	if (pendingTasks.length > 0) {
 		sections.push("");
 		sections.push("## Next Steps");

package/src/runtime/completion-guard.ts

@@ -1,5 +1,5 @@
 import * as fs from "node:fs";
-import type { TeamTaskState, TeamRunManifest } from "../state/types.ts";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 
 // ============================================================================
 // Phase 1.2: Completion Mutation Guard — detects tasks that claim success but
@@ -21,13 +21,27 @@ export interface CompletionMutationGuardResult {
 }
 
 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;
+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;
+	return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;
 }
 
 function commandText(value: unknown): string {
@@ -60,7 +74,10 @@ export function collectToolCallsFromEvent(event: unknown): Array<{ tool: string;
 	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")) {
+	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;
@@ -69,7 +86,8 @@ export function collectToolCallsFromEvent(event: unknown): Array<{ tool: string;
 			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 });
+			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;
@@ -94,7 +112,11 @@ export function evaluateCompletionMutationGuard(input: CompletionMutationGuardIn
 		const trimmed = line.trim();
 		if (!trimmed) continue;
 		let event: unknown;
-		try { event = JSON.parse(trimmed); } catch { continue; }
+		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;
@@ -133,10 +155,7 @@ function isTrivialError(error: string | undefined): boolean {
 	return error.trim().length === 0;
 }
 
-export function verifyTaskCompletion(
-	task: TeamTaskState,
-	manifest: TeamRunManifest,
-): CompletionVerifyResult {
+export function verifyTaskCompletion(task: TeamTaskState, manifest: TeamRunManifest): CompletionVerifyResult {
 	const warnings: string[] = [];
 	let greenLevel = 0;
 
@@ -156,9 +175,7 @@ export function verifyTaskCompletion(
 	}
 
 	// Check 4: For implementation tasks, verify artifacts were actually produced
-	const runArtifacts = manifest.artifacts.filter(
-		(a) => a.producer === task.id || a.producer === task.agent,
-	);
+	const runArtifacts = manifest.artifacts.filter((a) => a.producer === task.id || a.producer === task.agent);
 	if (runArtifacts.length > 0) {
 		greenLevel += 1;
 	} else if (greenLevel < 3) {