pi-crew 0.2.24 → 0.3.0

package/src/ui/tool-render.ts

@@ -0,0 +1,331 @@
+/**
+ * Shared rendering for pi-crew's tool TUI display.
+ * Ports logic from pi-subagent4 adapted for pi-crew's data model.
+ * Uses @mariozechner/pi-tui Components (Container, Text, Spacer) directly.
+ */
+import { Container, Spacer, Text, visibleWidth } from "@mariozechner/pi-tui";
+import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
+
+// ── Types ──────────────────────────────────────────────────────────────
+export interface Theme {
+	fg(color: ThemeColor, text: string): string;
+	bold(text: string): string;
+}
+export type ThemeColor = "success" | "error" | "warning" | "dim" | "toolTitle" | "accent" | "muted" | "text";
+export interface ToolRenderContext { expanded: boolean; lastComponent?: Container }
+export type Component = Container | Text;
+
+export interface TeamToolResultDetails {
+	action?: string; status?: string; runId?: string; goal?: string;
+	team?: string; workflow?: string; error?: string; agentRecords?: CrewAgentRecord[];
+}
+export interface AgentToolResultDetails {
+	results?: Array<{ agentId?: string; status?: string; output?: string; error?: string }>;
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────
+
+export function formatTokens(n: number): string {
+	if (n < 1000) return String(n);
+	if (n < 10_000) return `${(n / 1000).toFixed(1)}k`;
+	if (n < 1_000_000) return `${Math.round(n / 1000)}k`;
+	return `${(n / 1_000_000).toFixed(1)}M`;
+}
+
+export function formatDuration(ms: number): string {
+	if (ms < 1000) return `${ms}ms`;
+	if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`;
+	const m = Math.floor(ms / 60_000), s = Math.floor((ms % 60_000) / 1000);
+	return s > 0 ? `${m}m${s}s` : `${m}m`;
+}
+
+export function formatContextUsage(tokens: number, contextWindow: number | undefined): string {
+	if (!contextWindow) return `${formatTokens(tokens)} ctx`;
+	const pct = (tokens / contextWindow) * 100;
+	const maxStr = contextWindow >= 1_000_000 ? `${(contextWindow / 1_000_000).toFixed(1)}M` : `${Math.round(contextWindow / 1000)}k`;
+	return `${pct.toFixed(1)}%/${maxStr}`;
+}
+
+export function truncLine(text: string, maxWidth: number): string {
+	if (text.includes("\n") || text.includes("\r")) text = text.replace(/\r?\n/g, "↵ ");
+	if (visibleWidth(text) <= maxWidth) return text;
+	let result = "", width = 0;
+	for (let i = 0; i < text.length; i++) {
+		if (text[i] === "\x1b") {
+			const m = text.slice(i).match(/^\x1b\[[0-9;]*m/);
+			if (m) { result += m[0]; i += m[0].length - 1; continue; }
+		}
+		if (width >= maxWidth - 1) return result + "…";
+		result += text[i]; width++;
+	}
+	return result;
+}
+
+export function formatToolPreview(name: string, args: Record<string, unknown>): string {
+	switch (name) {
+		case "bash": case "safe_bash": return `$ ${((args.command as string) || "").slice(0, 80)}`;
+		case "read": return `read ${(args.path as string) || ""}`;
+		case "write": return `write ${(args.path as string) || ""}`;
+		case "edit": return `edit ${(args.path as string) || ""}`;
+		case "grep": case "find": return `${name} ${((args.pattern || args.path) as string) || ""}`;
+		case "ls": return `ls ${(args.path as string) || "."}`;
+		case "web_search": case "search": return `search "${((args.query as string) || "").slice(0, 60)}"`;
+		case "web_fetch": case "fetch": return `fetch ${(args.url as string) || ""}`;
+		case "team": return `team action=${(args.action as string) || ""}`;
+		case "agent": return `agent ${(args.agent as string) || ""}`;
+		default: { const s = JSON.stringify(args); return `${name} ${s.slice(0, 60)}`; }
+	}
+}
+
+// ── Tool Call Renderers ─────────────────────────────────────────────
+
+/** team tool call: collapsed "team action='run' impl..." / expanded: header + goal */
+export function renderTeamToolCall(
+	args: { action?: string; goal?: string; team?: string; workflow?: string },
+	theme: Theme, context: ToolRenderContext,
+): Component {
+	const action = args.action || "", goal = args.goal || "";
+	const team = args.team ? ` ${theme.fg("dim", `(${args.team})`)}` : "";
+
+	if (!context.expanded) {
+		const preview = goal.length > 60 ? goal.slice(0, 60) + "…" : goal;
+		return new Text(
+			`${theme.fg("toolTitle", theme.bold("team"))} action=${theme.fg("accent", `'${action}'`)}${team}${theme.fg("dim", preview ? ` "${preview.replace(/\n/g, " ")}"` : "")}`,
+			0, 0,
+		);
+	}
+	const c = context.lastComponent instanceof Container ? (context.lastComponent.clear(), context.lastComponent) : new Container();
+	c.addChild(new Text(`${theme.fg("toolTitle", theme.bold("team"))} action=${theme.fg("accent", `'${action}'`)}${team}`, 0, 0));
+	if (goal) { c.addChild(new Spacer(1)); c.addChild(new Text(theme.fg("text", goal), 0, 0)); }
+	return c;
+}
+
+/** agent tool call: collapsed "Agent explorer..." / expanded: header + prompt */
+export function renderAgentToolCall(
+	args: { agent?: string; prompt?: string; task?: string; cwd?: string },
+	theme: Theme, context: ToolRenderContext,
+): Component {
+	const agentName = args.agent || "", prompt = args.prompt || args.task || "";
+
+	if (!context.expanded) {
+		const preview = prompt.length > 60 ? prompt.slice(0, 60) + "…" : prompt;
+		return new Text(
+			`${theme.fg("toolTitle", theme.bold("agent"))} ${theme.fg("accent", agentName)}${theme.fg("dim", preview ? ` "${preview.replace(/\n/g, " ")}"` : "")}`,
+			0, 0,
+		);
+	}
+	const c = context.lastComponent instanceof Container ? (context.lastComponent.clear(), context.lastComponent) : new Container();
+	const cwdLabel = args.cwd ? theme.fg("dim", ` (cwd: ${args.cwd})`) : "";
+	c.addChild(new Text(`${theme.fg("toolTitle", theme.bold("agent"))} ${theme.fg("accent", agentName)}${cwdLabel}`, 0, 0));
+	if (prompt) { c.addChild(new Spacer(1)); c.addChild(new Text(theme.fg("text", prompt), 0, 0)); }
+	return c;
+}
+
+// ── Agent Progress Renderer ──────────────────────────────────────────
+
+/**
+ * Render a single crew agent's progress block.
+ * Icon: ⟳ running ○ pending ✓ completed ✗ failed
+ * Header: "✓ executor (model) — 5 tools · 12.3s"
+ * Tool log: "▸ bash: $ npm test" / "  read: src/index.ts"
+ * Usage: "↑12k ↓3k R45k W0 $0.023"
+ */
+export function renderAgentProgress(
+	record: CrewAgentRecord, theme: Theme, expanded: boolean, w: number,
+): Container {
+	const c = new Container();
+	const prog = record.progress;
+	const isRunning = record.status === "running";
+	const isPending = record.status === "queued" || record.status === "waiting";
+	const innerW = Math.max(20, w);
+
+	const addLine = (content: string) =>
+		c.addChild(new Text(expanded ? content : truncLine(content, innerW), 0, 0));
+
+	// Status icon
+	const icon = isRunning ? theme.fg("warning", "⟳")
+		: isPending ? theme.fg("dim", "○")
+		: record.status === "completed" ? theme.fg("success", "✓")
+		: theme.fg("error", "✗");
+
+	// Duration
+	const durationMs = prog?.durationMs ?? computeDurationMs(record.startedAt, record.completedAt);
+	const stats = `${prog?.toolCount ?? record.toolUses ?? 0} tools · ${formatDuration(durationMs)}`;
+	const modelStr = record.model ? ` (${record.model})` : "";
+	const roleLabel = record.role || record.agent || "agent";
+	addLine(`${icon} ${theme.fg("toolTitle", theme.bold(roleLabel))}${theme.fg("dim", modelStr)} — ${theme.fg("dim", stats)}`);
+
+	// Current tool (running)
+	if (isRunning && prog?.currentTool) {
+		const toolLabel = formatToolPreview(prog.currentTool, parseArgs(prog.currentToolArgs));
+		addLine(theme.fg("warning", `▸ ${prog.currentTool}: ${toolLabel}`));
+	}
+
+	// Recent tools log
+	if (prog?.recentTools?.length) {
+		for (const tool of prog.recentTools) {
+			const detail = tool.args ? `: ${tool.args}` : "";
+			const line = tool.endedAt
+				? theme.fg("muted", `  ${tool.tool}${detail}`)
+				: theme.fg("warning", `▸ ${tool.tool}${detail}`);
+			addLine(line);
+		}
+	}
+
+	// Last assistant message (prose)
+	const lastOutput = prog?.recentOutput?.slice(-1)[0];
+	if (lastOutput?.trim()) {
+		c.addChild(new Spacer(1));
+		addLine(theme.fg("text", truncLine(lastOutput.replace(/\s+/g, " ").trim(), innerW)));
+	}
+
+	// Error
+	if (record.error) addLine(theme.fg("error", `Error: ${record.error}`));
+
+	// Usage line
+	const usage = record.usage;
+	const parts: string[] = [];
+	if (usage?.input) parts.push(theme.fg("dim", `↑${formatTokens(usage.input)}`));
+	if (usage?.output) parts.push(theme.fg("dim", `↓${formatTokens(usage.output)}`));
+	if (usage?.cacheRead) parts.push(theme.fg("dim", `R${formatTokens(usage.cacheRead)}`));
+	if (usage?.cacheWrite) parts.push(theme.fg("dim", `W${formatTokens(usage.cacheWrite)}`));
+	if (usage?.cost) parts.push(theme.fg("dim", `$${usage.cost.toFixed(3)}`));
+	const tokens = prog?.tokens ?? 0;
+	if (tokens > 0) parts.push(theme.fg("dim", `${formatTokens(tokens)} ctx`));
+	if (parts.length) { c.addChild(new Spacer(1)); addLine(parts.join(" ")); }
+
+	return c;
+}
+
+// ── Tool Result Renderers ──────────────────────────────────────────────
+
+/** team tool result: 'run' shows agent progress rows, else compact summary */
+export function renderTeamToolResult(
+	result: { details?: TeamToolResultDetails; content?: unknown[] } & Record<string, unknown>,
+	_options: unknown, theme: Theme, _context: unknown,
+): Component {
+	// Handle both nested details (result.details) and flattened result shape (details at root level)
+	const d = (result as any).details;
+
+	// If details is explicitly undefined/null, check if result itself looks like details (flattened)
+	// This handles cases where the result object has details properties at root level
+	if (d === undefined || d === null) {
+		// Check if result has detail-like properties to treat as flattened details
+		if ("action" in result || "status" in result || "runId" in result || "agentRecords" in result) {
+			// Use result as the details object
+			const c = new Container();
+			const records = (result as any).agentRecords ?? (result as any).results;
+			if ((result as any).action === "run" && records?.length) {
+				for (const r of records) c.addChild(renderAgentProgress(r, theme, false, 116));
+				return c;
+			}
+			// For 'run' action without records: show goal prominently with status badge
+			if ((result as any).action === "run") {
+				const goalText = (result as any).goal || "";
+				const statusBadge = (result as any).status ? theme.fg((result as any).status === "completed" ? "success" : (result as any).status === "failed" ? "error" : "warning", `[${(result as any).status}]`) + " " : "";
+				return new Text(statusBadge + theme.fg("text", truncLine(goalText, 116)), 0, 0);
+			}
+			// For other actions: compact info line
+			const parts: string[] = [];
+			if ((result as any).status) parts.push(`status=${(result as any).status}`);
+			if ((result as any).runId) parts.push(`runId=${(result as any).runId}`);
+			if ((result as any).error) parts.push(theme.fg("error", `error`));
+			if ((result as any).goal && parts.length === 0) parts.push(theme.fg("dim", truncLine((result as any).goal, 116)));
+			return new Text(parts.join(" "), 0, 0);
+		}
+		// No details found, fall back to content
+		const text = extractText(result?.content).slice(0, 200);
+		return new Text(text, 0, 0);
+	}
+
+	const c = new Container();
+	// Support both 'results' array from subagents and direct agentRecords
+	const records = d.agentRecords ?? d.results;
+	if (d.action === "run" && records?.length) {
+		for (const r of records) c.addChild(renderAgentProgress(r, theme, false, 116));
+		return c;
+	}
+	const parts: string[] = [];
+	if (d.status) parts.push(`status=${d.status}`);
+	if (d.runId) parts.push(`runId=${d.runId}`);
+	if (d.team) parts.push(`team=${d.team}`);
+	if (d.workflow) parts.push(`workflow=${d.workflow}`);
+	if (d.error) parts.push(theme.fg("error", `error=${d.error}`));
+	if (d.goal) parts.push(theme.fg("dim", truncLine(d.goal, 116)));
+	if (parts.length === 0) return new Text(theme.fg("muted", "(no output)"), 0, 0);
+	return new Text(parts.join(" · "), 0, 0);
+}
+
+/** agent tool result: shows agent output rows with status icons */
+export function renderAgentToolResult(
+	result: { details?: AgentToolResultDetails; content?: unknown[] } & Record<string, unknown>,
+	_options: unknown, theme: Theme, _context: unknown,
+): Component {
+	// Handle both nested details and flattened result shape
+	const d = (result as any).details ?? result;
+	const c = new Container();
+	const w = 116;
+
+	// Check for results array (from subagent) OR single agent properties (agentId, status)
+	const results = d?.results;
+	if (results?.length) {
+		for (const item of results) {
+			const icon = item.status === "completed" ? theme.fg("success", "✓")
+				: item.status === "failed" ? theme.fg("error", "✗")
+				: item.status === "running" ? theme.fg("warning", "⟳")
+				: theme.fg("dim", "○");
+			const label = item.agentId || "agent";
+			c.addChild(new Text(`${icon} ${theme.fg("toolTitle", theme.bold(label))}`, 0, 0));
+			if (item.error) {
+				c.addChild(new Text(theme.fg("error", `  Error: ${item.error}`), 0, 0));
+			} else if (item.output) {
+				for (const line of item.output.split("\n").slice(0, 5))
+					c.addChild(new Text(theme.fg("dim", `  ${truncLine(line, w - 2)}`), 0, 0));
+			}
+		}
+		return c;
+	}
+
+	// Handle single agent result shape: { agentId, runId, status, output }
+	if (d?.agentId) {
+		const icon = d.status === "completed" ? theme.fg("success", "✓")
+			: d.status === "failed" ? theme.fg("error", "✗")
+			: d.status === "running" ? theme.fg("warning", "⟳")
+			: theme.fg("dim", "○");
+		const label = d.agentId;
+		c.addChild(new Text(`${icon} ${theme.fg("toolTitle", theme.bold(label))}`, 0, 0));
+		if (d.error) {
+			c.addChild(new Text(theme.fg("error", `  Error: ${d.error}`), 0, 0));
+		} else if (d.output) {
+			for (const line of d.output.split("\n").slice(0, 5))
+				c.addChild(new Text(theme.fg("dim", `  ${truncLine(line, w - 2)}`), 0, 0));
+		}
+		return c;
+	}
+
+	return new Text(extractText(result?.content).slice(0, 200), 0, 0);
+}
+
+// ── Utilities ─────────────────────────────────────────────────────────
+
+function extractText(content: unknown[] | undefined): string {
+	if (!content) return "(no output)";
+	if (!Array.isArray(content)) return String(content);
+	return content.filter((c: any) => c?.type === "text").map((c: any) => c?.text ?? "").join("\n") || "(no output)";
+}
+
+function parseArgs(argsStr: string | undefined): Record<string, unknown> {
+	if (!argsStr) return {};
+	try {
+		const p = JSON.parse(argsStr);
+		return typeof p === "object" && p !== null ? p as Record<string, unknown> : {};
+	} catch { return {}; }
+}
+
+function computeDurationMs(startedAt: string, completedAt?: string): number {
+	if (!startedAt) return 0;
+	const start = new Date(startedAt).getTime();
+	if (isNaN(start)) return 0;
+	if (completedAt) { const end = new Date(completedAt).getTime(); return isNaN(end) ? 0 : Math.max(0, end - start); }
+	return Math.max(0, Date.now() - start);
+}

package/test-bugs-all.mjs

@@ -0,0 +1,85 @@
+import fs from "node:fs";
+import path from "node:path";
+
+console.log("=== PI-CREW BUG FIXES VERIFICATION ===\n");
+
+let allPassed = true;
+
+// Bug #17: Check killAsync is commented out
+console.log("Bug #17: Background runner session shutdown fix");
+const registerContent = fs.readFileSync("src/extension/register.ts", "utf-8");
+const killAsyncMatch = registerContent.match(/\/\/\s*for\s*\(\s*const\s+manifest\s+of\s+manifestCache\.list\(50\)/);
+if (killAsyncMatch) {
+    console.log("  ✅ killAsync loop is commented out");
+} else if (registerContent.includes("for (const manifest of manifestCache.list(50))") && !registerContent.includes("// for (const manifest")) {
+    console.log("  ❌ killAsync loop is NOT commented out - BUG NOT FIXED");
+    allPassed = false;
+} else {
+    console.log("  ✅ killAsync pattern not found (may have been refactored)");
+}
+
+// Bug #18: Check stdio is ["ignore", "pipe", "pipe"]
+console.log("\nBug #18: Child-pi stdin fix");
+const childPiContent = fs.readFileSync("src/runtime/child-pi.ts", "utf-8");
+const stdioMatch = childPiContent.match(/stdio:\s*\[\s*"ignore"\s*,\s*"pipe"\s*,\s*"pipe"\s*\]/);
+if (stdioMatch) {
+    console.log("  ✅ stdio is ['ignore', 'pipe', 'pipe']");
+} else if (childPiContent.includes('stdio: ["pipe", "pipe", "pipe"]')) {
+    console.log("  ❌ stdio is still ['pipe', 'pipe', 'pipe'] - BUG NOT FIXED");
+    allPassed = false;
+} else {
+    console.log("  ⚠️  stdio pattern not found in expected format");
+}
+
+// Bug #19: Check temp workspace cleanup
+console.log("\nBug #19: Phantom runs temp workspace fix");
+const runIndexContent = fs.readFileSync("src/extension/run-index.ts", "utf-8");
+const tempDirCheck = runIndexContent.includes("isTempRoot") || runIndexContent.includes("tmpdir") || runIndexContent.includes("tmpDir");
+const activeRunContent = fs.readFileSync("src/state/active-run-registry.ts", "utf-8");
+const timeoutCheck = activeRunContent.includes("30 * 60 * 1000") || activeRunContent.includes("30*60*1000");
+if (tempDirCheck && timeoutCheck) {
+    console.log("  ✅ Temp workspace detection and 30-min timeout present");
+} else if (!tempDirCheck) {
+    console.log("  ❌ Temp workspace detection NOT found - BUG NOT FIXED");
+    allPassed = false;
+} else if (!timeoutCheck) {
+    console.log("  ❌ 30-min timeout NOT found - BUG NOT FIXED");
+    allPassed = false;
+}
+
+// Bug #20: Check needs_attention in completedIds
+console.log("\nBug #20: Infinite retry loop fix");
+const teamRunnerContent = fs.readFileSync("src/runtime/team-runner.ts", "utf-8");
+const needsAttentionMatch = teamRunnerContent.match(/status\s*===\s*"needs_attention"/g);
+if (needsAttentionMatch && needsAttentionMatch.length >= 3) {
+    console.log("  ✅ needs_attention status checks found (" + needsAttentionMatch.length + " places)");
+} else {
+    console.log("  ❌ needs_attention status check NOT found or insufficient - BUG NOT FIXED");
+    allPassed = false;
+}
+
+// Check the specific completedIds fix
+const completedIdsFix = teamRunnerContent.includes('status === "completed" || t.status === "needs_attention"');
+if (completedIdsFix) {
+    console.log("  ✅ completedIds includes needs_attention");
+} else {
+    console.log("  ❌ completedIds does NOT include needs_attention - BUG NOT FIXED");
+    allPassed = false;
+}
+
+// Check dist file
+console.log("\n=== Checking dist/index.mjs ===");
+const distContent = fs.readFileSync("dist/index.mjs", "utf-8");
+const distNeedsAttention = distContent.includes('status === "completed" || t.status === "needs_attention"');
+if (distNeedsAttention) {
+    console.log("  ✅ Bug #20 fix is in dist/index.mjs");
+} else {
+    console.log("  ❌ Bug #20 fix NOT in dist/index.mjs - rebuild needed");
+    allPassed = false;
+}
+
+console.log("\n" + "=".repeat(40));
+console.log(allPassed ? "✅ ALL BUGS ARE FIXED" : "❌ SOME BUGS ARE NOT FIXED");
+console.log("=".repeat(40));
+
+process.exit(allPassed ? 0 : 1);

package/test-lastActivityAt.mjs

@@ -0,0 +1,167 @@
+/**
+ * Test for lastActivityAt fallback in heartbeat-watcher
+ * Verifies that tasks with stale heartbeat but recent lastActivityAt are not marked dead
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { createMetricRegistry } from "./src/observability/metric-registry.ts";
+import { HeartbeatWatcher } from "./src/runtime/heartbeat-watcher.ts";
+import { createRunManifest, saveRunTasks, updateRunStatus } from "./src/state/state-store.ts";
+import { createManifestCache } from "./src/runtime/manifest-cache.ts";
+
+const team = { name: "t", description: "", source: "test", filePath: "t", roles: [{ name: "r", agent: "a" }] };
+const workflow = { name: "w", description: "", source: "test", filePath: "w", steps: [{ id: "s", role: "r", task: "x" }] };
+
+test("HeartbeatWatcher uses lastActivityAt fallback - task NOT dead when heartbeat stale but activity recent", () => {
+	const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "pi-crew-lastactivity-at-"));
+	try {
+		fs.writeFileSync(path.join(cwd, "package.json"), "{}", "utf-8");
+		const created = createRunManifest({ cwd, team, workflow, goal: "hb" });
+		const manifest = updateRunStatus(created.manifest, "running", "running");
+		
+		// Create task with STALE heartbeat (old lastSeenAt) but RECENT lastActivityAt
+		// Heartbeat is from Jan 1, 2026 (stale - 10 minutes old)
+		// lastActivityAt is from Jan 1, 2026 00:08:00 (2 minutes old - within dead threshold of 5 minutes)
+		const tasksWithHeartbeat = created.tasks.map((task) => ({
+			...task,
+			status: "running",
+			heartbeat: { workerId: task.id, lastSeenAt: "2026-01-01T00:00:00.000Z", alive: true },
+			// Agent is still active - lastActivityAt is recent (within dead threshold)
+			agentProgress: { 
+				lastActivityAt: "2026-01-01T00:08:00.000Z",  // 2 minutes ago
+				currentTool: "working",
+				toolCount: 5,
+				tokens: 1000,
+				turns: 2
+			}
+		}));
+		
+		saveRunTasks(manifest, tasksWithHeartbeat);
+		const cache = createManifestCache(cwd, { watch: false, debounceMs: 0 });
+		const notifications = [];
+		let deadletters = 0;
+		const watcher = new HeartbeatWatcher({ 
+			cwd, 
+			manifestCache: cache, 
+			registry: createMetricRegistry(), 
+			router: { enqueue: (n) => { notifications.push(n.id ?? ""); return true; } }, 
+			deadletterTickThreshold: 3, 
+			onDeadletterTrigger: () => { deadletters += 1; } 
+		});
+		
+		// Simulate time at 00:10:00 - 10 minutes after heartbeat, 2 minutes after activity
+		// With fallback: activity age = 2 minutes < dead threshold (5 minutes) -> should be warn/stale, not dead
+		watcher.tick(Date.parse("2026-01-01T00:10:00.000Z"));
+		watcher.tick(Date.parse("2026-01-01T00:10:05.000Z"));
+		watcher.tick(Date.parse("2026-01-01T00:10:10.000Z"));
+		
+		// Should NOT have any dead notifications because lastActivityAt is recent
+		assert.equal(notifications.length, 0, "Should NOT mark task dead when lastActivityAt is recent (within dead threshold)");
+		assert.equal(deadletters, 0, "Should NOT trigger deadletter when lastActivityAt is recent");
+		
+		watcher.dispose();
+		cache.dispose();
+	} finally {
+		fs.rmSync(cwd, { recursive: true, force: true });
+	}
+});
+
+test("HeartbeatWatcher marks task dead when BOTH heartbeat and lastActivityAt are stale", () => {
+	const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "pi-crew-both-stale-"));
+	try {
+		fs.writeFileSync(path.join(cwd, "package.json"), "{}", "utf-8");
+		const created = createRunManifest({ cwd, team, workflow, goal: "hb" });
+		const manifest = updateRunStatus(created.manifest, "running", "running");
+		
+		// Create task with BOTH stale heartbeat AND stale lastActivityAt
+		// Heartbeat is from Jan 1, 2026 00:00:00 (10 minutes old)
+		// lastActivityAt is also from Jan 1, 2026 00:00:00 (also 10 minutes old - beyond dead threshold)
+		const tasksWithHeartbeat = created.tasks.map((task) => ({
+			...task,
+			status: "running",
+			heartbeat: { workerId: task.id, lastSeenAt: "2026-01-01T00:00:00.000Z", alive: true },
+			agentProgress: { 
+				lastActivityAt: "2026-01-01T00:00:00.000Z",  // 10 minutes old - beyond dead threshold
+				currentTool: "done",
+				toolCount: 5,
+				tokens: 1000,
+				turns: 2
+			}
+		}));
+		
+		saveRunTasks(manifest, tasksWithHeartbeat);
+		const cache = createManifestCache(cwd, { watch: false, debounceMs: 0 });
+		const notifications = [];
+		let deadletters = 0;
+		const watcher = new HeartbeatWatcher({ 
+			cwd, 
+			manifestCache: cache, 
+			registry: createMetricRegistry(), 
+			router: { enqueue: (n) => { notifications.push(n.id ?? ""); return true; } }, 
+			deadletterTickThreshold: 3, 
+			onDeadletterTrigger: () => { deadletters += 1; } 
+		});
+		
+		// Simulate time at 00:10:00 - both heartbeat and activity are 10 minutes old
+		watcher.tick(Date.parse("2026-01-01T00:10:00.000Z"));
+		watcher.tick(Date.parse("2026-01-01T00:10:05.000Z"));
+		watcher.tick(Date.parse("2026-01-01T00:10:10.000Z"));
+		
+		// SHOULD have dead notifications because BOTH are stale (> 5 minutes)
+		assert.ok(notifications.length > 0, "Should mark task dead when BOTH heartbeat and lastActivityAt are stale");
+		assert.ok(deadletters > 0, "Should trigger deadletter when BOTH are stale");
+		
+		watcher.dispose();
+		cache.dispose();
+	} finally {
+		fs.rmSync(cwd, { recursive: true, force: true });
+	}
+});
+
+test("HeartbeatWatcher without lastActivityAt still marks stale heartbeat as dead", () => {
+	const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "pi-crew-no-activity-"));
+	try {
+		fs.writeFileSync(path.join(cwd, "package.json"), "{}", "utf-8");
+		const created = createRunManifest({ cwd, team, workflow, goal: "hb" });
+		const manifest = updateRunStatus(created.manifest, "running", "running");
+		
+		// Create task with stale heartbeat but NO lastActivityAt
+		const tasksWithHeartbeat = created.tasks.map((task) => ({
+			...task,
+			status: "running",
+			heartbeat: { workerId: task.id, lastSeenAt: "2026-01-01T00:00:00.000Z", alive: true },
+			// No agentProgress at all
+		}));
+		
+		saveRunTasks(manifest, tasksWithHeartbeat);
+		const cache = createManifestCache(cwd, { watch: false, debounceMs: 0 });
+		const notifications = [];
+		let deadletters = 0;
+		const watcher = new HeartbeatWatcher({ 
+			cwd, 
+			manifestCache: cache, 
+			registry: createMetricRegistry(), 
+			router: { enqueue: (n) => { notifications.push(n.id ?? ""); return true; } }, 
+			deadletterTickThreshold: 3, 
+			onDeadletterTrigger: () => { deadletters += 1; } 
+		});
+		
+		// Simulate time at 00:10:00 - heartbeat is 10 minutes old
+		watcher.tick(Date.parse("2026-01-01T00:10:00.000Z"));
+		watcher.tick(Date.parse("2026-01-01T00:10:05.000Z"));
+		watcher.tick(Date.parse("2026-01-01T00:10:10.000Z"));
+		
+		// SHOULD have dead notifications because heartbeat is stale and no fallback
+		assert.ok(notifications.length > 0, "Should mark task dead when heartbeat stale and no lastActivityAt");
+		assert.ok(deadletters > 0, "Should trigger deadletter when no fallback available");
+		
+		watcher.dispose();
+		cache.dispose();
+	} finally {
+		fs.rmSync(cwd, { recursive: true, force: true });
+	}
+});

package/test-tp.mjs

@@ -0,0 +1,12 @@
+import { formatToolProgress, formatCurrentToolLine } from "./src/runtime/tool-progress.ts";
+
+const progress = {
+  recentTools: [{ tool: "bash", args: "ls", endedAt: "2024-01-01T00:00:00.000Z" }],
+  toolCount: 1,
+  activityState: "active"
+};
+
+const display = formatToolProgress(progress);
+console.log("currentTool:", display.currentTool);
+console.log("toolCount:", display.toolCount);
+console.log("TEST PASSED if no errors above");