pi-zentui 0.12.0 → 0.14.0

package/README.md

@@ -157,8 +157,13 @@ Default config values — copy this and change any value you want:
 {
 	"projectRefreshIntervalMs": 30000,
 	"footerFormat": "",
+	"responsiveFooter": true,
+	"compactFooterFormat": "$cwd$wrap(in $session_name)$wrap(on $git_branch) $git_status$wrap$context$wrap_sep$tokens",
+	"compactFooterMaxLines": 2,
+	"editorMetadataFormat": "$model  $provider(  $thinking)",
 	"separator": "pipe",
 	"contextStyle": "text",
+	"editorModelLabel": "id",
 	"contextThresholds": {
 		"warning": 70,
 		"error": 90
@@ -278,6 +283,8 @@ Default config values — copy this and change any value you want:
 - Style values can be Starship/terminal strings (`bold purple`, `fg:202`, `#89b` / `#89b4fa`, `bg:blue fg:bright-green`) or Pi theme tokens (`accent`, `borderMuted`, `thinkingHigh`). Short `#rgb` hex values expand to `#rrggbb`.
 - `projectRefreshIntervalMs`: project status polling interval; `0` disables polling. Values `1..4999` clamp up to `5000` (minimum 5s); invalid/non-finite values fall back to `30000`.
 - `contextStyle`: `text` (default), `gauge`, or `text+gauge` for the context segment. Context usage refreshes during assistant streaming; token and cost totals remain canonical and finalize at turn boundaries.
+- `editorModelLabel`: controls the model shown in the editor frame. `id` (default) shows the model id; `name` shows the model's display name (including custom `name` values set in `models.json`), falling back to the id when no name is set.
+- `editorMetadataFormat`: JSON-only template for the left side of the editor metadata row. Missing, non-string, or empty values restore the default `$model  $provider(  $thinking)` layout; non-empty strings, including whitespace-only strings, are preserved. See [Editor Metadata Format](#editor-metadata-format) below.
 - `separator`: controls the default footer layout and extension-status connectors: `pipe` (default, ` | `), `dot` (` · `), `chevron` (` › `), or `none` (one space). Cycle it from the `/zentui` **Layout** tab. This selects the separator glyph; `colors.separator` controls its color. Custom `footerFormat` literals and `$sep` keep their existing behavior.
 - `contextThresholds`: `{ warning, error }` percentages (default `70` / `90`) that select contextNormal / contextWarning / contextError colors.
 - `pathDisplay`: controls how the cwd/`$cwd` path is shown. `mode` is `basename` (default, last segment only) or `full` (path with home contracted to `~`). In `full` mode, `depth` keeps only the last N trailing directories (`0` = entire path after `~`, max `5`); when parents are dropped the path is prefixed with `…/` (Starship-style). The `/zentui` **Layout** tab cycles path mode and path depth (`0`–`5`; depth is ignored for basename). Example: `~/Projects/foo/bar` with `depth: 2` → `…/foo/bar`.
@@ -286,7 +293,10 @@ Default config values — copy this and change any value you want:
 - `colorSources`: `theme` maps styles through Pi theme tokens; `terminal` emits terminal colors. `/zentui` switches these sources; manual JSON controls specific style values.
 - `features`: `editor` enables Zentui's custom editor, selector borders, and previous-message chrome. `statusLine` enables Zentui's custom footer/status line. `copyFriendly` hides editor and previous-message rail glyphs so native terminal selection copies less chrome. All three can be changed from `/zentui` or direct slash-command arguments.
 - `footerSegments`: show or hide individual built-in footer segments (`cwd`, `sessionName`, `gitBranch`, `gitStatus`, `gitCounts`, `gitCommit`, `gitMetrics`, `runtime`, `packageVersion`, `sessionDuration`, `username`, `time`, `os`, `context`, `tokens`, `cost`). Toggle them from the `Built-in segments` tab in `/zentui`.
-- `footerFormat`: optional Starship-style template string that fully controls the footer layout. When set, it overrides `footerSegments`. See [Footer Format Template](#footer-format-template) below. The `/zentui` **Layout** tab configures context style, separator, path display mode/depth, branch length, and icon mode; set or clear custom formats with `/zentui format`.
+- `footerFormat`: optional Starship-style template string that fully controls the footer layout. When set, it overrides `footerSegments`. See [Footer Format Template](#footer-format-template) below. The `/zentui` **Layout** tab configures responsive behavior, compact rows, context style, separator, path display mode/depth, branch length, and icon mode; set or clear custom formats with `/zentui format`.
+- `responsiveFooter`: enabled by default. Zentui keeps the current aligned one-row footer while every settings-resolved left/middle/right zone fits without layout truncation. Otherwise it tries two complete left-aligned rows, preferring `left` / `middle right` and then `left middle` / `right`. Only when neither split fits does it use `compactFooterFormat`. Set `false` to restore the legacy one-row fitting behavior. Selection uses measured terminal-cell width, not fixed device breakpoints.
+- `compactFooterFormat`: JSON-only template used by the compact stage. The default keeps cwd, session name, git branch/status, context, and abbreviated token/cache metrics. A top-level `$wrap` is an automatic wrap opportunity: one space on the same row or no space at a row break. `$wrap_sep` is the same kind of boundary but renders the styled ` | ` divider only when its adjacent chunks share a row. Nested uses of either boundary remain empty variables. `$fill` is ignored. A standalone `$extensions` chunk inserts active non-`off` extension statuses in left/middle/right placement order; embedded uses render empty. Custom `footerFormat` values use this built-in compact fallback unless this key is also customized.
+- `compactFooterMaxLines`: `1`, `2`, `3`, or `"unlimited"` (default `2`). Finite limits crop remaining chunks with exactly one trailing `…`. Compact cwd always uses basename mode; cwd/session/branch chunks target half the available row width before final ANSI-aware clamping. `/zentui` exposes the responsive toggle and row limit, while compact format editing remains JSON-only. Pi supplies footer width but no supported viewport-height budget, so `"unlimited"` is explicit.
 - `gitCommit`: Starship [`git_commit`](https://starship.rs/config/#git-commit)-style options for the `gitCommit` footer segment. `hashLength` (default `7`, clamped to `4`–`40`) controls the short-hash display length. `onlyDetached` (default `true`) shows the hash mainly on detached HEAD. `showTag` (default `true`) appends an exact-match tag (`git describe --tags --exact-match HEAD`). The tag probe piggybacks on the existing git refresh — it only runs when both the segment and `showTag` are on, and misses/failures degrade silently.
 - `gitMetrics`: Starship [`git_metrics`](https://starship.rs/config/#git-metrics)-style options for the `gitMetrics` footer segment. Uses `git diff HEAD --numstat` (staged + unstaged combined — the Starship “total dirty” view) to show aggregate `+added −deleted` line counts. `onlyNonzero` (default `true`) omits each zero component independently and hides the segment entirely at `0/0`. `ignoreSubmodules` (default `false`) adds `--ignore-submodules=all`. The numstat diff piggybacks on the existing git refresh and uses a hard 2s timeout; a metrics-only failure degrades silently without discarding fresh branch/status data. On very large monorepos the diff may lag or be omitted on timeout.
 - `extensionStatuses`: controls third-party statuses published by other Pi extensions through `ctx.ui.setStatus()`. `defaultPlacement` and each `placements` value can be `off`, `left`, `middle`, or `right`. The `Extension segments` tab in `/zentui` lists only statuses that are currently active.
@@ -298,6 +308,31 @@ Default config values — copy this and change any value you want:
 
 Tip: when using copy-friendly mode, setting Pi's `editorPaddingX` to `1` in `~/.pi/agent/settings.json` keeps a small left gutter without copying a rail glyph.
 
+## Editor Metadata Format
+
+Set `editorMetadataFormat` in `~/.pi/agent/zentui.json` to customize the left side of the editor metadata row:
+
+```json
+{
+	"editorMetadataFormat": "$model_name ($model_id)( · $provider)( · $thinking)( · $session_name)"
+}
+```
+
+The syntax follows the relevant `footerFormat` conventions: `$variable` and `${variable}` references, literal text and spaces, and conditional groups `( ... )` that disappear when all variables inside are empty. Unknown variables and `$fill` render empty; `$fill` never creates an editor layout zone because the right side remains reserved for structural Vim status.
+
+| Token           | Renders                                                                                       |
+| --------------- | --------------------------------------------------------------------------------------------- |
+| `$model`        | label selected by `editorModelLabel` (`id`, or name with ID fallback)                        |
+| `$model_id`     | active Pi model ID                                                                            |
+| `$model_name`   | active Pi model display name; empty when no name is set                                       |
+| `$provider`     | provider label using Zentui's existing formatting                                             |
+| `$thinking`     | current thinking level; empty when thinking is `off`                                          |
+| `$session_name` | current Pi session name; empty when unnamed                                                    |
+
+Model variables use `editorModel`, provider uses `editorProvider`, and thinking uses the matching `editorThinking*` style. Literal text and `$session_name` use the neutral editor border theme style. The template controls spacing. ANSI/VT sequences, control characters, and line-breaking whitespace are sanitized before rendering without collapsing ordinary spaces.
+
+Missing, non-string, or empty values use the default `$model  $provider(  $thinking)`. A non-empty format that resolves to no visible metadata keeps the normal blank spacer and metadata rows so the editor frame height remains stable. This option is configured only through JSON in its first version; `/zentui format` continues to control the footer only.
+
 ## Footer Format Template
 
 For full control, set a Starship-style `footerFormat` template string. It supports `$variable` and `${variable}` tokens, a special `$fill` token that splits the line into left and right zones, and conditional groups `( ... )` that drop entirely when every nested variable is empty. When set, it overrides the built-in `footerSegments` layout; when empty or omitted, the segment layout above is used.

package/extensions/zentui/config.ts

@@ -32,6 +32,11 @@ export type { IconMode } from "./icons";
 
 export type ContextStyle = "text" | "gauge" | "text+gauge";
 export type SeparatorStyle = "pipe" | "dot" | "chevron" | "none";
+export type ModelLabelSource = "id" | "name";
+export type CompactFooterMaxLines = 1 | 2 | 3 | "unlimited";
+
+export const DEFAULT_COMPACT_FOOTER_FORMAT =
+	"$cwd$wrap(in $session_name)$wrap(on $git_branch) $git_status$wrap$context$wrap_sep$tokens";
 
 export type ContextThresholds = {
 	warning: number;
@@ -121,12 +126,18 @@ export type ExtensionStatusesConfig = {
 
 const DEFAULT_PROJECT_REFRESH_INTERVAL_MS = 30_000;
 const MIN_PROJECT_REFRESH_INTERVAL_MS = 5_000;
+export const DEFAULT_EDITOR_METADATA_FORMAT = "$model  $provider(  $thinking)";
 
 export type PolishedTuiConfig = {
 	projectRefreshIntervalMs: number;
 	footerFormat: string;
+	responsiveFooter: boolean;
+	compactFooterFormat: string;
+	compactFooterMaxLines: CompactFooterMaxLines;
+	editorMetadataFormat: string;
 	separator: SeparatorStyle;
 	contextStyle: ContextStyle;
+	editorModelLabel: ModelLabelSource;
 	contextThresholds: ContextThresholds;
 	pathDisplay: PathDisplayConfig;
 	gitBranch: GitBranchConfig;
@@ -221,8 +232,13 @@ export const configPath = join(getAgentDir(), "zentui.json");
 export const defaultConfig: PolishedTuiConfig = {
 	projectRefreshIntervalMs: DEFAULT_PROJECT_REFRESH_INTERVAL_MS,
 	footerFormat: "",
+	responsiveFooter: true,
+	compactFooterFormat: DEFAULT_COMPACT_FOOTER_FORMAT,
+	compactFooterMaxLines: 2,
+	editorMetadataFormat: DEFAULT_EDITOR_METADATA_FORMAT,
 	separator: "pipe",
 	contextStyle: "text",
+	editorModelLabel: "id",
 	contextThresholds: { warning: 70, error: 90 },
 	pathDisplay: { mode: "basename", depth: 0 },
 	gitBranch: { maxLength: "full" },
@@ -327,6 +343,11 @@ function parseContextStyle(value: unknown): ContextStyle {
 	return defaultConfig.contextStyle;
 }
 
+function parseEditorModelLabel(value: unknown): ModelLabelSource {
+	if (value === "id" || value === "name") return value;
+	return defaultConfig.editorModelLabel;
+}
+
 export function isSeparatorStyle(value: unknown): value is SeparatorStyle {
 	return value === "pipe" || value === "dot" || value === "chevron" || value === "none";
 }
@@ -388,6 +409,10 @@ function stringValue(record: Record<string, unknown>, key: string): string | und
 	return typeof value === "string" ? value : undefined;
 }
 
+function parseCompactFooterMaxLines(value: unknown): CompactFooterMaxLines {
+	return value === 1 || value === 2 || value === 3 || value === "unlimited" ? value : 2;
+}
+
 function colorValue(record: Record<string, unknown>, key: string): string | undefined {
 	const value = stringValue(record, key);
 	return value !== undefined && isSupportedColorSpec(value) ? value : undefined;
@@ -761,11 +786,27 @@ export function mergeConfig(parsed: unknown): PolishedTuiConfig {
 	const fixedEditor = isRecord(config.fixedEditor)
 		? normalizeFixedEditorConfig(config.fixedEditor as Record<string, unknown>)
 		: defaultConfig.fixedEditor;
+	const editorMetadataFormat = stringValue(config, "editorMetadataFormat");
+	const compactFooterFormat = stringValue(config, "compactFooterFormat");
 	return {
 		projectRefreshIntervalMs: parseProjectRefreshIntervalMs(config.projectRefreshIntervalMs),
 		footerFormat: stringValue(config, "footerFormat") ?? "",
+		responsiveFooter:
+			typeof config.responsiveFooter === "boolean"
+				? config.responsiveFooter
+				: defaultConfig.responsiveFooter,
+		compactFooterFormat:
+			compactFooterFormat && compactFooterFormat.length > 0
+				? compactFooterFormat
+				: DEFAULT_COMPACT_FOOTER_FORMAT,
+		compactFooterMaxLines: parseCompactFooterMaxLines(config.compactFooterMaxLines),
+		editorMetadataFormat:
+			editorMetadataFormat && editorMetadataFormat.length > 0
+				? editorMetadataFormat
+				: DEFAULT_EDITOR_METADATA_FORMAT,
 		separator: parseSeparatorStyle(config.separator),
 		contextStyle: parseContextStyle(config.contextStyle),
+		editorModelLabel: parseEditorModelLabel(config.editorModelLabel),
 		contextThresholds: parseContextThresholds(config.contextThresholds),
 		pathDisplay: parsePathDisplay(config.pathDisplay),
 		gitBranch,
@@ -862,6 +903,25 @@ export function saveFooterFormatPatch(value: string, path = configPath): Polishe
 	});
 }
 
+export function saveResponsiveFooterPatch(
+	patch: Partial<
+		Pick<PolishedTuiConfig, "responsiveFooter" | "compactFooterFormat" | "compactFooterMaxLines">
+	>,
+	path = configPath,
+): PolishedTuiConfig {
+	return mutateConfig(path, (record) => {
+		if (typeof patch.responsiveFooter === "boolean") {
+			record.responsiveFooter = patch.responsiveFooter;
+		}
+		if (typeof patch.compactFooterFormat === "string") {
+			record.compactFooterFormat = patch.compactFooterFormat;
+		}
+		if (patch.compactFooterMaxLines !== undefined) {
+			record.compactFooterMaxLines = parseCompactFooterMaxLines(patch.compactFooterMaxLines);
+		}
+	});
+}
+
 export function saveIconsModePatch(mode: IconMode, path = configPath): PolishedTuiConfig {
 	return mutateConfig(path, (record) => {
 		const existing = isRecord(record.icons) ? { ...(record.icons as Record<string, unknown>) } : {};

package/extensions/zentui/editor-metadata-format.ts

@@ -0,0 +1,259 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { PolishedTuiConfig } from "./config";
+import { type FormatToken, parseFooterFormat } from "./footer-format";
+import { EDITOR_ACCENT_FALLBACK, renderStyleForSourceOrFallback, safeThemeFg } from "./style";
+
+export type EditorMetadataValues = {
+	model: string;
+	modelId: string;
+	modelName: string;
+	provider: string;
+	thinking: string;
+	sessionName: string;
+};
+
+type RenderedTokens = {
+	styled: string;
+	hasDynamic: boolean;
+	hasNonEmptyDynamic: boolean;
+};
+
+const ESC = 0x1b;
+const BEL = 0x07;
+const CAN = 0x18;
+const SUB = 0x1a;
+const C1_DCS = 0x90;
+const C1_CSI = 0x9b;
+const C1_ST = 0x9c;
+const C1_OSC = 0x9d;
+const C1_SOS = 0x98;
+const C1_PM = 0x9e;
+const C1_APC = 0x9f;
+
+function consumeCsi(value: string, start: number): number {
+	for (let index = start; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code === CAN || code === SUB) return index + 1;
+		if (code >= 0x40 && code <= 0x7e) return index + 1;
+	}
+	return value.length;
+}
+
+function consumeControlString(value: string, start: number, allowBel: boolean): number {
+	for (let index = start; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code === CAN || code === SUB) return index + 1;
+		if (allowBel && code === BEL) return index + 1;
+		if (code === C1_ST) return index + 1;
+		if (code === ESC && value.charCodeAt(index + 1) === 0x5c) return index + 2;
+	}
+	return value.length;
+}
+
+function consumeEscape(value: string, start: number): number {
+	if (start + 1 >= value.length) return value.length;
+	const next = value.charCodeAt(start + 1);
+	if (next === 0x5b) return consumeCsi(value, start + 2);
+	if (next === 0x5d) return consumeControlString(value, start + 2, true);
+	if (next === 0x50 || next === 0x58 || next === 0x5e || next === 0x5f) {
+		return consumeControlString(value, start + 2, false);
+	}
+
+	let index = start + 1;
+	while (index < value.length) {
+		const code = value.charCodeAt(index);
+		if (code >= 0x20 && code <= 0x2f) {
+			index += 1;
+			continue;
+		}
+		return code >= 0x30 && code <= 0x7e ? index + 1 : index;
+	}
+	return value.length;
+}
+
+function isNormalizedWhitespace(code: number): boolean {
+	return (
+		code === 0x09 ||
+		code === 0x0a ||
+		code === 0x0b ||
+		code === 0x0c ||
+		code === 0x0d ||
+		code === 0x85 ||
+		code === 0x2028 ||
+		code === 0x2029
+	);
+}
+
+export function sanitizeEditorMetadataText(value: string): string {
+	let sanitized = "";
+	for (let index = 0; index < value.length; ) {
+		const code = value.charCodeAt(index);
+		if (code === ESC) {
+			index = consumeEscape(value, index);
+			continue;
+		}
+		if (code === C1_CSI) {
+			index = consumeCsi(value, index + 1);
+			continue;
+		}
+		if (code === C1_OSC) {
+			index = consumeControlString(value, index + 1, true);
+			continue;
+		}
+		if (code === C1_DCS || code === C1_SOS || code === C1_PM || code === C1_APC) {
+			index = consumeControlString(value, index + 1, false);
+			continue;
+		}
+		if (isNormalizedWhitespace(code)) {
+			sanitized += " ";
+			do index += 1;
+			while (index < value.length && isNormalizedWhitespace(value.charCodeAt(index)));
+			continue;
+		}
+		if (code < 0x20 || (code >= 0x7f && code <= 0x9f)) {
+			index += 1;
+			continue;
+		}
+		sanitized += value[index];
+		index += 1;
+	}
+	return sanitized;
+}
+
+function editorThinkingStyle(config: PolishedTuiConfig, level: string): string | undefined {
+	switch (level.toLowerCase()) {
+		case "minimal":
+			return config.colors.editorThinkingMinimal ?? config.colors.editorThinking;
+		case "low":
+			return config.colors.editorThinkingLow ?? config.colors.editorThinking;
+		case "medium":
+			return config.colors.editorThinkingMedium ?? config.colors.editorThinking;
+		case "high":
+			return config.colors.editorThinkingHigh ?? config.colors.editorThinking;
+		case "xhigh":
+			return config.colors.editorThinkingXhigh ?? config.colors.editorThinking;
+		default:
+			return config.colors.editorThinking;
+	}
+}
+
+function renderVariable(
+	name: string,
+	values: EditorMetadataValues,
+	uiTheme: Theme,
+	config: PolishedTuiConfig,
+): { plain: string; styled: string } {
+	const colorSource = config.colorSources.editor;
+	const thinking = values.thinking.toLowerCase() === "off" ? "" : values.thinking;
+	const raw =
+		name === "model"
+			? values.model
+			: name === "model_id"
+				? values.modelId
+				: name === "model_name"
+					? values.modelName
+					: name === "provider"
+						? values.provider
+						: name === "thinking"
+							? thinking
+							: name === "session_name"
+								? values.sessionName
+								: "";
+	const plain = sanitizeEditorMetadataText(raw);
+	if (!plain) return { plain: "", styled: "" };
+
+	if (name === "model" || name === "model_id" || name === "model_name") {
+		return {
+			plain,
+			styled: renderStyleForSourceOrFallback(
+				uiTheme,
+				colorSource,
+				config.colors.editorModel,
+				EDITOR_ACCENT_FALLBACK,
+				plain,
+			),
+		};
+	}
+	if (name === "provider") {
+		return {
+			plain,
+			styled: renderStyleForSourceOrFallback(
+				uiTheme,
+				colorSource,
+				config.colors.editorProvider,
+				"text",
+				plain,
+			),
+		};
+	}
+	if (name === "thinking") {
+		return {
+			plain,
+			styled: renderStyleForSourceOrFallback(
+				uiTheme,
+				colorSource,
+				editorThinkingStyle(config, plain),
+				"muted",
+				plain,
+			),
+		};
+	}
+	if (name === "session_name") {
+		return { plain, styled: safeThemeFg(uiTheme, "border", plain) };
+	}
+	return { plain: "", styled: "" };
+}
+
+function renderTokens(
+	tokens: FormatToken[],
+	values: EditorMetadataValues,
+	uiTheme: Theme,
+	config: PolishedTuiConfig,
+): RenderedTokens {
+	let styled = "";
+	let hasDynamic = false;
+	let hasNonEmptyDynamic = false;
+
+	for (const token of tokens) {
+		if (token.kind === "text") {
+			const plain = sanitizeEditorMetadataText(token.value);
+			if (plain) styled += safeThemeFg(uiTheme, "border", plain);
+			continue;
+		}
+		if (token.kind === "fill") {
+			hasDynamic = true;
+			continue;
+		}
+		if (token.kind === "var") {
+			hasDynamic = true;
+			const rendered = renderVariable(token.name, values, uiTheme, config);
+			styled += rendered.styled;
+			if (rendered.plain) hasNonEmptyDynamic = true;
+			continue;
+		}
+
+		const rendered = renderTokens(token.tokens, values, uiTheme, config);
+		const visible = !rendered.hasDynamic || rendered.hasNonEmptyDynamic;
+		hasDynamic = true;
+		if (visible) {
+			styled += rendered.styled;
+			hasNonEmptyDynamic = true;
+		}
+	}
+
+	return { styled, hasDynamic, hasNonEmptyDynamic };
+}
+
+export function renderEditorMetadataFormat(
+	format: string,
+	values: EditorMetadataValues,
+	uiTheme: Theme,
+	config: PolishedTuiConfig,
+): string {
+	return renderTokens(
+		parseFooterFormat(sanitizeEditorMetadataText(format)),
+		values,
+		uiTheme,
+		config,
+	).styled;
+}

package/extensions/zentui/footer-format.ts

@@ -13,6 +13,12 @@ export type FormatToken =
 	| { kind: "fill" }
 	| { kind: "group"; tokens: FormatToken[] };
 
+export type CompactBoundaryKind = "space" | "separator";
+
+export type CompactFormatChunk =
+	| { kind: "tokens"; tokens: FormatToken[]; boundary: CompactBoundaryKind }
+	| { kind: "extensions"; boundary: CompactBoundaryKind };
+
 const TOKEN_REGEX = /\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}|\$([a-zA-Z_][a-zA-Z0-9_]*)/g;
 
 /**
@@ -151,6 +157,85 @@ export function renderFormatSplit(
 	};
 }
 
+export function compileCompactFormat(tokens: FormatToken[]): CompactFormatChunk[] {
+	const chunks: CompactFormatChunk[] = [];
+	let current: FormatToken[] = [];
+	let incomingBoundary: CompactBoundaryKind = "space";
+
+	const flush = () => {
+		const normalized = trimBoundaryWhitespace(current);
+		current = [];
+		if (normalized.length === 0) return;
+		if (
+			normalized.length === 1 &&
+			normalized[0]?.kind === "var" &&
+			normalized[0].name === "extensions"
+		) {
+			chunks.push({ kind: "extensions", boundary: incomingBoundary });
+			return;
+		}
+		chunks.push({ kind: "tokens", tokens: normalized, boundary: incomingBoundary });
+	};
+
+	for (const token of tokens) {
+		if (token.kind === "var" && (token.name === "wrap" || token.name === "wrap_sep")) {
+			flush();
+			incomingBoundary = token.name === "wrap_sep" ? "separator" : "space";
+			continue;
+		}
+		if (token.kind === "fill") continue;
+		current.push(token);
+	}
+	flush();
+	return chunks;
+}
+
+function trimBoundaryWhitespace(tokens: FormatToken[]): FormatToken[] {
+	const result = tokens.map((token) => (token.kind === "text" ? { ...token } : token));
+	while (result[0]?.kind === "text") {
+		result[0].value = result[0].value.replace(/^\s+/, "");
+		if (result[0].value) break;
+		result.shift();
+	}
+	while (result.at(-1)?.kind === "text") {
+		const last = result.at(-1);
+		if (last?.kind !== "text") break;
+		last.value = last.value.replace(/\s+$/, "");
+		if (last.value) break;
+		result.pop();
+	}
+	return result;
+}
+
+export function renderFormatTokens(
+	tokens: FormatToken[],
+	renderVariable: (name: string) => string,
+): string {
+	return renderTokenSlice(tokens, 0, tokens.length, renderVariable);
+}
+
+export function collectFooterFormatReferences(
+	tokens: FormatToken[],
+	aliases: Record<string, string> = {},
+): Set<string> {
+	const references = new Set<string>();
+	const visit = (items: FormatToken[]) => {
+		for (const token of items) {
+			if (token.kind === "group") {
+				visit(token.tokens);
+				continue;
+			}
+			if (token.kind !== "var") continue;
+			const canonical = aliases[token.name] ?? token.name;
+			if (canonical !== "wrap" && canonical !== "wrap_sep" && canonical !== "extensions") {
+				references.add(canonical);
+			}
+		}
+	};
+	visit(tokens);
+	return references;
+}
+
 function findTopLevelFillIndices(tokens: FormatToken[]): number[] {
 	const fillIndices: number[] = [];
 	for (let index = 0; index < tokens.length; index++) {

package/extensions/zentui/footer-layout.ts

@@ -0,0 +1,122 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { CompactFooterMaxLines } from "./config";
+import type { CompactBoundaryKind } from "./footer-format";
+
+export type FooterZones = {
+	left: string;
+	middle: string;
+	right: string;
+};
+
+export function fullFooterFitsAligned(zones: FooterZones, innerWidth: number): boolean {
+	const leftWidth = visibleWidth(zones.left);
+	const middleWidth = visibleWidth(zones.middle);
+	const rightWidth = visibleWidth(zones.right);
+	if (middleWidth === 0) {
+		return leftWidth + rightWidth + (leftWidth > 0 && rightWidth > 0 ? 1 : 0) <= innerWidth;
+	}
+
+	const gapWidth = innerWidth - leftWidth - rightWidth;
+	if (gapWidth < middleWidth) return false;
+	const leftPadding = Math.floor((gapWidth - middleWidth) / 2);
+	const rightPadding = gapWidth - middleWidth - leftPadding;
+	return (leftWidth === 0 || leftPadding >= 1) && (rightWidth === 0 || rightPadding >= 1);
+}
+
+function joinZones(parts: string[]): string {
+	return parts.filter(Boolean).join(" ");
+}
+
+function validRows(rows: string[], innerWidth: number): string[] | undefined {
+	const nonEmpty = rows.filter(Boolean);
+	if (nonEmpty.length === 0 || nonEmpty.length > 2) return undefined;
+	return nonEmpty.every((row) => visibleWidth(row) <= innerWidth) ? nonEmpty : undefined;
+}
+
+/** Prefer project identity alone, with middle/right status on the second row. */
+export function reflowFullFooter(zones: FooterZones, innerWidth: number): string[] | undefined {
+	const preferred = validRows([zones.left, joinZones([zones.middle, zones.right])], innerWidth);
+	if (preferred) return preferred;
+	return validRows([joinZones([zones.left, zones.middle]), zones.right], innerWidth);
+}
+
+export function compactChunkBudget(innerWidth: number): number {
+	return Math.max(8, Math.floor((innerWidth - 1) / 2));
+}
+
+export type CompactLayoutChunk = {
+	text: string;
+	boundary: CompactBoundaryKind;
+};
+
+type PackedRow = {
+	text: string;
+	endsWithRendererEllipsis: boolean;
+};
+
+function fitChunk(chunk: string, innerWidth: number): PackedRow {
+	if (visibleWidth(chunk) <= innerWidth) {
+		return { text: chunk, endsWithRendererEllipsis: false };
+	}
+	return {
+		text: truncateToWidth(chunk, innerWidth, "…"),
+		endsWithRendererEllipsis: true,
+	};
+}
+
+function appendOmissionMarker(row: PackedRow, innerWidth: number): PackedRow {
+	if (row.endsWithRendererEllipsis) return row;
+	if (innerWidth <= 1) return { text: "…", endsWithRendererEllipsis: true };
+	return {
+		text: `${truncateToWidth(row.text, innerWidth - 1, "")}…`,
+		endsWithRendererEllipsis: true,
+	};
+}
+
+export function packCompactChunks(
+	chunks: CompactLayoutChunk[],
+	innerWidth: number,
+	maxLines: CompactFooterMaxLines,
+	separator: string,
+): string[] {
+	if (innerWidth <= 0) return [""];
+	const content = chunks
+		.map((chunk) => ({ ...chunk, text: chunk.text.trim() }))
+		.filter((chunk) => chunk.text.length > 0);
+	if (content.length === 0) return [""];
+
+	const finiteLimit = maxLines === "unlimited" ? Number.POSITIVE_INFINITY : maxLines;
+	const rows: PackedRow[] = [];
+	let current: PackedRow | undefined;
+	let omitted = false;
+
+	for (const chunk of content) {
+		const fitted = fitChunk(chunk.text, innerWidth);
+		if (!current) {
+			current = fitted;
+			continue;
+		}
+
+		const join = chunk.boundary === "separator" ? separator : " ";
+		const candidate = `${current.text}${join}${fitted.text}`;
+		if (visibleWidth(candidate) <= innerWidth) {
+			current = {
+				text: candidate,
+				endsWithRendererEllipsis: fitted.endsWithRendererEllipsis,
+			};
+			continue;
+		}
+
+		if (rows.length + 1 < finiteLimit) {
+			rows.push(current);
+			current = fitted;
+			continue;
+		}
+
+		omitted = true;
+		break;
+	}
+
+	if (current) rows.push(omitted ? appendOmissionMarker(current, innerWidth) : current);
+	return rows.map((row) => truncateToWidth(row.text, innerWidth, ""));
+}