pi-mono-all 1.0.0

package/node_modules/pi-mono-btw/CHANGELOG.md

@@ -0,0 +1,180 @@
+# pi-mono-btw
+
+## 1.7.2
+
+### Patch Changes
+
+### Fixed: ask-user-question
+
+- Remove unused `StringEnum` import from `@mariozechner/pi-ai`.
+
+
+## 1.7.1
+
+### Patch Changes
+
+### Fixed: team-mode
+
+- Widget no longer mislabels blocked or approval-pending teams as "running smoothly" — blockers and pending approvals are now detected via team summaries.
+- Preserve in-flight work on re-emitted `session_start` events instead of tearing the runtime down and SIGTERM-ing live teammates.
+- Auto-relaunch leaders for `running` teams after a session reset; surface failures as both a team signal and a UI notification.
+- `createTeam` now defaults `repoRoots` to `[process.cwd()]` when the caller passes an empty array.
+- Archive `process.json` into `history/` before a new task reuses the same role slot, so the prior task's final state is no longer silently clobbered.
+
+### Enhanced: team-mode
+
+- Durable intent queue for subprocess handoff: `team_spawn_teammate` calls made from a teammate subprocess are written to disk and executed by the main session's `LeaderRuntime` instead of spawning orphaned grand-children.
+- New tool `team_task_create_batch` lets the leader emit the full initial task DAG in one call, removing per-task LLM round-trips during bootstrap.
+- `team_create` / `launchLeader` accept an `awaitBootstrap` option so the user sees the task graph before the tool returns; leader launch retries up to 3 times on transient failures.
+- Persist per-turn debug artifacts (prompt, invocation, stderr, raw event stream) for both leader and teammate subprocesses, exposed via `TeammateSummary.debugArtifacts`.
+- Track `exitCode`, `exitSignal`, `terminationReason`, `stderrTail`, `toolExecutions`, `model` and `modelProvider` on every `TeammateProcess` record.
+- Provider detection now consults pi's `settings.json` and `auth.json` in addition to env vars; default model IDs aligned with the provider/model scheme.
+- `collectPiOutput` supports `AbortSignal` cancellation.
+
+### Tests
+
+- New `intent-queue` and `model-config` suites; expanded coverage across `leader-runtime`, `team-manager`, `team-query-tool` and `formatters`.
+
+
+## 1.7.0
+
+### Minor Changes
+
+### Enhanced: status-line
+
+- Improved progress rendering and colors in expert mode
+
+### Enhanced: team-mode
+
+- **LLM-driven leader** — replaced the hardcoded `research → synthesis → implementation → verification` state machine with a pi subprocess coordinator that authors the task graph via tool calls
+- **New tool `team_task_create`** so the leader can author tasks at runtime
+- **New tool `team_handoff`** for explicit teammate → teammate context handoffs (replaces regex-scraping of `Handoffs:` output sections)
+- **File-based teammate specs** — drop `.claude/teammates/<role>.md` frontmatter files (`name`, `description`, `needsWorktree`, `hasMemory`, `modelTier`) to extend or override the seven built-in roles
+- **Event-driven leader wakes** — mailbox messages addressed to the leader (or broadcast) trigger a debounced (~200ms) cycle instead of waiting for the 20s polling tick
+- **Templates accept any string** — `fullstack` / `research` / `refactor` remain as built-ins, but unknown template keys are accepted and no-op gracefully
+- **Provider config per team** — per-team model overrides via `/team models`
+- Reduced leader overhead and parent-session token churn
+- `spawnTeammate` now always appends the full runtime-built context (signals, mailbox, dependencies, team memory) so teammates get the richer snapshot even when the caller's `context` argument is brief
+
+### Breaking changes: team-mode
+
+- Removed `LeaderPhase` enum and `currentPhase` field from `TeamRecord` / `TeamSummary`
+- Removed `parseExplicitHandoffs` export and the legacy `Handoffs:` output parser — peer handoffs must go through the `team_handoff` tool
+- Removed the deterministic auto-spawn loop (`ensureBootstrapTasks`) — all task authoring and teammate spawning is now the LLM leader's responsibility
+- Removed `StringEnum` gate on `team_create`'s `template` parameter (now plain string)
+
+### Fixed: review
+
+- Annotate diff lines so the model picks correct line numbers
+- Fix slice chunk around lines for comments in the reviewer TUI
+
+### Documentation
+
+- Updated root README and sentinel extension README
+- Documented the new file-based teammate spec format and event-driven leader wake in the team-mode README
+
+## 1.6.0
+
+### Minor Changes
+
+### New Extension: sentinel
+
+Replaced the `grep` extension with a new security-focused `sentinel` extension for monitoring and guarding sensitive operations.
+
+### Enhanced: team-mode
+
+- Added comprehensive test suite with integration tests
+- New mock helpers for subprocess testing
+- Improved signal manager with better error handling
+- Leader runtime refactoring for stability
+- Team query tool with dedicated tests
+
+### Enhanced: status-line
+
+- Added basic and expert mode displays
+- Improved index.ts with better state management
+
+### Enhanced: clear
+
+- Updated keyboard shortcut to `Ctrl+Shift+L`
+- Better busy-state handling for shortcuts
+- Added warning/cancel handling and error notifications
+
+### Enhanced: context-guard
+
+- Improved read deduplication across sessions
+- Added `context-guard:file-modified` event for cache eviction
+
+### Documentation
+
+- Added dedicated README for `clear` extension
+- Added dedicated README for `context-guard` extension
+- Updated main README with improved extension descriptions
+
+## 1.5.0
+
+### Minor Changes
+
+- ### `multi-edit` — diverge from upstream fork
+
+  The extension was originally derived from [mitsuhiko/agent-stuff](https://github.com/mitsuhiko/agent-stuff)'s `pi-extensions/multi-edit.ts`. This release rewrites the largest unmodified subsystems so the implementation is structurally distinct from upstream while keeping the public contract intact.
+
+  - **Modularized layout** — the 953-line `index.ts` is split into purpose-scoped modules: `types.ts`, `workspace.ts`, `classic.ts`, `patch.ts`, `diff.ts`, and a slim `index.ts` (~180 lines of registration + dispatch wiring).
+  - **New patch engine** — `patch.ts` is now a recursive-descent parser over a `LineCursor` class with `indexOf`-based hunk anchoring. Hunks are stored as `{ oldBlock, newBlock }` raw strings (previously `{ oldLines[], newLines[] }` arrays), letting the applier splice content directly instead of reconstructing line arrays per apply.
+  - **Two-pass diff renderer** — `diff.ts` now walks `diffLines` parts into a typed `Entry[]` stream and makes all gutter / context-collapse decisions in a second pass, replacing the prior single-loop state-flag design.
+  - **Polished classic edits** — extracted `groupEditsByPath`, `sortGroupByPosition`, `applyGroupToContent`, and `rollbackSnapshots` helpers; formalized the quote-fallback as an ordered `MATCH_PASSES` array so new normalizers (dashes, NBSP, etc.) can be added by appending one entry.
+  - **First contract test suite** — 34 tests under `__tests__/` cover classic edits (positional reordering, redundant-pair skip, quote fallback, atomic rollback, read-only preflight), patch operations (Add/Delete/Update round-trips, move-rejection, multi-op batches), and diff rendering (line-number gutter, context collapse, add/remove-only cases). Runs via `npm test` (`tsx --test`).
+  - **Dropped Codex apply_patch edge cases** (documented in `README.md` → "Codex apply_patch compatibility"): `*** End of File` sentinel hunks, 4-pass fuzzy `seekSequence` matching, implicit first hunk without `@@`, whitespace-tolerant anchoring. Common paths (Add/Delete/Update-single-chunk, Update with multiple hunks, Add+Update+Delete batches) are fully tested and preserved.
+  - **README attribution** — new "Origins" section crediting `mitsuhiko/agent-stuff` as the original source.
+
+## 1.4.0
+
+### Minor Changes
+
+- Add teammate progress heartbeats and widget refresh improvements to team mode.
+
+## 1.3.0
+
+## 1.2.0
+
+### Minor Changes
+
+- ### `multi-edit` — robustness improvements
+
+  - **No-op write guard**: skip file write and `context-guard:file-modified` event when new content is identical to what was last read — prevents unnecessary watcher churn
+  - **Early write-access check**: virtual workspace `checkWriteAccess` now validates real-filesystem permissions during the preflight pass so read-only files fail fast before any real file is touched
+  - **Curly-quote normalization**: new `findActualString` helper falls back to normalized quote matching (`"` / `'` ↔ `"` / `'`) when exact `oldText` search fails — the most common class of preflight mismatch
+  - **Atomic batch rollback**: `applyClassicEdits` gains a `rollbackOnError` option that restores all successfully written files when a later edit in the same batch fails
+
+  ### `ask-user-question` — UX fixes
+
+  - **Reliable text capture on submit**: answer is read directly from the editor before it clears itself, fixing a race where the stored value was always empty
+  - **Unified advance logic**: `advanceTab()` and `saveOtherModeText()` helpers replace scattered single-question fast-paths — behaviour is now consistent regardless of form length
+  - **Auto-advance on Enter / Tab**: pressing Enter or Tab in any question (text, radio with "Other", checkbox with "Other") advances to the next tab without requiring a separate click
+
+  ### `team-mode` — stability fixes
+
+  - **Infinite retry loop eliminated**: subprocess guard (`PI_TEAM_SUBPROCESS=1`) prevents spawned pi subprocesses from launching a ghost `LeaderRuntime` that immediately marks in-progress tasks as stalled
+  - **Stall detection grace period**: tasks updated within the last 2 × `LEADER_POLL_MS` (10 s) are skipped by `detectStalledTasks` — eliminates false positives on the spawning cycle
+  - **Circuit breaker**: tasks that stall more than `MAX_TASK_RETRIES` (3) times are permanently cancelled with a clear error signal instead of being silently re-queued
+  - **Concurrent cycle guard**: `runLeaderCycle` returns early if a cycle is already in-flight for the same team, preventing overlapping read-modify-write from the poll interval and completion handlers
+  - **Widget cleanup**: cancelled and completed teams are no longer shown in the team widget — only `initializing | running | paused | failed` states are displayed
+  - **Shorter auto-generated names**: `objectiveToName` now splits on non-alphanumeric characters (handles path separators), filters stopwords and extreme-length tokens, and hard-caps at 32 characters
+
+## 1.1.1
+
+### Patch Changes
+
+- chore: update all packages for consistency and include team-mode fixes
+
+## 1.1.0
+
+## 1.0.0
+
+### Major Changes
+
+- 199c367: First version of the extensions to upload to GitHub
+
+### Patch Changes
+
+- Bump all packages to 0.1.1

package/node_modules/pi-mono-btw/README.md

@@ -0,0 +1,24 @@
+# btw extension
+
+This extension adds Claude Code-style ` /btw ` behavior to pi.
+
+## Behavior
+
+- intercepts `/btw <question>` through the input pipeline instead of a normal extension command
+- starts a separate model request immediately
+- does not queue the question into the main agent loop
+- does not interrupt the current task
+- renders answers in a passive widget below the editor while pi keeps working
+- stores hidden history as custom session entries (`btw-history`)
+
+## Why it is implemented this way
+
+In pi, normal extension commands are checked before input expansion and are not the same as prompt templates or skills. To make `/btw` work while pi is already busy, this extension handles raw input that starts with `/btw` and launches its own background completion.
+
+## Extra shortcut
+
+- `Ctrl+Shift+B` asks the current editor text as a side question
+
+## Files
+
+- `index.ts` — extension entry point

package/node_modules/pi-mono-btw/index.ts

@@ -0,0 +1,499 @@
+import { complete, type UserMessage } from "@mariozechner/pi-ai";
+import type { ExtensionAPI, ExtensionContext, Theme } from "@mariozechner/pi-coding-agent";
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui";
+
+const BTW_ENTRY_TYPE = "btw-history";
+const BTW_WIDGET_ID = "btw-widget";
+const COMPLETED_ITEM_TTL_MS = 90_000;
+const MAX_TRANSCRIPT_CHARS = 14_000;
+const MAX_TOOL_RESULT_CHARS = 800;
+const MAX_RENDER_ITEMS = 2;
+const MAX_RENDERED_ANSWER_LINES = 6;
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
+
+const SIDE_QUESTION_SYSTEM_PROMPT = [
+	"You are answering a quick side question while the user's main pi session continues working.",
+	"Use the provided session transcript only as background context.",
+	"Answer directly and concisely.",
+	"Prefer compact bullets or short paragraphs.",
+	"If the transcript is insufficient, say that briefly instead of guessing.",
+].join("\n");
+
+type TextBlock = { type?: string; text?: string };
+type ToolCallBlock = { type?: string; name?: string; arguments?: Record<string, unknown> };
+
+type SessionEntryLike = {
+	type: string;
+	message?: {
+		role?: string;
+		content?: unknown;
+		toolName?: string;
+	};
+};
+
+type BtwRecord = {
+	question: string;
+	answer?: string;
+	error?: string;
+	askedAt: string;
+	answeredAt: string;
+	model: string;
+	sessionFile?: string;
+};
+
+type BtwItem = {
+	id: string;
+	question: string;
+	state: "loading" | "answer" | "error";
+	askedAt: string;
+	answeredAt?: string;
+	answer?: string;
+	error?: string;
+	model: string;
+	expiresAt?: number;
+};
+
+type BtwRuntime = {
+	sessionKey: string;
+	items: BtwItem[];
+	spinnerFrame: number;
+	requestRender?: () => void;
+	spinnerTimer?: ReturnType<typeof setInterval>;
+	expiryTimer?: ReturnType<typeof setTimeout>;
+};
+
+const runtimes = new Map<string, BtwRuntime>();
+const pendingPersistence = new Map<string, BtwRecord[]>();
+let nextItemId = 1;
+
+function getSessionKey(ctx: ExtensionContext): string {
+	return ctx.sessionManager.getSessionFile() ?? `memory:${ctx.sessionManager.getSessionId()}`;
+}
+
+function getRuntime(ctx: ExtensionContext): BtwRuntime {
+	const sessionKey = getSessionKey(ctx);
+	let runtime = runtimes.get(sessionKey);
+	if (!runtime) {
+		runtime = {
+			sessionKey,
+			items: [],
+			spinnerFrame: 0,
+		};
+		runtimes.set(sessionKey, runtime);
+	}
+	return runtime;
+}
+
+function extractTextParts(content: unknown): string[] {
+	if (typeof content === "string") {
+		return [content];
+	}
+
+	if (!Array.isArray(content)) {
+		return [];
+	}
+
+	const textParts: string[] = [];
+	for (const part of content) {
+		if (!part || typeof part !== "object") continue;
+		const block = part as TextBlock;
+		if (block.type === "text" && typeof block.text === "string") {
+			textParts.push(block.text);
+		}
+	}
+	return textParts;
+}
+
+function extractToolCalls(content: unknown): string[] {
+	if (!Array.isArray(content)) {
+		return [];
+	}
+
+	const toolCalls: string[] = [];
+	for (const part of content) {
+		if (!part || typeof part !== "object") continue;
+		const block = part as ToolCallBlock;
+		if (block.type !== "toolCall" || typeof block.name !== "string") continue;
+		toolCalls.push(`Assistant called tool ${block.name} with ${JSON.stringify(block.arguments ?? {})}`);
+	}
+	return toolCalls;
+}
+
+function clip(text: string, maxChars: number): string {
+	if (text.length <= maxChars) return text;
+	return `${text.slice(0, maxChars)}\n...[truncated]`;
+}
+
+function buildTranscriptText(entries: SessionEntryLike[]): string {
+	const relevantEntries = entries.filter((entry) => entry.type === "message").slice(-20);
+	const sections: string[] = [];
+
+	for (const entry of relevantEntries) {
+		const message = entry.message;
+		if (!message?.role) continue;
+
+		const role = message.role;
+		const text = extractTextParts(message.content).join("\n").trim();
+		const lines: string[] = [];
+
+		switch (role) {
+			case "user":
+				if (text) lines.push(`User: ${text}`);
+				break;
+			case "assistant":
+				if (text) lines.push(`Assistant: ${text}`);
+				lines.push(...extractToolCalls(message.content));
+				break;
+			case "toolResult":
+				if (text) {
+					const toolName = message.toolName ?? "tool";
+					lines.push(`Tool result from ${toolName}: ${clip(text, MAX_TOOL_RESULT_CHARS)}`);
+				}
+				break;
+			case "bashExecution":
+				if (text) lines.push(`User bash output: ${clip(text, MAX_TOOL_RESULT_CHARS)}`);
+				break;
+			case "custom":
+				if (text) lines.push(`Extension message: ${text}`);
+				break;
+			case "branchSummary":
+			case "compactionSummary":
+				if (text) lines.push(`Summary: ${text}`);
+				break;
+		}
+
+		if (lines.length > 0) {
+			sections.push(lines.join("\n"));
+		}
+	}
+
+	const transcript = sections.join("\n\n");
+	if (transcript.length <= MAX_TRANSCRIPT_CHARS) return transcript;
+	return `...[earlier session context omitted]\n\n${transcript.slice(-MAX_TRANSCRIPT_CHARS)}`;
+}
+
+function buildSideQuestionPrompt(question: string, transcript: string): string {
+	return [
+		"Current pi session transcript:",
+		"<session>",
+		transcript || "(No useful session transcript found.)",
+		"</session>",
+		"",
+		"Side question:",
+		"<question>",
+		question,
+		"</question>",
+	].join("\n");
+}
+
+function getModelLabel(ctx: ExtensionContext): string {
+	if (!ctx.model) return "unknown-model";
+	return `${ctx.model.provider}/${ctx.model.id}`;
+}
+
+async function askSideQuestion(question: string, ctx: ExtensionContext): Promise<string> {
+	if (!ctx.model) {
+		throw new Error("No model selected.");
+	}
+
+	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
+	if (!auth.ok) {
+		throw new Error(auth.error);
+	}
+	if (!auth.apiKey) {
+		throw new Error(`No API key available for ${getModelLabel(ctx)}.`);
+	}
+
+	const transcript = buildTranscriptText(ctx.sessionManager.getBranch() as SessionEntryLike[]);
+	const userMessage: UserMessage = {
+		role: "user",
+		content: [{ type: "text", text: buildSideQuestionPrompt(question, transcript) }],
+		timestamp: Date.now(),
+	};
+
+	const response = await complete(
+		ctx.model,
+		{
+			systemPrompt: SIDE_QUESTION_SYSTEM_PROMPT,
+			messages: [userMessage],
+		},
+		{
+			apiKey: auth.apiKey,
+			headers: auth.headers,
+		},
+	);
+
+	if (response.stopReason === "aborted") {
+		throw new Error("Cancelled.");
+	}
+
+	const answer = response.content
+		.filter((item): item is { type: "text"; text: string } => item.type === "text")
+		.map((item) => item.text)
+		.join("\n")
+		.trim();
+
+	return answer || "No response received.";
+}
+
+function ensureWidget(ctx: ExtensionContext, runtime: BtwRuntime) {
+	if (!ctx.hasUI) return;
+
+	ctx.ui.setWidget(
+		BTW_WIDGET_ID,
+		(tui, theme) => {
+			runtime.requestRender = () => tui.requestRender();
+			return new BtwWidget(theme, runtime);
+		},
+		{ placement: "belowEditor" },
+	);
+}
+
+function persistOrQueue(pi: ExtensionAPI, ctx: ExtensionContext, record: BtwRecord) {
+	if (ctx.isIdle()) {
+		pi.appendEntry(BTW_ENTRY_TYPE, record);
+		return;
+	}
+
+	const key = getSessionKey(ctx);
+	const queue = pendingPersistence.get(key) ?? [];
+	queue.push(record);
+	pendingPersistence.set(key, queue);
+}
+
+function flushPendingForCurrentSession(pi: ExtensionAPI, ctx: ExtensionContext) {
+	if (!ctx.isIdle()) return;
+
+	const key = getSessionKey(ctx);
+	const queue = pendingPersistence.get(key);
+	if (!queue || queue.length === 0) return;
+
+	for (const record of queue) {
+		pi.appendEntry(BTW_ENTRY_TYPE, record);
+	}
+	pendingPersistence.delete(key);
+}
+
+function cleanupExpiredItems(runtime: BtwRuntime) {
+	const now = Date.now();
+	runtime.items = runtime.items.filter((item) => item.state === "loading" || !item.expiresAt || item.expiresAt > now);
+}
+
+function syncRuntimeTimers(runtime: BtwRuntime) {
+	cleanupExpiredItems(runtime);
+
+	const hasLoading = runtime.items.some((item) => item.state === "loading");
+	if (hasLoading && !runtime.spinnerTimer) {
+		runtime.spinnerTimer = setInterval(() => {
+			runtime.spinnerFrame = (runtime.spinnerFrame + 1) % SPINNER_FRAMES.length;
+			runtime.requestRender?.();
+		}, 120);
+	}
+	if (!hasLoading && runtime.spinnerTimer) {
+		clearInterval(runtime.spinnerTimer);
+		runtime.spinnerTimer = undefined;
+	}
+
+	if (runtime.expiryTimer) {
+		clearTimeout(runtime.expiryTimer);
+		runtime.expiryTimer = undefined;
+	}
+
+	const now = Date.now();
+	const nextExpiry = runtime.items
+		.filter((item) => item.expiresAt && item.expiresAt > now)
+		.map((item) => item.expiresAt as number)
+		.sort((a, b) => a - b)[0];
+
+	if (nextExpiry) {
+		runtime.expiryTimer = setTimeout(() => {
+			cleanupExpiredItems(runtime);
+			syncRuntimeTimers(runtime);
+			runtime.requestRender?.();
+		}, Math.max(0, nextExpiry - now));
+	}
+}
+
+async function startBtw(question: string, pi: ExtensionAPI, ctx: ExtensionContext) {
+	if (!ctx.model) {
+		ctx.ui.notify("No model selected", "error");
+		return;
+	}
+
+	const runtime = getRuntime(ctx);
+	ensureWidget(ctx, runtime);
+
+	const item: BtwItem = {
+		id: `btw-${nextItemId++}`,
+		question,
+		state: "loading",
+		askedAt: new Date().toISOString(),
+		model: getModelLabel(ctx),
+	};
+
+	runtime.items.unshift(item);
+	runtime.items = runtime.items.slice(0, 6);
+	syncRuntimeTimers(runtime);
+	runtime.requestRender?.();
+
+	try {
+		const answer = await askSideQuestion(question, ctx);
+		item.state = "answer";
+		item.answer = answer;
+		item.answeredAt = new Date().toISOString();
+		item.expiresAt = Date.now() + COMPLETED_ITEM_TTL_MS;
+		persistOrQueue(pi, ctx, {
+			question,
+			answer,
+			askedAt: item.askedAt,
+			answeredAt: item.answeredAt,
+			model: item.model,
+			sessionFile: ctx.sessionManager.getSessionFile(),
+		});
+	} catch (error) {
+		item.state = "error";
+		item.error = error instanceof Error ? error.message : String(error);
+		item.answeredAt = new Date().toISOString();
+		item.expiresAt = Date.now() + COMPLETED_ITEM_TTL_MS;
+		persistOrQueue(pi, ctx, {
+			question,
+			error: item.error,
+			askedAt: item.askedAt,
+			answeredAt: item.answeredAt,
+			model: item.model,
+			sessionFile: ctx.sessionManager.getSessionFile(),
+		});
+	}
+
+	syncRuntimeTimers(runtime);
+	runtime.requestRender?.();
+}
+
+function normalizeShortcutQuestion(text: string): string {
+	const trimmed = text.trim();
+	if (!trimmed) return "";
+	return trimmed.replace(/^\/btw\b/i, "").trim();
+}
+
+function extractBtwQuestion(text: string): string | null {
+	const match = text.match(/^\/btw\b([\s\S]*)$/i);
+	if (!match) return null;
+	return match[1]?.trim() ?? "";
+}
+
+class BtwWidget {
+	constructor(
+		private readonly theme: Theme,
+		private readonly runtime: BtwRuntime,
+	) {}
+
+	render(width: number): string[] {
+		cleanupExpiredItems(this.runtime);
+		if (this.runtime.items.length === 0) {
+			return [];
+		}
+
+		const innerWidth = Math.max(24, width);
+		const lines: string[] = [];
+		const activeCount = this.runtime.items.filter((item) => item.state === "loading").length;
+		const recentCount = this.runtime.items.filter((item) => item.state !== "loading").length;
+		const summaryParts = [activeCount > 0 ? `${activeCount} running` : undefined, recentCount > 0 ? `${recentCount} recent` : undefined]
+			.filter(Boolean)
+			.join(" · ");
+
+		lines.push(this.theme.fg("accent", "BTW") + (summaryParts ? this.theme.fg("dim", ` · ${summaryParts}`) : ""));
+		lines.push(this.theme.fg("borderMuted", "─".repeat(Math.max(1, innerWidth - 2))));
+
+		for (const item of this.runtime.items.slice(0, MAX_RENDER_ITEMS)) {
+			const questionLines = wrapTextWithAnsi(this.theme.fg("accent", `Q: ${item.question}`), innerWidth);
+			lines.push(...questionLines);
+
+			if (item.state === "loading") {
+				const frame = SPINNER_FRAMES[this.runtime.spinnerFrame] ?? SPINNER_FRAMES[0]!;
+				lines.push(this.theme.fg("warning", `${frame} Answering with ${item.model}...`));
+			} else {
+				const body = item.state === "error" ? this.theme.fg("error", item.error ?? "Unknown error") : item.answer ?? "";
+				const wrapped = body
+					.split("\n")
+					.flatMap((line) => wrapTextWithAnsi(line.length > 0 ? line : " ", innerWidth));
+				const clipped = wrapped.slice(0, MAX_RENDERED_ANSWER_LINES);
+				lines.push(...clipped);
+				if (wrapped.length > clipped.length) {
+					lines.push(this.theme.fg("dim", `... ${wrapped.length - clipped.length} more line(s)`));
+				}
+			}
+
+			lines.push("");
+		}
+
+		if (lines[lines.length - 1] === "") {
+			lines.pop();
+		}
+
+		lines.push(this.theme.fg("dim", "Use /btw <question> anytime, even while pi is still working."));
+		return lines.map((line) => truncateToWidth(line, width, "...", true));
+	}
+
+	invalidate(): void {}
+}
+
+export default function (pi: ExtensionAPI) {
+	const attachCurrentSessionWidget = (_event: unknown, ctx: ExtensionContext) => {
+		ensureWidget(ctx, getRuntime(ctx));
+		flushPendingForCurrentSession(pi, ctx);
+	};
+
+	const flush = (_event: unknown, ctx: ExtensionContext) => {
+		flushPendingForCurrentSession(pi, ctx);
+	};
+
+	pi.on("session_start", attachCurrentSessionWidget);
+	pi.on("session_switch", attachCurrentSessionWidget);
+	pi.on("agent_end", flush);
+	pi.on("session_before_switch", flush);
+	pi.on("session_before_fork", flush);
+	pi.on("session_shutdown", (_event, _ctx) => {
+		for (const runtime of runtimes.values()) {
+			if (runtime.spinnerTimer) clearInterval(runtime.spinnerTimer);
+			if (runtime.expiryTimer) clearTimeout(runtime.expiryTimer);
+		}
+		runtimes.clear();
+	});
+
+	pi.on("input", (event, ctx) => {
+		if (!ctx.hasUI) {
+			return { action: "continue" as const };
+		}
+		if (event.source === "extension") {
+			return { action: "continue" as const };
+		}
+
+		const question = extractBtwQuestion(event.text);
+		if (question === null) {
+			return { action: "continue" as const };
+		}
+
+		if (!question) {
+			ctx.ui.notify("Usage: /btw <question>", "warning");
+			return { action: "handled" as const };
+		}
+
+		void startBtw(question, pi, ctx);
+		return { action: "handled" as const };
+	});
+
+	pi.registerShortcut("ctrl+shift+b", {
+		description: "Ask the current editor text as a side question",
+		handler: async (ctx) => {
+			if (!ctx.hasUI) return;
+			const editorText = ctx.ui.getEditorText();
+			const question = normalizeShortcutQuestion(editorText);
+			if (!question) {
+				ctx.ui.notify("Type a question in the editor, then press Ctrl+Shift+B, or submit /btw <question>.", "warning");
+				return;
+			}
+			ctx.ui.setEditorText("");
+			void startBtw(question, pi, ctx);
+		},
+	});
+}