fisi-dock 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.3.0
+
+### Vivid labels
+
+- The labels take the vividness of the cover title `#F43888`, each on its own hue: HSL saturation 90% and lightness 59%, lighter in steps of 0.01 (at most 0.80) only where a hue would read under 4.5:1 on the `#161616` background. One helper, `vivid` in `lib/palette.ts`.
+- Panel section titles (`session`, `heads-up`, `ODD`, `RDD`, `CI`, `agents`, `todo`, `changes`) and the counters on their top rule (`3/7`, `on`, the agents card's count) draw vivid on the rail, in `/dock` and on the narrow-screen todo and agents cards. Frames stay gray, rows keep their colors, and gray counters (`1 to commit`, the CI sha, `off`) stay muted.
+- On the prompt box, the permission mode and its dot (vivid red), the effort (vivid blue) and the clock wave on the working label (`ODD checking…`, vivid pink and lilac) draw vivid; the model stays muted. The line under the prompt paints the same labels, and the petal Fisi Dock turns with the wave takes the vivid theme tones, like the one Gentle Shell paints from the theme. Gentle Shell's own label and hint keep its colors; words, compaction and layout are unchanged.
+- The `Fisi-Dock` theme's accents `pink`, `deepPink`, `teal`, `coral`, `amber`, `lilac`, `green`, `blue` and `red` take their vivid values (amber `#e0af68` -> `#f5a838`, blue `#7b9cff` -> `#4c76f6`, and the rest); neutrals and backgrounds stay.
+
 ## 0.2.1
 
 ### Project

package/README.md

@@ -45,7 +45,7 @@ It is a Pi package (an extension and a theme) that paints its own panel in Gentl
 - **Prompt box**: Gentle Shell's prompt framed, with the working label (`ODD exploring…`), the permission mode, the model and the effort on its top border.
 - **Narrow screens and phones**: a one-line top row, a strip above the prompt, and compact agents and todo cards.
 - **`/dock`** and **`/fisi-dock`**: the whole panel over the screen, and an on/off switch that needs no uninstall ([Commands](#commands)).
-- **`Fisi-Dock` theme**: the panel's palette for the whole of Pi, applied once on the first start with your own theme remembered for `/fisi-dock off` ([Theme](#theme)).
+- **`Fisi-Dock` theme**: the panel's hues, vivid, for the whole of Pi, applied once on the first start with your own theme remembered for `/fisi-dock off` ([Theme](#theme)).
 
 Every section, row and data source is described in [docs/reference.md](docs/reference.md).
 
@@ -80,9 +80,9 @@ Install it into Gentle Shell from GitHub, so it loads every time Gentle Shell st
 gentle-shell install git:github.com/fisidj/fisi-dock
 ```
 
-Without a tag you follow the `main` branch. Releases are tagged `vX.Y.Z` and listed on the [Releases page](https://github.com/fisidj/fisi-dock/releases); the latest is `v0.2.1`. To pin one, add `@<tag>` to the source: `gentle-shell install git:github.com/fisidj/fisi-dock@v0.2.1`. Pi keeps a pinned tag: updates do not move it.
+Without a tag you follow the `main` branch. Releases are tagged `vX.Y.Z` and listed on the [Releases page](https://github.com/fisidj/fisi-dock/releases); the latest is `v0.3.0`. To pin one, add `@<tag>` to the source: `gentle-shell install git:github.com/fisidj/fisi-dock@v0.3.0`. Pi keeps a pinned tag: updates do not move it.
 
-Fisi Dock is also on npm: `gentle-shell install npm:fisi-dock`, pinned with `npm:fisi-dock@0.2.1`.
+Fisi Dock is also on npm: `gentle-shell install npm:fisi-dock`, pinned with `npm:fisi-dock@0.3.0`.
 
 If you run Gentle Shell with `--link` (Pi's own home instead of the launcher's isolated one), install it there instead: `gentle-shell --link install git:github.com/fisidj/fisi-dock`.
 
@@ -129,6 +129,8 @@ Gentle Shell and Pi controls that change what Fisi Dock shows:
 
 `Fisi-Dock` is a Pi theme with the panel's palette and a pink-tinted selection. It colors the whole of Pi, not only the panel. It is optional: the panel keeps its own colors with any theme.
 
+**Vivid labels.** The labels wear the vividness of the cover title `#F43888`, each on its own hue: the theme's accents (pink, deep pink, teal, coral, amber, lilac, green, blue, red), the panel's section titles and the counters on their top rule (`3/7`, `on`), and the labels Fisi Dock paints on the prompt box (`● SUPER-YOLO`, the effort, the `ODD exploring…` wave). Each color keeps its hue at HSL saturation 90% and lightness 59%, lighter where a hue would read under 4.5:1 on the `#161616` background (blue, lilac). The frames, the rows inside the sections, gray labels (the model, `1 to commit`), the neutrals and the backgrounds keep their colors.
+
 **The first start applies it once.** The first session with Fisi Dock on, inside Gentle Shell, remembers the theme you use, then switches Pi to `Fisi-Dock` and says so: `Fisi Dock applied its theme · /fisi-dock off puts your theme dark back`. This happens once, also on an install from before this step; every later start leaves your theme alone. It waits for the next start when Pi does not know the `Fisi-Dock` theme or cannot set it, and it never changes your theme when Fisi Dock cannot save the one you had. It never runs in a delegated subagent session, and a Fisi Dock that is off does nothing at start: `/fisi-dock on` sets the theme instead.
 
 | How | What happens |

package/docs/reference.md

@@ -6,17 +6,18 @@ Everything Fisi Dock draws, where each piece of data comes from, and how it fits
 
 While Gentle Shell's fullscreen rail is on screen (fullscreen mode, terminal at least 140 columns wide, Status placement `auto` or `right`):
 
-- **Side panel**: replaces the rail's Status section with the Fisi Dock panel: the GENTLESHELL wordmark, then framed `session`, `heads-up` (only when something is left open), `ODD` (always on screen), `RDD`, `CI` (only while the branch has GitHub Actions runs), `agents`, `todo` (always on screen) and `changes` sections, in that order, each section in its own color. Context, cost, the model profile, Engram memory and MCP servers are rows inside `session`; reviews have their own `RDD` section; there is no footer under the panel. Gentle Shell builds that wrap rail parts in their own cards (the transparent chrome surface on its `main` branch) get every panel row as a loose row, so the panel keeps its own frames instead of sitting inside a host card that would cut its right border.
+- **Side panel**: replaces the rail's Status section with the Fisi Dock panel: the GENTLESHELL wordmark, then framed `session`, `heads-up` (only when something is left open), `ODD` (always on screen), `RDD`, `CI` (only while the branch has GitHub Actions runs), `agents`, `todo` (always on screen) and `changes` sections, in that order, each section in its own color: its title and the counters on its top rule (`3/7`, `on`) in that color made vivid (see **Vivid labels** below), the frame gray and the rows in their own colors. Context, cost, the model profile, Engram memory and MCP servers are rows inside `session`; reviews have their own `RDD` section; there is no footer under the panel. Gentle Shell builds that wrap rail parts in their own cards (the transparent chrome surface on its `main` branch) get every panel row as a loose row, so the panel keeps its own frames instead of sitting inside a host card that would cut its right border.
 - **Only this panel in the rail**: Gentle Shell's own `todo`, `jobs` and `agents` rail sections and the status bar it paints under the rail (branch, permission mode, model, effort, context, cost) are taken over with parts that paint nothing, the same way the Status section and the top row are, so nothing repeats; Gentle Shell gets every original back when Fisi Dock unloads.
 - **Short screens**: when the panel is taller than the terminal (its rows minus the top row and the gap under it), it leaves out, in this order and only as far as needed, the `session` section's three group labels (`where ──`, `usage ──`, `connections ──`), then the `│` spacer rows between ODD steps and between RDD reviews (the gray lines under finished ODD steps and finished RDD reviews drop with them; the active step and a running review keep their line; the gray lines under the `CI` rows drop with them too), then the `changes` section, then the `CI` section when every check passed, then the `CI` section while a check runs, waits or failed, then the `RDD` section together with every ODD row but the latest step while a request runs. The wordmark, `session`, `heads-up`, `ODD` (at least its title and one row), `agents` and `todo` are never left out; if the panel is still too tall, the rail scrolls. `/dock` is not affected: it scrolls and shows everything.
 - **Start screen**: when Gentle Shell's `gentle:banner` command exists, the header Pi shows above the chat at startup is Fisi Dock's welcome card instead of Gentle Shell's rose banner (design 08): a gray frame with `Gentle Shell <version>` and a pink `with Fisi Dock`, `Ready in <project> on <branch>.`, the five commands to begin with (`/resume`, `/new`, `/changelog`, `/hotkeys`, `/quit`), and `Tip: alt+k opens the command palette.` under it, centered, 63 columns wide or the screen's width; under 34 columns only the title and ready lines show. The version is Gentle Shell's, from the `provisioned` record for this agent home in the `config.json` one folder above it (`4.6.0-main.dd37ffe` reads `4.6.0-main`); without it the title is `Gentle Shell`. It goes through Pi's `ctx.ui.setHeader`: Gentle Shell sets its banner a little after the session starts, which disposes the card, so the card takes the header back on the next microtask (at most 5 times per session). Without that command (no Gentle Shell) there is no card and no `loaded` box: Pi keeps its own header and listing.
 - **Loaded box**: under the welcome card, Pi's list of loaded skills, prompts and extensions (and context files, when Pi lists them) is one box in the same frame (design start-screen/02): `loaded` on its top rule, one row per kind with the kind, its count right-aligned and as many names as fit, cut with `…` (`skills      24  btw, chained-pr, cognitive-doc-design, g…`), and `ctrl+o lists them` on its bottom rule, naming the key Pi binds to `app.tools.expand`: the one Pi's editor holds, live; when Fisi Dock cannot reach the editor's keybindings, the one in Pi's `keybindings.json` (in `PI_CODING_AGENT_DIR`, else `~/.pi/agent`), read once when the box installs, with the legacy `expandTools` id counted and a list of keys joined with `/` (`ctrl+e/alt+o`); with no override there, or a missing or malformed file, Pi's default `ctrl+o`. A key bound to nothing (`[]`) leaves the rule without a hint. A kind with nothing loaded is left out. The box shrinks with the card, and under 34 columns its rows print without a frame or hint. Pressing that key shows Pi's own full listing, grouped by scope with paths, and pressing it again brings the box back. Pi's `[Skill warnings]`, `[Prompt conflicts]`, `[Extension issues]` and `[Theme conflicts]` always print under the box as Pi prints them. The box shows only while the welcome card holds the header (while Gentle Shell's rose briefly replaces it, Pi's listing shows), and only when Pi prints its listing (not with `quietStartup`). How: Fisi Dock finds Pi's loaded-resources container next to the card in the TUI tree and wraps the render of that one instance (never a shared prototype), reading the names from Pi's collapsed sections on each render, so Pi refilling the list on `/reload` keeps the box. `/fisi-dock off` and session shutdown put Pi's own render back. When Pi's tree or its sections have a shape Fisi Dock does not recognize, Pi's listing stays as it is.
 - **Top row**: shows only the project path. Model, effort, context and cost are in the panel and on the prompt box, so nothing repeats.
-- **Prompt box**: Gentle Shell's prompt is closed into a box with the labels on its top rule: `╭─ ✿ waiting for input ──── ● SUPER-YOLO  opus-5.5 · high ─╮`, then `│ › … │` rows, then a `╰────╯` bottom rule. The left label is Gentle Shell's own (`waiting for input`, `working…`, or the ODD phase while a request runs); when it is an ODD phase (`exploring…`, `implementing…`, `checking…` and the rest as Gentle Shell writes them) the box puts `ODD ` before it: `╭─ ✿ ODD exploring… ──── ● SUPER-YOLO  opus-5.5 · high ─╮`, never for `waiting for input`, `working…` or `queued`. `ODD ` takes 4 columns: the right part still gives way first (it compacts, then drops), and only where even the bare box would not fit with it does the label show without it; the right part is the permission mode after a red dot (only when it is not `NORMAL`, the rule of Gentle Shell's own status bar), then the model and effort. Gentle Shell's own hint on that rule (`esc again to clear`, the vim mode) stays after the labels; its `[ Panel ]` button (the phone sheet with its rail sections, empty while Fisi Dock paints them) is left out, and a tap on the rule row does nothing. The full panel on the phone is `/dock`. The box paints whenever Fisi Dock paints: Gentle Shell's sidebar state on the terminal, in the wide rail chrome and in the narrow fullscreen chrome. How: Fisi Dock wraps Gentle Shell's editor factory (the wrapper carries Gentle Shell's own `gentle-pi.prompt-owner` marker, so Gentle Shell's shutdown and reinstall treat it as their own), renders Gentle Shell's editor four columns narrower and rebuilds only its frame rows: any rows above it and Pi's autocomplete rows under it stay untouched, the editor's invisible cursor markers (APC sequences) count no columns, and mouse clicks are shifted back by the border. Gentle Shell's own work row and agent-question row above the prompt do not show while Fisi Dock empties the `agents` part they read: a question still opens Gentle Shell's own selector, the `agents` card marks it with `!`, and `/gentle:agents` opens the list. The factory it replaced comes back when Fisi Dock unloads. A Gentle Shell update that changes the shape of its panel rule (`─ ✿ label ──── hint ─`), its blank bottom row or its editor's `topRowCount` can break the box: it then falls back to Gentle Shell's own rows and the line below, and `tests/gentle-shell-keys.test.ts` fails against the installed package when `gentle-pi.prompt-owner`, `framePromptLines`, `panelPromptRule` or `topRowCount` are gone.
+- **Prompt box**: Gentle Shell's prompt is closed into a box with the labels on its top rule: `╭─ ✿ waiting for input ──── ● SUPER-YOLO  opus-5.5 · high ─╮`, then `│ › … │` rows, then a `╰────╯` bottom rule. The left label is Gentle Shell's own (`waiting for input`, `working…`, or the ODD phase while a request runs); when it is an ODD phase (`exploring…`, `implementing…`, `checking…` and the rest as Gentle Shell writes them) the box puts `ODD ` before it: `╭─ ✿ ODD exploring… ──── ● SUPER-YOLO  opus-5.5 · high ─╮`, never for `waiting for input`, `working…` or `queued`. `ODD ` takes 4 columns: the right part still gives way first (it compacts, then drops), and only where even the bare box would not fit with it does the label show without it; the right part is the permission mode after a red dot (only when it is not `NORMAL`, the rule of Gentle Shell's own status bar), then the model and effort: the dot and the mode bold in vivid red, the model muted, the effort in vivid blue (the line under the prompt paints them the same). Gentle Shell's own hint on that rule (`esc again to clear`, the vim mode) stays after the labels; its `[ Panel ]` button (the phone sheet with its rail sections, empty while Fisi Dock paints them) is left out, and a tap on the rule row does nothing. The full panel on the phone is `/dock`. The box paints whenever Fisi Dock paints: Gentle Shell's sidebar state on the terminal, in the wide rail chrome and in the narrow fullscreen chrome. How: Fisi Dock wraps Gentle Shell's editor factory (the wrapper carries Gentle Shell's own `gentle-pi.prompt-owner` marker, so Gentle Shell's shutdown and reinstall treat it as their own), renders Gentle Shell's editor four columns narrower and rebuilds only its frame rows: any rows above it and Pi's autocomplete rows under it stay untouched, the editor's invisible cursor markers (APC sequences) count no columns, and mouse clicks are shifted back by the border. Gentle Shell's own work row and agent-question row above the prompt do not show while Fisi Dock empties the `agents` part they read: a question still opens Gentle Shell's own selector, the `agents` card marks it with `!`, and `/gentle:agents` opens the list. The factory it replaced comes back when Fisi Dock unloads. A Gentle Shell update that changes the shape of its panel rule (`─ ✿ label ──── hint ─`), its blank bottom row or its editor's `topRowCount` can break the box: it then falls back to Gentle Shell's own rows and the line below, and `tests/gentle-shell-keys.test.ts` fails against the installed package when `gentle-pi.prompt-owner`, `framePromptLines`, `panelPromptRule` or `topRowCount` are gone.
 - **Prompt box on a narrow rule**: when the width cannot hold the labels beside the idle label (a phone, idle), the label's words drop first and the petal alone keeps them: `╭─ ✿ ──── ● SUPER-YOLO  opus-5.5 · high ─╮`, with Gentle Shell's hint after them when it fits too. The idle label is told by how Gentle Shell paints it, not by its words, so a translated, custom or clipped one (`waiting for i…`) gets the same rule: a label Gentle Shell animates (the working scan) is never idle, and one painted whole is idle unless it is `queued`, `working…` or an ODD phase (whole or clipped with `…`) or the editor's scroll indicator (`↑ 3 more`, text out of view). `working…`, `queued`, the ODD phase and the scroll indicator always keep their words. Still too tight, the labels compact step by step instead of dropping: tight separators (`● SUPER-YOLO opus-5.5·high`), then without the effort (`● SUPER-YOLO opus-5.5`), then the mode alone (`● SUPER-YOLO`; the model alone in normal mode), so working on a phone reads `╭─ ✿ working… ─ ● SUPER-YOLO opus-5.5 ─╮` at 40 columns. Each step is tried beside Gentle Shell's hint first (`● SUPER-YOLO  INSERT`); with no room for both, the hint wins beside a working label, as it does over the full labels, and our labels win beside the idle one. Only when not even the smallest step fits do the labels drop, then the hint; under 20 columns Gentle Shell's rows stay as they are.
-- **Working label**: the words come from Gentle Shell (`exploring…`, `implementing…`), with `ODD ` before a phase. In the box the color moves across the whole `ODD exploring…` by the clock, at a steady pace, however often the screen is redrawn, and the petal before it turns through Gentle Shell's four flowers (`✿ ❀ ❁ ✾`, in its tones) on the same clock, one flower per wave step (120 ms), each one column wide so nothing shifts. Gentle Shell's `potato` animation keeps its own label and petal, with `ODD ` in the label's gray; under `performance` the box moves the wave and the petal by the clock too, since Gentle Shell's own there step once a second.
+- **Working label**: the words come from Gentle Shell (`exploring…`, `implementing…`), with `ODD ` before a phase. In the box the color (vivid pink at the head, vivid lilac beside it, gray elsewhere) moves across the whole `ODD exploring…` by the clock, at a steady pace, however often the screen is redrawn, and the petal before it turns through Gentle Shell's four flowers (`✿ ❀ ❁ ✾`, in its tones) on the same clock, one flower per wave step (120 ms), each one column wide so nothing shifts. Gentle Shell's `potato` animation keeps its own label and petal, with `ODD ` in the label's gray; under `performance` the box moves the wave and the petal by the clock too, since Gentle Shell's own there step once a second.
 - **Under the prompt** (fallback): when the box could not be installed (no Gentle Shell editor yet, someone else's editor) or did not fit, one line with the same labels: `SUPER-YOLO · opus-5.5 · high` (`opus-5.5 · high` in normal mode). Too narrow for it, the labels compact the same way (`SUPER-YOLO·opus-5.5·high`, `SUPER-YOLO·opus-5.5`, `SUPER-YOLO`) before the line is cut with `…`. The mode, on the box and on the line, comes from Gentle Shell's permission-mode adapter, asked over `pi.events` on `gentle:yolo:host-ui` like its `/gentle:customize` does, and follows `/gentle:mode` and `/gentle:yolo`; without an answer the labels are model and effort only. The prompt editor itself stays Gentle Shell's.
-- **Theme**: ships the `Fisi-Dock` Pi theme with the design's palette and a pink-tinted selection. The first start with Fisi Dock on applies it once and remembers the theme you had, for `/fisi-dock off` to put back; later starts never call Pi's theme setter (see [Turning Fisi Dock off and on](#turning-fisi-dock-off-and-on)). It is also one more choice in `/settings`.
+- **Vivid labels**: section titles, the counters on their top rule and the labels Fisi Dock paints on the prompt box take the vividness of the cover title `#F43888` on their own hue: HSL saturation 90% and lightness 59%, and only for a hue that then reads under 4.5:1 on the `#161616` background, lightness up in steps of 0.01 until it does, at most 0.80 (`vivid` in `lib/palette.ts`). Amber `#e0af68` becomes `#f5a838`, lilac `#c3a6ff` `#9464f7`, coral `#ff9b85` `#f55a38`, teal `#5fd4e0` `#38e3f5`, pink `#f2a7c9` `#f5388e`, deep pink `#c9779f` `#f53894`, green `#8fc98f` `#38f538`, blue `#7b9cff` `#4c76f6`, red `#ff6b6b` `#f53838`, purple `#b48cff` `#945ff7`, rose `#ff76c3` `#f538a2`. Gray has no hue to raise: muted counters (`1 to commit`, the CI sha, `off`) and the model stay muted. Gentle Shell's own label, petal and hint keep the colors Gentle Shell paints them.
+- **Theme**: ships the `Fisi-Dock` Pi theme with the design's palette and a pink-tinted selection: its accents (`pink`, `deepPink`, `teal`, `coral`, `amber`, `lilac`, `green`, `blue`, `red`) are the vivid values above, its neutrals and backgrounds the panel's own. The first start with Fisi Dock on applies it once and remembers the theme you had, for `/fisi-dock off` to put back; later starts never call Pi's theme setter (see [Turning Fisi Dock off and on](#turning-fisi-dock-off-and-on)). It is also one more choice in `/settings`.
 
 ### Narrow screens
 
@@ -26,7 +27,7 @@ On narrow or non-fullscreen terminals (a phone over SSH, a split pane) the rail
 
 - **Strip above the prompt**: one line with what the panel would show and the top row does not, each part in its section color and only when it has data: `✓ ODD 2:45` once the request finished (while a phase is active, the prompt box's working label names it, so the strip does not repeat it), `todo 3/7` (only when no todo card shows, see below) and changed files (`±1 file`). Running agents are not counted here: the agents card lists them. A second line appears only for heads-up warnings (`! 1 commit not pushed · ! ODD plan fisi-dock`). On a tight screen trailing parts drop whole; with nothing to show the strip takes no space. It disappears as soon as the rail shows the panel.
 - **Agents card under the strip**: while an agent, a 4.6.0 subagent task or background job is running (or a subagent task waits for you), an `agents` card framed like the panel sections, with the number running on the right of its top border and one row per running or waiting agent: its turning spinner (an amber `!` for a task that waits for you), name, task (cut to fit) and the time it has been running, `m:ss` (`h:mm:ss` past an hour), ticking each second on the spinner's repaints (with `potato` or `FISI_DOCK_ORBS=off` there is no timer, so it moves only when something else repaints). A job's time counts from the start Gentle Shell reports for it; a job that reports no start counts from when Fisi Dock first saw it running, so one already running when Fisi Dock loaded shows less than its real time. A subagent task's time counts from its first `running` event (until then from its tool call), or from the start in the presence file when it was seeded after a `/reload` (see the `agents` row below). An agent with a model gets the same model label as in the side panel, after its time (`0:42 opus · high`). Up to 4 agents, then `+N more  /dock all`. Queued, finished and failed agents are not listed (the side panel still shows them for a while), and with nothing running the card takes no space.
-- **Todo card under the agents card**: while there is a todo list, Fisi Dock's compact `todo` section, framed to the full width: the coral title with `8/10` on the right, `✓ 8 done` with its bar, the active task highlighted with its spinner, the next task and `+N more  /dock all`. It keeps a fixed height however long the list is (the side panel lists the tasks instead); `/dock` shows every task. Its header already says `d/t`, so the strip leaves `todo 3/7` out while the card shows. Gentle Shell's own Todos card stays hidden. The card goes away with the strip when the rail shows the panel.
+- **Todo card under the agents card**: while there is a todo list, Fisi Dock's compact `todo` section, framed to the full width: the vivid coral title with `8/10` on the right, `✓ 8 done` with its bar, the active task highlighted with its spinner, the next task and `+N more  /dock all`. It keeps a fixed height however long the list is (the side panel lists the tasks instead); `/dock` shows every task. Its header already says `d/t`, so the strip leaves `todo 3/7` out while the card shows. Gentle Shell's own Todos card stays hidden. The card goes away with the strip when the rail shows the panel.
 - **Prompt box**: the same closed box as on wide screens; on a narrow rule its labels compact step by step (see Prompt box on a narrow rule above).
 - **`/dock`**: the side panel over the whole screen, scrolled with the arrows or a swipe (see Commands).
 
@@ -43,7 +44,7 @@ Without Gentle Shell, Fisi Dock paints nothing on its own (no rail parts, no str
 | session | design session-section/02 (Grouped): three groups, each named by a muted label with a short faint stub (`where ──`, `usage ──`, `connections ──`, no full-width rule; a section with one group only has no label), and one muted key column (`project`, `context`, `profile`, `memory`, `mcp`) so every value starts at the same place. **where**: `project  fisi-dock  main ↑2`, the project folder in bold, the git branch and the commits to push in green (no `↑N` while the heads-up says it). **usage**: the `context` row from Pi: a meter whose filled cells are a heavy `━` in the state color (teal, amber from 60%, red from 85%) and whose empty cells are a thin faint `─`, with a faint `┼` on the cells holding 60% and 85%, then the readout flush right on the same row, `5% · 53.5k/1M` (the percent bold in the state color, the tokens in context and the window size; `5% used` when Pi gives no token counts); the readout keeps at least 13 columns, and when that would leave the bar under 16 cells (the 34-column rail) the bar takes the whole row and the readout moves right-aligned to the row under it; no row when Pi does not know the percent. Then the `profile` row with the cost flush right (below); without a profile the cost keeps a row of its own (`cost     $0.012`). **connections**: the `memory` row for Engram (see Memory below), then one row per MCP server, at most 4 rows on the rail (see MCP servers below), or a muted `mcp      none configured` without MCP config. The `profile` row: the agent-model profile this session's launches use (`/gentle:profiles`), the label Gentle Shell's own Status section and top row show, which Fisi Dock takes over: `claude` for the global profile, `claude (session)` for one chosen with Use in this session, `team (local)` or `team (repo)` for a pinned one; read from Gentle Shell's in-process profile registries with each Pi read (session start, every turn) and, while no run is active and the panel is on screen, every 10 s; no profile row when the session has no profile or that state cannot be read. The cost: the session cost (`$0.012`), or, when that cost is 0 but the session used tokens (a subscription such as pi-claude-bridge records tokens at cost 0), the session tokens and an API-price estimate: `12.4M tok · ≈$38` (see Tokens and the ≈ estimate below); a long profile is cut before the cost is. The connection rows put the names and the state words in their own columns (names past 12 cells are cut), with one glyph per state so none rests on color alone: green `● connected`, amber `◌ connecting`, red `✗ failed` or `✗ unreachable`, muted `○ not installed`; the gap between name and word closes to one space when two would not fit, and the saved count is the first thing to drop |
 | heads-up | red warnings, drawn only when there is one (at most 5 rows, then `+N more`): other open git worktrees, todo tasks still open after a run ended, unfinished ODD plans in the project's `odd/tasks/*.md`, commits not pushed (replaces the branch's `↑N`), local branches not merged into the default branch |
 | ODD | always drawn: before the first request one muted row `○ ready · phases show while I work`; while a request runs, the timeline of ODD phases with times (latest 6 steps), where the active step shows an animated braille orb in its phase color and its phase name in gray with a white shine sweeping across it, like the prompt box; when the agent's turn ends while this session's subagents still run (queued, running or waiting), the active step stays active and keeps counting until the last of them finishes or the request settles; under each step one gray line, aligned with its name, says what it did: under the active step what its last tool is doing (`editing …/tables/table-row.ts`, `running npm test`), under each finished step a summary (`edited lib/tables/ · 2 files`, `ran npm test · +2 more`, `read 3 files · 1 search`; past 256 different files it says `256+ files`). Paths are relative to the project folder (without regard to case only on Windows drive and network paths); a line too long for the rail keeps its count whole and cuts the path in the middle at a folder (`edited …/tables/ · 12 files`). Commands, paths and labels come from the model, so escape sequences, control characters and bidi overrides are removed before they reach the terminal; once the request is over, one row `✓ last request 2:45 · 4 phases` (the request's wall time and how many phases it went through). `/dock` keeps listing every step after the request |
-| RDD | the session's RDD reviews from Gentle Shell's review events, one row per review, newest last (latest 6, then `+N earlier`), named by the first reviewed file and ` +N` more. A review whose files are not known yet shows as `changes` until they arrive; if the answer is that no review runs (an inspect or status check), that row goes away. On the title's right the RDD switch for the project folder: `on` in green or `off` muted, read from Gentle AI itself with its read-only `gentle-ai review mode status --cwd <folder> --json` at session start and after each turn, one call at a time with a 5 s timeout; a failed, timed-out or unreadable read keeps the last known switch (unknown at first: no switch). The binary is `gentle-ai` on PATH, else the one bundled in the `gentle-pi` package (`.gentle-ai/<version>/gentle-ai.exe` on Windows, `gentle-ai` elsewhere): the package the `gentle-shell` launcher names in `GENTLE_SHELL_CHILD_PACKAGE_INJECTION`, else the global npm one (`%APPDATA%\npm\node_modules\gentle-pi` on Windows; the npm prefix, node's own prefix, `/usr/local`, `/usr` and `~/.npm-global` elsewhere). A running review is highlighted with a turning teal spinner, `reviewing…` (or `fixing…` while findings are fixed) and its time; one waiting for you shows an amber `!` and `needs your OK`; finished ones show `✓ approved`, `✗ outdated · code changed` (changed after approval), `✗ unavailable` or a muted `skipped`, with the local time it ended (`23:05`). Under each review one gray line, aligned with its name, read from the review tools the agent calls (never from the opaque bindings): while it runs, what it is doing (`starting · readability, reliability`, `asks to review · 2 lenses`, `preparing 2 reviewers`, `running 2 reviewers · 1 done`, `fixing · up to 38 lines`, `validating the fix`, `closing · 7 findings, none blocking`, `stopped · 2 findings need your decision`); once it ends with its findings known, what it found (`7 findings · none blocking · 2 lenses`, `3 findings · 1 fix · 2 lenses`, `no findings · 1 lens`); a review that ends without findings known (outdated, unavailable, skipped) has no line. With no review yet: a green `●` and `watching · reviews high-risk changes` when on, `○ off · changes are not reviewed` when off. Not drawn when neither the switch nor any review is known (no Gentle AI) |
+| RDD | the session's RDD reviews from Gentle Shell's review events, one row per review, newest last (latest 6, then `+N earlier`), named by the first reviewed file and ` +N` more. A review whose files are not known yet shows as `changes` until they arrive; if the answer is that no review runs (an inspect or status check), that row goes away. On the title's right the RDD switch for the project folder: `on` in vivid green or `off` muted, read from Gentle AI itself with its read-only `gentle-ai review mode status --cwd <folder> --json` at session start and after each turn, one call at a time with a 5 s timeout; a failed, timed-out or unreadable read keeps the last known switch (unknown at first: no switch). The binary is `gentle-ai` on PATH, else the one bundled in the `gentle-pi` package (`.gentle-ai/<version>/gentle-ai.exe` on Windows, `gentle-ai` elsewhere): the package the `gentle-shell` launcher names in `GENTLE_SHELL_CHILD_PACKAGE_INJECTION`, else the global npm one (`%APPDATA%\npm\node_modules\gentle-pi` on Windows; the npm prefix, node's own prefix, `/usr/local`, `/usr` and `~/.npm-global` elsewhere). A running review is highlighted with a turning teal spinner, `reviewing…` (or `fixing…` while findings are fixed) and its time; one waiting for you shows an amber `!` and `needs your OK`; finished ones show `✓ approved`, `✗ outdated · code changed` (changed after approval), `✗ unavailable` or a muted `skipped`, with the local time it ended (`23:05`). Under each review one gray line, aligned with its name, read from the review tools the agent calls (never from the opaque bindings): while it runs, what it is doing (`starting · readability, reliability`, `asks to review · 2 lenses`, `preparing 2 reviewers`, `running 2 reviewers · 1 done`, `fixing · up to 38 lines`, `validating the fix`, `closing · 7 findings, none blocking`, `stopped · 2 findings need your decision`); once it ends with its findings known, what it found (`7 findings · none blocking · 2 lenses`, `3 findings · 1 fix · 2 lenses`, `no findings · 1 lens`); a review that ends without findings known (outdated, unavailable, skipped) has no line. With no review yet: a green `●` and `watching · reviews high-risk changes` when on, `○ off · changes are not reviewed` when off. Not drawn when neither the switch nor any review is known (no Gentle AI) |
 | CI | the GitHub Actions checks of the current branch's last pushed commit, read with `gh` in the session folder (`gh run list --branch <branch> --limit 20 --json …`, the branch from the git read): the commit is the newest run's, one row per workflow of that commit (its newest run). On the title's right the commit's short sha, muted. While a check runs, waits or failed: one row per workflow, sorted by name (at most 6, then `+N more`): a running one highlighted with a turning blue spinner, its name bold, `running…` and the time since it started, ticking with the spinner (when no gh read has succeeded for over 90 s, its time stays at the last successful read and its spinner holds still until the next one); a queued one with a faint `○`, its name muted and `queued` on the right; `✓ lint passed` and `✗ tests failed` (red) with their duration, a failed one with a gray line naming the failed job and its first failed step (`node-22 · Run npm test`, from `gh run view <id> --json jobs`, read again only when the run is updated, for example a re-run; a view that names no failed job leaves no line and is not read again, a failed view is retried on the next read); a cancelled or stale one muted with `-`. Once every check passed, one row `✓ 3 checks passed` (`1 check passed` for one) with the local time of the last update (`14:02`) and a gray line with the workflow names and the longest run (`build, lint, tests · longest 2:41`; only the names when gh gave no durations). gh is read at session start, every 30 s while a check runs or waits, every 3 min otherwise, 5 s and 20 s after a `bash` command with `git push` ends, and when the branch changes to another known branch (the shown checks go at once and the new branch is read; a git read that fails to name the branch changes nothing); never while drawing. Every name from gh is cut to 80 characters and loses escape sequences, control characters and bidi overrides. A failed or timed-out gh read keeps what is shown; no `gh`, no GitHub remote, no workflows or no branch: no section |
 | agents | Gentle Shell's background jobs, from its `gentle-ai:jobs-sidebar` event (finished ones ride the snapshot a short while, as `✓` or `✗`), then Gentle Shell 4.6.0's own subagent tasks (its `subagent_run` / `subagent_continue` tools) as rows of the same shape, in the order they started; at most 4 agents, then `+N more`. A task's state comes from the `gentle-pi:notification:source` events Gentle Shell publishes for this session (`queued` `○`, `running` spinner, `waiting` `!` on a highlighted row when the subagent asks you something, `completed` `✓`, `failed`/`cancelled`/`timed_out` `✗`), ordered by their sequence; its name (the agent) and task text from the tool call's arguments, and its label, model and effort from the tool result (`details.gentleAgents`), which names the task id. A `subagent_run` / `subagent_continue` call in flight is a running row from the moment it starts, before any event, so a running subagent shows even if its events never arrive: the first event of a new task takes the oldest call still waiting (a continue, its own task), the result sets the state while no event has, a refused launch leaves no row, a refused continue puts the row back as it was, and a call whose end was lost goes when the run settles. A task only events name shows as `subagent` with `task <id>` until details arrive. With calls in parallel, two tasks can show each other's text until their results arrive. Its time counts from its first `running` event, until then from the call. Finished tasks stay 60 s, the tail of Gentle Shell's finished jobs, and fold on the next event, tool end or idle refresh. Limits: Gentle Shell's task store is private, so there are no live tokens, cost, turns or tool counts per task; a task started before Fisi Dock loaded (after a `/reload`) shows from one read of Gentle Shell's presence activity file (`<agent home>/gentle-agents/presence/<sha256(session id)>.<incarnation>.activity.json`, agent home `GENTLE_PI_AGENT_HOME`, else `PI_CODING_AGENT_DIR`, else `~/.pi/agent`) at session start, with its own start time; a missing or unreadable file changes nothing. Tool arguments and results are model text, so they are made printable and bounded (escapes, controls and bidi overrides removed, 120 characters). An agent with a model gets a label at the right end of its row: the model family (`opus`, `sonnet`, `haiku`; a model with none of these shows its short name, `gpt-5.1`, any `provider/` prefix and `claude-` dropped) in its effort's color (`low`/`minimal` amber, `medium` blue, `high`/`xhigh`/`max` purple, any other or no effort gray), then ` · <effort>` in gray (`opus · high`); no effort: the family alone; no model: no label. Each agent stays one row: when it does not fit, the task is cut first, then ` · <effort>` drops, then the label. The label never plays the entrance |
 | todo | always drawn: with no todo list or 0 tasks one muted row `○ no tasks · the list shows while I plan` and nothing on the title's right (the todo card above the prompt and the strip's `todo d/t` still show only with tasks). Otherwise Gentle Shell's todo list; on the title's right a progress bar (`▰▱`, up to 10 cells) and `done/total`. Every task in order while there are at most 8 (`✓` done muted, the active one highlighted with its spinner, `○` pending, `◌` blocked, `-` dropped). Past 8, a window of 7 tasks starting at the task before the active one (else the first open task, else the last task), after a `✓ N earlier done` row (`N earlier` when some of them are not done) and before `+N more` with a `/dock all` hint. Without the task list (only counts known yet), at most 4 rows: done count with its bar, active task, next task, `+N more`. `/dock` lists every task (see Commands) |

package/lib/label-wave.ts

@@ -2,13 +2,16 @@
 // wave one step per render, so it races while text streams and nearly stops during
 // a quiet tool run. The box repaints the same words by the clock instead, with the
 // same shape: the head and its two neighbors in the theme's accent, its
-// softer tone one further out, muted elsewhere. Only while Gentle Shell itself scans,
-// in quality and performance (S93: there Gentle Shell steps its wave once a second).
+// softer tone one further out, muted elsewhere; both tones vivid (vivid labels S3).
+// Only while Gentle Shell itself scans, in quality and performance (S93: there
+// Gentle Shell steps its wave once a second).
 // The petal before the label turns on the same clock (S97).
 import type { OrbMotion } from "./orbs.ts";
-import { bold, fg, palette } from "./palette.ts";
+import { bold, fg, palette, vivid } from "./palette.ts";
 
 export const WAVE_STEP_MS = 120;
+const WAVE_HEAD = vivid(palette.pink);
+const WAVE_SOFT = vivid(palette.lilac);
 /** Gentle Shell's wave enters three columns before the label; a short label rests between sweeps. */
 const ENTRY_STEPS = 3;
 const MIN_STEPS = 15;
@@ -23,15 +26,15 @@ export function waveLabel(label: string, now: number): string {
 	return chars
 		.map((char, index) => {
 			const distance = Math.abs(head - index);
-			return fg(distance <= 1 ? palette.pink : distance === 2 ? palette.lilac : palette.muted, char);
+			return fg(distance <= 1 ? WAVE_HEAD : distance === 2 ? WAVE_SOFT : palette.muted, char);
 		})
 		.join("");
 }
 
 /** Gentle Shell's working petal (lib/shell-prompt.ts PETAL_FRAMES): four flowers, one column each. */
 const PETAL_FRAMES = ["✿", "❀", "❁", "✾"] as const;
-/** Its tones (PETAL_TONE_FRAMES: mdQuoteBorder, thinkingHigh, accent, borderAccent, accent, thinkingHigh, mdQuoteBorder twice) in the Fisi-Dock theme's colors. */
-const PETAL_TONES = [palette.deepPink, palette.lilac, palette.pink, palette.pink, palette.pink, palette.lilac, palette.deepPink, palette.deepPink] as const;
+/** Its tones (PETAL_TONE_FRAMES: mdQuoteBorder, thinkingHigh, accent, borderAccent, accent, thinkingHigh, mdQuoteBorder twice) in the Fisi-Dock theme's vivid colors. */
+const PETAL_TONES = [palette.deepPink, palette.lilac, palette.pink, palette.pink, palette.pink, palette.lilac, palette.deepPink, palette.deepPink].map(vivid);
 
 /** Gentle Shell's working petal at the moment `now`. Gentle Shell turns the petal and the wave on one tick, so one frame per wave step. */
 export function wavePetal(now: number): string {

package/lib/palette.ts

@@ -1,46 +1,84 @@
-// Design 07 palette in 24-bit color. The panel paints with its own accents
-// instead of Pi theme roles so each section keeps its hue (S9).
-
-export type Rgb = readonly [number, number, number];
-
-export const BACKGROUND: Rgb = [0x16, 0x16, 0x16];
-
-export const palette = {
-	pink: [0xf2, 0xa7, 0xc9],
-	/** The theme's deepPink (mdQuoteBorder): the deepest tone of Gentle Shell's petal. */
-	deepPink: [0xc9, 0x77, 0x9f],
-	teal: [0x5f, 0xd4, 0xe0],
-	coral: [0xff, 0x9b, 0x85],
-	amber: [0xe0, 0xaf, 0x68],
-	lilac: [0xc3, 0xa6, 0xff],
-	green: [0x8f, 0xc9, 0x8f],
-	blue: [0x7b, 0x9c, 0xff],
-	red: [0xff, 0x6b, 0x6b],
-	/** High agent effort (S56). */
-	purple: [0xb4, 0x8c, 0xff],
-	/** Gentle Shell's Gentleman-Sexy theme accent and its deepPink: the wordmark's SHELL. */
-	sexyPink: [0xf4, 0x38, 0x88],
-	sexyDeepPink: [0xbf, 0x0f, 0x50],
-	/** Gentle Shell's banner rose. */
-	rose: [0xff, 0x76, 0xc3],
-	text: [0xe1, 0xe1, 0xe1],
-	muted: [0x6c, 0x6c, 0x6c],
-	faint: [0x4a, 0x4a, 0x4a],
-	/** Section frames: one neutral gray, Grok-style, same as Gentle Shell's welcome card frame; titles carry the hue. */
-	frame: [0x45, 0x45, 0x45],
-	highlight: [0x26, 0x26, 0x26],
-} as const satisfies Record<string, Rgb>;
-
-export const RESET = "\x1b[0m";
-
-/** Blend `color` over the panel background, keeping `amount` of the color. */
-export function dim(color: Rgb, amount = 0.4): Rgb {
-	return color.map((channel, index) => Math.round(channel * amount + BACKGROUND[index] * (1 - amount))) as unknown as Rgb;
-}
-
-export const fgCode = ([r, g, b]: Rgb) => `\x1b[38;2;${r};${g};${b}m`;
-export const bgCode = ([r, g, b]: Rgb) => `\x1b[48;2;${r};${g};${b}m`;
-
-// Style closers reset only their own attribute, so a row background survives.
-export const fg = (color: Rgb, text: string) => (text ? `${fgCode(color)}${text}\x1b[39m` : "");
-export const bold = (text: string) => (text ? `\x1b[1m${text}\x1b[22m` : "");
+// Design 07 palette in 24-bit color. The panel paints with its own accents
+// instead of Pi theme roles so each section keeps its hue (S9).
+
+export type Rgb = readonly [number, number, number];
+
+export const BACKGROUND: Rgb = [0x16, 0x16, 0x16];
+
+export const palette = {
+	pink: [0xf2, 0xa7, 0xc9],
+	/** The theme's deepPink (mdQuoteBorder): the deepest tone of Gentle Shell's petal. */
+	deepPink: [0xc9, 0x77, 0x9f],
+	teal: [0x5f, 0xd4, 0xe0],
+	coral: [0xff, 0x9b, 0x85],
+	amber: [0xe0, 0xaf, 0x68],
+	lilac: [0xc3, 0xa6, 0xff],
+	green: [0x8f, 0xc9, 0x8f],
+	blue: [0x7b, 0x9c, 0xff],
+	red: [0xff, 0x6b, 0x6b],
+	/** High agent effort (S56). */
+	purple: [0xb4, 0x8c, 0xff],
+	/** Gentle Shell's Gentleman-Sexy theme accent and its deepPink: the wordmark's SHELL. */
+	sexyPink: [0xf4, 0x38, 0x88],
+	sexyDeepPink: [0xbf, 0x0f, 0x50],
+	/** Gentle Shell's banner rose. */
+	rose: [0xff, 0x76, 0xc3],
+	text: [0xe1, 0xe1, 0xe1],
+	muted: [0x6c, 0x6c, 0x6c],
+	faint: [0x4a, 0x4a, 0x4a],
+	/** Section frames: one neutral gray, Grok-style, same as Gentle Shell's welcome card frame; titles carry the hue. */
+	frame: [0x45, 0x45, 0x45],
+	highlight: [0x26, 0x26, 0x26],
+} as const satisfies Record<string, Rgb>;
+
+export const RESET = "\x1b[0m";
+
+/** Blend `color` over the panel background, keeping `amount` of the color. */
+export function dim(color: Rgb, amount = 0.4): Rgb {
+	return color.map((channel, index) => Math.round(channel * amount + BACKGROUND[index] * (1 - amount))) as unknown as Rgb;
+}
+
+/** The WCAG contrast of `color` on the panel background. */
+function contrast(color: Rgb): number {
+	const luminance = (rgb: Rgb) => {
+		const [r, g, b] = rgb.map((channel) => channel / 255).map((value) => (value <= 0.03928 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4));
+		return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+	};
+	return (luminance(color) + 0.05) / (luminance(BACKGROUND) + 0.05);
+}
+
+/** `color`'s hue at HSL saturation 0.9 and `lightness`. */
+function withLightness(color: Rgb, lightness: number): Rgb {
+	const [r, g, b] = color.map((channel) => channel / 255);
+	const max = Math.max(r, g, b);
+	const spread = max - Math.min(r, g, b);
+	let hue = 0;
+	if (spread) hue = max === r ? ((g - b) / spread) % 6 : max === g ? (b - r) / spread + 2 : (r - g) / spread + 4;
+	hue = (hue * 60 + 360) % 360;
+	const chroma = (1 - Math.abs(2 * lightness - 1)) * 0.9;
+	const x = chroma * (1 - Math.abs(((hue / 60) % 2) - 1));
+	const m = lightness - chroma / 2;
+	const sextant = Math.floor(hue / 60);
+	const [r1, g1, b1] = [[chroma, x, 0], [x, chroma, 0], [0, chroma, x], [0, x, chroma], [x, 0, chroma], [chroma, 0, x]][sextant];
+	return [r1, g1, b1].map((value) => Math.round((value + m) * 255)) as unknown as Rgb;
+}
+
+/**
+ * The vividness of the cover title #f43888 on `color`'s own hue (vivid labels S1):
+ * HSL saturation 90%, lightness 59%; a hue that then reads under 4.5:1 on the
+ * background gets lighter in steps of 0.01 until it does, at most 0.80.
+ */
+export function vivid(color: Rgb): Rgb {
+	for (let step = 59; step < 80; step++) {
+		const out = withLightness(color, step / 100);
+		if (contrast(out) >= 4.5) return out;
+	}
+	return withLightness(color, 0.8);
+}
+
+export const fgCode = ([r, g, b]: Rgb) => `\x1b[38;2;${r};${g};${b}m`;
+export const bgCode = ([r, g, b]: Rgb) => `\x1b[48;2;${r};${g};${b}m`;
+
+// Style closers reset only their own attribute, so a row background survives.
+export const fg = (color: Rgb, text: string) => (text ? `${fgCode(color)}${text}\x1b[39m` : "");
+export const bold = (text: string) => (text ? `\x1b[1m${text}\x1b[22m` : "");

package/lib/panel.ts

@@ -5,7 +5,7 @@ import { fitDetail } from "./odd-detail.ts";
 import { orbAt, orbOf, orbWidth, shimmerText, spinnerAt } from "./orbs.ts";
 import type { AgentInfo, ChangeInfo, CiCheck, CiInfo, FooterInfo, HeadsUpWarning, McpServerInfo, OddInfo, PanelModel, RddInfo, RddReview, SessionInfo, TodoInfo, TodoTask } from "./panel-model.ts";
 import { shortAgentModel } from "./prompt-line.ts";
-import { RESET, bgCode, bold, dim, fg, palette, type Rgb } from "./palette.ts";
+import { RESET, bgCode, bold, dim, fg, palette, vivid, type Rgb } from "./palette.ts";
 import { ellipsize, padEnd, truncateToWidth, visibleWidth } from "./text.ts";
 
 // Pure model-to-lines renderer for the rail (design 07, S2/S8/S9). Gentle Shell
@@ -362,7 +362,7 @@ function emptyTodoSection(width: number): Section {
 function todoSection(todo: TodoInfo, width: number, expanded = false, spinner?: number, compact = false): Section | undefined {
 	if (todo.total <= 0) return undefined;
 	const color = palette.coral;
-	const right = fg(color, `${todo.done}/${todo.total}`);
+	const right = fg(vivid(color), `${todo.done}/${todo.total}`);
 	if (expanded && todo.tasks?.length) return { title: "todo", color, right, rows: taskRows(todo.tasks, width, spinner, todo.entrance) };
 	if (!compact && todo.tasks?.length) {
 		// S58: the listed rail keeps the progress bar, on the title before done/total.
@@ -476,7 +476,7 @@ function rddRow(review: RddReview, width: number, spinner?: number): Row {
 function rddSection(rdd: RddInfo | undefined, mode: FooterInfo["rdd"], width: number, spacers = true, spinner?: number, doneDetails = true): Section | undefined {
 	const reviews = rdd?.reviews ?? [];
 	if (reviews.length === 0 && !mode) return undefined;
-	const right = mode === "on" ? bold(fg(palette.green, "on")) : mode === "off" ? bold(fg(palette.muted, "off")) : undefined;
+	const right = mode === "on" ? bold(fg(vivid(palette.green), "on")) : mode === "off" ? bold(fg(palette.muted, "off")) : undefined;
 	const section = (rows: Row[]): Section => ({ title: "RDD", color: palette.rose, ...(right ? { right } : {}), rows });
 	if (reviews.length === 0) {
 		// One-column dot (S57): the 🌹 emoji has no fixed width across terminals and broke the frame.
@@ -669,7 +669,8 @@ function changesSection(changes: ChangeInfo[], width: number, cap = LIST_CAP): S
 
 function topBorder(section: Section, width: number): string {
 	const frame = palette.frame;
-	const title = (text: string) => bold(fg(section.color, text));
+	// Titles wear the cover title's vividness on their own hue (vivid labels S2).
+	const title = (text: string) => bold(fg(vivid(section.color), text));
 	const titleWidth = visibleWidth(section.title);
 	// "╭─ " title " " fill [" " right " ─"] "╮", with at least one fill dash.
 	const bare = 3 + titleWidth + 1 + 1 + 1;
@@ -815,7 +816,7 @@ export function renderAgentsCard(agents: AgentInfo[] | undefined, width: number,
 	});
 	const hidden = running.length - shown.length;
 	if (hidden > 0) rows.push({ text: item(" ", (rest) => spread(muted(`+${hidden} more`), `${plainText("/dock")}${muted(" all")}`, rest), inner) });
-	const section: Section = { title: "agents", color: palette.lilac, right: fg(palette.lilac, String(running.length)), rows };
+	const section: Section = { title: "agents", color: palette.lilac, right: fg(vivid(palette.lilac), String(running.length)), rows };
 	return drawSection(section, columns).map((line) => truncateToWidth(line, columns));
 }
 

package/lib/prompt-box.ts

@@ -13,7 +13,7 @@
 // before it (S96); with the clock the wave sweeps both and the petal turns by
 // the same clock (S97).
 import { waveLabel, wavePetal } from "./label-wave.ts";
-import { fg, palette } from "./palette.ts";
+import { fg, palette, vivid } from "./palette.ts";
 import { promptLineSteps, type PromptLineModel, type PromptLinePart } from "./prompt-line.ts";
 import { ellipsize, padEnd, sliceColumns, truncateToWidth, visibleWidth } from "./text.ts";
 
@@ -67,13 +67,13 @@ const join = (segments: Segment[], plain: string, styled = plain): Segment => ({
 	styled: segments.map((segment) => segment.styled).join(styled),
 });
 
-/** `● SUPER-YOLO  opus-5.5 · high`, or tight `● SUPER-YOLO opus-5.5·high`: the dot in red, the rest as the prompt line paints it. */
+/** `● SUPER-YOLO  opus-5.5 · high`, or tight `● SUPER-YOLO opus-5.5·high`: the dot in vivid red, the rest as the prompt line paints it. */
 function ownSegment(parts: PromptLinePart[], tight: boolean): Segment {
 	const mode = parts.find((part) => part.kind === "mode");
 	const rest = parts.filter((part) => part.kind !== "mode");
 	const dot = tight ? "·" : " · ";
 	const segments: Segment[] = [
-		...(mode ? [{ plain: `● ${mode.plain}`, styled: `${fg(palette.red, "●")} ${mode.styled}` }] : []),
+		...(mode ? [{ plain: `● ${mode.plain}`, styled: `${fg(vivid(palette.red), "●")} ${mode.styled}` }] : []),
 		...(rest.length ? [join(rest, dot, fg(palette.faint, dot))] : []),
 	];
 	return join(segments, tight ? " " : "  ");

package/lib/prompt-line.ts

@@ -1,4 +1,4 @@
-import { bold, fg, palette } from "./palette.ts";
+import { bold, fg, palette, vivid } from "./palette.ts";
 import { ellipsize, visibleWidth } from "./text.ts";
 
 // Design 07 shows the model and effort beside the prompt. The prompt editor is
@@ -38,8 +38,9 @@ export interface PromptLinePart {
 }
 
 /**
- * The labels in order, each plain and styled: the mode bold in red, like its dot (only when
- * it is not normal), the model muted, the effort in blue. Nothing without a model.
+ * The labels in order, each plain and styled: the mode bold in vivid red, like its dot (only
+ * when it is not normal), the model muted, the effort in vivid blue (vivid labels S3).
+ * Nothing without a model.
  * The line under the prompt and the prompt box (S88) paint the same parts.
  */
 export function promptLineParts(model: PromptLineModel): PromptLinePart[] {
@@ -47,9 +48,9 @@ export function promptLineParts(model: PromptLineModel): PromptLinePart[] {
 	const mode = permissionModeLabel(model.mode);
 	const name = shortModelName(model.modelId);
 	return [
-		...(mode ? [{ kind: "mode" as const, plain: mode, styled: bold(fg(palette.red, mode)) }] : []),
+		...(mode ? [{ kind: "mode" as const, plain: mode, styled: bold(fg(vivid(palette.red), mode)) }] : []),
 		{ kind: "model" as const, plain: name, styled: fg(palette.muted, name) },
-		...(model.effort ? [{ kind: "effort" as const, plain: model.effort, styled: fg(palette.blue, model.effort) }] : []),
+		...(model.effort ? [{ kind: "effort" as const, plain: model.effort, styled: fg(vivid(palette.blue), model.effort) }] : []),
 	];
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fisi-dock",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Side panel for Gentle Shell: session, ODD, RDD, CI, agents, todo and changes at a glance (Pi extension and theme)",
   "type": "module",
   "license": "MIT",

package/themes/Fisi-Dock.json

@@ -11,16 +11,16 @@
     "text": "#e1e1e1",
     "muted": "#6c6c6c",
     "dim": "#6b6b6b",
-    "pink": "#f2a7c9",
-    "deepPink": "#c9779f",
+    "pink": "#f5388e",
+    "deepPink": "#f53894",
     "pinkSelection": "#2a2228",
-    "teal": "#5fd4e0",
-    "coral": "#ff9b85",
-    "amber": "#e0af68",
-    "lilac": "#c3a6ff",
-    "green": "#8fc98f",
-    "blue": "#7b9cff",
-    "red": "#ff6b6b",
+    "teal": "#38e3f5",
+    "coral": "#f55a38",
+    "amber": "#f5a838",
+    "lilac": "#9464f7",
+    "green": "#38f538",
+    "blue": "#4c76f6",
+    "red": "#f53838",
     "diffAddedBg": "#24321f",
     "toolErrorBg": "#2e1a1d"
   },