pi-crew 0.9.28 → 0.9.29

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

@@ -0,0 +1,292 @@
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { requestRenderTarget } from "../../ui/pi-ui-compat.ts";
+import { asCrewTheme, type CrewTheme } from "../../ui/theme-adapter.ts";
+import { truncateToWidth, visibleWidth } from "../../utils/visual.ts";
+import type { CrewVibesConfig } from "./config.ts";
+import type { ProviderUsage } from "./provider-usage.ts";
+import { formatCount, getCapacityUsage, renderCapacity, renderProviderUsage } from "./render.ts";
+
+/**
+ * Custom footer replacement for crew-vibes.
+ *
+ * Why this exists: pi joins ALL `setStatus()` entries onto ONE line and
+ * right-truncates when the line overflows. The provider quota lives at the
+ * tail, so it gets chopped to "W..." whenever the `pi-crew` widget status grows
+ * during sub-agent runs. Five prior attempts (right-align padding, dynamic
+ * padding, separate keys) all failed because an extension using `setStatus`
+ * cannot see the widget's width, other extensions' widths, or pi's real render
+ * width. `setFooter` sidesteps all of that: `render(width)` receives the REAL
+ * width and we own the line layout, so the meters get a dedicated line that is
+ * never truncated by the join.
+ */
+
+/** Live values the footer reads on each render (owned by the extension). */
+export interface CrewVibesFooterSource {
+	getConfig(): CrewVibesConfig;
+	getQuotaUsage(): ProviderUsage | null;
+	getThinkingLevel(): string | undefined;
+}
+
+export interface CrewVibesFooterDeps {
+	tui: unknown;
+	theme: unknown;
+	footerData: unknown;
+	ctx: ExtensionContext;
+	source: CrewVibesFooterSource;
+}
+
+interface FooterData {
+	getGitBranch(): string | null;
+	getExtensionStatuses(): ReadonlyMap<string, string>;
+	getAvailableProviderCount(): number;
+	onBranchChange(cb: () => void): () => void;
+}
+
+interface FooterComponent {
+	render(width: number): string[];
+	invalidate(): void;
+	dispose(): void;
+}
+
+function num(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+/** Mirror pi's footer cwd formatting: collapse the home prefix to `~`. */
+function formatCwdForFooter(cwd: string, home: string | undefined): string {
+	if (!home) return cwd;
+	const resolvedCwd = resolve(cwd);
+	const resolvedHome = resolve(home);
+	const rel = relative(resolvedHome, resolvedCwd);
+	const inside = rel === "" || (rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
+	if (!inside) return cwd;
+	return rel === "" ? "~" : `~${sep}${rel}`;
+}
+
+/** Mirror pi's status sanitizer (collapse control chars + runs of spaces). */
+function sanitizeStatusText(text: string): string {
+	return text
+		.replace(/[\r\n\t]/g, " ")
+		.replace(/ +/g, " ")
+		.trim();
+}
+
+function asFooterData(value: unknown): FooterData | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const record = value as Record<string, unknown>;
+	if (
+		typeof record.getGitBranch !== "function" ||
+		typeof record.getExtensionStatuses !== "function" ||
+		typeof record.getAvailableProviderCount !== "function" ||
+		typeof record.onBranchChange !== "function"
+	) {
+		return undefined;
+	}
+	return value as FooterData;
+}
+
+interface SessionTotals {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	cost: number;
+}
+
+function computeTotals(entries: unknown[]): SessionTotals {
+	const totals: SessionTotals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+	for (const entry of entries) {
+		const rec = entry as {
+			type?: string;
+			message?: { role?: string; usage?: Record<string, unknown> & { cost?: { total?: unknown } } };
+		};
+		if (rec?.type !== "message" || rec.message?.role !== "assistant") continue;
+		const usage = rec.message.usage;
+		if (!usage) continue;
+		totals.input += num(usage.input);
+		totals.output += num(usage.output);
+		totals.cacheRead += num(usage.cacheRead);
+		totals.cacheWrite += num(usage.cacheWrite);
+		totals.cost += num(usage.cost?.total);
+	}
+	return totals;
+}
+
+class CrewVibesFooter implements FooterComponent {
+	private readonly theme: CrewTheme;
+	private readonly footerData: FooterData | undefined;
+	private readonly ctx: ExtensionContext;
+	private readonly source: CrewVibesFooterSource;
+	private readonly tui: unknown;
+	private readonly unsubscribeBranch: () => void;
+
+	constructor(deps: CrewVibesFooterDeps) {
+		this.theme = asCrewTheme(deps.theme);
+		this.footerData = asFooterData(deps.footerData);
+		this.ctx = deps.ctx;
+		this.source = deps.source;
+		this.tui = deps.tui;
+		this.unsubscribeBranch = this.footerData ? this.footerData.onBranchChange(() => requestRenderTarget(this.tui)) : () => {};
+	}
+
+	invalidate(): void {}
+
+	dispose(): void {
+		this.unsubscribeBranch();
+	}
+
+	private buildPwdLine(width: number): string {
+		const sm = this.ctx.sessionManager;
+		let pwd = formatCwdForFooter(sm.getCwd(), process.env.HOME || process.env.USERPROFILE);
+		const branch = this.footerData?.getGitBranch();
+		if (branch) pwd = `${pwd} (${branch})`;
+		const sessionName = sm.getSessionName?.();
+		if (sessionName) pwd = `${pwd} • ${sessionName}`;
+		return truncateToWidth(this.theme.fg("dim", pwd), width, this.theme.fg("dim", "..."));
+	}
+
+	private buildStatsLine(width: number): string {
+		const theme = this.theme;
+		const model = this.ctx.model as { id?: string; provider?: string; reasoning?: unknown; contextWindow?: number } | undefined;
+		const totals = computeTotals(this.ctx.sessionManager.getEntries() as unknown[]);
+		const contextUsage = this.ctx.getContextUsage?.();
+		const contextWindow = contextUsage?.contextWindow ?? model?.contextWindow ?? 0;
+		const percentValue = contextUsage?.percent ?? 0;
+		const percentKnown = contextUsage?.percent !== null && contextUsage?.percent !== undefined;
+
+		const statsParts: string[] = [];
+		if (totals.input) statsParts.push(`↑${formatCount(totals.input)}`);
+		if (totals.output) statsParts.push(`↓${formatCount(totals.output)}`);
+		if (totals.cacheRead) statsParts.push(`R${formatCount(totals.cacheRead)}`);
+		if (totals.cacheWrite) statsParts.push(`W${formatCount(totals.cacheWrite)}`);
+
+		const usingSubscription = !!(model && this.ctx.modelRegistry?.isUsingOAuth?.(this.ctx.model as never));
+		if (totals.cost || usingSubscription) {
+			statsParts.push(`$${totals.cost.toFixed(3)}${usingSubscription ? " (sub)" : ""}`);
+		}
+
+		// User choice: always show the "(auto)" compaction indicator (pi's default);
+		// the toggle state is not observable by extensions.
+		const autoIndicator = " (auto)";
+		const contextDisplay = percentKnown
+			? `${percentValue.toFixed(1)}%/${formatCount(contextWindow)}${autoIndicator}`
+			: `?/${formatCount(contextWindow)}${autoIndicator}`;
+		const contextColored =
+			percentValue > 90
+				? theme.fg("error", contextDisplay)
+				: percentValue > 70
+					? theme.fg("warning", contextDisplay)
+					: contextDisplay;
+		statsParts.push(contextColored);
+
+		let statsLeft = statsParts.join(" ");
+		let statsLeftWidth = visibleWidth(statsLeft);
+		if (statsLeftWidth > width) {
+			statsLeft = truncateToWidth(statsLeft, width, "...");
+			statsLeftWidth = visibleWidth(statsLeft);
+		}
+
+		const minPadding = 2;
+		const modelName = model?.id || "no-model";
+		let rightSideWithoutProvider = modelName;
+		if (model?.reasoning) {
+			// Prefer the authoritative thinking level from session state
+			// (buildSessionContext), which reflects the current effective level
+			// including the model default — not just the last thinking_level_select
+			// event (which only fires on manual switch).
+			let level = this.source.getThinkingLevel();
+			try {
+				const ctx = this.ctx.sessionManager as { buildSessionContext?: () => { thinkingLevel?: string } };
+				if (typeof ctx.buildSessionContext === "function") {
+					const resolved = ctx.buildSessionContext()?.thinkingLevel;
+					if (resolved) level = resolved;
+				}
+			} catch {
+				// buildSessionContext may throw on empty/early sessions — fall back.
+			}
+			const finalLevel = level || "off";
+			rightSideWithoutProvider = finalLevel === "off" ? `${modelName} • thinking off` : `${modelName} • ${finalLevel}`;
+		}
+
+		let rightSide = rightSideWithoutProvider;
+		const providerCount = this.footerData?.getAvailableProviderCount() ?? 0;
+		if (providerCount > 1 && model?.provider) {
+			rightSide = `(${model.provider}) ${rightSideWithoutProvider}`;
+			if (statsLeftWidth + minPadding + visibleWidth(rightSide) > width) rightSide = rightSideWithoutProvider;
+		}
+
+		const rightSideWidth = visibleWidth(rightSide);
+		let statsLine: string;
+		if (statsLeftWidth + minPadding + rightSideWidth <= width) {
+			statsLine = statsLeft + " ".repeat(width - statsLeftWidth - rightSideWidth) + rightSide;
+		} else {
+			const availableForRight = width - statsLeftWidth - minPadding;
+			if (availableForRight > 0) {
+				const truncatedRight = truncateToWidth(rightSide, availableForRight, "");
+				const padding = " ".repeat(Math.max(0, width - statsLeftWidth - visibleWidth(truncatedRight)));
+				statsLine = statsLeft + padding + truncatedRight;
+			} else {
+				statsLine = statsLeft;
+			}
+		}
+
+		const dimStatsLeft = theme.fg("dim", statsLeft);
+		const dimRemainder = theme.fg("dim", statsLine.slice(statsLeft.length));
+		return dimStatsLeft + dimRemainder;
+	}
+
+	private buildStatusLine(width: number): string | undefined {
+		if (!this.footerData) return undefined;
+		const statuses = this.footerData.getExtensionStatuses();
+		if (statuses.size === 0) return undefined;
+		const joined = Array.from(statuses.entries())
+			.sort(([a], [b]) => a.localeCompare(b))
+			.map(([, text]) => sanitizeStatusText(text))
+			.join(" ");
+		if (!joined) return undefined;
+		return truncateToWidth(joined, width, this.theme.fg("dim", "..."));
+	}
+
+	private rightAlign(text: string, width: number): string {
+		const w = visibleWidth(text);
+		if (w >= width) return truncateToWidth(text, width, "…");
+		return " ".repeat(width - w) + text;
+	}
+
+	/** Capacity + provider quota. Uses the REAL render width, so the quota is
+	 * never chopped. When both do not fit on one line, wrap to two lines
+	 * (capacity above, quota right-aligned below) per the chosen behavior. */
+	private buildMeterLines(width: number): string[] {
+		const config = this.source.getConfig();
+		if (!config.enabled) return [];
+		const capText = config.capacity.enabled ? renderCapacity(this.theme, config.capacity, getCapacityUsage(this.ctx)) : undefined;
+		const quotaText = config.capacity.providerUsage ? renderProviderUsage(this.theme, this.source.getQuotaUsage()) : undefined;
+
+		if (!capText && !quotaText) return [];
+		if (capText && !quotaText) return [truncateToWidth(capText, width, "…")];
+		if (!capText && quotaText) return [this.rightAlign(quotaText, width)];
+
+		const cap = capText as string;
+		const quota = quotaText as string;
+		const capWidth = visibleWidth(cap);
+		const quotaWidth = visibleWidth(quota);
+		if (capWidth + 1 + quotaWidth <= width) {
+			const pad = Math.max(1, width - capWidth - quotaWidth);
+			return [cap + " ".repeat(pad) + quota];
+		}
+		return [truncateToWidth(cap, width, "…"), this.rightAlign(quota, 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));
+		return lines;
+	}
+}
+
+export function createCrewVibesFooter(deps: CrewVibesFooterDeps): FooterComponent {
+	return new CrewVibesFooter(deps);
+}

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

@@ -1,19 +1,17 @@
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { requestRender, setFooter } from "../../ui/pi-ui-compat.ts";
 import { type CrewVibesConfig, loadConfig, PROVIDER_STATUS_ID, saveConfig } from "./config.ts";
-import { fetchProviderUsage, clearProviderUsageCache, providerSupportsQuota } from "./provider-usage.ts";
 import { intervalForSpeed } from "./figures.ts";
+import { type CrewVibesFooterSource, createCrewVibesFooter } from "./footer.ts";
+import { clearProviderUsageCache, fetchProviderUsage, type ProviderUsage } from "./provider-usage.ts";
 import {
 	asCrewTheme,
 	clearVibesStatus,
 	crewIndicatorFrames,
 	formatSpeed,
 	getCapacityUsage,
-	renderCapacity,
-	renderProviderUsage,
 	renderSpeedFooter,
 	renderWorkingMessage,
-	setCapacityStatus,
-	setProviderStatus,
 	setSpeedStatus,
 } from "./render.ts";
 import { SpeedAnimator, SpeedTracker } from "./speed.ts";
@@ -49,37 +47,41 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 	let footerTimer: ReturnType<typeof setInterval> | undefined;
 	let capacityTimer: ReturnType<typeof setInterval> | undefined;
 	let providerTimer: ReturnType<typeof setInterval> | undefined;
-	let lastProviderText: string | undefined;
+	let lastProviderUsage: ProviderUsage | null = null;
 	let currentProvider: string | undefined;
+	let currentThinkingLevel: string | undefined;
 
-	/** Strip ANSI codes to measure visible width. */
-	function visibleLen(text: string): number {
-		return text.replace(/\x1b\[[0-9;]*m/g, "").length;
+	function themeOf(ctx: ExtensionContext) {
+		return asCrewTheme(ctx.hasUI ? ctx.ui.theme : undefined);
 	}
 
-	/** Left-align `left`, right-align `right` on the same line.
-	 * Uses non-breaking space (U+00A0) for padding because pi's
-	 * sanitizeStatusText collapses regular spaces: / +/g → " ". */
-	function spreadLine(left: string, right: string): string {
-		const cols = process.stdout.columns || 120;
-		const padding = Math.max(2, cols - visibleLen(left) - visibleLen(right));
-		return left + "\u00A0".repeat(padding) + right;
-	}
+	const footerSource: CrewVibesFooterSource = {
+		getConfig: () => config,
+		getQuotaUsage: () => lastProviderUsage,
+		getThinkingLevel: () => currentThinkingLevel,
+	};
 
-	function themeOf(ctx: ExtensionContext) {
-		return asCrewTheme(ctx.hasUI ? ctx.ui.theme : undefined);
+	/** Whether the custom footer has crew-vibes meters to add on top of pi's stats. */
+	function metersActive(): boolean {
+		return config.enabled && (config.capacity.enabled || config.capacity.providerUsage);
 	}
 
-	function publishCapacity(ctx: ExtensionContext): void {
+	/** Install our custom footer, or restore pi's built-in footer when idle.
+	 * Unlike setStatus (joined + right-truncated), the footer's render(width)
+	 * gets the real width and owns line layout, so the quota is never chopped. */
+	function installFooter(ctx: ExtensionContext): void {
 		if (!ctx?.hasUI) return;
-		if (!config.enabled || !config.capacity.enabled) {
-			setCapacityStatus(ctx, config, undefined);
+		if (!metersActive()) {
+			setFooter(ctx, undefined);
 			return;
 		}
-		const capText = renderCapacity(themeOf(ctx), config.capacity, getCapacityUsage(ctx));
-		// Combine capacity + provider on one line with spacing
-		const combined = lastProviderText ? spreadLine(capText, lastProviderText) : capText;
-		setCapacityStatus(ctx, config, combined);
+		setFooter(ctx, (tui, theme, footerData) => createCrewVibesFooter({ tui, theme, footerData, ctx, source: footerSource }));
+		requestRender(ctx);
+	}
+
+	/** Trigger a footer repaint; the footer recomputes capacity/quota on render. */
+	function refreshFooter(ctx: ExtensionContext): void {
+		if (ctx?.hasUI) requestRender(ctx);
 	}
 
 	function publishSpeedFooter(ctx: ExtensionContext, speed = footerAnimator.value()): void {
@@ -164,34 +166,36 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 	function startCapacityTimer(ctx: ExtensionContext): void {
 		if (capacityTimer) return;
 		const interval = Math.max(250, config.capacity.refreshIntervalMs);
-		capacityTimer = setInterval(() => publishCapacity(ctx), interval);
+		capacityTimer = setInterval(() => refreshFooter(ctx), interval);
 		capacityTimer.unref?.();
 	}
 
+	/** Fetch provider usage for currentProvider and refresh the footer.
+	 *  Called on start, on each timer tick, and immediately when the
+	 *  provider changes (model_select) so the quota reflects the new
+	 *  provider without waiting for the next 5-minute tick. */
+	async function fetchProviderAndRefresh(ctx: ExtensionContext): Promise<void> {
+		if (!config.enabled || !config.capacity.providerUsage) {
+			lastProviderUsage = null;
+			refreshFooter(ctx);
+			return;
+		}
+		try {
+			lastProviderUsage = await fetchProviderUsage(config.capacity.providerRefreshMs, currentProvider);
+		} catch {
+			// Never crash on provider fetch failure
+			lastProviderUsage = null;
+		}
+		refreshFooter(ctx);
+	}
+
 	function startProviderTimer(ctx: ExtensionContext): void {
 		if (providerTimer) return;
 		if (!config.capacity.providerUsage) return;
 		const interval = Math.max(10000, config.capacity.providerRefreshMs);
 
-		async function tick(): Promise<void> {
-			if (!config.enabled || !config.capacity.providerUsage) {
-				stopProviderTimer();
-				return;
-			}
-			try {
-				const usage = await fetchProviderUsage(config.capacity.providerRefreshMs, currentProvider);
-				lastProviderText = renderProviderUsage(themeOf(ctx), usage);
-				// Re-render combined capacity + provider line
-				publishCapacity(ctx);
-			} catch {
-				// Never crash on provider fetch failure
-				lastProviderText = undefined;
-				publishCapacity(ctx);
-			}
-		}
-
-		tick(); // Fetch immediately on start
-		providerTimer = setInterval(tick, interval);
+		fetchProviderAndRefresh(ctx); // Fetch immediately on start
+		providerTimer = setInterval(() => fetchProviderAndRefresh(ctx), interval);
 		providerTimer.unref?.();
 	}
 
@@ -209,11 +213,13 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 			stopFooterTimer();
 			stopCapacityTimer();
 			stopProviderTimer();
+			setFooter(ctx, undefined);
 			clearVibesStatus(ctx);
 			return;
 		}
-		publishCapacity(ctx);
+		installFooter(ctx);
 		publishSpeedFooter(ctx);
+		startCapacityTimer(ctx);
 		if (config.capacity.providerUsage) startProviderTimer(ctx);
 	}
 
@@ -230,11 +236,13 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 		clearProviderUsageCache();
 		// Initialize provider from current model — model_select only fires on manual switch
 		currentProvider = (ctx.model as { provider?: string } | undefined)?.provider;
+		currentThinkingLevel = undefined;
 		if (!config.enabled) {
+			setFooter(ctx, undefined);
 			clearVibesStatus(ctx);
 			return;
 		}
-		publishCapacity(ctx);
+		installFooter(ctx);
 		publishSpeedFooter(ctx);
 		startCapacityTimer(ctx);
 		startProviderTimer(ctx);
@@ -285,7 +293,7 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 
 	pi.on("message_end", (event, ctx) => {
 		if (!isAssistantMessage(event.message)) return;
-		publishCapacity(ctx);
+		refreshFooter(ctx);
 		if (!config.enabled || !config.speed.enabled || !speedTracker.isStreaming) return;
 
 		const completed = speedTracker.finishMessage(assistantUsageOutput(event.message) ?? 0, assistantStopReason(event.message));
@@ -314,16 +322,23 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 	pi.on("model_select", (event, ctx) => {
 		currentProvider = (event as { model?: { provider?: string } }).model?.provider;
 		clearProviderUsageCache();
-		publishCapacity(ctx);
+		// Fetch immediately so the quota reflects the new provider without
+		// waiting for the next 5-minute timer tick.
+		fetchProviderAndRefresh(ctx);
+	});
+	pi.on("thinking_level_select", (event, ctx) => {
+		currentThinkingLevel = (event as { level?: unknown }).level as string | undefined;
+		refreshFooter(ctx);
 	});
-	pi.on("session_compact", (_event, ctx) => publishCapacity(ctx));
-	pi.on("session_tree", (_event, ctx) => publishCapacity(ctx));
+	pi.on("session_compact", (_event, ctx) => refreshFooter(ctx));
+	pi.on("session_tree", (_event, ctx) => refreshFooter(ctx));
 
 	pi.on("session_shutdown", (_event, ctx) => {
 		stopLiveTimer();
 		stopFooterTimer();
 		stopCapacityTimer();
 		stopProviderTimer();
+		setFooter(ctx, undefined);
 		clearVibesStatus(ctx);
 	});
 

package/src/prompt/prompt-runtime.ts

@@ -1,5 +1,5 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import * as fs from "node:fs";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 export const PI_TEAMS_INHERIT_PROJECT_CONTEXT_ENV = "PI_TEAMS_INHERIT_PROJECT_CONTEXT";
 export const PI_TEAMS_INHERIT_SKILLS_ENV = "PI_TEAMS_INHERIT_SKILLS";

package/src/runtime/child-pi.ts

@@ -80,6 +80,22 @@ function clearHardKillTimer(pid: number | undefined): void {
 	childHardKillTimers.delete(pid);
 }
 
+/**
+ * B6: spawn taskkill and attach an 'error' listener. spawn() emits ENOENT/EACCES
+ * asynchronously via the 'error' event (not as a throw), so an unlistened spawn
+ * can crash the parent as an uncaught exception. taskkill is a standard Windows
+ * binary so this is defensive, but the listener keeps failures bounded.
+ */
+function spawnTaskkillSafe(pid: number): void {
+	const taskkillChild = spawn("taskkill", ["/pid", String(pid), "/t", "/f"], {
+		stdio: "ignore",
+		windowsHide: true,
+	});
+	taskkillChild.on("error", (err) => {
+		logInternalError("child-pi.taskkill-spawn-error", err instanceof Error ? err : new Error(String(err)), `pid=${pid}`);
+	});
+}
+
 export function killProcessPid(pid: number): void {
 	if (!Number.isInteger(pid) || pid <= 0) return;
 	try {
@@ -87,10 +103,7 @@ export function killProcessPid(pid: number): void {
 			// 3.8: Windows path uses taskkill /T /F (force kill the entire tree).
 			// taskkill itself can silently fail (PID gone, permission denied, etc.)
 			// so verify after 2s and log a warning if the process is still alive.
-			spawn("taskkill", ["/pid", String(pid), "/t", "/f"], {
-				stdio: "ignore",
-				windowsHide: true,
-			});
+			spawnTaskkillSafe(pid);
 			const verifyTimer = setTimeout(() => {
 				try {
 					process.kill(pid, 0); // throws ESRCH when dead
@@ -101,10 +114,7 @@ export function killProcessPid(pid: number): void {
 						`pid=${pid}`,
 					);
 					try {
-						spawn("taskkill", ["/pid", String(pid), "/t", "/f"], {
-							stdio: "ignore",
-							windowsHide: true,
-						});
+						spawnTaskkillSafe(pid);
 					} catch {
 						/* best-effort */
 					}
@@ -894,6 +904,20 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 	});
 	// Pass steering file path to child for real-time steer injection
 	if (input.steeringFile) built.env.PI_CREW_STEERING_FILE = input.steeringFile;
+	// B5: if the parent already aborted before we spawn, do not start the child
+	// at all. Spawning a doomed process wastes resources, and the abort listener
+	// registered below will not re-fire for an already-aborted signal (so the
+	// child would only be killed later by the response-timeout path). Return a
+	// cancelled-style result immediately.
+	if (input.signal?.aborted) {
+		return {
+			exitCode: null,
+			stdout: "",
+			stderr: "",
+			error: "Aborted before spawn (parent AbortSignal already aborted)",
+			aborted: true,
+		};
+	}
 	const spawnSpec = getPiSpawnCommand(built.args);
 	try {
 		return await new Promise<ChildPiRunResult>((resolve) => {
@@ -1129,45 +1153,30 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 								turnCount += 1;
 								if (maxTurns !== undefined && !softLimitReached && turnCount >= maxTurns) {
 									softLimitReached = true;
-									// Inject steer via stdin to tell child to wrap up.
-									// Steer injection is ADVISORY: it asks the worker to wrap up. The real
-									// enforcement is the hard-abort at maxTurns + graceTurns (below). So a
-									// failed/non-writable stdin must NOT kill the worker — that destroys a
-									// valid answer already in stdout (Phase-0 root cause of the
-									// disableTools/maxTurns:1 exit-null bug). Just log + let the hard-abort
-									// path handle a genuinely runaway worker.
-									if (child.stdin?.writable) {
-										const steerPayload =
-											JSON.stringify({
-												type: "steer",
-												message:
-													"You have reached your turn limit. Wrap up immediately — provide your final answer now.",
-											}) + "\n";
-										const writeSucceeded = child.stdin.write(steerPayload);
-										if (!writeSucceeded) {
-											// Normal Node backpressure: the payload is buffered and will flush on
-											// 'drain'. NOT a failure — do NOT kill the worker. The steer is
-											// advisory; if the worker ignores it and runs past maxTurns +
-											// graceTurns, the hard-abort below terminates it.
+									// C8: deliver the "wrap up" advisory by appending to the steering JSONL
+									// file the child polls (PI_CREW_STEERING_FILE). The child is spawned with
+									// stdio:["ignore",...], so child.stdin is null and the old stdin branch was
+									// dead code that only spammed logs on every soft-limit hit. Advisory only —
+									// the hard-abort below at maxTurns + graceTurns is the real enforcement, so
+									// a failed write must NOT kill the worker.
+									if (input.steeringFile) {
+										try {
+											fs.appendFileSync(
+												input.steeringFile,
+												JSON.stringify({
+													type: "steer",
+													message:
+														"You have reached your turn limit. Wrap up immediately — provide your final answer now.",
+												}) + "\n",
+												"utf-8",
+											);
+										} catch (err) {
 											logInternalError(
-												"child-pi.steer-backpressure",
-												new Error(
-													"stdin write returned false (normal backpressure); steer buffered, worker NOT killed",
-												),
+												"child-pi.steer-write-failed",
+												err instanceof Error ? err : new Error(String(err)),
 												`pid=${child.pid}`,
 											);
 										}
-									} else {
-										// stdin closed (worker already finished) or otherwise unwritable.
-										// Also advisory — the worker is done or nearly done; let it exit
-										// naturally. Hard-abort remains the safety net for true runaways.
-										logInternalError(
-											"child-pi.steer-not-writable",
-											new Error(
-												"stdin not writable when attempting steer injection (worker may be done); worker NOT killed",
-											),
-											`pid=${child.pid}`,
-										);
 									}
 								} else if (maxTurns !== undefined && softLimitReached && turnCount >= maxTurns + (graceTurns ?? 5)) {
 									// Hard abort — terminate after grace turns

package/src/runtime/cross-extension-rpc.ts

@@ -1,5 +1,5 @@
 import * as crypto from "node:crypto";
-import { isHmacEnabled, extractSignaturePayload, verifyRpcSignature } from "../extension/rpc-hmac.ts";
+import { extractSignaturePayload, isHmacEnabled, verifyRpcSignature } from "../extension/rpc-hmac.ts";
 
 export interface EventBus {
 	on(event: string, handler: (data: unknown) => void): () => void;