pi-crew 0.9.16 → 0.9.18

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

@@ -1,12 +1,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import { DEFAULT_OUTPUT_CONTEXT } from "../config/defaults.ts";
 import { writeArtifact } from "../state/artifact-store.ts";
+import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../state/types.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";
 import { applyCompactPipeline } from "./compact-pipeline.ts";
 import { ANSI_STRIP_STAGE, BLANK_COLLAPSE_STAGE, TruncationStage } from "./compact-stages/index.ts";
+import { DEFAULT_PRUNE_CONFIG, type FileEditEvent, pruneToolOutputs, type ToolResultEntry } from "./tool-output-pruner.ts";
 
 export interface DependencyContextEntry {
 	taskId: string;
@@ -23,6 +24,21 @@ export interface DependencyContextEntry {
 	structuredResults?: Record<string, unknown>;
 	artifactsProduced?: string[];
 	usage?: { inputTokens: number; outputTokens: number; durationMs: number };
+	/** L4 total-budget: byte length of `resultSummary` (UTF-16 code units).
+	 *  Populated by `collectDependencyOutputContext` so the trim step can sum
+	 *  per-dep sizes without re-computing. Set to 0 when the dep is
+	 *  downgraded to path-only. Optional for backward-compat with existing
+	 *  test fixtures that build entry objects directly. */
+	inlineBytes?: number;
+	/** L4 priority sort key: derived from the upstream task's `finishedAt`
+	 *  (ms epoch). More recent = higher priority in the trim. Undefined
+	 *  when the dep task never finished (treated as 0). */
+	recency?: number;
+	/** L4 priority sort key: heuristic relevance in [0, 1]. Higher = more
+	 *  relevant. Derived from the upstream task's `dependsOn` position in
+	 *  the workflow (earlier deps = higher relevance because they were
+	 *  explicitly listed first). Defaults to 0.5 (neutral) when unknown. */
+	relevance?: number;
 }
 
 export interface DependencyOutputContext {
@@ -34,7 +50,12 @@ export interface DependencyOutputContext {
 	 * and the path is exposed via `fullOutputPath` so the downstream worker
 	 * can `read` it back if it needs the dropped middle.
 	 */
-	sharedReads: Array<{ name: string; path: string; content: string; fullOutputPath?: string }>;
+	sharedReads: Array<{
+		name: string;
+		path: string;
+		content: string;
+		fullOutputPath?: string;
+	}>;
 }
 
 function containedExists(filePath: string, baseDir?: string): boolean {
@@ -53,8 +74,26 @@ function containedExists(filePath: string, baseDir?: string): boolean {
  * 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.
+ *
+ * Single source of truth: DEFAULT_OUTPUT_CONTEXT.maxResultInlineBytes
+ * (Round 25 / L6 — moved from hardcoded constant to config/defaults.ts).
+ */
+export const MAX_RESULT_INLINE_BYTES = DEFAULT_OUTPUT_CONTEXT.maxResultInlineBytes;
+
+/**
+ * L4 total-budget: cap on the SUM of inline bytes across ALL dependencies
+ * for a single downstream worker. 96KB is 3× the per-dep cap (3 × 32KB).
+ * Sized so a worker with 3 large dep outputs (e.g. 3 × 32KB truncated)
+ * stays below budget and the typical 1–2 dep case never hits the trim.
+ * When the sum exceeds this, the trim step in
+ * {@link collectDependencyOutputContext} downgrades the lowest-priority
+ * deps to path-only (resultPath + fullOutputPath, no inline text) so the
+ * downstream worker can `read` the full content on demand. The tee
+ * write happens BEFORE the trim, so fullOutputPath is always available.
+ *
+ * Single source of truth: DEFAULT_OUTPUT_CONTEXT.maxTotalDepInlineBytes.
  */
-export const MAX_RESULT_INLINE_BYTES = 32_000;
+export const MAX_TOTAL_DEP_INLINE_BYTES = DEFAULT_OUTPUT_CONTEXT.maxTotalDepInlineBytes;
 
 /**
  * Tee-recovery multiplier (R2). A shared artifact is teed to disk — so the
@@ -63,8 +102,10 @@ export const MAX_RESULT_INLINE_BYTES = 32_000;
  * (64 KB) to 1.25 (40 KB) so the 32–64 KB band, where the head+tail split
  * is already materially lossy for structured content, also gets a recovery
  * path instead of losing the middle forever.
+ *
+ * Single source of truth: DEFAULT_OUTPUT_CONTEXT.teeThresholdMultiplier.
  */
-export const TEE_THRESHOLD_MULTIPLIER = 1.25;
+export const TEE_THRESHOLD_MULTIPLIER = DEFAULT_OUTPUT_CONTEXT.teeThresholdMultiplier;
 
 /**
  * Read a file and return its content, truncating to a head+tail slice if it
@@ -161,7 +202,12 @@ export function readIfSmallWithTee(
 				BLANK_COLLAPSE_STAGE,
 				new TruncationStage(maxChars, {
 					preserveImportant: true,
-					marker: { verb: "truncated", unit: "chars", headSeparator: "\n\n", tailSeparator: "\n" },
+					marker: {
+						verb: "truncated",
+						unit: "chars",
+						headSeparator: "\n\n",
+						tailSeparator: "\n",
+					},
 				}),
 			]);
 			return fullOutputPath ? { content: result.text, fullOutputPath } : { content: result.text };
@@ -190,7 +236,8 @@ export function readIfSmall(filePath: string, baseDir?: string): string | undefi
 
 function safeSharedName(name: string): string {
 	const normalized = name.replaceAll("\\", "/").replace(/^\.\/+/, "");
-	if (!normalized || normalized.split("/").some((segment) => segment === "..") || path.isAbsolute(normalized)) throw new Error(`Invalid shared artifact name: ${name}`);
+	if (!normalized || normalized.split("/").some((segment) => segment === "..") || path.isAbsolute(normalized))
+		throw new Error(`Invalid shared artifact name: ${name}`);
 	return normalized;
 }
 
@@ -232,6 +279,66 @@ function aggregateUsage(task: TeamTaskState): DependencyContextEntry["usage"] {
 	return { inputTokens, outputTokens, durationMs };
 }
 
+/**
+ * L4 total-budget trim. When the SUM of `inlineBytes` across all deps
+ * exceeds {@link MAX_TOTAL_DEP_INLINE_BYTES}, downgrade the lowest-priority
+ * deps to path-only (clear inline text, keep resultPath + fullOutputPath)
+ * so the downstream worker can `read` the full content on demand.
+ *
+ * Priority order (highest kept first):
+ *   1. status in {failed, needs-attention} (worker MUST see the failure)
+ *   2. recency descending (newer outputs more relevant)
+ *   3. relevance descending (workflow author-declared order)
+ *   4. tie-breaker: original array index (stable sort)
+ *
+ * Algorithm: sort by priority (descending), then walk top-down, keeping
+ * each dep until the running total would exceed the budget. The remaining
+ * deps are returned with `resultSummary=""` and `inlineBytes=0`; the
+ * `resultPath` and `fullOutputPath` fields are preserved so the worker
+ * can `read` them. Stable: the original input order is preserved for
+ * entries at the same priority level.
+ *
+ * Pure function — no I/O. Exported for unit testing.
+ */
+export function enforceDependencyInlineBudget(dependencies: DependencyContextEntry[]): DependencyContextEntry[] {
+	if (dependencies.length === 0) return dependencies;
+	const totalInlineBytes = dependencies.reduce((sum, dep) => sum + (dep.inlineBytes ?? 0), 0);
+	if (totalInlineBytes <= MAX_TOTAL_DEP_INLINE_BYTES) return dependencies;
+	// Build an index-keyed array so we can sort AND preserve the original
+	// position (for stable output order). Each entry gets a numeric
+	// priority score (higher = more important) and a stable tie-breaker.
+	const indexed = dependencies.map((dep, originalIndex) => {
+		const highPriority = dep.status === "failed" || dep.status === "needs-attention";
+		// Score: (highPriority?1000:0) + (recency/1e10) + (relevance*10) - (index*0.001)
+		// The 1000 base ensures high-priority wins even with no recency/relevance.
+		// recency/1e10 keeps it in [0, 1] for ms timestamps up to 1e13 (~year 2286).
+		// relevance*10 puts it in [0, 10].
+		// index*0.001 keeps stable order within the same bucket.
+		const score = (highPriority ? 1000 : 0) + (dep.recency ?? 0) / 1e10 + (dep.relevance ?? 0) * 10 - originalIndex * 0.001;
+		return { dep, originalIndex, score };
+	});
+	const sorted = [...indexed].sort((a, b) => b.score - a.score);
+	let used = 0;
+	const keepSet = new Set<number>(); // originalIndex values to KEEP inline
+	for (const item of sorted) {
+		const next = used + (item.dep.inlineBytes ?? 0);
+		if (next <= MAX_TOTAL_DEP_INLINE_BYTES) {
+			used = next;
+			keepSet.add(item.originalIndex);
+		}
+	}
+	// Return entries in original order; downgrade ones NOT in keepSet.
+	return dependencies.map((dep, originalIndex) => {
+		if (keepSet.has(originalIndex)) return dep;
+		return {
+			...dep,
+			resultSummary: "",
+			structuredResults: undefined,
+			inlineBytes: 0,
+		};
+	});
+}
+
 /**
  * Apply staleness-aware pruning to shared reads before they are injected
  * into a downstream worker's prompt. Converts shared reads to generic
@@ -273,66 +380,123 @@ function pruneSharedReads(
 			if (typeof artifact !== "string") continue;
 			// Map artifact path (relative to artifactsRoot) to absolute and
 			// check against read targets.
-			fileEdits.push({ target: path.resolve(artifactsRoot, artifact), index: reads.length + depIndex });
+			fileEdits.push({
+				target: path.resolve(artifactsRoot, 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 }));
+	return pruned.results.map((entry, index) => ({
+		...reads[index]!,
+		content: entry.content,
+	}));
 }
 
-export function collectDependencyOutputContext(manifest: TeamRunManifest, tasks: TeamTaskState[], task: TeamTaskState, step: WorkflowStep): DependencyOutputContext {
+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 fullOutputPath = item.resultArtifact ? teePathForArtifact(manifest.artifactsRoot, task.id, item.id) : undefined;
-		const teeResult = item.resultArtifact
-			? readIfSmallWithTee(item.resultArtifact.path, { baseDir: manifest.artifactsRoot, ...(fullOutputPath ? { tee: { fullOutputPath } } : {}) })
-			: undefined;
-		const resultText = teeResult?.content;
-		return {
-			taskId: item.id,
-			role: item.role,
-			status: item.status,
-			resultSummary: resultText ?? "",
-			resultPath: item.resultArtifact?.path,
-			...(teeResult?.fullOutputPath ? { fullOutputPath: teeResult.fullOutputPath } : {}),
-			structuredResults: resultText ? tryParseJson(resultText) : undefined,
-			artifactsProduced: listTaskArtifacts(manifest, item.id),
-			usage: aggregateUsage(item),
-		};
-	});
-	const rawSharedReads = (step.reads === false ? [] : step.reads ?? []).map((name) => {
-		const filePath = sharedPath(manifest, name);
-		// P1-A tee-recovery: when the shared artifact is large enough that the
-		// 75/25 head+tail split is materially lossy (>2× MAX_RESULT_INLINE_BYTES),
-		// tee the full content to ${artifactsRoot}/tee/${taskId}-${name}.full.txt
-		// and expose the path so the downstream worker can `read` the full file
-		// if it needs the dropped middle. The truncated content is still
-		// included inline; tee is an enhancement, not a hard dependency. Tee
-		// write is best-effort (writeTeeFile swallows I/O errors and the result
-		// simply omits fullOutputPath in that case).
-		const teePath = teePathForArtifact(manifest.artifactsRoot, task.id, name);
-		const teeResult = readIfSmallWithTee(filePath, {
-			baseDir: path.resolve(manifest.artifactsRoot, "shared"),
-			tee: { fullOutputPath: teePath },
+	// L4 priority keys: build (a) the position of each dep in the workflow's
+	// `dependsOn:` list (earlier = more relevant because the workflow author
+	// declared it first), and (b) the finishedAt timestamp of each dep task
+	// (used for recency sort in the trim step). Both are looked up against
+	// `task.dependsOn` (the declared order) and `tasks` (finished timestamps).
+	const declaredOrder = new Map<string, number>();
+	task.dependsOn.forEach((depId, index) => declaredOrder.set(depId, index));
+	const recencyByTaskId = new Map<string, number>();
+	for (const item of tasks) {
+		if (!item.finishedAt) continue;
+		const ms = new Date(item.finishedAt).getTime();
+		if (Number.isFinite(ms)) recencyByTaskId.set(item.id, ms);
+	}
+	const dependencies = task.dependsOn
+		.map((dep) => byStep.get(dep) ?? byId.get(dep))
+		.filter((item): item is TeamTaskState => Boolean(item))
+		.map((item) => {
+			const fullOutputPath = item.resultArtifact ? teePathForArtifact(manifest.artifactsRoot, task.id, item.id) : undefined;
+			const teeResult = item.resultArtifact
+				? readIfSmallWithTee(item.resultArtifact.path, {
+						baseDir: manifest.artifactsRoot,
+						...(fullOutputPath ? { tee: { fullOutputPath } } : {}),
+					})
+				: undefined;
+			const resultText = teeResult?.content;
+			const inlineBytes = resultText?.length ?? 0;
+			// L4 priority keys: recency from the dep's finishedAt, relevance
+			// from the dep's declared position in `task.dependsOn` (inverted
+			// to [0,1]: position 0 → 1.0, position N → max(0, 1 - N*0.1)).
+			const position = declaredOrder.get(item.id) ?? declaredOrder.get(item.stepId ?? "") ?? 0;
+			const relevance = Math.max(0, 1 - position * 0.1);
+			return {
+				taskId: item.id,
+				role: item.role,
+				status: item.status,
+				resultSummary: resultText ?? "",
+				resultPath: item.resultArtifact?.path,
+				...(teeResult?.fullOutputPath ? { fullOutputPath: teeResult.fullOutputPath } : {}),
+				structuredResults: resultText ? tryParseJson(resultText) : undefined,
+				artifactsProduced: listTaskArtifacts(manifest, item.id),
+				usage: aggregateUsage(item),
+				inlineBytes,
+				recency: recencyByTaskId.get(item.id),
+				relevance,
+			};
 		});
-		if (teeResult === undefined) return { name, path: filePath, content: "" };
-		const entry: { name: string; path: string; content: string; fullOutputPath?: string } = {
-			name,
-			path: filePath,
-			content: teeResult.content,
-		};
-		if (teeResult.fullOutputPath) entry.fullOutputPath = teeResult.fullOutputPath;
-		return entry;
-	}).filter((item) => item.content.trim().length > 0);
+	// L4 total-budget trim: when the SUM of inline bytes across all deps
+	// exceeds MAX_TOTAL_DEP_INLINE_BYTES, downgrade the lowest-priority
+	// deps to path-only (clear inline text, keep resultPath +
+	// fullOutputPath). The downstream worker can `read` the full content
+	// on demand. Priority order (highest kept first):
+	//   1. status in {failed, needs-attention} (worker MUST see the failure)
+	//   2. recency descending (newer outputs more relevant)
+	//   3. relevance descending (workflow author-declared order)
+	// Tie-breakers within the same priority bucket are stable: the
+	// declaration order in `task.dependsOn` (earlier = more relevant).
+	const trimmedDependencies = enforceDependencyInlineBudget(dependencies);
+	const rawSharedReads = (step.reads === false ? [] : (step.reads ?? []))
+		.map((name) => {
+			const filePath = sharedPath(manifest, name);
+			// P1-A tee-recovery: when the shared artifact is large enough that the
+			// 75/25 head+tail split is materially lossy (>2× MAX_RESULT_INLINE_BYTES),
+			// tee the full content to ${artifactsRoot}/tee/${taskId}-${name}.full.txt
+			// and expose the path so the downstream worker can `read` the full file
+			// if it needs the dropped middle. The truncated content is still
+			// included inline; tee is an enhancement, not a hard dependency. Tee
+			// write is best-effort (writeTeeFile swallows I/O errors and the result
+			// simply omits fullOutputPath in that case).
+			const teePath = teePathForArtifact(manifest.artifactsRoot, task.id, name);
+			const teeResult = readIfSmallWithTee(filePath, {
+				baseDir: path.resolve(manifest.artifactsRoot, "shared"),
+				tee: { fullOutputPath: teePath },
+			});
+			if (teeResult === undefined) return { name, path: filePath, content: "" };
+			const entry: {
+				name: string;
+				path: string;
+				content: string;
+				fullOutputPath?: string;
+			} = {
+				name,
+				path: filePath,
+				content: teeResult.content,
+			};
+			if (teeResult.fullOutputPath) entry.fullOutputPath = teeResult.fullOutputPath;
+			return entry;
+		})
+		.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, manifest.artifactsRoot);
-	return { dependencies, sharedReads };
+	const sharedReads = pruneSharedReads(rawSharedReads, trimmedDependencies, manifest.artifactsRoot);
+	return { dependencies: trimmedDependencies, sharedReads };
 }
 
 export function renderDependencyOutputContext(context: DependencyOutputContext): string {
@@ -340,7 +504,14 @@ export function renderDependencyOutputContext(context: DependencyOutputContext):
 	if (context.dependencies.length) {
 		parts.push("# Dependency Outputs", "");
 		for (const dep of context.dependencies) {
-			parts.push(`## ${dep.taskId} (${dep.role})`, `Status: ${dep.status}`, dep.resultPath ? `Result artifact: ${dep.resultPath}` : "", "", dep.resultSummary?.trim() || "(no result output)", "");
+			parts.push(
+				`## ${dep.taskId} (${dep.role})`,
+				`Status: ${dep.status}`,
+				dep.resultPath ? `Result artifact: ${dep.resultPath}` : "",
+				"",
+				dep.resultSummary?.trim() || "(no result output)",
+				"",
+			);
 			// P1-A dependency tee-recovery hint: when the dependency's result was
 			// materially truncated (>1.25× MAX_RESULT_INLINE_BYTES) the full RAW
 			// content was teed to fullOutputPath. Mirrors the sharedReads hint so the
@@ -348,7 +519,11 @@ export function renderDependencyOutputContext(context: DependencyOutputContext):
 			if (dep.fullOutputPath) parts.push(`Full output (if you need the missing middle): ${dep.fullOutputPath}`, "");
 			if (dep.structuredResults) parts.push("Structured results:", JSON.stringify(dep.structuredResults, null, 2), "");
 			if (dep.artifactsProduced?.length) parts.push(`Artifacts produced: ${dep.artifactsProduced.join(", ")}`, "");
-			if (dep.usage) parts.push(`Usage: ${dep.usage.inputTokens} input tokens, ${dep.usage.outputTokens} output tokens, ${dep.usage.durationMs}ms`, "");
+			if (dep.usage)
+				parts.push(
+					`Usage: ${dep.usage.inputTokens} input tokens, ${dep.usage.outputTokens} output tokens, ${dep.usage.durationMs}ms`,
+					"",
+				);
 		}
 	}
 	if (context.sharedReads.length) {
@@ -379,7 +554,11 @@ export function writeTaskSharedOutput(manifest: TeamRunManifest, step: WorkflowS
 	});
 }
 
-export function writeTaskInputsArtifact(manifest: TeamRunManifest, task: TeamTaskState, context: DependencyOutputContext): ArtifactDescriptor {
+export function writeTaskInputsArtifact(
+	manifest: TeamRunManifest,
+	task: TeamTaskState,
+	context: DependencyOutputContext,
+): ArtifactDescriptor {
 	return writeArtifact(manifest.artifactsRoot, {
 		kind: "metadata",
 		relativePath: `metadata/${task.id}.inputs.json`,
@@ -389,29 +568,34 @@ 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, manifest?.artifactsRoot) : undefined;
-		const hasBody = Boolean(body?.trim());
-		const expectedMissing = task.resultArtifact && !containedExists(task.resultArtifact.path, manifest?.artifactsRoot);
-		const status = task.status === "skipped"
-			? "SKIPPED"
-			: task.status === "failed"
-				? `FAILED${task.exitCode !== undefined ? ` (exit code ${task.exitCode ?? "null"})` : ""}${task.error ? `: ${task.error}` : ""}`
-				: expectedMissing
-					? `EMPTY OUTPUT (expected result artifact missing: ${task.resultArtifact?.path})`
-					: !hasBody
-						? "EMPTY OUTPUT (no textual response returned)"
-						: task.status.toUpperCase();
-		return [
-			`=== Task ${index + 1}: ${task.id} (${task.agent}) ===`,
-			`Status: ${status}`,
-			task.role ? `Role: ${task.role}` : "",
-			task.resultArtifact?.path ? `Result artifact: ${task.resultArtifact.path}` : "",
-			task.logArtifact?.path ? `Log artifact: ${task.logArtifact.path}` : "",
-			task.transcriptArtifact?.path ? `Transcript: ${task.transcriptArtifact.path}` : "",
-			task.usage ? `Usage: ${JSON.stringify(task.usage)}` : "",
-			"",
-			hasBody ? body!.trim() : status,
-		].filter(Boolean).join("\n");
-	}).join("\n\n");
+	return tasks
+		.map((task, index) => {
+			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"
+					? "SKIPPED"
+					: task.status === "failed"
+						? `FAILED${task.exitCode !== undefined ? ` (exit code ${task.exitCode ?? "null"})` : ""}${task.error ? `: ${task.error}` : ""}`
+						: expectedMissing
+							? `EMPTY OUTPUT (expected result artifact missing: ${task.resultArtifact?.path})`
+							: !hasBody
+								? "EMPTY OUTPUT (no textual response returned)"
+								: task.status.toUpperCase();
+			return [
+				`=== Task ${index + 1}: ${task.id} (${task.agent}) ===`,
+				`Status: ${status}`,
+				task.role ? `Role: ${task.role}` : "",
+				task.resultArtifact?.path ? `Result artifact: ${task.resultArtifact.path}` : "",
+				task.logArtifact?.path ? `Log artifact: ${task.logArtifact.path}` : "",
+				task.transcriptArtifact?.path ? `Transcript: ${task.transcriptArtifact.path}` : "",
+				task.usage ? `Usage: ${JSON.stringify(task.usage)}` : "",
+				"",
+				hasBody ? body!.trim() : status,
+			]
+				.filter(Boolean)
+				.join("\n");
+		})
+		.join("\n\n");
 }

package/src/runtime/task-packet.ts

@@ -1,5 +1,5 @@
 import * as path from "node:path";
-import type { TeamRunManifest, TaskPacket, TaskScope, VerificationContract } from "../state/types.ts";
+import type { TaskPacket, TaskScope, TeamRunManifest, VerificationContract } from "../state/types.ts";
 import type { WorkflowStep } from "../workflows/workflow-config.ts";
 import { generateTaskHashId } from "./task-id.ts";
 
@@ -10,7 +10,6 @@ import { generateTaskHashId } from "./task-id.ts";
 // See: SECURITY-ISSUES.md SEC-007
 // ═══════════════════════════════════════════════════════════════════════════
 
-
 /**
  * Sanitize workflow step task text to reduce injection risk.
  *
@@ -33,7 +32,7 @@ export function sanitizeTaskText(task: string): string {
 	// 2. Strip known prompt injection directive patterns
 	sanitized = sanitized.replace(
 		/^\s*(?:SYSTEM|INSTRUCTION|IGNORE(?:\s+ALL)?\s+INSTRUCTIONS|OVERRIDE|YOUR\s+ROLE\s+IS|MALICIOUS)\s*:.*$/gim,
-		""
+		"",
 	);
 
 	// 3. Strip base64/hex encoded command payloads
@@ -62,7 +61,7 @@ export interface TaskPacketValidationResult {
 }
 
 export function inferTaskScope(step: WorkflowStep): TaskScope {
-	const reads = step.reads === false ? [] : step.reads ?? [];
+	const reads = step.reads === false ? [] : (step.reads ?? []);
 	if (reads.length === 1) return "single_file";
 	if (reads.length > 1) return "module";
 	return "workspace";
@@ -78,7 +77,7 @@ export function defaultVerificationContract(step: WorkflowStep): VerificationCon
 
 export function buildTaskPacket(input: BuildTaskPacketInput): TaskPacket {
 	const scope = inferTaskScope(input.step);
-	const reads = input.step.reads === false ? [] : input.step.reads ?? [];
+	const reads = input.step.reads === false ? [] : (input.step.reads ?? []);
 	const scopePath = reads.length === 1 ? reads[0] : reads.length > 1 ? reads.join(", ") : undefined;
 	// SEC-007: Sanitize task text before inserting into task packet
 	const sanitizedTask = sanitizeTaskText(input.step.task);
@@ -87,11 +86,7 @@ export function buildTaskPacket(input: BuildTaskPacketInput): TaskPacket {
 	// Generate a deterministic hash-based task ID for traceability and logging.
 	// Uses goal + step ID + run ID as content parts.
 	// TODO: Once TaskPacket type gains a hashId field, include this in the packet.
-	const _taskHashId = generateTaskHashId([
-		input.manifest.goal,
-		input.step.id,
-		input.manifest.runId,
-	]);
+	const _taskHashId = generateTaskHashId([input.manifest.goal, input.step.id, input.manifest.runId]);
 
 	return {
 		objective: sanitizedTask.replaceAll("{goal}", sanitizedGoal),
@@ -99,11 +94,15 @@ export function buildTaskPacket(input: BuildTaskPacketInput): TaskPacket {
 		scopePath,
 		repo: path.basename(input.manifest.cwd) || input.manifest.cwd,
 		worktree: input.worktreePath,
-		branchPolicy: input.manifest.workspaceMode === "worktree" ? "Use the assigned task worktree and avoid modifying the leader checkout." : "Use the current checkout; do not create branches unless explicitly requested.",
+		branchPolicy:
+			input.manifest.workspaceMode === "worktree"
+				? "Use the assigned task worktree and avoid modifying the leader checkout."
+				: "Use the current checkout; do not create branches unless explicitly requested.",
 		acceptanceTests: [],
 		commitPolicy: "Do not commit unless explicitly requested by the user or workflow.",
 		reportingContract: "Report intended/changed files, verification evidence, blockers, conflict risks, and next recommended action.",
-		escalationPolicy: "Stop and report if scope is ambiguous, destructive action is needed, permissions are missing, verification cannot be completed, or edits may overlap with another worker/task.",
+		escalationPolicy:
+			"Stop and report if scope is ambiguous, destructive action is needed, permissions are missing, verification cannot be completed, or edits may overlap with another worker/task.",
 		constraints: [
 			"Stay within the assigned task scope.",
 			"Do not claim completion without verification evidence.",
@@ -265,12 +264,5 @@ export function parseHandoffFromOutput(output: string): ParsedHandoff {
 }
 
 export function renderTaskPacket(packet: TaskPacket): string {
-	return [
-		"# Task Packet",
-		"",
-		"```json",
-		JSON.stringify(packet, null, 2),
-		"```",
-		"",
-	].join("\n");
+	return ["# Task Packet", "", "```json", JSON.stringify(packet, null, 2), "```", ""].join("\n");
 }

package/src/runtime/task-quality.ts

@@ -104,7 +104,8 @@ function isResultDescriptive(task: TeamTaskState): boolean {
 		typeof task.diagnostics === "object" &&
 		typeof task.diagnostics.result === "string" &&
 		(task.diagnostics.result as string).trim().length > 0
-	) return true;
+	)
+		return true;
 
 	return false;
 }
@@ -138,22 +139,13 @@ function isDurationReasonable(task: TeamTaskState): boolean {
  * @param artifactsDir - Optional path to the run artifacts directory
  * @returns TaskQualityScore with numeric score, breakdown, and letter grade
  */
-export function computeTaskQuality(
-	task: TeamTaskState,
-	artifactsDir?: string,
-): TaskQualityScore {
+export function computeTaskQuality(task: TeamTaskState, artifactsDir?: string): TaskQualityScore {
 	const hasDiagnostics =
-		task.diagnostics !== undefined &&
-		typeof task.diagnostics === "object" &&
-		Object.keys(task.diagnostics).length > 0;
+		task.diagnostics !== undefined && typeof task.diagnostics === "object" && Object.keys(task.diagnostics).length > 0;
 
-	const hasMetrics =
-		task.metrics !== undefined &&
-		typeof task.metrics === "object" &&
-		Object.keys(task.metrics).length > 0;
+	const hasMetrics = task.metrics !== undefined && typeof task.metrics === "object" && Object.keys(task.metrics).length > 0;
 
-	const producedArtifacts =
-		artifactsDir !== undefined && hasTaskArtifacts(task.id, artifactsDir);
+	const producedArtifacts = artifactsDir !== undefined && hasTaskArtifacts(task.id, artifactsDir);
 
 	const hasDescription = isResultDescriptive(task);
 

package/src/runtime/task-runner/context-retrieval.ts

@@ -20,7 +20,7 @@ export interface RetrievalQuery {
 
 export interface RelevanceEvaluation {
 	path: string;
-	relevance: number;     // 0.0–1.0
+	relevance: number; // 0.0–1.0
 	reason: string;
 	missingContext: string[];
 }
@@ -45,11 +45,7 @@ export interface RetrievalResult {
  * @param keywords - Task-relevant keywords
  * @returns Relevance score 0.0–1.0
  */
-export function scoreRelevance(
-	filePath: string,
-	fileContent: string,
-	keywords: string[],
-): number {
+export function scoreRelevance(filePath: string, fileContent: string, keywords: string[]): number {
 	if (keywords.length === 0) return 0;
 
 	const pathLower = filePath.toLowerCase();
@@ -96,9 +92,7 @@ export function hasConverged(evaluations: RelevanceEvaluation[]): boolean {
 	if (highRelevance.length < CONVERGENCE_MIN_HIGH_RELEVANCE) return false;
 
 	// Check for critical gaps — any evaluation with empty missingContext
-	const criticalGaps = evaluations.some(
-		(e) => e.relevance < 0.3 && e.missingContext.length > 0,
-	);
+	const criticalGaps = evaluations.some((e) => e.relevance < 0.3 && e.missingContext.length > 0);
 
 	return !criticalGaps;
 }
@@ -115,10 +109,7 @@ export function hasConverged(evaluations: RelevanceEvaluation[]): boolean {
  * @param evaluations - Results from the current cycle
  * @returns Refined query for the next cycle
  */
-export function refineQuery(
-	query: RetrievalQuery,
-	evaluations: RelevanceEvaluation[],
-): RetrievalQuery {
+export function refineQuery(query: RetrievalQuery, evaluations: RelevanceEvaluation[]): RetrievalQuery {
 	const newKeywords = new Set(query.keywords);
 	const newExcludes = new Set(query.excludes);
 	const newFocusAreas = new Set(query.focusAreas ?? []);