one-code-extension 0.3.0 → 0.4.0

package/extensions/btw/index.ts

@@ -0,0 +1,207 @@
+/**
+ * btw extension — Claude Code's `/btw` ("by the way") side question.
+ *
+ * `/btw <question>` asks a one-off question that is answered from the current
+ * conversation's context while the main agent keeps working. CC frames the
+ * answering model as a separate, lightweight, tool-less instance (the verbatim
+ * reminder in prompt.ts, captured from CC 2.1.278) and shows the answer in a
+ * focused overlay panel, not in the transcript — so the exchange never enters
+ * the main agent's context and cannot steer its work.
+ *
+ * The call reuses recap's machinery: the exact messages the session last put on
+ * the wire (captured from the `context` event), name-only tool stubs so a
+ * history carrying tool_use blocks stays valid on strict providers, and
+ * withReasoningFallback for models that cannot disable thinking. Unlike recap it
+ * uses the SESSION model (not an economical one) — a side question deserves the
+ * same quality as the main conversation — and sends the full captured history,
+ * not just the recent window.
+ *
+ * Deviations from CC, logged in docs/decisions/btw.md: the exchange is stateless
+ * (each `/btw` sees only the shared main context, never a prior `/btw` — CC
+ * keeps a side-session; the "one-off, no follow-up" framing holds either way);
+ * `f to fork` is omitted (pi's `ctx.fork` branches from a session entry, not
+ * from an injected side exchange); and the call runs with an empty system prompt
+ * (the `context` event carries no system prompt to reuse), relying on the shared
+ * history plus the reminder.
+ */
+
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { completeSimple } from "@earendil-works/pi-ai/compat";
+import { convertToLlm, copyToClipboard, type ExtensionAPI, type ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { withReasoningFallback } from "../lib/model-policy.ts";
+import { answerText, stripImageBlocks, toolStubs, trimToTurnBoundary } from "../lib/side-call.ts";
+import { boundedDockHeight, truncateLine } from "../lib/tui-render.ts";
+import { recordUsage } from "../lib/usage-bus.ts";
+import { applyBtwKey, type BtwBody, BTW_MAX_HEIGHT, decodeBtwKey, initialBtwState, renderBtwPanel } from "./panel.ts";
+import { sideQuestionMessage } from "./prompt.ts";
+
+const BTW_MAX_TOKENS = 8192;
+const BTW_TIMEOUT_MS = 120_000;
+/** Description on the name-only tool stubs sent with the side question. */
+const STUB_REASON = "Unavailable during this side question; answer in text.";
+
+export default function btwExtension(pi: ExtensionAPI) {
+	// The exact request messages the session last sent (after every extension's
+	// mutations), captured like recap and the compaction extension do.
+	let capturedMessages: AgentMessage[] | undefined;
+	pi.on("context", (event) => {
+		capturedMessages = event.messages;
+	});
+
+	// The controller for an open panel's in-flight call. Aborted when the session
+	// is replaced or torn down, so a late resolve cannot repaint a disposed `tui`
+	// or record usage on a stale `pi` (the crash the subagents panel once hit —
+	// docs/decisions/tools.md lifecycle review).
+	let inFlight: AbortController | undefined;
+
+	// A new session (including after /clear) shares no context with the old one,
+	// and any in-flight side question is abandoned.
+	pi.on("session_start", () => {
+		capturedMessages = undefined;
+		inFlight?.abort();
+		inFlight = undefined;
+	});
+	pi.on("session_shutdown", () => {
+		inFlight?.abort();
+		inFlight = undefined;
+	});
+
+	/** Run the side question against the session model; returns the answer text. */
+	async function ask(ctx: ExtensionCommandContext, question: string, signal: AbortSignal): Promise<string> {
+		const model = ctx.model;
+		if (!model) throw new Error("No model is configured for this session.");
+		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+		if (!auth.ok) throw new Error("No API key is available for the current model.");
+		const baseUrl = (auth as { baseUrl?: string }).baseUrl;
+
+		const tools = toolStubs(pi.getActiveTools(), STUB_REASON);
+		const context = trimToTurnBoundary(capturedMessages ?? []);
+		// btw runs on a cheap, possibly text-only reader and answers a text question,
+		// so images the conversation carried are stripped before the call
+		// (docs/decisions/model-policy.md).
+		const messages = [...stripImageBlocks(convertToLlm(context)), { role: "user" as const, content: sideQuestionMessage(question), timestamp: Date.now() }];
+
+		const result = await withReasoningFallback(
+			model as Model<Api>,
+			(reasoning) => {
+				const timeout = AbortSignal.timeout(BTW_TIMEOUT_MS);
+				return completeSimple(
+					baseUrl ? ({ ...model, baseUrl } as Model<Api>) : (model as Model<Api>),
+					{ systemPrompt: "", messages, tools },
+					{
+						apiKey: auth.apiKey,
+						headers: auth.headers,
+						env: auth.env,
+						signal: AbortSignal.any([signal, timeout]),
+						maxTokens: BTW_MAX_TOKENS,
+						...(reasoning ? { reasoning } : {}),
+					},
+				);
+			},
+			undefined,
+			(usage) => recordUsage(pi, "btw", usage),
+		);
+		return answerText(result.content);
+	}
+
+	pi.registerCommand("btw", {
+		description: "Ask a one-off side question, answered from the current context while the main agent keeps working",
+		handler: async (args, ctx) => {
+			const question = args.trim();
+			if (!question) {
+				ctx.ui.notify("Ask a side question: /btw <question>", "info");
+				return;
+			}
+
+			// Headless (-p / --mode json): no panel — answer and print it. The
+			// handler blocks to completion, so the process does not exit early.
+			if (!ctx.hasUI) {
+				try {
+					const answer = await ask(ctx, question, new AbortController().signal);
+					ctx.ui.notify(answer || "(no answer)", "info");
+				} catch (error) {
+					ctx.ui.notify(`Side question failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+				}
+				return;
+			}
+
+			// Show the panel at once with a loading line; run the call concurrently
+			// and repaint when it lands. Closing the panel — or a session
+			// replacement/shutdown — aborts an in-flight call.
+			inFlight?.abort();
+			const controller = new AbortController();
+			inFlight = controller;
+			const view: { answer?: string; error?: string } = {};
+			const bodyState = (): BtwBody =>
+				view.error !== undefined ? { kind: "error", message: view.error } : view.answer !== undefined ? { kind: "answer", text: view.answer } : { kind: "loading" };
+
+			await ctx.ui.custom<null>((tui, theme, _keybindings, done) => {
+				const state = initialBtwState();
+				let cache: { width: number; lines: string[] } | undefined;
+				const repaint = () => {
+					cache = undefined;
+					// A repaint can be requested from an async callback that raced a
+					// session teardown; a stale `tui` throws, so never let it propagate.
+					try {
+						tui.requestRender();
+					} catch {}
+				};
+
+				// Kick off the model call once, at mount, so `repaint` is bound.
+				void (async () => {
+					try {
+						const answer = await ask(ctx, question, controller.signal);
+						if (controller.signal.aborted) return;
+						view.answer = answer;
+					} catch (error) {
+						if (controller.signal.aborted) return;
+						view.error = error instanceof Error ? error.message : String(error);
+					}
+					repaint();
+				})();
+
+				return {
+					render: (width: number) => {
+						if (cache?.width === width) return cache.lines;
+						const termRows = (tui as { terminal: { rows: number } }).terminal.rows;
+						const height = boundedDockHeight(termRows, BTW_MAX_HEIGHT);
+						// Belt-and-suspenders truncate on top of renderBtwPanel's own,
+						// matching every sibling dock panel: pi-tui crashes the app on
+						// a line wider than the terminal.
+						const lines = renderBtwPanel({ state, question, body: bodyState(), width, height }, theme).map((line) => truncateLine(line, width));
+						cache = { width, lines };
+						return lines;
+					},
+					handleInput: (data: string) => {
+						const key = decodeBtwKey(data);
+						if (!key) return;
+						const effect = applyBtwKey(state, key);
+						switch (effect?.kind) {
+							case "close":
+								done(null);
+								return;
+							case "copy":
+								// Only offer copy once there is a non-empty answer.
+								if (view.answer) {
+									void copyToClipboard(view.answer).then(() => {
+										state.copied = true;
+										repaint();
+									});
+								}
+								return;
+							default:
+								repaint();
+						}
+					},
+					invalidate: () => {
+						cache = undefined;
+					},
+				};
+			});
+
+			controller.abort();
+			if (inFlight === controller) inFlight = undefined;
+		},
+	});
+}

package/extensions/btw/panel.ts

@@ -0,0 +1,179 @@
+/**
+ * Pure state, key decoding, and rendering for the `/btw` answer overlay — Claude
+ * Code's side-question panel: a focused, scrollable view of the answer with the
+ * question dim above it. `↑/↓` (and PgUp/PgDn) scroll, `c` copies the answer,
+ * `Esc` closes.
+ *
+ * Kept free of pi imports so the scroll maths and layout are unit-tested; the
+ * extension owns the overlay, repaint, and the actual clipboard write. CC's
+ * panel also offers `f to fork`; One Code omits it (pi exposes no primitive to
+ * branch a session with an injected exchange) — docs/decisions/btw.md.
+ */
+
+import { panelTopRule, safeThemePaint, truncateLine, wrapPlainText } from "../lib/tui-render.ts";
+
+export const BTW_MAX_HEIGHT = 24;
+
+/** Key hint shown at the foot of the panel. Every key here is discoverable. */
+export const BTW_HINT = "↑/↓ to scroll · c to copy · Esc to close";
+
+/** Most echoed question lines shown in the header, so it can't starve the body. */
+export const MAX_QUESTION_LINES = 4;
+
+/**
+ * The panel's body state. The pure module owns the text for each phase so every
+ * appearance (loading, error, answer) is rendered — and tested — here rather
+ * than assembled by the extension wiring.
+ */
+export type BtwBody = { kind: "loading" } | { kind: "error"; message: string } | { kind: "answer"; text: string };
+
+/** The text shown in the body for a given phase. */
+function bodyText(body: BtwBody): string {
+	switch (body.kind) {
+		case "loading":
+			return "Thinking…";
+		case "error":
+			return `Side question failed: ${body.message}`;
+		case "answer":
+			return body.text || "(no answer)";
+	}
+}
+
+export interface BtwPanelState {
+	/** First body line shown (0 = top). */
+	offset: number;
+	/** Largest valid offset for the current viewport; render keeps it current. */
+	maxOffset: number;
+	/** Visible body lines in the current viewport; render keeps it current. */
+	viewport: number;
+	/** Set for one frame after a copy so the footer can confirm it. */
+	copied: boolean;
+}
+
+export function initialBtwState(): BtwPanelState {
+	return { offset: 0, maxOffset: 0, viewport: 1, copied: false };
+}
+
+export type BtwKey = { kind: "up" | "down" | "pageUp" | "pageDown" | "top" | "bottom" | "copy" | "close" };
+
+export function decodeBtwKey(data: string): BtwKey | undefined {
+	switch (data) {
+		case "\x1b[A":
+		case "\x1bOA":
+		case "\x10": // ctrl+p
+			return { kind: "up" };
+		case "\x1b[B":
+		case "\x1bOB":
+		case "\x0e": // ctrl+n
+			return { kind: "down" };
+		case "\x1b[5~":
+			return { kind: "pageUp" };
+		case "\x1b[6~":
+			return { kind: "pageDown" };
+		case "\x1b[H":
+		case "\x1bOH":
+			return { kind: "top" };
+		case "\x1b[F":
+		case "\x1bOF":
+			return { kind: "bottom" };
+		case "c":
+		case "C":
+			return { kind: "copy" };
+		case "\x1b":
+		case "\x03": // ctrl+c
+		case "q":
+			return { kind: "close" };
+		default:
+			return undefined;
+	}
+}
+
+export type BtwEffect = { kind: "copy" } | { kind: "close" };
+
+/** Page size for PgUp/PgDn: nearly a full viewport, one line of overlap for orientation. */
+function pageStep(viewport: number): number {
+	return Math.max(1, viewport - 1);
+}
+
+/**
+ * Apply a key to the scroll state. Returns an effect for the extension to run
+ * (copy, close) or undefined for a scroll (repaint only). Offsets are clamped to
+ * `state.maxOffset`, and pages by `state.viewport` — both set by the most recent
+ * render from the real viewport.
+ */
+export function applyBtwKey(state: BtwPanelState, key: BtwKey): BtwEffect | undefined {
+	state.copied = false;
+	const step = pageStep(state.viewport);
+	switch (key.kind) {
+		case "up":
+			state.offset = Math.max(0, state.offset - 1);
+			return undefined;
+		case "down":
+			state.offset = Math.min(state.maxOffset, state.offset + 1);
+			return undefined;
+		case "pageUp":
+			state.offset = Math.max(0, state.offset - step);
+			return undefined;
+		case "pageDown":
+			state.offset = Math.min(state.maxOffset, state.offset + step);
+			return undefined;
+		case "top":
+			state.offset = 0;
+			return undefined;
+		case "bottom":
+			state.offset = state.maxOffset;
+			return undefined;
+		case "copy":
+			return { kind: "copy" };
+		case "close":
+			return { kind: "close" };
+	}
+}
+
+/**
+ * Render the panel to at most `height` lines. The header (the dim question) and
+ * footer (rule + key hint, with a scroll indicator and a copy confirmation) are
+ * fixed; the answer scrolls within what remains. Clamps and writes back
+ * `state.offset`/`state.maxOffset` so key handling scrolls against the real
+ * body length. Every line is width-truncated (pi-tui crashes on an overwide
+ * line).
+ */
+export function renderBtwPanel(
+	input: { state: BtwPanelState; question: string; body: BtwBody; width: number; height: number },
+	theme?: unknown,
+): string[] {
+	const { state, question, body, width, height } = input;
+	const paint = safeThemePaint(theme);
+	const inner = Math.max(1, width);
+
+	// Cap the echoed question so a long one (a pasted paragraph or URL) cannot
+	// grow the header past the panel height and starve the answer of rows; a
+	// truncated last line gets an ellipsis. The answer is what scrolls, not the
+	// question.
+	const questionLines = wrapPlainText(question.trim(), inner);
+	const shownQuestion =
+		questionLines.length > MAX_QUESTION_LINES
+			? [...questionLines.slice(0, MAX_QUESTION_LINES - 1), truncateLine(`${questionLines[MAX_QUESTION_LINES - 1]}…`, inner)]
+			: questionLines;
+	const header = [
+		paint("accent", truncateLine("Side question", inner)),
+		...shownQuestion.map((line) => paint("muted", truncateLine(line, inner))),
+		panelTopRule(paint, inner),
+	];
+
+	const bodyAll = wrapPlainText(bodyText(body), inner);
+	const capacity = Math.max(1, height - header.length - 2); // 2 = footer rule + hint
+	state.viewport = capacity;
+	state.maxOffset = Math.max(0, bodyAll.length - capacity);
+	state.offset = Math.min(Math.max(0, state.offset), state.maxOffset);
+
+	const visible = bodyAll.slice(state.offset, state.offset + capacity).map((line) => truncateLine(line, inner));
+	// Pad a short answer so the footer sits at the panel's foot, not mid-screen.
+	while (visible.length < capacity) visible.push("");
+
+	const scrollNote = state.maxOffset > 0 ? `  (${state.offset + 1}-${Math.min(state.offset + capacity, bodyAll.length)} of ${bodyAll.length})` : "";
+	const hint = state.copied ? "Copied to clipboard" : `${BTW_HINT}${scrollNote}`;
+	const footer = [panelTopRule(paint, inner), paint("muted", truncateLine(hint, inner))];
+
+	return [...header, ...visible, ...footer];
+}

package/extensions/btw/prompt.ts

@@ -0,0 +1,45 @@
+/**
+ * Pure pieces of Claude Code's `/btw` ("by the way") side-question feature: a
+ * lightweight, one-off question answered against the current conversation's
+ * context while the main agent keeps working. Prompt text is verbatim from CC's
+ * capture (captures/btw.json, CC 2.1.278): a `<system-reminder>` that frames the
+ * answering model as a separate, tool-less instance, prepended to the user's
+ * question as the final user message.
+ *
+ * Kept free of pi imports so the message assembly and text extraction are
+ * unit-tested; the extension owns the model call, the spinner, and the panel.
+ */
+
+/**
+ * CC's verbatim side-question reminder (captures/btw.json message 20). It frames
+ * the answering instance as a separate, lightweight, tool-less agent so the
+ * model answers in one shot from context instead of trying to act. One Code
+ * backs this framing for real: it sends name-only tool stubs (never live tools)
+ * and does not persist the exchange, so there genuinely is no follow-up turn.
+ */
+export const SIDE_QUESTION_REMINDER = `<system-reminder>This is a side question from the user. You must answer this question directly in a single response.
+
+IMPORTANT CONTEXT:
+- You are a separate, lightweight agent spawned to answer this one question
+- The main agent is NOT interrupted - it continues working independently in the background
+- You share the conversation context but are a completely separate instance
+- Do NOT reference being interrupted or what you were "previously doing" - that framing is incorrect
+
+CRITICAL CONSTRAINTS:
+- You have NO tools available - you cannot read files, run commands, search, or take any actions
+- Do NOT write tool calls or tool output as text (for example invoke or function_calls XML blocks) - nothing you write here is executed; if answering would need reading files, running commands, or searching, say that can't be checked from a side question and suggest asking in the main conversation
+- This is a one-off response - there will be no follow-up turns
+- You can ONLY provide information based on what you already know from the conversation context
+- NEVER say things like "Let me try...", "I'll now...", "Let me check...", or promise to take any action
+- If you don't know the answer, say so - do not offer to look it up or investigate
+
+Simply answer the question with the information you have.</system-reminder>`;
+
+/**
+ * The final user message a `/btw` call sends: CC's reminder, a blank line, then
+ * the user's question verbatim (captures/btw.json message 20 is exactly this
+ * string). The question is trimmed of surrounding whitespace only.
+ */
+export function sideQuestionMessage(question: string): string {
+	return `${SIDE_QUESTION_REMINDER}\n\n${question.trim()}`;
+}

package/extensions/clear/index.ts

@@ -13,9 +13,20 @@
  * a clean context — which is what a `/clear` habit wants. Like `/exit`→`/quit`,
  * we cannot fold this into pi's `/new` palette entry (pi has no command
  * aliases), so `/clear` and `/new` are two entries that both reset.
+ *
+ * Claude Code tells the model the conversation was cleared: the new
+ * conversation opens with the `/clear` breadcrumb (caveat, command, empty
+ * stdout — lib/local-command.ts). It cannot be queued from the handler: pi's
+ * `newSession()` replaces the whole runtime (a `session_shutdown` with reason
+ * "new" on the old extension runner, every factory run again — findings §8),
+ * so a reminder queued before the call dies with the old queue. The NEW
+ * instance announces it instead, from its `session_start` with reason "new" —
+ * which is also what pi's own `/new` and an RPC `new_session` produce, and
+ * they are the same user action as far as the model is concerned.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { announceLocalCommand } from "../lib/local-command.ts";
 
 export default function clearExtension(pi: ExtensionAPI) {
 	pi.registerCommand("clear", {
@@ -24,4 +35,8 @@ export default function clearExtension(pi: ExtensionAPI) {
 			await ctx.newSession();
 		},
 	});
+
+	pi.on("session_start", (event) => {
+		if ((event as { reason?: string }).reason === "new") announceLocalCommand(pi, { name: "clear" });
+	});
 }

package/extensions/compaction/fit.ts

@@ -27,16 +27,19 @@
  *
  * Both decisions ask pi-ai's `clampMaxTokensToContext` — the very function
  * `completeSimple` applies to the request — rather than re-deriving its
- * arithmetic, so they can never disagree with the clamp they predict. One
- * trap in that estimator: it anchors on the last assistant message's
- * `usage` total when there is one (`withoutUsage`).
+ * arithmetic, so they can never disagree with the clamp they predict. They
+ * `normalizeContext` the request first, exactly as `completeSimple` does, so the
+ * prompt and tools are counted (pi 0.86.1 carries them in a leading system
+ * message, not separate `Context` fields). One trap in that estimator: it
+ * anchors on the last assistant message's `usage` total when there is one
+ * (`withoutUsage`).
  */
 
 import { type Api, type Context, contentText, type Message, type Model } from "@earendil-works/pi-ai";
 import { PREVIEW_BYTES } from "../lib/persisted-output.ts";
 // Vendored from pi-ai: importing its deep subpaths directly breaks under the
 // bundled app's library loader (distribution review 2026-09-09, H1).
-import { clampMaxTokensToContext, estimateMessageTokens } from "../lib/pi-ai-estimate.ts";
+import { clampMaxTokensToContext, estimateMessageTokens, normalizeContext } from "../lib/pi-ai-estimate.ts";
 
 /**
  * The least output room a replay must leave for the summary. Below it the
@@ -60,7 +63,7 @@ export const CLEARED_RESULT_HEAD_CHARS = PREVIEW_BYTES;
  */
 export function replayFits(reason: "manual" | "threshold" | "overflow", model: Model<Api>, request: Context, maxTokens: number): boolean {
 	if (reason === "overflow") return false;
-	return clampMaxTokensToContext(model, request, maxTokens) >= MIN_REPLAY_SUMMARY_TOKENS;
+	return clampMaxTokensToContext(model, normalizeContext(request), maxTokens) >= MIN_REPLAY_SUMMARY_TOKENS;
 }
 
 /**
@@ -80,7 +83,7 @@ export function fitToBudget(model: Model<Api>, request: Context, maxTokens: numb
 
 	let cleared = 0;
 	for (const { index } of candidates) {
-		if (clampMaxTokensToContext(model, fitted, maxTokens) >= STANDALONE_SUMMARY_TOKENS) break;
+		if (clampMaxTokensToContext(model, normalizeContext(fitted), maxTokens) >= STANDALONE_SUMMARY_TOKENS) break;
 		messages[index] = clearToolResult(messages[index]);
 		cleared++;
 	}

package/extensions/doctor/build.ts

@@ -17,7 +17,10 @@ import { readJsonFile } from "../lib/atomic-write.ts";
 import { oneCodeSettingsPath } from "../lib/one-code-settings.ts";
 import { webSearchSettingsFrom } from "../web/backends.ts";
 import { collectCompat, importedConfigSection, mcpSection } from "./compat.ts";
-import { checkDependencies, dependenciesSection } from "./dependencies.ts";
+import { checkDependencies, dependenciesSection, type ShellsInput } from "./dependencies.ts";
+import { readSettingsEnv } from "../lib/claude-settings.ts";
+import { resolveBashSpawn, resolvePowerShellSpawn } from "../lib/shell-spawn.ts";
+import { shellToolPolicy } from "../powershell/policy.ts";
 import { collectModelFacts, modelsSection } from "./models.ts";
 import { computePresets, presetsSection } from "./presets.ts";
 import {
@@ -181,7 +184,7 @@ export function buildDoctorReport({ env, registry, session }: BuildInput): Docto
 	sections.push(mcpSection(compat, session, env.home));
 
 	const webSearchSettings = webSearchSettingsFrom(readJsonFile<{ webSearch?: unknown }>(oneCodeSettingsPath(env.home, env.env))?.webSearch);
-	const deps = checkDependencies({ cwd: env.cwd, env: env.env, platform: env.platform, mcpServers: compat.mcp.servers, sessionModel: session.model, webSearchSettings });
+	const deps = checkDependencies({ cwd: env.cwd, env: env.env, platform: env.platform, agentDir: env.agentDir, mcpServers: compat.mcp.servers, sessionModel: session.model, webSearchSettings, shells: resolveShells(env.env, env.home, env.platform) });
 	findings.push(...deps.findings);
 	sections.push(dependenciesSection(deps));
 
@@ -224,3 +227,20 @@ function summaryText(input: {
 export function oneCodeVersion(env: NodeJS.ProcessEnv = process.env): string {
 	return env.CC_VERSION ?? extensionVersion();
 }
+
+/** The shell tools exactly as a session resolves them (bash/index.ts, powershell/index.ts). */
+export function resolveShells(procEnv: NodeJS.ProcessEnv, home: string, platform: string): ShellsInput {
+	const plat = platform as NodeJS.Platform;
+	const bash = resolveBashSpawn({ env: procEnv, settingsEnv: readSettingsEnv(home) });
+	const powershell = resolvePowerShellSpawn({ platform: plat, env: procEnv });
+	const policy = shellToolPolicy({ platform: plat, env: procEnv, bash: !!bash.spawn, powershell: !!powershell });
+	return {
+		bash: bash.spawn?.shell,
+		bashWarning: bash.warning,
+		powershell: powershell?.shell,
+		powershellWanted: policy.powershellWanted,
+		bashExpected: policy.bashExpected,
+		primary: policy.primary,
+		notices: policy.notices,
+	};
+}