@pellux/goodvibes-tui 2.0.14 → 2.0.16

package/src/panels/notifications-panel.ts

@@ -1,12 +1,12 @@
 /**
- * NotificationsPanel — the visible home for notifications routed to the
+ * NotificationsPanel, the visible home for notifications routed to the
  * `panel_only` target (see notifications-feed.ts for why this exists).
  *
  * Renders every entry the feed has accumulated: standalone panel-routed
  * notifications, and collapsed burst/batch groups shown honestly with their
  * real running count and the plain-language reason they were held back from
  * the conversation. Descriptive text (titles, bodies, reason descriptions)
- * is always wrapped in full — never clipped to a column width.
+ * is always wrapped in full, never clipped to a column width.
  */
 import type { Line } from '@pellux/goodvibes-sdk/platform/types';
 import type { RoutingDecision } from '@/runtime/index.ts';
@@ -23,7 +23,7 @@ import { wrapText } from '../utils/terminal-width.ts';
 import { getSharedNotificationFeed, type PanelFeedEntry, type PanelNotificationFeed } from './notifications-feed.ts';
 
 // Reuses the shared, mode-aware (dark/light) panel palette's existing
-// bad/warn/info/dim tokens rather than minting new hex literals — this
+// bad/warn/info/dim tokens rather than minting new hex literals, this
 // panel has no color needs the shared palette doesn't already name.
 const C = DEFAULT_PANEL_PALETTE;
 
@@ -51,17 +51,17 @@ function levelTag(level: PanelFeedEntry['level']): string {
   return `[${level}]`;
 }
 
-/** Build every Line an entry needs — title/meta row, then the full body and reason text wrapped with no line cap (descriptive text is never clipped). */
+/** Build every Line an entry needs, title/meta row, then the full body and reason text wrapped with no line cap (descriptive text is never clipped). */
 function renderEntry(entry: PanelFeedEntry, width: number): Line[] {
   const lines: Line[] = [];
   const fg = levelColor(entry.level);
   const countSuffix = entry.collapsedCount > 1 ? ` ×${entry.collapsedCount}` : '';
-  const headerText = `${levelTag(entry.level)} ${entry.domain} — ${entry.title}${countSuffix}`;
+  const headerText = `${levelTag(entry.level)} ${entry.domain}: ${entry.title}${countSuffix}`;
   for (const wrapped of wrapText(headerText, Math.max(1, width - 1))) {
     lines.push(buildStyledPanelLine(width, [{ text: ` ${wrapped}`, fg, bold: true }]));
   }
   const reasonText = entry.collapsedCount > 1
-    ? `  ${entry.collapsedCount} notifications collapsed — ${REASON_DESCRIPTIONS[entry.reasonCode]}`
+    ? `  ${entry.collapsedCount} notifications collapsed: ${REASON_DESCRIPTIONS[entry.reasonCode]}`
     : `  ${REASON_DESCRIPTIONS[entry.reasonCode]}`;
   for (const wrapped of wrapText(reasonText, Math.max(1, width - 1))) {
     lines.push(buildStyledPanelLine(width, [{ text: ` ${wrapped}`, fg: C.dim }]));

package/src/panels/panel-confirm-overlay.ts

@@ -1,10 +1,10 @@
 // ---------------------------------------------------------------------------
-// PanelConfirmOverlay — arm a confirm from outside, resolve it inside
+// PanelConfirmOverlay, arm a confirm from outside, resolve it inside
 // handleInput().
 //
-// Why this exists: SlashCommand.handler(args, ctx) is a single-shot call —
+// Why this exists: SlashCommand.handler(args, ctx) is a single-shot call,
 // there is no "await next keypress" primitive in the command layer. A command
-// that needs a destructive confirm (e.g. /rewind — checkpoint-runtime.ts) can
+// that needs a destructive confirm (e.g. /rewind, checkpoint-runtime.ts) can
 // only resolve its target, open+focus a panel, and arm a pending confirm;
 // the actual y/n/Enter/Esc handling has to live in that panel's
 // handleInput() loop. This wraps the project's canonical ConfirmState<T>
@@ -24,7 +24,7 @@ export class PanelConfirmOverlay {
   private state: ConfirmState<{ id: string }> | null = null;
   private handlers: PanelConfirmOverlayHandlers | null = null;
 
-  /** @param onChange Called after arm() and after a confirmed/cancelled resolution (not on an absorbed keypress) — wire to the host panel's protected markDirty(). */
+  /** @param onChange Called after arm() and after a confirmed/cancelled resolution (not on an absorbed keypress), wire to the host panel's protected markDirty(). */
   constructor(private readonly onChange: () => void = () => {}) {}
 
   /** Arm a confirm/cancel prompt. Caller's handlers run only from handleInput(), never eagerly. */

package/src/panels/panel-manager.ts

@@ -1,12 +1,12 @@
 // ---------------------------------------------------------------------------
-// PanelManager — central manager for panel lifecycle, navigation, and split
+// PanelManager, central manager for panel lifecycle, navigation, and split
 // ---------------------------------------------------------------------------
 
 import type { Panel, PanelRegistration, PanelCategory, PanelDeepLinkTarget } from './types.ts';
 export type { PanelDeepLinkTarget } from './types.ts';
 // Type-only, erased at runtime, routed through the `@/` alias (not a relative
 // path) so it stays out of the relative-import graph the architecture
-// cycle-checker walks — same discipline as the PanelManager import in types.ts.
+// cycle-checker walks, same discipline as the PanelManager import in types.ts.
 import type { ConfigModalSurface } from '@/input/config-modal-types.ts';
 
 // ---------------------------------------------------------------------------
@@ -39,7 +39,7 @@ export class PanelManager {
   /**
    * Retired panel id -> modal name (panels migrated to config-modal surfaces).
    * Unlike `aliases` (panel -> panel), a hit here means no panel is ever
-   * constructed for this id — `open()` invokes `openModalCallback` instead
+   * constructed for this id, `open()` invokes `openModalCallback` instead
    * and returns a sentinel. This map and the open()-time check are the
    * sole mechanism for that redirect.
    */
@@ -75,7 +75,7 @@ export class PanelManager {
   // panel focus to disagree with workspace visibility (see getFocusTarget).
   private _focusTarget: 'prompt' | 'panel' = 'prompt';
 
-  // Cache for getWorkspaceTabs() — invalidated on every panel lifecycle event
+  // Cache for getWorkspaceTabs(), invalidated on every panel lifecycle event
   private _cachedWorkspaceTabs: readonly WorkspaceTab[] | null = null;
 
   // Most-recently-opened panel ids (front = newest), for the picker's "Recent"
@@ -146,7 +146,7 @@ export class PanelManager {
   }
 
   /**
-   * The modal name `panelIdOrAlias` redirects to, if any — lets callers
+   * The modal name `panelIdOrAlias` redirects to, if any, lets callers
    * (e.g. the `/panel` command) print "moved to the <name> modal" before or
    * instead of calling open().
    */
@@ -173,7 +173,7 @@ export class PanelManager {
 
   /**
    * Placeholder returned by open() for a modal-redirected id. Never pushed
-   * into a pane, never retained, never rendered — it exists only so open()
+   * into a pane, never retained, never rendered, it exists only so open()
    * can keep its non-null `Panel` return type without constructing the real
    * (deleted) panel view. `name` carries the modal name so a caller that
    * inspects the returned panel's `name` (rather than calling
@@ -221,7 +221,7 @@ export class PanelManager {
   }
 
   // -------------------------------------------------------------------------
-  // Panel lifecycle — operates on a specific pane (defaults to focused)
+  // Panel lifecycle, operates on a specific pane (defaults to focused)
   // -------------------------------------------------------------------------
 
   /** Invalidate the workspace tab cache. Call on every panel lifecycle mutation. */
@@ -278,7 +278,7 @@ export class PanelManager {
   /**
    * Hand an optional deep-link target (item 4) to a panel that just
    * resolved from open(). Panels without a "node" concept simply don't
-   * implement `receiveDeepLink` — the call is a no-op via optional chaining.
+   * implement `receiveDeepLink`, the call is a no-op via optional chaining.
    */
   private _deliverDeepLink(panel: Panel, target: PanelDeepLinkTarget | undefined): Panel {
     if (target) panel.receiveDeepLink?.(target);
@@ -353,7 +353,7 @@ export class PanelManager {
   }
 
   // -------------------------------------------------------------------------
-  // Navigation — operates on focused pane
+  // Navigation, operates on focused pane
   // -------------------------------------------------------------------------
 
   nextPanel(): void {
@@ -456,7 +456,7 @@ export class PanelManager {
 
   /**
    * Give keyboard focus to the panel workspace. No-op when there is nothing
-   * focusable (no visible, non-empty pane with an active panel) — this is the
+   * focusable (no visible, non-empty pane with an active panel), this is the
    * guard that upholds the focus/visibility invariant on the write path.
    */
   focusPanels(): void {
@@ -497,10 +497,10 @@ export class PanelManager {
           this.bottomPane.activeIndex = 0;
         } else {
           // Open a predictable default panel in the bottom pane. purge:
-          // 'panel-list' was deleted (dead weight over a 5-panel registry —
+          // 'panel-list' was deleted (dead weight over a 5-panel registry,
           // see the DELETE disposition), so the default is explicitly
           // 'fleet' rather than falling back to registry[0] (whatever
-          // registers first, currently 'git' — see risk 5 in the brief).
+          // registers first, currently 'git', see risk 5 in the brief).
           const defaultPanel = this._getRegistration('fleet') ?? this.registry[0];
           if (defaultPanel) {
             this.open(defaultPanel.id, 'bottom');
@@ -606,7 +606,7 @@ export class PanelManager {
   toggle(): void {
     this._visible = !this._visible;
     // Auto-open a default panel if toggling visible with nothing open.
-    // purge: explicitly 'fleet' rather than registry[0] — see the
+    // purge: explicitly 'fleet' rather than registry[0], see the
     // matching comment in toggleBottomPane() above.
     if (this._visible && this.topPane.panels.length === 0 && this.bottomPane.panels.length === 0) {
       const defaultPanel = this._getRegistration('fleet') ?? this.registry[0];

package/src/panels/plugins-panel.ts

@@ -20,7 +20,7 @@ import {
   type PanelPalette,
 } from './polish.ts';
 
-// Base chrome only — title band, state colors, and text tokens all come
+// Base chrome only, title band, state colors, and text tokens all come
 // straight from DEFAULT_PANEL_PALETTE.
 const C = DEFAULT_PANEL_PALETTE;
 
@@ -31,7 +31,7 @@ const C = DEFAULT_PANEL_PALETTE;
  * no mutation methods, so the constructor param is widened to also require
  * the handful of `PluginManager` methods this panel actually calls. The real
  * runtime object passed at bootstrap (`services.pluginManager`, a full
- * `PluginManager` instance — see src/runtime/services.ts) already satisfies
+ * `PluginManager` instance, see src/runtime/services.ts) already satisfies
  * this widened shape.
  */
 export type PluginManagerControls = PluginManagerObserver
@@ -87,7 +87,7 @@ export class PluginsPanel extends ScrollableListPanel<PluginStatus> {
       || plugin.version.toLowerCase().includes(q);
   }
 
-  // selection is preserved across onActivate — BasePanel's default
+  // selection is preserved across onActivate, BasePanel's default
   // (mark dirty, no index reset) is exactly what we want, so no override.
 
   public override onDestroy(): void {
@@ -95,7 +95,7 @@ export class PluginsPanel extends ScrollableListPanel<PluginStatus> {
   }
 
   // -------------------------------------------------------------------------
-  // Input — e=enable, d=disable (confirm), v=verify, q=lift quarantine (confirm)
+  // Input, e=enable, d=disable (confirm), v=verify, q=lift quarantine (confirm)
   // -------------------------------------------------------------------------
 
   public handleInput(key: string): boolean {
@@ -149,7 +149,7 @@ export class PluginsPanel extends ScrollableListPanel<PluginStatus> {
   }
 
   /**
-   * optional one-key capture-to-memory for a quarantined plugin — 'm'
+   * optional one-key capture-to-memory for a quarantined plugin, 'm'
    * dispatches `/recall capture plugin <name>` (recall-capture.ts:146 pattern)
    * instead of requiring the operator to type the command by hand.
    */
@@ -273,7 +273,7 @@ export class PluginsPanel extends ScrollableListPanel<PluginStatus> {
       return workspace;
     }
 
-    // Provenance/error posture header — surface trust + quarantine pressure first.
+    // Provenance/error posture header, surface trust + quarantine pressure first.
     const quarantined = plugins.filter((p) => p.quarantined).length;
     const untrusted = plugins.filter((p) => p.trustTier === 'untrusted').length;
     const active = plugins.filter((p) => p.active).length;

package/src/panels/polish-core.ts

@@ -9,7 +9,7 @@ import { activeUiTones, registerThemeRefresh } from '../renderer/theme.ts';
 // The leaf foundation of the panel formatting toolkit: both `polish.ts` and
 // `polish-tables.ts` build on these. Kept dependency-free (only grid /
 // terminal-width / ui-primitives) so it never participates in an import cycle.
-// All symbols are re-exported from `polish.ts` — panels import from there.
+// All symbols are re-exported from `polish.ts`, panels import from there.
 // ---------------------------------------------------------------------------
 
 export interface PanelPalette {
@@ -33,7 +33,7 @@ export interface PanelPalette {
 
 // Built from the mode-resolved chrome tones (activeUiTones). Because 100+ call
 // sites read this object by reference, mode changes rebuild it IN PLACE via the
-// registered refresher below rather than re-resolving per call — see theme.ts's
+// registered refresher below rather than re-resolving per call, see theme.ts's
 // active-mode runtime note. This refresher is registered before any panel's
 // extendPalette() runs (panels import polish → polish-core first), so on a mode
 // flip the base is rebuilt before the extended palettes re-merge from it.

package/src/panels/polish-tables.ts

@@ -10,7 +10,7 @@ import type { PanelPalette, StyledPanelSegment } from './polish-core.ts';
 // Shared formatting primitives (the toolkit panels standardize on).
 //
 // All are display-width aware (via getDisplayWidth / truncateDisplay) so they
-// stay aligned across emoji, CJK, and other wide characters — never hand-roll
+// stay aligned across emoji, CJK, and other wide characters, never hand-roll
 // .slice()/.padEnd() truncation or alignment in panels.
 // ---------------------------------------------------------------------------
 
@@ -113,7 +113,7 @@ const STATUS_BADGES: Record<StatusBadgeKind, BadgeSpec> = {
 
 /**
  * Canonical status badge (glyph + label) with a consistent color per lifecycle
- * state. Returns StyledPanelSegment[] — spread into a buildPanelLine call:
+ * state. Returns StyledPanelSegment[], spread into a buildPanelLine call:
  *   buildPanelLine(width, [['  ', C.label], ...buildStatusBadge('running')])
  * Supersedes ad-hoc per-panel status→color maps.
  */

package/src/panels/polish.ts

@@ -162,7 +162,7 @@ export function buildSearchInputLine(
 /**
  * Build a status pill segment (glyph + label) for use in buildPanelLine.
  *
- * Returns StyledPanelSegment[] — spread directly into a buildPanelLine segments
+ * Returns StyledPanelSegment[], spread directly into a buildPanelLine segments
  * array:
  *   buildPanelLine(width, [['  count ', C.label], ...buildStatusPill('bad', '3')])
  *

package/src/panels/project-planning-answer-actions.ts

@@ -17,7 +17,7 @@ export interface PlanningAnswerAction {
   readonly disabled?: boolean;
 }
 
-/** SDK placeholder recommendations that carry no real signal — never surfaced as an answer action. */
+/** SDK placeholder recommendations that carry no real signal, never surfaced as an answer action. */
 export function isGenericRecommendation(value: string): boolean {
   return /\bdefine the first-pass scope\b/i.test(value)
     || /\bcreate task records\b/i.test(value)
@@ -32,12 +32,12 @@ function compactAnswerDetail(text: string): string {
 
 /**
  * Builds the answer-action list for the current question: keyword-matched
- * canned suggestions first (de-duplicated by normalized answer text — a
+ * canned suggestions first (de-duplicated by normalized answer text, a
  * question that matches more than one keyword category, e.g. scope +
  * recommendedAnswer echoing one of the scope answers verbatim, must not show
  * the same suggested answer twice), then the fixed ask-narrower/custom actions.
  *
- * dismissing planning is no longer a pseudo answer-row — it is a
+ * dismissing planning is no longer a pseudo answer-row, it is a
  * first-class confirmed modal action (the `d` key), so no dismiss row is
  * produced here. A canned answer records against the current open question via
  * /plan answer; the custom row's free-form text is submitted to chat.

package/src/panels/scrollable-list-panel.ts

@@ -22,15 +22,15 @@ import { GLYPHS } from '../renderer/ui-primitives.ts';
  * Base class for all list-based panels that require scroll/cursor navigation.
  *
  * Subclasses implement:
- *   - `getItems()` — the ordered list of items to display
- *   - `renderItem(item, index, selected, width)` — one `Line` per item
+ *   - `getItems()`, the ordered list of items to display
+ *   - `renderItem(item, index, selected, width)`, one `Line` per item
  *
  * Optionally override:
- *   - `getEmptyStateMessage()` / `getEmptyStateActions()` — empty-state copy
- *   - `onSelect(item)` — called when the user presses Enter
- *   - `onAction(item, action)` — for secondary key bindings
- *   - `getPalette()` — colour palette (defaults to `DEFAULT_PANEL_PALETTE`)
- *   - `getPageSize()` — rows per page-up/page-down (default 10)
+ *   - `getEmptyStateMessage()` / `getEmptyStateActions()`, empty-state copy
+ *   - `onSelect(item)`, called when the user presses Enter
+ *   - `onAction(item, action)`, for secondary key bindings
+ *   - `getPalette()`, colour palette (defaults to `DEFAULT_PANEL_PALETTE`)
+ *   - `getPageSize()`, rows per page-up/page-down (default 10)
  *
  * `renderList()` produces the full `Line[]` output that a trivial panel's
  * `render()` can return directly:
@@ -71,7 +71,7 @@ export abstract class ScrollableListPanel<T> extends BasePanel {
   }
 
   /**
-   * The list after applying the active filter — used for both display and
+   * The list after applying the active filter, used for both display and
    * navigation. Identical to `getItems()` unless a filter is enabled and a
    * non-empty query is set, so existing panels are unaffected.
    */
@@ -84,12 +84,12 @@ export abstract class ScrollableListPanel<T> extends BasePanel {
 
   /**
    * The item currently under the cursor, resolved against the FILTERED list
-   * that navigation actually moves over (`getVisibleItems()`) — never the raw
+   * that navigation actually moves over (`getVisibleItems()`), never the raw
    * `getItems()` source.
    *
    * Subclasses MUST read the selected row through this method (or, when a
    * function also needs the list for counts/windows, through a function-scope
-   * `const visible = this.getVisibleItems()` local — indexing that local, never
+   * `const visible = this.getVisibleItems()` local, indexing that local, never
    * the raw source). Indexing a raw item array (`this.rows`, `this.entries`,
    * `getItems()`, …) with `this.selectedIndex` silently returns the wrong row
    * whenever a filter is active, because `selectedIndex` is an offset into the
@@ -126,7 +126,7 @@ export abstract class ScrollableListPanel<T> extends BasePanel {
         this.needsRender = true;
         return true;
       }
-      // Arrow/paging keys navigate the filtered list — fall through.
+      // Arrow/paging keys navigate the filtered list, fall through.
       if (key === 'up' || key === 'down' || key === 'pageup' || key === 'pagedown' || key === 'home' || key === 'end') {
         return null;
       }
@@ -172,7 +172,7 @@ export abstract class ScrollableListPanel<T> extends BasePanel {
   }
 
   // -------------------------------------------------------------------------
-  // Abstract — subclasses must implement
+  // Abstract, subclasses must implement
   // -------------------------------------------------------------------------
 
   /** Return the full ordered list of items to display. */
@@ -224,7 +224,7 @@ export abstract class ScrollableListPanel<T> extends BasePanel {
   }
 
   // -------------------------------------------------------------------------
-  // Navigation — consistent across ALL panels
+  // Navigation, consistent across ALL panels
   // -------------------------------------------------------------------------
 
   /**
@@ -245,7 +245,7 @@ export abstract class ScrollableListPanel<T> extends BasePanel {
   /**
    * The `/`-to-filter buffer wants every character of a burst (paste, or a
    * fast-typed query landing in one input.feed() call), same as it always
-   * has — see the interface doc on `Panel.isCapturingTextBurst`.
+   * has, see the interface doc on `Panel.isCapturingTextBurst`.
    */
   isCapturingTextBurst(): boolean {
     return this.filterEnabled && this.filterActive;
@@ -348,7 +348,7 @@ export abstract class ScrollableListPanel<T> extends BasePanel {
   }
 
   // -------------------------------------------------------------------------
-  // Render helper — the main convenience entry point
+  // Render helper, the main convenience entry point
   // -------------------------------------------------------------------------
 
   /**

package/src/panels/search-focus.ts

@@ -20,7 +20,7 @@ export function getPanelSearchFocusTransition(
 // Panel search filters are end-anchored (no moveable cursor).
 // Per the delete-key policy (src/input/delete-key-policy.ts):
 //   'backspace' removes the last character.
-//   'delete' is a no-op — there is no cursor, so forward-delete is meaningless.
+//   'delete' is a no-op, there is no cursor, so forward-delete is meaningless.
 export function isPanelSearchBackspace(key: string): boolean {
   return isTextBackspace(key);
 }

package/src/panels/session-maintenance.ts

@@ -3,7 +3,7 @@
  *
  * The canonical evaluator is the SDK version exported from @/runtime/index.ts
  * (via operations.evaluateSessionMaintenance), which reads from configManager.
- * Import the evaluator from there — this module provides only the shared
+ * Import the evaluator from there, this module provides only the shared
  * Panel* type surface used across TUI panels and tests; it intentionally does
  * not re-implement the evaluator.
  */

package/src/panels/skills-panel.ts

@@ -34,7 +34,7 @@ export interface SkillRecord {
   frontmatter: Record<string, string>;
   /**
    * Set when this skill's file lives under an installed ecosystem-marketplace
-   * receipt's targetPath — the receipt's provenance summary (e.g. curated
+   * receipt's targetPath, the receipt's provenance summary (e.g. curated
    * source / signature info), so marketplace-installed skills read as such
    * instead of looking identical to hand-authored ones.
    */
@@ -370,7 +370,7 @@ export class SkillsPanel extends ScrollableListPanel<SkillRecord> {
   // (the purge): Enter used to open the skill's markdown source in the
   // preview panel via a staged pendingOpenPreview flag + handlePanelIntegrationAction
   // (same pattern diff-panel.ts used). 'preview' is DELETE-disposition with no
-  // successor surface (no file-picker-overlay preview to repoint to either —
+  // successor surface (no file-picker-overlay preview to repoint to either,
   // verified), so that cross-panel jump was removed rather than repointed;
   // Enter is currently a no-op on this list (browse-only until migrates
   // Skills to a modal).
@@ -392,7 +392,7 @@ export class SkillsPanel extends ScrollableListPanel<SkillRecord> {
     }
     if (confirmResult === 'absorbed') return true;
 
-    // I1: 'd' prompts delete confirmation — only outside filter mode, so 'd'
+    // I1: 'd' prompts delete confirmation, only outside filter mode, so 'd'
     // remains typeable into the filter query while it is active (// converged modal '/' filter coexists with single-letter action keys).
     if (!this.filterActive && key === 'd') {
       const skill = this.getSelectedItem();

package/src/panels/token-budget-panel.ts

@@ -43,7 +43,7 @@ interface TurnUsage {
 // ---------------------------------------------------------------------------
 
 const C = extendPalette(DEFAULT_PANEL_PALETTE, {
-  // Token data-series colors (input/output/cache) — categorical, no shared equivalent
+  // Token data-series colors (input/output/cache), categorical, no shared equivalent
   input: '#00ffff',
   output: '#d000ff',
   cacheRead: '#00d700',
@@ -96,11 +96,11 @@ function fmtTok(n: number): string {
 export class TokenBudgetPanel extends BasePanel {
   /** Snapshot of cumulative usage from the Orchestrator after each turn. */
   private sessionUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-  /** lastInputTokens from the Orchestrator — current context window occupancy. */
+  /** lastInputTokens from the Orchestrator, current context window occupancy. */
   private lastInputTokens = 0;
   /** Context window size from the model config (0 = unknown). */
   private contextWindow = 0;
-  /** Per-turn snapshots — at most MAX_TURN_HISTORY entries. */
+  /** Per-turn snapshots, at most MAX_TURN_HISTORY entries. */
   private turnHistory: TurnUsage[] = [];
   /** Previous cumulative snapshot to compute per-turn delta. */
   private prevCumulative = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
@@ -115,7 +115,7 @@ export class TokenBudgetPanel extends BasePanel {
   private readonly configManager: Pick<ConfigManager, 'get'>;
   private readonly requestRender: () => void;
 
-  /** Turn-event bus subscriptions — absorbed from ContextVisualizerPanel. */
+  /** Turn-event bus subscriptions, absorbed from ContextVisualizerPanel. */
   private unsubs: Array<() => void> = [];
 
   /** Manual scroll cursor into turnHistory; -1 = auto-follow the latest turn. */
@@ -261,7 +261,7 @@ export class TokenBudgetPanel extends BasePanel {
   }
 
   handleInput(key: string): boolean {
-    // Confirmation dialog — use the shared handleConfirmInput for y/n/Esc UX
+    // Confirmation dialog, use the shared handleConfirmInput for y/n/Esc UX
     const confirmResult = handleConfirmInput(this.confirm, key);
     if (confirmResult === 'confirmed') {
       this.confirm = null;
@@ -462,11 +462,11 @@ export class TokenBudgetPanel extends BasePanel {
       const nextStep = status.nextSteps[0]!;
       // when the recommended next step is /compact and C is armed
       // (see handleInput's elevated-only C branch and the footer hint),
-      // advertise the key instead of the command — pressing C already
+      // advertise the key instead of the command, pressing C already
       // dispatches it for real, so printing '/compact' here was a redundant
       // action substitute.
       if (nextStep === '/compact' && this._pressureElevated()) {
-        lines.push(buildGuidanceLine(width, 'C', 'compact context now — the recommended next maintenance action', DEFAULT_PANEL_PALETTE));
+        lines.push(buildGuidanceLine(width, 'C', 'compact context now: the recommended next maintenance action', DEFAULT_PANEL_PALETTE));
       } else {
         lines.push(buildGuidanceLine(width, nextStep, 'open the next maintenance action directly', DEFAULT_PANEL_PALETTE));
       }
@@ -569,14 +569,14 @@ export class TokenBudgetPanel extends BasePanel {
     const suffix = ` ${fmtTok(this.lastInputTokens)}/${fmtTok(this.contextWindow)} (${pctInt}%)${warnSuffix}`;
     const BAR_W = Math.max(8, width - label.length - suffix.length - 2);
     const filled = Math.round(pct * BAR_W);
-    // Context fill is the headline metric — render it with the shared meter
+    // Context fill is the headline metric, render it with the shared meter
     // primitive so the bar glyphs and width handling match every other panel.
     lines.push(buildMeterLine(width, filled, BAR_W,
       { filled: barColor, empty: C.barBg, label: C.label },
       { prefix: label, suffix },
     ));
 
-    // Pressure pill — absorbed from ContextVisualizerPanel's headline indicator.
+    // Pressure pill, absorbed from ContextVisualizerPanel's headline indicator.
     const overLimit = this.contextWindow > 0 && this.lastInputTokens > this.contextWindow;
     const pressureState = overLimit || pct >= WARN_RED ? 'bad' : pct >= WARN_YELLOW ? 'warn' : 'good';
     const pressureLabel = overLimit ? 'over limit' : pct >= WARN_RED ? 'critical' : pct >= WARN_YELLOW ? 'elevated' : 'healthy';
@@ -612,7 +612,7 @@ export class TokenBudgetPanel extends BasePanel {
       ]));
     }
 
-    // Inline cost estimate — absorbed pricing wiring (cost-utils.ts), shown
+    // Inline cost estimate, absorbed pricing wiring (cost-utils.ts), shown
     // whenever the active model id is known.
     if (this.getCurrentModelId) {
       const modelId = this.getCurrentModelId();
@@ -628,7 +628,7 @@ export class TokenBudgetPanel extends BasePanel {
           ? [{ text: ` (${source})`, fg: C.dim }]
           : priced
             ? []
-            : [{ text: ' — set it with p on the cost panel', fg: C.dim }]),
+            : [{ text: ': set it with p on the cost panel', fg: C.dim }]),
       ]));
     }
 

package/src/panels/types.ts

@@ -3,7 +3,7 @@ import type { StatusState } from '../renderer/status-glyphs.ts';
 import type { ComponentResourceContract, ComponentHealthState } from '../runtime/perf/panel-contracts.ts';
 // Routed through the `@/` alias (not `./panel-manager.ts`) so this foundational
 // types module stays a leaf in the relative-import graph the architecture
-// cycle-checker walks. Type-only, erased at runtime — no real dependency edge.
+// cycle-checker walks. Type-only, erased at runtime, no real dependency edge.
 import type { PanelManager } from '@/panels/panel-manager.ts';
 
 /**
@@ -20,7 +20,7 @@ export interface PanelIntegrationContext {
  * A cross-panel deep-link target (item 4): a specific node a panel
  * should select + reveal when opened via `PanelManager.open(id, pane, target)`,
  * e.g. a Fleet tree node keyed by its process id and (optionally) its
- * ProcessKind for disambiguation. Panel-agnostic on purpose — only panels that
+ * ProcessKind for disambiguation. Panel-agnostic on purpose, only panels that
  * have a "node" concept implement `Panel.receiveDeepLink`.
  */
 export interface PanelDeepLinkTarget {
@@ -56,7 +56,7 @@ export type NamedKey =
 export type KeyName = NamedKey | (string & {});
 
 /**
- * the former single 'monitoring' bucket held 33 panels pre-merge —
+ * the former single 'monitoring' bucket held 33 panels pre-merge,
  * too coarse for the picker to be useful and too large for any one operator
  * mental model. Split into named operator domains so each category holds a
  * bounded, coherent set (no category may exceed 10 registrations):
@@ -102,10 +102,10 @@ export interface Panel {
   /** Called by the compositor after a successful render to clear the dirty flag. */
   markRendered(): void;
 
-  // Resource contract (optional — panels may declare resource requirements)
+  // Resource contract (optional, panels may declare resource requirements)
   resourceContract?: Readonly<ComponentResourceContract>;
 
-  // Health state (optional — set by ComponentHealthMonitor when panel is registered)
+  // Health state (optional, set by ComponentHealthMonitor when panel is registered)
   healthState?: Readonly<ComponentHealthState>;
 
   // Input (optional)
@@ -114,8 +114,8 @@ export interface Panel {
   /**
    * Optional: report `true` while this panel has an active inline text
    * capture (e.g. a `/`-to-filter or search buffer) that deliberately wants
-   * every character of a burst — paste, or several keystrokes typed fast
-   * enough to land in one `input.feed()` call — delivered to `handleInput`
+   * every character of a burst, paste, or several keystrokes typed fast
+   * enough to land in one `input.feed()` call, delivered to `handleInput`
    * one at a time, same as it always has. When this returns `false` or is
    * not implemented, the input router treats a printable burst as never a
    * deliberate single-key panel hotkey and routes it to the composer
@@ -141,11 +141,11 @@ export interface Panel {
   /**
    * Optional: called by the global Ctrl+X (`panel-close`) shortcut BEFORE it
    * closes this panel (handler-shortcuts.ts). Return `true` to consume
-   * Ctrl+X for an in-panel action instead — e.g. FleetPanel (session
+   * Ctrl+X for an in-panel action instead, e.g. FleetPanel (session
    * tabs) detaches its active tab and leaves the panel open. Return `false`
    * (or omit this hook) to fall through to the ordinary close behavior.
    * Ctrl+X never reaches a panel's own `handleInput` (ctrl/meta combos are
-   * intercepted earlier — see handlePanelFocusToken in
+   * intercepted earlier, see handlePanelFocusToken in
    * src/input/handler-feed-routes.ts), so this is the one seam a panel has
    * to intervene before the global shortcut acts.
    */
@@ -153,12 +153,12 @@ export interface Panel {
 
   /**
    * Optional: consume a deep-link target handed in by `PanelManager.open(id,
-   * pane, target)` (item 4) — select + reveal the matching node on the
+   * pane, target)` (item 4), select + reveal the matching node on the
    * panel's next snapshot. A panel without a "node" concept simply doesn't
    * implement this (the call is a no-op via optional chaining in
    * PanelManager). A panel that DOES implement it owns its own honest
    * "not found" surface (e.g. FleetPanel.setError) when the target no longer
-   * resolves — PanelManager has no transcript/print seam to report on its
+   * resolves, PanelManager has no transcript/print seam to report on its
    * behalf.
    */
   receiveDeepLink?(target: PanelDeepLinkTarget): void;
@@ -168,19 +168,19 @@ export interface PanelRegistration extends Pick<Panel, 'id' | 'name' | 'icon' |
   factory: () => Panel;
   description: string;
   /**
-   * lifecycle flags. `preload` and `retainOnClose` are independent —
+   * lifecycle flags. `preload` and `retainOnClose` are independent,
    * a panel can eagerly instantiate without being kept alive on close, or be
    * kept alive on close without eager bootstrap instantiation. They happened
    * to be identical for all builtin panels before this split (both driven by
    * a single `preload: true`); that existing 10-panel retained set is
    * preserved unchanged by giving each of those 10 registrations both flags.
    *
-   * - `preload` — instantiate this panel during `PanelManager.prewarmRegistered()`
+   * - `preload`, instantiate this panel during `PanelManager.prewarmRegistered()`
    *   (called once at bootstrap) so its factory runs and it starts
    *   accumulating background data (subscriptions, timers) before the user
    *   ever opens the workspace. Panels without `preload` are instantiated
    *   lazily on first `open()`.
-   * - `retainOnClose` — when this panel is closed, keep the live instance in
+   * - `retainOnClose`, when this panel is closed, keep the live instance in
    *   `PanelManager`'s retained-panel map (background subscriptions/timers
    *   keep running) instead of calling `onDestroy()`. Reopening returns the
    *   same instance with its accumulated state intact. Panels without