pi-crew 0.9.68 → 0.10.2

package/src/ui/inline-panel/panel-store.ts

@@ -0,0 +1,111 @@
+/**
+ * panel-store.ts — process-wide state shared by the inline panel's two halves.
+ *
+ * The editor wrapper mutates the cursor; the widget renderer and the transcript
+ * pane read it. Neither can own the state (the editor is created by pi's
+ * factory, the widget by another), so it lives here as a small observable
+ * singleton — the same shape pi-subtask keeps in its closure.
+ *
+ * Row projection is injected rather than computed here: the widget already owns
+ * the manifest/snapshot caches that produce the run list, and duplicating that
+ * read on every keypress would put disk I/O on the input path.
+ */
+
+import type { PanelRow, PanelSelection, PanelTarget } from "./panel-selection.ts";
+import { isAgentSelection } from "./panel-selection.ts";
+
+let selection: PanelSelection = null;
+let viewed: PanelTarget | undefined;
+let rowsProvider: (() => PanelRow[]) | undefined;
+const listeners = new Set<() => void>();
+
+/** Install the row projection. Called once during panel wiring. */
+export function setPanelRowsProvider(provider: (() => PanelRow[]) | undefined): void {
+	rowsProvider = provider;
+}
+
+/**
+ * Navigable rows, freshly projected on each call.
+ *
+ * A provider throw must never break input handling — a transient manifest read
+ * failure would otherwise make the panel swallow keys — so it degrades to an
+ * empty list, which the editor treats as "nothing to navigate".
+ */
+export function panelRows(): PanelRow[] {
+	if (!rowsProvider) return [];
+	try {
+		return rowsProvider();
+	} catch {
+		return [];
+	}
+}
+
+export function getPanelSelection(): PanelSelection {
+	return selection;
+}
+
+export function setPanelSelection(next: PanelSelection): void {
+	if (next === selection) return;
+	if (isAgentSelection(selection) && isAgentSelection(next) && selection.runId === next.runId && selection.taskId === next.taskId) {
+		return;
+	}
+	selection = next;
+	notifyPanelChange();
+}
+
+export function getViewedAgent(): PanelTarget | undefined {
+	return viewed;
+}
+
+export function setViewedAgent(next: PanelTarget | undefined): void {
+	if (viewed === next) return;
+	if (viewed && next && viewed.runId === next.runId && viewed.taskId === next.taskId) return;
+	viewed = next;
+	notifyPanelChange();
+}
+
+/** True while the panel holds the cursor, i.e. keys are not going to the editor. */
+export function isPanelFocused(): boolean {
+	return selection !== null;
+}
+
+/** What the widget renderer needs, in one read. */
+export function panelDisplayState(): {
+	selectedTaskId: string | undefined;
+	viewedTaskId: string | undefined;
+	focused: boolean;
+} {
+	return {
+		selectedTaskId: isAgentSelection(selection) ? selection.taskId : undefined,
+		viewedTaskId: viewed?.taskId,
+		// Cursor-driven: uncapping the row budget while the user is typing
+		// into the pane (viewed set, selection null) would jerk the layout on
+		// every pane open. The cursor entry is when the full list is needed.
+		focused: selection !== null,
+	};
+}
+
+export function subscribePanelChange(listener: () => void): () => void {
+	listeners.add(listener);
+	return () => {
+		listeners.delete(listener);
+	};
+}
+
+export function notifyPanelChange(): void {
+	for (const listener of [...listeners]) {
+		try {
+			listener();
+		} catch {
+			// A failing repaint listener must not stop the others.
+		}
+	}
+}
+
+/** Session teardown / test isolation. */
+export function resetPanelStore(): void {
+	selection = null;
+	viewed = undefined;
+	rowsProvider = undefined;
+	listeners.clear();
+}

package/src/ui/inline-panel/view-session-store.ts

@@ -0,0 +1,36 @@
+/**
+ * view-session-store.ts — session-switch guard for run protection.
+ *
+ * Agent views are in-document panes (see agent-pane.ts / inline-panel's
+ * openPane): viewing an agent NEVER switches, resumes, or tears down a
+ * session. This store is the one piece of session-switch machinery that
+ * remains, and it protects runs from switches the USER makes (/resume, /new,
+ * /fork): a switch tears the current session down via session.abort(), which
+ * fires the abort signal of any tool call still in flight — a foreground
+ * team run created by that tool is linked to the turn's abort, so ANY switch
+ * seconds after a run starts used to kill the run's workers ("Child Pi
+ * exited with 143" → run cancelled). While the guard is set, the
+ * caller-abort propagation is suppressed (run-deadline.ts).
+ *
+ * Set by the session_before_switch handler (runs before teardown's abort),
+ * cleared on the next session_start (the switch landed) and on reconcile.
+ */
+
+let sessionSwitchInFlight = false;
+
+export function markSessionSwitchInFlight(): void {
+	sessionSwitchInFlight = true;
+}
+
+export function clearSessionSwitchInFlight(): void {
+	sessionSwitchInFlight = false;
+}
+
+export function isSessionSwitchInFlight(): boolean {
+	return sessionSwitchInFlight;
+}
+
+/** Test isolation. */
+export function resetCrewViewSessionState(): void {
+	sessionSwitchInFlight = false;
+}

package/src/ui/keybinding-map.ts

@@ -26,6 +26,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { type KeyId, matchesKey } from "@earendil-works/pi-tui";
+import { getCrewEnv } from "../config/env-vars.ts";
 import { keyOf } from "./key-utils.ts";
 
 export const DASHBOARD_KEYS = {
@@ -52,6 +53,7 @@ export const DASHBOARD_KEYS = {
 		output: ["4"],
 		health: ["5"],
 		metrics: ["6"],
+		plan: ["7"],
 	},
 	navigation: { up: ["k", "up"], down: ["j", "down"] },
 	mailbox: {
@@ -63,6 +65,7 @@ export const DASHBOARD_KEYS = {
 		openDetail: ["\r", "\n"],
 	},
 	health: { recovery: ["R"], killStale: ["K"], diagnosticExport: ["D"] },
+	plan: { approve: ["A"], deny: ["n"], diff: ["X"] },
 	notification: { dismissAll: ["H"] },
 } as const;
 
@@ -70,7 +73,7 @@ export const DASHBOARD_KEYS = {
  * Pane identifiers that can scope a binding. `undefined` means the binding
  * fires in every pane.
  */
-export type ActivePane = "agents" | "progress" | "mailbox" | "output" | "health" | "metrics";
+export type ActivePane = "agents" | "progress" | "mailbox" | "output" | "health" | "metrics" | "plan";
 
 /**
  * A single keybinding: the keys that trigger it, the action it produces, and
@@ -81,8 +84,8 @@ export type ActivePane = "agents" | "progress" | "mailbox" | "output" | "health"
 export interface KeyBinding {
 	readonly keys: readonly string[];
 	readonly action: DashboardKeyAction;
-	/** When set, the binding only fires when `activePane === pane`. */
-	readonly pane?: ActivePane;
+	/** When set, the binding fires only in these pane(s). */
+	readonly pane?: PaneScope;
 }
 
 export type DashboardKeyAction =
@@ -106,12 +109,16 @@ export type DashboardKeyAction =
 	| "pane-output"
 	| "pane-health"
 	| "pane-metrics"
+	| "pane-plan"
+	| "plan-diff"
 	| "up"
 	| "down"
 	| "mailbox-detail"
 	| "health-recovery"
 	| "health-kill-stale"
 	| "health-diagnostic-export"
+	| "plan-approve"
+	| "plan-deny"
 	| "notifications-dismiss";
 
 /**
@@ -125,14 +132,17 @@ export type DashboardKeyAction =
  *   2. `mailbox-detail` (\r, \n) is pane-scoped to mailbox and MUST precede
  *      `select` (which also binds \r, \n) so Enter opens the detail instead of
  *      triggering select while in the mailbox pane.
- *   3. `health-*` are pane-scoped to health.
+ *   3. `health-*` and `plan-*` are pane-scoped (health / progress).
  *   4. `notifications-dismiss` (H) is global.
  *   5. `select`, then the root actions, pane switches, and navigation.
  *
  * NOTE: mailbox action keys A/N/C/P/X (ack/nudge/compose/preview/ackAll) are
- * intentionally NOT in this table. They live in `DASHBOARD_KEYS.mailbox` for
- * reservation but are handled by the mailbox overlay's own `handleInput`,
- * not by the dashboard dispatch. Adding them here would change behavior.
+ * intentionally NOT dispatched for the mailbox pane by this table. They live
+ * in `DASHBOARD_KEYS.mailbox` for reservation but are handled by the mailbox
+ * overlay's own `handleInput`, not by the dashboard dispatch. The `plan`
+ * group reuses uppercase "A" (approve) pane-scoped to "progress" — it never
+ * fires while the mailbox pane (or the mailbox-detail overlay) owns input,
+ * so `mailbox.ack` behavior is unchanged.
  */
 const DEFAULT_BINDINGS: readonly KeyBinding[] = [
 	{ keys: DASHBOARD_KEYS.close, action: "close" },
@@ -157,6 +167,22 @@ const DEFAULT_BINDINGS: readonly KeyBinding[] = [
 		action: "health-diagnostic-export",
 		pane: "health",
 	},
+	{
+		keys: DASHBOARD_KEYS.plan.approve,
+		action: "plan-approve",
+		// WP-7: shared by the progress banner and the Plan pane (pane 7).
+		pane: ["progress", "plan"],
+	},
+	{
+		keys: DASHBOARD_KEYS.plan.deny,
+		action: "plan-deny",
+		pane: ["progress", "plan"],
+	},
+	{
+		keys: DASHBOARD_KEYS.plan.diff,
+		action: "plan-diff",
+		pane: "plan",
+	},
 	{
 		keys: DASHBOARD_KEYS.notification.dismissAll,
 		action: "notifications-dismiss",
@@ -179,6 +205,7 @@ const DEFAULT_BINDINGS: readonly KeyBinding[] = [
 	{ keys: DASHBOARD_KEYS.pane.output, action: "pane-output" },
 	{ keys: DASHBOARD_KEYS.pane.health, action: "pane-health" },
 	{ keys: DASHBOARD_KEYS.pane.metrics, action: "pane-metrics" },
+	{ keys: DASHBOARD_KEYS.pane.plan, action: "pane-plan" },
 	{ keys: DASHBOARD_KEYS.navigation.up, action: "up" },
 	{ keys: DASHBOARD_KEYS.navigation.down, action: "down" },
 ];
@@ -202,6 +229,7 @@ const KEY_RESERVED = new Set<string>([
 	...Object.values(DASHBOARD_KEYS.navigation).flat(),
 	...Object.values(DASHBOARD_KEYS.mailbox).flat(),
 	...Object.values(DASHBOARD_KEYS.health).flat(),
+	...Object.values(DASHBOARD_KEYS.plan).flat(),
 	...Object.values(DASHBOARD_KEYS.notification).flat(),
 ]);
 
@@ -253,9 +281,22 @@ function parseKeybindingOverride(raw: unknown): KeybindingOverride {
  * bindings fire at once (so a shared key is genuinely ambiguous). Global
  * (`undefined`) matches anything; two different concrete panes never overlap.
  */
-function paneScopesCompatible(a: ActivePane | undefined, b: ActivePane | undefined): boolean {
+/** Pane scopes — a binding may fire in ONE pane, SEVERAL panes (WP-7: plan
+ *  approval keys are shared by progress + plan panes), or every pane
+ *  (undefined). */
+export type PaneScope = ActivePane | readonly ActivePane[];
+
+function paneScopeMatches(scope: PaneScope | undefined, pane: ActivePane | undefined): boolean {
+	if (scope === undefined) return true;
+	if (Array.isArray(scope)) return pane !== undefined && scope.includes(pane);
+	return scope === pane;
+}
+
+function paneScopesCompatible(a: PaneScope | undefined, b: PaneScope | undefined): boolean {
 	if (a === undefined || b === undefined) return true;
-	return a === b;
+	const as = Array.isArray(a) ? a : [a];
+	const bs = Array.isArray(b) ? b : [b];
+	return as.some((x) => bs.includes(x));
 }
 
 interface EffectiveBindingsResult {
@@ -311,7 +352,7 @@ function readConfigKeybindings(cwd: string): KeybindingOverride {
 
 /** Read the `PI_CREW_KEYBINDINGS` env var (JSON object string). */
 function readEnvKeybindings(): KeybindingOverride {
-	const raw = process.env[KEYBINDINGS_ENV];
+	const raw = getCrewEnv(KEYBINDINGS_ENV);
 	if (!raw) return {};
 	try {
 		return parseKeybindingOverride(JSON.parse(raw));
@@ -344,7 +385,7 @@ let _overrideWarnings: readonly string[] = [];
  * mtime, cwd); a single `statSync` per call detects on-disk config changes.
  */
 function getEffectiveBindings(cwd: string = process.cwd()): readonly KeyBinding[] {
-	const envRaw = process.env[KEYBINDINGS_ENV];
+	const envRaw = getCrewEnv(KEYBINDINGS_ENV);
 	const configMtime = configKeybindingsMtime(cwd);
 	if (_effectiveCache && _effectiveCache.env === envRaw && _effectiveCache.configMtime === configMtime && _effectiveCache.cwd === cwd) {
 		return _effectiveCache.bindings;
@@ -402,7 +443,7 @@ export function dashboardActionForKey(data: string, activePane?: ActivePane): Da
 	// Pass 1 — exact string match (case-sensitive). Handles literal ASCII
 	// keystrokes ('d', 'D', 'q', 'S', …) and preserves their distinct meanings.
 	for (const binding of BINDINGS) {
-		if (binding.pane !== undefined && binding.pane !== activePane) continue;
+		if (!paneScopeMatches(binding.pane, activePane)) continue;
 		if (binding.keys.includes(data)) return binding.action;
 	}
 	// Pass 2 — terminal-aware match for escape sequences / canonical KeyIds.
@@ -411,7 +452,7 @@ export function dashboardActionForKey(data: string, activePane?: ActivePane): Da
 	// legacy CSI, app-cursor-mode, and Kitty-protocol variants uniformly.
 	const key = keyOf(data);
 	for (const binding of BINDINGS) {
-		if (binding.pane !== undefined && binding.pane !== activePane) continue;
+		if (!paneScopeMatches(binding.pane, activePane)) continue;
 		for (const candidate of binding.keys) {
 			if (key === candidate) return binding.action;
 			if (matchesKey(data, candidate as KeyId)) return binding.action;

package/src/ui/pi-ui-compat.ts

@@ -46,6 +46,15 @@ export function setExtensionWidget(
 	ctx.ui.setWidget(key, content as never, widgetOptions as WidgetOptions);
 }
 
+/**
+ * Map the crew widget placement onto pi's `WidgetPlacement`. `"bottom"` is a
+ * crew-only placement (rendered inside the crew-vibes footer, below the quota
+ * lines); when a raw widget slot is involved it falls back to `belowEditor`.
+ */
+export function toPiWidgetPlacement(placement: "aboveEditor" | "belowEditor" | "bottom"): "aboveEditor" | "belowEditor" {
+	return placement === "bottom" ? "belowEditor" : placement;
+}
+
 type FooterFactory = (tui: unknown, theme: unknown, footerData: unknown) => unknown;
 
 /** Install a custom footer component, or pass `undefined` to restore pi's built-in footer.

package/src/ui/powerbar-publisher.ts

@@ -4,6 +4,7 @@ import { listRecentRuns } from "../extension/run-index.ts";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
 import { listLiveAgents, listLiveAgentsByWorkspace } from "../runtime/live-session/live-agent-manager.ts";
 import type { ManifestCache } from "../runtime/manifest-cache.ts";
+import { isPlanApprovalPending } from "../runtime/plan-approval.ts";
 import { isDisplayActiveRun } from "../runtime/process-status.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { aggregateUsage } from "../state/usage.ts";
@@ -87,6 +88,10 @@ export function registerPiCrewPowerbarSegments(events: EventBus, config?: CrewUi
 		id: "pi-crew-steps",
 		label: "pi-crew workflow steps",
 	});
+	safeEmit(events, "powerbar:register-segment", {
+		id: "pi-crew-plan",
+		label: "pi-crew plan approval",
+	});
 }
 
 export function updatePiCrewPowerbar(
@@ -136,11 +141,40 @@ interface ActiveItem {
  * Build the workflow steps segment showing: ✓explore › →plan › ○execute › ○verify
  * with the current/active step highlighted using → arrow.
  */
-function buildStepsPayload(active: ActiveItem[], allTasks: TeamTaskState[]): PowerbarPayloadShape {
+export function buildStepsPayload(active: ActiveItem[], allTasks: TeamTaskState[]): PowerbarPayloadShape {
 	if (!active.length) {
 		return { id: "pi-crew-steps" };
 	}
 	const run = active[0]!.run;
+	// WP-7 (R7): plan-carrying runs show PLAN PHASES instead of workflow steps —
+	// the plan is the actual execution shape (a re-plan revision switches the
+	// segment without waiting for workflow steps that no longer apply).
+	const plans = active[0]!.snapshot?.plans;
+	if (plans && plans.length > 0) {
+		const current = plans[plans.length - 1]!;
+		const itemById = new Map(current.items.map((i) => [i.id, i]));
+		const statusOf = (ids: string[]): "completed" | "running" | "pending" => {
+			const items = ids.map((id) => itemById.get(id)?.status).filter(Boolean) as string[];
+			if (items.length && items.every((s) => s === "done")) return "completed";
+			if (items.some((s) => s === "active")) return "running";
+			return "pending";
+		};
+		const parts = current.phases.map((phase) => {
+			const status = phase.status === "done" ? "completed" : statusOf(phase.itemIds);
+			const icon = status === "completed" ? "✓" : status === "running" ? "→" : "○";
+			const name = phase.title.length > 10 ? `${phase.title.slice(0, 9)}…` : phase.title;
+			return `${icon}${name}`;
+		});
+		if (parts.length) {
+			const hasRunning = parts.some((p) => p.startsWith("→"));
+			const allComplete = parts.every((p) => p.startsWith("✓"));
+			return {
+				id: "pi-crew-steps",
+				text: `P${current.version} ${parts.join(" › ")}`,
+				color: allComplete ? "success" : hasRunning ? "accent" : "dim",
+			};
+		}
+	}
 	const workflowName = run.workflow ?? "default";
 	// Load workflow steps
 	const workflows = allWorkflows(discoverWorkflows(run.cwd));
@@ -206,6 +240,7 @@ class PowerbarPublisher {
 	#lastActiveKey: string | undefined;
 	#lastProgressKey: string | undefined;
 	#lastStepsKey: string | undefined;
+	#lastPlanKey: string | undefined;
 	#latestArgs: PowerbarUpdateArgs | null = null;
 	readonly #coalescer: RenderCoalescer;
 
@@ -279,9 +314,11 @@ class PowerbarPublisher {
 			this.#lastActiveKey = undefined;
 			this.#lastProgressKey = undefined;
 			this.#lastStepsKey = undefined;
+			this.#lastPlanKey = undefined;
 			safeEmit(events, "powerbar:update", { id: "pi-crew-active" });
 			safeEmit(events, "powerbar:update", { id: "pi-crew-progress" });
 			safeEmit(events, "powerbar:update", { id: "pi-crew-steps" });
+			safeEmit(events, "powerbar:update", { id: "pi-crew-plan" });
 			return;
 		}
 		const agents = active.flatMap((item) => item.agents);
@@ -373,6 +410,12 @@ class PowerbarPublisher {
 		} as const;
 		// Build step progress: "explorer > planner > executor > verifier" with current step highlighted
 		const stepsPayload = buildStepsPayload(active, tasks);
+		// WP-3 (H4): plan-approval segment — `plan:pending` while ANY active run is
+		// parked awaiting plan approval, clear payload otherwise. `item.run` is
+		// always the freshest manifest available (snapshot.manifest when cached).
+		const planPayload: PowerbarPayloadShape = active.some((item) => isPlanApprovalPending(item.run))
+			? { id: "pi-crew-plan", text: "plan:pending", color: "warning" }
+			: { id: "pi-crew-plan" };
 		// 1.8: dedup per segment using a key over every visible field. Previously
 		// the dedup string only carried text/suffix/running, so changes to `bar`
 		// (progress %) or `color` could be swallowed and stale UI emitted again
@@ -380,6 +423,7 @@ class PowerbarPublisher {
 		const activeKey = powerbarKey(activePayload);
 		const progressKey = powerbarKey(progressPayload);
 		const stepsKey = powerbarKey(stepsPayload);
+		const planKey = powerbarKey(planPayload);
 		if (activeKey !== this.#lastActiveKey) {
 			this.#lastActiveKey = activeKey;
 			safeEmit(events, "powerbar:update", activePayload);
@@ -392,6 +436,10 @@ class PowerbarPublisher {
 			this.#lastStepsKey = stepsKey;
 			safeEmit(events, "powerbar:update", stepsPayload);
 		}
+		if (planKey !== this.#lastPlanKey) {
+			this.#lastPlanKey = planKey;
+			safeEmit(events, "powerbar:update", planPayload);
+		}
 		// Never call setStatusFallback - crew-widget manages "pi-crew" status with its own widget format
 		// Powerbar only emits events; it does not set status directly
 	}
@@ -431,9 +479,11 @@ class PowerbarPublisher {
 		this.#lastActiveKey = undefined;
 		this.#lastProgressKey = undefined;
 		this.#lastStepsKey = undefined;
+		this.#lastPlanKey = undefined;
 		safeEmit(events, "powerbar:update", { id: "pi-crew-active" });
 		safeEmit(events, "powerbar:update", { id: "pi-crew-progress" });
 		safeEmit(events, "powerbar:update", { id: "pi-crew-steps" });
+		safeEmit(events, "powerbar:update", { id: "pi-crew-plan" });
 	}
 
 	/** Reset dedup state on session lifecycle events. */
@@ -441,6 +491,7 @@ class PowerbarPublisher {
 		this.#lastActiveKey = undefined;
 		this.#lastProgressKey = undefined;
 		this.#lastStepsKey = undefined;
+		this.#lastPlanKey = undefined;
 	}
 
 	dispose(): void {

package/src/ui/run-dashboard.ts

@@ -3,6 +3,7 @@ import type { MetricRegistry } from "../observability/metric-registry.ts";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
 import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
 import { getLiveAgentContextPercent } from "../runtime/live-session/live-agent-manager.ts";
+import { isPlanApprovalPending } from "../runtime/plan-approval.ts";
 import { isDisplayActiveRun, isLikelyOrphanedActiveRun } from "../runtime/process-status.ts";
 import type { TeamRunManifest, TeamTaskState, UsageState } from "../state/types.ts";
 import { aggregateUsage } from "../state/usage.ts";
@@ -16,6 +17,7 @@ import { summarizeTerminalReason } from "./dashboard-panes/cancellation-pane.ts"
 import { renderHealthPane } from "./dashboard-panes/health-pane.ts";
 import { renderMailboxPane } from "./dashboard-panes/mailbox-pane.ts";
 import { renderMetricsPane } from "./dashboard-panes/metrics-pane.ts";
+import { renderPlanPane } from "./dashboard-panes/plan-pane.ts";
 import { renderProgressPane } from "./dashboard-panes/progress-pane.ts";
 import { renderTranscriptPane } from "./dashboard-panes/transcript-pane.ts";
 import { DynamicCrewBorder } from "./dynamic-border.ts";
@@ -75,7 +77,7 @@ export interface RunDashboardOptions {
  * looking at. Resetting to "agents" on every `new RunDashboard(...)` was a
  * UX regression.
  */
-let lastActivePane: "agents" | "progress" | "mailbox" | "output" | "health" | "metrics" = "agents";
+let lastActivePane: "agents" | "progress" | "mailbox" | "output" | "health" | "metrics" | "plan" = "agents";
 
 export type RunDashboardAction =
 	| "status"
@@ -94,6 +96,8 @@ export type RunDashboardAction =
 	| "health-recovery"
 	| "health-kill-stale"
 	| "health-diagnostic-export"
+	| "plan-approve"
+	| "plan-deny"
 	| "notifications-dismiss";
 export interface RunDashboardSelection {
 	runId: string;
@@ -404,7 +408,9 @@ export class RunDashboard implements DashboardComponent {
 	private runScrollOffset = 0;
 	private showFullProgress = false;
 	private showHelp = false;
-	private activePane: "agents" | "progress" | "mailbox" | "output" | "health" | "metrics" = lastActivePane;
+	private activePane: "agents" | "progress" | "mailbox" | "output" | "health" | "metrics" | "plan" = lastActivePane;
+	/** WP-7 (R7): pane-scoped revision-diff toggle (X). */
+	private planDiff = false;
 	private runs: TeamRunManifest[];
 	private readonly done: (selection: RunDashboardSelection | undefined) => void;
 	private readonly theme: CrewTheme;
@@ -638,7 +644,7 @@ export class RunDashboard implements DashboardComponent {
 				lines.push(
 					border("╭", "╮"),
 					row(
-						`${fg("accent", "▐")} ${this.theme.bold("pi-crew")} · ${this.runs.length} runs  ${fg("dim", "1-6 pane · ↑↓ · Enter · ? help · Esc")}`,
+						`${fg("accent", "▐")} ${this.theme.bold("pi-crew")} · ${this.runs.length} runs  ${fg("dim", "1-7 pane · ↑↓ · Enter · ? help · Esc")}`,
 					),
 					sep(),
 				);
@@ -732,7 +738,9 @@ export class RunDashboard implements DashboardComponent {
 															registry: this.options.registry,
 														}),
 													)
-												: safeRenderPane("transcript", () => renderTranscriptPane(snap))
+												: this.activePane === "plan"
+													? safeRenderPane("plan", () => renderPlanPane(snap, { diff: this.planDiff }))
+													: safeRenderPane("transcript", () => renderTranscriptPane(snap))
 							: [...readAgentPreview(r, 4, this.options), ...readProgressPreview(r, 2, this.options.snapshotCache)];
 						const filteredPane = paneLines.filter((l) => l && !l.includes("(none)") && l.trim() !== "");
 						if (filteredPane.length > 0) {
@@ -832,6 +840,19 @@ export class RunDashboard implements DashboardComponent {
 			this.done(selectedRunId ? { runId: selectedRunId, action: "status" } : undefined);
 			return;
 		}
+		// WP-3 (H4-subset): plan approval keys. Deliberately a DEDICATED branch
+		// (not the generic union block below) because plan actions must gate on
+		// the selected run actually being parked on a pending approval — a
+		// stray keystroke on a non-pending run is a silent no-op (dashboard
+		// stays open) instead of closing it via done(undefined).
+		if (action === "plan-approve" || action === "plan-deny") {
+			const run = selectedRunFromGrouped(this.runs, this.selected, this.options.snapshotCache);
+			const manifest = run ? (snapshotFor(run, this.options.snapshotCache)?.manifest ?? run) : undefined;
+			if (run && manifest && isPlanApprovalPending(manifest)) {
+				this.done({ runId: run.runId, action });
+			}
+			return;
+		}
 		if (
 			action === "summary" ||
 			action === "artifacts" ||
@@ -875,7 +896,12 @@ export class RunDashboard implements DashboardComponent {
 		else if (action === "pane-output") this.activePane = "output";
 		else if (action === "pane-health") this.activePane = "health";
 		else if (action === "pane-metrics") this.activePane = "metrics";
-		else if (action === "up") this.selected = Math.max(0, this.selected - 1);
+		else if (action === "pane-plan") this.activePane = "plan";
+		else if (action === "plan-diff") {
+			this.planDiff = !this.planDiff;
+			this.invalidate();
+			return;
+		} else if (action === "up") this.selected = Math.max(0, this.selected - 1);
 		else if (action === "down") {
 			const selectableCount = groupedRuns(this.runs, this.options.snapshotCache).filter((row) => row.run).length;
 			this.selected = Math.min(Math.max(0, selectableCount - 1), this.selected + 1);