shariq-pi-extensions 0.1.0

package/extensions/context-usage/lib/ansi.ts

@@ -0,0 +1,60 @@
+// ANSI helpers for Context Usage.
+// This directory has no index.ts on purpose: pi's extension discovery skips it.
+
+/** Matches one OSC sequence (hyperlink/title). The payload can never contain ESC — ESC
+ * starts the ST terminator — so excluding it keeps the match from greedily swallowing
+ * the visible text between an ST-terminated OSC 8 open and its close. */
+export const OSC_SEQUENCE = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
+
+/** Strip CSI (colors/cursor) and OSC (hyperlink/title) escape sequences. */
+export function stripAnsi(text: string): string {
+  return text
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+    .replace(OSC_SEQUENCE, "");
+}
+
+/** Index of the last char of the escape sequence starting at `i`, or undefined. */
+export function ansiEndIndex(line: string, i: number): number | undefined {
+  if (line[i] !== "\x1b") return undefined;
+  if (line[i + 1] === "[") {
+    const end = line.slice(i).search(/[A-Za-z~]/);
+    return end >= 0 ? i + end : undefined;
+  }
+  if (line[i + 1] === "]") {
+    const bel = line.indexOf("\x07", i + 2);
+    const st = line.indexOf("\x1b\\", i + 2);
+    const end = bel === -1 ? st : st === -1 ? bel : Math.min(bel, st);
+    return end >= 0 ? end + (line[end] === "\x1b" ? 1 : 0) : undefined;
+  }
+  return undefined;
+}
+
+/** Raw string index of the visible character at visible index `target` (escape-aware). */
+export function rawIndexAtVisibleIndex(line: string, target: number): number {
+  let visible = 0;
+  for (let i = 0; i < line.length; i++) {
+    const ansiEnd = ansiEndIndex(line, i);
+    if (ansiEnd !== undefined) {
+      i = ansiEnd;
+      continue;
+    }
+    if (visible === target) return i;
+    visible++;
+  }
+  return line.length;
+}
+
+/** Like rawIndexAtVisibleIndex, but lands *before* any escapes preceding the char. */
+export function rawIndexBeforeVisibleIndex(line: string, target: number): number {
+  let visible = 0;
+  for (let i = 0; i < line.length; i++) {
+    if (visible === target) return i;
+    const ansiEnd = ansiEndIndex(line, i);
+    if (ansiEnd !== undefined) {
+      i = ansiEnd;
+      continue;
+    }
+    visible++;
+  }
+  return line.length;
+}

package/extensions/context-usage/lib/boundary.ts

@@ -0,0 +1,27 @@
+// Boundary helpers for values that enter Context Usage from JSON, Pi internals,
+// provider payloads, or other untyped seams. Keep generic uncertainty here or in
+// domain-named parsers, not in rendering/core logic.
+
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+export type JsonObject = { [key: string]: JsonValue };
+
+export function isJsonObject(value: unknown): value is JsonObject {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+export function jsonObjectOrEmpty(value: unknown): JsonObject {
+  return isJsonObject(value) ? value : {};
+}
+
+export function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined;
+}
+
+export function positiveNumberValue(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+
+export function booleanValue(value: unknown): boolean | undefined {
+  return typeof value === "boolean" ? value : undefined;
+}

package/extensions/context-usage/lib/chat.ts

@@ -0,0 +1,190 @@
+// Shared structural detection of pi's chat tree. All detection is duck-typed
+// against extension-visible component shapes and contract-tested against the
+// installed pi (tests/contract/pi-internals.test.ts), never imported from
+// pi internals — that is what lets the family survive `pi update`.
+import { stripAnsi } from "./ansi.ts";
+
+export interface ToolArgsLike {
+  [key: string]: unknown;
+  path?: unknown;
+  file_path?: unknown;
+  content?: unknown;
+  command?: unknown;
+  offset?: unknown;
+  limit?: unknown;
+}
+
+export interface ToolResultDetailsLike {
+  diff?: unknown;
+  patch?: unknown;
+}
+
+export interface ToolResultLike {
+  isError?: unknown;
+  content?: unknown;
+  details?: ToolResultDetailsLike;
+}
+
+export interface ToolCallPreviewLike {
+  [key: string]: unknown;
+  error?: unknown;
+  diff?: unknown;
+}
+
+export interface ToolCallRendererLike {
+  render?: (width: number) => unknown;
+  preview?: ToolCallPreviewLike;
+}
+
+export interface ToolRowDataLike {
+  toolName?: unknown;
+  args?: ToolArgsLike;
+  result?: ToolResultLike;
+  isPartial?: unknown;
+  /** pi's per-row expansion flag: written by setExpanded(), read for the zoom ladder (design language §9.12). */
+  expanded?: unknown;
+  cwd?: unknown;
+  callRendererComponent?: ToolCallRendererLike;
+  __tracelineWriteSnapshot?: unknown;
+}
+
+export interface ToolRowLike extends ToolRowDataLike {
+  render: (width: number) => unknown;
+  setExpanded: (...args: unknown[]) => unknown;
+}
+
+export interface AssistantMessageLike {
+  content?: unknown;
+  role?: unknown;
+  timestamp?: unknown;
+}
+
+export interface AssistantRowDataLike {
+  hideThinkingBlock?: unknown;
+  lastMessage?: AssistantMessageLike;
+  hiddenThinkingLabel?: unknown;
+  render?: (width: number) => unknown;
+}
+
+export interface AssistantRowLike extends AssistantRowDataLike {
+  hideThinkingBlock: boolean;
+  setHideThinkingBlock: (...args: unknown[]) => unknown;
+}
+
+export interface ToolRowPrototypeLike extends Partial<ToolRowLike> {
+  __tracelineWriteSnapshotPatchVersion?: number;
+  __tracelineOriginalSetArgsComplete?: (...args: unknown[]) => unknown;
+  setArgsComplete?: (...args: unknown[]) => unknown;
+  __tracelineOriginalMarkExecutionStarted?: (...args: unknown[]) => unknown;
+  markExecutionStarted?: (...args: unknown[]) => unknown;
+  __tracelineOriginalRender?: (width: number) => unknown;
+}
+
+export interface AssistantRowPrototypeLike extends Partial<AssistantRowLike> {
+  __tracelineAssistantPatchVersion?: number;
+  __tracelineOriginalAssistantRender?: (width: number) => unknown;
+}
+
+export interface TracelineTuiLike {
+  requestRender: (force?: boolean) => unknown;
+  __tracelineRRWrapVersion?: number;
+  __tracelineOriginalRequestRender?: (force?: boolean) => unknown;
+}
+
+/** A tool execution row: has setExpanded() and a toolName property. */
+export function isToolRow(component: unknown): component is ToolRowLike {
+  if (!component || typeof component !== "object") return false;
+  const c = component as { constructor?: { name?: string }; render?: unknown; setExpanded?: unknown };
+  if (c.constructor?.name === "ToolExecutionComponent") return true;
+  return typeof c.render === "function" && typeof c.setExpanded === "function" && "toolName" in c;
+}
+
+/** An assistant message row: carries the hideThinkingBlock toggle. */
+export function isAssistantRow(component: unknown): component is AssistantRowLike {
+  const c = component as { setHideThinkingBlock?: unknown; hideThinkingBlock?: unknown };
+  return !!c && typeof c.setHideThinkingBlock === "function" && typeof c.hideThinkingBlock === "boolean";
+}
+
+export interface ContainerLike {
+  children: unknown[];
+  addChild?: (child: unknown) => void;
+}
+
+/** Depth-first search for the container whose direct children satisfy `predicate`. */
+export function findContainerBy(
+  node: unknown,
+  predicate: (children: unknown[]) => boolean,
+  seen = new Set<unknown>(),
+): ContainerLike | undefined {
+  if (!node || typeof node !== "object" || seen.has(node)) return undefined;
+  seen.add(node);
+  const children = (node as { children?: unknown[] }).children;
+  if (Array.isArray(children)) {
+    if (predicate(children)) return node as unknown as ContainerLike;
+    for (const child of children) {
+      const found = findContainerBy(child, predicate, seen);
+      if (found) return found;
+    }
+  }
+  return undefined;
+}
+
+// The startup resource listing pi renders at session start: leaf ExpandableText
+// sections whose first line is a [Section] header. Since pi 0.80 it lives in a
+// loadedResourcesContainer rendered immediately before the chat container, making it
+// the one reliable pre-rows landmark for finding that container in a fresh session
+// (the welcome/changelog block is gated on updates). Same seam Context Usage has
+// anchored on since v1.
+export const RESOURCE_HEADER_RE = /^\s*\[(Context|Skills|Prompts|Extensions|Themes)\]/m;
+
+/** A single startup resource section: a leaf component whose render carries a [Section] header. */
+export function isResourceRow(component: unknown): boolean {
+  const c = component as { render?: (width: number) => string[]; children?: unknown };
+  if (!c || typeof c.render !== "function" || Array.isArray(c.children)) return false;
+  try {
+    return RESOURCE_HEADER_RE.test(stripAnsi(c.render(200).join("\n")));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * In pi 0.80.x, loaded resources moved out of chatContainer into a sibling
+ * loadedResourcesContainer that is rendered immediately before chatContainer. Use that
+ * ordering as the fresh-session fallback when there are no assistant/tool rows yet.
+ */
+function findChatContainerAfterResourceContainer(node: unknown, seen = new Set<unknown>()): ContainerLike | undefined {
+  if (!node || typeof node !== "object" || seen.has(node)) return undefined;
+  seen.add(node);
+
+  const children = (node as { children?: unknown[] }).children;
+  if (!Array.isArray(children)) return undefined;
+
+  for (let i = 0; i < children.length - 1; i++) {
+    const child = children[i];
+    const next = children[i + 1];
+    if (child && typeof child === "object" && next && typeof next === "object") {
+      const childChildren = (child as { children?: unknown[] }).children;
+      const nextChildren = (next as { children?: unknown[] }).children;
+      if (Array.isArray(childChildren) && Array.isArray(nextChildren) && childChildren.some((c) => isResourceRow(c))) {
+        return next as ContainerLike;
+      }
+    }
+  }
+
+  for (const child of children) {
+    const found = findChatContainerAfterResourceContainer(child, seen);
+    if (found) return found;
+  }
+  return undefined;
+}
+
+/** pi's chat container: the one whose direct children include the chat rows — or, in a
+ * fresh session with no rows yet, the empty sibling immediately after the startup
+ * resource listing (pi 0.80+). */
+export function findChatContainer(node: unknown): ContainerLike | undefined {
+  return (
+    findContainerBy(node, (children) => children.some((c) => isToolRow(c) || isAssistantRow(c))) ??
+    findChatContainerAfterResourceContainer(node)
+  );
+}

package/extensions/context-usage/lib/config.ts

@@ -0,0 +1,30 @@
+// Shared config-file convention for Context Usage:
+// user-level agent config, then project-level Pi config.
+
+import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export function expandHomePath(filePath: string): string {
+  if (filePath === "~") return homedir();
+  if (filePath.startsWith("~/")) return join(homedir(), filePath.slice(2));
+  return filePath;
+}
+
+/** Read JSON config through a domain parser; undefined on absence or any parse error. */
+export function readJsonConfig<T>(filePath: string, parse: (value: unknown) => T): T | undefined {
+  try {
+    const expanded = expandHomePath(filePath);
+    if (!existsSync(expanded)) return undefined;
+    const parsed: unknown = JSON.parse(readFileSync(expanded, "utf8"));
+    return parse(parsed);
+  } catch {
+    return undefined;
+  }
+}
+
+/** Standard lookup order: user file first, project file second (later overrides). */
+export function configPaths(name: string, cwd: string): string[] {
+  return [join(getAgentDir(), `${name}.json`), join(cwd, CONFIG_DIR_NAME, `${name}.json`)];
+}

package/extensions/context-usage/lib/fmt.ts

@@ -0,0 +1,59 @@
+// Shared number formatting for Context Usage.
+// (docs/design-language.md §4). One unit, everywhere: counts render in fixed
+// one-decimal k-units (0.1k, 1.2k, 52.3k) so magnitudes compare down a column —
+// raw integers never appear. M is the only step-up, at ≥1M, where k becomes
+// unreadable (9.1M, not 9100.0k). Char counts read `0.4k ch`.
+
+export function compactCount(value: number): string {
+  if (!Number.isFinite(value)) return "?";
+  const rounded = Math.round(value);
+  if (Math.abs(rounded) >= 999_950) return `${(rounded / 1_000_000).toFixed(1)}M`;
+  return `${(rounded / 1000).toFixed(1)}k`;
+}
+
+export function formatChars(value: number): string {
+  return `${compactCount(value)} ch`;
+}
+
+/**
+ * Token counts wear the estimate marker unless provider-reported: the ~/no-~
+ * distinction is semantic, never stylistic (design language §4).
+ */
+export function formatTokens(value: number, options: { exact?: boolean } = {}): string {
+  return `${options.exact ? "" : "~"}${compactCount(value)} tokens`;
+}
+
+/** Money: two decimals; three below $0.10, where the third digit is significant. */
+export function formatUsd(value: number): string {
+  return value >= 0.10 ? `$${value.toFixed(2)}` : `$${value.toFixed(3)}`;
+}
+
+/** Latency durations (design language §4): below 10s the first decimal is significant
+ * at first-token scale (`1.9s`, `9.6s`); from 10s the compact mixed-unit grammar
+ * resumes. */
+export function formatLatency(ms: number): string {
+  const seconds = Math.max(0, ms) / 1000;
+  if (seconds < 9.95) return `${seconds.toFixed(1)}s`;
+  return formatDuration(ms);
+}
+
+/** Rates (design language §4): integer tok/s; `~` when estimated from streamed chars,
+ * none when derived from provider usage. The ~/no-~ distinction is semantic. */
+export function formatRate(tokensPerSecond: number, options: { exact?: boolean } = {}): string {
+  if (!Number.isFinite(tokensPerSecond) || tokensPerSecond < 0) return "?";
+  return `${options.exact ? "" : "~"}${Math.round(tokensPerSecond)} tok/s`;
+}
+
+/** Durations: compact mixed units, no spaces — 14s, 2m41s, 9h50m. */
+export function formatDuration(ms: number): string {
+  const seconds = Math.max(0, Math.round(ms / 1000));
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) {
+    const rest = seconds % 60;
+    return rest > 0 ? `${minutes}m${rest.toString().padStart(2, "0")}s` : `${minutes}m`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const restMinutes = minutes % 60;
+  return restMinutes > 0 ? `${hours}h${restMinutes}m` : `${hours}h`;
+}

package/extensions/context-usage/lib/style.ts

@@ -0,0 +1,260 @@
+// Context Usage terminal styling.
+// Identity lives in glyphs and layout, not colour: all ink is theme-derived through
+// ink(), with raw-ANSI fallbacks only for surfaces rendered before a Theme handle
+// exists and for the one tone pi's theme has no faithful role for ("running").
+
+import type { Theme, ThemeColor } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { homedir } from "node:os";
+import { OSC_SEQUENCE, rawIndexAtVisibleIndex, stripAnsi } from "./ansi.ts";
+
+/** Line-kind glyphs: one per line, gutter position (design language §1). */
+export const GLYPH = {
+  /** a tool action (one trace row) — traceline */
+  tool: "\u203a", // ›
+  /** a loop-economics fact (clock, notice, ledger line) — cachemire */
+  econ: "\u25cd", // ◍
+  /** an expandable/summarizable section header — Context Usage */
+  section: "\u25b8", // ▸
+  /** tool-block rail — the dim left edge that fuses a run of trace rows into one block */
+  rail: "\u258f", // ▏
+} as const;
+
+/** Status scale — family-shared vocabulary (design language §1). */
+export const SCALE = {
+  cold: "\u25cb", // ○ cold / empty
+  hit: "\u25cf", // ● hit / full
+  partial: "\u25d1", // ◑ partial
+  miss: "\u25cc", // ◌ miss / broken
+} as const;
+
+/** The only inline fact separator (design language §5). */
+export const SEP = " \u00b7 "; // ·
+
+/**
+ * Ink tones (design language §2): the neutral ramp (text/muted/dim), the status
+ * tones (success/warning/error/running), and the family accent.
+ */
+export type Tone =
+  | "text"
+  | "muted"
+  | "dim"
+  | "success"
+  | "warning"
+  | "error"
+  | "running"
+  | "accent";
+
+const THEME_ROLE: Partial<Record<Tone, ThemeColor>> = {
+  text: "text",
+  muted: "muted",
+  dim: "dim",
+  success: "success",
+  warning: "warning",
+  error: "error",
+  accent: "accent",
+  // "running" has no faithful theme role (accent would collide with brand/total
+  // highlights; warning overloads "fading") — resolved to the ANSI-blue raw tone
+  // (design language §2).
+};
+
+const RESET = "\x1b[0m";
+
+// Raw fallbacks: basic ANSI only (widest terminal support), used when no Theme is
+// available yet. "text" and "accent" fall back to uncoloured text — plain is honest
+// before the theme exists.
+const RAW: Record<Tone, string> = {
+  text: "",
+  muted: "\x1b[90m",
+  dim: "\x1b[90m",
+  success: "\x1b[32m",
+  warning: "\x1b[33m",
+  error: "\x1b[31m",
+  running: "\x1b[34m",
+  accent: "",
+};
+
+/** All family ink flows through here (design language §3). */
+export function ink(theme: Theme | undefined, tone: Tone, text: string): string {
+  if (text.length === 0) return text;
+  const role = THEME_ROLE[tone];
+  if (theme && role) {
+    try {
+      return theme.fg(role, text);
+    } catch {
+      // fall through to the raw tone — never let styling break a render
+    }
+  }
+  const open = RAW[tone];
+  return open ? `${open}${text}${RESET}` : text;
+}
+
+// --- panel headers (design language §8) -------------------------------------------------
+
+/** Mode pips for a panel header: active mode accent-bold, others dim, `→` dim. */
+export function panelPips(theme: Theme | undefined, modes: readonly string[], active: string): string {
+  return modes
+    .map((mode) => (mode === active ? ink(theme, "accent", bold(theme, mode)) : ink(theme, "dim", mode)))
+    .join(ink(theme, "dim", " → "));
+}
+
+/**
+ * The family panel-header form (design language §8): `[Name]` in bold accent, optional
+ * mode pips, then one dim hint line carrying keybinding, scope, and the panel's
+ * methodology — stated here once, never on data rows.
+ */
+export function panelHeader(
+  theme: Theme | undefined,
+  name: string,
+  options: { modes?: readonly string[]; active?: string; hint?: string } = {},
+): string[] {
+  const brand = ink(theme, "accent", bold(theme, `[${name}]`));
+  const pips = options.modes && options.active ? ` ${panelPips(theme, options.modes, options.active)}` : "";
+  const lines = ["", `${brand}${pips}`];
+  if (options.hint) lines.push(`  ${ink(theme, "dim", options.hint)}`);
+  return lines;
+}
+
+function bold(theme: Theme | undefined, text: string): string {
+  try {
+    return theme?.bold ? theme.bold(text) : text;
+  } catch {
+    return text;
+  }
+}
+
+// --- layout helpers (design language §5) -----------------------------------------------
+
+export const ELLIPSIS = "\u2026"; // …
+
+const MIN_HEAD_COLS = 6;
+const TAIL_RATIO = 0.55;
+
+// Replace an absolute home-directory prefix with ~ so boilerplate path heads stop eating
+// width (e.g. bash `cd /Users/me/... && ...` -> `cd ~/... && ...`). OSC sequences are
+// skipped: a read row's OSC 8 hyperlink carries a file:// URL containing the home path,
+// and tildifying *that* would corrupt the click target. The pattern is built once —
+// tildify runs for every visible row on every frame.
+const TILDIFY_PATTERN = (() => {
+  const home = homedir();
+  if (!home) return undefined;
+  return new RegExp(`${OSC_SEQUENCE.source}|${home.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "g");
+})();
+
+export function tildify(text: string): string {
+  if (!TILDIFY_PATTERN) return text;
+  return text.replace(TILDIFY_PATTERN, (match) => (match.startsWith("\x1b") ? match : "~"));
+}
+
+// ANSI-aware middle truncation that protects the *tail* of the line — the basename +
+// :line-range for a path, or the operative end of a command — because that is where the
+// information distinguishing one row from the next lives. The cut snaps to a nearby "/"
+// or space boundary, and the ellipsis is dimmed so it reads as a UI marker rather than as
+// part of the path/command. Falls back to tail truncation only when the width is too
+// small to keep both ends.
+// Ink continuity across the cut (design language §5): the tail's opening SGR may
+// sit in the removed middle, which would leave the tail at the terminal default until
+// the next styled span opened. Replay the *net* SGR state active at the cut point —
+// one sequence per attribute, offs and full resets clearing their slots — so the tail
+// keeps its ink without echoing the whole styling history.
+function activeSgrAt(line: string, rawIndex: number): string {
+  const state = new Map<string, string>();
+  const sgr = /\x1b\[([0-9;]*)m/g;
+  let match: RegExpExecArray | null;
+  while ((match = sgr.exec(line)) && match.index < rawIndex) {
+    const params = match[1] ?? "";
+    if (params === "" || params === "0") {
+      state.clear();
+      continue;
+    }
+    const key =
+      params.startsWith("38") || params === "39" || /^(3[0-7]|9[0-7])$/.test(params)
+        ? "fg"
+        : params.startsWith("48") || params === "49" || /^(4[0-7]|10[0-7])$/.test(params)
+          ? "bg"
+          : params === "1" || params === "2" || params === "22"
+            ? "weight"
+            : params === "3" || params === "23"
+              ? "italic"
+              : params === "4" || params === "24"
+                ? "underline"
+                : params; // unknown/compound: replay verbatim, keyed by itself
+    const off = params === "39" || params === "49" || params === "22" || params === "23" || params === "24";
+    if (off) state.delete(key);
+    else state.set(key, match[0]);
+  }
+  return [...state.values()].join("");
+}
+
+export function middleTruncate(line: string, width: number, theme?: Theme): string {
+  const maxWidth = Math.max(1, width);
+  if (visibleWidth(line) <= maxWidth) return line;
+
+  const vis = stripAnsi(line);
+  const visLen = vis.length;
+  const ellipsisWidth = visibleWidth(ELLIPSIS);
+  const budget = Math.max(1, maxWidth - ellipsisWidth); // reserve columns for the ellipsis
+
+  const maxTail = Math.min(budget - MIN_HEAD_COLS, Math.max(12, Math.floor(budget * TAIL_RATIO)));
+  if (maxTail < 1) return truncateToWidth(line, maxWidth, ELLIPSIS);
+
+  // The cut is a column (design language §9.8): the tail is exactly `maxTail` wide and
+  // the head exactly fills the rest, so every line truncated to the same budget cuts at
+  // identical columns and fills the budget exactly. No content-dependent snapping — a
+  // mid-token cut beside a dim ellipsis is legible; a wandering ellipsis column is not.
+  const tailStart = visLen - maxTail;
+  const dimEllipsis = ink(theme, "dim", ELLIPSIS);
+  const tailRawStart = rawIndexAtVisibleIndex(line, tailStart);
+  const tailRaw = `${activeSgrAt(line, tailRawStart)}${line.slice(tailRawStart)}`;
+
+  const headEnd = budget - maxTail;
+  if (headEnd <= 0) return `${dimEllipsis}${tailRaw}`;
+
+  const headRaw = line.slice(0, rawIndexAtVisibleIndex(line, headEnd));
+  return `${headRaw}${RESET}${dimEllipsis}${tailRaw}`;
+}
+
+/** Quantities right (design language §5): body left, right-aligned suffix, ≥2-space gap
+ * (§9.1 — the tail must not crowd the facts); the body middle-truncates and the suffix
+ * wins when the width is starved. `reserve` (design language §9.8) is a minimum
+ * right-side reservation — gap included — so callers can hold every body in a block to
+ * the same budget regardless of each row's own suffix. */
+export function rightAlignSuffix(
+  body: string,
+  suffix: string,
+  width: number,
+  theme?: Theme,
+  reserve = 0,
+): string {
+  const maxWidth = Math.max(1, width);
+  const bodyText = body.trimEnd();
+  if (!suffix) {
+    const budget = maxWidth - reserve >= MIN_HEAD_COLS ? maxWidth - reserve : maxWidth;
+    return middleTruncate(bodyText, budget, theme);
+  }
+
+  const suffixWidth = visibleWidth(suffix);
+  if (suffixWidth >= maxWidth) return truncateToWidth(suffix, maxWidth, ELLIPSIS);
+
+  const bodyWidth = Math.max(0, maxWidth - Math.max(suffixWidth + 2, reserve));
+  const fittedBody = bodyWidth > 0 ? middleTruncate(bodyText, bodyWidth, theme) : "";
+  const gapWidth = Math.max(1, maxWidth - visibleWidth(fittedBody) - suffixWidth);
+  return `${fittedBody}${" ".repeat(gapWidth)}${suffix}`;
+}
+
+// --- severity (design language §6) -------------------------------------------------------
+
+/** Severity thresholds for tool result sizes, in chars (design language §6). */
+export type SizeThresholds = { warning: number; error: number };
+
+export const SIZE_THRESHOLDS: SizeThresholds = { warning: 10_000, error: 50_000 };
+
+/**
+ * Tone for a result-size quantity: dim below the warning threshold so healthy rows
+ * stay quiet; warning/error above so ballooned outputs jump out of the column.
+ */
+export function sizeTone(chars: number, thresholds: SizeThresholds = SIZE_THRESHOLDS): Tone {
+  if (chars >= thresholds.error) return "error";
+  if (chars >= thresholds.warning) return "warning";
+  return "dim";
+}

package/extensions/copy-all/README.md

@@ -0,0 +1,15 @@
+# Copy All
+
+Copies a readable transcript of the active Pi conversation branch to the system clipboard.
+
+## Command
+
+`/copy-all` waits for the current agent run to settle, then copies visible user and assistant messages from the active branch. Messages are labeled `USER` and `ASSISTANT` and separated with a horizontal divider.
+
+The exported transcript intentionally excludes system messages, tool calls, tool results, and hidden reasoning. Image blocks are represented as `[image]`. Empty branches produce an informational notification instead of changing the clipboard.
+
+Clipboard access uses Pi's cross-platform clipboard helper. A clipboard failure is shown in the interface and does not alter the session.
+
+## Validation
+
+From the repository root, run `npm run validate`.