pi-crew 0.1.32 → 0.1.34

package/src/extension/registration/commands.ts

@@ -7,16 +7,108 @@ import { loadRunManifestById } from "../../state/state-store.ts";
 import type { TeamRunManifest } from "../../state/types.ts";
 import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
 import { AnimatedMascot } from "../../ui/mascot.ts";
+import * as path from "node:path";
 import { RunDashboard, type RunDashboardSelection } from "../../ui/run-dashboard.ts";
 import { DurableTextViewer } from "../../ui/transcript-viewer.ts";
+import { ConfirmOverlay, type ConfirmOptions } from "../../ui/overlays/confirm-overlay.ts";
+import { MailboxDetailOverlay, type MailboxAction } from "../../ui/overlays/mailbox-detail-overlay.ts";
+import { MailboxComposeOverlay, type MailboxComposeResult } from "../../ui/overlays/mailbox-compose-overlay.ts";
+import { AgentPickerOverlay } from "../../ui/overlays/agent-picker-overlay.ts";
+import { dispatchDiagnosticExport, dispatchHealthRecovery, dispatchKillStaleWorkers, dispatchMailboxAck, dispatchMailboxAckAll, dispatchMailboxCompose, dispatchMailboxNudge } from "../../ui/run-action-dispatcher.ts";
+import { listRecentDiagnostic } from "../../runtime/diagnostic-export.ts";
 import { commandText, notifyCommandResult, parseRunArgs, parseScalar, pushUnset, setNestedConfig } from "./command-utils.ts";
 import { openTranscriptViewer, selectAgentTask } from "./viewers.ts";
 import { printTimings, time } from "../../utils/timings.ts";
+import { requestRenderTarget } from "../../ui/pi-ui-compat.ts";
+import type { createRunSnapshotCache } from "../../ui/run-snapshot-cache.ts";
 
 export interface RegisterTeamCommandsDeps {
 	startForegroundRun: (ctx: ExtensionContext, runner: (signal?: AbortSignal) => Promise<void>, runId?: string) => void;
 	openLiveSidebar: (ctx: ExtensionContext, runId: string) => void;
 	getManifestCache: (cwd: string) => { list(max?: number): TeamRunManifest[] };
+	getRunSnapshotCache?: (cwd: string) => ReturnType<typeof createRunSnapshotCache>;
+	dismissNotifications?: () => void;
+}
+
+async function openConfirm(ctx: ExtensionCommandContext, options: ConfirmOptions): Promise<boolean> {
+	if (!ctx.hasUI) return false;
+	return await ctx.ui.custom<boolean>((_tui, theme, _keybindings, done) => new ConfirmOverlay(options, done, theme), { overlay: true, overlayOptions: { width: 64, maxHeight: "70%", anchor: "center" } });
+}
+
+async function handleMailboxDashboardAction(ctx: ExtensionCommandContext, runId: string): Promise<void> {
+	if (!ctx.hasUI) return;
+	const action = await ctx.ui.custom<MailboxAction | undefined>((_tui, theme, _keybindings, done) => new MailboxDetailOverlay({ runId, cwd: ctx.cwd, done, theme }), { overlay: true, overlayOptions: { width: "90%", maxHeight: "85%", anchor: "center" } });
+	if (!action || action.type === "close") return;
+	let resultMessage: string | undefined;
+	let ok = true;
+	if (action.type === "ack") {
+		const result = await dispatchMailboxAck(ctx as ExtensionContext, runId, action.messageId);
+		ok = result.ok;
+		resultMessage = result.message;
+	} else if (action.type === "ackAll") {
+		const confirmed = await openConfirm(ctx, { title: "Acknowledge all unread messages?", body: "This cannot be undone. Y=ack all, N=cancel.", dangerLevel: "medium", defaultAction: "cancel" });
+		if (!confirmed) return;
+		const result = await dispatchMailboxAckAll(ctx as ExtensionContext, runId);
+		ok = result.ok;
+		resultMessage = result.message;
+	} else if (action.type === "compose") {
+		const compose = await ctx.ui.custom<MailboxComposeResult>((_tui, theme, _keybindings, done) => new MailboxComposeOverlay({ done, theme }), { overlay: true, overlayOptions: { width: "90%", maxHeight: "85%", anchor: "center" } });
+		if (compose.type === "cancel") return;
+		const result = await dispatchMailboxCompose(ctx as ExtensionContext, runId, compose.payload);
+		ok = result.ok;
+		resultMessage = result.message;
+	} else if (action.type === "nudge") {
+		let agentId = action.agentId;
+		if (!agentId) {
+			const picked = await ctx.ui.custom<{ agentId: string } | undefined>((_tui, theme, _keybindings, done) => new AgentPickerOverlay({ cwd: ctx.cwd, runId, done, theme }), { overlay: true, overlayOptions: { width: 72, maxHeight: "75%", anchor: "center" } });
+			agentId = picked?.agentId;
+		}
+		if (!agentId) return;
+		const result = await dispatchMailboxNudge(ctx as ExtensionContext, runId, agentId, "Please report your current status, blocker, or smallest next step.");
+		ok = result.ok;
+		resultMessage = result.message;
+	}
+	depsNotify(ctx, resultMessage ?? "Mailbox action complete.", ok ? "info" : "error");
+}
+
+function depsNotify(ctx: ExtensionCommandContext, message: string, level: "info" | "warning" | "error"): void {
+	ctx.ui.notify(message, level);
+}
+
+async function handleHealthDashboardAction(ctx: ExtensionCommandContext, selection: RunDashboardSelection): Promise<void> {
+	const loaded = loadRunManifestById(ctx.cwd, selection.runId);
+	if (!loaded) {
+		depsNotify(ctx, `Run '${selection.runId}' not found.`, "error");
+		return;
+	}
+	if (selection.action === "health-recovery") {
+		if (loaded.manifest.async) {
+			depsNotify(ctx, "Recovery is only available for foreground runs.", "warning");
+			return;
+		}
+		const confirmed = await openConfirm(ctx, { title: "Interrupt foreground run?", body: "Tasks may be marked failed. Y=interrupt, N=cancel.", dangerLevel: "high", defaultAction: "cancel" });
+		if (!confirmed) return;
+		const result = await dispatchHealthRecovery(ctx as ExtensionContext, selection.runId);
+		depsNotify(ctx, result.message, result.ok ? "info" : "error");
+		return;
+	}
+	if (selection.action === "health-kill-stale") {
+		const confirmed = await openConfirm(ctx, { title: "Mark stale workers dead?", body: "This updates worker heartbeat state. Y=mark dead, N=cancel.", dangerLevel: "medium", defaultAction: "cancel" });
+		if (!confirmed) return;
+		const result = await dispatchKillStaleWorkers(ctx as ExtensionContext, selection.runId);
+		depsNotify(ctx, result.message, result.ok ? "info" : "error");
+		return;
+	}
+	if (selection.action === "health-diagnostic-export") {
+		const diagDir = path.join(loaded.manifest.artifactsRoot, "diagnostic");
+		const recent = listRecentDiagnostic(diagDir, 60_000);
+		if (recent) {
+			const confirmed = await openConfirm(ctx, { title: "Recent diagnostic exists", body: `File ${recent} was created <1min ago. Export another diagnostic?`, defaultAction: "cancel" });
+			if (!confirmed) return;
+		}
+		const result = await dispatchDiagnosticExport(ctx as ExtensionContext, selection.runId);
+		depsNotify(ctx, result.message, result.ok ? "info" : "error");
+	}
 }
 
 export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommandsDeps): void {
@@ -133,11 +225,26 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 			const uiConfig = loadConfig(ctx.cwd).config.ui;
 			const rightPanel = uiConfig?.dashboardPlacement !== "center";
 			const width = rightPanel ? Math.min(90, Math.max(40, uiConfig?.dashboardWidth ?? 56)) : "90%";
-			const selection = await ctx.ui.custom<RunDashboardSelection | undefined>((_tui, theme, _keybindings, done) => new RunDashboard(runs, done, theme, { placement: rightPanel ? "right" : "center", showModel: uiConfig?.showModel, showTokens: uiConfig?.showTokens, showTools: uiConfig?.showTools }), { overlay: true, overlayOptions: rightPanel ? { width, minWidth: 40, maxHeight: "100%", anchor: "top-right", offsetX: 0, offsetY: 0, margin: { top: 0, right: 0, bottom: 0, left: 0 } } : { width, maxHeight: "90%", anchor: "center", margin: 2 } });
+			const selection = await ctx.ui.custom<RunDashboardSelection | undefined>((_tui, theme, _keybindings, done) => new RunDashboard(runs, done, theme, { placement: rightPanel ? "right" : "center", showModel: uiConfig?.showModel, showTokens: uiConfig?.showTokens, showTools: uiConfig?.showTools, snapshotCache: deps.getRunSnapshotCache?.(ctx.cwd), runProvider: () => deps.getManifestCache(ctx.cwd).list(50) }), { overlay: true, overlayOptions: rightPanel ? { width, minWidth: 40, maxHeight: "100%", anchor: "top-right", offsetX: 0, offsetY: 0, margin: { top: 0, right: 0, bottom: 0, left: 0 } } : { width, maxHeight: "90%", anchor: "center", margin: 2 } });
 			if (!selection) return;
 			if (selection.action === "reload") continue;
+			if (selection.action === "notifications-dismiss") {
+				deps.dismissNotifications?.();
+				ctx.ui.notify("pi-crew notifications dismissed.", "info");
+				continue;
+			}
+			if (selection.action === "mailbox-detail") {
+				await handleMailboxDashboardAction(ctx, selection.runId);
+				deps.getRunSnapshotCache?.(ctx.cwd).invalidate(selection.runId);
+				continue;
+			}
+			if (selection.action === "health-recovery" || selection.action === "health-kill-stale" || selection.action === "health-diagnostic-export") {
+				await handleHealthDashboardAction(ctx, selection);
+				deps.getRunSnapshotCache?.(ctx.cwd).invalidate(selection.runId);
+				continue;
+			}
 			if (selection.action === "agent-transcript" && await openTranscriptViewer(ctx, selection.runId)) continue;
-			const result = selection.action === "api" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-manifest" } }, ctx) : selection.action === "agents" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "agent-dashboard" } }, ctx) : selection.action === "agent-events" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-agent-events", limit: 50 } }, ctx) : selection.action === "agent-output" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-agent-output", maxBytes: 32_000 } }, ctx) : selection.action === "agent-transcript" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-agent-transcript" } }, ctx) : await handleTeamTool({ action: selection.action, runId: selection.runId }, ctx);
+			const result = selection.action === "api" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-manifest" } }, ctx) : selection.action === "agents" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "agent-dashboard" } }, ctx) : selection.action === "mailbox" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-mailbox" } }, ctx) : selection.action === "agent-events" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-agent-events", limit: 50 } }, ctx) : selection.action === "agent-output" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-agent-output", maxBytes: 32_000 } }, ctx) : selection.action === "agent-transcript" ? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-agent-transcript" } }, ctx) : await handleTeamTool({ action: selection.action, runId: selection.runId }, ctx);
 			await notifyCommandResult(ctx, commandText(result));
 			return;
 		}
@@ -151,7 +258,7 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 		const effectArg = tokens.find((t) => ["random", "none", "typewriter", "scanline", "rain", "fade", "crt", "glitch", "dissolve"].includes(t));
 		const style = (styleArg as "cat" | "armin" | undefined) ?? uiConfig?.mascotStyle ?? "cat";
 		const effect = (effectArg as "random" | "none" | "typewriter" | "scanline" | "rain" | "fade" | "crt" | "glitch" | "dissolve" | undefined) ?? uiConfig?.mascotEffect ?? "random";
-		await ctx.ui.custom<undefined>((tui, theme, _keybindings, done) => new AnimatedMascot(theme, () => done(undefined), { frameIntervalMs: style === "armin" ? 33 : 180, autoCloseMs: 7000, requestRender: () => (tui as { requestRender?: () => void }).requestRender?.(), style, effect }), { overlay: true, overlayOptions: { width: style === "armin" ? 48 : 62, maxHeight: "85%", anchor: "center" } });
+		await ctx.ui.custom<undefined>((tui, theme, _keybindings, done) => new AnimatedMascot(theme, () => done(undefined), { frameIntervalMs: style === "armin" ? 33 : 180, autoCloseMs: 7000, requestRender: () => requestRenderTarget(tui), style, effect }), { overlay: true, overlayOptions: { width: style === "armin" ? 48 : 62, maxHeight: "85%", anchor: "center" } });
 	} });
 
 	pi.registerCommand("team-init", { description: "Initialize project-local pi-crew directories and gitignore entries", handler: async (args: string, ctx: ExtensionCommandContext) => {

package/src/extension/registration/team-tool.ts

@@ -5,6 +5,7 @@ import type { CrewWidgetState } from "../../ui/crew-widget.ts";
 import { updateCrewWidget } from "../../ui/crew-widget.ts";
 import { updatePiCrewPowerbar } from "../../ui/powerbar-publisher.ts";
 import type { createManifestCache } from "../../runtime/manifest-cache.ts";
+import type { createRunSnapshotCache } from "../../ui/run-snapshot-cache.ts";
 import { handleTeamTool } from "../team-tool.ts";
 
 export interface RegisterTeamToolDeps {
@@ -12,6 +13,7 @@ export interface RegisterTeamToolDeps {
 	startForegroundRun: (ctx: ExtensionContext, runner: (signal?: AbortSignal) => Promise<void>, runId?: string) => void;
 	openLiveSidebar: (ctx: ExtensionContext, runId: string) => void;
 	getManifestCache: (cwd: string) => ReturnType<typeof createManifestCache>;
+	getRunSnapshotCache?: (cwd: string) => ReturnType<typeof createRunSnapshotCache>;
 	widgetState: CrewWidgetState;
 }
 
@@ -48,8 +50,9 @@ export function registerTeamTool(pi: ExtensionAPI, deps: RegisterTeamToolDeps):
 				}
 				const config = loadConfig(ctx.cwd).config.ui;
 				const cache = deps.getManifestCache(ctx.cwd);
-				updateCrewWidget(ctx, deps.widgetState, config, cache);
-				updatePiCrewPowerbar(pi.events, ctx.cwd, config, cache);
+				const snapshotCache = deps.getRunSnapshotCache?.(ctx.cwd);
+				updateCrewWidget(ctx, deps.widgetState, config, cache, snapshotCache);
+				updatePiCrewPowerbar(pi.events, ctx.cwd, config, cache, snapshotCache, ctx);
 				return output;
 			} finally {
 				signal?.removeEventListener("abort", abort);

package/src/extension/registration/viewers.ts

@@ -1,6 +1,7 @@
 import type { ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
 import { loadRunManifestById } from "../../state/state-store.ts";
 import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
+import { loadConfig } from "../../config/config.ts";
 import { DurableTranscriptViewer } from "../../ui/transcript-viewer.ts";
 
 export async function selectAgentTask(ctx: ExtensionCommandContext, runId: string | undefined, taskId?: string): Promise<{ runId: string; taskId?: string } | undefined> {
@@ -24,7 +25,8 @@ export async function openTranscriptViewer(ctx: ExtensionCommandContext, initial
 	if (!runId || !ctx.hasUI) return false;
 	const loaded = loadRunManifestById(ctx.cwd, runId);
 	if (!loaded) return false;
-	await ctx.ui.custom<undefined>((_tui, theme, _keybindings, done) => new DurableTranscriptViewer(loaded.manifest, theme, done, taskId), {
+	const uiConfig = loadConfig(ctx.cwd).config.ui;
+	await ctx.ui.custom<undefined>((_tui, theme, _keybindings, done) => new DurableTranscriptViewer(loaded.manifest, theme, done, taskId, { maxTailBytes: uiConfig?.transcriptTailBytes }), {
 		overlay: true,
 		overlayOptions: { width: "90%", maxHeight: "85%", anchor: "center" },
 	});

package/src/extension/team-recommendation.ts

@@ -26,8 +26,8 @@ const REVIEW_TERMS = ["review", "audit", "security", "vulnerability", "diff", "p
 const RESEARCH_TERMS = ["research", "investigate", "compare", "analyze", "document", "docs", "explain", "architecture", "đọc sâu", "source", "projects"];
 const PARALLEL_RESEARCH_RE = /(?:đọc sâu|deep read|deep research|source audit|multiple projects|các project|pi-\*|source\/|@source)/i;
 const FAST_FIX_TERMS = ["quick fix", "fast-fix", "small bug", "typo", "one-line", "minor", "lint"];
-const IMPLEMENTATION_TERMS = ["implement", "refactor", "migrate", "feature", "tests", "test", "integration", "upgrade", "build", "create", "add"];
-const RISKY_TERMS = ["migration", "refactor", "large", "multiple", "parallel", "concurrent", "risky", "critical"];
+const IMPLEMENTATION_TERMS = ["implement", "refactor", "migrate", "feature", "tests", "test", "integration", "upgrade", "build", "create", "add", "fix", "update", "sửa", "thêm", "cập nhật", "kiểm thử"];
+const RISKY_TERMS = ["migration", "refactor", "large", "multiple", "parallel", "concurrent", "risky", "critical", "nhiều file", "nhiều task"];
 const NUMBERED_LINE_RE = /^\s*\d+[.)]\s+(.+)$/;
 const BULLETED_LINE_RE = /^\s*[-*•]\s+(.+)$/;
 const CONJUNCTION_SPLIT_RE = /\s+(?:and|,\s*and|,)\s+/i;
@@ -67,12 +67,14 @@ export function decomposeGoal(goal: string): { strategy: DecompositionStrategy;
 		const subtask = makeSubtask(goal);
 		return { strategy: "atomic", subtasks: [subtask], fanout: 1 };
 	}
-	if (lines.length >= 2 && lines.every((line) => NUMBERED_LINE_RE.test(line))) {
-		const subtasks = lines.map((line) => makeSubtask(line.match(NUMBERED_LINE_RE)?.[1] ?? line));
+	const numberedLines = lines.map((line) => line.match(NUMBERED_LINE_RE)?.[1]).filter((line): line is string => line !== undefined);
+	if (numberedLines.length >= 2 && numberedLines.length >= lines.length - 1) {
+		const subtasks = numberedLines.map((line) => makeSubtask(line));
 		return { strategy: "numbered", subtasks, fanout: subtasks.length };
 	}
-	if (lines.length >= 2 && lines.every((line) => BULLETED_LINE_RE.test(line))) {
-		const subtasks = lines.map((line) => makeSubtask(line.match(BULLETED_LINE_RE)?.[1] ?? line));
+	const bulletedLines = lines.map((line) => line.match(BULLETED_LINE_RE)?.[1]).filter((line): line is string => line !== undefined);
+	if (bulletedLines.length >= 2 && bulletedLines.length >= lines.length - 1) {
+		const subtasks = bulletedLines.map((line) => makeSubtask(line));
 		return { strategy: "bulleted", subtasks, fanout: subtasks.length };
 	}
 	if (lines.length === 1) {
@@ -94,6 +96,7 @@ function metadataMatches(goal: string, values: string[] | undefined): string[] {
 export function recommendTeam(goal: string, config: PiTeamsAutonomousConfig = {}, resources?: { teams?: TeamConfig[]; agents?: AgentConfig[] }): TeamRecommendation {
 	const normalized = goal.toLowerCase();
 	const intents = detectTeamIntent(goal, config);
+	const decomposition = decomposeGoal(goal);
 	const reasons: string[] = [];
 	let team: TeamRecommendation["team"] = "default";
 	let workflow: TeamRecommendation["workflow"] = "default";
@@ -138,10 +141,15 @@ export function recommendTeam(goal: string, config: PiTeamsAutonomousConfig = {}
 		workflow = "fast-fix";
 		confidence = "high";
 		reasons.push(`Small fix terms detected: ${fastFixMatches.join(", ") || "fast-fix intent"}.`);
+	} else if (intents.includes("taskList")) {
+		team = "implementation";
+		workflow = "implementation";
+		confidence = "high";
+		reasons.push(`Actionable multi-item task list detected (${decomposition.fanout} bullet${decomposition.fanout === 1 ? "" : "s"}); use coordinated implementation planning.`);
 	} else if (intents.includes("implementation") || implementationMatches.length > 0) {
 		team = "implementation";
 		workflow = "implementation";
-		confidence = implementationMatches.length >= 2 || riskyMatches.length > 0 ? "high" : "medium";
+		confidence = implementationMatches.length >= 2 || riskyMatches.length > 0 || decomposition.fanout >= 2 ? "high" : "medium";
 		reasons.push(`Implementation terms detected: ${implementationMatches.join(", ") || "implementation intent"}.`);
 	} else {
 		action = "plan";
@@ -149,7 +157,7 @@ export function recommendTeam(goal: string, config: PiTeamsAutonomousConfig = {}
 		reasons.push("No strong team-specific intent detected; start with planning/default discovery.");
 	}
 
-	const decomposition = decomposeGoal(goal);
+
 	if (decomposition.strategy !== "atomic") reasons.push(`Goal decomposes into ${decomposition.subtasks.length} subtasks using ${decomposition.strategy} parsing.`);
 	const async = config.preferAsyncForLongTasks === true && (wordCount(goal) > 24 || riskyMatches.length > 0 || implementationMatches.length >= 2 || decomposition.fanout >= 3);
 	const workspaceMode = config.allowWorktreeSuggestion === false ? "single" : (riskyMatches.length > 0 && team === "implementation" ? "worktree" : "single");

package/src/runtime/child-pi.ts

@@ -399,6 +399,7 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 
 			input.signal?.addEventListener("abort", abort, { once: true });
 			child.stdout?.on("data", (chunk: Buffer) => {
+				restartNoResponseTimer();
 				lineObserver.observe(chunk.toString("utf-8"));
 			});
 			child.stderr?.on("data", (chunk: Buffer) => {

package/src/runtime/diagnostic-export.ts

@@ -0,0 +1,107 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { readCrewAgents } from "./crew-agent-records.ts";
+import { readEvents, type TeamEvent } from "../state/event-log.ts";
+import { loadRunManifestById } from "../state/state-store.ts";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import { summarizeHeartbeats, type HeartbeatSummary } from "../ui/heartbeat-aggregator.ts";
+import type { RunUiSnapshot } from "../ui/snapshot-types.ts";
+
+export interface DiagnosticReport {
+	runId: string;
+	exportedAt: string;
+	manifest: TeamRunManifest;
+	tasks: TeamTaskState[];
+	recentEvents: TeamEvent[];
+	heartbeat: HeartbeatSummary;
+	agents: unknown[];
+	envRedacted: Record<string, string>;
+}
+
+const SECRET_KEY_PATTERN = /(token|key|password|secret|credential|auth)/i;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+export function redactSecrets(value: unknown, keyName = ""): unknown {
+	if (SECRET_KEY_PATTERN.test(keyName)) return "***";
+	if (typeof value === "string") return value.replace(/((?:token|key|password|secret|credential|auth)[\w.-]*\s*[=:]\s*)[^\s,;]+/gi, "$1***");
+	if (Array.isArray(value)) return value.map((item) => redactSecrets(item));
+	if (isRecord(value)) {
+		const output: Record<string, unknown> = {};
+		for (const [key, entry] of Object.entries(value)) output[key] = redactSecrets(entry, key);
+		return output;
+	}
+	return value;
+}
+
+function envRedacted(): Record<string, string> {
+	const output: Record<string, string> = {};
+	for (const [key, value] of Object.entries(process.env)) {
+		if (SECRET_KEY_PATTERN.test(key)) output[key] = "***";
+		else if (typeof value === "string") output[key] = value;
+	}
+	return output;
+}
+
+function buildSnapshot(manifest: TeamRunManifest, tasks: TeamTaskState[]): RunUiSnapshot {
+	const agents = readCrewAgents(manifest);
+	return {
+		runId: manifest.runId,
+		cwd: manifest.cwd,
+		fetchedAt: Date.now(),
+		signature: `${manifest.runId}:${manifest.updatedAt}`,
+		manifest,
+		tasks,
+		agents,
+		progress: {
+			total: tasks.length,
+			completed: tasks.filter((task) => task.status === "completed").length,
+			running: tasks.filter((task) => task.status === "running").length,
+			failed: tasks.filter((task) => task.status === "failed").length,
+			queued: tasks.filter((task) => task.status === "queued").length,
+		},
+		usage: { tokensIn: 0, tokensOut: 0, toolUses: 0 },
+		mailbox: { inboxUnread: 0, outboxPending: 0, needsAttention: 0 },
+		recentEvents: [],
+		recentOutputLines: [],
+	};
+}
+
+export async function exportDiagnostic(ctx: Pick<ExtensionContext, "cwd">, runId: string): Promise<{ path: string; report: DiagnosticReport }> {
+	const loaded = loadRunManifestById(ctx.cwd, runId);
+	if (!loaded) throw new Error(`Run '${runId}' not found.`);
+	const exportedAt = new Date().toISOString();
+	const safeTimestamp = exportedAt.replace(/[:.]/g, "-");
+	const recentEvents = readEvents(loaded.manifest.eventsPath).slice(-200);
+	const report: DiagnosticReport = {
+		runId,
+		exportedAt,
+		manifest: redactSecrets(loaded.manifest) as TeamRunManifest,
+		tasks: redactSecrets(loaded.tasks) as TeamTaskState[],
+		recentEvents: redactSecrets(recentEvents) as TeamEvent[],
+		heartbeat: summarizeHeartbeats(buildSnapshot(loaded.manifest, loaded.tasks)),
+		agents: redactSecrets(readCrewAgents(loaded.manifest)) as unknown[],
+		envRedacted: envRedacted(),
+	};
+	const dir = path.join(loaded.manifest.artifactsRoot, "diagnostic");
+	fs.mkdirSync(dir, { recursive: true });
+	const filePath = path.join(dir, `diagnostic-${safeTimestamp}.json`);
+	fs.writeFileSync(filePath, `${JSON.stringify(report, null, 2)}\n`, "utf-8");
+	return { path: filePath, report };
+}
+
+export function listRecentDiagnostic(dir: string, windowMs: number, now = Date.now()): string | undefined {
+	try {
+		if (!fs.existsSync(dir)) return undefined;
+		return fs.readdirSync(dir)
+			.filter((file) => file.startsWith("diagnostic-") && file.endsWith(".json"))
+			.map((file) => ({ file, mtimeMs: fs.statSync(path.join(dir, file)).mtimeMs }))
+			.filter((entry) => now - entry.mtimeMs < windowMs)
+			.sort((a, b) => b.mtimeMs - a.mtimeMs)[0]?.file;
+	} catch {
+		return undefined;
+	}
+}

package/src/runtime/pi-spawn.ts

@@ -87,7 +87,10 @@ function resolvePiCliScript(): string | undefined {
 
 export function getPiSpawnCommand(args: string[]): PiSpawnCommand {
 	const explicit = process.env.PI_TEAMS_PI_BIN?.trim();
-	if (explicit && fs.existsSync(explicit) && !isRunnableNodeScript(explicit)) return { command: explicit, args };
+	if (explicit && fs.existsSync(explicit)) {
+		if (isRunnableNodeScript(explicit)) return { command: process.execPath, args: [explicit, ...args] };
+		return { command: explicit, args };
+	}
 	if (process.platform === "win32") {
 		const script = resolvePiCliScript();
 		if (script) return { command: process.execPath, args: [script, ...args] };

package/src/runtime/task-packet.ts

@@ -43,12 +43,13 @@ export function buildTaskPacket(input: BuildTaskPacketInput): TaskPacket {
 		branchPolicy: input.manifest.workspaceMode === "worktree" ? "Use the assigned task worktree and avoid modifying the leader checkout." : "Use the current checkout; do not create branches unless explicitly requested.",
 		acceptanceTests: [],
 		commitPolicy: "Do not commit unless explicitly requested by the user or workflow.",
-		reportingContract: "Report changed files, verification evidence, blockers, and next recommended action.",
-		escalationPolicy: "Stop and report if scope is ambiguous, destructive action is needed, permissions are missing, or verification cannot be completed.",
+		reportingContract: "Report intended/changed files, verification evidence, blockers, conflict risks, and next recommended action.",
+		escalationPolicy: "Stop and report if scope is ambiguous, destructive action is needed, permissions are missing, verification cannot be completed, or edits may overlap with another worker/task.",
 		constraints: [
 			"Stay within the assigned task scope.",
 			"Do not claim completion without verification evidence.",
 			"Use mailbox/API state for coordination when available.",
+			"Do not make overlapping edits to the same file/symbol without explicit leader sequencing or ownership guidance.",
 		],
 		expectedArtifacts: ["prompt", "result", "verification"],
 		verification: defaultVerificationContract(input.step),
@@ -66,6 +67,14 @@ export function validateTaskPacket(packet: TaskPacket): TaskPacketValidationResu
 	if ((packet.scope === "module" || packet.scope === "single_file" || packet.scope === "custom") && !packet.scopePath?.trim()) {
 		errors.push(`scopePath is required for scope '${packet.scope}'`);
 	}
+	if (packet.constraints.length === 0) errors.push("constraints must contain at least one entry");
+	for (const [index, constraint] of packet.constraints.entries()) {
+		if (!constraint.trim()) errors.push(`constraints contains an empty value at index ${index}`);
+	}
+	if (packet.expectedArtifacts.length === 0) errors.push("expectedArtifacts must contain at least one entry");
+	for (const [index, artifact] of packet.expectedArtifacts.entries()) {
+		if (!artifact.trim()) errors.push(`expectedArtifacts contains an empty value at index ${index}`);
+	}
 	for (const [index, test] of packet.acceptanceTests.entries()) {
 		if (!test.trim()) errors.push(`acceptanceTests contains an empty value at index ${index}`);
 	}

package/src/runtime/task-runner/prompt-builder.ts

@@ -23,6 +23,9 @@ export function coordinationBridgeInstructions(task: TeamTaskState): string {
 		`Mailbox target for this task: ${task.id}`,
 		"Use the run mailbox contract for coordination with the leader/orchestrator:",
 		"- If blocked or uncertain, report the blocker in your final result and, when mailbox tools/API are available, send an inbox/outbox message addressed to the leader.",
+		"- Ask the leader before editing when scope is ambiguous, requirements conflict, destructive action is needed, or you discover likely overlap with another task.",
+		"- Before making non-trivial edits, state intended changed files in your notes/result; if another worker may touch the same file/symbol, pause and request sequencing/ownership guidance.",
+		"- Do not resolve cross-worker conflicts silently. Escalate via mailbox/result with: file/symbol, conflicting task if known, proposed owner, and safest next step.",
 		"- If nudged, answer with current status, blocker, or smallest next step.",
 		"- Treat inherited/dependency context as reference-only; do not continue the parent conversation directly.",
 		"- Completion handoff should include: DONE/FAILED, summary, changed/read files, verification evidence, and remaining risks.",

package/src/schema/config-schema.ts

@@ -72,6 +72,15 @@ export const PiTeamsTelemetryConfigSchema = Type.Object({
 	enabled: Type.Optional(Type.Boolean()),
 });
 
+export const PiTeamsNotificationsConfigSchema = Type.Object({
+	enabled: Type.Optional(Type.Boolean()),
+	severityFilter: Type.Optional(Type.Array(Type.Union([Type.Literal("info"), Type.Literal("warning"), Type.Literal("error"), Type.Literal("critical")]))),
+	dedupWindowMs: Type.Optional(Type.Integer({ minimum: 1000 })),
+	batchWindowMs: Type.Optional(Type.Integer({ minimum: 0 })),
+	quietHours: Type.Optional(Type.String({ pattern: "^\\d{2}:\\d{2}-\\d{2}:\\d{2}$" })),
+	sinkRetentionDays: Type.Optional(Type.Integer({ minimum: 1, maximum: 90 })),
+});
+
 export const PiTeamsUiConfigSchema = Type.Object({
 	widgetPlacement: Type.Optional(Type.Union([Type.Literal("aboveEditor"), Type.Literal("belowEditor")])),
 	widgetMaxLines: Type.Optional(Type.Integer({ minimum: 1 })),
@@ -84,6 +93,7 @@ export const PiTeamsUiConfigSchema = Type.Object({
 	showModel: Type.Optional(Type.Boolean()),
 	showTokens: Type.Optional(Type.Boolean()),
 	showTools: Type.Optional(Type.Boolean()),
+	transcriptTailBytes: Type.Optional(Type.Number({ minimum: 1024 })),
 	mascotStyle: Type.Optional(Type.Union([Type.Literal("cat"), Type.Literal("armin")])),
 	mascotEffect: Type.Optional(Type.Union([Type.Literal("random"), Type.Literal("none"), Type.Literal("typewriter"), Type.Literal("scanline"), Type.Literal("rain"), Type.Literal("fade"), Type.Literal("crt"), Type.Literal("glitch"), Type.Literal("dissolve")])),
 });
@@ -101,5 +111,6 @@ export const PiTeamsConfigSchema = Type.Object({
 	agents: Type.Optional(PiTeamsAgentsConfigSchema),
 	tools: Type.Optional(PiTeamsToolsConfigSchema),
 	telemetry: Type.Optional(PiTeamsTelemetryConfigSchema),
+	notifications: Type.Optional(PiTeamsNotificationsConfigSchema),
 	ui: Type.Optional(PiTeamsUiConfigSchema),
 });