pi-crew 0.9.67 → 0.10.1

package/src/config/resilient-parser.ts

@@ -1,117 +0,0 @@
-/**
- * Per-field resilient config parsing — continues on error, collects all field-level issues.
- */
-
-import type { TSchema } from "@sinclair/typebox";
-import { Value } from "@sinclair/typebox/value";
-import { PiTeamsConfigSchema } from "../schema/config-schema.ts";
-import { type PiTeamsConfig, parseConfig } from "./config.ts";
-import { suggestConfigKey } from "./suggestions.ts";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface FieldError {
-	field: string;
-	message: string;
-	value: unknown;
-	suggestion?: string;
-}
-
-export interface ResilientParseResult {
-	config: Record<string, unknown>;
-	errors: FieldError[];
-	warnings: string[];
-	valid: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const KNOWN_TOP_LEVEL_KEYS: readonly string[] = Object.keys(PiTeamsConfigSchema.properties ?? {});
-
-function isObject(value: unknown): value is Record<string, unknown> {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-// ---------------------------------------------------------------------------
-// Implementation
-// ---------------------------------------------------------------------------
-
-/**
- * Parse a raw config value field-by-field.
- *
- * - Each top-level key is validated independently via TypeBox sub-schemas.
- * - Fields that fail are recorded as errors but do not block others.
- * - Unknown keys get a fuzzy suggestion via Levenshtein distance.
- * - The returned `config` contains only successfully-parsed fields (via `parseConfig`).
- */
-export function parseConfigResilient(raw: unknown): ResilientParseResult {
-	const errors: FieldError[] = [];
-	const warnings: string[] = [];
-
-	if (!isObject(raw)) {
-		return {
-			config: {},
-			errors: [
-				{
-					field: "config",
-					message: "config must be an object",
-					value: raw,
-				},
-			],
-			warnings,
-			valid: false,
-		};
-	}
-
-	// Collect unknown top-level keys with suggestions
-	for (const key of Object.keys(raw)) {
-		if (!KNOWN_TOP_LEVEL_KEYS.includes(key)) {
-			const suggestion = suggestConfigKey(key, KNOWN_TOP_LEVEL_KEYS);
-			errors.push({
-				field: key,
-				message: `unknown config key '${key}'`,
-				value: raw[key],
-				suggestion: suggestion ?? undefined,
-			});
-		}
-	}
-
-	// Use TypeBox per-field validation for known keys
-	for (const key of KNOWN_TOP_LEVEL_KEYS) {
-		if (!(key in raw)) continue;
-		const value = raw[key];
-		const subSchema = (PiTeamsConfigSchema.properties as Record<string, unknown>)[key];
-		if (subSchema && !Value.Check(subSchema as TSchema, value)) {
-			// Collect ALL errors for this field
-			const fieldErrors = [...Value.Errors(subSchema as TSchema, value)];
-			for (const err of fieldErrors) {
-				const errObj = err as unknown as Record<string, unknown>;
-				const msg = typeof errObj.message === "string" ? errObj.message : "invalid value";
-				errors.push({
-					field: key,
-					message: msg,
-					value,
-				});
-			}
-		}
-	}
-
-	// Build the valid subset using existing parseConfig (which silently drops invalid fields)
-	const parsed: PiTeamsConfig = parseConfig(raw);
-	const config: Record<string, unknown> = {};
-	for (const key of Object.keys(parsed)) {
-		const val = (parsed as Record<string, unknown>)[key];
-		if (val !== undefined) config[key] = val;
-	}
-
-	return {
-		config,
-		errors,
-		warnings,
-		valid: errors.length === 0,
-	};
-}

package/src/extension/crew-vibes/cat-frames.ts

@@ -1,18 +0,0 @@
-/**
- * ANSI art cat animation frames extracted from runner-spritesheet.png.
- * Used when PUA font glyphs are not available (web terminals like gotty).
- * Each frame is an array of strings (one per line).
- */
-export const CAT_FRAMES: readonly string[][] = [
-	// Frame 0 — standing
-	["▄▄ ███▄ ", "▀▀█████▄", "  ██▀██ ", "  ▀▀  ▀▀"],
-	// Frame 1 — step 1
-	["  ████  ", "  █████▄", "▄██████▀", "  ██ ▀█▄"],
-	// Frame 2 — step 2
-	[" ▄██████", " █████▀ ", "███████ ", "▀██████ "],
-	// Frame 3 — step 3
-	["  ████  ", "▄█████▄ ", "▀██████▄", "▄█▀  ██ "],
-] as const;
-
-/** Number of animation frames. */
-export const CAT_FRAME_COUNT = CAT_FRAMES.length;

package/src/extension/result-watcher.ts

@@ -1,139 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { buildCompletionKey, getGlobalSeenMap, markSeenWithTtl } from "../utils/completion-dedupe.ts";
-import { createFileCoalescer } from "../utils/file-coalescer.ts";
-import { closeWatcher, watchWithErrorHandler } from "../utils/fs-watch.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-
-export interface ResultWatcherEvents {
-	emit(event: string, data: unknown): void;
-}
-
-export interface ResultWatcherHandle {
-	start(): void;
-	prime(): void;
-	stop(): void;
-}
-
-interface ResultWatcherDependencies {
-	watch?: typeof watchWithErrorHandler;
-}
-
-export interface ResultWatcherOptions extends ResultWatcherDependencies {
-	eventName?: string;
-	completionTtlMs?: number;
-	isCurrent?: () => boolean;
-}
-
-const RESULT_WATCHER_RESTART_MS = 3000;
-const RESULT_WATCHER_POLL_MS = 1000;
-
-function shouldFallBackToPolling(error: unknown): boolean {
-	const code = error && typeof error === "object" ? (error as { code?: unknown }).code : undefined;
-	return code === "EMFILE" || code === "ENOSPC" || code === "EPERM";
-}
-
-function readJson(filePath: string): unknown | undefined {
-	try {
-		return JSON.parse(fs.readFileSync(filePath, "utf-8")) as unknown;
-	} catch (error) {
-		logInternalError("result-watcher.parse", error, `filePath=${filePath}`);
-		return undefined;
-	}
-}
-
-export function createResultWatcher(
-	events: ResultWatcherEvents,
-	resultsDir: string,
-	eventNameOrOptions: string | ResultWatcherOptions = "pi-crew:run-result",
-): ResultWatcherHandle {
-	const options: ResultWatcherOptions = typeof eventNameOrOptions === "string" ? { eventName: eventNameOrOptions } : eventNameOrOptions;
-	const eventName = options.eventName ?? "pi-crew:run-result";
-	const completionTtlMs = options.completionTtlMs ?? 5 * 60_000;
-	const watch = options.watch ?? watchWithErrorHandler;
-	const isCurrent = options.isCurrent ?? (() => true);
-	const seen = getGlobalSeenMap("pi-crew.result-watcher");
-	let watcher: fs.FSWatcher | null | undefined;
-	let restartTimer: ReturnType<typeof setTimeout> | undefined;
-	let pollTimer: ReturnType<typeof setInterval> | undefined;
-	const coalescer = createFileCoalescer((file) => {
-		if (!isCurrent()) return;
-		const filePath = path.join(resultsDir, file);
-		if (!file.endsWith(".json") || !fs.existsSync(filePath)) return;
-		const payload = readJson(filePath);
-		if (payload === undefined) {
-			coalescer.schedule(file, RESULT_WATCHER_POLL_MS);
-			return;
-		}
-		const key = buildCompletionKey(
-			payload && typeof payload === "object" && !Array.isArray(payload) ? (payload as Record<string, unknown>) : {},
-			`file:${file}`,
-		);
-		if (!markSeenWithTtl(seen, key, Date.now(), completionTtlMs)) {
-			events.emit(eventName, payload);
-		}
-		try {
-			fs.unlinkSync(filePath);
-		} catch (error) {
-			logInternalError("result-watcher.unlink", error, `filePath=${filePath}`);
-		}
-	}, 50);
-	const poll = () => {
-		if (!isCurrent() || !fs.existsSync(resultsDir)) return;
-		for (const file of fs.readdirSync(resultsDir).filter((entry) => entry.endsWith(".json"))) coalescer.schedule(file, 0);
-	};
-	const startPolling = () => {
-		if (pollTimer) return;
-		pollTimer = setInterval(poll, RESULT_WATCHER_POLL_MS);
-		pollTimer.unref();
-		poll();
-	};
-	const stopPolling = () => {
-		if (pollTimer) clearInterval(pollTimer);
-		pollTimer = undefined;
-	};
-	const scheduleRestart = (error?: unknown) => {
-		if (shouldFallBackToPolling(error)) startPolling();
-		if (restartTimer) clearTimeout(restartTimer);
-		restartTimer = setTimeout(() => {
-			restartTimer = undefined;
-			try {
-				if (!isCurrent()) return;
-				fs.mkdirSync(resultsDir, { recursive: true });
-				handle.start();
-			} catch (error) {
-				logInternalError("result-watcher.restart", error, `resultsDir=${resultsDir}`);
-			}
-		}, RESULT_WATCHER_RESTART_MS);
-		restartTimer.unref();
-	};
-	const handle: ResultWatcherHandle = {
-		start() {
-			if (!isCurrent()) return;
-			fs.mkdirSync(resultsDir, { recursive: true });
-			if (watcher) closeWatcher(watcher);
-			watcher = watch(
-				resultsDir,
-				(event, fileName) => {
-					if (event !== "rename" || !fileName) return;
-					coalescer.schedule(fileName.toString());
-				},
-				scheduleRestart,
-			);
-			if (watcher) stopPolling();
-			watcher?.unref();
-		},
-		prime() {
-			poll();
-		},
-		stop() {
-			if (restartTimer) clearTimeout(restartTimer);
-			restartTimer = undefined;
-			closeWatcher(watcher);
-			watcher = undefined;
-			stopPolling();
-			coalescer.clear();
-		},
-	};
-	return handle;
-}

package/src/observability/exporters/prometheus-exporter.ts

@@ -1,54 +0,0 @@
-import type { HistogramPoint, MetricLabels, MetricPoint, MetricSnapshot } from "../metrics-primitives.ts";
-
-function prometheusName(name: string): string {
-	return name.replace(/[^a-zA-Z0-9_:]/g, "_").replace(/^[0-9]/, "_$&");
-}
-
-function escapeLabel(value: string): string {
-	return value.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/"/g, '\\"');
-}
-
-function labelsText(labels: MetricLabels): string {
-	const entries = Object.entries(labels);
-	if (!entries.length) return "";
-	return `{${entries.map(([key, value]) => `${key}="${escapeLabel(String(value))}"`).join(",")}}`;
-}
-
-function metricType(type: MetricSnapshot["type"]): string {
-	return type === "histogram" ? "histogram" : type === "gauge" ? "gauge" : "counter";
-}
-
-function isHistogramPoint(value: MetricPoint | HistogramPoint): value is HistogramPoint {
-	return "buckets" in value && "counts" in value;
-}
-
-function formatPrometheusValue(num: number): string {
-	if (Number.isNaN(num)) return "Nan";
-	if (num === Number.POSITIVE_INFINITY) return "+Inf";
-	if (num === Number.NEGATIVE_INFINITY) return "-Inf";
-	return String(num);
-}
-
-export function formatPrometheus(snapshots: MetricSnapshot[]): string {
-	const lines: string[] = [];
-	for (const snapshot of snapshots) {
-		const name = prometheusName(snapshot.name);
-		lines.push(`# HELP ${name} ${snapshot.description}`);
-		lines.push(`# TYPE ${name} ${metricType(snapshot.type)}`);
-		for (const value of snapshot.values) {
-			if (isHistogramPoint(value)) {
-				let cumulative = 0;
-				for (let index = 0; index < value.buckets.length; index += 1) {
-					cumulative += value.counts[index] ?? 0;
-					const le = Number.isFinite(value.buckets[index]) ? String(value.buckets[index]) : "+Inf";
-					lines.push(`${name}_bucket${labelsText({ ...value.labels, le })} ${cumulative}`);
-				}
-				lines.push(`${name}_sum${labelsText(value.labels)} ${value.sum}`);
-				lines.push(`${name}_count${labelsText(value.labels)} ${value.count}`);
-			} else {
-				lines.push(`${name}${labelsText(value.labels)} ${formatPrometheusValue(value.value)}`);
-			}
-		}
-	}
-	return `${lines.join("\n")}\n`;
-}

package/src/observability/metric-retention.ts

@@ -1,64 +0,0 @@
-import { labelKey, type MetricLabels } from "./metrics-primitives.ts";
-
-interface WindowEvent {
-	timestamp: number;
-	labels: MetricLabels;
-	delta: number;
-}
-
-export class TimeWindowedCounter {
-	private events: WindowEvent[] = [];
-	private readonly windowMs: number;
-	private readonly now: () => number;
-	private static readonly MAX_EVENTS = 100_000;
-
-	constructor(windowMs = 3_600_000, now: () => number = () => Date.now()) {
-		this.windowMs = windowMs;
-		this.now = now;
-	}
-
-	inc(labels: MetricLabels = {}, delta = 1): void {
-		if (!Number.isFinite(delta)) return;
-		// Cap the event array to prevent unbounded memory growth.
-		if (this.events.length >= TimeWindowedCounter.MAX_EVENTS) this.prune();
-		this.events.push({
-			timestamp: this.now(),
-			labels: { ...labels },
-			delta,
-		});
-		this.prune();
-	}
-
-	// PERF (OBS-5): This method is O(N) per call because it linearly scans
-	// all events and calls labelKey() (which uses JSON.stringify) on each.
-	// A more efficient aggregation (e.g., pre-aggregated label buckets or a
-	// sliding-window histogram) is planned to replace this hot path.
-	count(labels: MetricLabels = {}, durationMs = this.windowMs): number {
-		const now = this.now();
-		this.pruneAt(now);
-		const key = labelKey(labels);
-		const cutoff = now - durationMs;
-		return this.events
-			.filter((event) => event.timestamp >= cutoff && labelKey(event.labels) === key)
-			.reduce((sum, event) => sum + event.delta, 0);
-	}
-
-	rate(labels: MetricLabels = {}, durationMs = this.windowMs): number {
-		if (durationMs <= 0) return 0;
-		return this.count(labels, durationMs) / (durationMs / 1000);
-	}
-
-	size(): number {
-		this.prune();
-		return this.events.length;
-	}
-
-	private prune(): void {
-		this.pruneAt(this.now());
-	}
-
-	private pruneAt(now: number): void {
-		const cutoff = now - this.windowMs;
-		this.events = this.events.filter((event) => event.timestamp >= cutoff);
-	}
-}

package/src/runtime/compaction/compaction-summary.ts

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