@xiliumz/pi-minimal 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Azaria Beryl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,79 @@
+# pi-minimal
+
+Bash-style prompt layout for [pi](https://pi.dev).
+
+```
+~/project (main*):
+$ |
+```
+
+No header. No footer. Session stats live behind `/info` or `F8`.
+
+## Install
+
+```bash
+# from git
+pi install git:github.com/xiliumz/pi-minimal
+
+# from a local checkout
+pi install /path/to/pi-minimal
+
+# from npm
+pi install npm:@xiliumz/pi-minimal
+```
+
+Restart pi or run `/reload`.
+
+## What you get
+
+| Piece | Behavior |
+| --- | --- |
+| Prompt | `~/path (branch*):` above `$ ` input — dirty tree shows `*` |
+| Spinner | Shown in the prompt while the agent runs |
+| Header / footer | Removed |
+| `/info` / `F8` | Model, thinking level, context %, tokens, cost, session file/id |
+
+Multiline input and slash-command autocomplete start at column 0 (under `$ `).
+Soft-wrapped continuations use the full terminal width — only the first visual line shares space with `$ `.
+
+## Notes
+
+`/new`, `/resume`, and `/fork` briefly flash the stock pi header/footer/editor.
+Pi resets extension UI before the old session context goes stale, then re-runs
+`session_start` so this layout comes back. Extension-side fix is not available.
+
+## Develop
+
+```bash
+git clone https://github.com/xiliumz/pi-minimal.git
+cd pi-minimal
+
+# point pi at the working tree (no copy)
+pi install "$PWD"
+
+# edit → /reload inside pi
+```
+
+Layout:
+
+```
+extensions/index.ts   # pi entry (registers hooks + commands)
+src/editor.ts         # bash prompt CustomEditor
+src/info.ts           # /info UI + token stats
+src/git.ts            # branch + dirty
+src/format.ts         # cwd/tokens helpers
+src/ui.ts             # empty header/footer component
+```
+
+## Uninstall
+
+```bash
+pi remove git:github.com/xiliumz/pi-minimal
+# or
+pi remove npm:@xiliumz/pi-minimal
+pi remove /path/to/pi-minimal
+```
+
+## License
+
+MIT

package/extensions/index.ts

@@ -0,0 +1,104 @@
+/**
+ * pi-minimal
+ *
+ * Bash-style prompt for pi:
+ *   ~/path (branch*):
+ *   $ |
+ *
+ * Header/footer chrome removed. Session stats via /info.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { TUI } from "@earendil-works/pi-tui";
+import { createBashPromptEditor } from "../src/editor.js";
+import { fetchGitState, type GitState } from "../src/git.js";
+import { showInfoUi } from "../src/info.js";
+import { EmptyComponent } from "../src/ui.js";
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+export default function bashLayoutExtension(pi: ExtensionAPI): void {
+	let activeTui: TUI | undefined;
+	let git: GitState = { dirty: false };
+	let isWorking = false;
+	let spinnerIndex = 0;
+	let spinnerTimer: ReturnType<typeof setInterval> | undefined;
+
+	const stopSpinner = () => {
+		if (spinnerTimer) {
+			clearInterval(spinnerTimer);
+			spinnerTimer = undefined;
+		}
+	};
+
+	const refreshGit = async (cwd: string) => {
+		git = await fetchGitState(pi, cwd);
+		activeTui?.requestRender();
+	};
+
+	const promptState = {
+		get git() {
+			return git;
+		},
+		get isWorking() {
+			return isWorking;
+		},
+		get spinnerFrame() {
+			return SPINNER_FRAMES[spinnerIndex]!;
+		},
+		onMount(tui: TUI) {
+			activeTui = tui;
+		},
+	};
+
+	pi.on("agent_start", () => {
+		isWorking = true;
+		stopSpinner();
+		spinnerTimer = setInterval(() => {
+			spinnerIndex = (spinnerIndex + 1) % SPINNER_FRAMES.length;
+			activeTui?.requestRender();
+		}, 80);
+		activeTui?.requestRender();
+	});
+
+	pi.on("agent_end", (_event, ctx) => {
+		isWorking = false;
+		stopSpinner();
+		if (ctx.mode === "tui") {
+			void refreshGit(ctx.cwd);
+		}
+		activeTui?.requestRender();
+	});
+
+	pi.on("session_shutdown", () => {
+		stopSpinner();
+		activeTui = undefined;
+	});
+
+	pi.on("session_start", (_event, ctx) => {
+		if (ctx.mode !== "tui") return;
+
+		ctx.ui.setHeader(() => new EmptyComponent());
+		ctx.ui.setFooter(() => new EmptyComponent());
+		ctx.ui.setWorkingVisible(false);
+
+		void refreshGit(ctx.cwd);
+
+		const Editor = createBashPromptEditor(ctx, promptState);
+		ctx.ui.setEditorComponent((tui, theme, keybindings) => new Editor(tui, theme, keybindings));
+	});
+
+	const showInfo = async (ctx: ExtensionContext) => {
+		await showInfoUi(ctx, pi.getThinkingLevel());
+	};
+
+	pi.registerCommand("info", {
+		description: "Show model, tokens, cost, and context usage for this session",
+		handler: (_args, ctx) => showInfo(ctx),
+	});
+
+	pi.registerShortcut("f8", {
+		description: "Show session info",
+		handler: showInfo,
+	});
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+	"name": "@xiliumz/pi-minimal",
+	"version": "1.0.0",
+	"description": "Bash-style prompt layout for pi — ~/path (branch*): with /info",
+	"type": "module",
+	"license": "MIT",
+	"author": "Azaria Beryl",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/xiliumz/pi-minimal.git"
+	},
+	"homepage": "https://github.com/xiliumz/pi-minimal#readme",
+	"bugs": {
+		"url": "https://github.com/xiliumz/pi-minimal/issues"
+	},
+	"keywords": [
+		"pi",
+		"extension",
+		"layout",
+		"minimal"
+	],
+	"engines": {
+		"node": ">=20"
+	},
+	"files": [
+		"extensions",
+		"src",
+		"README.md",
+		"LICENSE"
+	],
+	"pi": {
+		"extensions": [
+			"./extensions/index.ts"
+		]
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-ai": "*",
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*"
+	},
+	"scripts": {
+		"typecheck": "tsc --noEmit"
+	},
+	"devDependencies": {
+		"@earendil-works/pi-ai": "^0.83.0",
+		"@earendil-works/pi-coding-agent": "^0.83.0",
+		"@earendil-works/pi-tui": "^0.83.0",
+		"@types/node": "^26.1.2",
+		"typescript": "^7.0.2"
+	}
+}

package/src/cost.ts

@@ -0,0 +1,157 @@
+/**
+ * Cost section support for /info: cache re-billing (waste) and per-model
+ * cost breakdown.
+ *
+ * Port of pi-coding-agent internals — `core/cache-stats.ts` (computeCacheWaste)
+ * and `core/usage-totals.ts` (getUsageCostBreakdown) — neither is exported from
+ * the package root. Kept in sync manually with those files.
+ *
+ * Scope: the current branch's assistant-message usage, matching the
+ * "Tokens (branch)" stats in /info so the Cost section reconciles.
+ */
+
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+
+/** Per-turn misses at or below this are cache breakpoint granularity noise. */
+const NOISE_FLOOR_TOKENS = 1024;
+
+export interface CacheWasteTotals {
+	missedTokens: number;
+	missedCost: number;
+	/** Number of counted misses (turns above the noise floor). */
+	missCount: number;
+}
+
+export interface UsageCostBreakdownEntry {
+	key: string;
+	cost: number;
+	tokens: number;
+}
+
+/** Lite view of a session branch entry (structural subset of SessionEntry). */
+export interface BranchEntry {
+	type: string;
+	message?: {
+		role?: string;
+		provider?: string;
+		model?: string;
+		responseModel?: string;
+		content?: unknown;
+		usage?: AssistantMessage["usage"];
+	};
+}
+
+/** Minimal pricing lookup, satisfied by ModelRegistry. Cost is $/million tokens. */
+export interface ModelPriceSource {
+	find(provider: string, modelId: string): { cost: { cacheRead: number } } | undefined;
+}
+
+interface PrevRequest {
+	promptTokens: number;
+	reportedCache: boolean;
+}
+
+interface MissRecord {
+	missedTokens: number;
+	missedCost: number;
+}
+
+function detectMiss(
+	prev: PrevRequest | undefined,
+	msg: NonNullable<BranchEntry["message"]>,
+	models: ModelPriceSource,
+): MissRecord | undefined {
+	const usage = msg.usage;
+	if (!usage) return undefined;
+	const promptTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+	// A zero-cache turn only counts when cache activity was reported before:
+	// on cache-read-only providers that is a total miss, while on providers
+	// that never report caching it means nothing.
+	if (!prev || promptTokens <= 0 || (usage.cacheRead + usage.cacheWrite === 0 && !prev.reportedCache)) {
+		return undefined;
+	}
+	const missedTokens = Math.min(prev.promptTokens, promptTokens) - usage.cacheRead;
+	if (missedTokens <= NOISE_FLOOR_TOKENS) return undefined;
+
+	// Extra cost = missed tokens billed at the actual paid rate (input/cacheWrite,
+	// incl. write premium) instead of the cache-read rate. Missed tokens can only
+	// land in the input or cacheWrite buckets, so the paid rate comes straight
+	// from this message's own cost breakdown.
+	const paidTokens = usage.input + usage.cacheWrite;
+	const paidPerToken = paidTokens > 0 ? (usage.cost.input + usage.cost.cacheWrite) / paidTokens : 0;
+	const readPerToken =
+		usage.cacheRead > 0
+			? usage.cost.cacheRead / usage.cacheRead
+			: (models.find(msg.provider ?? "", msg.model ?? "")?.cost.cacheRead ?? 0) / 1_000_000;
+
+	return {
+		missedTokens,
+		missedCost: missedTokens * Math.max(0, paidPerToken - readPerToken),
+	};
+}
+
+function asPreviousRequest(
+	msg: NonNullable<BranchEntry["message"]>,
+	reportedCache: boolean,
+): PrevRequest | undefined {
+	const usage = msg.usage;
+	if (!usage) return undefined;
+	const promptTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+	if (promptTokens <= 0) return undefined;
+	return {
+		promptTokens,
+		reportedCache: reportedCache || usage.cacheRead + usage.cacheWrite > 0,
+	};
+}
+
+/**
+ * Cumulative cache waste across the branch: prompt tokens that should have been
+ * cache reads (they were in the previous turn's prompt) but were re-billed.
+ */
+export function computeCacheWaste(
+	entries: readonly BranchEntry[],
+	models: ModelPriceSource,
+): CacheWasteTotals {
+	let prev: PrevRequest | undefined;
+	const totals: CacheWasteTotals = { missedTokens: 0, missedCost: 0, missCount: 0 };
+	for (const entry of entries) {
+		if (entry.type === "compaction" || entry.type === "branch_summary") {
+			// The context legitimately changed; the next turn's prompt is new
+			// content, not re-billed content. Model switches are NOT exempt:
+			// they re-bill the full prompt and should be counted.
+			prev = undefined;
+			continue;
+		}
+		if (entry.type === "message" && entry.message?.role === "assistant") {
+			const miss = detectMiss(prev, entry.message, models);
+			if (miss) {
+				totals.missedTokens += miss.missedTokens;
+				totals.missedCost += miss.missedCost;
+				totals.missCount += 1;
+			}
+			prev = asPreviousRequest(entry.message, prev?.reportedCache ?? false) ?? prev;
+		}
+	}
+	return totals;
+}
+
+/**
+ * Group assistant usage by model (`provider/responseModel ?? model`), sorted by
+ * cost descending. Scoped to the branch so the lines reconcile with the Total.
+ */
+export function getUsageCostBreakdown(entries: readonly BranchEntry[]): UsageCostBreakdownEntry[] {
+	const costByKey = new Map<string, { cost: number; tokens: number }>();
+	for (const entry of entries) {
+		if (entry.type !== "message") continue;
+		const msg = entry.message;
+		if (msg?.role !== "assistant" || !msg.usage) continue;
+		const key = `${msg.provider ?? ""}/${msg.responseModel ?? msg.model ?? ""}`;
+		const totals = costByKey.get(key) ?? { cost: 0, tokens: 0 };
+		totals.cost += msg.usage.cost.total;
+		totals.tokens += msg.usage.input + msg.usage.output + msg.usage.cacheRead + msg.usage.cacheWrite;
+		costByKey.set(key, totals);
+	}
+	return Array.from(costByKey, ([key, totals]) => ({ key, ...totals }))
+		.filter((entry) => entry.cost > 0 || entry.tokens > 0)
+		.sort((a, b) => b.cost - a.cost);
+}

package/src/editor.ts

@@ -0,0 +1,230 @@
+import {
+	CustomEditor,
+	type ExtensionContext,
+	type KeybindingsManager,
+	type Theme,
+} from "@earendil-works/pi-coding-agent";
+import type { EditorTheme, TUI } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import {
+	formatCwd,
+	isBorderOrScrollLine,
+	wordWrapLineVariable,
+	type GraphemeSeg,
+	type WrapChunk,
+} from "./format.js";
+import type { GitState } from "./git.js";
+
+export interface BashPromptState {
+	git: GitState;
+	isWorking: boolean;
+	spinnerFrame: string;
+	/** Called when the editor mounts so the extension can request re-renders. */
+	onMount: (tui: TUI) => void;
+}
+
+/** Subset of Editor internals used for dual-width soft-wrap. */
+interface EditorInternals {
+	state: { lines: string[]; cursorLine: number; cursorCol: number };
+	scrollOffset: number;
+	segment(text: string, mode: "word" | "grapheme"): Iterable<{ segment: string; index: number }>;
+}
+
+interface LayoutLine {
+	text: string;
+	hasCursor: boolean;
+	cursorPos?: number;
+}
+
+/**
+ * Borderless editor with path above the input:
+ *   ~/path (branch*):
+ *   $ |
+ *
+ * Soft-wrap: first visual line reserves space for `$ `; every continuation
+ * line uses the full terminal width at column 0.
+ * Slash/path autocomplete also renders at column 0, full width.
+ */
+export function createBashPromptEditor(
+	ctx: ExtensionContext,
+	state: BashPromptState,
+): new (tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) => CustomEditor {
+	return class BashPromptEditor extends CustomEditor {
+		/** Columns reserved on the first visual line for `$ `. */
+		private promptInset = 0;
+
+		constructor(tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) {
+			super(tui, theme, keybindings, { paddingX: 0 });
+			// pi-tui's Editor declares `private layoutText`; TS forbids a subclass
+			// member with that name (TS2415/TS2322), but JS ignores `private` at
+			// runtime — so install the override as an instance property instead.
+			(this as unknown as { layoutText: (contentWidth: number) => LayoutLine[] })
+				.layoutText = (contentWidth) => this.layoutWithInset(contentWidth);
+			state.onMount(tui);
+		}
+
+		/** Host may push settings padding — keep 0 so prompt math stays correct. */
+		override setPaddingX(_paddingX: number): void {
+			super.setPaddingX(0);
+		}
+
+		private promptString(): string {
+			const thm = ctx.ui.theme as Theme;
+			const cwd = formatCwd(ctx.cwd);
+			const branch = state.git.branch
+				? thm.fg("muted", ` (${state.git.branch}${state.git.dirty ? "*" : ""})`)
+				: "";
+			const path = thm.fg("success", cwd);
+			const working = state.isWorking
+				? thm.fg("accent", `${state.spinnerFrame} `)
+				: "";
+			return `${working}${path}${branch}${thm.fg("dim", ":")}`;
+		}
+
+		private internals(): EditorInternals {
+			return this as unknown as EditorInternals;
+		}
+
+		/**
+		 * Same shape as Editor.layoutText, but the first logical line's first chunk
+		 * is narrowed by `promptInset` so `$ ` fits on that row. Soft-wrap
+		 * continuations (and later hard lines) use the full `contentWidth`.
+		 * Installed as the runtime `layoutText` override in the constructor.
+		 */
+		layoutWithInset(contentWidth: number): LayoutLine[] {
+			// Keep method calls on `ed` so `segment` retains Editor as `this`
+			// (it calls `this.validPasteIds()` internally).
+			const ed = this.internals();
+			const layoutLines: LayoutLine[] = [];
+			const inset = Math.max(0, this.promptInset);
+			const firstWidth = Math.max(1, contentWidth - inset);
+
+			if (ed.state.lines.length === 0 || (ed.state.lines.length === 1 && ed.state.lines[0] === "")) {
+				layoutLines.push({ text: "", hasCursor: true, cursorPos: 0 });
+				return layoutLines;
+			}
+
+			for (let i = 0; i < ed.state.lines.length; i++) {
+				const line = ed.state.lines[i] || "";
+				const isCurrentLine = i === ed.state.cursorLine;
+				const lineVisibleWidth = visibleWidth(line);
+				// Only the very first logical line pays the `$ ` tax, and only on
+				// its first visual chunk. Hard-newline lines are full width.
+				const useInset = i === 0 && inset > 0;
+				const fitsSingle =
+					lineVisibleWidth <= (useInset ? firstWidth : contentWidth);
+
+				if (fitsSingle) {
+					if (isCurrentLine) {
+						layoutLines.push({
+							text: line,
+							hasCursor: true,
+							cursorPos: ed.state.cursorCol,
+						});
+					} else {
+						layoutLines.push({ text: line, hasCursor: false });
+					}
+					continue;
+				}
+
+				const graphemes: GraphemeSeg[] = [...ed.segment(line, "grapheme")].map((s) => ({
+					segment: s.segment,
+					index: s.index,
+				}));
+				const chunks: WrapChunk[] = useInset
+					? wordWrapLineVariable(line, firstWidth, contentWidth, graphemes)
+					: wordWrapLineVariable(line, contentWidth, contentWidth, graphemes);
+
+				for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+					const chunk = chunks[chunkIndex]!;
+					const isLastChunk = chunkIndex === chunks.length - 1;
+					let hasCursorInChunk = false;
+					let adjustedCursorPos = 0;
+
+					if (isCurrentLine) {
+						const cursorPos = ed.state.cursorCol;
+						if (isLastChunk) {
+							hasCursorInChunk = cursorPos >= chunk.startIndex;
+							adjustedCursorPos = cursorPos - chunk.startIndex;
+						} else {
+							hasCursorInChunk =
+								cursorPos >= chunk.startIndex && cursorPos < chunk.endIndex;
+							if (hasCursorInChunk) {
+								adjustedCursorPos = cursorPos - chunk.startIndex;
+								if (adjustedCursorPos > chunk.text.length) {
+									adjustedCursorPos = chunk.text.length;
+								}
+							}
+						}
+					}
+
+					if (hasCursorInChunk) {
+						layoutLines.push({
+							text: chunk.text,
+							hasCursor: true,
+							cursorPos: adjustedCursorPos,
+						});
+					} else {
+						layoutLines.push({ text: chunk.text, hasCursor: false });
+					}
+				}
+			}
+
+			return layoutLines;
+		}
+
+		render(width: number): string[] {
+			const prompt = truncateToWidth(this.promptString(), width, "");
+			const inputPrefix = width >= 3 ? "$ " : "";
+			this.promptInset = inputPrefix.length;
+
+			// Full terminal width — layoutText narrows only the first visual chunk.
+			const raw = super.render(width);
+			this.promptInset = 0;
+
+			if (raw.length === 0) return [prompt];
+
+			// raw: [topBorder, ...content, bottomBorder, ...autocomplete?]
+			const withoutTop = raw.slice(1);
+			if (withoutTop.length === 0) return [prompt];
+
+			let borderIdx = -1;
+			for (let i = withoutTop.length - 1; i >= 0; i--) {
+				if (isBorderOrScrollLine(withoutTop[i]!)) {
+					borderIdx = i;
+					break;
+				}
+			}
+
+			const content = borderIdx >= 0 ? withoutTop.slice(0, borderIdx) : withoutTop;
+			const out: string[] = [prompt];
+			const scrolled = this.internals().scrollOffset > 0;
+			// First content row is padded to full width by Editor; keep only the
+			// budget to the right of `$ `, then splice the prefix in.
+			const firstBudget = Math.max(1, width - inputPrefix.length);
+
+			for (let i = 0; i < content.length; i++) {
+				const line = content[i]!;
+				if (i === 0 && !scrolled) {
+					const body = truncateToWidth(line, firstBudget, "");
+					out.push(truncateToWidth(inputPrefix + body, width, ""));
+				} else {
+					// Column 0 — full width for wrapped and hard-newline continuations.
+					out.push(truncateToWidth(line, width, ""));
+				}
+			}
+
+			// Autocomplete at column 0, full terminal width.
+			const acList = (
+				this as unknown as { autocompleteList?: { render: (w: number) => string[] } }
+			).autocompleteList;
+			if (this.isShowingAutocomplete() && acList) {
+				for (const line of acList.render(width)) {
+					out.push(truncateToWidth(line, width, ""));
+				}
+			}
+
+			return out;
+		}
+	};
+}

package/src/format.ts

@@ -0,0 +1,126 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+
+export function stripAnsi(s: string): string {
+	return s.replace(ANSI_RE, "");
+}
+
+/** Editor top/bottom chrome or scroll indicators from CustomEditor.render(). */
+export function isBorderOrScrollLine(line: string): boolean {
+	const plain = stripAnsi(line).trim();
+	if (!plain) return true;
+	if (/^─+$/.test(plain)) return true;
+	if (/^─+\s*[↑↓]/.test(plain)) return true;
+	return false;
+}
+
+export interface WrapChunk {
+	text: string;
+	startIndex: number;
+	endIndex: number;
+}
+
+export interface GraphemeSeg {
+	segment: string;
+	index: number;
+}
+
+/**
+ * Soft-wrap one logical line.
+ * `firstWidth` applies only to the first visual chunk (room for a same-line prompt);
+ * later chunks use `restWidth` (full editor width).
+ */
+export function wordWrapLineVariable(
+	line: string,
+	firstWidth: number,
+	restWidth: number,
+	preSegmented?: GraphemeSeg[],
+): WrapChunk[] {
+	if (!line) {
+		return [{ text: "", startIndex: 0, endIndex: 0 }];
+	}
+	const first = Math.max(1, firstWidth);
+	const rest = Math.max(1, restWidth);
+	const segments =
+		preSegmented ??
+		[...new Intl.Segmenter(undefined, { granularity: "grapheme" }).segment(line)].map((s) => ({
+			segment: s.segment,
+			index: s.index,
+		}));
+
+	const chunks: WrapChunk[] = [];
+	let maxWidth = first;
+	let currentWidth = 0;
+	let chunkStart = 0;
+	let wrapOppIndex = -1;
+	let wrapOppWidth = 0;
+
+	const pushChunk = (end: number) => {
+		chunks.push({ text: line.slice(chunkStart, end), startIndex: chunkStart, endIndex: end });
+		// After the first visual line, continuations get the full width.
+		maxWidth = rest;
+	};
+
+	for (let i = 0; i < segments.length; i++) {
+		const seg = segments[i]!;
+		const grapheme = seg.segment;
+		const gWidth = visibleWidth(grapheme);
+		const charIndex = seg.index;
+		const isWs = /\s/.test(grapheme);
+
+		if (currentWidth + gWidth > maxWidth) {
+			if (wrapOppIndex >= 0 && currentWidth - wrapOppWidth + gWidth <= maxWidth) {
+				pushChunk(wrapOppIndex);
+				chunkStart = wrapOppIndex;
+				currentWidth -= wrapOppWidth;
+			} else if (chunkStart < charIndex) {
+				pushChunk(charIndex);
+				chunkStart = charIndex;
+				currentWidth = 0;
+			}
+			wrapOppIndex = -1;
+			wrapOppWidth = 0;
+		}
+
+		// Single grapheme wider than the line — hard-split by force.
+		if (gWidth > maxWidth) {
+			if (chunkStart < charIndex) {
+				pushChunk(charIndex);
+				chunkStart = charIndex;
+			}
+			// Put the oversized grapheme on its own chunk and continue.
+			pushChunk(charIndex + grapheme.length);
+			chunkStart = charIndex + grapheme.length;
+			currentWidth = 0;
+			wrapOppIndex = -1;
+			wrapOppWidth = 0;
+			continue;
+		}
+
+		currentWidth += gWidth;
+		const next = segments[i + 1];
+		if (isWs && next && !/\s/.test(next.segment)) {
+			// Prefer breaking after a whitespace run (at the start of the next word).
+			wrapOppIndex = next.index;
+			wrapOppWidth = currentWidth;
+		}
+	}
+
+	chunks.push({ text: line.slice(chunkStart), startIndex: chunkStart, endIndex: line.length });
+	return chunks.length > 0 ? chunks : [{ text: "", startIndex: 0, endIndex: 0 }];
+}
+
+export function formatCwd(cwd: string): string {
+	const home = process.env.HOME;
+	if (home && cwd.startsWith(home)) {
+		return `~${cwd.slice(home.length)}`;
+	}
+	return cwd;
+}
+
+export function formatTokens(n: number): string {
+	if (n < 1000) return `${n}`;
+	if (n < 1_000_000) return `${(n / 1000).toFixed(n < 10_000 ? 1 : 0)}k`;
+	return `${(n / 1_000_000).toFixed(2)}M`;
+}

package/src/git.ts

@@ -0,0 +1,21 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export interface GitState {
+	branch?: string;
+	dirty: boolean;
+}
+
+export async function fetchGitState(pi: ExtensionAPI, cwd: string): Promise<GitState> {
+	try {
+		const branchResult = await pi.exec("git", ["branch", "--show-current"], { cwd });
+		const branch = branchResult?.stdout?.trim() || undefined;
+
+		const dirtyResult = await pi.exec("git", ["status", "--porcelain"], { cwd });
+		const dirty = Boolean(dirtyResult?.stdout?.trim());
+
+		return { branch: branch || undefined, dirty };
+	} catch {
+		// Stale ctx after reload/session replace, or non-git cwd.
+		return { dirty: false };
+	}
+}

package/src/info.ts

@@ -0,0 +1,189 @@
+import type {
+	ExtensionContext,
+	Theme,
+} from "@earendil-works/pi-coding-agent";
+import { matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+import { computeCacheWaste, getUsageCostBreakdown, type BranchEntry } from "./cost.js";
+import { formatCwd, formatTokens } from "./format.js";
+
+interface TokenStats {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	cost: number;
+	assistantMessages: number;
+	userMessages: number;
+	toolCalls: number;
+}
+
+type SessionManagerLite = {
+	getBranch: () => ReadonlyArray<BranchEntry>;
+	getSessionName?: () => string | undefined;
+	getSessionFile?: () => string | undefined;
+	getSessionId?: () => string | undefined;
+};
+
+function collectTokenStats(branch: ReadonlyArray<BranchEntry>): TokenStats {
+	let input = 0;
+	let output = 0;
+	let cacheRead = 0;
+	let cacheWrite = 0;
+	let cost = 0;
+	let assistantMessages = 0;
+	let userMessages = 0;
+	let toolCalls = 0;
+
+	for (const entry of branch) {
+		if (entry.type !== "message" || !entry.message) continue;
+		const msg = entry.message;
+		if (msg.role === "user") {
+			userMessages++;
+			continue;
+		}
+		if (msg.role !== "assistant") continue;
+
+		assistantMessages++;
+		input += msg.usage?.input ?? 0;
+		output += msg.usage?.output ?? 0;
+		cacheRead += msg.usage?.cacheRead ?? 0;
+		cacheWrite += msg.usage?.cacheWrite ?? 0;
+		cost += msg.usage?.cost?.total ?? 0;
+		if (Array.isArray(msg.content)) {
+			toolCalls += msg.content.filter(
+				(c) => typeof c === "object" && c !== null && (c as { type?: string }).type === "toolCall",
+			).length;
+		}
+	}
+
+	return { input, output, cacheRead, cacheWrite, cost, assistantMessages, userMessages, toolCalls };
+}
+
+export function buildInfoLines(
+	ctx: ExtensionContext,
+	theme: Theme,
+	thinkingLevel: string,
+): string[] {
+	const sm = ctx.sessionManager as SessionManagerLite;
+	const branch = sm.getBranch();
+	const stats = collectTokenStats(branch);
+	const waste = computeCacheWaste(branch, ctx.modelRegistry);
+	const costBreakdown = getUsageCostBreakdown(branch);
+	const usage = ctx.getContextUsage();
+	const model = ctx.model;
+	const dim = (s: string) => theme.fg("dim", s);
+	const label = (k: string, v: string) => `${dim(k.padEnd(14))} ${v}`;
+	const lines: string[] = [];
+
+	lines.push(theme.bold("Session"));
+	const sessionName = sm.getSessionName?.();
+	if (sessionName) lines.push(label("Name", sessionName));
+	lines.push(label("File", sm.getSessionFile?.() ?? "in-memory"));
+	const sessionId = sm.getSessionId?.();
+	if (sessionId) lines.push(label("ID", sessionId));
+	lines.push(label("Cwd", formatCwd(ctx.cwd)));
+	lines.push("");
+
+	lines.push(theme.bold("Model"));
+	lines.push(label("Model", model ? `${model.provider}/${model.id}` : "none"));
+	lines.push(label("Thinking", thinkingLevel));
+	if (model?.contextWindow) {
+		lines.push(label("Window", formatTokens(model.contextWindow)));
+	}
+	lines.push("");
+
+	lines.push(theme.bold("Context"));
+	if (usage?.percent != null && usage.tokens != null) {
+		lines.push(
+			label(
+				"Used",
+				`${formatTokens(usage.tokens)} / ${formatTokens(usage.contextWindow)} (${Math.round(usage.percent)}%)`,
+			),
+		);
+	} else if (usage?.contextWindow) {
+		lines.push(label("Window", formatTokens(usage.contextWindow)));
+		lines.push(label("Used", "n/a (no estimate yet)"));
+	} else {
+		lines.push(label("Used", "n/a"));
+	}
+	lines.push("");
+
+	lines.push(theme.bold("Tokens (branch)"));
+	const promptTokens = stats.input + stats.cacheRead + stats.cacheWrite;
+	lines.push(label("Input", formatTokens(promptTokens)));
+	if (promptTokens > 0 && (stats.cacheRead > 0 || stats.cacheWrite > 0)) {
+		const hit = ((stats.cacheRead / promptTokens) * 100).toFixed(1);
+		lines.push(label("  cached", `${formatTokens(stats.cacheRead)} (${hit}%)`));
+		lines.push(label("  uncached", formatTokens(stats.input + stats.cacheWrite)));
+	}
+	lines.push(label("Output", formatTokens(stats.output)));
+	lines.push(
+		label("Total", formatTokens(stats.input + stats.output + stats.cacheRead + stats.cacheWrite)),
+	);
+	lines.push("");
+
+	if (stats.cost > 0 || waste.missedTokens > 0) {
+		lines.push(theme.bold("Cost"));
+		lines.push(`${dim("Total:")} $${stats.cost.toFixed(3)}`);
+		if (costBreakdown.length > 1) {
+			for (const entry of costBreakdown) {
+				lines.push(
+					`  ${dim(`${entry.key}:`)} $${entry.cost.toFixed(3)} ${dim(`(${formatTokens(entry.tokens)} tokens)`)}`,
+				);
+			}
+		}
+		if (waste.missedTokens > 0) {
+			const missLabel = waste.missCount === 1 ? "1 miss" : `${waste.missCount} misses`;
+			lines.push(
+				`${dim("Cache Re-billed:")} $${waste.missedCost.toFixed(3)} ${dim(`(${waste.missedTokens.toLocaleString()} tokens, ${missLabel})`)}`,
+			);
+		}
+		lines.push("");
+	}
+
+	lines.push(theme.bold("Messages (branch)"));
+	lines.push(label("User", `${stats.userMessages}`));
+	lines.push(label("Assistant", `${stats.assistantMessages}`));
+	lines.push(label("Tool calls", `${stats.toolCalls}`));
+
+	return lines;
+}
+
+export async function showInfoUi(
+	ctx: ExtensionContext,
+	thinkingLevel: string,
+): Promise<void> {
+	if (ctx.mode !== "tui" || !ctx.hasUI) {
+		const plainTheme = {
+			bold: (s: string) => s,
+			fg: (_c: string, s: string) => s,
+		} as Theme;
+		ctx.ui.notify(buildInfoLines(ctx, plainTheme, thinkingLevel).join("\n"), "info");
+		return;
+	}
+
+	await ctx.ui.custom((tui, theme, _kb, done) => {
+		const body = buildInfoLines(ctx, theme, thinkingLevel);
+		return {
+			render(width: number): string[] {
+				const out: string[] = [""];
+				out.push(truncateToWidth(theme.fg("accent", theme.bold(" /info ")), width));
+				out.push(truncateToWidth(theme.fg("dim", "─".repeat(Math.min(width, 40))), width));
+				for (const line of body) {
+					out.push(truncateToWidth(line, width));
+				}
+				out.push("");
+				out.push(truncateToWidth(theme.fg("dim", "Enter/Esc to close"), width));
+				out.push("");
+				return out;
+			},
+			invalidate() {},
+			handleInput(data: string) {
+				if (matchesKey(data, "enter") || matchesKey(data, "escape")) {
+					done(undefined);
+					tui.requestRender();
+				}
+			},
+		};
+	});
+}

package/src/ui.ts

@@ -0,0 +1,9 @@
+import type { Component } from "@earendil-works/pi-tui";
+
+/** Zero-height component used to blank header/footer chrome. */
+export class EmptyComponent implements Component {
+	render(): string[] {
+		return [];
+	}
+	invalidate(): void {}
+}