pi-crew 0.1.32 → 0.1.34

package/src/extension/autonomous-policy.ts

@@ -5,22 +5,61 @@ import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
 import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
 
 const DEFAULT_MAGIC_KEYWORDS: Record<string, string[]> = {
-	implementation: ["autoteam", "team:", "implementation-team"],
+	implementation: ["autoteam", "team:", "implementation-team", "pi-crew", "dùng team", "use team"],
 	review: ["review-team", "security review", "code review"],
 	fastFix: ["fast-fix", "quick fix"],
 	research: ["research-team", "deep research"],
 };
 
+const BULLET_OR_NUMBERED_TASK_RE = /^\s*(?:[-*•]|\d+[.)])\s+\S+/;
+const ACTIONABLE_TASK_TERMS: readonly string[] = Array.from(new Set([
+	"implement",
+	"refactor",
+	"migrate",
+	"fix",
+	"add",
+	"update",
+	"test",
+	"review",
+	"research",
+	"analyze",
+	"document",
+	"docs",
+	"sửa",
+	"thêm",
+	"cập nhật",
+	"kiểm thử",
+	"nghiên cứu",
+	"phân tích",
+	"viết docs",
+]));
+
 function mergeMagicKeywords(configured: Record<string, string[]> | undefined): Record<string, string[]> {
 	return { ...DEFAULT_MAGIC_KEYWORDS, ...(configured ?? {}) };
 }
 
+function actionableLineCount(prompt: string): number {
+	return prompt
+		.split(/\r?\n/)
+		.map((line) => line.trim())
+		.filter((line) => BULLET_OR_NUMBERED_TASK_RE.test(line) && ACTIONABLE_TASK_TERMS.some((term) => line.toLowerCase().includes(term)))
+		.length;
+}
+
+function hasTaskListSignal(prompt: string): boolean {
+	const lower = prompt.toLowerCase();
+	const bulletCount = prompt.split(/\r?\n/).filter((line) => BULLET_OR_NUMBERED_TASK_RE.test(line)).length;
+	const explicitList = ["các task", "danh sách task", "todo", "tasks sau", "task list", "làm lần lượt"].some((term) => lower.includes(term));
+	return bulletCount >= 3 || actionableLineCount(prompt) >= 2 || (explicitList && bulletCount >= 2);
+}
+
 export function detectTeamIntent(prompt: string, config: PiTeamsAutonomousConfig = {}): string[] {
 	const lower = prompt.toLowerCase();
 	const matches: string[] = [];
 	for (const [intent, keywords] of Object.entries(mergeMagicKeywords(config.magicKeywords))) {
 		if (keywords.some((keyword) => lower.includes(keyword.toLowerCase()))) matches.push(intent);
 	}
+	if (hasTaskListSignal(prompt) && !matches.includes("taskList")) matches.push("taskList");
 	return matches;
 }
 
@@ -39,8 +78,15 @@ export function buildAutonomousPolicy(prompt: string, config: PiTeamsAutonomousC
 		`Autonomy profile: ${effective.profile}.`,
 		"You have access to the `team` tool for coordinated multi-agent work. Use it proactively when the task benefits from specialized roles, planning, review, verification, durable artifacts, async execution, or worktree isolation.",
 		"",
+		"Decision framework (not keyword-only):",
+		"- Treat a user-supplied task list with 2+ actionable bullets/numbered items as a delegation candidate even when no pi-crew keyword appears.",
+		"- Prefer `team` when tasks span multiple files/subsystems, require sequencing, combine implementation + tests/docs/review, or need independent exploration before edits.",
+		"- If unsure whether subtasks conflict, call `team` with action='recommend' first instead of manually splitting work.",
+		"- For assisted/aggressive autonomy and non-trivial multi-task work, prefer a team run or plan over direct single-agent execution.",
+		"",
 		"Use `team` automatically when:",
 		"- The task spans multiple files, subsystems, or unclear code areas.",
+		"- The prompt contains a non-trivial task list, roadmap, checklist, migration plan, or ordered implementation plan.",
 		"- The task requires planning before implementation.",
 		"- The task asks for implementation plus tests, review, verification, migration, architecture, security review, or debugging.",
 		"- The task would benefit from explorer/planner/executor/reviewer/verifier roles.",
@@ -48,6 +94,7 @@ export function buildAutonomousPolicy(prompt: string, config: PiTeamsAutonomousC
 		"Do not use `team` when:",
 		"- The user asks a simple factual question or tiny single-file edit.",
 		"- The user explicitly asks you to work directly without delegation.",
+		"- The tasks clearly modify the same small file region and can be completed safer by one agent without parallel fanout.",
 		"- The action is destructive (`delete`, `forget`, `prune`, forced cleanup) and the user has not explicitly confirmed it.",
 		"",
 		"Recommended mappings:",
@@ -60,9 +107,16 @@ export function buildAutonomousPolicy(prompt: string, config: PiTeamsAutonomousC
 		"- Before claiming delegated work is complete, inspect the run with action='status' or action='summary'.",
 		"- Unsure or risky work -> action='plan' first, then run the selected team.",
 		"",
+		"Conflict-safe task splitting:",
+		"- Do not parallelize subtasks that may edit the same file, same symbol, same migration path, package manifest, lockfile, or generated schema unless a planner explicitly sequences them.",
+		"- For potential overlap, use plan/recommend first, assign one owner per file/symbol, and require workers to report intended changed files before editing.",
+		"- Prefer workspaceMode: 'worktree' for parallel implementation in clean git repositories, but still avoid merging overlapping edits without review.",
+		"- If workers discover overlap, blockers, missing requirements, or need leader decisions, they must use mailbox/status artifacts to ask the leader/orchestrator and pause risky edits.",
+		"- The leader should resolve conflicts by sequencing, narrowing scope, or reassigning ownership before continuing.",
+		"",
 		asyncGuidance,
 		worktreeGuidance,
-		intents.length > 0 ? `Detected pi-crew routing keywords/intents in the user prompt: ${intents.join(", ")}. Consider the matching team workflow if appropriate.` : "No explicit pi-crew magic keyword was detected; decide based on task complexity and risk.",
+		intents.length > 0 ? `Detected pi-crew routing signals/intents in the user prompt: ${intents.join(", ")}. Consider the matching team workflow if appropriate.` : "No explicit pi-crew routing signal was detected; decide based on complexity, risk, task-list structure, and conflict potential.",
 	].join("\n");
 }
 

package/src/extension/notification-router.ts

@@ -0,0 +1,116 @@
+export type Severity = "info" | "warning" | "error" | "critical";
+
+export interface NotificationDescriptor {
+	id?: string;
+	severity: Severity;
+	source: string;
+	runId?: string;
+	title: string;
+	body?: string;
+	timestamp?: number;
+}
+
+export interface NotificationRouterOptions {
+	dedupWindowMs?: number;
+	batchWindowMs?: number;
+	quietHours?: string;
+	severityFilter?: Severity[];
+	sink?: (notification: NotificationDescriptor) => void;
+	now?: () => number;
+}
+
+const DEFAULT_SEVERITY_FILTER: Severity[] = ["warning", "error", "critical"];
+const SEVERITY_RANK: Record<Severity, number> = { info: 0, warning: 1, error: 2, critical: 3 };
+
+export function parseHHMMRange(range: string): { startMin: number; endMin: number } {
+	const match = /^(\d{2}):(\d{2})-(\d{2}):(\d{2})$/.exec(range);
+	if (!match) throw new Error(`Invalid quiet-hours range '${range}'. Expected HH:MM-HH:MM.`);
+	const [, sh, sm, eh, em] = match;
+	const startHour = Number(sh);
+	const startMinute = Number(sm);
+	const endHour = Number(eh);
+	const endMinute = Number(em);
+	if (startHour > 23 || endHour > 23 || startMinute > 59 || endMinute > 59) throw new Error(`Invalid quiet-hours range '${range}'.`);
+	return { startMin: startHour * 60 + startMinute, endMin: endHour * 60 + endMinute };
+}
+
+export function isInQuietHours(range: string, now = new Date()): boolean {
+	const { startMin, endMin } = parseHHMMRange(range);
+	const current = now.getHours() * 60 + now.getMinutes();
+	if (startMin === endMin) return false;
+	return startMin <= endMin ? current >= startMin && current < endMin : current >= startMin || current < endMin;
+}
+
+function notificationKey(notification: NotificationDescriptor): string {
+	return notification.id ?? `${notification.source}:${notification.runId ?? "global"}:${notification.title}`;
+}
+
+function batchSeverity(items: NotificationDescriptor[]): Severity {
+	return items.reduce((highest, item) => SEVERITY_RANK[item.severity] > SEVERITY_RANK[highest] ? item.severity : highest, "info" as Severity);
+}
+
+export class NotificationRouter {
+	private readonly opts: NotificationRouterOptions;
+	private readonly deliver: (notification: NotificationDescriptor) => void;
+	private readonly seen = new Map<string, number>();
+	private batch: NotificationDescriptor[] = [];
+	private timer: ReturnType<typeof setTimeout> | undefined;
+
+	constructor(opts: NotificationRouterOptions = {}, deliver: (notification: NotificationDescriptor) => void) {
+		this.opts = opts;
+		this.deliver = deliver;
+	}
+
+	enqueue(notification: NotificationDescriptor): boolean {
+		const now = this.opts.now?.() ?? Date.now();
+		const withTime = { ...notification, timestamp: notification.timestamp ?? now };
+		try {
+			this.opts.sink?.(withTime);
+		} catch {
+			// Notification delivery must never crash the extension.
+		}
+		const filter = this.opts.severityFilter ?? DEFAULT_SEVERITY_FILTER;
+		if (!filter.includes(withTime.severity)) return false;
+		if (this.opts.quietHours && isInQuietHours(this.opts.quietHours, new Date(now))) return false;
+		const key = notificationKey(withTime);
+		const dedupWindow = this.opts.dedupWindowMs ?? 30_000;
+		const previous = this.seen.get(key);
+		if (previous !== undefined && now - previous < dedupWindow) return false;
+		this.seen.set(key, now);
+		const batchWindow = this.opts.batchWindowMs ?? 0;
+		if (batchWindow <= 0) {
+			this.deliver(withTime);
+			return true;
+		}
+		this.batch.push(withTime);
+		if (!this.timer) this.timer = setTimeout(() => this.flush(), batchWindow);
+		return true;
+	}
+
+	flush(): void {
+		if (this.timer) clearTimeout(this.timer);
+		this.timer = undefined;
+		if (this.batch.length === 0) return;
+		const items = this.batch;
+		this.batch = [];
+		if (items.length === 1) {
+			this.deliver(items[0]!);
+			return;
+		}
+		this.deliver({
+			id: `batch:${items.map((item) => notificationKey(item)).join(",")}`,
+			severity: batchSeverity(items),
+			source: "batch",
+			title: `${items.length} pi-crew notifications`,
+			body: items.map((item) => `• ${item.title}`).join("\n"),
+			timestamp: this.opts.now?.() ?? Date.now(),
+		});
+	}
+
+	dispose(): void {
+		if (this.timer) clearTimeout(this.timer);
+		this.timer = undefined;
+		this.batch = [];
+		this.seen.clear();
+	}
+}

package/src/extension/notification-sink.ts

@@ -0,0 +1,51 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { NotificationDescriptor } from "./notification-router.ts";
+import { redactSecrets } from "../runtime/diagnostic-export.ts";
+import { logInternalError } from "../utils/internal-error.ts";
+
+export interface NotificationSink {
+	write(notification: NotificationDescriptor): void;
+	dispose(): void;
+}
+
+function rotateOldFiles(dir: string, retentionDays: number, now = Date.now()): void {
+	if (!fs.existsSync(dir)) return;
+	const cutoff = now - retentionDays * 24 * 60 * 60 * 1000;
+	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+		if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
+		const filePath = path.join(dir, entry.name);
+		try {
+			if (fs.statSync(filePath).mtimeMs < cutoff) fs.unlinkSync(filePath);
+		} catch (error) {
+			logInternalError("notification-sink.rotate", error, filePath);
+		}
+	}
+}
+
+export function createJsonlSink(crewRoot: string, retentionDays = 7): NotificationSink {
+	const dir = path.join(crewRoot, "state", "notifications");
+	let lastRotateDate = "";
+	return {
+		write(notification: NotificationDescriptor): void {
+			try {
+				const timestamp = notification.timestamp ?? Date.now();
+				const date = new Date(timestamp).toISOString().slice(0, 10);
+				if (date !== lastRotateDate) {
+					rotateOldFiles(dir, retentionDays, timestamp);
+					lastRotateDate = date;
+				}
+				fs.mkdirSync(dir, { recursive: true });
+				const payload = redactSecrets({ ...notification, timestamp }) as NotificationDescriptor;
+				fs.appendFileSync(path.join(dir, `${date}.jsonl`), `${JSON.stringify(payload)}\n`, "utf-8");
+			} catch (error) {
+				logInternalError("notification-sink.write", error);
+			}
+		},
+		dispose(): void {
+			// Synchronous append-only sink has no resources to close.
+		},
+	};
+}
+
+export const __test__ = { rotateOldFiles };

package/src/extension/register.ts

@@ -11,7 +11,7 @@ import { loadRunManifestById, updateRunStatus } from "../state/state-store.ts";
 import { terminateActiveChildPiProcesses } from "../subagents/spawn.ts";
 import { SubagentManager } from "../subagents/manager.ts";
 import { __test__subagentSpawnParams, sendFollowUp } from "./registration/subagent-helpers.ts";
-import { DEFAULT_UI } from "../config/defaults.ts";
+import { DEFAULT_NOTIFICATIONS, DEFAULT_UI } from "../config/defaults.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { createManifestCache } from "../runtime/manifest-cache.ts";
 import { resetTimings, time } from "../utils/timings.ts";
@@ -20,6 +20,13 @@ import { registerSubagentTools } from "./registration/subagent-tools.ts";
 import { runArtifactCleanup } from "./registration/artifact-cleanup.ts";
 import { registerTeamTool } from "./registration/team-tool.ts";
 import { registerCompactionGuard } from "./registration/compaction-guard.ts";
+import { requestRender, setExtensionWidget, setWorkingIndicator, showCustom } from "../ui/pi-ui-compat.ts";
+import { createRunSnapshotCache } from "../ui/run-snapshot-cache.ts";
+import { RenderScheduler } from "../ui/render-scheduler.ts";
+import { NotificationRouter, type NotificationDescriptor } from "./notification-router.ts";
+import { createJsonlSink, type NotificationSink } from "./notification-sink.ts";
+import { projectCrewRoot } from "../utils/paths.ts";
+import { summarizeHeartbeats } from "../ui/heartbeat-aggregator.ts";
 
 export { __test__subagentSpawnParams };
 
@@ -42,14 +49,58 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	let rpcHandle: PiCrewRpcHandle | undefined;
 	let cleanedUp = false;
 	let manifestCache = createManifestCache(process.cwd());
+	let runSnapshotCache = createRunSnapshotCache(process.cwd());
+	let cacheCwd = process.cwd();
 	const getManifestCache = (cwd: string): ReturnType<typeof createManifestCache> => {
-		if (manifestCache && currentCtx?.cwd === cwd) return manifestCache;
+		if (manifestCache && cacheCwd === cwd) return manifestCache;
 		if (manifestCache) manifestCache.dispose();
+		if (runSnapshotCache) runSnapshotCache.dispose?.();
+		cacheCwd = cwd;
 		manifestCache = createManifestCache(cwd);
+		runSnapshotCache = createRunSnapshotCache(cwd);
 		return manifestCache;
 	};
+	const getRunSnapshotCache = (cwd: string): ReturnType<typeof createRunSnapshotCache> => {
+		if (cacheCwd !== cwd) getManifestCache(cwd);
+		return runSnapshotCache;
+	};
 	const telemetryEnabled = (): boolean => loadConfig(currentCtx?.cwd ?? process.cwd()).config.telemetry?.enabled !== false;
 	const widgetState: CrewWidgetState = { frame: 0 };
+	let notificationSink: NotificationSink | undefined;
+	let notificationRouter: NotificationRouter | undefined;
+	const configureNotifications = (ctx: ExtensionContext): void => {
+		notificationRouter?.dispose();
+		notificationSink?.dispose();
+		notificationRouter = undefined;
+		notificationSink = undefined;
+		const config = loadConfig(ctx.cwd).config;
+		if (config.notifications?.enabled === false) return;
+		if (config.telemetry?.enabled !== false) notificationSink = createJsonlSink(projectCrewRoot(ctx.cwd), config.notifications?.sinkRetentionDays ?? DEFAULT_NOTIFICATIONS.sinkRetentionDays);
+		notificationRouter = new NotificationRouter({
+			dedupWindowMs: config.notifications?.dedupWindowMs ?? DEFAULT_NOTIFICATIONS.dedupWindowMs,
+			batchWindowMs: config.notifications?.batchWindowMs ?? DEFAULT_NOTIFICATIONS.batchWindowMs,
+			quietHours: config.notifications?.quietHours,
+			severityFilter: config.notifications?.severityFilter ?? [...DEFAULT_NOTIFICATIONS.severityFilter],
+			sink: (notification) => notificationSink?.write(notification),
+		}, (notification) => {
+			widgetState.notificationCount = (widgetState.notificationCount ?? 0) + 1;
+			sendFollowUp(pi, [notification.title, notification.body, notification.runId ? `Run: ${notification.runId}` : undefined].filter((line): line is string => Boolean(line)).join("\n"));
+			if (currentCtx) {
+				const uiConfig = loadConfig(currentCtx.cwd).config.ui;
+				updateCrewWidget(currentCtx, widgetState, uiConfig, getManifestCache(currentCtx.cwd), getRunSnapshotCache(currentCtx.cwd));
+				updatePiCrewPowerbar(pi.events, currentCtx.cwd, uiConfig, getManifestCache(currentCtx.cwd), getRunSnapshotCache(currentCtx.cwd), currentCtx, widgetState.notificationCount ?? 0);
+			}
+		});
+	};
+	const autoRecoveryLast = new Map<string, number>();
+	const notifyOperator = (notification: NotificationDescriptor): void => {
+		try {
+			notificationRouter?.enqueue(notification);
+		} catch (error) {
+			logInternalError("register.notification", error);
+			sendFollowUp(pi, [notification.title, notification.body].filter((line): line is string => Boolean(line)).join("\n"));
+		}
+	};
 	const subagentManager = new SubagentManager(
 		4,
 		(record) => {
@@ -68,7 +119,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 			}
 			if (!record.background || record.resultConsumed) return;
 			if (record.status === "completed" || record.status === "failed" || record.status === "cancelled" || record.status === "blocked" || record.status === "error") {
-				sendFollowUp(pi, [`pi-crew subagent ${record.id} ${record.status}.`, record.runId ? `Run: ${record.runId}` : undefined, `Use get_subagent_result with agent_id=${record.id} for output.`].filter((line): line is string => Boolean(line)).join("\n"));
+				notifyOperator({ id: `subagent:${record.id}:${record.status}`, severity: record.status === "completed" ? "info" : "warning", source: "subagent-completed", runId: record.runId, title: `pi-crew subagent ${record.id} ${record.status}.`, body: `Use get_subagent_result with agent_id=${record.id} for output.` });
 			}
 		},
 		1000,
@@ -77,25 +128,24 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 				const id = typeof payload.id === "string" ? payload.id : "unknown";
 				const runId = typeof payload.runId === "string" ? payload.runId : "unknown";
 				const durationMs = typeof payload.durationMs === "number" ? payload.durationMs : 0;
-				sendFollowUp(pi, [`pi-crew subagent ${id} may be stuck in blocked state for ${Math.max(1, Math.round(durationMs / 1000))}s.`, `Run: ${runId}`, `Use team status runId=${runId} and investigate.`, "Subagent may need manual intervention."].filter((line): line is string => Boolean(line)).join("\n"));
+				notifyOperator({ id: `subagent-stuck:${id}:${runId}`, severity: "warning", source: "subagent-stuck", runId, title: `pi-crew subagent ${id} may be stuck in blocked state for ${Math.max(1, Math.round(durationMs / 1000))}s.`, body: `Use team status runId=${runId} and investigate.\nSubagent may need manual intervention.` });
 			}
 			pi.events?.emit?.(event, payload);
 		},
 	);
 	const foregroundControllers = new Set<AbortController>();
 	let liveSidebarRunId: string | undefined;
-	let liveSidebarTimer: ReturnType<typeof setInterval> | undefined;
-	const requestRender = (ctx: ExtensionContext): void => (ctx.ui as { requestRender?: () => void }).requestRender?.();
+	let renderScheduler: RenderScheduler | undefined;
 	const stopSessionBoundSubagents = (): void => {
 		for (const controller of foregroundControllers) controller.abort();
 		foregroundControllers.clear();
 		subagentManager.abortAll();
 		terminateActiveChildPiProcesses();
-		if (liveSidebarTimer) clearInterval(liveSidebarTimer);
-		liveSidebarTimer = undefined;
+		renderScheduler?.dispose();
+		renderScheduler = undefined;
 		liveSidebarRunId = undefined;
 		if (currentCtx) stopCrewWidget(currentCtx, widgetState, loadConfig(currentCtx.cwd).config.ui);
-		clearPiCrewPowerbar(pi.events);
+		clearPiCrewPowerbar(pi.events, currentCtx);
 	};
 	const openLiveSidebar = (ctx: ExtensionContext, runId: string): void => {
 		const uiConfig = loadConfig(ctx.cwd).config.ui;
@@ -103,28 +153,28 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		const foregroundAutoOpen = uiConfig?.autoOpenDashboardForForegroundRuns !== false;
 		if (!ctx.hasUI || !autoOpen || !foregroundAutoOpen || (uiConfig?.dashboardPlacement ?? "right") !== "right") return;
 		if (liveSidebarRunId === runId) return;
-		if (liveSidebarTimer) clearInterval(liveSidebarTimer);
 		liveSidebarRunId = runId;
-		ctx.ui.setWidget("pi-crew", undefined, { placement: uiConfig?.widgetPlacement ?? "aboveEditor" });
-		ctx.ui.setWidget("pi-crew-active", undefined, { placement: uiConfig?.widgetPlacement ?? "aboveEditor" });
+		const widgetPlacement = uiConfig?.widgetPlacement ?? "aboveEditor";
+		setExtensionWidget(ctx, "pi-crew", undefined, { placement: widgetPlacement });
+		setExtensionWidget(ctx, "pi-crew-active", undefined, { placement: widgetPlacement });
+		widgetState.lastVisibility = "hidden";
+		widgetState.lastPlacement = widgetPlacement;
+		widgetState.lastKey = "pi-crew-active";
+		widgetState.model = undefined;
 		const width = Math.min(90, Math.max(40, uiConfig?.dashboardWidth ?? 56));
-		liveSidebarTimer = setInterval(() => requestRender(ctx), uiConfig?.dashboardLiveRefreshMs ?? DEFAULT_UI.refreshMs);
-		liveSidebarTimer.unref?.();
-		void ctx.ui.custom<undefined>((_tui, theme, _keybindings, done) => new LiveRunSidebar({ cwd: ctx.cwd, runId, done, theme, config: uiConfig }), {
+		void showCustom<undefined>(ctx, (_tui, theme, _keybindings, done) => new LiveRunSidebar({ cwd: ctx.cwd, runId, done, theme, config: uiConfig, snapshotCache: getRunSnapshotCache(ctx.cwd) }), {
 			overlay: true,
 			overlayOptions: { width, minWidth: 40, maxHeight: "100%", anchor: "top-right", offsetX: 0, offsetY: 0, margin: { top: 0, right: 0, bottom: 0, left: 0 }, visible: (termWidth: number) => termWidth >= 100 },
 		}).finally(() => {
 			if (liveSidebarRunId === runId) liveSidebarRunId = undefined;
-			if (liveSidebarTimer) clearInterval(liveSidebarTimer);
-			liveSidebarTimer = undefined;
-			updateCrewWidget(ctx, widgetState, loadConfig(ctx.cwd).config.ui, getManifestCache(ctx.cwd));
+			updateCrewWidget(ctx, widgetState, loadConfig(ctx.cwd).config.ui, getManifestCache(ctx.cwd), getRunSnapshotCache(ctx.cwd));
 		});
 	};
 	const startForegroundRun = (ctx: ExtensionContext, runner: (signal?: AbortSignal) => Promise<void>, runId?: string): void => {
 		const controller = new AbortController();
 		foregroundControllers.add(controller);
 		if (ctx.hasUI) {
-			(ctx.ui as { setWorkingIndicator?: (options?: { frames?: string[]; intervalMs?: number }) => void }).setWorkingIndicator?.({ frames: ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"], intervalMs: 80 });
+			setWorkingIndicator(ctx, { frames: ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"], intervalMs: 80 });
 			ctx.ui.setWorkingMessage(runId ? `pi-crew foreground run ${runId}...` : "pi-crew foreground run...");
 		}
 		setImmediate(() => {
@@ -144,7 +194,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 				.finally(() => {
 					foregroundControllers.delete(controller);
 					if (ctx.hasUI) {
-						(ctx.ui as { setWorkingIndicator?: (options?: { frames?: string[]; intervalMs?: number }) => void }).setWorkingIndicator?.();
+						setWorkingIndicator(ctx);
 						ctx.ui.setWorkingMessage();
 					}
 					if (runId) {
@@ -177,8 +227,8 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 					}
 					if (currentCtx) {
 						const config = loadConfig(currentCtx.cwd).config.ui;
-						updateCrewWidget(currentCtx, widgetState, config, getManifestCache(currentCtx.cwd));
-						updatePiCrewPowerbar(pi.events, currentCtx.cwd, config, getManifestCache(currentCtx.cwd));
+						updateCrewWidget(currentCtx, widgetState, config, getManifestCache(currentCtx.cwd), getRunSnapshotCache(currentCtx.cwd));
+						updatePiCrewPowerbar(pi.events, currentCtx.cwd, config, getManifestCache(currentCtx.cwd), getRunSnapshotCache(currentCtx.cwd), currentCtx, widgetState.notificationCount ?? 0);
 					}
 				});
 		});
@@ -194,8 +244,16 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		stopSessionBoundSubagents();
 		stopAsyncRunNotifier(notifierState);
 		stopCrewWidget(currentCtx, widgetState, currentCtx ? loadConfig(currentCtx.cwd).config.ui : undefined);
-		clearPiCrewPowerbar(pi.events);
+		clearPiCrewPowerbar(pi.events, currentCtx);
 		manifestCache.dispose();
+		runSnapshotCache.dispose?.();
+		renderScheduler?.dispose();
+		renderScheduler = undefined;
+		autoRecoveryLast.clear();
+		notificationRouter?.dispose();
+		notificationSink?.dispose();
+		notificationRouter = undefined;
+		notificationSink = undefined;
 		rpcHandle?.unsubscribe();
 		rpcHandle = undefined;
 		currentCtx = undefined;
@@ -212,24 +270,57 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		widgetState.interval = undefined;
 		notifyActiveRuns(ctx);
 		const loadedConfig = loadConfig(ctx.cwd);
+		autoRecoveryLast.clear();
+		configureNotifications(ctx);
 		registerPiCrewPowerbarSegments(pi.events, loadedConfig.config.ui);
 		startAsyncRunNotifier(ctx, notifierState, loadedConfig.config.notifierIntervalMs ?? DEFAULT_UI.notifierIntervalMs);
 		const cache = getManifestCache(ctx.cwd);
-		updateCrewWidget(ctx, widgetState, loadedConfig.config.ui, cache);
-		updatePiCrewPowerbar(pi.events, ctx.cwd, loadedConfig.config.ui, cache);
-		widgetState.interval = setInterval(() => {
+		updateCrewWidget(ctx, widgetState, loadedConfig.config.ui, cache, getRunSnapshotCache(ctx.cwd));
+		updatePiCrewPowerbar(pi.events, ctx.cwd, loadedConfig.config.ui, cache, getRunSnapshotCache(ctx.cwd), ctx, widgetState.notificationCount ?? 0);
+		renderScheduler?.dispose();
+		const renderTick = (): void => {
 			if (!currentCtx) return;
 			const config = loadConfig(currentCtx.cwd).config.ui;
-			const cache = getManifestCache(currentCtx.cwd);
+			const activeCache = getManifestCache(currentCtx.cwd);
 			if (liveSidebarRunId) {
-				currentCtx.ui.setWidget("pi-crew", undefined, { placement: config?.widgetPlacement ?? "aboveEditor" });
-				currentCtx.ui.setWidget("pi-crew-active", undefined, { placement: config?.widgetPlacement ?? "aboveEditor" });
+				const placement = config?.widgetPlacement ?? "aboveEditor";
+				if (widgetState.lastVisibility !== "hidden" || widgetState.lastPlacement !== placement) {
+					setExtensionWidget(currentCtx, "pi-crew", undefined, { placement });
+					setExtensionWidget(currentCtx, "pi-crew-active", undefined, { placement });
+					widgetState.lastVisibility = "hidden";
+					widgetState.lastPlacement = placement;
+					widgetState.lastKey = "pi-crew-active";
+					widgetState.model = undefined;
+				}
+				requestRender(currentCtx);
 			} else {
-				updateCrewWidget(currentCtx, widgetState, config, cache);
+				updateCrewWidget(currentCtx, widgetState, config, activeCache, getRunSnapshotCache(currentCtx.cwd));
+			}
+			updatePiCrewPowerbar(pi.events, currentCtx.cwd, config, activeCache, getRunSnapshotCache(currentCtx.cwd), currentCtx, widgetState.notificationCount ?? 0);
+			const now = Date.now();
+			for (const run of activeCache.list(20)) {
+				try {
+					const snapshot = getRunSnapshotCache(currentCtx.cwd).refreshIfStale(run.runId);
+					const summary = summarizeHeartbeats(snapshot, { now });
+					const maybeNotifyHealth = (kind: string, count: number, title: string, body: string): void => {
+						if (count <= 0) return;
+						const key = `${kind}_${run.runId}`;
+						const previous = autoRecoveryLast.get(key);
+						if (previous !== undefined && now - previous < 5 * 60_000) return;
+						autoRecoveryLast.set(key, now);
+						notifyOperator({ id: key, severity: "warning", source: "health", runId: run.runId, title, body });
+					};
+					maybeNotifyHealth("recovery_dead_workers", summary.dead, `Run ${run.runId} has ${summary.dead} dead worker(s).`, "Open /team-dashboard → 5 health → R recovery / K kill stale / D diagnostic.");
+					maybeNotifyHealth("recovery_missing_heartbeat", summary.missing, `Run ${run.runId} has ${summary.missing} worker(s) missing heartbeat.`, "Open /team-dashboard → 5 health → inspect health actions.");
+				} catch (error) {
+					logInternalError("register.health-notification", error, run.runId);
+				}
 			}
-			updatePiCrewPowerbar(pi.events, currentCtx.cwd, config, cache);
-		}, DEFAULT_UI.widgetDefaultFrameMs);
-		widgetState.interval.unref?.();
+		};
+		renderScheduler = new RenderScheduler(pi.events, renderTick, {
+			fallbackMs: loadedConfig.config.ui?.dashboardLiveRefreshMs ?? 750,
+			onInvalidate: () => getRunSnapshotCache(ctx.cwd).invalidate(),
+		});
 	});
 	pi.on("session_before_switch", () => stopSessionBoundSubagents());
 	pi.on("session_shutdown", () => cleanupRuntime());
@@ -252,9 +343,16 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		};
 	});
 
-	registerTeamTool(pi, { foregroundControllers, startForegroundRun, openLiveSidebar, getManifestCache, widgetState });
+	registerTeamTool(pi, { foregroundControllers, startForegroundRun, openLiveSidebar, getManifestCache, getRunSnapshotCache, widgetState });
 	registerSubagentTools(pi, subagentManager);
 	time("register.tools");
 
-	registerTeamCommands(pi, { startForegroundRun, openLiveSidebar, getManifestCache });
+	registerTeamCommands(pi, { startForegroundRun, openLiveSidebar, getManifestCache, getRunSnapshotCache, dismissNotifications: () => {
+		widgetState.notificationCount = 0;
+		if (currentCtx) {
+			const uiConfig = loadConfig(currentCtx.cwd).config.ui;
+			updateCrewWidget(currentCtx, widgetState, uiConfig, getManifestCache(currentCtx.cwd), getRunSnapshotCache(currentCtx.cwd));
+			updatePiCrewPowerbar(pi.events, currentCtx.cwd, uiConfig, getManifestCache(currentCtx.cwd), getRunSnapshotCache(currentCtx.cwd), currentCtx, 0);
+		}
+	} });
 }