pi-dev-team 0.2.0

package/extensions/dev-team/lib/tools-misc.ts

@@ -0,0 +1,152 @@
+/**
+ * Small tools the dev-team content expects from Claude Code:
+ *   ask_user  — AskUserQuestion (human gates in /plan, /specs, /build, /setup, ...)
+ *   web_fetch — WebFetch (source-verification, competitive-analysis)
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+
+const OptionSchema = Type.Object({
+	label: Type.String(),
+	description: Type.Optional(Type.String()),
+});
+
+const QuestionSchema = Type.Object({
+	question: Type.String({ description: "The question to ask" }),
+	header: Type.Optional(Type.String({ description: "Short label" })),
+	options: Type.Optional(Type.Array(OptionSchema, { description: "Choices; omit for a free-text answer" })),
+	multiSelect: Type.Optional(Type.Boolean()),
+});
+
+const AskParams = Type.Object({
+	question: Type.Optional(Type.String({ description: "Single question (or use `questions`)" })),
+	options: Type.Optional(Type.Array(Type.Union([Type.String(), OptionSchema]))),
+	multiSelect: Type.Optional(Type.Boolean()),
+	questions: Type.Optional(Type.Array(QuestionSchema, { description: "Several questions (Claude AskUserQuestion shape)" })),
+});
+
+type Q = { question: string; header?: string; options?: { label: string; description?: string }[]; multiSelect?: boolean };
+
+const OTHER = "Other (type an answer)";
+
+async function askOne(q: Q, ctx: ExtensionContext): Promise<string | undefined> {
+	const title = q.header ? `${q.header}: ${q.question}` : q.question;
+	if (!q.options?.length) return ctx.ui.input(title);
+	const labels = q.options.map((o) => (o.description ? `${o.label} — ${o.description}` : o.label));
+	if (q.multiSelect) {
+		const listing = labels.map((l, i) => `${i + 1}. ${l}`).join("\n");
+		const raw = await ctx.ui.input(`${title}\n${listing}\nEnter numbers separated by commas, or free text`);
+		if (raw === undefined) return undefined;
+		const picks = raw
+			.split(",")
+			.map((s) => Number(s.trim()))
+			.filter((n) => Number.isInteger(n) && n >= 1 && n <= labels.length);
+		return picks.length ? picks.map((n) => q.options?.[n - 1]?.label).join(", ") : raw;
+	}
+	const choice = await ctx.ui.select(title, [...labels, OTHER]);
+	if (choice === undefined) return undefined;
+	if (choice === OTHER) return ctx.ui.input(title);
+	return q.options[labels.indexOf(choice)]?.label ?? choice;
+}
+
+export function registerAskUser(pi: ExtensionAPI): void {
+	pi.registerTool({
+		name: "ask_user",
+		label: "Ask user",
+		description:
+			"Ask the human one or more questions (Claude Code's AskUserQuestion). Use for dev-team human gates: approvals, ambiguity resolution, choices. In non-interactive runs it returns that no human is attached; then take the documented non-interactive default.",
+		promptSnippet: "Ask the human a question (AskUserQuestion equivalent)",
+		parameters: AskParams,
+		executionMode: "sequential",
+		// It asks the human, so only the model may call it, never a codemode script.
+		exposure: "model-only",
+		annotations: { readOnlyHint: true, openWorldHint: false },
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const questions: Q[] = params.questions?.length
+				? (params.questions as Q[])
+				: params.question
+					? [
+							{
+								question: params.question,
+								options: params.options?.map((o) => (typeof o === "string" ? { label: o } : o)),
+								multiSelect: params.multiSelect,
+							},
+						]
+					: [];
+			if (!questions.length) throw new Error("Provide `question` or `questions`.");
+			if (!ctx.hasUI || process.env.DEV_TEAM_INTERACTIVE !== "1") {
+				return {
+					content: [
+						{
+							type: "text",
+							text: "NON-INTERACTIVE: no human is attached to this run. Do not wait. Apply the documented non-interactive default for this gate and record that you did.",
+						},
+					],
+					details: { answered: false },
+				};
+			}
+			const answers: { question: string; answer: string | null }[] = [];
+			for (const q of questions) {
+				const a = await askOne(q, ctx);
+				answers.push({ question: q.question, answer: a ?? null });
+			}
+			const text = answers.map((a) => `Q: ${a.question}\nA: ${a.answer ?? "(dismissed — no answer)"}`).join("\n\n");
+			return { content: [{ type: "text", text }], details: { answered: true, answers } };
+		},
+	});
+}
+
+function htmlToText(html: string): string {
+	return html
+		.replace(/<script[\s\S]*?<\/script>/gi, "")
+		.replace(/<style[\s\S]*?<\/style>/gi, "")
+		.replace(/<noscript[\s\S]*?<\/noscript>/gi, "")
+		.replace(/<(br|\/p|\/div|\/li|\/h[1-6]|\/tr)>/gi, "\n")
+		.replace(/<li[^>]*>/gi, "- ")
+		.replace(/<[^>]+>/g, "")
+		.replace(/&nbsp;/g, " ")
+		.replace(/&amp;/g, "&")
+		.replace(/&lt;/g, "<")
+		.replace(/&gt;/g, ">")
+		.replace(/&quot;/g, '"')
+		.replace(/&#39;/g, "'")
+		.replace(/[ \t]+/g, " ")
+		.replace(/\n\s*\n\s*\n+/g, "\n\n")
+		.trim();
+}
+
+const FETCH_CAP = 60_000;
+
+export function registerWebFetch(pi: ExtensionAPI): void {
+	pi.registerTool({
+		name: "web_fetch",
+		label: "Web fetch",
+		description:
+			"Fetch a URL and return its text (Claude Code's WebFetch). HTML is converted to plain text; output is capped. `prompt` states what you are looking for; extract it yourself from the returned text.",
+		promptSnippet: "Fetch a web page as text (WebFetch equivalent)",
+		parameters: Type.Object({
+			url: Type.String({ description: "http(s) URL" }),
+			prompt: Type.Optional(Type.String({ description: "What to look for in the page" })),
+		}),
+		annotations: { readOnlyHint: true, openWorldHint: true },
+		async execute(_id, params, signal) {
+			const url = params.url.replace(/^http:\/\//, "https://");
+			const controller = new AbortController();
+			const timer = setTimeout(() => controller.abort(), 30_000);
+			signal?.addEventListener("abort", () => controller.abort(), { once: true });
+			try {
+				const res = await fetch(url, { signal: controller.signal, redirect: "follow", headers: { "user-agent": "pi-dev-team/1.0" } });
+				const type = res.headers.get("content-type") ?? "";
+				const raw = await res.text();
+				let text = type.includes("html") ? htmlToText(raw) : raw;
+				const truncated = text.length > FETCH_CAP;
+				if (truncated) text = `${text.slice(0, FETCH_CAP)}\n\n[truncated: ${text.length - FETCH_CAP} more characters]`;
+				const head = `URL: ${res.url}\nStatus: ${res.status}\nContent-Type: ${type}${params.prompt ? `\nLooking for: ${params.prompt}` : ""}\n\n`;
+				if (!res.ok) throw new Error(`${head}HTTP ${res.status}`);
+				return { content: [{ type: "text", text: head + text }], details: { status: res.status, truncated } };
+			} finally {
+				clearTimeout(timer);
+			}
+		},
+	});
+}

package/extensions/dev-team/lib/transcript.ts

@@ -0,0 +1,110 @@
+/**
+ * Synthetic Claude Code subagent transcripts.
+ *
+ * The SubagentStop hooks (review_verdict_recorder.py, subagent_completion_guard.py,
+ * task_completion_metrics.py) read a Claude-format sidechain transcript: the first record is the
+ * dispatch prompt (user turn), assistant records carry `attributionAgent`, `message.content` blocks,
+ * `message.stop_reason` and `message.usage`. pi children run with --no-session, so the subagent tool
+ * records the child's JSON event stream and writes this equivalent file before firing SubagentStop.
+ */
+import { writeSessionFile } from "./session-files.ts";
+
+interface PiContentBlock {
+	type: string;
+	text?: string;
+	name?: string;
+	id?: string;
+	arguments?: unknown;
+	thinking?: string;
+}
+
+export interface PiMessageLike {
+	role: string;
+	content?: unknown;
+	model?: string;
+	stopReason?: string;
+	toolCallId?: string;
+	toolName?: string;
+	isError?: boolean;
+	usage?: { input?: number; output?: number; cacheRead?: number; cacheWrite?: number };
+}
+
+const STOP_MAP: Record<string, string | null> = {
+	stop: "end_turn",
+	toolUse: "tool_use",
+	length: "max_tokens",
+	error: null,
+	aborted: null,
+};
+
+function contentBlocks(content: unknown): PiContentBlock[] {
+	if (typeof content === "string") return [{ type: "text", text: content }];
+	return Array.isArray(content) ? (content as PiContentBlock[]) : [];
+}
+
+export function buildTranscriptLines(opts: {
+	agentName: string;
+	agentId: string;
+	sessionId: string;
+	cwd: string;
+	prompt: string;
+	messages: PiMessageLike[];
+}): string[] {
+	const base = { isSidechain: true, agentId: opts.agentId, sessionId: opts.sessionId, cwd: opts.cwd };
+	const attribution = `dev-team:${opts.agentName}`;
+	const lines: string[] = [
+		JSON.stringify({ ...base, type: "user", message: { role: "user", content: opts.prompt } }),
+	];
+	for (const m of opts.messages) {
+		if (m.role === "assistant") {
+			const blocks = contentBlocks(m.content)
+				.map((b) => {
+					if (b.type === "text") return { type: "text", text: b.text ?? "" };
+					if (b.type === "toolCall") return { type: "tool_use", id: b.id, name: b.name, input: b.arguments ?? {} };
+					if (b.type === "thinking") return { type: "thinking", thinking: b.thinking ?? "" };
+					return undefined;
+				})
+				.filter(Boolean);
+			const u = m.usage ?? {};
+			lines.push(
+				JSON.stringify({
+					...base,
+					type: "assistant",
+					attributionAgent: attribution,
+					message: {
+						role: "assistant",
+						model: m.model,
+						content: blocks,
+						stop_reason: m.stopReason ? (STOP_MAP[m.stopReason] ?? null) : null,
+						usage: {
+							input_tokens: u.input ?? 0,
+							output_tokens: u.output ?? 0,
+							cache_read_input_tokens: u.cacheRead ?? 0,
+							cache_creation_input_tokens: u.cacheWrite ?? 0,
+						},
+					},
+				}),
+			);
+		} else if (m.role === "toolResult") {
+			const text = contentBlocks(m.content)
+				.filter((b) => b.type === "text")
+				.map((b) => b.text ?? "")
+				.join("\n");
+			lines.push(
+				JSON.stringify({
+					...base,
+					type: "user",
+					message: {
+						role: "user",
+						content: [{ type: "tool_result", tool_use_id: m.toolCallId, content: text, is_error: !!m.isError }],
+					},
+				}),
+			);
+		}
+	}
+	return lines;
+}
+
+export function writeTranscript(sessionId: string, agentId: string, lines: string[]): string {
+	return writeSessionFile(sessionId, "subagents", `agent-${agentId}.jsonl`, `${lines.join("\n")}\n`);
+}

package/extensions/dev-team/lib/trust.ts

@@ -0,0 +1,52 @@
+/**
+ * How this session's pi trust decision reaches the pi processes it starts (dev_team_subagent children
+ * and the claude shim). pi decides trust per working directory, so a granted decision covers exactly
+ * the session's directory, plus a worktree this session created of the repository rooted there. A
+ * declined decision is always forwarded, so a saved /trust entry or defaultProjectTrust cannot
+ * re-trust a child. Everywhere else the child decides for itself.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+/** The directory as pi sees it: symlinks resolved, or just resolved when it does not exist. */
+export function canonicalDir(dir: string): string {
+	try {
+		return fs.realpathSync(dir);
+	} catch {
+		return path.resolve(dir);
+	}
+}
+
+export interface ChildTrust {
+	/** pi's decision for the session (ctx.isProjectTrusted()). */
+	projectTrusted: boolean;
+	/** canonicalDir(ctx.cwd): the directory that decision is for. */
+	sessionDir: string;
+}
+
+/** This session's decision, as children inherit it. */
+export function childTrustOf(ctx: Pick<ExtensionContext, "cwd" | "isProjectTrusted">): ChildTrust {
+	return { projectTrusted: ctx.isProjectTrusted(), sessionDir: canonicalDir(ctx.cwd) };
+}
+
+/**
+ * Flags for a child pi running in `runCwd`. `worktreeRepoRoot` is the repository a worktree was made
+ * from when the child runs in one this session created; it inherits trust only when that repository
+ * root is the session's own directory.
+ */
+export function trustArgs(trust: ChildTrust, runCwd: string, worktreeRepoRoot?: string): string[] {
+	if (!trust.projectTrusted) return ["--no-approve"];
+	const here = canonicalDir(runCwd) === trust.sessionDir;
+	const ownWorktree = worktreeRepoRoot !== undefined && canonicalDir(worktreeRepoRoot) === trust.sessionDir;
+	return here || ownWorktree ? ["--approve"] : [];
+}
+
+/**
+ * Environment for the claude shim (bin/claude): DEV_TEAM_TRUSTED_DIR is set only when trusted, and
+ * the shim adds --approve only when it runs in exactly that directory; --no-approve rides in
+ * DEV_TEAM_PI_ARGS when declined.
+ */
+export function shimTrustEnv(trust: ChildTrust, forwarded: string[]): { piArgs: string[]; trustedDir?: string } {
+	return trust.projectTrusted ? { piArgs: forwarded, trustedDir: trust.sessionDir } : { piArgs: [...forwarded, "--no-approve"] };
+}

package/extensions/dev-team/lib/usage-breakdown.ts

@@ -0,0 +1,176 @@
+/**
+ * Where a session's spend went, for every provider: the same runs the status line totals
+ * (session-spend.ts), grouped by model, by provider, by dispatched agent and provider, and by thread.
+ * Each group sums USD (pi's own cost, which every provider reports), the GitHub Copilot AI credits of
+ * the runs Copilot served (ai-credits.ts), and tokens. Shares are of USD. A run counts when it cost
+ * something or used tokens, so a free local model still shows; a run with neither is left out, and an
+ * empty breakdown means no usage at all. Amounts stay floats here; only the display rounds them.
+ */
+import { creditsFor } from "./ai-credits.ts";
+import { costUsd, type PiUsage, positiveFiniteOrZero, providerOf, type SpendRun } from "./session-spend.ts";
+import type { SpendHistory } from "./usage-history.ts";
+
+/** What a group of runs spent. */
+export interface SpendAmounts {
+	usd: number;
+	/** AI credits of the runs GitHub Copilot served; 0 when it served none. */
+	credits: number;
+	tokens: number;
+}
+
+export interface UsageRow<L extends string = string> extends SpendAmounts {
+	label: L;
+	/** Fraction (0 to 1) of the USD of the grouping this row belongs to; 0 when that grouping cost nothing. */
+	share: number;
+}
+
+/** How a thread is named on screen; the overlay's thread split draws the same closed set (THREAD_ORDER). */
+export type ThreadLabel = "main" | "subagents" | "overhead";
+
+export interface ThreadRow extends UsageRow<ThreadLabel> {
+	/** The SpendRun thread behind the label ("subagents" is "subagent"). */
+	thread: SpendRun["thread"];
+}
+
+/** One dispatched agent's spend on one provider; `label` is the agent's name. */
+export interface AgentRow extends UsageRow {
+	/** The provider that served this part of the agent's spend. */
+	provider: string;
+}
+
+export interface UsageBreakdown {
+	/** Every run's spend; the sum of the `byModel` rows. */
+	total: SpendAmounts;
+	/** "provider/model" rows. */
+	byModel: UsageRow[];
+	byProvider: UsageRow[];
+	/** One row per dispatched agent and provider (main-thread turns and overhead are not agents); shares are of the agents' own USD. */
+	byAgent: AgentRow[];
+	/** "main", "subagents" and "overhead", whichever spent, ranked like the other groupings. */
+	byThread: ThreadRow[];
+}
+
+export const THREAD_LABEL: Record<SpendRun["thread"], ThreadLabel> = { main: "main", subagent: "subagents", overhead: "overhead" };
+/** The threads in the order the overlay's thread split draws them, so a glyph always means the same thread. */
+export const THREAD_ORDER: readonly ThreadLabel[] = Object.values(THREAD_LABEL);
+/** Below this share a non-zero row displays as "<1%". */
+const TINY_SHARE = 0.01;
+/** The finest USD amount the display shows; below it a cost reads as "<$0.01". */
+const USD_CENT = 0.01;
+
+/** A run's tokens: input, output and both cache directions. */
+export function runTokens(usage: PiUsage): number {
+	return positiveFiniteOrZero(usage.input) + positiveFiniteOrZero(usage.output) + positiveFiniteOrZero(usage.cacheRead) + positiveFiniteOrZero(usage.cacheWrite);
+}
+
+/** A run's USD, AI credits (from that same USD, when Copilot served it) and tokens. */
+function runAmounts(run: SpendRun): SpendAmounts {
+	const usd = positiveFiniteOrZero(costUsd(run.usage));
+	return { usd, credits: creditsFor(run.model, usd), tokens: runTokens(run.usage) };
+}
+
+const ZERO: SpendAmounts = { usd: 0, credits: 0, tokens: 0 };
+const plus = (a: SpendAmounts, b: SpendAmounts): SpendAmounts => ({ usd: a.usd + b.usd, credits: a.credits + b.credits, tokens: a.tokens + b.tokens });
+
+/** A group's label and what it spent, before ranking. */
+interface Group<L extends string, E> {
+	label: L;
+	/** Breaks ties between groups with the same label (an agent on two providers). */
+	tieBreak: string;
+	amounts: SpendAmounts;
+	extra: E;
+}
+
+/** Rows by USD, largest first, then by tokens, then by name; each with its share of the groups' USD. */
+function rank<L extends string, E>(groups: Iterable<Group<L, E>>): (UsageRow<L> & E)[] {
+	const list = [...groups];
+	const totalUsd = list.reduce((sum, g) => sum + g.amounts.usd, 0);
+	return list
+		.sort((a, b) => b.amounts.usd - a.amounts.usd || b.amounts.tokens - a.amounts.tokens || a.label.localeCompare(b.label, "en") || a.tieBreak.localeCompare(b.tieBreak, "en"))
+		.map((g) => ({ ...g.extra, label: g.label, ...g.amounts, share: totalUsd > 0 ? g.amounts.usd / totalUsd : 0 }));
+}
+
+/** Sums runs into groups by key, keeping each group's label and extra fields from its first run. */
+class Grouper<L extends string, E> {
+	private readonly groups = new Map<string, Group<L, E>>();
+	add(key: string, label: L, amounts: SpendAmounts, extra: E, tieBreak = ""): void {
+		const group = this.groups.get(key);
+		if (group) group.amounts = plus(group.amounts, amounts);
+		else this.groups.set(key, { label, tieBreak, amounts, extra });
+	}
+	ranked(): (UsageRow<L> & E)[] {
+		return rank(this.groups.values());
+	}
+}
+
+/** False when nothing was spent: no USD and no tokens. */
+export function hasUsage(amounts: SpendAmounts): boolean {
+	return amounts.usd > 0 || amounts.tokens > 0;
+}
+
+export function usageBreakdown(runs: Iterable<SpendRun>): UsageBreakdown {
+	const models = new Grouper<string, object>();
+	const providers = new Grouper<string, object>();
+	const agents = new Grouper<string, { provider: string }>();
+	const threads = new Grouper<ThreadLabel, { thread: SpendRun["thread"] }>();
+	for (const run of runs) {
+		const amounts = runAmounts(run);
+		if (!hasUsage(amounts)) continue;
+		const provider = providerOf(run.model);
+		models.add(run.model, run.model, amounts, {});
+		providers.add(provider, provider, amounts, {});
+		threads.add(run.thread, THREAD_LABEL[run.thread], amounts, { thread: run.thread });
+		// Keyed on the pair, so no agent name can collide with another agent and provider.
+		if (run.thread === "subagent") agents.add(JSON.stringify([run.agent, provider]), run.agent, amounts, { provider }, provider);
+	}
+	const byModel = models.ranked();
+	return {
+		total: byModel.reduce<SpendAmounts>((sum, row) => plus(sum, row), ZERO),
+		byModel,
+		byProvider: providers.ranked(),
+		byAgent: agents.ranked(),
+		byThread: threads.ranked(),
+	};
+}
+
+/** What this month's load produced. */
+export interface MonthSnapshot {
+	breakdown: UsageBreakdown;
+	/** Session files that could not be read. */
+	unreadable: number;
+	/** When the load finished; the header says "as of" this time. */
+	loadedAt: Date;
+}
+
+/** The snapshot of a finished load: the breakdown of its runs, the files it could not read, and when it finished. */
+export function monthSnapshot(history: SpendHistory, loadedAt: Date): MonthSnapshot {
+	return { breakdown: usageBreakdown(history.records.map((r) => r.run)), unreadable: history.unreadable, loadedAt };
+}
+
+/** "83.3%", "<1%" for a non-zero share under 1% so a small row never reads as 0.0%, and "0%" for none. */
+export function formatShare(share: number): string {
+	if (!(share > 0)) return "0%";
+	return share < TINY_SHARE ? "<1%" : `${(share * 100).toFixed(1)}%`;
+}
+
+/** "$4.20", "$1,234.50", "<$0.01" for a cost under a cent, "$0.00" for none. */
+export function formatUsd(usd: number): string {
+	if (!(usd > 0)) return "$0.00";
+	if (Number(usd.toFixed(2)) < USD_CENT) return "<$0.01";
+	return `$${usd.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+}
+
+const TOKEN_UNITS: readonly (readonly [number, string])[] = [
+	[1e9, "B"],
+	[1e6, "M"],
+	[1e3, "k"],
+];
+
+/** "320 tok", "85.3k tok", "1.2M tok". */
+export function formatTokens(tokens: number): string {
+	for (const [size, unit] of TOKEN_UNITS) {
+		const scaled = tokens / size;
+		if (Number(scaled.toFixed(1)) >= 1) return `${Number(scaled.toFixed(1)).toLocaleString("en-US")}${unit} tok`;
+	}
+	return `${Math.round(tokens)} tok`;
+}

package/extensions/dev-team/lib/usage-chart.ts

@@ -0,0 +1,153 @@
+/**
+ * Block-character ranked bar chart for the /dev-team usage overlay (barChartLines); the stacked
+ * splits are usage-split-bar.ts. Pure string rendering: every line is built from plain
+ * text, measured with pi-tui's visibleWidth, cut where needed and only then styled, so a line never
+ * exceeds the width it was asked for and colour comes from the injected style alone. Formatting
+ * (USD, credits, tokens, share) is injected too, which keeps this module free of the breakdown and
+ * theme code that feeds it.
+ */
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { cutToWidth, toSingleLine } from "./terminal-text.ts";
+
+export interface ChartRow {
+	label: string;
+	/** The bar's length and the first value column. */
+	usd: number;
+	/** AI credits; a column of its own when any row has some. */
+	credits: number;
+	tokens: number;
+	/** Fraction (0 to 1), shown through `format.share`. */
+	share: number;
+}
+
+export interface ChartStyle {
+	/** Colours a bar. */
+	bar(text: string): string;
+	/** De-emphasises the secondary columns (credits, tokens, share). */
+	muted(text: string): string;
+}
+
+export interface ChartFormat {
+	usd(usd: number): string;
+	/** "" for a row without credits worth showing; the cell stays blank. */
+	credits(credits: number): string;
+	tokens(tokens: number): string;
+	share(share: number): string;
+}
+
+export interface BarChartOptions {
+	/** Terminal columns every returned line must fit in. */
+	width: number;
+	/** Most lines to return; rows beyond that fold into one "other (N)" line that takes the last slot. */
+	maxRows: number;
+	format: ChartFormat;
+	/**
+	 * Which optional columns the rows want, decided by the caller over all rows (before any fold into
+	 * "other"), so the overlay and the text summary apply one rule. Share is always wanted.
+	 */
+	wantedColumns: { credits: boolean; tokens: boolean };
+	style: ChartStyle;
+}
+
+const COLUMN_GAP = "  ";
+const GAP_WIDTH = COLUMN_GAP.length;
+/** Gaps between the label, bar and USD columns; each optional column adds one more. */
+const GAPS_LABEL_BAR_USD = 2;
+const MAX_BAR_CELLS = 30;
+/** `▏` to `▉`: one to seven eighths of a cell; a full cell is `█`. */
+const PARTIAL_BLOCKS = "▏▎▍▌▋▊▉";
+export const FULL_BLOCK = "█";
+const EIGHTHS_PER_CELL = 8;
+/** Narrowest label and bar worth drawing; below these the layout drops a column instead of squeezing. */
+const MIN_LABEL_CELLS = 6;
+const MIN_BAR_CELLS = 6;
+/** `eighths` eighths of a cell as glyphs: whole cells of `█`, then one partial block. */
+function barGlyphs(eighths: number): string {
+	const rest = eighths % EIGHTHS_PER_CELL;
+	return FULL_BLOCK.repeat(Math.floor(eighths / EIGHTHS_PER_CELL)) + (rest ? PARTIAL_BLOCKS[rest - 1] : "");
+}
+
+/** Bar length in eighths of a cell; any non-zero value gets at least one so it never vanishes. */
+function barEighths(value: number, max: number, cells: number): number {
+	if (value <= 0 || max <= 0) return 0;
+	return Math.max(1, Math.round((value / max) * cells * EIGHTHS_PER_CELL));
+}
+
+const padEnd = (text: string, width: number) => text + " ".repeat(Math.max(0, width - visibleWidth(text)));
+const padStart = (text: string, width: number) => " ".repeat(Math.max(0, width - visibleWidth(text))) + text;
+
+/** The columns after the bar, in drop order: the first one listed goes last. */
+const OPTIONAL_COLUMNS = ["credits", "tokens", "share"] as const;
+type OptionalColumn = (typeof OPTIONAL_COLUMNS)[number];
+
+interface Columns {
+	/** 0 drops the label column and its gap. */
+	label: number;
+	/** 0 drops the bar column. */
+	bar: number;
+	/** The optional columns kept, each at its natural width. */
+	shown: ReadonlySet<OptionalColumn>;
+	/** Narrower than the natural USD width only when the USD value alone overflows the line. */
+	usd: number;
+}
+
+/**
+ * Splits `width` across the columns. The label truncates first (down to MIN_LABEL_CELLS, or its
+ * natural width when shorter); when the bar would fall below MIN_BAR_CELLS the optional columns go,
+ * share first, then tokens, then credits; then the bar, then the label, leaving the USD value alone,
+ * which is cut (with an ellipsis) only when it overflows the line by itself. USD is never dropped.
+ */
+function fitColumns(width: number, natural: { label: number; usd: number } & Record<OptionalColumn, number>, wanted: readonly OptionalColumn[]): Columns {
+	const minLabel = Math.min(natural.label, MIN_LABEL_CELLS);
+	for (let keep = wanted.length; keep >= 0; keep--) {
+		const shown = new Set(wanted.slice(0, keep));
+		const optionalWidth = [...shown].reduce((sum, column) => sum + natural[column] + GAP_WIDTH, 0);
+		const room = width - natural.usd - optionalWidth - GAPS_LABEL_BAR_USD * GAP_WIDTH;
+		const label = Math.min(natural.label, room - MIN_BAR_CELLS);
+		if (label >= minLabel) return { label, bar: Math.min(MAX_BAR_CELLS, room - label), shown, usd: natural.usd };
+	}
+	const none = new Set<OptionalColumn>();
+	const label = Math.min(natural.label, width - natural.usd - GAP_WIDTH);
+	if (label > 0) return { label, bar: 0, shown: none, usd: natural.usd };
+	return { label: 0, bar: 0, shown: none, usd: Math.max(0, Math.min(natural.usd, width)) };
+}
+
+/** The first `maxRows - 1` rows, then "other (N)" summing the rest; all rows when they fit. */
+function foldRows(rows: readonly ChartRow[], maxRows: number): ChartRow[] {
+	if (rows.length <= maxRows) return [...rows];
+	const kept = rows.slice(0, Math.max(0, maxRows - 1));
+	const folded = rows.slice(kept.length);
+	const sum = (pick: (r: ChartRow) => number) => folded.reduce((total, r) => total + pick(r), 0);
+	return [...kept, { label: `other (${folded.length})`, usd: sum((r) => r.usd), credits: sum((r) => r.credits), tokens: sum((r) => r.tokens), share: sum((r) => r.share) }];
+}
+
+/** One line per row: label, bar scaled to the largest USD, USD, then the wanted optional columns (credits, tokens) and share. */
+export function barChartLines(allRows: readonly ChartRow[], { width, maxRows, format, wantedColumns, style }: BarChartOptions): string[] {
+	const rows = (maxRows > 0 ? foldRows(allRows, maxRows) : []).map((r) => ({ ...r, label: toSingleLine(r.label) }));
+	if (!rows.length) return [];
+	const cellsOf: Record<OptionalColumn, string[]> = {
+		credits: rows.map((r) => format.credits(r.credits)),
+		tokens: rows.map((r) => format.tokens(r.tokens)),
+		share: rows.map((r) => format.share(r.share)),
+	};
+	const usdCells = rows.map((r) => format.usd(r.usd));
+	const widest = (cells: readonly string[]) => Math.max(...cells.map(visibleWidth));
+	const natural = { label: widest(rows.map((r) => r.label)), usd: widest(usdCells), credits: widest(cellsOf.credits), tokens: widest(cellsOf.tokens), share: widest(cellsOf.share) };
+	const wanted = OPTIONAL_COLUMNS.filter((column) => column === "share" || wantedColumns[column]);
+	const columns = fitColumns(width, natural, wanted);
+	const max = Math.max(...rows.map((r) => r.usd));
+
+	return rows.map((row, i) => {
+		const cells: string[] = [];
+		if (columns.label) cells.push(padEnd(cutToWidth(row.label, columns.label), columns.label));
+		if (columns.bar) {
+			const bar = barGlyphs(barEighths(row.usd, max, columns.bar));
+			cells.push(style.bar(bar) + " ".repeat(columns.bar - visibleWidth(bar)));
+		}
+		cells.push(padStart(cutToWidth(usdCells[i], columns.usd), columns.usd));
+		for (const column of OPTIONAL_COLUMNS) {
+			if (columns.shown.has(column)) cells.push(style.muted(padStart(cellsOf[column][i], natural[column])));
+		}
+		return cells.join(COLUMN_GAP);
+	});
+}