@pellux/goodvibes-tui 2.0.21 → 2.1.1

package/src/input/panel-integration-actions.ts

@@ -1,33 +0,0 @@
-import type { CommandContext } from './command-registry.ts';
-import type { Panel } from '../panels/types.ts';
-import type { PanelManager } from '../panels/panel-manager.ts';
-
-// (the purge): every instanceof-routed branch this file used to carry
-// (FileExplorerPanel/FilePreviewPanel/SymbolOutlinePanel, DELETE;
-// ApprovalPanel/TasksPanel/OrchestrationPanel/AgentInspectorPanel,
-// RETIRE-INTO-FLEET) targeted a panel class that no longer exists. Panels
-// migrated onto the formal `Panel.handlePanelIntegrationAction` hook (the
-// preferred seam, see the comment below) are unaffected; this function now
-// only provides that passthrough. See
-// .goodvibes/audit/2026-07-04-wave6-briefs.json for the disposition
-// map.
-export function handlePanelIntegrationAction(
-  panelManager: PanelManager,
-  activePanel: Panel | null,
-  key: string,
-  commandContext?: CommandContext,
-): boolean {
-  if (!activePanel) return false;
-
-  // Prefer the panel's own integration hook when it provides one. Panels migrated
-  // onto the formal hook opt out of the instanceof routing below.
-  if (activePanel.handlePanelIntegrationAction) {
-    const consumed = activePanel.handlePanelIntegrationAction(key, {
-      panelManager,
-      executeCommand: commandContext?.executeCommand,
-    });
-    if (consumed) return true;
-  }
-
-  return false;
-}

package/src/input/panel-mouse-geometry.ts

@@ -1,97 +0,0 @@
-// ---------------------------------------------------------------------------
-// panel-mouse-geometry.ts
-//
-// Pure mouse-geometry helpers for the panel workspace, extracted from
-// handler-feed-routes.ts so that file stays under the 800-line architecture
-// cap once the focus verbs and the paste-flood guard both live in
-// it. These map a terminal (row, col) onto the panel/pane/workspace-tab under
-// the cursor. No dependency on the feed-route state types, so no import cycle.
-// ---------------------------------------------------------------------------
-
-import type { PanelManager } from '../panels/panel-manager.ts';
-import { renderPanelWorkspaceBar } from '../renderer/panel-workspace-bar.ts';
-import type { TabHitRegion } from '../renderer/tab-strip.ts';
-
-/** Screen rectangle the panel workspace occupies, plus its vertical split. */
-export type PanelMouseLayout = {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-  hasBottomPane: boolean;
-  verticalSplitRatio: number;
-};
-
-function clampRatio(value: number): number {
-  return Math.max(0.2, Math.min(0.8, value));
-}
-
-export function getActivePanelInPane(panelManager: PanelManager, pane: 'top' | 'bottom') {
-  const target = pane === 'top' ? panelManager.getTopPane() : panelManager.getBottomPane();
-  return target.panels[target.activeIndex] ?? null;
-}
-
-export function getPanelUnderMouse(
-  panelManager: PanelManager,
-  layout: PanelMouseLayout | null,
-  row: number,
-  col: number,
-) {
-  if (
-    layout === null
-    || !panelManager.isVisible()
-    || panelManager.getAllOpen().length === 0
-    || col < layout.x
-    || col >= layout.x + layout.width
-    || row < layout.y
-    || row >= layout.y + layout.height
-  ) {
-    return null;
-  }
-
-  const panelRow = row - layout.y;
-  if (!layout.hasBottomPane) {
-    return getActivePanelInPane(panelManager, 'top');
-  }
-
-  // Single consolidated workspace bar (row 0) + h-separator; the rest splits
-  // between the two panes' content.
-  const panelAreaRows = Math.max(0, layout.height - 1);
-  const contentRows = Math.max(0, panelAreaRows - 1);
-  const topContentRows = contentRows <= 1
-    ? contentRows
-    : Math.max(1, Math.floor(contentRows * clampRatio(layout.verticalSplitRatio)));
-  // panelRow 0 = workspace bar; rows 1..topContentRows = top pane; rest = bottom.
-  return panelRow <= topContentRows
-    ? getActivePanelInPane(panelManager, 'top')
-    : getActivePanelInPane(panelManager, 'bottom');
-}
-
-/**
- * If the mouse is over the consolidated workspace tab bar (the first panel
- * row), return the index of the tab under the cursor, else null. Recomputes the
- * tab hit regions by rendering the bar with a layout callback, cheap and keeps
- * the click geometry in lockstep with what was drawn.
- */
-export function workspaceTabAtMouse(
-  panelManager: PanelManager,
-  layout: PanelMouseLayout | null,
-  row: number,
-  col: number,
-): number | null {
-  if (
-    layout === null
-    || !panelManager.isVisible()
-    || panelManager.getAllOpen().length === 0
-    || row !== layout.y // workspace bar is the first panel row
-    || col < layout.x
-    || col >= layout.x + layout.width
-  ) {
-    return null;
-  }
-  let regions: readonly TabHitRegion[] = [];
-  renderPanelWorkspaceBar(panelManager.getWorkspaceTabs(), layout.width, true, (r) => { regions = r; });
-  const relCol = col - layout.x;
-  const hit = regions.find((rg) => relCol >= rg.startCol && relCol < rg.endCol);
-  return hit ? hit.index : null;
-}

package/src/input/panel-paste-flood-guard.ts

@@ -1,86 +0,0 @@
-// ---------------------------------------------------------------------------
-// panel-paste-flood-guard.ts, item 5.
-//
-// A terminal WITHOUT bracketed paste delivers a pasted block as a burst of
-// discrete 1-char 'text' tokens (isPasteToken stays false for every one of
-// them, since that flag only fires for a single token whose value.length > 1
-//, see handler-feed-routes.ts's own Invariant B doc). Before this guard,
-// each such character became a real panel hotkey on a focused non-capturing
-// panel (K arms kill, etc.) once it reached handlePanelFocusToken's per-char
-// dispatch loop.
-//
-// This is a RATE guard: more than PANEL_PASTE_FLOOD_THRESHOLD qualifying
-// tokens within the trailing PANEL_PASTE_FLOOD_WINDOW_MS, evaluated with a
-// real sliding window (old timestamps age out of `timestamps` every call).
-// It is deliberately NOT the retired per-feed char-SUM burst heuristic this
-// same input layer already tore out once (see panel-focus-burst.test.ts's
-// header doc): that old guard summed one feed()'s character count with no
-// timing signal at all, so two ordinary nav keystrokes landing in a single
-// feed(), a real, common case, not an edge case, were misread as a burst
-// and focus was silently flipped to the composer. This guard:
-//   - never touches focus (panelFocused is untouched by trackPanelPasteFloodGuard
-//     and by its caller);
-//   - is keyed on WALL-CLOCK TIMING, not a per-feed token count, so it
-//     doesn't care how many tokens land in one feed() call, only how fast
-//     they arrive relative to each other;
-//   - is sticky once tripped (only a quiet gap, no qualifying token for a
-//     full window, clears it) so it doesn't flap dispatch on/off as the
-//     count oscillates near the threshold mid-flood.
-//
-// ~8 keys/120ms is far beyond sustained human typing (a fast typist peaks
-// well under that inter-key rate over any real span) but is exactly the
-// shape an unbracketed paste replay takes. It also keeps the pre-existing
-// Invariant B regression tests (2 keys in one feed(), no timing control at
-// all) far under threshold while catching a real flood within its first ~9
-// characters.
-// ---------------------------------------------------------------------------
-
-export const PANEL_PASTE_FLOOD_WINDOW_MS = 120;
-export const PANEL_PASTE_FLOOD_THRESHOLD = 8;
-
-/**
- * Guard state, a single persistent instance lives on the caller's
- * long-lived context (handler-feed.ts's InputFeedContext, mirroring how that
- * object already owns `nextPasteId`/`mouseDownRow`/etc.) and is MUTATED IN
- * PLACE by trackPanelPasteFloodGuard below, never replaced, so callers never
- * need to thread a return value back into their own state (unlike
- * `panelFocused`, which handlePanelFocusToken returns because it is NOT a
- * mutable outparam).
- */
-export interface PanelBurstGuardState {
-  timestamps: readonly number[];
-  suspended: boolean;
-  hintShown: boolean;
-}
-
-export interface PanelBurstGuardResult {
-  /** False while suspended, the caller must drop this token, not dispatch it. */
-  readonly dispatch: boolean;
-  /** True exactly once per burst: the call that just tripped suspension. */
-  readonly showHintNow: boolean;
-}
-
-/** Advance `guard` (mutated in place) by one qualifying token at time `now` (ms). */
-export function trackPanelPasteFloodGuard(guard: PanelBurstGuardState, now: number): PanelBurstGuardResult {
-  const lastAt = guard.timestamps.length > 0 ? guard.timestamps[guard.timestamps.length - 1]! : -Infinity;
-  const isQuietGap = now - lastAt > PANEL_PASTE_FLOOD_WINDOW_MS;
-  if (isQuietGap && guard.suspended) {
-    // A silence at least as long as the window means whatever burst was
-    // happening has ended, un-suspend so a LATER burst gets its own fresh
-    // count and its own one-shot hint.
-    guard.suspended = false;
-    guard.hintShown = false;
-  }
-  guard.timestamps = isQuietGap
-    ? [now]
-    : [...guard.timestamps.filter((t) => t > now - PANEL_PASTE_FLOOD_WINDOW_MS), now];
-  if (guard.timestamps.length > PANEL_PASTE_FLOOD_THRESHOLD) {
-    guard.suspended = true;
-  }
-  let showHintNow = false;
-  if (guard.suspended && !guard.hintShown) {
-    guard.hintShown = true;
-    showHintNow = true;
-  }
-  return { dispatch: !guard.suspended, showHintNow };
-}

package/src/panels/base-panel.ts

@@ -1,301 +0,0 @@
-import type { Line } from '@pellux/goodvibes-sdk/platform/types';
-import type { Panel, PanelCategory } from './types.ts';
-import type { ComponentResourceContract, ComponentHealthState } from '../runtime/perf/panel-contracts.ts';
-import type { ComponentHealthMonitor } from '@pellux/goodvibes-sdk/platform/runtime/observability';
-import { UIFactory } from '../renderer/ui-factory.ts';
-import { SPINNER_FRAMES } from '../renderer/ui-primitives.ts';
-import { fitDisplay } from '../utils/terminal-width.ts';
-
-/** Canonical error-surface foreground (bad/red), kept out of the render body. */
-const ERROR_FG = '#ef4444';
-
-/**
- * Frame requester wired by main.ts to the render scheduler. Without it,
- * markDirty() only sets a flag the compositor reads when a frame is ALREADY
- * being composed for another reason (input, streaming), so a live panel
- * (fleet ticks, registry subscriptions) sat visibly stale while the app was
- * idle until the next keypress (a replay finding). The scheduler
- * coalesces same-tick requests, so this stays cheap.
- */
-let panelFrameRequester: (() => void) | null = null;
-
-export function setPanelFrameRequester(requester: (() => void) | null): void {
-  panelFrameRequester = requester;
-}
-
-export abstract class BasePanel implements Panel {
-  public needsRender = true;
-  public isTransient = false;
-  public isPinned = false;
-  protected readonly componentHealthMonitor?: ComponentHealthMonitor;
-
-  // -------------------------------------------------------------------------
-  // Timer registry
-  // -------------------------------------------------------------------------
-
-  /** All timers registered via registerTimer(). Cleared automatically on onDestroy(). */
-  private readonly _timers: Set<ReturnType<typeof setTimeout> | ReturnType<typeof setInterval>> = new Set();
-
-  /**
-   * Register a timer id (from setInterval or setTimeout) so it is
-   * automatically cleared when the panel is destroyed. Returns the id
-   * unchanged so the call can be chained inline:
-   *
-   * ```ts
-   * this.registerTimer(setInterval(() => this.refresh(), 5_000));
-   * ```
-   */
-  protected registerTimer<T extends ReturnType<typeof setTimeout> | ReturnType<typeof setInterval>>(id: T): T {
-    this._timers.add(id);
-    return id;
-  }
-
-  /**
-   * Clear a specific timer and remove it from the registry.
-   * Safe to call with an id that was never registered or already cleared.
-   */
-  protected clearTimer(id: ReturnType<typeof setTimeout> | ReturnType<typeof setInterval>): void {
-    clearInterval(id as ReturnType<typeof setInterval>);
-    this._timers.delete(id);
-  }
-
-  // -------------------------------------------------------------------------
-  // I2: Error surface slot
-  // -------------------------------------------------------------------------
-
-  /**
-   * Last error message to surface in the panel footer.
-   * Auto-cleared on the next keystroke by `ScrollableListPanel.handleInput()` (and any
-   * subclass that calls `super.handleInput()` or manually calls `this.clearError()` at
-   * the start of its handler). BasePanel itself does NOT auto-clear, only subclasses
-   * that opt into the contract do.
-   */
-  protected lastError: string | null = null;
-
-  /**
-   * Set a transient error message. Triggers a re-render.
-   * The error will be auto-cleared on the next keystroke if the panel extends
-   * `ScrollableListPanel` (which calls `clearError()` at the top of `handleInput()`).
-   */
-  protected setError(msg: string): void {
-    this.lastError = msg;
-    this.needsRender = true;
-  }
-
-  /** Clear the current error. */
-  protected clearError(): void {
-    this.lastError = null;
-  }
-
-  /**
-   * Build a single error Line for display above the hints footer.
-   * Returns null when there is no active error.
-   *
-   * Color: bold red foreground (palette-consistent: #ef4444).
-   */
-  protected renderErrorLine(width: number): Line | null {
-    if (!this.lastError) return null;
-    return UIFactory.stringToLine(
-      fitDisplay(` ✕ ${this.lastError}`, width),
-      width,
-      { fg: ERROR_FG, bold: true },
-    );
-  }
-
-  // -------------------------------------------------------------------------
-  // I3: Loading spinner slot
-  // -------------------------------------------------------------------------
-
-  /** Tracks the loading label for the spinner (undefined = no spinner active). */
-  protected loadingState: 'idle' | 'loading' | 'error' = 'idle';
-  private _loadingLabel = '';
-
-  /** Begin loading. Triggers a re-render. */
-  protected startLoading(label = 'Loading...'): void {
-    this.loadingState = 'loading';
-    this._loadingLabel = label;
-    this.needsRender = true;
-  }
-
-  /** End loading (returns to idle). Triggers a re-render. */
-  protected stopLoading(): void {
-    this.loadingState = 'idle';
-    this._loadingLabel = '';
-    this.needsRender = true;
-  }
-
-  /**
-   * Run an async operation with the panel's loading spinner visible.
-   * The spinner is always cleared on completion, whether the operation succeeds or throws
-   * (uses try/finally). Rethrows any error so callers can handle it or forward to setError.
-   *
-   * @param label Optional label shown next to the spinner.
-   * @param fn    The async work to run.
-   *
-   * @example
-   * ```ts
-   * try {
-   *   await this.withLoading('Loading diff…', () => this.fetchDiff());
-   * } catch (err) {
-   *   this.setError(summarizeError(err));
-   * }
-   * ```
-   */
-  protected async withLoading<T>(label: string | undefined, fn: () => Promise<T>): Promise<T> {
-    this.startLoading(label);
-    try {
-      return await fn();
-    } finally {
-      this.stopLoading();
-    }
-  }
-
-  /**
-   * Build a spinner Line for the loading state.
-   * Returns null when loadingState is not 'loading'.
-   *
-   * @param width  Panel width in columns.
-   * @param frame  Current animation frame index (caller increments each render).
-   */
-  protected renderLoadingLine(width: number, frame = 0): Line | null {
-    if (this.loadingState !== 'loading') return null;
-    const idx = (frame || Math.floor(Date.now() / 100)) % SPINNER_FRAMES.length;
-    const spinner = SPINNER_FRAMES[idx] ?? SPINNER_FRAMES[0]!;
-    const text = ` ${spinner} ${this._loadingLabel}`;
-    return UIFactory.stringToLine(fitDisplay(text, width), width, { fg: '135', bold: true });
-  }
-
-  /**
-   * Optional resource contract for this panel.
-   * Override in subclasses to declare a custom contract; leave undefined
-   * to use the category default enforced by ComponentHealthMonitor.
-   */
-  public resourceContract: Readonly<ComponentResourceContract> | undefined = undefined;
-
-  /**
-   * Live health state populated by ComponentHealthMonitor.
-   * Read-only from outside the monitor.
-   */
-  public get healthState(): Readonly<ComponentHealthState> | undefined {
-    return this.componentHealthMonitor?.getHealth(this.id);
-  }
-
-  constructor(
-    public readonly id: string,
-    public readonly name: string,
-    public readonly icon: string,
-    public readonly category: PanelCategory,
-    componentHealthMonitor?: ComponentHealthMonitor,
-  ) {
-    this.componentHealthMonitor = componentHealthMonitor;
-  }
-
-  onActivate(): void { this.needsRender = true; }
-  onDeactivate(): void {}
-
-  /**
-   * Called when the panel is permanently removed. Subclasses should call
-   * `super.onDestroy()` to ensure all registered timers are cleared.
-   */
-  onDestroy(): void {
-    for (const id of this._timers) {
-      clearInterval(id as ReturnType<typeof setInterval>);
-    }
-    this._timers.clear();
-  }
-
-  abstract render(width: number, height: number): Line[];
-
-  /**
-   * Default mouse-wheel handling: translate a wheel delta into the panel's
-   * existing up/down keyboard navigation, so every panel scrolls with the wheel
-   * without bespoke code. Panels with richer scroll state (e.g.
-   * `ScrollableListPanel`) override this. No-op for panels that don't implement
-   * `handleInput`. Returns true if any step was consumed.
-   */
-  public handleScroll(deltaRows: number): boolean {
-    const self = this as unknown as { handleInput?: (key: string) => boolean };
-    if (typeof self.handleInput !== 'function') return false;
-    const rows = Math.trunc(deltaRows);
-    if (rows === 0) return false;
-    const key = rows > 0 ? 'down' : 'up';
-    const steps = Math.min(Math.abs(rows), 10); // clamp runaway wheel deltas
-    let consumed = false;
-    for (let i = 0; i < steps; i++) {
-      if (self.handleInput(key)) consumed = true;
-    }
-    return consumed;
-  }
-
-  /** Mark this panel dirty, it will be re-rendered on the next compositor frame. */
-  public invalidate(): void { this.needsRender = true; }
-
-  /** Called by the compositor after a successful render to clear the dirty flag. */
-  public markRendered(): void { this.needsRender = false; }
-
-  protected markDirty(): void {
-    // Request only on the false→true transition: a pending frame already
-    // covers repeat marks, and a panel that dirties itself mid-render must
-    // not schedule frames forever.
-    const wasDirty = this.needsRender;
-    this.needsRender = true;
-    if (!wasDirty) panelFrameRequester?.();
-  }
-
-  /**
-   * Check whether the panel is currently permitted to render.
-   *
-   * Consults the shared ComponentHealthMonitor. Returns true if not registered
-   * (unthrottled) or if the monitor permits a render at this moment.
-   *
-   * Call this inside render() or before invoking render() to skip
-   * expensive work when throttled:
-   *
-   * ```ts
-   * render(width, height): Line[] {
-   *   if (!this.canRenderNow()) return this._lastLines ?? [];
-   *   // ... expensive render ...
-   * }
-   * ```
-   */
-  protected canRenderNow(now: number = Date.now()): boolean {
-    return this.componentHealthMonitor?.canRender(this.id, now) ?? true;
-  }
-
-  /**
-   * Report the duration of a completed render to the health monitor.
-   * Call this at the end of render() after measuring wall-clock cost.
-   */
-  protected reportRenderDuration(durationMs: number, now: number = Date.now()): void {
-    this.componentHealthMonitor?.recordRender(this.id, durationMs, now);
-  }
-
-  /** Cache of the most recent lines produced by trackedRender. */
-  private _lastTrackedLines: Line[] = [];
-
-  /**
-   * Wrap a render body with canRenderNow throttle check, wall-clock timing,
-   * and automatic reportRenderDuration.
-   *
-   * When throttled, returns the previously cached lines (stale but correctly
-   * sized) rather than empty lines, avoiding a flicker on every skipped frame.
-   *
-   * Usage:
-   * ```ts
-   * render(width: number, height: number): Line[] {
-   *   return this.trackedRender(() => {
-   *     // expensive render logic
-   *     return lines;
-   *   });
-   * }
-   * ```
-   */
-  protected trackedRender(fn: () => Line[]): Line[] {
-    if (!this.canRenderNow()) return this._lastTrackedLines;
-    const start = Date.now();
-    const lines = fn();
-    this.reportRenderDuration(Date.now() - start);
-    this._lastTrackedLines = lines;
-    return lines;
-  }
-}

package/src/panels/builtin/agent.ts

@@ -1,27 +0,0 @@
-import type { PanelManager } from '../panel-manager.ts';
-import type { ResolvedBuiltinPanelDeps } from './shared.ts';
-
-// (the purge): thinking, tools, inspector, and wrfc were registered here
-// before the purge. thinking/tools were DELETE-disposition (no surviving
-// human surface, thinking already renders inline in the transcript, tool
-// results render inline plus per-node in Fleet); inspector/wrfc were
-// RETIRE-INTO-FLEET (their live console is subsumed by the Fleet panel,
-// operations.ts:84). See registerOperationsPanels for the fleet
-// registration and .goodvibes/audit/2026-07-04-wave6-briefs.json for
-// the full disposition map.
-export function registerAgentPanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
-  // Compat: '/panel open agent-logs' and 'inspector' (and any saved
-  // layout/muscle memory) still resolve, redirected straight to fleet.
-  // Repointed from agent-logs->inspector now that inspector itself
-  // is retired; alias resolution is a single hop (PanelManager._resolveId),
-  // so this must point at the real surviving id, not at another alias.
-  manager.registerAlias('agent-logs', 'fleet');
-  manager.registerAlias('inspector', 'fleet');
-  manager.registerAlias('wrfc', 'fleet');
-
-  // (the purge), group B: 'work-plan' and 'project-planning'
-  // migrated to the 'work-plan-modal' / 'planning-modal' config-modal surfaces.
-  // Their surfaces AND panel→modal redirects are registered centrally in
-  // registerBuiltinModals (builtin-modals.ts). Panel registrations retired here.
-  void deps;
-}

package/src/panels/builtin/development.ts

@@ -1,92 +0,0 @@
-import type { PanelManager } from '../panel-manager.ts';
-import { GitPanel } from '../git-panel.ts';
-import { DiffPanel } from '../diff-panel.ts';
-import { DiffReviewPanel } from '../diff-review-panel.ts';
-import { CostTrackerPanel } from '../cost-tracker-panel.ts';
-import type { ResolvedBuiltinPanelDeps } from './shared.ts';
-import { requireUiServices, withUnconfiguredFallback } from './shared.ts';
-
-// (the purge): plan, intelligence, explorer, preview, and symbols were
-// registered here before the purge. plan was RETIRE-INTO-FLEET (its
-// execution-plan view is subsumed by Fleet, operations.ts:84); the other
-// four were DELETE-disposition (no surviving human surface, intelligence's
-// read-model still backs the surviving `/intelligence` CLI subcommands, see
-// intelligence-runtime.ts; explorer/preview/symbols had no dedicated
-// read-model to preserve). See .goodvibes/audit/2026-07-04-wave6-briefs.json
-// for the full disposition map.
-export function registerDevelopmentPanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
-  manager.registerType({
-    id: 'git',
-    name: 'Git',
-    icon: 'G',
-    category: 'development',
-    description: 'Git status, staged/unstaged changes, and recent commits',
-    // sessionChangeTracker is optional: when a caller wires it into
-    // BuiltinPanelDeps, the Git panel highlights files touched this session.
-    factory: () => new GitPanel(
-      requireUiServices(deps).environment.workingDirectory,
-      deps.requestRender,
-      deps.sessionChangeTracker ? () => deps.sessionChangeTracker!.getChangedFiles() : undefined,
-    ),
-  });
-
-  // Compat: '/panel open plan' (and any saved layout/muscle memory) still
-  // resolves, redirected to fleet, which absorbs the execution-plan view.
-  manager.registerAlias('plan', 'fleet');
-
-  manager.registerType({
-    id: 'diff',
-    name: 'Diff',
-    icon: 'D',
-    category: 'development',
-    description: 'Unified diff view of agent file changes',
-    factory: () => new DiffPanel(requireUiServices(deps).environment.workingDirectory, deps.requestRender),
-  });
-
-  manager.registerType({
-    id: 'review',
-    name: 'Review',
-    icon: 'R',
-    category: 'development',
-    description: 'Comment on session diff hunks and steer the comments to the model',
-    factory: () => new DiffReviewPanel(
-      requireUiServices(deps).environment.workingDirectory,
-      deps.requestRender,
-      deps.sessionChangeTracker ? () => deps.sessionChangeTracker!.getChangedFiles() : undefined,
-    ),
-  });
-
-  // 'inspector' registration moved to builtin/agent.ts (category
-  // 'agent'), it now absorbs the merged agent-logs capabilities.
-
-  // always registered (was gated behind `if (deps.getOrchestratorUsage)`,
-  // so `/panel open cost` reported "Unknown panel" on builds without usage
-  // tracking wired). Falls back to a "dependency not configured" empty state.
-  {
-    const { getOrchestratorUsage, budgetThreshold } = deps;
-    manager.registerType({
-      id: 'cost',
-      name: 'Cost',
-      icon: '$',
-      category: 'providers',
-      description: 'Estimated costs per session, agent, and plan with budget alerts',
-      factory: withUnconfiguredFallback(
-        getOrchestratorUsage !== undefined,
-        'cost', 'Cost', '$', 'providers',
-        ' Cost tracking not configured for this session.',
-        'This runtime was not wired with orchestrator usage tracking at bootstrap, so no cost data is available.',
-        () => {
-          const ui = requireUiServices(deps);
-          return new CostTrackerPanel(ui.events.turns, ui.events.agents, getOrchestratorUsage!, {
-            budgetThreshold,
-            getAgentStatus: (id) => ui.agents.agentManager.getStatus(id),
-            configAccess: {
-              get: (key) => deps.configManager.get(key as Parameters<typeof deps.configManager.get>[0]),
-              set: (key, value) => deps.configManager.set(key as Parameters<typeof deps.configManager.set>[0], value as never),
-            },
-          });
-        },
-      ),
-    });
-  }
-}

package/src/panels/builtin/knowledge.ts

@@ -1,12 +0,0 @@
-import type { PanelManager } from '../panel-manager.ts';
-import type { ResolvedBuiltinPanelDeps } from './shared.ts';
-
-// (the purge), group B: 'knowledge' and 'memory' migrated to the
-// 'knowledge-modal' / 'memory-modal' config-modal surfaces. Both surfaces and
-// their panel→modal redirects are registered centrally in registerBuiltinModals
-// (src/panels/builtin-modals.ts). This registrar is intentionally empty
-// post-migration, kept as a stable call site invoked from registerBuiltinPanels.
-export function registerKnowledgePanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
-  void manager;
-  void deps;
-}