@shanepadgett/tau-agent 0.1.0

package/extensions/patch/render.ts

@@ -0,0 +1,247 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { formatToolRowTitle, type ToolRowStateStore } from "../../shared/tool-row-state.js";
+import { type ApplyPatchSummary, deriveStats } from "./executor.ts";
+
+// renderCall owns only the pre-execution streaming preview. Once execution starts, pi stacks
+// renderResult below renderCall in the same container, so yielding here avoids a duplicated op list.
+// renderResult receives partial summaries via result.details on each onUpdate, so the live indicator
+// walk lives there natively — no progress stash needed.
+
+interface PreviewOp {
+	sectionIndex: number;
+	kind: "add" | "replace" | "update" | "delete";
+	path: string;
+	moveTo?: string;
+	linesAdded: number;
+	linesRemoved: number;
+}
+
+const END_PATCH_MARKER = "*** End Patch";
+const ADD_FILE_MARKER = "*** Add File: ";
+const REPLACE_FILE_MARKER = "*** Replace File: ";
+const DELETE_FILE_MARKER = "*** Delete File: ";
+const UPDATE_FILE_MARKER = "*** Update File: ";
+const MOVE_TO_MARKER = "*** Move to: ";
+
+function topLevelDirective(line: string): string {
+	return line.trim();
+}
+
+function updateDirective(line: string): string {
+	return line.trimEnd();
+}
+
+function pathAfter(value: string, prefix: string): string | undefined {
+	if (!value.startsWith(prefix)) return undefined;
+	const path = value.slice(prefix.length).trim();
+	return path.length > 0 ? path : undefined;
+}
+
+function startPreviewOp(ops: PreviewOp[], kind: PreviewOp["kind"], path: string): PreviewOp {
+	const op = { sectionIndex: ops.length + 1, kind, path, linesAdded: 0, linesRemoved: 0 };
+	ops.push(op);
+	return op;
+}
+
+// Tolerant preview scan — never throws, display-oriented (partial patches during streaming).
+function scanPreview(input: string | undefined): PreviewOp[] {
+	if (typeof input !== "string" || !input) return [];
+	const lines = input.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+	const ops: PreviewOp[] = [];
+	let current: PreviewOp | undefined;
+
+	for (const line of lines) {
+		const value = current?.kind === "update" ? updateDirective(line) : topLevelDirective(line);
+		if (value === END_PATCH_MARKER) break;
+
+		const addPath = pathAfter(value, ADD_FILE_MARKER);
+		if (addPath !== undefined) {
+			current = startPreviewOp(ops, "add", addPath);
+			continue;
+		}
+
+		const replacePath = pathAfter(value, REPLACE_FILE_MARKER);
+		if (replacePath !== undefined) {
+			current = startPreviewOp(ops, "replace", replacePath);
+			continue;
+		}
+
+		const deletePath = pathAfter(value, DELETE_FILE_MARKER);
+		if (deletePath !== undefined) {
+			current = startPreviewOp(ops, "delete", deletePath);
+			continue;
+		}
+
+		const updatePath = pathAfter(value, UPDATE_FILE_MARKER);
+		if (updatePath !== undefined) {
+			current = startPreviewOp(ops, "update", updatePath);
+			continue;
+		}
+
+		if (!current) continue;
+
+		if (current.kind === "update") {
+			const movePath = pathAfter(updateDirective(line), MOVE_TO_MARKER);
+			if (movePath !== undefined) {
+				current.moveTo = movePath;
+				continue;
+			}
+			if (line.startsWith("+")) current.linesAdded += 1;
+			else if (line.startsWith("-")) current.linesRemoved += 1;
+			continue;
+		}
+
+		if (current.kind === "add" || current.kind === "replace") {
+			if (line.startsWith("+")) current.linesAdded += 1;
+		}
+	}
+
+	return ops;
+}
+
+function statsBadge(summary: ApplyPatchSummary | undefined, preview: PreviewOp[], theme: Theme): string {
+	let fileCount: number;
+	let linesAdded: number;
+	let linesRemoved: number;
+	let moves: number;
+
+	if (summary && summary.changes.length > 0) {
+		const s = deriveStats(summary);
+		fileCount = new Set(summary.changes.map((c) => c.move?.to ?? c.path)).size;
+		linesAdded = s.linesAdded;
+		linesRemoved = s.linesRemoved;
+		moves = s.moved.length;
+	} else {
+		fileCount = new Set(preview.map((op) => op.moveTo ?? op.path)).size;
+		linesAdded = preview.reduce((sum, op) => sum + op.linesAdded, 0);
+		linesRemoved = preview.reduce((sum, op) => sum + op.linesRemoved, 0);
+		moves = preview.filter((op) => op.moveTo).length;
+	}
+
+	const stats = [
+		linesAdded > 0 ? `+${linesAdded}` : "",
+		linesRemoved > 0 ? `-${linesRemoved}` : "",
+		moves > 0 ? `>${moves}` : "",
+	]
+		.filter(Boolean)
+		.join(" ");
+
+	const badge = stats
+		? `${fileCount} file${fileCount === 1 ? "" : "s"} · ${stats}`
+		: `${fileCount} file${fileCount === 1 ? "" : "s"}`;
+	return theme.fg("accent", badge);
+}
+
+function opLabel(op: PreviewOp): string {
+	if (op.moveTo) return `Move   ${op.path} → ${op.moveTo}`;
+	if (op.kind === "add") return `Add    ${op.path}`;
+	if (op.kind === "replace") return `Replace ${op.path}`;
+	if (op.kind === "delete") return `Delete ${op.path}`;
+	return `Edit   ${op.path}`;
+}
+
+type OpStatus = "pending" | "applied" | "failed";
+
+function deriveStatuses(summary: ApplyPatchSummary): Map<number, OpStatus> {
+	const map = new Map<number, OpStatus>();
+	for (const change of summary.changes) map.set(change.sectionIndex, "applied");
+	for (const failure of summary.failures) {
+		if (failure.sectionIndex > 0) map.set(failure.sectionIndex, "failed");
+	}
+	return map;
+}
+
+function renderOpLine(op: PreviewOp, status: OpStatus | undefined, theme: Theme): string {
+	const label = `${theme.fg("muted", "  ")}${theme.fg("text", opLabel(op))}`;
+	const ind =
+		status === "applied"
+			? theme.fg("success", "✓")
+			: status === "failed"
+				? theme.fg("error", "!")
+				: theme.fg("muted", "…");
+	return ind ? `${label}  ${ind}` : label;
+}
+
+interface RenderCallContext {
+	expanded: boolean;
+	executionStarted: boolean;
+	isPartial: boolean;
+	lastComponent?: unknown;
+	rowState: ToolRowStateStore;
+	rowId: string;
+	invalidate: () => void;
+}
+
+function patchTitle(theme: Theme, context: Pick<RenderCallContext, "rowState" | "rowId" | "invalidate">): string {
+	context.rowState.watch(context.rowId, context.invalidate);
+	return formatToolRowTitle(context.rowState, context.rowId, "patch", theme);
+}
+
+function textComponent(lastComponent: unknown): Text {
+	return (lastComponent as Text | undefined) ?? new Text("", 0, 0);
+}
+
+export function renderPatchCall(args: { input?: string } | undefined, theme: Theme, context: RenderCallContext): Text {
+	const text = textComponent(context.lastComponent);
+	// Once execution starts, renderResult owns the view (it gets the live summary). Yield to avoid
+	// a duplicated op list, since pi stacks both renderers in the same container.
+	if (context.executionStarted || !context.isPartial) {
+		text.setText("");
+		return text;
+	}
+
+	const input = args?.input;
+	const preview = scanPreview(input);
+	const header = `${patchTitle(theme, context)}  ${statsBadge(undefined, preview, theme)}`;
+
+	if (context.expanded) {
+		const raw = typeof input === "string" ? input.replace(/\r\n/g, "\n").trim() : "";
+		text.setText(raw ? `${header}\n${theme.fg("muted", raw)}` : header);
+		return text;
+	}
+
+	if (preview.length === 0) {
+		text.setText(header);
+		return text;
+	}
+	const lines = preview.map((op) => renderOpLine(op, "pending", theme));
+	text.setText([header, ...lines].join("\n"));
+	return text;
+}
+
+export function renderPatchResult(
+	result: { details?: ApplyPatchSummary },
+	options: { expanded: boolean },
+	theme: Theme,
+	context: {
+		expanded: boolean;
+		args?: { input?: string };
+		lastComponent?: unknown;
+		rowState: ToolRowStateStore;
+		rowId: string;
+		invalidate: () => void;
+	},
+): Text {
+	const text = textComponent(context.lastComponent);
+	const summary = result.details;
+	if (!summary) {
+		text.setText("");
+		return text;
+	}
+	const preview = scanPreview(context.args?.input);
+	const header = `${patchTitle(theme, context)}  ${statsBadge(summary, preview, theme)}`;
+	const statuses = deriveStatuses(summary);
+
+	if (options.expanded) {
+		const raw = context.args?.input?.replace(/\r\n/g, "\n").trim() ?? "";
+		const sections = [header];
+		if (raw) sections.push(theme.fg("muted", raw));
+		text.setText(sections.join("\n"));
+		return text;
+	}
+
+	const lines = preview.map((op) => renderOpLine(op, statuses.get(op.sectionIndex), theme));
+	text.setText([header, ...lines].join("\n"));
+	return text;
+}

package/extensions/patch/summary.ts

@@ -0,0 +1,35 @@
+import { type ApplyPatchSummary, deriveStats } from "./executor.ts";
+
+export function formatPatchSummary(summary: ApplyPatchSummary): string {
+	const s = deriveStats(summary);
+	const lines: string[] = [];
+	if (summary.status === "failed") {
+		lines.push("No changes applied.");
+	} else {
+		const parts: string[] = [];
+		if (s.linesAdded > 0) parts.push(`+${s.linesAdded}`);
+		if (s.linesRemoved > 0) parts.push(`-${s.linesRemoved}`);
+		const badge = parts.length > 0 ? ` [${parts.join(" ")}]` : "";
+		lines.push(`Applied ${s.completedOperations}/${summary.totalSections} sections.${badge}`);
+	}
+
+	for (const path of s.added) lines.push(`A ${path}`);
+	for (const path of s.replaced) lines.push(`M ${path}`);
+	for (const path of s.updated) lines.push(`M ${path}`);
+	for (const path of s.deleted) lines.push(`D ${path}`);
+	for (const move of s.moved) lines.push(`R ${move.from} -> ${move.to}`);
+
+	if (summary.failures.length > 0) {
+		lines.push("Failures:");
+		for (const failure of summary.failures) {
+			const kind = failure.kind ? `${failure.kind} ` : "";
+			const path = failure.path ?? "";
+			const chunk =
+				failure.chunkIndex && failure.totalChunks ? ` chunk ${failure.chunkIndex}/${failure.totalChunks}` : "";
+			const ctx = failure.contextHint ? ` (context: "${failure.contextHint}")` : "";
+			lines.push(`- ${kind}${path}${chunk}: ${failure.message}${ctx}`.trim());
+		}
+	}
+
+	return lines.join("\n");
+}

package/extensions/publish/README.md

@@ -0,0 +1,11 @@
+# Publish
+
+Create a tagged Tau release and monitor its GitHub Actions npm publish run.
+
+## Usage
+
+```text
+/publish
+```
+
+`/publish` requires a clean Git working tree and authenticated GitHub CLI. It recommends a semantic version bump from commits since the previous release tag, asks for confirmation, then pushes a release tag. GitHub Actions publishes the TUI package before the agent package through npm trusted publishing.

package/extensions/publish/index.ts

@@ -0,0 +1,225 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { createGitRunner, type GitRunner, loadRepoStatus } from "../../shared/git.ts";
+import { errorText } from "../../shared/text.ts";
+
+const PACKAGE_PATHS = ["packages/tui/package.json", "packages/agent/package.json"] as const;
+const LOCKFILE_PATH = "package-lock.json";
+const WORKFLOW_NAME = "publish.yml";
+const WORKFLOW_WAIT_MS = 10 * 60_000;
+const POLL_INTERVAL_MS = 5_000;
+
+type Bump = "patch" | "minor" | "major";
+
+interface PackageManifest {
+	name: string;
+	version: string;
+	dependencies?: Record<string, string>;
+}
+
+interface WorkflowRun {
+	databaseId: number;
+	status: string;
+	conclusion: string | null;
+	url: string;
+}
+
+export default function publishExtension(pi: ExtensionAPI): void {
+	pi.registerCommand("publish", {
+		description: "Create a tagged release and monitor trusted npm publishing",
+		handler: async (args, ctx) => {
+			await ctx.waitForIdle();
+			if (args.trim()) {
+				ctx.ui.notify("Usage: /publish", "error");
+				return;
+			}
+			if (!ctx.hasUI) {
+				ctx.ui.notify("Publishing requires interactive confirmation.", "error");
+				return;
+			}
+			ctx.ui.setStatus("publish", "preparing release");
+			try {
+				await publish(pi, ctx);
+			} catch (error) {
+				ctx.ui.notify(`Publish failed: ${errorText(error)}`, "error");
+			} finally {
+				ctx.ui.setStatus("publish", undefined);
+				ctx.ui.setWidget("publish", undefined);
+			}
+		},
+	});
+}
+
+async function publish(pi: ExtensionAPI, ctx: ExtensionCommandContext): Promise<void> {
+	const git = createGitRunner(pi, ctx);
+	const repo = await loadRepoStatus(git);
+	if (!repo) throw new Error("No git repository found.");
+	if (repo.fileCount > 0)
+		throw new Error("Working tree is not clean. Commit or stash every change before publishing.");
+	await run(pi, ctx, "gh", ["auth", "status"], repo.root);
+
+	const manifests = await loadManifests(repo.root);
+	const currentVersion = sharedVersion(manifests);
+	const tag = await latestReleaseTag(git, repo.root);
+	const bump = await recommendBump(git, repo.root, tag);
+	const version = tag ? incrementVersion(currentVersion, bump) : currentVersion;
+	const selectedBump = await ctx.ui.select(`Release ${version}`, [
+		`Use recommended ${bump} bump`,
+		"Choose a different bump",
+		"Cancel",
+	]);
+	if (!selectedBump || selectedBump === "Cancel") return;
+
+	const finalBump =
+		selectedBump === "Choose a different bump"
+			? await ctx.ui.select("Release type", ["patch", "minor", "major"])
+			: bump;
+	if (!finalBump) return;
+	const finalVersion = tag ? incrementVersion(currentVersion, finalBump as Bump) : currentVersion;
+	const releaseTag = `v${finalVersion}`;
+	if (await tagExists(git, repo.root, releaseTag)) throw new Error(`Tag ${releaseTag} already exists.`);
+
+	const confirmed = await ctx.ui.confirm(
+		`Publish ${releaseTag}?`,
+		`This will push ${releaseTag}. GitHub Actions will publish @shanepadgett/tau-tui and @shanepadgett/tau-agent to npm.`,
+	);
+	if (!confirmed) return;
+
+	if (tag) await writeReleaseVersion(repo.root, manifests, finalVersion);
+	ctx.ui.setStatus("publish", "packing packages");
+	await run(pi, ctx, "npm", ["pack", "--dry-run", "--workspace", "@shanepadgett/tau-tui"], repo.root);
+	await run(pi, ctx, "npm", ["pack", "--dry-run", "--workspace", "@shanepadgett/tau-agent"], repo.root);
+
+	if (tag) {
+		await git.run(["add", ...PACKAGE_PATHS, LOCKFILE_PATH], { cwd: repo.root });
+		await git.run(["commit", "-m", `chore(release): ${releaseTag}`], { cwd: repo.root });
+	}
+	await git.run(["tag", releaseTag], { cwd: repo.root });
+	await git.run(["push", "origin", "HEAD"], { cwd: repo.root, timeout: 120_000 });
+	await git.run(["push", "origin", releaseTag], { cwd: repo.root, timeout: 120_000 });
+	await monitorWorkflow(pi, ctx, repo.root, await git.run(["rev-parse", "HEAD"], { cwd: repo.root }), releaseTag);
+}
+
+async function loadManifests(root: string): Promise<PackageManifest[]> {
+	return Promise.all(
+		PACKAGE_PATHS.map(async (path) => JSON.parse(await readFile(join(root, path), "utf8")) as PackageManifest),
+	);
+}
+
+function sharedVersion(manifests: readonly PackageManifest[]): string {
+	const versions = new Set(manifests.map((manifest) => manifest.version));
+	if (versions.size !== 1) throw new Error("Publishable packages must use the same version.");
+	const version = manifests[0]?.version;
+	if (!version || !/^\d+\.\d+\.\d+$/.test(version)) throw new Error("Package version must be stable semver.");
+	return version;
+}
+
+async function latestReleaseTag(git: GitRunner, root: string): Promise<string | undefined> {
+	const tags = await git.run(["tag", "--list", "v*", "--sort=-version:refname"], { cwd: root });
+	return tags.split("\n").find((tag) => /^v\d+\.\d+\.\d+$/.test(tag));
+}
+
+async function recommendBump(git: GitRunner, root: string, tag: string | undefined): Promise<Bump> {
+	const range = tag ? `${tag}..HEAD` : "HEAD";
+	const commits = await git.run(["log", "--format=%B%x00", range], { cwd: root });
+	if (/BREAKING CHANGE:|^[^\n]*!:/m.test(commits)) return "major";
+	if (/^feat(?:\([^\n]+\))?:/m.test(commits)) return "minor";
+	return "patch";
+}
+
+function incrementVersion(version: string, bump: Bump): string {
+	const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
+	if (!match) throw new Error(`Invalid version: ${version}`);
+	const major = Number(match[1]);
+	const minor = Number(match[2]);
+	const patch = Number(match[3]);
+	if (bump === "major") return `${major + 1}.0.0`;
+	if (bump === "minor") return `${major}.${minor + 1}.0`;
+	return `${major}.${minor}.${patch + 1}`;
+}
+
+async function tagExists(git: GitRunner, root: string, tag: string): Promise<boolean> {
+	return Boolean(await git.run(["tag", "--list", tag], { cwd: root }));
+}
+
+async function writeReleaseVersion(
+	root: string,
+	manifests: readonly PackageManifest[],
+	version: string,
+): Promise<void> {
+	for (const [index, path] of PACKAGE_PATHS.entries()) {
+		const manifest = manifests[index];
+		if (!manifest) throw new Error(`Missing package manifest: ${path}`);
+		manifest.version = version;
+		if (manifest.name === "@shanepadgett/tau-agent" && manifest.dependencies)
+			manifest.dependencies["@shanepadgett/tau-tui"] = version;
+		await writeFile(join(root, path), `${JSON.stringify(manifest, null, "\t")}\n`);
+	}
+	const lockfile = JSON.parse(await readFile(join(root, LOCKFILE_PATH), "utf8")) as {
+		packages: Record<string, PackageManifest>;
+	};
+	for (const path of PACKAGE_PATHS) {
+		const manifest = lockfile.packages[path];
+		if (!manifest) throw new Error(`Missing lockfile package: ${path}`);
+		manifest.version = version;
+		if (manifest.name === "@shanepadgett/tau-agent" && manifest.dependencies)
+			manifest.dependencies["@shanepadgett/tau-tui"] = version;
+	}
+	await writeFile(join(root, LOCKFILE_PATH), `${JSON.stringify(lockfile, null, "\t")}\n`);
+}
+
+async function run(
+	pi: ExtensionAPI,
+	ctx: ExtensionCommandContext,
+	command: string,
+	args: string[],
+	cwd: string,
+): Promise<string> {
+	const result = await pi.exec(command, args, { cwd, signal: ctx.signal, timeout: 120_000 });
+	if (result.code === 0) return result.stdout.trim();
+	throw new Error([result.stderr, result.stdout].filter(Boolean).join("\n").trim() || `${command} failed`);
+}
+
+async function monitorWorkflow(
+	pi: ExtensionAPI,
+	ctx: ExtensionCommandContext,
+	root: string,
+	sha: string,
+	tag: string,
+): Promise<void> {
+	const deadline = Date.now() + WORKFLOW_WAIT_MS;
+	while (Date.now() < deadline) {
+		const output = await run(
+			pi,
+			ctx,
+			"gh",
+			[
+				"run",
+				"list",
+				"--workflow",
+				WORKFLOW_NAME,
+				"--commit",
+				sha,
+				"--limit",
+				"1",
+				"--json",
+				"databaseId,status,conclusion,url",
+			],
+			root,
+		);
+		const workflowRun = (JSON.parse(output) as WorkflowRun[])[0];
+		if (workflowRun) {
+			ctx.ui.setWidget("publish", [`Release ${tag}`, `GitHub Actions: ${workflowRun.status}`, workflowRun.url]);
+			if (workflowRun.status === "completed") {
+				if (workflowRun.conclusion === "success") {
+					ctx.ui.notify(`Published ${tag}: ${workflowRun.url}`, "info");
+					return;
+				}
+				throw new Error(`GitHub Actions ${workflowRun.conclusion ?? "failed"}: ${workflowRun.url}`);
+			}
+		}
+		await new Promise<void>((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+	}
+	throw new Error(`Timed out waiting for GitHub Actions for ${tag}. Check the Actions tab.`);
+}

package/extensions/qna/README.md

@@ -0,0 +1,45 @@
+# qna Extension
+
+Structured question UI for blocked agent decisions.
+
+## Commands
+
+`/qna [context]` temporarily enables `ask_question` and sends a hidden instruction asking the agent to re-ask its last question with structured UI. Optional context is included as framing guidance for the question.
+
+## Tools
+
+Registers `ask_question`, inactive by default. It is enabled for `/qna`, then disabled after `ask_question` returns or the agent turn ends.
+
+Use only when missing user intent, preference, or constraint would materially change the next action. Supports:
+
+- `select`: one option or custom answer
+- `multi`: multiple options plus optional custom answer
+- `input`: free-form typed answer
+- `confirm`: fixed yes/no
+
+Selectable questions require real options, recommendation values, and an honest recommendation reason. User can add notes to real options.
+
+Every panel includes a final user-owned `Additional Context` tab. It is not part of the tool schema. Non-empty text returns as top-level `additionalContext`.
+
+## UI
+
+- Question tabs get a `•` suffix when answered. The final `Additional Context` tab gets `•` when it has text.
+- The final `Additional Context` tab is always present and uses Pi's native single-line input.
+- `select` and `confirm` render as pointer lists, with `✓` on the selected answer.
+- `multi` renders checkboxes.
+- `input` uses Pi's native single-line input.
+- Custom answers edit inline: move to "Type your own answer..." and type.
+- Notes render under option descriptions with `└─`.
+- `tab`/`←→` moves between questions and additional context.
+- `enter` advances through questions and submits from additional context. `alt+enter` submits anytime; unanswered questions are skipped.
+- Results render as a Markdown-style numbered question/answer list, plus an additional context section when supplied.
+
+## Layout
+
+- `index.ts`: Pi registration, schema, prompt guidance, renderers
+- `model.ts`: validation, normalized state, result building
+- `ui.ts`: custom TUI component
+
+## Skipped
+
+No settings, replay, persistence, notifications, interview workflow, or preview panes. Add when usage proves need.

package/extensions/qna/additional-context-body.ts

@@ -0,0 +1,51 @@
+import {
+	type Component,
+	type Focusable,
+	Input,
+	Key,
+	matchesKey,
+	truncateToWidth,
+	wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+import { type QnaState, saveAdditionalContext } from "./model.ts";
+
+export class AdditionalContextBody implements Component, Focusable {
+	private readonly getState: () => QnaState;
+	private readonly setState: (state: QnaState) => void;
+	private readonly submit: () => void;
+	private readonly input = new Input();
+
+	constructor(getState: () => QnaState, setState: (state: QnaState) => void, submit: () => void) {
+		this.getState = getState;
+		this.setState = setState;
+		this.submit = submit;
+	}
+
+	get focused(): boolean {
+		return this.input.focused;
+	}
+
+	set focused(value: boolean) {
+		this.input.focused = value;
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, Key.enter)) {
+			this.setState(saveAdditionalContext(this.getState(), this.input.getValue()));
+			this.submit();
+			return;
+		}
+		this.input.handleInput(data);
+		this.setState(saveAdditionalContext(this.getState(), this.input.getValue()));
+	}
+
+	render(width: number): string[] {
+		return [
+			...wrapTextWithAnsi("Any additional context for the agent? Optional.", width),
+			"",
+			...this.input.render(width).map((line) => truncateToWidth(line, width, "")),
+		];
+	}
+
+	invalidate(): void {}
+}

package/extensions/qna/body-render.ts

@@ -0,0 +1,6 @@
+import { wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import type { NormalizedQuestion } from "./model.ts";
+
+export function renderQuestionPrompt(question: NormalizedQuestion, width: number): string[] {
+	return [...wrapTextWithAnsi(question.prompt, width), ""];
+}