pi-crew 0.10.1 → 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/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/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;