pi-crew 0.10.1 → 0.10.2

package/src/config/config-validation.ts

@@ -456,11 +456,17 @@ function parseAgentOverride(value: unknown): AgentOverrideConfig | undefined {
 function parseUiConfig(value: unknown): CrewUiConfig | undefined {
 	const obj = asRecord(value);
 	if (!obj) return undefined;
-	const rawWidgetPlacement = parseWithSchema(Type.Union([Type.Literal("aboveEditor"), Type.Literal("belowEditor")]), obj.widgetPlacement);
+	const rawWidgetPlacement = parseWithSchema(
+		Type.Union([Type.Literal("aboveEditor"), Type.Literal("belowEditor"), Type.Literal("bottom")]),
+		obj.widgetPlacement,
+	);
 	const rawDashboardPlacement = parseWithSchema(Type.Union([Type.Literal("center"), Type.Literal("right")]), obj.dashboardPlacement);
+	const rawRowStyle = parseWithSchema(Type.Union([Type.Literal("compact"), Type.Literal("detailed")]), obj.widgetRowStyle);
 	const ui: CrewUiConfig = {
 		widgetPlacement: rawWidgetPlacement,
 		widgetMaxLines: parsePositiveInteger(obj.widgetMaxLines, 50),
+		widgetRowStyle: rawRowStyle,
+		inlinePanel: parseWithSchema(Type.Boolean(), obj.inlinePanel),
 		powerbar: parseWithSchema(Type.Boolean(), obj.powerbar),
 		dashboardPlacement: rawDashboardPlacement,
 		dashboardWidth: parseIntegerInRange(obj.dashboardWidth, 32, 120),

package/src/config/defaults.ts

@@ -129,8 +129,15 @@ export const DEFAULT_UI = {
 	refreshMs: 1000,
 	notifierIntervalMs: 5000,
 	widgetDefaultFrameMs: 1000,
-	widgetPlacement: "aboveEditor" as const,
+	// The crew widget (agent rows + hint + main row) docks BELOW the editor,
+	// matching pi-subtask's subtask panel — the transcript pane separately
+	// mounts above the editor, exactly like pi-subtask's fork view.
+	// The dock renders at the very bottom of the screen, below the crew-vibes
+	// quota/meter footer (falls back to belowEditor when no footer sink exists).
+	widgetPlacement: "bottom" as const,
 	widgetMaxLines: 8,
+	widgetRowStyle: "compact" as const,
+	inlinePanel: true,
 	powerbar: true,
 	dashboardPlacement: "center" as const,
 	dashboardWidth: 72,

package/src/config/role-tools.ts

@@ -90,9 +90,11 @@ export const ROLE_TOOL_CONFIGS: Record<string, RoleToolConfig> = {
 		scratchpad: true,
 	},
 
-	// Test Engineer - Can write tests (F1: hyphenated key)
+	// Test Engineer - Can write tests (F1: hyphenated key). Tool list mirrors
+	// agents/test-engineer.md frontmatter (T3 binding, commit c25dfbe2):
+	// search tools + delegate for spawning depth-1 helpers.
 	"test-engineer": {
-		tools: ["read", "edit", "write", "bash", "ls", "scratchpad", "ask"],
+		tools: ["read", "edit", "write", "bash", "ls", "glob", "grep", "find", "scratchpad", "ask", "delegate"],
 		excludeTools: ["web"],
 		// Phase 1 scratchpad: build/run test suites with state across cells.
 		scratchpad: true,

package/src/config/types.ts

@@ -143,8 +143,26 @@ export interface GoalWrapWorkflowConfig {
 }
 
 export interface CrewUiConfig {
-	widgetPlacement?: "aboveEditor" | "belowEditor";
+	/**
+	 * Where the crew dock (agents list) renders:
+	 *  - `aboveEditor` / `belowEditor`: pi's widget slots around the prompt;
+	 *  - `bottom`: inside the crew-vibes footer, BELOW the quota/meter lines
+	 *    (the very bottom of the screen). Falls back to `belowEditor` when
+	 *    crew-vibes is not active (no footer sink).
+	 */
+	widgetPlacement?: "aboveEditor" | "belowEditor" | "bottom";
 	widgetMaxLines?: number;
+	/**
+	 * Per-agent row layout in the widget. `compact` is one width-budgeted line
+	 * per agent; `detailed` keeps the two-line tree (name row + activity row).
+	 */
+	widgetRowStyle?: "compact" | "detailed";
+	/**
+	 * Keyboard-navigable agent rows under the prompt (`↓` from an empty prompt).
+	 * Requires owning pi's editor component, so it yields to any other extension
+	 * that already installed a custom editor.
+	 */
+	inlinePanel?: boolean;
 	powerbar?: boolean;
 	dashboardPlacement?: "center" | "right";
 	dashboardWidth?: number;

package/src/extension/crew-cleanup.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { cleanupAllTrackedTempDirs } from "../runtime/model/pi-args.ts";
+import { isSessionSwitchInFlight } from "../ui/inline-panel/view-session-store.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 
 // NOTE: globalProgressTracker import kept for documentation but not directly used
@@ -67,6 +68,18 @@ export function registerCleanupHandler(pi: ExtensionAPI, opts?: { disposeTermina
 		console.log("[pi-crew] Session shutdown - cleaning up resources");
 
 		try {
+			// Navigational switches (pi's own resume/new/fork) tear the session
+			// down on purpose — the user is only LOOKING at a different pi
+			// session; foreground team runs + their workers share this process
+			// and must keep running (P0: "jumping into any session stops the
+			// run" — exit 143 signature). Killing them here bypasses child-pi's
+			// abort flags, so the worker exit reads as an "unexpected
+			// code=143 signal=null" and the run is cancelled. Same contract as
+			// stopSessionBoundSubagents and the run-deadline caller-abort
+			// suppression; on REAL shutdowns (quit/reload) the flag is unset
+			// and this cleanup still drains the registry, as does the
+			// process-exit hook (tryRegisterSessionCleanup) when pi dies.
+			if (isSessionSwitchInFlight()) return;
 			// Kill all child-pi processes
 			await cleanupChildProcesses();
 

package/src/extension/crew-vibes/footer.ts

@@ -1,7 +1,9 @@
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getFooterDockProvider } from "../../ui/dock-footer.ts";
 import { requestRenderTarget } from "../../ui/pi-ui-compat.ts";
 import { asCrewTheme, type CrewTheme } from "../../ui/theme-adapter.ts";
+import { colorWidgetLine, renderLines } from "../../ui/widget/widget-renderer.ts";
 import { truncateToWidth, visibleWidth } from "../../utils/visual.ts";
 import type { CrewVibesConfig } from "./config.ts";
 import type { ProviderUsage } from "./provider-usage.ts";
@@ -280,11 +282,28 @@ class CrewVibesFooter implements FooterComponent {
 		return [truncateToWidth(cap, width, "…"), this.rightAlign(quota, width)];
 	}
 
+	/** Dock lines registered by the crew widget (`widgetPlacement: "bottom"`):
+	 *  painted as the very last block of the footer, below the quota/meters.
+	 *  The provider returns RAW lines; we color them with this footer's theme
+	 *  (same per-line palette the widget would have used) and truncate to the
+	 *  real render width. */
+	private buildDockLines(width: number): string[] {
+		const provider = getFooterDockProvider();
+		if (!provider) return [];
+		const raw = provider(width);
+		if (raw.length === 0) return [];
+		return renderLines(
+			raw.map((line, index) => colorWidgetLine(line, index, this.theme)),
+			width,
+		).map((line) => truncateToWidth(line, width, "…"));
+	}
+
 	render(width: number): string[] {
 		const lines = [this.buildPwdLine(width), this.buildStatsLine(width)];
 		const statusLine = this.buildStatusLine(width);
 		if (statusLine) lines.push(statusLine);
 		lines.push(...this.buildMeterLines(width));
+		lines.push(...this.buildDockLines(width));
 		return lines;
 	}
 }

package/src/extension/crew-vibes/index.ts

@@ -19,6 +19,7 @@ function safeUiCall(scope: string, fn: () => void): void {
 	}
 }
 
+import { setFooterDockSinkActive } from "../../ui/dock-footer.ts";
 import { type CrewVibesConfig, loadConfig, saveConfig } from "./config.ts";
 import { intervalForSpeed } from "./figures.ts";
 import { type CrewVibesFooterSource, createCrewVibesFooter } from "./footer.ts";
@@ -91,11 +92,18 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 	function installFooter(ctx: ExtensionContext): void {
 		if (!ctx?.hasUI) return;
 		if (!metersActive()) {
-			safeUiCall("clear-footer", () => setFooter(ctx, undefined));
+			safeUiCall("clear-footer", () => {
+				// The crew dock can no longer render at the very bottom — the
+				// widget falls back to pi's belowEditor slot automatically.
+				setFooterDockSinkActive(false);
+				setFooter(ctx, undefined);
+			});
 			return;
 		}
 		safeUiCall("install-footer", () => {
 			setFooter(ctx, (tui, theme, footerData) => createCrewVibesFooter({ tui, theme, footerData, ctx, source: footerSource }));
+			// The footer can now host the crew dock below the quota lines.
+			setFooterDockSinkActive(true);
 			requestRender(ctx);
 		});
 	}
@@ -245,6 +253,7 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 			stopFooterTimer();
 			stopCapacityTimer();
 			stopProviderTimer();
+			setFooterDockSinkActive(false);
 			setFooter(ctx, undefined);
 			clearVibesStatus(ctx);
 			return;
@@ -370,6 +379,7 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 		stopFooterTimer();
 		stopCapacityTimer();
 		stopProviderTimer();
+		setFooterDockSinkActive(false);
 		setFooter(ctx, undefined);
 		clearVibesStatus(ctx);
 	});

package/src/extension/register.ts

@@ -21,6 +21,7 @@ import { loadConfig } from "../config/config.ts";
 import { startRuntimeWarmup } from "../runtime/model/runtime-warmup.ts";
 import { primePeerDep } from "../runtime/peer-dep.ts";
 import { deployBundledThemes } from "../ui/deploy-bundled-themes.ts";
+import { installChildProcessAbortShield } from "../utils/child-process-shield.ts";
 import { resetTimings, time } from "../utils/timings.ts";
 import { registerAutonomousPolicy } from "./autonomous-policy.ts";
 import { registerContextStatusInjection } from "./context-status-injection.ts";
@@ -52,6 +53,13 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	resetTimings();
 	time("register:start");
 
+	// MUST run before any team run can start: guarantees every signal-spawned
+	// child in the process has an 'error' listener so Node's abort-after-exit
+	// AbortError dispatches instead of being rethrown on the next tick as an
+	// uncaughtException that kills pi (see child-process-shield.ts for the
+	// full crash chain — /crew-view mid-run crash).
+	installChildProcessAbortShield();
+
 	startRuntimeWarmup();
 	primePeerDep().catch(() => undefined);
 	deployBundledThemes();

package/src/extension/registration/command-registration.ts

@@ -31,6 +31,7 @@ export function registerPiCommands(pi: ExtensionAPI, ctx: RegistrationContext):
 		getManifestCache: ctx.getManifestCache,
 		getRunSnapshotCache: ctx.getRunSnapshotCache,
 		getMetricRegistry: () => ctx.observabilityState.metricRegistry,
+		getCurrentSessionFile: () => ctx.currentCtx?.sessionManager?.getSessionFile?.(),
 		uiState: ctx.uiState,
 		dismissNotifications: () => {
 			ctx.widgetState.notificationCount = 0;

package/src/extension/registration/commands/run.ts

@@ -17,7 +17,21 @@ export function registerRunCommands(pi: ExtensionAPI, deps: RegisterTeamCommands
 				abortForegroundRun: deps.abortForegroundRun,
 				onRunStarted: undefined,
 			});
-			await notifyCommandResult(ctx, commandText(result));
+			// A foreground run can span a session switch (e.g. the user opens
+			// an agent view mid-run and the run finishes there). The captured
+			// ctx is stale after the switch: ANY access to it (even reading a
+			// field) throws pi's "This extension ctx is stale ..." error, which
+			// pi then prints into whichever session is active. Probe
+			// defensively and skip the notification when the session moved on
+			// (the result is still visible via /team-status).
+			try {
+				const capturedFile = ctx.sessionManager?.getSessionFile?.();
+				const currentFile = deps.getCurrentSessionFile?.();
+				if (capturedFile && currentFile && capturedFile !== currentFile) return;
+				await notifyCommandResult(ctx, commandText(result));
+			} catch {
+				// Stale ctx during the probe or notify — nothing to do here.
+			}
 		},
 	});
 

package/src/extension/registration/commands/shared.ts

@@ -80,6 +80,14 @@ export interface RegisterTeamCommandsDeps {
 	getMetricRegistry?: () => MetricRegistry | undefined;
 	uiState?: UiState;
 	dismissNotifications?: () => void;
+	/**
+	 * The session file of the CURRENT session (RegistrationContext.currentCtx).
+	 * Commands whose handler can span a session switch — team-run awaits the
+	 * whole foreground run — use this after the await to detect that the
+	 * captured ctx is stale and skip notifications that pi would drop with a
+	 * "ctx is stale" error.
+	 */
+	getCurrentSessionFile?: () => string | undefined;
 }
 
 // Lazy-loaded UI module cache — avoids importing 900ms+ of UI at Pi startup.

package/src/extension/registration/foreground-run-controller.ts

@@ -20,6 +20,7 @@ import { setWorkingIndicator } from "../../ui/pi-ui-compat.ts";
 import { requestPowerbarUpdate } from "../../ui/powerbar-publisher.ts";
 import { updateCrewWidget } from "../../ui/widget/index.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
+import { safeAbort } from "../../utils/safe-abort.ts";
 import type { RegistrationContext } from "./registration-types.ts";
 
 /**
@@ -36,7 +37,10 @@ export function installForegroundRunController(pi: ExtensionAPI, ctx: Registrati
 	ctx.abortForegroundRun = (runId) => {
 		const controller = ctx.foregroundTeamRunControllers.get(runId);
 		if (!controller) return false;
-		controller.abort();
+		// safe-abort: cancel can race a completed run whose spawned children
+		// already exited — Node's child_process signal listener would throw
+		// AbortError out of abort() and kill the host (uncaughtException).
+		safeAbort(controller, "fg-run.abort-by-run-id");
 		return true;
 	};
 }
@@ -142,7 +146,11 @@ function startForegroundRunImpl(
 						.catch((error) => logInternalError("register.foreground-watchdog", error, `runId=${runId}`));
 				}
 				const ownerCurrent = ctx.isContextCurrent(extensionCtx, ownerGeneration);
-				if (extensionCtx.hasUI) {
+				// The owner ctx can go stale while the run is in flight (e.g. the
+				// user opened an agent session view via /crew-view and the run
+				// finishes there): the `hasUI` getter THROWS on a stale ctx, so
+				// it must only be touched for the still-current owner.
+				if (ownerCurrent && extensionCtx.hasUI) {
 					try {
 						setWorkingIndicator(extensionCtx);
 						extensionCtx.ui.setWorkingMessage();

package/src/extension/registration/lifecycle-handlers.ts

@@ -24,6 +24,7 @@ import { pruneFinishedRuns, pruneUserLevelRuns } from "../../extension/run-maint
 import { type BrokerSpawnCredentials, setActiveBrokerIssuer } from "../../runtime/broker/broker-issuer.ts";
 import { CrewBroker } from "../../runtime/broker/crew-broker.ts";
 import { terminateActiveChildPiProcesses } from "../../runtime/child-pi/child-pi.ts";
+import { forgetDetachedRun, hasDetachedRuns, peekFinishedDetachedRunResults } from "../../runtime/detached-run-results.ts";
 import { listLiveAgents } from "../../runtime/live-session/live-agent-manager.ts";
 import type { createManifestCache } from "../../runtime/manifest-cache.ts";
 import { configuredModelInfosFromPiConfig } from "../../runtime/model/model-fallback.ts";
@@ -39,7 +40,9 @@ import { applyCrewSettingsTiersToConfig, loadCrewSettingsTiers } from "../../run
 import { loadRunManifestById } from "../../state/stores/state-store.ts";
 import type { TeamRunManifest } from "../../state/types.ts";
 import { summarizeHeartbeats } from "../../ui/heartbeat-aggregator.ts";
-import { requestRender, setExtensionWidget } from "../../ui/pi-ui-compat.ts";
+import { installInlinePanel } from "../../ui/inline-panel/index.ts";
+import { clearSessionSwitchInFlight, markSessionSwitchInFlight } from "../../ui/inline-panel/view-session-store.ts";
+import { requestRender, setExtensionWidget, toPiWidgetPlacement } from "../../ui/pi-ui-compat.ts";
 import {
 	registerPiCrewPowerbarSegments,
 	requestPowerbarUpdate,
@@ -75,6 +78,36 @@ export function installSessionLifecycleHandlers(pi: ExtensionAPI, ctx: Registrat
 	installModelTrackingHandlers(pi);
 }
 
+/**
+ * Hand over the outcome of runs detached by an agent-view switch.
+ *
+ * Delivered as a DISPLAYED session entry (not a follow-up queue item): an idle
+ * session never flushes a follow-up, so the queued variant left the result
+ * invisible. Each result is dropped from the registry only after its send
+ * succeeded, and only while the owning session is current — a worker's view
+ * session must never receive the parent run's report.
+ */
+function deliverDetachedRunResults(pi: ExtensionAPI, extensionCtx: ExtensionContext): void {
+	if (!hasDetachedRuns()) return;
+	try {
+		// Agent views are in-document panes now, never sessions: the current
+		// session is always the main one, so detached results always deliver.
+		const inViewSession = false;
+		for (const { runId, text } of peekFinishedDetachedRunResults({ inViewSession })) {
+			pi.sendMessage({ customType: "pi-crew-run-result", content: text, display: true });
+			forgetDetachedRun(runId);
+			try {
+				extensionCtx.ui.notify(text.split("\n")[0] ?? `pi-crew run finished: ${runId}`, "info");
+			} catch {
+				/* toast is secondary to the session entry */
+			}
+		}
+	} catch (error) {
+		// Keep the entry: the next tick retries rather than losing the outcome.
+		logInternalError("register.detachedRunResults", error);
+	}
+}
+
 /**
  * model_select / thinking_level_select:
  *   Track what the MAIN session is *actually* running so subagents that
@@ -125,6 +158,12 @@ function installSessionShutdownHandler(pi: ExtensionAPI, ctx: RegistrationContex
  */
 function installSessionBeforeSwitchHandler(pi: ExtensionAPI, ctx: RegistrationContext): void {
 	pi.on("session_before_switch", () => {
+		// The switch tears the current turn down right after this handler
+		// (teardownCurrent → session.abort()). That turn-abort must NOT cancel
+		// a foreground team run that is still forming (see run-deadline.ts):
+		// foreground runs survive session switches (P0). Cleared on the next
+		// session_start.
+		markSessionSwitchInFlight();
 		ctx.sessionGeneration++;
 		const pendingCount = ctx.lifecycleState.deliveryCoordinator?.getPendingCount() ?? 0;
 		try {
@@ -167,6 +206,9 @@ function installSessionBeforeSwitchHandler(pi: ExtensionAPI, ctx: RegistrationCo
  */
 function installSessionStartHandler(pi: ExtensionAPI, ctx: RegistrationContext): void {
 	pi.on("session_start", (_event, extensionCtx) => {
+		// Any session start means a pending switch landed — the turn-abort
+		// suppression window for that switch is over.
+		clearSessionSwitchInFlight();
 		runArtifactCleanup(extensionCtx.cwd);
 
 		// Restore brief mode state from session entries (best-effort).
@@ -273,6 +315,13 @@ function installSessionStartHandler(pi: ExtensionAPI, ctx: RegistrationContext):
 		});
 		const cache = ctx.getManifestCache(extensionCtx.cwd);
 		updateCrewWidget(extensionCtx, ctx.widgetState, loadedConfig.config.ui, cache, ctx.getRunSnapshotCache(extensionCtx.cwd));
+		// Inline agent panel: keyboard-navigable rows under the prompt + per-agent
+		// transcript pane. Installed after the widget so the row projection sees
+		// the same caches the widget paint uses.
+		installInlinePanel(pi, extensionCtx, loadedConfig.config.ui);
+		// Returning from an agent view lands here: report any detached run that
+		// finished while the view was open, without waiting for a render tick.
+		deliverDetachedRunResults(pi, extensionCtx);
 		updatePiCrewPowerbar(
 			pi.events,
 			extensionCtx.cwd,
@@ -681,13 +730,14 @@ function setupRenderLoop(
 
 	const renderTick = (): void => {
 		if (!ctx.currentCtx) return;
+		deliverDetachedRunResults(pi, ctx.currentCtx);
 		const config = lastPreloadedConfig?.config.ui;
 		const activeCache = lastFrameManifestCache ?? ctx.getManifestCache(ctx.currentCtx.cwd);
 		const snapshotCache = lastFrameSnapshotCache ?? ctx.getRunSnapshotCache(ctx.currentCtx.cwd);
 		const manifests = lastPreloadedManifests;
 		if (!lastPreloadedConfig) backgroundPreload();
 		if (ctx.uiState.liveSidebarRunId || ctx.uiState.dashboardOpen) {
-			const placement = config?.widgetPlacement ?? DEFAULT_UI.widgetPlacement;
+			const placement = toPiWidgetPlacement(config?.widgetPlacement ?? DEFAULT_UI.widgetPlacement);
 			if (ctx.widgetState.lastVisibility !== "hidden" || ctx.widgetState.lastPlacement !== placement) {
 				setExtensionWidget(ctx.currentCtx, "pi-crew", undefined, { placement });
 				setExtensionWidget(ctx.currentCtx, "pi-crew-active", undefined, { placement });

package/src/extension/registration/runtime-cleanup.ts

@@ -20,12 +20,12 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { loadConfig } from "../../config/config.ts";
 import { clearHooksScoped } from "../../hooks/registry.ts";
-import { terminateActiveChildPiProcesses } from "../../runtime/child-pi/child-pi.ts";
 import { stopAllWatchdogs } from "../../runtime/foreground-watchdog.ts";
 import { clearPiCrewPowerbar, disposePowerbarCoalescer } from "../../ui/powerbar-publisher.ts";
 import { stopCrewWidget } from "../../ui/widget/index.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
 import { clearProjectRootCache } from "../../utils/paths.ts";
+import { safeAbortAll } from "../../utils/safe-abort.ts";
 import { extractSessionId } from "../../utils/session-utils.ts";
 import { stopAsyncRunNotifier } from "../async-notifier.ts";
 import { uninstallCrewGlobalRegistry } from "../team-tool.ts";
@@ -135,7 +135,9 @@ function buildCleanupRuntime(ctx: RegistrationContext): () => void {
 		ctx.stopSessionBoundSubagents();
 		// P0 fix: also abort foreground team runs on session shutdown (not on session switch).
 		// This is the only place where foreground team run controllers should be aborted.
-		for (const controller of ctx.foregroundTeamRunControllers.values()) controller.abort();
+		// safe-abort: shutdown races completed runs whose spawned children already
+		// exited — abort() would throw AbortError from Node's child_process listener.
+		safeAbortAll(ctx.foregroundTeamRunControllers.values(), "cleanup-runtime.foreground-team");
 		ctx.foregroundTeamRunControllers.clear();
 		// RC-01: stop the foreground-run watchdog timers on full shutdown — they were
 		// never cleared, so an active (non-terminal) foreground run left its watchdog
@@ -219,10 +221,26 @@ function buildStopSessionBoundSubagents(ctx: RegistrationContext): () => void {
 		// Only abort subagent controllers — NOT foreground team runs.
 		// Foreground team runs are bound to the session lifecycle; they will be aborted
 		// by cleanupRuntime during session_shutdown.
-		for (const controller of ctx.foregroundControllers.values()) controller.abort();
+		// safe-abort: these signals may be linked to spawned children (pipelines pass
+		// them into spawn options.signal); aborting after a child exited makes Node's
+		// child_process listener throw AbortError synchronously — inside a session
+		// event handler that would surface as uncaughtException and kill pi.
+		safeAbortAll(ctx.foregroundControllers.values(), "stop-session-bound.foreground");
 		ctx.foregroundControllers.clear();
-		ctx.subagentManager.abortAll("Session switching — foreground subagents cancelled.");
-		terminateActiveChildPiProcesses();
+		try {
+			ctx.subagentManager.abortAll("Session switching — foreground subagents cancelled.");
+		} catch (error) {
+			logInternalError("stop-session-bound.abortAll", error);
+		}
+		// Deliberately NOT terminateActiveChildPiProcesses() here: the active
+		// child registry holds EVERY child pi spawned in this process —
+		// including foreground team-run workers. Killing them on a session
+		// switch (resume/new/fork) is exactly the regression "jumping into any
+		// session stops the run" (exit 143). Session-bound subagents are
+		// cancelled above via their own controllers; foreground runs must
+		// survive switches (P0) and are aborted only by cleanupRuntime on real
+		// shutdown; the process-exit hook (tryRegisterSessionCleanup) drains
+		// the registry when pi actually exits.
 		ctx.disposeRenderSchedulerSubscriptions();
 		ctx.renderScheduler?.dispose();
 		ctx.renderScheduler = undefined;

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

@@ -13,6 +13,7 @@ import type { createRunSnapshotCache } from "../../ui/run-snapshot-cache.ts";
 import { statusIcon, type ToolRenderContext, teamToolRenderer } from "../../ui/tool-renderers/index.ts";
 import type { CrewWidgetState } from "../../ui/widget/index.ts";
 import { updateCrewWidget } from "../../ui/widget/index.ts";
+import { safeAbort } from "../../utils/safe-abort.ts";
 import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
 // Team tool handler — lazy-loaded because team-tool.ts imports many modules
 import type { handleTeamTool as HandleTeamToolFn } from "../team-tool.ts";
@@ -174,7 +175,10 @@ export function registerTeamTool(pi: ExtensionAPI, deps: RegisterTeamToolDeps):
 			const controller = new AbortController();
 			const toolKey = Symbol();
 			deps.foregroundControllers.set(toolKey, controller);
-			const abort = (): void => controller.abort();
+			// safe-abort: pi's tool-call abort can race a completed run whose
+			// spawned children already exited — Node's child_process signal
+			// listener throws AbortError out of abort() and kills the host.
+			const abort = (): void => safeAbort(controller, "team-tool.caller-abort");
 			signal?.addEventListener("abort", abort, { once: true });
 			const stopProgress = startTeamToolProgressBinder(onUpdate as OnUpdate | undefined);
 			try {

package/src/extension/registration/ui.ts

@@ -15,7 +15,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { loadConfig } from "../../config/config.ts";
 import { DEFAULT_UI } from "../../config/defaults.ts";
 import type { LiveRunSidebar as LiveRunSidebarType } from "../../ui/live-run-sidebar.ts";
-import { requestRender, setExtensionWidget, showCustom } from "../../ui/pi-ui-compat.ts";
+import { requestRender, setExtensionWidget, showCustom, toPiWidgetPlacement } from "../../ui/pi-ui-compat.ts";
 import {
 	clearPiCrewPowerbar,
 	registerPiCrewPowerbarSegments,
@@ -76,10 +76,11 @@ export async function installLiveSidebar(ctx: ExtensionContext, runId: string, s
 	state.liveSidebarRunId = runId;
 	state.dashboardOpened = true;
 	const widgetPlacement = uiConfig?.widgetPlacement ?? DEFAULT_UI.widgetPlacement;
-	setExtensionWidget(ctx, "pi-crew", undefined, { placement: widgetPlacement });
-	setExtensionWidget(ctx, "pi-crew-active", undefined, { placement: widgetPlacement });
+	const placement = toPiWidgetPlacement(widgetPlacement);
+	setExtensionWidget(ctx, "pi-crew", undefined, { placement });
+	setExtensionWidget(ctx, "pi-crew-active", undefined, { placement });
 	deps.widgetState.lastVisibility = "hidden";
-	deps.widgetState.lastPlacement = widgetPlacement;
+	deps.widgetState.lastPlacement = placement;
 	deps.widgetState.lastKey = "pi-crew-active";
 	deps.widgetState.model = undefined;
 	const width = Math.min(90, Math.max(40, uiConfig?.dashboardWidth ?? DEFAULT_UI.dashboardWidth));

package/src/extension/team-tool/run-deadline.ts

@@ -1,5 +1,7 @@
 import type { PiTeamsConfig } from "../../config/config.ts";
 import { loadConfig } from "../../config/config.ts";
+import { isSessionSwitchInFlight } from "../../ui/inline-panel/view-session-store.ts";
+import { safeAbort } from "../../utils/safe-abort.ts";
 import type { TeamContext } from "./context.ts";
 
 /**
@@ -66,10 +68,23 @@ export function resolveRunDeadline<T extends object>(
 	// signal fired afterwards, the listener would only call abort() on an
 	// already-aborted controller — a no-op.
 	if (ctx.signal) {
-		if (ctx.signal.aborted) controller.abort();
+		if (ctx.signal.aborted) safeAbort(controller, "run-deadline.caller-preaborted");
 		else {
 			const callerSignal = ctx.signal;
-			const onCallerAbort = () => controller.abort();
+			// The deadline signal is passed down to run executors that may spawn
+			// children with it; aborting after a child exited throws AbortError
+			// from Node's child_process listener — never let that escape a
+			// pi event handler (safe-abort).
+			const onCallerAbort = () => {
+				// Regression: switching sessions (resume/new/fork — including
+				// /crew-view) tears the current turn down via session.abort(),
+				// firing the tool-call abort while the run is still forming. A
+				// foreground run must survive session switches (P0 — it shares
+				// the process), so a teardown abort must NOT cancel it. Only a
+				// genuine caller abort OUTSIDE a session switch propagates.
+				if (isSessionSwitchInFlight()) return;
+				safeAbort(controller, "run-deadline.caller-abort");
+			};
 			callerSignal.addEventListener("abort", onCallerAbort, { once: true });
 			controller.signal.addEventListener("abort", () => callerSignal.removeEventListener("abort", onCallerAbort), { once: true });
 		}
@@ -77,9 +92,11 @@ export function resolveRunDeadline<T extends object>(
 	// Arm the deadline timer (unref'd so it never blocks process exit).
 	// RC-02: expose the timer so callers can clearTimeout on normal completion —
 	// otherwise every run leaves a dangling 1h timer retaining ctx/params in closure.
+	// Same abort-after-exit guard as above: the timer may fire after workers
+	// already exited and their spawn-signal listeners are gone — Node can throw.
 	let timer: NodeJS.Timeout | undefined;
 	if (deadlineMs > 0) {
-		timer = setTimeout(() => controller.abort(), deadlineMs);
+		timer = setTimeout(() => safeAbort(controller, "run-deadline.timer"), deadlineMs);
 		timer.unref?.();
 	}
 	return { signal: controller.signal, deadlineMs, controller, timer };

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

@@ -15,6 +15,7 @@ const _typeCheck: typeof ExecuteTeamRunFn = null as never as typeof ExecuteTeamR
 import { fsFailureLabel } from "../../utils/fs-errno.ts";
 import { errorMessage } from "../../utils/guards.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
+import { safeAbort } from "../../utils/safe-abort.ts";
 import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
 
 let _cachedExecuteTeamRun: typeof ExecuteTeamRunFn | undefined;
@@ -722,12 +723,14 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 			// so cancel-via-abortForegroundRun propagates to executeTeamRun.
 			fgCallbackSignal = signal;
 			if (signal && signal !== fgSignal) {
-				if (signal.aborted) fgDeadline.controller.abort();
+				if (signal.aborted) safeAbort(fgDeadline.controller, "fg-run.caller-preaborted");
 				else {
 					// RC-03: keep the ref so we can removeEventListener on completion (the
 					// {once:true} alone leaks on the success path — the listener stays
 					// attached to the long-lived callback signal if the deadline never fires).
-					fgAbortListener = () => fgDeadline.controller.abort();
+					// safe-abort: the deadline signal may be linked to spawned children;
+					// aborting after they exited throws AbortError from Node's listener.
+					fgAbortListener = () => safeAbort(fgDeadline.controller, "fg-run.caller-abort");
 					signal.addEventListener("abort", fgAbortListener, { once: true });
 				}
 			}
@@ -771,6 +774,27 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		// Wait for the foreground run to complete and return actual results.
 		try {
 			const completed = await waitForRun(updatedManifest.runId, resolvedCtx.cwd, { timeoutMs: fgDeadline.deadlineMs });
+			if (completed.detached) {
+				// The waiter was released so this turn can settle (agent view
+				// switch); the run keeps executing and reports on completion.
+				return result(
+					[
+						`pi-crew run detached to background: ${updatedManifest.runId}`,
+						`Team: ${team.name}`,
+						`Workflow: ${workflow.name}`,
+						`Goal: ${goal}`,
+						"",
+						"The run keeps executing — you will be notified when it finishes.",
+						`Check status with: team status runId=${updatedManifest.runId}`,
+					].join("\n"),
+					{
+						action: "run",
+						status: "ok",
+						runId: updatedManifest.runId,
+						artifactsRoot: updatedManifest.artifactsRoot,
+					},
+				);
+			}
 			return formatRunResult(completed.manifest, {
 				tasks: completed.tasks,
 				metrics: collectRunMetrics(resolvedCtx.cwd, completed.manifest.runId),

package/src/runtime/child-pi/child-pi-constants.ts

@@ -32,6 +32,14 @@ export const MAX_LINE_BUFFER_BYTES = 1024 * 1024; // 1 MB
 /** Maximum characters for assistant text fragments in compacted events. */
 export const MAX_ASSISTANT_TEXT_CHARS = DEFAULT_CHILD_PI.maxAssistantTextChars;
 
+/**
+ * Maximum characters for reasoning (`thinking`) fragments in compacted events,
+ * and the size cap for the thinking parts in the agent view pane / view
+ * session. Reasoning is display-only (never folded into results or artifacts),
+ * so it gets a tighter cap than full assistant text.
+ */
+export const MAX_THINKING_CHARS = 8 * 1024;
+
 /** Maximum characters for tool-result fragments in compacted events. */
 export const MAX_TOOL_RESULT_CHARS = DEFAULT_CHILD_PI.maxToolResultChars;