pi-crew 0.9.68 → 0.10.2

package/src/ui/run-snapshot-cache.ts

@@ -1,12 +1,14 @@
 import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { getCrewEnv } from "../config/env-vars.ts";
 import { agentOutputPath, agentsPath, readCrewAgents, readCrewAgentsAsync } from "../runtime/crew-agent-records.ts";
 import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
 import { isActiveRunStatus } from "../runtime/process-status.ts";
 import type { MailboxMessageStatus } from "../state/coordination/mailbox.ts";
 import type { TeamEvent } from "../state/event-log/event-log.ts";
 import { sequencePath } from "../state/event-log/event-log.ts";
+import { loadPlanRecords, planFilePath } from "../state/stores/plan-store.ts";
 import { loadRunManifestById, loadRunManifestByIdAsync } from "../state/stores/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { extractDwfPhaseState } from "./dwf-phase-display.ts";
@@ -25,6 +27,12 @@ export interface RunSnapshotCache extends RunSnapshotCacheBase {
 	preloadAllStale(runIds: string[]): Promise<void>;
 }
 
+/** WP-7 (R7): the plans slice + Plan pane load only when this flag is set —
+ *  flag-off keeps the snapshot build byte-identical (zero extra I/O). */
+export function isPlanUiEnabled(): boolean {
+	return getCrewEnv("PI_CREW_PLAN_UI") === "1";
+}
+
 const DEFAULT_TTL_MS = 1500;
 const DEFAULT_MAX_ENTRIES = 24;
 const DEFAULT_RECENT_EVENTS = 20;
@@ -44,6 +52,8 @@ interface SnapshotStamps {
 	agents: FileStamp;
 	events: FileStamp;
 	mailbox: FileStamp;
+	/** WP-7 (R7): present only when PI_CREW_PLAN_UI=1. */
+	plans?: FileStamp;
 }
 
 interface CacheEntry {
@@ -163,15 +173,10 @@ function safeAgentOutputPath(manifest: TeamRunManifest, agent: CrewAgentRecord):
 	}
 }
 
-function outputStamp(manifest: TeamRunManifest, agents: CrewAgentRecord[]): FileStamp {
-	return combineStamps(agents.map((agent) => stampFile(safeAgentOutputPath(manifest, agent))));
-}
-
-async function outputStampAsync(manifest: TeamRunManifest, agents: CrewAgentRecord[]): Promise<FileStamp> {
-	return combineStamps(await Promise.all(agents.map((agent) => stampFileAsync(safeAgentOutputPath(manifest, agent)))));
-}
-
-function sameStamp(a: FileStamp, b: FileStamp): boolean {
+function sameStamp(a: FileStamp | undefined, b: FileStamp | undefined): boolean {
+	// Optional stamps (WP-7 plans): absent on both sides = unchanged; absent
+	// on one side = the flag flipped — force a rebuild.
+	if (a === undefined || b === undefined) return a === b;
 	return a.mtimeMs === b.mtimeMs && a.size === b.size;
 }
 
@@ -181,19 +186,11 @@ function sameStamps(a: SnapshotStamps, b: SnapshotStamps): boolean {
 		sameStamp(a.tasks, b.tasks) &&
 		sameStamp(a.agents, b.agents) &&
 		sameStamp(a.events, b.events) &&
-		sameStamp(a.mailbox, b.mailbox)
+		sameStamp(a.mailbox, b.mailbox) &&
+		sameStamp(a.plans, b.plans)
 	);
 }
 
-function readTasks(tasksPath: string): TeamTaskState[] {
-	try {
-		const parsed = JSON.parse(fs.readFileSync(tasksPath, "utf-8")) as unknown;
-		return Array.isArray(parsed) ? (parsed as TeamTaskState[]) : [];
-	} catch {
-		throw new Error(`Failed to parse tasks at ${tasksPath}`);
-	}
-}
-
 /** Tail-read JSONL lines from a file, returning parsed objects (limited). */
 function tailJsonlLines<T>(filePath: string, limit: number, parse: (line: string) => T | undefined): T[] {
 	if (limit <= 0) return [];
@@ -711,6 +708,21 @@ function computeSliceSignatures(input: Omit<RunUiSnapshot, "signature" | "fetche
 				event.data?.reason,
 			]),
 		),
+		...(input.plans
+			? {
+					// WP-7 (R7): plan writes (revision append / approval flip / item
+					// linkage) must invalidate the Plan pane. Plans live outside the
+					// stamped files' content — the slice hashes the records directly.
+					plans: hash(
+						input.plans.map((record) => [
+							record.version,
+							record.approval?.status,
+							record.items.map((item) => [item.id, item.status, item.taskIds]),
+							record.phases.map((p) => [p.id, p.status]),
+						]),
+					),
+				}
+			: {}),
 	};
 }
 
@@ -723,7 +735,21 @@ function signatureFor(
 		const digest = createHash("sha256");
 		digest.update(
 			JSON.stringify({
-				run: [input.manifest.runId, input.manifest.status, input.manifest.updatedAt, input.manifest.artifacts.length],
+				// WP-3 (H4): planApproval.status is a RUN-level field surfaced by the
+				// widget badge / progress banner / powerbar segment — pending→approved
+				// must flip the signature so per-run render caches (run-dashboard keys
+				// on snapshot.signature) invalidate. `undefined` serializes as null,
+				// keeping the array shape stable for older manifests without the field.
+				run: [
+					input.manifest.runId,
+					input.manifest.status,
+					input.manifest.updatedAt,
+					input.manifest.artifacts.length,
+					input.manifest.planApproval?.status,
+					// T2/R4 (ADR-4 §2): a re-plan (revision switch) or record-side
+					// approval flip must invalidate per-run render caches too.
+					input.manifest.plan?.version ?? null,
+				],
 				tasks: sliceSignatures.tasks,
 				agents: sliceSignatures.agents,
 				progress: input.progress,
@@ -731,6 +757,7 @@ function signatureFor(
 				mailbox: input.mailbox,
 				groupJoins: input.groupJoins,
 				events: sliceSignatures.events,
+				...(sliceSignatures.plans ? { plans: sliceSignatures.plans } : {}),
 				cancellationReason: input.cancellationReason,
 				dwfPhaseState: input.dwfPhaseState,
 				output: input.recentOutputLines,
@@ -744,16 +771,8 @@ function signatureFor(
 	}
 }
 
-/**
- * 1.6 / 1.7 — compute one short hash per logical slice of the snapshot so
- * dashboard panes / widget can short-circuit when their slice hasn't moved.
- * The slice contents must mirror what `signatureFor` packs into each branch.
- */
-function sliceSignaturesFor(sliceSignatures: SliceSignatures): SliceSignatures {
-	return sliceSignatures;
-}
-
 function stampsFor(manifest: TeamRunManifest, _agents: CrewAgentRecord[]): SnapshotStamps {
+	// WP-7: optional plans stamp — one extra statSync, flag-gated.
 	// 1.4: use events sequence file instead of stat-ing the events log directly.
 	// 1.5: drop per-agent output.log stamping; rely on event-bus invalidation
 	// (`crew.subagent.*` and stream events) and on agents.json mtime which
@@ -765,6 +784,7 @@ function stampsFor(manifest: TeamRunManifest, _agents: CrewAgentRecord[]): Snaps
 		agents: stampFile(agentsPath(manifest)),
 		events: eventsStamp(manifest.eventsPath),
 		mailbox: mailboxStamp(manifest),
+		...(isPlanUiEnabled() ? { plans: stampFile(planFilePath(manifest)) } : {}),
 	};
 }
 
@@ -834,7 +854,12 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 		let tasks: TeamTaskState[];
 		let agents: CrewAgentRecord[];
 		try {
-			tasks = readTasks(loaded.manifest.tasksPath);
+			// R10-4 (docs/refactor-plan.review.md §ROUND 10): sync/async parity.
+			// loadRunManifestById already returns tasks validated against the
+			// current tasks.json (mtime+size+generation check in state-store),
+			// so the old readTasks() re-read only doubled tasks.json I/O per
+			// sync rebuild. buildAsync() has always used loaded.tasks.
+			tasks = loaded.tasks;
 			agents = readCrewAgents(loaded.manifest);
 		} catch {
 			if (previous) return previous;
@@ -857,6 +882,7 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 			dwfPhaseState: extractDwfPhaseState(recentEvents),
 			recentEvents,
 			recentOutputLines: recentOutputLines(loaded.manifest, agents, recentOutputLimit),
+			...(isPlanUiEnabled() ? { plans: loadPlanRecords(loaded.manifest) } : {}),
 		};
 		const stamps = stampsFor(loaded.manifest, agents);
 		const sliceSignatures = computeSliceSignatures(base);
@@ -915,6 +941,7 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 			dwfPhaseState: extractDwfPhaseState(recentEvents),
 			recentEvents,
 			recentOutputLines: recentOutput,
+			...(isPlanUiEnabled() ? { plans: loadPlanRecords(loaded.manifest) } : {}),
 		};
 		const stamps = await stampsForAsync(loaded.manifest, agents);
 		const sliceSignatures = computeSliceSignatures(base);

package/src/ui/snapshot-types.ts

@@ -1,6 +1,6 @@
 import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
 import type { TeamEvent } from "../state/event-log/event-log.ts";
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import type { PlanRecord, TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import type { DwfPhaseState } from "./dwf-phase-display.ts";
 
 export interface RunUiProgress {
@@ -64,6 +64,8 @@ export interface RunUiSnapshot {
 		mailbox: string;
 		progress: string;
 		events: string;
+		/** WP-7 (R7): present only when the plans slice is loaded (flag on). */
+		plans?: string;
 	};
 	manifest: TeamRunManifest;
 	tasks: TeamTaskState[];
@@ -76,6 +78,9 @@ export interface RunUiSnapshot {
 	cancellationReason?: string;
 	/** DWF phase state derived from `recentEvents`. Null/absent for non-DWF runs. */
 	dwfPhaseState?: DwfPhaseState | null;
+	/** WP-7 (R7): plan records for the Plan pane — populated ONLY when
+	 *  PI_CREW_PLAN_UI=1 (flag-off → field absent, zero extra I/O). */
+	plans?: PlanRecord[];
 	recentEvents: TeamEvent[];
 	recentOutputLines: string[];
 }

package/src/ui/widget/index.ts

@@ -11,6 +11,9 @@ import { DEFAULT_UI } from "../../config/defaults.ts";
 import type { ManifestCache } from "../../runtime/manifest-cache.ts";
 import type { TeamRunManifest } from "../../state/types.ts";
 import { truncate } from "../../utils/visual.ts";
+import { isFooterDockSinkActive, setFooterDockProvider } from "../dock-footer.ts";
+import { panelRowsFromRuns } from "../inline-panel/panel-rows.ts";
+import { panelDisplayState, setPanelRowsProvider, subscribePanelChange } from "../inline-panel/panel-store.ts";
 import { requestRender, requestRenderTarget, setExtensionWidget } from "../pi-ui-compat.ts";
 import type { OverlaySchedulerHandle } from "../shared-overlay-scheduler.ts";
 import { registerOverlayScheduler } from "../shared-overlay-scheduler.ts";
@@ -18,6 +21,7 @@ import type { RunSnapshotCache } from "../snapshot-types.ts";
 import { spinnerBucket, spinnerFrame } from "../spinner.ts";
 import type { CrewTheme } from "../theme-adapter.ts";
 import { asCrewTheme, subscribeThemeChange } from "../theme-adapter.ts";
+import { buildTaskListLines } from "./task-list.ts";
 import { activeWidgetRuns, statusSummary } from "./widget-model.ts";
 import { buildWidgetLines, colorWidgetLine, DEFAULT_WIDGET_WIDTH, renderLines } from "./widget-renderer.ts";
 import type { CrewWidgetModel, CrewWidgetState, WidgetRun } from "./widget-types.ts";
@@ -62,6 +66,8 @@ export {
 const MAX_LINES_DEFAULT = DEFAULT_UI.widgetMaxLines;
 const LEGACY_WIDGET_KEY = "pi-crew";
 const WIDGET_KEY = "pi-crew-active";
+/** The run's plan progress, painted ABOVE the editor (task-list.ts). */
+const TASKS_WIDGET_KEY = "pi-crew-tasks";
 const STATUS_KEY = "pi-crew";
 
 /**
@@ -78,11 +84,12 @@ const SIGNATURE_CACHE_TTL_MS = 100;
 // next invalidate; a mid-run resize could briefly paint a frame at the old
 // width. We register ONE debounced process-level listener (guarded so it never
 // accumulates across widget reinstalls) that busts the active widget's cache
-// and pokes Pi to repaint at the new width. The listener references a
-// module-level `activeResizeTarget` (the most-recently-mounted widget) rather
-// than a specific instance, so replaced widgets do not leak listeners.
+// and pokes Pi to repaint at the new width. The listener references the
+// module-level `activeResizeTargets` set (every mounted widget) rather than
+// specific instances, so replaced widgets do not leak listeners.
 let resizeListenerInstalled = false;
-let activeResizeTarget: { invalidate(): void; requestRepaint(): void } | undefined;
+/** All mounted widgets (dock + task list) — every one gets resize-busted. */
+const activeResizeTargets = new Set<{ invalidate(): void; requestRepaint(): void }>();
 let resizeTimer: ReturnType<typeof setTimeout> | undefined;
 
 /**
@@ -95,8 +102,10 @@ const onResize = (): void => {
 	// Debounce (~120ms) so a drag-resize doesn't thrash renders.
 	resizeTimer = setTimeout(() => {
 		resizeTimer = undefined;
-		activeResizeTarget?.invalidate();
-		activeResizeTarget?.requestRepaint();
+		for (const target of activeResizeTargets) {
+			target.invalidate();
+			target.requestRepaint();
+		}
 	}, 120);
 };
 
@@ -134,7 +143,7 @@ export function uninstallResizeListener(): void {
 		clearTimeout(resizeTimer);
 		resizeTimer = undefined;
 	}
-	activeResizeTarget = undefined;
+	activeResizeTargets.clear();
 	process.off("SIGWINCH", onResize);
 	// Windows has no SIGWINCH; Node emits "resize" on stdout instead.
 	// Remove via whichever API is present. The listener was only registered
@@ -159,6 +168,8 @@ interface WidgetComponent extends CrewComponent {}
 class CrewWidgetComponent implements WidgetComponent {
 	private readonly model: CrewWidgetModel;
 	private theme: CrewTheme;
+	/** Which surface this instance paints: the agent dock, or the task list. */
+	private readonly variant: "dock" | "tasks";
 	private cacheSignature = "";
 	/** C4 — invalidate-on-write cache for the buildSignature() result. */
 	private cachedBuildSignature = "";
@@ -169,10 +180,12 @@ class CrewWidgetComponent implements WidgetComponent {
 	private cachedTheme: CrewTheme;
 	private readonly tui: unknown;
 	private readonly unsubscribeTheme: () => void;
+	private readonly unsubscribePanel: () => void;
 	private readonly schedulerHandle: OverlaySchedulerHandle;
 
-	constructor(model: CrewWidgetModel, themeLike: unknown, tui?: unknown) {
+	constructor(model: CrewWidgetModel, themeLike: unknown, tui?: unknown, variant: "dock" | "tasks" = "dock") {
 		this.model = model;
+		this.variant = variant;
 		this.theme = asCrewTheme(themeLike);
 		this.cachedTheme = this.theme;
 		this.tui = tui;
@@ -180,9 +193,16 @@ class CrewWidgetComponent implements WidgetComponent {
 		// terminal-resize listener is installed. On a resize the cached width
 		// goes stale; busting the cache + requesting a repaint refreshes the
 		// widget at the new width without waiting for the next event tick (T-2).
-		activeResizeTarget = this;
+		activeResizeTargets.add(this);
 		installResizeListener();
 		this.unsubscribeTheme = subscribeThemeChange(themeLike, () => this.invalidate());
+		// Cursor movement is a keypress, not a run event, so it never reaches the
+		// shared scheduler. Repaint directly instead of waiting for the next host
+		// tick — a lagging cursor reads as a dropped keystroke.
+		this.unsubscribePanel = subscribePanelChange(() => {
+			this.invalidate();
+			this.requestRepaint();
+		});
 		// 1.10 (UI-P1-1): route run:state / worker:lifecycle / ui:invalidate
 		// through a RenderScheduler (debounce + fallback) instead of three
 		// direct runEventBus.onChannel subscriptions. With 3 overlays
@@ -265,8 +285,9 @@ class CrewWidgetComponent implements WidgetComponent {
 
 	dispose(): void {
 		this.unsubscribeTheme();
+		this.unsubscribePanel();
 		this.schedulerHandle.dispose();
-		if (activeResizeTarget === this) activeResizeTarget = undefined;
+		activeResizeTargets.delete(this);
 	}
 
 	render(width: number): string[] {
@@ -295,7 +316,35 @@ class CrewWidgetComponent implements WidgetComponent {
 		const signature = `${sigBase}:${this.model.notificationCount ?? 0}`;
 		const runningGlyph = spinnerFrame("widget-header");
 
-		if (this.cacheSignature !== signature || width !== this.cachedWidth || this.cachedTheme !== this.theme) {
+		// Task-list variant: the run's plan above the editor (task-list.ts).
+		// No panel state, no spinner glyph — the list changes only on task
+		// transitions, which the run signature already covers.
+		if (this.variant === "tasks") {
+			if (this.cacheSignature !== signature || width !== this.cachedWidth || this.cachedTheme !== this.theme) {
+				this.cachedBaseLines = buildTaskListLines(runs, width);
+				this.cachedLines = this.colorize(this.cachedBaseLines, width);
+				this.cachedWidth = width;
+				this.cachedTheme = this.theme;
+				this.cacheSignature = signature;
+			}
+			if (runs.length === 0) {
+				this.invalidate();
+				return [];
+			}
+			return this.cachedLines.map((line) => truncate(line, width));
+		}
+
+		// Panel cursor/pane state is part of the rendered output, so it belongs in
+		// the cache key — otherwise moving the cursor would not repaint.
+		const panel = panelDisplayState();
+		const signatureWithPanel = `${signature}|panel:${panel.selectedTaskId ?? ""}/${panel.viewedTaskId ?? ""}/${panel.focused ? 1 : 0}`;
+
+		// The spinner-frame swap only belongs on the LEGACY header, whose line 0
+		// already starts with a glyph position (`<frame> Crew agents …`). The
+		// compact dock's line 0 is the HINT text ("agents (N) — ↓ to select"):
+		// swapping would visibly eat its first character on every frame.
+		const compactDock = this.model.rowStyle === "compact";
+		if (this.cacheSignature !== signatureWithPanel || width !== this.cachedWidth || this.cachedTheme !== this.theme) {
 			this.cachedBaseLines = buildWidgetLines(
 				this.model.cwd,
 				0,
@@ -303,14 +352,15 @@ class CrewWidgetComponent implements WidgetComponent {
 				runs,
 				this.model.notificationCount ?? 0,
 				width,
+				{ rowStyle: this.model.rowStyle, ...panel },
 			).map((line, index) => {
-				if (index === 0 && line.length > 0) return `${runningGlyph}${line.slice(1)}`;
+				if (!compactDock && index === 0 && line.length > 0) return `${runningGlyph}${line.slice(1)}`;
 				return line;
 			});
 			this.cachedLines = this.colorize(this.cachedBaseLines, width);
 			this.cachedWidth = width;
 			this.cachedTheme = this.theme;
-			this.cacheSignature = signature;
+			this.cacheSignature = signatureWithPanel;
 		}
 
 		if (runs.length === 0) {
@@ -323,12 +373,43 @@ class CrewWidgetComponent implements WidgetComponent {
 			return [];
 		}
 
-		const updatedHeader = `${runningGlyph}${this.cachedBaseLines[0]?.slice(1) ?? ""}`;
-		this.cachedLines[0] = truncate(colorWidgetLine(updatedHeader, 0, this.theme), width);
+		if (!compactDock) {
+			const updatedHeader = `${runningGlyph}${this.cachedBaseLines[0]?.slice(1) ?? ""}`;
+			this.cachedLines[0] = truncate(colorWidgetLine(updatedHeader, 0, this.theme), width);
+		}
 		return this.cachedLines.map((line) => truncate(line, width));
 	}
 }
 
+// ── Footer dock host (widgetPlacement: "bottom") ──────────────────────
+
+/**
+ * Dock host for `widgetPlacement: "bottom"`. Keeps a single CrewWidgetComponent
+ * (theme-less → raw lines, no ANSI) per session and feeds its render output to
+ * the crew-vibes footer through the dock-footer registry. The footer colors the
+ * lines with ITS OWN theme so the dock matches the footer context. All caching,
+ * event wiring (panel changes, run events, resize) lives in the wrapped
+ * component; the footer is re-rendered by pi on every host repaint.
+ */
+class FooterDockHost {
+	private component: CrewWidgetComponent | undefined;
+	private readonly model: CrewWidgetModel;
+
+	constructor(model: CrewWidgetModel) {
+		this.model = model;
+	}
+
+	render(width: number): string[] {
+		if (!this.component) this.component = new CrewWidgetComponent(this.model, undefined, undefined);
+		return this.component.render(width);
+	}
+
+	dispose(): void {
+		this.component?.dispose();
+		this.component = undefined;
+	}
+}
+
 // ── Re-export listLiveAgents for buildSignature ───────────────────────
 
 import { listLiveAgents } from "../../runtime/live-session/live-agent-manager.ts";
@@ -355,20 +436,39 @@ export function updateCrewWidget(
 	}
 
 	const runs = activeWidgetRuns(ctx.cwd, manifestCache, snapshotCache, preloadedManifests, workspaceId);
-	const lines = buildWidgetLines(ctx.cwd, state.frame, maxLines, runs, state.notificationCount ?? 0, getRenderWidth());
+	const rowStyle = config?.widgetRowStyle ?? DEFAULT_UI.widgetRowStyle;
+	// The inline panel navigates the same run list the widget paints, and this is
+	// the only place already holding the manifest/snapshot caches — so the row
+	// projection is registered here instead of re-reading state on every keypress.
+	setPanelRowsProvider(() => panelRowsFromRuns(activeWidgetRuns(ctx.cwd, manifestCache, snapshotCache, preloadedManifests, workspaceId)));
+	const lines = buildWidgetLines(ctx.cwd, state.frame, maxLines, runs, state.notificationCount ?? 0, getRenderWidth(), {
+		rowStyle,
+		...panelDisplayState(),
+	});
 	const placement = config?.widgetPlacement ?? DEFAULT_UI.widgetPlacement;
+	// `bottom` is not a pi widget slot: the dock then renders inside the
+	// crew-vibes footer (dock-footer registry). pi's slot calls always use a
+	// real slot so legacy-clear/installs stay on maps pi understands.
+	const bottomMode = placement === "bottom";
+	const dockInFooter = bottomMode && isFooterDockSinkActive();
+	const piPlacement: "aboveEditor" | "belowEditor" = bottomMode ? "belowEditor" : placement;
 
 	ctx.ui.setStatus(STATUS_KEY, lines.length ? statusSummary(runs) : undefined);
 
 	const shouldClearLegacy = state.legacyCleared !== true || state.lastPlacement !== placement;
 	if (shouldClearLegacy) {
-		setExtensionWidget(ctx, LEGACY_WIDGET_KEY, undefined, { placement });
+		setExtensionWidget(ctx, LEGACY_WIDGET_KEY, undefined, { placement: piPlacement });
 		state.legacyCleared = true;
 	}
 
 	if (!lines.length) {
 		if (state.lastVisibility !== "hidden" || state.lastPlacement !== placement) {
-			setExtensionWidget(ctx, WIDGET_KEY, undefined, { placement });
+			setExtensionWidget(ctx, WIDGET_KEY, undefined, { placement: piPlacement });
+			setExtensionWidget(ctx, TASKS_WIDGET_KEY, undefined, { placement: "aboveEditor" });
+			state.lastTasksVisibility = "hidden";
+			state.footerDock?.dispose();
+			state.footerDock = undefined;
+			setFooterDockProvider(undefined);
 			state.lastVisibility = "hidden";
 			state.lastPlacement = placement;
 			state.lastKey = WIDGET_KEY;
@@ -398,6 +498,7 @@ export function updateCrewWidget(
 			snapshotCache,
 			preloadManifests: preloadedManifests,
 			workspaceId,
+			rowStyle,
 		};
 	else {
 		state.model.cwd = ctx.cwd;
@@ -408,12 +509,33 @@ export function updateCrewWidget(
 		state.model.snapshotCache = snapshotCache;
 		state.model.preloadManifests = preloadedManifests;
 		state.model.workspaceId = workspaceId;
+		state.model.rowStyle = rowStyle;
 	}
 
-	if (needsWidgetInstall) {
+	if (dockInFooter) {
+		// Keep pi's widget slot free: the crew-vibes footer paints the dock at
+		// the very bottom, below the quota/meter lines. A widget-slot install
+		// from a PREVIOUS placement (or a sink that was just enabled) must be
+		// removed first.
+		if (needsWidgetInstall && state.lastKey === WIDGET_KEY) {
+			setExtensionWidget(ctx, WIDGET_KEY, undefined, { placement: piPlacement });
+		}
+		if (!state.footerDock) state.footerDock = new FooterDockHost(state.model);
+		setFooterDockProvider((width) => state.footerDock!.render(width));
+	} else {
+		// Widget-slot path (aboveEditor/belowEditor, or no footer sink for
+		// "bottom"): ensure any stale footer dock is detached first.
+		if (state.footerDock) {
+			state.footerDock.dispose();
+			state.footerDock = undefined;
+		}
+		setFooterDockProvider(undefined);
+	}
+
+	if (needsWidgetInstall && !dockInFooter) {
 		const model = state.model;
 		setExtensionWidget(ctx, WIDGET_KEY, ((_tui: unknown, theme: unknown) => new CrewWidgetComponent(model, theme, _tui)) as never, {
-			placement,
+			placement: piPlacement,
 			persist: true,
 		});
 		state.lastVisibility = "visible";
@@ -421,6 +543,32 @@ export function updateCrewWidget(
 		state.lastKey = WIDGET_KEY;
 		state.lastMaxLines = maxLines;
 		state.lastCwd = ctx.cwd;
+	} else if (dockInFooter) {
+		state.lastVisibility = "visible";
+		state.lastPlacement = placement;
+		state.lastKey = WIDGET_KEY;
+		state.lastMaxLines = maxLines;
+		state.lastCwd = ctx.cwd;
+	}
+
+	// Task list (aboveEditor): the run's plan progress — Claude Code / droid
+	// style, independent of the dock's placement (so it also shows when the
+	// dock renders in the crew-vibes footer). Installed once while any
+	// display-active run exists; the component paints nothing until a run
+	// carries a tasks slice.
+	const tasksVisible = runs.length > 0 && Boolean(state.model);
+	if (tasksVisible && state.lastTasksVisibility !== "visible") {
+		const model = state.model;
+		setExtensionWidget(
+			ctx,
+			TASKS_WIDGET_KEY,
+			((_tui: unknown, theme: unknown) => new CrewWidgetComponent(model, theme, _tui, "tasks")) as never,
+			{ placement: "aboveEditor" },
+		);
+		state.lastTasksVisibility = "visible";
+	} else if (!tasksVisible && state.lastTasksVisibility === "visible") {
+		setExtensionWidget(ctx, TASKS_WIDGET_KEY, undefined, { placement: "aboveEditor" });
+		state.lastTasksVisibility = "hidden";
 	}
 
 	requestRender(ctx);
@@ -436,9 +584,15 @@ export function stopCrewWidget(
 	uninstallResizeListener();
 	if (ctx?.hasUI) {
 		const placement = config?.widgetPlacement ?? DEFAULT_UI.widgetPlacement;
+		const piPlacement: "aboveEditor" | "belowEditor" = placement === "bottom" ? "belowEditor" : placement;
 		ctx.ui.setStatus(STATUS_KEY, undefined);
-		setExtensionWidget(ctx, LEGACY_WIDGET_KEY, undefined, { placement });
-		setExtensionWidget(ctx, WIDGET_KEY, undefined, { placement });
+		setExtensionWidget(ctx, LEGACY_WIDGET_KEY, undefined, { placement: piPlacement });
+		setExtensionWidget(ctx, WIDGET_KEY, undefined, { placement: piPlacement });
+		setExtensionWidget(ctx, TASKS_WIDGET_KEY, undefined, { placement: "aboveEditor" });
+		state.lastTasksVisibility = "hidden";
+		state.footerDock?.dispose();
+		state.footerDock = undefined;
+		setFooterDockProvider(undefined);
 		state.lastVisibility = "hidden";
 		state.lastPlacement = placement;
 		state.lastKey = WIDGET_KEY;