pi-crew 0.9.53 → 0.9.55

package/src/runtime/compact-pipeline.ts

@@ -0,0 +1,56 @@
+/**
+ * Stage-chain compression pipeline (P0-A).
+ *
+ * Composable, monotonic-shrink-safe text compression. Each stage declares an
+ * `id` and an `apply(text): string` method. The pipeline runs stages in
+ * order, applying each stage's output ONLY if it is no longer than the
+ * stage's input. This is the safety property that prevents the family of
+ * bugs the old L4 caveman-shrink refactor surfaced (24/27 artifacts corrupted
+ * with null bytes because a regex-based shrink expanded its input in some
+ * cases — knowledge.md "L4 output-handling"). With the monotonic-shrink gate,
+ * a buggy stage implementation can NEVER cause output growth, and therefore
+ * cannot corrupt downstream structure.
+ *
+ * Ported from Hypa's `src/Hypa.Infrastructure/Compression/GenericOutputCompressor.cs`
+ * (stage loop with `if (next.Length <= text.Length)` gate).
+ */
+
+export interface ICompactStage {
+	/** Stable identifier; surfaced in `PipelineResult.applied` for observability. */
+	readonly id: string;
+	/**
+	 * Transform `text`. MUST be pure (no side effects, deterministic for a
+	 * given input). MAY return the input unchanged when nothing to do — the
+	 * pipeline will skip it via the monotonic-shrink gate regardless, but
+	 * returning the same string keeps `applied` honest.
+	 */
+	apply(text: string): string;
+}
+
+export interface PipelineResult {
+	text: string;
+	/** ids of stages whose output was accepted (shorter-or-equal than their input). */
+	applied: readonly string[];
+}
+
+/**
+ * Run `stages` in order. Each stage is applied only if its output is no
+ * longer than its current input. The pipeline NEVER expands text — if a
+ * stage would expand, it is silently skipped (its id is not added to
+ * `applied`).
+ */
+export function applyCompactPipeline(text: string, stages: readonly ICompactStage[]): PipelineResult {
+	let current = text;
+	const applied: string[] = [];
+	for (const stage of stages) {
+		if (!stage || typeof stage.apply !== "function") continue; // defensive: skip malformed entries
+		const next = stage.apply(current);
+		if (typeof next !== "string") continue; // defensive: skip non-string output
+		if (next.length <= current.length) {
+			current = next;
+			applied.push(stage.id);
+		}
+		// else: stage attempted to expand input — silently drop (monotonic-shrink gate).
+	}
+	return { text: current, applied };
+}

package/src/runtime/compact-stages/ansi-strip-stage.ts

@@ -0,0 +1,25 @@
+/**
+ * AnsiStripStage — strip ANSI CSI escape sequences.
+ *
+ * Matches the common CSI pattern: ESC `[` followed by parameter bytes
+ * (0-9 ; ?), intermediate bytes (space - /), and a final byte (@-~).
+ * Sufficient for the color/cursor codes emitted by npm, cargo, jest, etc.
+ * Does not attempt to handle OSC / DCS / private modes (rare in CLI output
+ * captured into artifacts; can be added later if real-world signal emerges).
+ *
+ * Idempotent (no ANSI in → no change; ANSI in → ANSI out).
+ */
+import type { ICompactStage } from "../compact-pipeline.ts";
+
+// CSI: ESC [ <params 0-9;> <intermediates space-/ > <final @-~>
+const ANSI_CSI_PATTERN = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+
+export class AnsiStripStage implements ICompactStage {
+	readonly id = "ansi-strip";
+	apply(text: string): string {
+		if (text.indexOf("\x1b") === -1) return text; // fast path: no ESC at all
+		return text.replace(ANSI_CSI_PATTERN, "");
+	}
+}
+
+export const ANSI_STRIP_STAGE = new AnsiStripStage();

package/src/runtime/compact-stages/blank-collapse-stage.ts

@@ -0,0 +1,31 @@
+/**
+ * BlankCollapseStage — collapse runs of 3+ consecutive newlines to a single
+ * blank line (i.e., 2 newlines).
+ *
+ * Reduces whitespace noise in long command output (npm install, cargo build,
+ * jest, etc. frequently emit blocks of blank lines between sections). Does
+ * NOT touch 1 or 2 consecutive newlines — those are legitimate paragraph
+ * breaks in prose.
+ *
+ * Idempotent (already-collapsed input → unchanged).
+ */
+import type { ICompactStage } from "../compact-pipeline.ts";
+
+export class BlankCollapseStage implements ICompactStage {
+	readonly id = "blank-collapse";
+	// NOTE: deliberately NOT using parameter-property shorthand here because
+	// Node's --experimental-strip-types does not support it. Field + ctor
+	// assignment is the portable shape.
+	private readonly minConsecutive: number;
+	constructor(minConsecutive = 3) {
+		this.minConsecutive = minConsecutive;
+	}
+	apply(text: string): string {
+		if (this.minConsecutive < 2) return text;
+		// {minConsecutive,} matches minConsecutive or more; replace with "\n\n" (one blank line).
+		const pattern = new RegExp(`\\n{${this.minConsecutive},}`, "g");
+		return text.replace(pattern, "\n\n");
+	}
+}
+
+export const BLANK_COLLAPSE_STAGE = new BlankCollapseStage();

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

@@ -0,0 +1,34 @@
+/**
+ * DeduplicateStage — collapse CONSECUTIVE duplicate lines into one.
+ *
+ * Useful for log output where the same line repeats (retry attempts, poll
+ * loops, etc.). Only collapses CONSECUTIVE duplicates — non-adjacent
+ * repetitions are kept (they may be legitimately repeated later). Does NOT
+ * touch whitespace-only differences.
+ *
+ * Idempotent.
+ *
+ * SAFETY: do NOT enable this stage on assistant prose. "I I I went to the
+ * store" would lose emphasis. compactString's default pipeline does NOT
+ * include this stage for that reason; it is opt-in only.
+ */
+import type { ICompactStage } from "../compact-pipeline.ts";
+
+export class DeduplicateStage implements ICompactStage {
+	readonly id = "deduplicate";
+	apply(text: string): string {
+		if (text.length === 0) return text;
+		const lines = text.split(/\r?\n/);
+		if (lines.length < 2) return text;
+		const out: string[] = [lines[0]!];
+		for (let i = 1; i < lines.length; i++) {
+			const cur = lines[i]!;
+			if (cur !== out[out.length - 1]) out.push(cur);
+		}
+		// Preserve original line ending style: if input used \r\n, restore that.
+		const sep = text.includes("\r\n") ? "\r\n" : "\n";
+		return out.join(sep);
+	}
+}
+
+export const DEDUPLICATE_STAGE = new DeduplicateStage();

package/src/runtime/compact-stages/head-snap-stage.ts

@@ -0,0 +1,57 @@
+/**
+ * HeadSnapStage — keep the first N bytes of the input, optionally snapping to
+ * the last newline within that region for clean line boundaries.
+ *
+ * Distinct from TruncationStage (head + important-middle + tail, P0-B / P0-A):
+ * this stage is pure head-only with optional newline-snap, used by the
+ * iteration-hooks hook-output capture where the goal is "first N bytes
+ * snapped to a clean line" rather than head + tail.
+ *
+ * Use case in pi-crew:
+ *   - `iteration-hooks.ts` truncateToLimit — hook stdout capture capped at
+ *     MAX_STDOUT_BYTES (8KB), snapped to the last newline in the head region
+ *     so partial lines never appear in the captured preview.
+ *
+ * Byte cap (not char cap) to preserve the original memory budget semantic:
+ * the input is converted from Buffer to string once, then this stage ensures
+ * the output never exceeds the byte cap by walking back any partial UTF-8
+ * sequence at the cut boundary.
+ */
+import type { ICompactStage } from "../compact-pipeline.ts";
+
+export interface HeadSnapStageConfig {
+	/** Maximum output size in bytes. */
+	maxBytes: number;
+	/** When true, snap the cut to the last newline within the head region. */
+	snapToNewline?: boolean;
+	/** Optional explicit id; defaults to "head-snap". */
+	id?: string;
+}
+
+export class HeadSnapStage implements ICompactStage {
+	readonly id: string;
+	private readonly maxBytes: number;
+	private readonly snapToNewline: boolean;
+	constructor(config: HeadSnapStageConfig) {
+		if (!Number.isFinite(config.maxBytes) || config.maxBytes <= 0) {
+			throw new Error(`HeadSnapStage: maxBytes must be a positive finite number, got ${config.maxBytes}`);
+		}
+		this.maxBytes = config.maxBytes;
+		this.snapToNewline = config.snapToNewline !== false;
+		this.id = config.id ?? "head-snap";
+	}
+	apply(text: string): string {
+		if (Buffer.byteLength(text, "utf-8") <= this.maxBytes) return text;
+		// Approximate: slice by char count, then walk back any partial UTF-8
+		// sequence to keep byte-length <= maxBytes.
+		let slice = text.slice(0, this.maxBytes);
+		while (Buffer.byteLength(slice, "utf-8") > this.maxBytes) {
+			slice = slice.slice(0, slice.length - 1);
+		}
+		if (this.snapToNewline) {
+			const lastNewline = slice.lastIndexOf("\n");
+			if (lastNewline >= 0) return slice.slice(0, lastNewline);
+		}
+		return slice;
+	}
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Barrel re-exports for the compact-stages module.
+ *
+ * Callers import from `../../runtime/compact-stages/index.ts` (or just
+ * `../../runtime/compact-stages/`) rather than reaching into individual
+ * stage files, so internal refactors do not break the public surface.
+ */
+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 {
+	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

@@ -0,0 +1,77 @@
+/**
+ * TailCaptureStage — keep the last N characters/bytes of the input, prepend
+ * an optional marker when truncation fires.
+ *
+ * Distinct from TruncationStage (head + important-middle + tail, P0-B / P0-A):
+ * this stage is pure tail-capture, used by streaming accumulators that need to
+ * keep the most recent N chars/bytes and drop the oldest. No important-line
+ * preservation, no head — just the tail + optional marker.
+ *
+ * Use cases in pi-crew:
+ *   - `appendBoundedTail` (child-pi.ts) — stdout/stderr streaming accumulator
+ *     with byte cap and a `[pi-crew captured output truncated to last X KiB]`
+ *     marker.
+ *   - `stream-preview.ts` textBuffer — incremental text buffer for the live UI
+ *     preview, char cap, NO marker (the UI shows raw text without a prefix).
+ *
+ * Two cap modes:
+ *   - `maxChars`: character-based cap (UTF-8 safe by definition).
+ *   - `maxBytes`: byte-based cap (legacy, used when memory budget matters
+ *     more than UTF-8 safety). The tail is snapped to the last byte that
+ *     keeps the result ≤ maxBytes to avoid splitting a multi-byte sequence.
+ */
+import type { ICompactStage } from "../compact-pipeline.ts";
+
+export interface TailCaptureStageConfig {
+	/** Character cap (UTF-8 safe). Mutually exclusive with maxBytes. */
+	maxChars?: number;
+	/** Byte cap (legacy, used by streaming accumulators). Mutually exclusive with maxChars. */
+	maxBytes?: number;
+	/** Marker prepended (with a newline separator) when truncation fires. Empty string = no marker. */
+	marker?: string;
+	/** Optional explicit id; defaults to "tail-capture" (or "tail-capture-stream" if maxBytes mode). */
+	id?: string;
+}
+
+export class TailCaptureStage implements ICompactStage {
+	readonly id: string;
+	private readonly maxChars: number | undefined;
+	private readonly maxBytes: number | undefined;
+	private readonly marker: string;
+	constructor(config: TailCaptureStageConfig) {
+		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})`,
+			);
+		}
+		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}`);
+		this.maxChars = config.maxChars;
+		this.maxBytes = config.maxBytes;
+		this.marker = config.marker ?? "";
+		this.id = config.id ?? (hasBytes ? "tail-capture" : "tail-capture");
+	}
+	apply(text: string): string {
+		if (this.maxBytes !== undefined) {
+			// Byte cap mode — snap tail to a UTF-8 char boundary so the result
+			// never contains a partial multi-byte sequence.
+			if (Buffer.byteLength(text, "utf-8") <= this.maxBytes) return text;
+			let tail = text.slice(Math.max(0, text.length - this.maxBytes));
+			while (Buffer.byteLength(tail, "utf-8") > this.maxBytes) tail = tail.slice(0, -1);
+			return this.marker ? `${this.marker}\n${tail}` : tail;
+		}
+		// Char cap mode.
+		const max = this.maxChars as number;
+		if (text.length <= max) return text;
+		const tail = text.slice(text.length - max);
+		return this.marker ? `${this.marker}\n${tail}` : tail;
+	}
+}
+
+/** 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",
+});

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

@@ -0,0 +1,74 @@
+/**
+ * TruncationStage — head(75%) + important-middle + tail(25%) compression.
+ *
+ * Wraps the head/tail/important-line split (from P0-B's `important-line-classifier.ts`)
+ * as a pipeline stage so it composes with other stages (ANSI strip, blank
+ * collapse, etc.). When the input is at or below `maxChars`, returns the
+ * input unchanged (idempotent — the pipeline gate then marks this stage as
+ * a no-op).
+ *
+ * Marker wording is parameterized so the SAME stage serves both `compactString`
+ * ("compacted ... chars") and `readIfSmall` ("truncated ... chars") with
+ * their distinct separators. Defaults match `compactString`'s pre-P0-A output
+ * exactly so that callers that do not opt into additional stages get
+ * bit-identical output (L4 backward-compat safety).
+ */
+import type { ICompactStage } from "../compact-pipeline.ts";
+import { splitWithImportantLines } from "../important-line-classifier.ts";
+
+export interface TruncationMarkerConfig {
+	/** "compacted" (compactString default) or "truncated" (readIfSmall default). */
+	verb: "compacted" | "truncated";
+	/** Unit reported in the marker. Both callers currently use "chars" post-Sprint 1. */
+	unit: "chars" | "bytes";
+	/** Newline(s) between `head` and the marker line. compactString uses "\n"; readIfSmall uses "\n\n". */
+	headSeparator: string;
+	/** Newline(s) between the marker (or joined important lines) and `tail`. Both callers use "\n". */
+	tailSeparator: string;
+}
+
+const DEFAULT_MARKER: TruncationMarkerConfig = {
+	verb: "compacted",
+	unit: "chars",
+	headSeparator: "\n",
+	tailSeparator: "\n",
+};
+
+export class TruncationStage implements ICompactStage {
+	readonly id = "truncation";
+	private readonly maxChars: number;
+	private readonly preserveImportant: boolean;
+	private readonly marker: TruncationMarkerConfig;
+	constructor(
+		maxChars: number,
+		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}`);
+		}
+		this.maxChars = maxChars;
+		this.preserveImportant = opts.preserveImportant !== false;
+		this.marker = { ...DEFAULT_MARKER, ...(opts.marker ?? {}) };
+	}
+	apply(text: string): string {
+		if (text.length <= this.maxChars) return text;
+		const { head, tail, importantLines, baseDropped } = splitWithImportantLines(text, this.maxChars, {
+			preserveImportant: this.preserveImportant,
+		});
+		let result: string;
+		if (importantLines.length === 0) {
+			result = `${head}${this.marker.headSeparator}...[pi-crew ${this.marker.verb} ${baseDropped} ${this.marker.unit}, head+tail preserved]...${this.marker.tailSeparator}${tail}`;
+		} else {
+			const joined = importantLines.join("\n");
+			const remaining = text.length - head.length - tail.length - joined.length;
+			result = `${head}${this.marker.headSeparator}...[pi-crew ${this.marker.verb} ${baseDropped} ${this.marker.unit}, head+tail + ${importantLines.length} important lines preserved, ${remaining} ${this.marker.unit} remaining dropped]...\n${joined}${this.marker.tailSeparator}${tail}`;
+		}
+		// Defense-in-depth: this stage's own monotonic-shrink invariant. The
+		// pipeline gate is a SECOND line of defense.
+		if (result.length >= text.length) return text;
+		return result;
+	}
+}

package/src/runtime/compaction-summary.ts

@@ -0,0 +1,278 @@
+/**
+ * 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 { 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;
+
+/** 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");
+}