@cocasts/pi-status-line 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @cocasts/pi-status-line
+
+## 0.1.0
+
+### Minor Changes
+
+- feat(status-line): add modular status line package

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 moecasts
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,228 @@
-# Temporary Holding Version
+# @cocasts/pi-status-line
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A modular, multi-row status line for the [pi coding agent](https://pi.dev). Instead of a fixed
+footer layout, you list which **modules** appear on each row's left and right, and how each one is
+labelled, formatted, and coloured.
+
+## Features
+
+- Declares any number of footer rows, each with its own left and right module lists.
+- Ships twelve built-in modules: model, provider, effort, path, branch, session, token volumes,
+  cache hit rate, throughput, context pressure, and cost.
+- Lets each module choose a label style, format preset, theme colour, and literal prefix/suffix.
+- Shrinks each row on its own by module priority, keeping the context reading as a floor.
+- Reports the effective layout, last-turn timing, and config problems through `/statusline`.
+- Keeps rendering the usable entries when the config file is partly invalid.
+
+The default layout mirrors pi's native footer:
+
+```text
+~/projects/pi-extensions (feature/status-line) • tidy-footer
+↑ 35k · ↓ 1.2k · ◎ 99.8% · ϟ 82/s · $0.42 · 17.0%/1.0M     (anthropic) anthropic/claude-sonnet-4 • high
+```
+
+Everything renders `dim`, the way the native footer does; only context pressure borrows `warning`
+(above 70 %) and `error` (above 90 %). Modules render in the order you list them, and a module with
+nothing to say (no branch, no output yet, no rate yet, only one provider) disappears without
+leaving a dangling separator.
+
+## Requirements
+
+- A current [pi coding agent](https://pi.dev) installation.
+- A monospace terminal font that draws `↑ ↓ ◎ ϟ` in one cell. Otherwise use `label: "word"`.
+
+## Installation
+
+```bash
+pi install npm:@cocasts/pi-status-line
+
+# or try it for one run without installing
+pi -e npm:@cocasts/pi-status-line
+```
+
+If pi is already running, `/reload` picks up a fresh install.
+
+## Configuration
+
+The config file is `status-line/config.json` inside pi's agent directory — by default
+`~/.pi/agent/status-line/config.json`, or `$PI_CODING_AGENT_DIR/status-line/config.json` when that
+override is set.
+
+It is read at session start and on `/reload`. A missing file means the built-in defaults; an invalid
+entry is skipped with one warning and the rest of the line still renders.
+
+```jsonc
+{
+  "divider": " · ",
+  "rows": [
+    {
+      "divider": " ",
+      "left": ["path", "branch", { "id": "session", "prefix": "• " }]
+    },
+    {
+      "left": [
+        "input",
+        "output",
+        { "id": "cache-hit", "format": "hit" },
+        "tps",
+        "cost",
+        { "id": "context", "format": "window" }
+      ],
+      "rightDivider": " ",
+      "right": [
+        "provider",
+        { "id": "model", "format": "short" },
+        { "id": "effort", "label": "word", "prefix": "• " }
+      ]
+    }
+  ]
+}
+```
+
+Top level:
+
+| Field | Values | Meaning |
+| --- | --- | --- |
+| `rows` | array of `{ "left": [], "right": [] }` | Footer rows, top to bottom. A row with nothing to show is omitted. |
+| `divider` | any string (default `" · "`) | Literal text between two modules on a row. |
+
+A row accepts `left` and `right` module lists; an omitted side is empty. It may also override the
+separator with `divider` (both sides), `leftDivider`, or `rightDivider` — the default layout uses
+`" "` on the directory row and on the identity side so `~/app (main) • session` and
+`(provider) model • level` read as phrases, while the readings keep the `·` beat. Every entry
+accepts:
+
+| Field | Values | Meaning |
+| --- | --- | --- |
+| `id` | a module id (below) | Which module to render. Unknown ids are skipped with a warning. |
+| `label` | `glyph` · `word` · `none` | How the label reads. Omit for the module's default. |
+| `format` | module-specific preset | Controls the value only. Omit for the module's default. |
+| `color` | a pi theme token | Overrides the module's own colour. Omit to keep it (e.g. context pressure). |
+| `prefix` / `suffix` | any string | Literal decoration around the whole module, rendered dim. Spaces are literal. |
+
+A bare id is shorthand for `{ "id": "…" }`, so `"left": ["input", "context"]` also works. An empty
+`rows` array clears the footer. The older single-row shape (`{ "left": [...], "right": [...] }`
+without `rows`) is still read as one row, with the default metrics row for whichever side it omits.
+
+### Labels
+
+- `glyph` — one-cell symbol from the terminal's own monospace font, followed by a space: `↑ 35k`.
+- `word` — the spelled-out label with a space: `input 35k`. Use this when a font draws a glyph wider
+  than its cell.
+- `none` — value only. The default for self-describing modules such as `model`, `context`, and
+  `cost`.
+
+### Colours
+
+`color` accepts pi's foreground theme tokens (`accent`, `muted`, `success`, `error`, `warning`,
+`syntaxString`, `thinkingLow`, …). Background tokens are rejected; run `/statusline` to validate a
+name. Every module defaults to `dim`, matching the native footer. `context` keeps its dynamic
+pressure colour unless you override it.
+
+## Modules
+
+Priority decides what leaves the footer first when the terminal narrows: **lowest priority is dropped
+first**. `floor` modules are never dropped by the shrink pass.
+
+| Module | Formats (default first) | Default label | Default colour | Priority | Floor |
+| --- | --- | --- | --- | --- | --- |
+| `session` | `name` | `none` | `dim` | 10 | no |
+| `branch` | `paren` (`(main)`) · `name` (`main`) | `none` | `dim` | 15 | no |
+| `path` | `full` (home-relative) · `tail` (last two segments) | `none` | `dim` | 20 | no |
+| `tps` | `rate` (`82/s`) · `long` (`82 tok/s`) | `glyph` `ϟ` | `dim` | 30 | no |
+| `effort` | `native` (`medium`, `thinking off`) · `word` (`medium`) · `initial` (`M`) | `none` | `dim` | 40 | no |
+| `cache-hit` | `percent` (`99.8%`) · `hit` (`99.8% hit`) | `glyph` `◎` | `dim` | 50 | no |
+| `output` | `tokens` · `exact` | `glyph` `↓` | `dim` | 60 | no |
+| `cost` | `usd` (`$0.42`) · `exact` (`$0.4200`) | `none` | `dim` | 70 | no |
+| `input` | `tokens` · `exact` | `glyph` `↑` | `dim` | 80 | no |
+| `provider` | `paren` (`(anthropic)`) · `name` (`anthropic`) | `none` | `dim` | 85 | no |
+| `model` | `id` · `short` (no provider prefix) | `none` | `dim` | 90 | no |
+| `context` | `native` (`17.0%/200k`) · `window` (`34k/200k`) · `tokens` (`34k`) · `percent` (`17%`) | `none` | pressure colour | 1000 | **yes** |
+
+Notes:
+
+- `input` / `output` count session prompt tokens that were neither read from nor written to cache, and
+  assistant output tokens. They hide while zero, as do `branch` (no repository), `session` (no name),
+  `provider` (only one provider available), `cost` (nothing spent yet), `cache-hit` and `tps` (before
+  the first turn).
+- `tps` is the **latest turn**, not a session average: an average folds in cold-cache warm-up turns
+  and reports a speed the route no longer has. `~82/s` marks an estimate; a bare `82/s` came from
+  provider usage.
+- `cost` is session spend in USD. A nonzero amount that rounds to nothing reads `$0.01`, never `$0`.
+- `context` follows the native footer: one decimal of pressure over the abbreviated window, and `?`
+  when pi withholds the share after a compaction. It is a floor and survives every shrink rung.
+
+## Overflow
+
+Each row shrinks on its own, so a long working directory never costs the metrics their seats. Within
+a row, non-floor modules give up their seat one at a time in priority order — **whichever side they
+sit on** — so:
+
+```text
+session → branch → path → tps → effort → cache-hit → output → cost → input → provider → model →
+(context stays)
+```
+
+The directory row therefore keeps the path as long as it fits, dropping the session and branch tail
+first, the way the native footer truncates its directory line from the right. A row never renders a
+module half-cut: the last module on a row that still does not fit truncates with `…`. At
+`width <= 0` the extension renders an empty line.
+
+## Commands
+
+| Command | Effect |
+| --- | --- |
+| `/statusline` | Print the effective rows, their resolved formatting, the last turn's timing, and any config problems. |
+
+The report lists each row's module order and divider, every resolved `label` / `format` / `color`
+with its source (default or config), each module's priority and floor flag, the last turn's timing
+(`ttft`, decode window, rate), and any validation problems. When there are no problems it says so
+explicitly.
+
+The report describes what is loaded, not the file on disk — after editing the file, run `/reload`,
+then `/statusline` to confirm what pi is actually showing.
+
+## Turn metrics
+
+The throughput reading follows the harness contract: a request opens at `before_provider_request`, the
+first streamed delta freezes TTFT, and a finished message's rate is
+`usage.output / ((messageEnd − firstToken) / 1000)`. A decode window shorter than 200 ms is treated as
+a burst arrival and reports **no** rate rather than a confident fake; `/statusline` shows the last
+turn's TTFT and decode window so the number is auditable.
+
+## Design rules
+
+- A glyph and a word both keep a space before the value (`↑ 35k`, `input 35k`); `none` leaves the
+  value to speak for itself.
+- Every glyph is one cell, drawn by the terminal's own monospace font, with no emoji presentation —
+  two-cell or fallback-drawn glyphs overlap the following character. Use `label: "word"` if a font
+  misbehaves.
+- Values are dim by default, like pi's native footer; context pressure is the one dynamic colour.
+  A configured `color` is an opt-in accent.
+- Rendering is a pure function of `(theme, width, layout, parts)`. There is no timer: no module reads a
+  clock, so the footer repaints on events rather than on a tick.
+- A broken config never takes the footer down: parse problems are reported once, and the usable
+  entries still render.
+
+## Development
+
+```bash
+bun install        # from the monorepo root
+bun run verify     # TypeScript 7 + Biome checks + Vitest
+bun run format     # format with Biome
+bun run test       # vitest only
+```
+
+To load the local package in pi:
+
+```bash
+pi -e ./packages/pi-status-line
+```
+
+## Author
+
+**moecasts** — <moecasts.caster@gmail.com>
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/extensions/status-line/config.ts

@@ -0,0 +1,389 @@
+/**
+ * The config schema and its tolerant reader.
+ *
+ * `parseConfig` is a pure function of the file's text: it validates every entry, records one
+ * human-readable problem per rejected or corrected field, and always returns a usable layout. A
+ * missing file, a half-edited JSON document, or a stale module id must never take the status line
+ * down — the footer is chrome, and chrome that throws is worse than chrome that is wrong.
+ */
+
+import type { ThemeColor } from '@earendil-works/pi-coding-agent';
+
+import { isModuleId, type LabelStyle, MODULE_IDS, MODULES, type ModuleId, type ResolvedEntry } from './modules.ts';
+import type { Layout } from './render.ts';
+
+/** Every foreground theme token pi exposes. Backgrounds are excluded on purpose. */
+export const THEME_COLORS: readonly ThemeColor[] = [
+  'accent',
+  'border',
+  'borderAccent',
+  'borderMuted',
+  'success',
+  'error',
+  'warning',
+  'muted',
+  'dim',
+  'text',
+  'thinkingText',
+  'scrollbarTrack',
+  'scrollbarThumb',
+  'searchMatchText',
+  'userMessageText',
+  'customMessageText',
+  'customMessageLabel',
+  'toolTitle',
+  'toolOutput',
+  'mdHeading',
+  'mdLink',
+  'mdLinkUrl',
+  'mdCode',
+  'mdCodeBlock',
+  'mdCodeBlockBorder',
+  'mdQuote',
+  'mdQuoteBorder',
+  'mdHr',
+  'mdListBullet',
+  'toolDiffAdded',
+  'toolDiffRemoved',
+  'toolDiffContext',
+  'syntaxComment',
+  'syntaxKeyword',
+  'syntaxFunction',
+  'syntaxVariable',
+  'syntaxString',
+  'syntaxNumber',
+  'syntaxType',
+  'syntaxOperator',
+  'syntaxPunctuation',
+  'thinkingOff',
+  'thinkingMinimal',
+  'thinkingLow',
+  'thinkingMedium',
+  'thinkingHigh',
+  'thinkingXhigh',
+  'thinkingMax',
+  'bashMode',
+];
+
+const LABEL_STYLES: readonly LabelStyle[] = ['none', 'glyph', 'word'];
+
+/** The separator used when the config does not name one: the visible beat between readings. */
+const DEFAULT_DIVIDER = ' · ';
+
+/** One module reference in the config file. */
+export interface ConfigEntry {
+  id: ModuleId;
+  label?: LabelStyle;
+  format?: string;
+  color?: ThemeColor;
+  prefix?: string;
+  suffix?: string;
+}
+
+/**
+ * One footer row. A missing side is empty, not inherited.
+ *
+ * `divider` overrides the top-level separator for both groups; `leftDivider` and `rightDivider`
+ * override it per side, which is how the default layout keeps `·` between readings but a plain space
+ * between the directory and its branch, and between the provider, model, and thinking level.
+ */
+export interface ConfigRow {
+  left: ConfigEntry[];
+  right: ConfigEntry[];
+  divider?: string;
+  leftDivider?: string;
+  rightDivider?: string;
+}
+
+export interface Config {
+  rows: ConfigRow[];
+  divider: string;
+}
+
+/**
+ * The order a fresh install reads, matching pi's native footer.
+ *
+ * Row one is the working directory and its context; row two is the session's volumes and the model
+ * identity. `provider` and `session` stay hidden until they have something to say, so the default
+ * line is exactly as short as the native one.
+ */
+export function defaultConfig(): Config {
+  return {
+    divider: DEFAULT_DIVIDER,
+    rows: [
+      {
+        // The directory line reads like a sentence, not a list of readings.
+        divider: ' ',
+        left: [{ id: 'path' }, { id: 'branch' }, { id: 'session', prefix: '• ' }],
+        right: [],
+      },
+      {
+        left: [
+          { id: 'input' },
+          { id: 'output' },
+          { id: 'cache-hit' },
+          { id: 'tps' },
+          { id: 'cost' },
+          { id: 'context' },
+        ],
+        // Identity is one phrase: `(provider) model • level`.
+        rightDivider: ' ',
+        right: [{ id: 'provider' }, { id: 'model' }, { id: 'effort', prefix: '• ' }],
+      },
+    ],
+  };
+}
+
+export interface ParsedConfig {
+  config: Config;
+  layout: Layout;
+  problems: string[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/** "model, effort, path, …" — every valid id, for a problem that tells you what to pick instead. */
+const KNOWN_IDS = MODULE_IDS.join(', ');
+
+function validLabel(value: unknown): value is LabelStyle {
+  return typeof value === 'string' && (LABEL_STYLES as readonly string[]).includes(value);
+}
+
+function validColor(value: unknown): value is ThemeColor {
+  return typeof value === 'string' && (THEME_COLORS as readonly string[]).includes(value);
+}
+
+/** Resolves one validated config entry into the layout's module instance. */
+export function resolveEntry(entry: ConfigEntry): ResolvedEntry {
+  const def = MODULES[entry.id];
+  return {
+    def,
+    label: entry.label ?? def.defaultLabel,
+    format: entry.format ?? def.defaultFormat,
+    color: entry.color ?? null,
+    prefix: entry.prefix ?? '',
+    suffix: entry.suffix ?? '',
+  };
+}
+
+/**
+ * Parses the config file.
+ *
+ * @param text - The file's contents, or null when it does not exist.
+ * @returns The effective config, its resolved layout, and every problem found while reading it.
+ */
+export function parseConfig(text: string | null): ParsedConfig {
+  if (text === null) {
+    const config = defaultConfig();
+    return { config, layout: toLayout(config), problems: [] };
+  }
+
+  let raw: unknown;
+  try {
+    raw = JSON.parse(text);
+  } catch (error) {
+    const config = defaultConfig();
+    const detail = error instanceof Error ? error.message : String(error);
+    return {
+      config,
+      layout: toLayout(config),
+      problems: [`config.json is not valid JSON (${detail}); using the built-in defaults`],
+    };
+  }
+
+  if (!isRecord(raw)) {
+    const config = defaultConfig();
+    return {
+      config,
+      layout: toLayout(config),
+      problems: ['config.json must be a JSON object with a "rows" array; using the built-in defaults'],
+    };
+  }
+
+  const problems: string[] = [];
+  const config: Config = {
+    divider: parseDivider(raw.divider, 'divider', problems) ?? DEFAULT_DIVIDER,
+    rows: parseRowsSetting(raw, problems),
+  };
+  return { config, layout: toLayout(config), problems };
+}
+
+/** The literal separator between modules; newlines would break the one-line-per-row contract. */
+function parseDivider(value: unknown, where: string, problems: string[]): string | null {
+  if (value === undefined) return null;
+  if (typeof value !== 'string') {
+    problems.push(`${where} must be a string; using the default separator`);
+    return null;
+  }
+  if (/[\r\n]/.test(value)) {
+    problems.push(`${where} must not contain a newline; using the default separator`);
+    return null;
+  }
+  return value;
+}
+
+/**
+ * Reads `rows`, or the older top-level `left` / `right` pair as a single row.
+ *
+ * The legacy pair keeps a just-written config working after the multi-row change: it is read as the
+ * metrics row, with the old defaults for whichever side it omitted.
+ */
+function parseRowsSetting(raw: Record<string, unknown>, problems: string[]): ConfigRow[] {
+  if (raw.rows !== undefined) return parseRows(raw.rows, problems);
+
+  if (raw.left === undefined && raw.right === undefined) return defaultConfig().rows;
+
+  const legacy = defaultConfig().rows[1] ?? { left: [], right: [] };
+  return [
+    {
+      left: parseSide(raw.left, 'left', problems, legacy.left),
+      right: parseSide(raw.right, 'right', problems, legacy.right),
+    },
+  ];
+}
+
+function parseRows(value: unknown, problems: string[]): ConfigRow[] {
+  if (!Array.isArray(value)) {
+    problems.push('rows must be an array of { "left": [...], "right": [...] } objects; using the built-in rows');
+    return defaultConfig().rows;
+  }
+  const rows: ConfigRow[] = [];
+  value.forEach((item, index) => {
+    if (!isRecord(item)) {
+      problems.push(`rows[${index}]: expected an object with "left" and/or "right"; skipped`);
+      return;
+    }
+    const row: ConfigRow = {
+      left: parseSide(item.left, `rows[${index}].left`, problems, []),
+      right: parseSide(item.right, `rows[${index}].right`, problems, []),
+    };
+    for (const key of ['divider', 'leftDivider', 'rightDivider'] as const) {
+      const divider = parseDivider(item[key], `rows[${index}].${key}`, problems);
+      if (divider !== null) row[key] = divider;
+    }
+    rows.push(row);
+  });
+  return rows;
+}
+
+/** Accepts `[{ id: "input" }]`, the shorthand `["input"]`, or a missing/!array value (fallback). */
+function parseSide(value: unknown, where: string, problems: string[], fallback: ConfigEntry[]): ConfigEntry[] {
+  if (value === undefined) return fallback;
+  if (!Array.isArray(value)) {
+    problems.push(`${where} must be an array of modules; using its default side`);
+    return fallback;
+  }
+  const entries: ConfigEntry[] = [];
+  value.forEach((item, index) => {
+    const entry = parseEntry(item, `${where}[${index}]`, problems);
+    if (entry !== null) entries.push(entry);
+  });
+  return entries;
+}
+
+function parseEntry(item: unknown, where: string, problems: string[]): ConfigEntry | null {
+  // Shorthand: a bare module id.
+  const raw = typeof item === 'string' ? { id: item } : item;
+  if (!isRecord(raw)) {
+    problems.push(`${where}: expected an object like { "id": "input" }; skipped`);
+    return null;
+  }
+
+  const id = raw.id;
+  if (!isModuleId(id)) {
+    problems.push(`${where}: unknown module ${JSON.stringify(id ?? null)}; skipped (known: ${KNOWN_IDS})`);
+    return null;
+  }
+
+  const def = MODULES[id];
+  const entry: ConfigEntry = { id };
+
+  if (raw.label !== undefined) {
+    if (validLabel(raw.label)) entry.label = raw.label;
+    else problems.push(`${where}: label must be one of ${LABEL_STYLES.join(' | ')}; using ${def.defaultLabel}`);
+  }
+
+  if (raw.format !== undefined) {
+    if (typeof raw.format === 'string' && def.formats.includes(raw.format)) entry.format = raw.format;
+    else {
+      problems.push(
+        `${where}: ${id} has no format ${JSON.stringify(raw.format)}; using ${def.defaultFormat}` +
+          (def.formats.length > 0 ? ` (known: ${def.formats.join(' | ')})` : ''),
+      );
+    }
+  }
+
+  if (raw.color !== undefined) {
+    if (validColor(raw.color)) entry.color = raw.color;
+    else problems.push(`${where}: unknown theme color ${JSON.stringify(raw.color)}; using the module's own colour`);
+  }
+
+  for (const key of ['prefix', 'suffix'] as const) {
+    const text = raw[key];
+    if (text === undefined) continue;
+    if (typeof text === 'string') entry[key] = text;
+    else problems.push(`${where}: ${key} must be a string; ignored`);
+  }
+
+  return entry;
+}
+
+/** Config entries → layout instances, preserving row order and resolving each side's separator. */
+export function toLayout(config: Config): Layout {
+  return {
+    rows: config.rows.map((row) => {
+      const divider = row.divider ?? config.divider;
+      return {
+        left: row.left.map(resolveEntry),
+        right: row.right.map(resolveEntry),
+        divider: row.leftDivider ?? divider,
+        rightDivider: row.rightDivider ?? divider,
+      };
+    }),
+  };
+}
+
+/**
+ * The `/statusline` report: the effective rows, every resolved field with its source, and the
+ * problems the reader found. Plain text; the command layer adds the title.
+ */
+export function reportConfig(parsed: ParsedConfig, source: string): string[] {
+  const lines: string[] = [`config: ${source}`, `divider: ${JSON.stringify(parsed.config.divider)}`];
+
+  parsed.config.rows.forEach((row, index) => {
+    const divider = row.divider ?? parsed.config.divider;
+    const leftDivider = row.leftDivider ?? divider;
+    const rightDivider = row.rightDivider ?? divider;
+    const dividers =
+      leftDivider === rightDivider
+        ? JSON.stringify(leftDivider)
+        : `${JSON.stringify(leftDivider)} (right: ${JSON.stringify(rightDivider)})`;
+    lines.push('', `row[${index}]:`, `  divider: ${dividers}`);
+    for (const side of ['left', 'right'] as const) {
+      lines.push(`  ${side}:`);
+      if (row[side].length === 0) lines.push('    (empty)');
+      else {
+        for (const entry of row[side]) {
+          const def = MODULES[entry.id];
+          const fields = [
+            `label=${entry.label ?? def.defaultLabel}${entry.label === undefined ? ' (default)' : ''}`,
+            `format=${entry.format ?? def.defaultFormat}${entry.format === undefined ? ' (default)' : ''}`,
+            `color=${entry.color ?? `${def.colorNote ?? def.defaultColor} (module)`}`,
+            `priority=${def.priority}${def.floor ? ' floor' : ''}`,
+          ];
+          if (entry.prefix !== undefined) fields.push(`prefix=${JSON.stringify(entry.prefix)}`);
+          if (entry.suffix !== undefined) fields.push(`suffix=${JSON.stringify(entry.suffix)}`);
+          lines.push(`    ${entry.id.padEnd(10)} ${fields.join('  ')}`);
+        }
+      }
+    }
+  });
+
+  lines.push('', 'problems:');
+  if (parsed.problems.length === 0) lines.push('  none — config is valid');
+  else for (const problem of parsed.problems) lines.push(`  - ${problem}`);
+
+  return lines;
+}