pi-zentui 0.25.0 → 0.26.0

package/README.md

@@ -1,6 +1,6 @@
 <h1 align="center">Zentui</h1>
 
-<p align="center">A Starship-inspired statusline and Opencode-style TUI for <a href="https://pi.dev">Pi</a>.</p>
+<p align="center">A modular terminal UI for <a href="https://pi.dev">Pi</a>.</p>
 
 <p align="center">
   <a href="https://www.npmjs.com/package/pi-zentui"><img alt="npm version" src="https://shieldcn.dev/npm/pi-zentui.svg?variant=outline" /></a>
@@ -14,13 +14,13 @@
 
 ## What is this?
 
-Zentui gives Pi surfaces independently selectable treatments:
+Zentui lets you shape Pi’s interface one component at a time. Customize your editor, messages, progress display, and footer independently—use the pieces you want and leave the rest native.
 
 - **Editor** — Opencode, Opencode copy-friendly, Accent Rail, and Minimalist input treatments
 - **User messages** — framed, framed copy-friendly, compact, and labeled transcript messages
 - **Thinking (Experimental)** — optional Rail, Tree, or Streaming private thinking renderers, without owning the Working line
 - **Working line** — optional ownership of Pi's complete in-progress row and settled turn summary
-- **Footer** — Pi's native Footer, a Starship-style statusline, or a hidden zero-row Footer
+- **Footer** — Pi's native Footer, a Starship-style statusline, or Hidden (only allowed extension statuses)
 
 Editor, User messages, Thinking (Experimental), Working line, and selector borders have independent `enabled` fields. Footer uses one `style`: `native`, `starship`, or `hidden`. Use `/zentui` to configure each component without coupling it to the others.
 
@@ -91,7 +91,7 @@ pi install git:github.com/lmilojevicc/pi-zentui
 
 ## Configure
 
-Run `/zentui` inside Pi to configure Appearance, Editor, User messages, Thinking (Experimental), Working line, and Footer. With Starship selected, Footer contains **Segments →**, **Git →**, and **Extension statuses →** child pages. Use `Tab` and `Shift+Tab` to switch sections; compact help follows your configured selection keys. Every section has a direct route (for example, `/zentui footer`). `/zentui segments`, `/zentui git`, and `/zentui extensions` open the Footer child pages when Starship is active; under Native or Hidden they open Footer with a requires-Starship explanation, without changing style or saved preferences. The configured cancel key returns from a child to Footer; at the top level it closes settings. Extension statuses are published keyed Footer statuses, not extension management or Working line integrations. Inactive options retain their saved preferences. Most changes apply live. Active Streaming can switch live to Rail or Tree, and Rail and Tree can switch live between each other. Entering Streaming from a structural mode, first enable, and re-enable after a live disable require restarting Pi. Configuration is saved to:
+Run `/zentui` inside Pi to configure Appearance, Editor, User messages, Thinking (Experimental), Working line, Footer, and Extension statuses. With Starship selected, Footer contains **Segments →** and **Git →** child pages. Use `Tab` and `Shift+Tab` to switch sections; compact help follows your configured selection keys. Every section has a direct route (for example, `/zentui footer`). `/zentui segments` and `/zentui git` open Footer child pages when Starship is active; under Native or Hidden they open Footer with a requires-Starship explanation. `/zentui extensions` always opens independent default/per-key status visibility, without changing Footer style or saved Starship placement/color preferences. The configured cancel key returns from a child to Footer; at the top level it closes settings. Extension statuses are published keyed Footer statuses, not extension management or Working line integrations. Inactive options retain their saved preferences. Most changes apply live. Active Streaming can switch live to Rail or Tree, and Rail and Tree can switch live between each other. Entering Streaming from a structural mode, first enable, and re-enable after a live disable require restarting Pi. Configuration is saved to:
 
 ```text
 ~/.pi/agent/zentui.json
@@ -106,9 +106,9 @@ Choose **Appearance → Preset** in `/zentui`, or run `/zentui preset <id>`:
 | `opencode` | Opencode | Starship | Framed |
 | `opencode-copy-friendly` | Opencode (copy-friendly) | Starship | Framed (copy-friendly) |
 | `rail` | Accent Rail | Starship | Compact (accent rail) |
-| `minimalist` | Minimalist | Hidden (zero rows) | Zentui styling disabled |
+| `minimalist` | Minimalist | Hidden (statuses only) | Zentui styling disabled |
 
-Presets apply once, saving only these component selections. Colors, color sources, style options, icons, Footer segments/formats, selector borders, Working line, and Thinking remain unchanged. Minimalist preserves the dormant message style and leaves Pi's native message presentation alone. Hidden suppresses the Footer; it is not Native.
+Presets apply once, saving only these component selections. Colors, color sources, style options, icons, Footer segments/formats, selector borders, Working line, and Thinking remain unchanged. Minimalist preserves the dormant message style and leaves Pi's native message presentation alone. Hidden suppresses main Footer segments, not allowed extension statuses; it is not Native.
 
 The displayed preset is derived from your current selections: individual changes may show **Custom**, and returning to a matching combination restores its name. No `preset` config key is saved or reapplied at startup. Defaults are unchanged and match Opencode. Selecting a preset keeps settings open for further adjustments. Editor installation waits until the panel closes; if editor ownership prevents application, the saved choice may require reloading Pi.
 
@@ -141,7 +141,7 @@ To adopt **only User messages**, explicitly leave the other default-enabled surf
 }
 ```
 
-Disabled/Native leaves Pi or a predecessor in control. Hidden instead intentionally owns zero Footer rows. Ordinary saves snapshot only the edited owner. `/zentui migrate` is a separate confirmed all-owner selection/source/style-option snapshot; it preserves aliases, unknown fields, and shared color inheritance, and never copies generated palettes. See the configuration reference for exact owner color keys and reset behavior.
+Disabled/Native leaves Pi or a predecessor in control. Hidden instead shows only allowed extension statuses below the editor, with no row when empty. Ordinary saves snapshot only the edited owner. `/zentui migrate` is a separate confirmed all-owner selection/source/style-option snapshot; it preserves aliases, unknown fields, and shared color inheritance, and never copies generated palettes. See the configuration reference for exact owner color keys and reset behavior.
 
 Detailed reference:
 

package/docs/configuration.md

@@ -31,11 +31,11 @@ To adopt only User messages while leaving the other default-enabled surfaces nat
 }
 ```
 
-Native releases Zentui's ownership; Hidden deliberately installs a zero-row Footer. Disabling a component preserves its dormant preferences. See [color overrides and inheritance](#component-color-overrides-and-inheritance) and [explicit migration](#compatibility-and-migration) before snapshotting legacy settings.
+Native releases Zentui's ownership; Hidden hides Footer metrics, path, and model segments but keeps allowed extension statuses on one line below the editor. With no nonempty allowed statuses, it renders no rows. Disabling a component preserves its dormant preferences. See [color overrides and inheritance](#component-color-overrides-and-inheritance) and [explicit migration](#compatibility-and-migration) before snapshotting legacy settings.
 
 ## `/zentui` settings
 
-The interactive `/zentui` menu is split into six component-oriented sections. Use `Tab` and `Shift+Tab` to switch sections. Selection/Change/Back/Close hints follow injected host keybindings (with older-host defaults when unavailable). Narrow help retains Change, Sections, and Back (on child pages) or Close guidance:
+The interactive `/zentui` menu is split into seven component-oriented sections. Use `Tab` and `Shift+Tab` to switch sections. Selection/Change/Back/Close hints follow injected host keybindings (with older-host defaults when unavailable). Narrow help retains Change, Sections, and Back (on child pages) or Close guidance:
 
 1. **Appearance** — component Preset; selector-border enablement, informational fixed style, and colors; icon mode.
 2. **Editor** — enablement, style, colors, Codex quota, model label, border behavior, viewport indicators, settings for the selected editor style, and a static synthetic preview.
@@ -45,13 +45,13 @@ The interactive `/zentui` menu is split into six component-oriented sections. Us
 6. **Footer** — Native, Starship, or Hidden. Starship additionally exposes colors, Codex quota, model label, responsive layout, separator, context style, and path display.
    - **Segments →** — visibility toggles for non-Git Starship segments.
    - **Git →** — Starship Footer Git segment and probe controls, not Editor Git controls.
-   - **Extension statuses →** — Starship placement and color controls for active published keyed Footer statuses; not extension management or Working line integrations.
+7. **Extension statuses** — one Default placement and each observed/saved extension's placement and color. Off controls visibility; positions are saved per Footer mode.
 
-The three Footer child entries appear only with Starship selected. Child headings show their scope (for example, **Footer > Git**). The configured cancel key returns to Footer focused on the originating child entry; at the top level it still closes settings. `Tab` / `Shift+Tab` remain available on child pages to move to the next / previous top-level section relative to Footer. Visiting or backing out of a page does not save settings or change component ownership.
+The two Footer child entries appear only with Starship selected. Child headings show their scope (for example, **Footer > Git**). The configured cancel key returns to Footer focused on the originating child entry; at the top level it still closes settings. `Tab` / `Shift+Tab` remain available on child pages to move to the next / previous top-level section relative to Footer. Visiting or backing out of a page does not save settings or change component ownership.
 
-Editor, User messages, Thinking (Experimental), and Working line retain independent configuration. Editor, User-message, and Thinking previews remain visible while their component is disabled. Only the Working-line preview owns an animation timer. Starship-specific rows are shown only while Starship is selected. Footer Color overrides remain available for preconfiguration under every Footer style and say **Saved for Starship** when inactive. Native and Hidden hide the three child entries without changing their saved preferences. Other dormant choices explain their scope without rewriting values. Auto icons assume a Nerd Font without detecting one; ASCII replaces icons only, not all borders or UI glyphs.
+Editor, User messages, Thinking (Experimental), and Working line retain independent configuration. Editor, User-message, and Thinking previews remain visible while their component is disabled. Only the Working-line preview owns an animation timer. Footer’s Starship-specific rows are shown only while Starship is selected; Extension statuses offers the same unprefixed placement/color rows in every Footer style. Native saves dormant Starship position/color preferences without changing Pi's layout. Footer Color overrides remain available for preconfiguration under every Footer style and say **Saved for Starship** when inactive. Native and Hidden hide the two child entries without changing their saved preferences. Other dormant choices explain their scope without rewriting values. Auto icons assume a Nerd Font without detecting one; ASCII replaces icons only, not all borders or UI glyphs.
 
-Free-form values such as custom formats, Opencode metadata formats, and inactive extension keys remain JSON-only. Component raw colors are editable through each component’s **Color overrides** action, with explicit **Reset / inherit**. Working-line speed accepts validated custom milliseconds in `/zentui`.
+Free-form values such as custom formats, Opencode metadata formats, and previously unseen, unsaved extension keys remain JSON-only. Component raw colors are editable through each component’s **Color overrides** action, with explicit **Reset / inherit**. Working-line speed accepts validated custom milliseconds in `/zentui`.
 
 Every section and Footer child page has a direct route and completion:
 
@@ -67,7 +67,7 @@ Every section and Footer child page has a direct route and completion:
 /zentui extensions
 ```
 
-`/zentui segments`, `/zentui git`, and `/zentui extensions` open the corresponding **Footer > …** child page when Starship is active. Under Native or Hidden, they instead open Footer with a requires-Starship explanation; they do not show active child controls, enable Starship, or write configuration.
+`/zentui segments` and `/zentui git` open the corresponding **Footer > …** child page when Starship is active. Under Native or Hidden, they instead open Footer with a requires-Starship explanation; they do not show active child controls, enable Starship, or write configuration. `/zentui extensions` always opens the independent Extension statuses section.
 
 `messages` and `thinking-steps` remain section aliases; Footer also accepts the aliases below. Useful slash-command shortcuts:
 
@@ -115,16 +115,55 @@ These are one-time, atomic selection patches, not ongoing profiles. Only the lis
 
 **Custom** is a derived display state, not a selectable preset or a saved key. Matching checks only the listed selection leaves, not colors/options or current runtime ownership; Minimalist ignores dormant message style. Unsupported active selected styles do not match. Hand-editing or individually changing a selection can show Custom; returning to a matching combination restores the preset label. No `preset` config key is used, and nothing is automatically reapplied on startup. New-install defaults remain unchanged and match Opencode.
 
-The existing Minimalist editor stays enabled with its saved metadata/options. Disabled User messages releases only Zentui styling, leaving native or predecessor rendering intact. Hidden installs an owned zero-row Footer, whereas Native releases Zentui's Footer to Pi or a predecessor; `/zentui statusline disable` still selects Native, not Hidden.
+The existing Minimalist editor stays enabled with its saved metadata/options. Disabled User messages releases only Zentui styling, leaving native or predecessor rendering intact. Hidden owns a status-only Footer (no rows when no allowed statuses remain), whereas Native releases Zentui's Footer to Pi or a predecessor; `/zentui statusline disable` still selects Native, not Hidden.
 
 Selecting presets keeps the settings panel open and preserves its focus. Config, Footer, and User messages update immediately; editor installation waits until the panel closes and Pi restores the draft. Only the latest editor settings are reconciled on exit, and shutdown cancels pending installation. With public editor-text APIs available, opening settings expands nonempty drafts before Pi snapshots them, preserving collapsed paste contents; this can move the cursor to the end and add an undo step. Empty drafts are untouched. Older hosts without these APIs retain Pi's existing draft-restoration behavior. Saves fail without changing active settings or overwriting corrupt/unreadable JSON. Live application reconciles only Editor, User messages, Footer, and dependent timers. Editor ownership restrictions are reported as saved-but-not-applied/reload-required; Footer host failures retain existing fail-open behavior. Direct preset commands also save in non-TUI modes without installing TUI components. Unknown IDs, missing IDs, and extra arguments do not change settings.
 
+### Extension-status visibility
+
+`/zentui extensions` is available with Native, Hidden, or Starship Footer. It shows **Default placement**, then each observed or saved extension's **placement** and **color** (Original, Zentui). Both placement controls offer only Left, Middle, Right, Off, in that order. No separate visibility rows or mode prefixes are shown. Unset or inherited placements display their effective position or Off, not a selectable Default value. Off hides statuses via `components.extensionStatuses`; a positive per-extension placement explicitly shows that key even when the default is Off. Choices save atomically; merely opening the panel does not rewrite config:
+
+```json
+{
+  "components": {
+    "extensionStatuses": {
+      "defaultVisibility": "show",
+      "visibility": { "github-pr": "hide" }
+    }
+  }
+}
+```
+
+Off suppresses observed publications through Pi's public `setStatus` method. A visible choice passes the original text through; the current Footer still controls rendering. Hidden renders nonempty allowed statuses on one minimal line below the editor, preserving incoming colors by default and Pi's key ordering within each placement, with safe single-line text and width truncation. Default Off hides inherited keys; per-key Off hides that key. No remaining statuses means no blank row. Starship's local `off` placement still omits a shown status only in Starship, never in Hidden. Starship placement/color preserve their existing Footer-owned preferences; they do not route or recolor Hidden or native/third-party footers. Native positive placements save dormant Starship preferences and Show visibility but never move Pi's native statuses. Historical Starship `off` settings never become global Off in Native or Hidden.
+
+With Hidden selected, default placement starts at Left. To restore inheritance in config, remove the key's visibility and Hidden placement overrides; its color can remain saved. These sparse preferences live in `components.extensionStatuses.hidden`, independently of Starship and visibility:
+
+```json
+{
+  "components": {
+    "extensionStatuses": {
+      "hidden": {
+        "defaultPlacement": "left",
+        "placements": { "github-pr": "right", "sync": "middle" },
+        "colorModes": { "github-pr": "zentui" }
+      }
+    }
+  }
+}
+```
+
+Each color under Hidden offers Original (the default) or Zentui. Original keeps the extension's supplied styling and safe links. Zentui shows plain text in the active Pi theme's `muted` color, independently of Starship's palette and color-source settings. Choices are saved in `components.extensionStatuses.hidden.colorModes`; selecting Original removes only that key's override. Color changes do not alter visibility or placement.
+
+Left and Right anchor to the edges; Middle is terminal-centered, then clamped between them. Crowded zones share space fairly and truncate safely with at least one separating cell. At widths too narrow for all zones, Left, Middle, then Right take priority. Original mode preserves incoming styles and safe links; resets prevent colors/backgrounds/links from leaking into padding or another status. Off and explicit positions change visibility; no choice changes Footer style. Hidden never inherits Starship's `off`, placement, or colors. Switching Footer style retains both sets of preferences; Native keeps native positioning.
+
+Discovery is best-effort and session-scoped: observed raw keys and saved visibility/Hidden/Starship keys remain editable, with already-owned Starship or Hidden Footer data supplementing discovery only, never suppression/replay provenance. Hidden also applies visibility to those provider statuses when rendering; it does not republish them. Zentui never installs a Footer just to discover statuses. **No observed statuses** does not mean no extensions are running. Publications before observation, cached setters, separate UI contexts, and nondelegating successor extensions may bypass these controls. Unsupported/frozen setter shapes fail open. Cleanup restores only safely owned suppression and does not overwrite a successor setter or replay uncertain stale values. This controls keyed status visibility, not extension enablement or Working-line integrations.
+
 ### Extension-status hyperlinks
 
 An extension's **Original** color mode preserves SGR styling and HTTP/HTTPS
 OSC 8 hyperlinks supplied by that extension. For example, set
 `components.footer.styles.starship.extensionStatuses.colorModes.github-pr` to
-`"original"` to retain a PR link from a GitHub status extension. Open it with
+`"original"` to retain a PR link from a GitHub status extension. Hidden's color choice is separate, under `components.extensionStatuses.hidden.colorModes`, and defaults to Original. Open it with
 your terminal's link-opening gesture. Other URL schemes and unrelated terminal
 controls (including clipboard, title, and cursor commands) are removed.
 
@@ -232,6 +271,10 @@ Reference only—not a starter file. Prefer the minimal overrides above. Optiona
         "tokens": true
       }
     },
+    "extensionStatuses": {
+      "defaultVisibility": "show",
+      "visibility": {}
+    },
     "selectorBorders": {
       "enabled": true,
       "style": "zentui",
@@ -370,9 +413,9 @@ Reference only—not a starter file. Prefer the minimal overrides above. Optiona
 - All three modes decorate Pi's private host renderer and are tested on exact Pi versions 0.80.5, 0.82.1, 0.83.0, 0.84.0, 0.84.4, and 0.85.1. Active Streaming can switch live to Rail or Tree, and Rail and Tree can switch live between each other. Entering Streaming from a structural mode, first enable, and re-enable after live disable require restart; live disable restores native thinking. Disabled mode changes only preconfigure.
 - `components.workingLine.enabled` is the sole Working-line ownership switch. Thinking (Experimental) never enables, configures, or owns the Working line and leaves the existing **Thinking time** option unchanged.
 - `components.selectorBorders` owns selector-border enablement, fixed `zentui` style, and color source. Disable it for native Pi behavior.
-- `components.footer` owns `native | starship | hidden` style selection, color source, model label, and Starship options. Hidden installs an empty component with zero rows.
+- `components.footer` owns `native | starship | hidden` style selection, color source, model label, and Starship options. Hidden hides its main segments, retaining only allowed extension statuses; an empty status line occupies no rows.
 - Starship's package-version segment reads the project manifest and is distinct from the runtime segment, which reports the installed toolchain.
-- Active third-party statuses from `ctx.ui.setStatus()` can be placed left, middle, or right, hidden per key, and assigned independent color modes.
+- `components.extensionStatuses` independently controls Show/Hide for observed `ctx.ui.setStatus()` publications. It also owns Hidden-only placement under `hidden`; Starship retains its own placement and color modes.
 - The shown `editor*` colors match the default `theme` source. Omit them to preserve source-aware defaults when switching between `theme` and `terminal`.
 
 ### Codex account quota

package/docs/footer-format.md

@@ -45,6 +45,27 @@ Center the branch between directory and cost:
 }
 ```
 
+Show model, provider, and active thinking level in the Footer:
+
+```text
+/zentui format "$model $provider( $thinkingLevel)"
+```
+
+Add `$model $provider( $thinkingLevel)` to `components.footer.styles.starship.compactFormat` separately to keep these details in compact layouts. Defaults and the built-in Model info segment are unchanged.
+
+To keep metadata on the right, set both templates independently:
+
+```json
+{
+  "format": "$cwd( in $session_name)( on $git_branch)( $git_status)( $git_state)( via $runtime)$fill$model($sep$provider)($sep$thinkingLevel)($sep$context)( $auto_compaction)($sep$tokens)( $cache_read)( $cache_write)($sep$cost)( $subscription)",
+  "compactFormat": "$cwd$wrap(in $session_name)$wrap(on $git_branch) $git_status$fill$model$wrap_sep($provider)$wrap_sep($thinkingLevel)$wrap_sep$context$wrap_sep$tokens"
+}
+```
+
+These keys belong under `components.footer.styles.starship`. Separate metadata chunks can wrap at narrow widths; a single combined chunk may truncate thinking. Earlier right-hand chunks take priority; project details and later telemetry may be truncated or omitted.
+
+Footer configuration never changes the Editor. To hide those details there, independently customize `components.editor.styles.opencode.metadataFormat` or `components.editor.styles.opencode-copy-friendly.metadataFormat`, omitting `$model`, `$provider`, and `$thinking`. Use `" "` for no metadata; `""` restores the default. See [Editor metadata format](./configuration.md#editor-metadata-format).
+
 Set or clear the template at runtime:
 
 ```text
@@ -71,6 +92,7 @@ The released flat `footerFormat` and `footerSegments` keys remain accepted only
 | `$runtime` | | runtime icon and version |
 | `$model` | | selected Footer model label |
 | `$provider` | | formatted provider label |
+| `$thinkingLevel` | | current thinking level; empty when unavailable or `off` |
 | `$package` | | project package version as `is <glyph> <version>` |
 | `$package_version` | | raw project package version |
 | `$session_duration` | `$duration` | session running time |
@@ -86,7 +108,7 @@ The released flat `footerFormat` and `footerSegments` keys remain accepted only
 | `$subscription` | | `(sub)` in subscription mode; otherwise empty |
 | `$auto_compaction` | | `(auto)` when automatic compaction is enabled |
 | `$sep` | `$separator` | themed `|` using `colors.separator` |
-| `$fill` | — | wide-format layout boundary |
+| `$fill` | — | wide or compact layout boundary |
 
 Each variable renders its core value without prose prefixes such as `on` or `via`; add those words as literals.
 
@@ -138,6 +160,8 @@ These tokens are structural in compact mode: `$wrap` and `$wrap_sep` render no t
 
 ## `$fill` behavior
 
+In the wide template:
+
 | Count | Layout |
 | ---: | --- |
 | 0 | everything left-aligned |
@@ -145,7 +169,11 @@ These tokens are structural in compact mode: `$wrap` and `$wrap_sep` render no t
 | 2 | before first is left, between is truly centered, after second is right |
 | 3+ | first two count; extras are ignored |
 
-The centered middle zone uses `floor((gap - middle) / 2)`, matching third-party statuses placed in the middle.
+The centered middle zone uses `floor((gap - middle) / 2)`, matching third-party statuses placed in the middle. During responsive two-row reflow, custom templates with a top-level `$fill` keep the right-bearing row right-aligned; a middle zone sharing that row retains its order, not centering.
+
+In `compactFormat`, the first top-level `$fill` splits left/right zones and flushes the current chunk. Additional fills are ignored (no compact center zone). Nested fills are nonstructural in both templates. Compact fills were previously ignored; existing templates containing them now opt into alignment. Templates without fill and shipped defaults are unchanged.
+
+Compact packing reserves right-hand chunks first, in template order, within `compactMaxLines`, then fits left-hand chunks into the remaining row budgets. Nonempty zones have at least one space between them. `$wrap_sep` separators appear only between chunks on the same row. Right content ends at the inner right edge (one cell inside the terminal margin); an empty right zone retains ordinary left packing. Long chunks truncate and capped omissions use `…`; arbitrarily narrow layouts cannot retain every value.
 
 ## Conditional groups
 
@@ -163,7 +191,7 @@ If every variable inside a group is empty, the group and its literal text are dr
 - `$session_name` is independent of `components.footer.styles.starship.segments.sessionName` in custom formats.
 - Built-in wide layout appends cache totals to Tokens, `(sub)` to Cost, and `(auto)` to Context when available.
 - Custom formats keep `$tokens`, `$cost`, and `$context` backward-compatible. Add `$cache_read`, `$cache_write`, `$subscription`, and `$auto_compaction` explicitly for atomic telemetry.
-- `DEFAULT_COMPACT_FOOTER_FORMAT` omits model/provider and atomic telemetry. Add variables to `components.footer.styles.starship.compactFormat` to opt in at narrow widths. The flat `compactFooterFormat` key remains migration-only input.
+- `DEFAULT_COMPACT_FOOTER_FORMAT` omits model/provider, thinking level, and atomic telemetry. Add variables to `components.footer.styles.starship.compactFormat` to opt in at narrow widths. The flat `compactFooterFormat` key remains migration-only input.
 - Auto-compaction settings refresh at the next normal Footer synchronization. Unsupported Pi capabilities or read errors omit optional markers.
 - Unknown variables render empty.
 - `$fill`, `$wrap`, and `$wrap_sep` are structural and never render visible text.

package/extensions/zentui/config.ts

@@ -272,7 +272,23 @@ export type ThinkingStepsComponentConfig = {
 	mode: ThinkingStepsMode;
 };
 
+export type ExtensionStatusVisibility = "show" | "hide";
+export type ExtensionStatusVisibilityConfig = {
+	defaultVisibility: ExtensionStatusVisibility;
+	visibility: Record<string, ExtensionStatusVisibility>;
+};
+
+export type HiddenExtensionStatusPlacement = "left" | "middle" | "right";
+export type ExtensionStatusComponentConfig = ExtensionStatusVisibilityConfig & {
+	hidden?: {
+		defaultPlacement?: HiddenExtensionStatusPlacement;
+		placements?: Record<string, HiddenExtensionStatusPlacement>;
+		colorModes?: Record<string, ExtensionStatusColorMode>;
+	};
+};
+
 export type ComponentsConfig = {
+	extensionStatuses: ExtensionStatusComponentConfig;
 	editor: EditorComponentConfig;
 	userMessages: UserMessagesComponentConfig;
 	thinkingSteps: ThinkingStepsComponentConfig;
@@ -404,6 +420,7 @@ export const FOOTER_FORMAT_VARIABLES = [
 	"runtime",
 	"model",
 	"provider",
+	"thinkingLevel",
 	"session_duration",
 	"username",
 	"os",
@@ -500,6 +517,7 @@ const defaultStarshipStyle: StarshipFooterStyleConfig = {
 };
 
 const defaultComponents: ComponentsConfig = {
+	extensionStatuses: { defaultVisibility: "show", visibility: {} },
 	editor: {
 		codexQuota: false,
 		enabled: true,
@@ -1208,6 +1226,75 @@ function resolveWorkingLineMessages(messages: ConfigRecord): WorkingLineMessages
 	return { custom, values: hasOwn(messages, "values") ? legacyValues : preset() };
 }
 
+export function isHiddenExtensionStatusPlacement(
+	value: unknown,
+): value is HiddenExtensionStatusPlacement {
+	return value === "left" || value === "middle" || value === "right";
+}
+
+export function getHiddenExtensionStatusPlacement(
+	config: ExtensionStatusComponentConfig,
+	key: string,
+): HiddenExtensionStatusPlacement {
+	const placements = config.hidden?.placements;
+	return (
+		(placements && Object.hasOwn(placements, key) ? placements[key] : undefined) ??
+		config.hidden?.defaultPlacement ??
+		"left"
+	);
+}
+
+export function getHiddenExtensionStatusColorMode(
+	config: ExtensionStatusComponentConfig,
+	key: string,
+): ExtensionStatusColorMode {
+	const modes = config.hidden?.colorModes;
+	return modes && Object.hasOwn(modes, key) && modes[key] === "zentui" ? "zentui" : "original";
+}
+
+function resolveExtensionStatusComponent(raw: unknown): ExtensionStatusComponentConfig {
+	const owner = recordValue(raw);
+	const hidden = recordValue(owner.hidden);
+	return {
+		...(isRecord(owner.hidden)
+			? {
+					hidden: {
+						...(isHiddenExtensionStatusPlacement(hidden.defaultPlacement)
+							? { defaultPlacement: hidden.defaultPlacement }
+							: {}),
+						...(isRecord(hidden.colorModes)
+							? {
+									colorModes: Object.fromEntries(
+										Object.entries(hidden.colorModes).filter(
+											(entry): entry is [string, ExtensionStatusColorMode] =>
+												isExtensionStatusColorMode(entry[1]),
+										),
+									),
+								}
+							: {}),
+						...(isRecord(hidden.placements)
+							? {
+									placements: Object.fromEntries(
+										Object.entries(hidden.placements).filter(
+											(entry): entry is [string, HiddenExtensionStatusPlacement] =>
+												isHiddenExtensionStatusPlacement(entry[1]),
+										),
+									),
+								}
+							: {}),
+					},
+				}
+			: {}),
+		defaultVisibility: owner.defaultVisibility === "hide" ? "hide" : "show",
+		visibility: Object.fromEntries(
+			Object.entries(recordValue(owner.visibility)).filter(
+				(entry): entry is [string, ExtensionStatusVisibility] =>
+					entry[1] === "show" || entry[1] === "hide",
+			),
+		),
+	};
+}
+
 function resolveComponents(config: ConfigRecord): ComponentsConfig {
 	const components = recordValue(config.components);
 	const editor = recordValue(components.editor);
@@ -1254,6 +1341,7 @@ function resolveComponents(config: ConfigRecord): ComponentsConfig {
 	const userMessagesSelection = resolveUserMessagesSelection(userMessages, framed, features);
 
 	return {
+		extensionStatuses: resolveExtensionStatusComponent(components.extensionStatuses),
 		editor: {
 			codexQuota: parseBoolean(editor.codexQuota, false),
 			...(isRecord(editor.colors)
@@ -2261,25 +2349,210 @@ export function saveExtensionStatusColorMode(
 	key: string,
 	colorMode: ExtensionStatusColorMode,
 	path = configPath,
+): PolishedTuiConfig {
+	return mutateConfig(path, (record) => {
+		const footer = recordValue(recordValue(record.components).footer);
+		const starship = recordValue(recordValue(footer.styles).starship);
+		const statuses = recordValue(starship.extensionStatuses);
+		const colorModes = Object.hasOwn(statuses, "colorModes")
+			? recordValue(statuses.colorModes)
+			: recordValue(recordValue(record.extensionStatuses).colorModes);
+		record.components = overlayKnown(record.components, {
+			footer: {
+				styles: {
+					starship: { extensionStatuses: { colorModes: { ...colorModes, [key]: colorMode } } },
+				},
+			},
+		});
+	});
+}
+
+/** Hidden placement edits remain sparse and never snapshot another owner's preferences. */
+export function saveHiddenExtensionStatusDefaultPlacement(
+	placement: HiddenExtensionStatusPlacement,
+	path = configPath,
+): PolishedTuiConfig {
+	return mutateConfig(path, (record) => {
+		record.components = overlayKnown(record.components, {
+			extensionStatuses: { hidden: { defaultPlacement: placement } },
+		});
+	});
+}
+
+export function saveHiddenExtensionStatusPlacement(
+	key: string,
+	placement: HiddenExtensionStatusPlacement | undefined,
+	path = configPath,
+): PolishedTuiConfig {
+	return mutateConfig(path, (record) => {
+		if (placement === undefined) {
+			const owner = recordValue(recordValue(record.components).extensionStatuses);
+			delete recordValue(recordValue(owner.hidden).placements)[key];
+		} else {
+			record.components = overlayKnown(record.components, {
+				extensionStatuses: { hidden: { placements: { [key]: placement } } },
+			});
+		}
+	});
+}
+
+/** Original is Hidden's default; choosing it removes only this color override. */
+export function saveHiddenExtensionStatusColorMode(
+	key: string,
+	colorMode: ExtensionStatusColorMode,
+	path = configPath,
+): PolishedTuiConfig {
+	return mutateConfig(path, (record) => {
+		if (colorMode === "original") {
+			const owner = recordValue(recordValue(record.components).extensionStatuses);
+			delete recordValue(recordValue(owner.hidden).colorModes)[key];
+		} else {
+			record.components = overlayKnown(record.components, {
+				extensionStatuses: { hidden: { colorModes: { [key]: colorMode } } },
+			});
+		}
+	});
+}
+
+export function saveExtensionStatusDefaultVisibility(
+	visibility: ExtensionStatusVisibility,
+	path = configPath,
 ): PolishedTuiConfig {
 	return saveComponentsMutation(
-		["footer"],
+		["extensionStatuses"],
 		(components) => {
-			Object.defineProperty(components.footer.styles.starship.extensionStatuses.colorModes, key, {
-				value: colorMode,
-				enumerable: true,
-				configurable: true,
-				writable: true,
-			});
+			components.extensionStatuses.defaultVisibility = visibility;
+		},
+		path,
+	);
+}
+
+/** Undefined resumes the independent default, without changing Starship presentation. */
+export function saveExtensionStatusVisibility(
+	key: string,
+	visibility: ExtensionStatusVisibility | undefined,
+	path = configPath,
+): PolishedTuiConfig {
+	return saveComponentsMutation(
+		["extensionStatuses"],
+		(components) => {
+			if (visibility === undefined) delete components.extensionStatuses.visibility[key];
+			else
+				Object.defineProperty(components.extensionStatuses.visibility, key, {
+					value: visibility,
+					enumerable: true,
+					configurable: true,
+					writable: true,
+				});
 		},
 		path,
+		(record) => {
+			// overlayKnown preserves unknown leaves; explicitly remove a reset override.
+			if (visibility === undefined) {
+				const owner = recordValue(recordValue(record.components).extensionStatuses);
+				delete recordValue(owner.visibility)[key];
+			}
+		},
 	);
 }
 
+export type ExtensionStatusChoice = "default" | ExtensionStatusPlacement;
+
+/** Save one menu choice in a single atomic write, without snapshotting other components. */
+export function saveExtensionStatusDefaultChoice(
+	placement: ExtensionStatusPlacement,
+	style: FooterStyle,
+	path = configPath,
+): PolishedTuiConfig {
+	return mutateConfig(path, (record) => {
+		record.components = overlayKnown(record.components, {
+			extensionStatuses: { defaultVisibility: placement === "off" ? "hide" : "show" },
+		});
+		if (placement === "off") return;
+		if (style === "hidden") {
+			record.components = overlayKnown(record.components, {
+				extensionStatuses: { hidden: { defaultPlacement: placement } },
+			});
+		} else {
+			// Native retains Starship positioning as a dormant preference; Pi owns its layout.
+			record.components = overlayKnown(record.components, {
+				footer: { styles: { starship: { extensionStatuses: { defaultPlacement: placement } } } },
+			});
+		}
+	});
+}
+
+/** Default removes both visibility and current-mode placement, shadowing legacy Starship maps. */
+export function saveExtensionStatusChoice(
+	key: string,
+	choice: ExtensionStatusChoice,
+	style: FooterStyle,
+	path = configPath,
+): PolishedTuiConfig {
+	return mutateConfig(path, (record) => {
+		const components = recordValue(record.components);
+		const owner = recordValue(components.extensionStatuses);
+		const hidden = recordValue(owner.hidden);
+		const starship = recordValue(recordValue(recordValue(components.footer).styles).starship);
+		const canonicalStatuses = recordValue(starship.extensionStatuses);
+		if (choice === "default") {
+			delete recordValue(owner.visibility)[key];
+			if (style === "hidden") {
+				delete recordValue(hidden.placements)[key];
+			} else {
+				// An empty canonical map must remain to prevent top-level legacy fallback.
+				const placements = {
+					...recordValue(
+						Object.hasOwn(canonicalStatuses, "placements")
+							? canonicalStatuses.placements
+							: recordValue(record.extensionStatuses).placements,
+					),
+				};
+				delete placements[key];
+				record.components = overlayKnown(record.components, {
+					footer: { styles: { starship: { extensionStatuses: { placements: {} } } } },
+				});
+				const footer = recordValue(recordValue(record.components).footer);
+				const savedStarship = recordValue(recordValue(footer.styles).starship);
+				recordValue(savedStarship.extensionStatuses).placements = placements;
+			}
+			return;
+		}
+		record.components = overlayKnown(record.components, {
+			extensionStatuses: { visibility: { [key]: choice === "off" ? "hide" : "show" } },
+		});
+		if (choice === "off") return;
+		if (style === "hidden") {
+			record.components = overlayKnown(record.components, {
+				extensionStatuses: { hidden: { placements: { [key]: choice } } },
+			});
+		} else {
+			const placements = Object.hasOwn(canonicalStatuses, "placements")
+				? recordValue(canonicalStatuses.placements)
+				: recordValue(recordValue(record.extensionStatuses).placements);
+			record.components = overlayKnown(record.components, {
+				footer: {
+					styles: {
+						starship: { extensionStatuses: { placements: { ...placements, [key]: choice } } },
+					},
+				},
+			});
+		}
+	});
+}
+
 /** Explicit all-owner migration; callers must obtain confirmation before invoking. */
 export function migrateComponentSelections(path = configPath): PolishedTuiConfig {
 	return saveComponentsMutation(
-		["editor", "userMessages", "thinkingSteps", "workingLine", "selectorBorders", "footer"],
+		[
+			"editor",
+			"userMessages",
+			"thinkingSteps",
+			"workingLine",
+			"selectorBorders",
+			"footer",
+			"extensionStatuses",
+		],
 		() => {},
 		path,
 	);