pi-crew 0.1.51 → 0.2.0

package/src/runtime/cancellation.ts

@@ -1,61 +1,61 @@
-import type { OperationTerminalEvidence } from "../state/types.ts";
-
-export type CancellationReasonCode = "caller_cancelled" | "leader_interrupted" | "provider_timeout" | "worker_timeout" | "tool_timeout" | "shutdown" | "unknown";
-
-export interface CancellationReason {
-	code: CancellationReasonCode;
-	message: string;
-	cause?: unknown;
-}
-
-export function buildSyntheticTerminalEvidence(
-	operation: "worker" | "tool" | "model",
-	reason: CancellationReason,
-	startedAt?: string,
-): OperationTerminalEvidence {
-	return { operation, status: "cancelled", startedAt, finishedAt: new Date().toISOString(), reason };
-}
-
-const KNOWN_CODES: ReadonlySet<string> = new Set(["caller_cancelled", "leader_interrupted", "provider_timeout", "worker_timeout", "tool_timeout", "shutdown", "unknown"]);
-
-export class CrewCancellationError extends Error {
-	readonly reason: CancellationReason;
-
-	constructor(reason: CancellationReason) {
-		super(reason.message);
-		this.name = "CrewCancellationError";
-		this.reason = reason;
-	}
-}
-
-function reasonFromString(value: string): CancellationReason {
-	const trimmed = value.trim();
-	if (KNOWN_CODES.has(trimmed)) return { code: trimmed as CancellationReasonCode, message: `Cancelled: ${trimmed}` };
-	return { code: "caller_cancelled", message: trimmed || "Cancelled by caller." };
-}
-
-export function cancellationReasonFromUnknown(value: unknown): CancellationReason {
-	if (value instanceof CrewCancellationError) return value.reason;
-	if (value instanceof Error) return { code: "caller_cancelled", message: value.message || "Cancelled by caller.", cause: value };
-	if (typeof value === "string") return reasonFromString(value);
-	if (value && typeof value === "object" && !Array.isArray(value)) {
-		const record = value as { code?: unknown; reason?: unknown; message?: unknown; cause?: unknown };
-		const rawCode = typeof record.code === "string" ? record.code : typeof record.reason === "string" ? record.reason : undefined;
-		const code = rawCode && KNOWN_CODES.has(rawCode) ? rawCode as CancellationReasonCode : "caller_cancelled";
-		const message = typeof record.message === "string" && record.message.trim() ? record.message.trim() : `Cancelled: ${code}`;
-		return { code, message, cause: record.cause ?? value };
-	}
-	return { code: "caller_cancelled", message: "Cancelled by caller." };
-}
-
-export function cancellationReasonFromSignal(signal: AbortSignal | undefined): CancellationReason {
-	return cancellationReasonFromUnknown(signal?.reason);
-}
-
-export function cancellationErrorFromSignal(signal: AbortSignal | undefined): CrewCancellationError {
-	return new CrewCancellationError(cancellationReasonFromSignal(signal));
-}
-
-export function throwIfCancelled(signal: AbortSignal | undefined): void {
-	if (signal?.aborted) throw cancellationErrorFromSignal(signal);
-}
+import type { OperationTerminalEvidence } from "../state/types.ts";
+
+export type CancellationReasonCode = "caller_cancelled" | "leader_interrupted" | "provider_timeout" | "worker_timeout" | "tool_timeout" | "shutdown" | "unknown";
+
+export interface CancellationReason {
+	code: CancellationReasonCode;
+	message: string;
+	cause?: unknown;
+}
+
+export function buildSyntheticTerminalEvidence(
+	operation: "worker" | "tool" | "model",
+	reason: CancellationReason,
+	startedAt?: string,
+): OperationTerminalEvidence {
+	return { operation, status: "cancelled", startedAt, finishedAt: new Date().toISOString(), reason };
+}
+
+const KNOWN_CODES: ReadonlySet<string> = new Set(["caller_cancelled", "leader_interrupted", "provider_timeout", "worker_timeout", "tool_timeout", "shutdown", "unknown"]);
+
+export class CrewCancellationError extends Error {
+	readonly reason: CancellationReason;
+
+	constructor(reason: CancellationReason) {
+		super(reason.message);
+		this.name = "CrewCancellationError";
+		this.reason = reason;
+	}
+}
+
+function reasonFromString(value: string): CancellationReason {
+	const trimmed = value.trim();
+	if (KNOWN_CODES.has(trimmed)) return { code: trimmed as CancellationReasonCode, message: `Cancelled: ${trimmed}` };
+	return { code: "caller_cancelled", message: trimmed || "Cancelled by caller." };
+}
+
+export function cancellationReasonFromUnknown(value: unknown): CancellationReason {
+	if (value instanceof CrewCancellationError) return value.reason;
+	if (value instanceof Error) return { code: "caller_cancelled", message: value.message || "Cancelled by caller.", cause: value };
+	if (typeof value === "string") return reasonFromString(value);
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		const record = value as { code?: unknown; reason?: unknown; message?: unknown; cause?: unknown };
+		const rawCode = typeof record.code === "string" ? record.code : typeof record.reason === "string" ? record.reason : undefined;
+		const code = rawCode && KNOWN_CODES.has(rawCode) ? rawCode as CancellationReasonCode : "caller_cancelled";
+		const message = typeof record.message === "string" && record.message.trim() ? record.message.trim() : `Cancelled: ${code}`;
+		return { code, message, cause: record.cause ?? value };
+	}
+	return { code: "caller_cancelled", message: "Cancelled by caller." };
+}
+
+export function cancellationReasonFromSignal(signal: AbortSignal | undefined): CancellationReason {
+	return cancellationReasonFromUnknown(signal?.reason);
+}
+
+export function cancellationErrorFromSignal(signal: AbortSignal | undefined): CrewCancellationError {
+	return new CrewCancellationError(cancellationReasonFromSignal(signal));
+}
+
+export function throwIfCancelled(signal: AbortSignal | undefined): void {
+	if (signal?.aborted) throw cancellationErrorFromSignal(signal);
+}

package/src/runtime/capability-inventory.ts

@@ -1,116 +1,116 @@
-import type { AgentConfig, ResourceSource } from "../agents/agent-config.ts";
-import { discoverAgents } from "../agents/discover-agents.ts";
-import { discoverTeams } from "../teams/discover-teams.ts";
-import { discoverWorkflows } from "../workflows/discover-workflows.ts";
-import { discoverSkills } from "../skills/discover-skills.ts";
-import type { PiTeamsConfig } from "../config/config.ts";
-
-export type CapabilityKind = "team" | "workflow" | "agent" | "skill" | "tool" | "runtime";
-export type CapabilitySource = "builtin" | "project" | "user" | "package" | "git";
-export type CapabilityState = "active" | "disabled" | "shadowed" | "missing";
-
-export interface CapabilityItem {
-	id: string;
-	kind: CapabilityKind;
-	name: string;
-	description: string;
-	source: CapabilitySource;
-	path?: string;
-	state: CapabilityState;
-	disabledReason?: string;
-	shadowedBy?: string;
-}
-
-function normalizeAgents(agents: AgentConfig[], source: CapabilitySource, disabledIds: Set<string>): CapabilityItem[] {
-	return agents.map((agent) => {
-		const id = `agent:${agent.name}`;
-		const configDisabled = disabledIds.has(id);
-		const agentDisabled = agent.disabled || configDisabled;
-		return {
-			id,
-			kind: "agent" as const,
-			name: agent.name,
-			description: agent.description,
-			source,
-			path: agent.filePath,
-			state: agentDisabled ? "disabled" : "active",
-			disabledReason: configDisabled ? "disabled by policy" : agent.disabled ? "disabled in config" : undefined,
-		};
-	});
-}
-
-function normalizeSkills(cwd: string, disabledIds: Set<string>): CapabilityItem[] {
-	const skills = discoverSkills(cwd);
-	return skills.map((skill) => {
-		const id = `skill:${skill.name}`;
-		const configDisabled = disabledIds.has(id);
-		return {
-			id,
-			kind: "skill" as const,
-			name: skill.name,
-			description: skill.description,
-			source: skill.source as CapabilitySource,
-			path: skill.path,
-			state: configDisabled ? "disabled" : "active",
-			disabledReason: configDisabled ? "disabled by policy" : undefined,
-		};
-	});
-}
-
-function normalizeTeams(cwd: string, disabledIds: Set<string>): CapabilityItem[] {
-	const result = discoverTeams(cwd);
-	return [...result.builtin, ...result.user, ...result.project].map((team) => {
-		const id = `team:${team.name}`;
-		const configDisabled = disabledIds.has(id);
-		return {
-			id,
-			kind: "team" as const,
-			name: team.name,
-			description: team.description,
-			source: team.source as CapabilitySource,
-			path: team.filePath,
-			state: configDisabled ? "disabled" : "active",
-			disabledReason: configDisabled ? "disabled by policy" : undefined,
-		};
-	});
-}
-
-function normalizeWorkflows(cwd: string, disabledIds: Set<string>): CapabilityItem[] {
-	const result = discoverWorkflows(cwd);
-	return [...result.builtin, ...result.user, ...result.project].map((workflow) => {
-		const id = `workflow:${workflow.name}`;
-		const configDisabled = disabledIds.has(id);
-		return {
-			id,
-			kind: "workflow" as const,
-			name: workflow.name,
-			description: workflow.description,
-			source: workflow.source as CapabilitySource,
-			path: workflow.filePath,
-			state: configDisabled ? "disabled" : "active",
-			disabledReason: configDisabled ? "disabled by policy" : undefined,
-		};
-	});
-}
-
-export function buildCapabilityInventory(cwd: string, config?: PiTeamsConfig): CapabilityItem[] {
-	const disabledIds = new Set<string>(config?.policy?.disabledCapabilities ?? []);
-	const agents = discoverAgents(cwd);
-	const items = [
-		...normalizeTeams(cwd, disabledIds),
-		...normalizeWorkflows(cwd, disabledIds),
-		...normalizeAgents([...agents.builtin, ...agents.user, ...agents.project], "builtin", disabledIds),
-		...normalizeSkills(cwd, disabledIds),
-	];
-
-	// Mark shadowed resources: project/user items with same kind:name as a builtin
-	const builtinNames = new Set(items.filter((item) => item.source === "builtin" || item.source === "package").map((item) => `${item.kind}:${item.name}`));
-	for (const item of items) {
-		if (item.source !== "builtin" && item.source !== "package" && builtinNames.has(`${item.kind}:${item.name}`)) {
-			item.state = "shadowed";
-			item.shadowedBy = `builtin:${item.kind}:${item.name}`;
-		}
-	}
-
-	return items.sort((a, b) => a.id.localeCompare(b.id));
-}
+import type { AgentConfig, ResourceSource } from "../agents/agent-config.ts";
+import { discoverAgents } from "../agents/discover-agents.ts";
+import { discoverTeams } from "../teams/discover-teams.ts";
+import { discoverWorkflows } from "../workflows/discover-workflows.ts";
+import { discoverSkills } from "../skills/discover-skills.ts";
+import type { PiTeamsConfig } from "../config/config.ts";
+
+export type CapabilityKind = "team" | "workflow" | "agent" | "skill" | "tool" | "runtime";
+export type CapabilitySource = "builtin" | "project" | "user" | "package" | "git";
+export type CapabilityState = "active" | "disabled" | "shadowed" | "missing";
+
+export interface CapabilityItem {
+	id: string;
+	kind: CapabilityKind;
+	name: string;
+	description: string;
+	source: CapabilitySource;
+	path?: string;
+	state: CapabilityState;
+	disabledReason?: string;
+	shadowedBy?: string;
+}
+
+function normalizeAgents(agents: AgentConfig[], source: CapabilitySource, disabledIds: Set<string>): CapabilityItem[] {
+	return agents.map((agent) => {
+		const id = `agent:${agent.name}`;
+		const configDisabled = disabledIds.has(id);
+		const agentDisabled = agent.disabled || configDisabled;
+		return {
+			id,
+			kind: "agent" as const,
+			name: agent.name,
+			description: agent.description,
+			source,
+			path: agent.filePath,
+			state: agentDisabled ? "disabled" : "active",
+			disabledReason: configDisabled ? "disabled by policy" : agent.disabled ? "disabled in config" : undefined,
+		};
+	});
+}
+
+function normalizeSkills(cwd: string, disabledIds: Set<string>): CapabilityItem[] {
+	const skills = discoverSkills(cwd);
+	return skills.map((skill) => {
+		const id = `skill:${skill.name}`;
+		const configDisabled = disabledIds.has(id);
+		return {
+			id,
+			kind: "skill" as const,
+			name: skill.name,
+			description: skill.description,
+			source: skill.source as CapabilitySource,
+			path: skill.path,
+			state: configDisabled ? "disabled" : "active",
+			disabledReason: configDisabled ? "disabled by policy" : undefined,
+		};
+	});
+}
+
+function normalizeTeams(cwd: string, disabledIds: Set<string>): CapabilityItem[] {
+	const result = discoverTeams(cwd);
+	return [...result.builtin, ...result.user, ...result.project].map((team) => {
+		const id = `team:${team.name}`;
+		const configDisabled = disabledIds.has(id);
+		return {
+			id,
+			kind: "team" as const,
+			name: team.name,
+			description: team.description,
+			source: team.source as CapabilitySource,
+			path: team.filePath,
+			state: configDisabled ? "disabled" : "active",
+			disabledReason: configDisabled ? "disabled by policy" : undefined,
+		};
+	});
+}
+
+function normalizeWorkflows(cwd: string, disabledIds: Set<string>): CapabilityItem[] {
+	const result = discoverWorkflows(cwd);
+	return [...result.builtin, ...result.user, ...result.project].map((workflow) => {
+		const id = `workflow:${workflow.name}`;
+		const configDisabled = disabledIds.has(id);
+		return {
+			id,
+			kind: "workflow" as const,
+			name: workflow.name,
+			description: workflow.description,
+			source: workflow.source as CapabilitySource,
+			path: workflow.filePath,
+			state: configDisabled ? "disabled" : "active",
+			disabledReason: configDisabled ? "disabled by policy" : undefined,
+		};
+	});
+}
+
+export function buildCapabilityInventory(cwd: string, config?: PiTeamsConfig): CapabilityItem[] {
+	const disabledIds = new Set<string>(config?.policy?.disabledCapabilities ?? []);
+	const agents = discoverAgents(cwd);
+	const items = [
+		...normalizeTeams(cwd, disabledIds),
+		...normalizeWorkflows(cwd, disabledIds),
+		...normalizeAgents([...agents.builtin, ...agents.user, ...agents.project], "builtin", disabledIds),
+		...normalizeSkills(cwd, disabledIds),
+	];
+
+	// Mark shadowed resources: project/user items with same kind:name as a builtin
+	const builtinNames = new Set(items.filter((item) => item.source === "builtin" || item.source === "package").map((item) => `${item.kind}:${item.name}`));
+	for (const item of items) {
+		if (item.source !== "builtin" && item.source !== "package" && builtinNames.has(`${item.kind}:${item.name}`)) {
+			item.state = "shadowed";
+			item.shadowedBy = `builtin:${item.kind}:${item.name}`;
+		}
+	}
+
+	return items.sort((a, b) => a.id.localeCompare(b.id));
+}

package/src/runtime/child-pi.ts

@@ -8,7 +8,7 @@ import { getPiSpawnCommand } from "./pi-spawn.ts";
 import { DEFAULT_CHILD_PI } from "../config/defaults.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { attachPostExitStdioGuard, trySignalChild } from "./post-exit-stdio-guard.ts";
-import { redactJsonLine } from "../utils/redaction.ts";
+import { redactJsonLine, SECRET_KEY_PATTERN } from "../utils/redaction.ts";
 
 const POST_EXIT_STDIO_GUARD_MS = DEFAULT_CHILD_PI.postExitStdioGuardMs;
 const FINAL_DRAIN_MS = DEFAULT_CHILD_PI.finalDrainMs;
@@ -110,9 +110,14 @@ export interface ChildPiRunResult {
 }
 
 export function buildChildPiSpawnOptions(cwd: string, env: NodeJS.ProcessEnv): SpawnOptions {
+	// Filter out env vars whose keys match secret patterns to avoid leaking credentials to child processes
+	const filteredEnv: Record<string, string> = {};
+	for (const [key, value] of Object.entries(env)) {
+		if (value !== undefined && !SECRET_KEY_PATTERN.test(key)) filteredEnv[key] = value;
+	}
 	return {
 		cwd,
-		env: { ...env, PI_CREW_PARENT_PID: String(process.pid) },
+		env: { ...filteredEnv, PI_CREW_PARENT_PID: String(process.pid) },
 		stdio: ["ignore", "pipe", "pipe"],
 		detached: process.platform !== "win32",
 		windowsHide: true,

package/src/runtime/compaction-summary.ts

@@ -0,0 +1,271 @@
+/**
+ * Deterministic compaction summary — builds a markdown summary of a pi-crew run
+ * from manifest.json, tasks.json, and the tail of events.jsonl.
+ *
+ * Distilled from pi-autoresearch's compaction-summary pattern.
+ */
+
+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";
+
+/** Maximum number of events to read from the tail of events.jsonl. */
+const MAX_TAIL_EVENTS = 100;
+
+/** Maximum number of completed tasks to include in the "Recent Results" section. */
+const MAX_RECENT_RESULTS = 10;
+
+/** Paths relevant to building a compaction summary for a run. */
+export interface SummaryPaths {
+	manifestPath: string;
+	tasksPath: string;
+	eventsPath: string;
+	stateRoot: string;
+}
+
+/**
+ * Derive the standard summary-relevant paths from a state root directory.
+ * Mirrors pi-autoresearch's `autoresearchSummaryPathsFor()`.
+ */
+export function summaryPathsFor(stateRoot: string): SummaryPaths {
+	return {
+		stateRoot,
+		manifestPath: path.join(stateRoot, "manifest.json"),
+		tasksPath: path.join(stateRoot, "tasks.json"),
+		eventsPath: path.join(stateRoot, "events.jsonl"),
+	};
+}
+
+/**
+ * Read the last N lines from a text file.
+ * Uses reverse buffer reading to avoid loading the entire file into memory.
+ * For files larger than TAIL_MAX_READ bytes, only the last chunk is read.
+ */
+const TAIL_MAX_READ = 256 * 1024; // 256KB — enough for ~1000 lines of JSONL
+const MAX_FALLBACK_READ = 2 * 1024 * 1024; // 2MB — safety limit for giant-line fallback
+function readTailLines(filePath: string, maxLines: number): string[] {
+	if (!fs.existsSync(filePath)) return [];
+	try {
+		const stat = fs.statSync(filePath);
+		const fileSize = stat.size;
+		if (fileSize === 0) return [];
+
+		// 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);
+		}
+
+		// For large files, read only the last chunk.
+		// Search backwards from the read boundary for a newline to avoid
+		// splitting mid-line or mid-multibyte UTF-8 character.
+		const fd = fs.openSync(filePath, "r");
+		try {
+			const readSize = Math.min(fileSize, TAIL_MAX_READ);
+			const readOffset = fileSize - readSize;
+			const buf = Buffer.alloc(readSize);
+			fs.readSync(fd, buf, 0, readSize, readOffset);
+
+			// Find the first newline in the buffer to avoid partial lines.
+			// This also handles multibyte UTF-8 safety — we start after a
+			// newline boundary which is always a clean character boundary.
+			let start = 0;
+			if (readOffset > 0) {
+				const firstNewline = buf.indexOf("\n");
+				if (firstNewline >= 0) {
+					start = firstNewline + 1;
+				} else {
+					// No newline found in the entire tail chunk — single giant line.
+					// Fall back to reading the full file to avoid data loss.
+					// Note: fd will be closed by the outer finally block.
+					throw new GiantLineFallbackError();
+				}
+			}
+
+			const content = buf.toString("utf-8", start, readSize);
+			const lines = content.split("\n").filter((line) => line.trim().length > 0);
+			return lines.slice(-maxLines);
+		} finally {
+			fs.closeSync(fd);
+		}
+	} catch (err) {
+		// Giant-line fallback: fd already closed by finally above.
+		if (err instanceof GiantLineFallbackError) {
+			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 [];
+	}
+}
+
+/**
+ * Parse JSONL lines into TeamEvent objects, skipping malformed lines.
+ */
+function parseEvents(lines: string[]): TeamEvent[] {
+	const events: TeamEvent[] = [];
+	for (const line of lines) {
+		try {
+			const parsed = JSON.parse(line.trim());
+			if (typeof parsed === "object" && parsed !== null && typeof parsed.type === "string" && typeof parsed.runId === "string") {
+				events.push(parsed as TeamEvent);
+			}
+		} catch {
+			// Skip malformed lines
+		}
+	}
+	return events;
+}
+
+/**
+ * Compute a human-readable duration between two ISO timestamp strings.
+ */
+function formatDuration(startIso?: string, endIso?: string): string {
+	if (!startIso) return "—";
+	const start = new Date(startIso).getTime();
+	if (Number.isNaN(start)) return "—";
+	const end = endIso ? new Date(endIso).getTime() : Date.now();
+	if (Number.isNaN(end)) return "—";
+	const diffMs = end - start;
+	if (diffMs < 0) return "—";
+	const seconds = Math.floor(diffMs / 1000);
+	if (seconds < 60) return `${seconds}s`;
+	const minutes = Math.floor(seconds / 60);
+	const remainingSeconds = seconds % 60;
+	if (minutes < 60) return `${minutes}m ${remainingSeconds}s`;
+	const hours = Math.floor(minutes / 60);
+	const remainingMinutes = minutes % 60;
+	return `${hours}h ${remainingMinutes}m`;
+}
+
+/**
+ * Build a deterministic compaction summary for a pi-crew run.
+ *
+ * Reads manifest.json, tasks.json, and the tail of events.jsonl to produce
+ * a self-contained markdown summary suitable for context injection.
+ *
+ * @param stateRoot - Path to the run's state root directory
+ * @returns Markdown-formatted compaction summary
+ */
+export function buildCompactionSummary(stateRoot: string): string {
+	const paths = summaryPathsFor(stateRoot);
+
+	// Read manifest
+	const manifest = readJsonFile<TeamRunManifest>(paths.manifestPath);
+
+	// Read tasks
+	const tasks = readJsonFile<TeamTaskState[]>(paths.tasksPath) ?? [];
+
+	// Read tail events
+	const tailLines = readTailLines(paths.eventsPath, MAX_TAIL_EVENTS);
+	const tailEvents = parseEvents(tailLines);
+
+	const sections: string[] = [];
+
+	// Section: Run Metadata
+	sections.push("# Run Summary");
+	if (manifest) {
+		sections.push("");
+		sections.push("## Run Metadata");
+		sections.push(`- **Run ID**: ${manifest.runId}`);
+		sections.push(`- **Team**: ${manifest.team}`);
+		if (manifest.workflow) {
+			sections.push(`- **Workflow**: ${manifest.workflow}`);
+		}
+		if (manifest.goal) {
+			sections.push(`- **Goal**: ${manifest.goal.replace(/\n/g, " ").slice(0, 500)}`);
+		}
+		sections.push(`- **Status**: ${manifest.status}`);
+		sections.push(`- **Created**: ${manifest.createdAt}`);
+		sections.push(`- **Updated**: ${manifest.updatedAt}`);
+		if (manifest.workspaceMode) {
+			sections.push(`- **Workspace Mode**: ${manifest.workspaceMode}`);
+		}
+	} else {
+		sections.push("");
+		sections.push("## Run Metadata");
+		sections.push("- **Status**: manifest unavailable");
+	}
+
+	// Section: Task Progress Table
+	sections.push("");
+	sections.push("## Task Progress");
+	if (tasks.length > 0) {
+		sections.push("");
+		sections.push("| ID | Role | Status | Duration |");
+		sections.push("|---|---|---|---|");
+		for (const task of tasks) {
+			const taskId = task.id;
+			const role = task.role || "—";
+			const status = task.status || "—";
+			const duration = formatDuration(task.startedAt, task.finishedAt);
+			sections.push(`| ${taskId} | ${role} | ${status} | ${duration} |`);
+		}
+	} else {
+		sections.push("");
+		sections.push("No tasks recorded.");
+	}
+
+	// Section: Recent Task Results
+	const completedTasks = tasks
+		.filter((t) => t.status === "completed" || t.status === "failed")
+		.slice(-MAX_RECENT_RESULTS);
+
+	if (completedTasks.length > 0) {
+		sections.push("");
+		sections.push("## Recent Task Results");
+		for (const task of completedTasks) {
+			sections.push("");
+			sections.push(`### ${task.id} (${task.status})`);
+			if (task.error) {
+				sections.push(`- **Error**: ${task.error}`);
+			}
+			if (task.diagnostics && Object.keys(task.diagnostics).length > 0) {
+				sections.push("- **Diagnostics**:");
+				for (const [key, value] of Object.entries(task.diagnostics)) {
+					sections.push(`  - ${key}: ${JSON.stringify(value)}`);
+				}
+			}
+			if (task.metrics && Object.keys(task.metrics).length > 0) {
+				sections.push("- **Metrics**:");
+				for (const [key, value] of Object.entries(task.metrics)) {
+					sections.push(`  - ${key}: ${value}`);
+				}
+			}
+		}
+	}
+
+	// Section: Next Steps (pending/queued tasks)
+	const pendingStatuses = new Set(["queued", "waiting", "running"]);
+	const pendingTasks = tasks.filter(
+		(t) => pendingStatuses.has(t.status),
+	);
+	if (pendingTasks.length > 0) {
+		sections.push("");
+		sections.push("## Next Steps");
+		sections.push("");
+		for (const task of pendingTasks) {
+			const title = task.title || task.role || "Untitled";
+			sections.push(`- [${task.status}] ${task.id}: ${title}`);
+		}
+	}
+
+	// Section: Tail Events Summary
+	if (tailEvents.length > 0) {
+		sections.push("");
+		sections.push(`## Recent Events (last ${tailEvents.length})`);
+		sections.push("");
+		for (const event of tailEvents.slice(-10)) {
+			const taskPart = event.taskId ? ` task=${event.taskId}` : "";
+			const msgPart = event.message ? ` — ${event.message}` : "";
+			sections.push(`- [${event.time}] ${event.type}${taskPart}${msgPart}`);
+		}
+	}
+
+	return sections.join("\n");
+}