@pellux/goodvibes-tui 1.7.0 → 1.9.1

package/src/panels/fleet-panel.ts

@@ -4,23 +4,17 @@
 // W2.2 — FleetPanel: the live unified observability tree. Renders the
 // registered process fleet (agents incl. WRFC roles, WRFC chains/subtasks,
 // workflow-tool FSMs, watchers, background processes) as a depth-first tree
-// with a selected-row detail region.
-//
-// Wave-3 (W3.1 Part C) adds session tabs: Enter on an attachable node (agent
-// or wrfc-chain) opens a tab showing that process's transcript (agent) or
-// live member summary (chain); the tree itself is the always-present root
-// tab. See fleet-tabs.ts for the tab-state model and fleet-transcript.ts for
-// tab content rendering — this file owns input dispatch and layout only.
-//
-// Coexists with (does not replace) the process modal, ops, wrfc, and
-// inspector entry points this wave — only the footer process indicator's
-// [Enter] is repointed to open this panel (see handler-feed-routes.ts).
-// Removal of the older entry points is Wave 6.
+// with a selected-row detail region. Session tabs (W3.1 Part C): Enter on an
+// attachable node (agent/wrfc-chain) opens a tab with that process's
+// transcript/member summary — see fleet-tabs.ts + fleet-transcript.ts. This
+// file owns input dispatch and layout; fleet-deep-link.ts owns the
+// cross-panel jump target (DEBT-5 item 4).
 // ---------------------------------------------------------------------------
 
 import { readFile } from 'node:fs/promises';
 import type { Line } from '../types/grid.ts';
 import type { ProcessCostState, ProcessUsage, SteerResult } from '@pellux/goodvibes-sdk/platform/runtime/fleet';
+import { formatWorkItemIsolationDetailFromRaw } from './fleet-panel-worktree-detail.ts';
 import type { ConversationMessageSnapshot } from '@pellux/goodvibes-sdk/platform/core';
 import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
 import { ScrollableListPanel } from './scrollable-list-panel.ts';
@@ -52,62 +46,15 @@ import {
   type FleetTabsState,
   type SteerBadge,
 } from './fleet-tabs.ts';
-import { reconcileSteerBadges as reconcileSteerBadgesPure, steerBadgeGlyph, steerBadgeTone } from './fleet-steer.ts';
-import { FleetStopTracker, fleetStateDisplay, toggleFleetPause, buildFleetTreeHints } from './fleet-stop.ts';
+import { liveSteerableLabels, reconcileSteerBadges as reconcileSteerBadgesPure, renderSteerBadgeLine, steerBadgeGlyph, steerBadgeTone, steerRefusalMessage } from './fleet-steer.ts';
+import { FleetStopTracker, fleetStateDisplay, toggleFleetPause, buildFleetTreeHints, countDescendantStats } from './fleet-stop.ts';
+import { resolveFleetDeepLinkIndex } from './fleet-deep-link.ts';
 import { parseAgentLedger, renderFleetAgentTranscript, renderFleetChainSummary, renderFleetLedgerFallback, renderFleetTranscriptLoading } from './fleet-transcript.ts';
 import { renderFleetTabStrip } from '../renderer/fleet-tab-strip.ts';
+import { planColumns, toneColor, formatFleetTokens, formatFleetCost } from './fleet-panel-format.ts';
 
 const C = DEFAULT_PANEL_PALETTE;
 
-// Column widths for the tree row layout. `label` absorbs whatever width is
-// left over after the fixed columns + gaps; on hostile (narrow) widths the
-// trailing columns simply clip (buildAlignedRow/buildSelectablePanelLine stop
-// writing once a cell would overflow the row) rather than throwing or
-// wrapping — the tree stays readable, just denser.
-const KIND_W = 8;
-const ELAPSED_W = 7;
-const TOKENS_W = 7;
-const COST_W = 8;
-const ACTIVITY_W = 20;
-const GAP = 1;
-const FIXED_W = 1 /* glyph */ + KIND_W + ELAPSED_W + TOKENS_W + COST_W + ACTIVITY_W + GAP * 6;
-
-function planColumns(width: number): ColumnSpec[] {
-  const labelWidth = Math.max(10, width - FIXED_W);
-  return [
-    { width: 1 },
-    { width: KIND_W },
-    { width: labelWidth },
-    { width: ELAPSED_W, align: 'right' },
-    { width: TOKENS_W, align: 'right' },
-    { width: COST_W, align: 'right' },
-    { width: ACTIVITY_W },
-  ];
-}
-
-function toneColor(tone: FleetStateTone, palette: PanelPalette): string {
-  switch (tone) {
-    case 'active': return palette.info ?? DEFAULT_PANEL_PALETTE.info;
-    case 'success': return palette.good ?? DEFAULT_PANEL_PALETTE.good;
-    case 'failure': return palette.bad ?? DEFAULT_PANEL_PALETTE.bad;
-    case 'warn': return palette.warn ?? DEFAULT_PANEL_PALETTE.warn;
-    case 'muted': return palette.dim;
-  }
-}
-
-function formatFleetTokens(usage: ProcessUsage | undefined): string {
-  const total = fleetUsageTokens(usage);
-  if (total === null) return 'n/a';
-  return total >= 1000 ? `${(total / 1000).toFixed(1)}k` : String(total);
-}
-
-/** Honest cost display: never a fabricated $0.00 — 'unpriced' when costState says so. */
-function formatFleetCost(costUsd: number | null | undefined, costState: ProcessCostState): string {
-  if (!hasFleetCost(costUsd, costState)) return 'unpriced';
-  const formatted = formatAgentCost(costUsd as number);
-  return costState === 'estimated' ? `~${formatted}` : formatted;
-}
-
 export interface FleetActionCallbacks {
   /** Graceful interruption (AgentManager.cancel / trigger-schedule disable, via the registry). */
   readonly interrupt: (id: string) => boolean;
@@ -286,15 +233,11 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
   }
 
   /**
-   * W3.3 (cross-restart honesty) — investigation confirmed there is no
-   * bridge from a prior TUI process's in-memory registry (or the daemon's
-   * separate one) into this one: a restart always starts from an empty
-   * `AgentManager` Map, so a completed process from a previous session can
-   * never reappear as a tree row here, no matter how recently it ran. That
-   * is a real, permanent limitation (not a bug to fix in this item — see the
-   * W3.3 brief's design point 5), so it is documented plainly here rather
-   * than silently leaving the empty tree looking like "nothing has ever run"
-   * or, worse, implying a restart would bring prior processes back.
+   * W3.3 (cross-restart honesty): a restart always starts from an empty
+   * `AgentManager` Map (no bridge from a prior TUI/daemon registry), so a
+   * completed process from a previous session can never reappear here — a
+   * real, permanent limitation (W3.3 brief point 5), documented rather than
+   * silently implying "nothing has ever run" or that a restart brings it back.
    */
   protected override getEmptyStateActions(): Array<{ command: string; summary: string }> {
     return [
@@ -361,6 +304,18 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
     return this.getItems().find((row) => row.node.id === nodeId)?.node ?? null;
   }
 
+  /** DEBT-5 item 4 (see fleet-deep-link.ts). */
+  public receiveDeepLink(target: { readonly id: string; readonly kind?: string }): void {
+    const idx = resolveFleetDeepLinkIndex(this.getItems(), target);
+    if (idx < 0) { this.setError('node no longer present.'); return; }
+    // A successful reveal must be VISIBLE: with a session tab active, render()
+    // routes to the tab view and the selection change would be silently
+    // swallowed (batch refutation finding 1) — return to the tree first
+    // (tabs kept; only the active view switches).
+    this.tabsState = { tabs: this.tabsState.tabs, activeTabIndex: 0 };
+    this.clearError(); this.selectedIndex = idx; this.selectedNodeId = target.id; this.markDirty();
+  }
+
   /**
    * Wave-3 (W3.2, risk #2 — "dropped inference"): called on every read-model
    * snapshot update and on the panel's 1s tick. See fleet-steer.ts's
@@ -373,31 +328,6 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
     if (changed) this.markDirty();
   }
 
-  /** Count of descendants of `nodeId` (in the current snapshot) that report `capabilities.killable` — the Wave-3 K-confirm child count (Part C7). */
-  private countKillableDescendants(nodeId: string): number {
-    const rows = this.getItems();
-    const byParent = new Map<string, string[]>();
-    for (const row of rows) {
-      if (!row.node.parentId) continue;
-      const siblings = byParent.get(row.node.parentId) ?? [];
-      siblings.push(row.node.id);
-      byParent.set(row.node.parentId, siblings);
-    }
-    const byId = new Map(rows.map((row) => [row.node.id, row] as const));
-    let count = 0;
-    const stack = [...(byParent.get(nodeId) ?? [])];
-    const seen = new Set<string>();
-    while (stack.length > 0) {
-      const id = stack.pop()!;
-      if (seen.has(id)) continue;
-      seen.add(id);
-      const row = byId.get(id);
-      if (row?.node.capabilities.killable) count++;
-      for (const child of byParent.get(id) ?? []) stack.push(child);
-    }
-    return count;
-  }
-
   /** Kick off (once) the async ledger-fallback load for a tab whose conversation snapshot is unavailable. */
   private ensureLedgerLoaded(tab: FleetTab): void {
     if (tab.ledgerLoadStarted) return;
@@ -479,8 +409,8 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
       }
       const node = selected.node;
       const shortId = node.id.length > 8 ? node.id.slice(-8) : node.id;
-      const childCount = this.countKillableDescendants(node.id);
-      const suffix = childCount > 0 ? ` (+${childCount} child${childCount === 1 ? '' : 'ren'})` : '';
+      const stats = countDescendantStats(this.getItems(), node.id);
+      const suffix = stats.total > 0 ? ` (+${stats.total} descendant${stats.total === 1 ? '' : 's'}, ${stats.active} active)` : '';
       this.confirmOverlay.arm({
         id: node.id,
         label: `${node.kind} ${shortId}${suffix}`,
@@ -527,6 +457,28 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
       return true;
     }
 
+    if (key === 's') {
+      // Batch replay D4: 's' from the TREE was silently dead — steering
+      // required an undiscoverable Enter-attach first. Attach-and-steer in
+      // one press for a steerable node; honest refusal otherwise.
+      if (!selected) return false;
+      const node = selected.node;
+      // Closure replay note: a node that FINISHED in the hint→keypress race
+      // window must say so — "does not support steer" is misleading for an
+      // agent whose only problem is being done.
+      if (isTerminalProcessState(node.state)) {
+        this.setError(`${node.kind} already finished — nothing to steer.`);
+        return true;
+      }
+      if (!node.capabilities.steerable || !isAttachableFleetKind(node.kind)) {
+        this.setError(`${node.kind} does not support steer.`);
+        return true;
+      }
+      this.tabsState = attachFleetTab(this.tabsState, node);
+      this.markDirty();
+      return this.tryOpenSteerDraft(activeFleetTab(this.tabsState)!);
+    }
+
     const consumed = super.handleInput(key);
     if (consumed) this.captureSelectionAnchor();
     return consumed;
@@ -539,8 +491,12 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
    */
   private tryOpenSteerDraft(tab: FleetTab): boolean {
     const node = this.findLiveNode(tab.nodeId);
-    if (!node || isTerminalProcessState(node.state) || !node.capabilities.steerable) {
-      this.setError(`${node?.kind ?? tab.kind} does not support steering.`);
+    if (!node || isTerminalProcessState(node.state)) {
+      this.setError(`${node?.kind ?? tab.kind} already finished — nothing to steer.`);
+      return true;
+    }
+    if (!node.capabilities.steerable) {
+      this.setError(`${node.kind} does not support steering.`);
       return true;
     }
     tab.steerDraft = '';
@@ -557,8 +513,15 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
     }
     if (isPanelSearchCommit(key)) {
       const text = (tab.steerDraft ?? '').trim();
-      tab.steerDraft = null;
-      if (text.length > 0) this.submitSteer(tab, text);
+      if (text.length === 0) {
+        tab.steerDraft = null;
+        this.markDirty();
+        return true;
+      }
+      // Clear the draft ONLY on a confirmed queue. A refusal keeps the composer
+      // open with the text intact (submitSteer explains why + suggests live targets)
+      // so the operator never loses what they typed to a just-idle agent.
+      if (this.submitSteer(tab, text)) tab.steerDraft = null;
       this.markDirty();
       return true;
     }
@@ -580,16 +543,25 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
     return true; // absorb every other key while composing
   }
 
-  /** Submit a composed steer message: queued -> badge; refused -> honest inline error (setError), same convention as the i/K "not supported" messages. */
-  private submitSteer(tab: FleetTab, text: string): void {
+  /**
+   * Submit a composed steer message. Returns whether it was queued so the caller
+   * clears the draft only on a confirmed send (WO UX-A item 4): a refusal (target
+   * went idle while composing) PRESERVES the typed text and suggests which agents
+   * ARE steerable, instead of silently discarding the draft. On a successful queue
+   * the ⧗ badge line is the immediate honest acknowledgment.
+   */
+  private submitSteer(tab: FleetTab, text: string): boolean {
     const result = this.actions.steer(tab.nodeId, text);
     if (result.queued) {
       // queuedAt drives reconcileSteerBadges' TTL-expiry fallback (fleet-steer.ts).
       tab.steerBadge = { messageId: result.messageId, status: 'queued', queuedAt: Date.now() };
-    } else {
-      this.setError(result.reason);
+      this.markDirty();
+      return true;
     }
+    const siblings = liveSteerableLabels(this.readModel.getSnapshot().rows.map((row) => row.node), tab.nodeId);
+    this.setError(steerRefusalMessage(result.reason, siblings));
     this.markDirty();
+    return false;
   }
 
   protected renderItem(row: FleetTreeRow, _index: number, _selected: boolean, width: number): Line {
@@ -662,12 +634,10 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
       [' activity ', C.label],
       [truncateDisplay(activityText, Math.max(0, width - 11)), C.dim],
     ]);
-    // Wave 3 hook: approval history attaches here once session tabs land.
-    const line4 = buildPanelLine(width, [
-      [' approvals ', C.label],
-      ['(Wave 3)', C.dim],
-    ]);
-    return [line1, line2, line3, line4];
+    // Approval history attaches here once session tabs land.
+    const line4 = buildPanelLine(width, [[' approvals ', C.label], ['—', C.dim]]);
+    const isolationDetail = node.kind === 'work-item' ? formatWorkItemIsolationDetailFromRaw(node.raw) : null;
+    return [line1, line2, line3, line4, ...(isolationDetail ? [buildPanelLine(width, [[' isolation ', C.label], [isolationDetail, C.dim]])] : [])];
   }
 
   /** Renders the active session tab's content (transcript / chain summary / ledger fallback) in place of the tree. */
@@ -706,8 +676,12 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
         palette,
         { active: true, bg: palette.inputBg, valueColor: palette.info },
       ));
-    } else if (tab.steerBadge) {
-      composerLines.push(this.renderSteerBadgeLine(tab.steerBadge, width, palette));
+    } else if (tab.steerBadge && !this.stopTracker.isStopping(tab.nodeId)) {
+      // A queued-steer promise ("delivers on its next turn") must not render
+      // while a stop is in flight for this node — there may be no next turn
+      // (refutation finding 4). The badge reconciles to dropped/consumed once
+      // the node's terminal state lands.
+      composerLines.push(renderSteerBadgeLine(tab.steerBadge, width, palette, liveNode?.label));
     }
 
     const footerLines = [
@@ -749,22 +723,6 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
     return buildPanelWorkspace(width, height, { title: `Fleet — ${tab.label}`, sections, footerLines, palette });
   }
 
-  /** One-line honest status for the active tab's steer badge (queued/consumed/dropped) — see fleet-tabs.ts's SteerBadgeStatus doc. */
-  private renderSteerBadgeLine(badge: SteerBadge, width: number, palette: PanelPalette): Line {
-    const glyph = steerBadgeGlyph(badge.status);
-    const tone = steerBadgeTone(badge.status, palette);
-    const label = badge.status === 'queued'
-      ? 'steer queued — awaiting the agent\'s next turn'
-      : badge.status === 'consumed'
-        ? 'steer consumed'
-        : `steer dropped — ${badge.note ?? 'the target ended before delivery'}`;
-    return buildPanelLine(width, [
-      [' ', palette.dim],
-      [glyph, tone],
-      [` ${label}`, palette.dim],
-    ]);
-  }
-
   private renderTreeView(width: number, height: number): Line[] {
     const selected = this.getSelectedItem();
     const footer: Line[] = [];

package/src/panels/fleet-read-model.ts

@@ -71,6 +71,15 @@ export interface FleetSnapshot {
 
 export type FleetStateTone = 'active' | 'success' | 'failure' | 'warn' | 'muted';
 
+// W6-P1 ruling: this is a DIFFERENT table from the SDK presentation
+// contract's STATE_GLYPHS (@pellux/goodvibes-sdk/platform/presentation) — that
+// one is a 4-state semantic alias (good/warn/bad/info) shared by the TUI and
+// agent renderers; this one is a 12-state ProcessNode taxonomy specific to the
+// Fleet tree panel (thinking/executing-tool/awaiting-approval/streaming/
+// stalled/retrying/done/failed/killed/interrupted/idle/queued/paused), and no
+// other surface (checked: the agent has no fleet-panel renderer) consumes it
+// today. Per the presentation-parity brief, a table only moves to the SDK
+// contract when 2+ surfaces need it — this one stays TUI-renderer-local.
 const STATE_GLYPHS: Record<ProcessState, string> = {
   thinking: '◔',
   'executing-tool': '●',
@@ -374,6 +383,40 @@ export function buildFleetSnapshot(nodes: readonly ProcessNode[], capturedAt: nu
   return { rows, totalCost, totalTokens, runningCount, capturedAt };
 }
 
+/**
+ * The fleet's honest leaf cost total — the SAME figure as
+ * FleetSnapshot.totalCost, but computed in one pass WITHOUT building the display
+ * rows, for cheap per-frame use (the always-visible footer). Excludes rollup
+ * aggregates (chain/subtask/workstream/phase) AND the WRFC owner (its usage is a
+ * mixed-model rollup of its children), so it is a true leaf-sum with no
+ * double-count. Null when nothing priced. Add this to the main session cost for
+ * the true "you + fleet" total.
+ */
+export function fleetLeafCostTotal(nodes: readonly ProcessNode[]): number | null {
+  let total: number | null = null;
+  for (const node of nodes) {
+    if (isFleetAggregateRollupNode(node)) continue;
+    if (!hasFleetCost(node.costUsd, node.costState)) continue;
+    total = (total ?? 0) + (node.costUsd as number);
+  }
+  return total;
+}
+
+/**
+ * The fleet cost figure for the always-visible footer: fleetLeafCostTotal over a
+ * fresh registry query, but ONLY while a fleet is live — the idle single-session
+ * path must never pay the aggregate-on-read query() scan. Query failures degrade to
+ * null (honest "no fleet cost"), never a throw into the render loop.
+ */
+export function footerFleetCost(queryNodes: () => readonly ProcessNode[], hasLiveFleet: boolean): number | null {
+  if (!hasLiveFleet) return null;
+  try {
+    return fleetLeafCostTotal(queryNodes());
+  } catch {
+    return null;
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Read-model — two-factory shape (live / static), mirrors cockpit-read-model.ts
 // ---------------------------------------------------------------------------

package/src/panels/fleet-steer.ts

@@ -11,8 +11,9 @@
 
 import { STEER_TTL_MS, type ProcessNode } from '@pellux/goodvibes-sdk/platform/runtime/fleet';
 import { isTerminalProcessState } from './fleet-read-model.ts';
-import type { FleetTab, SteerBadgeStatus } from './fleet-tabs.ts';
-import { DEFAULT_PANEL_PALETTE, type PanelPalette } from './polish.ts';
+import type { FleetTab, SteerBadge, SteerBadgeStatus } from './fleet-tabs.ts';
+import { buildPanelLine, DEFAULT_PANEL_PALETTE, type PanelPalette } from './polish.ts';
+import type { Line } from '../types/grid.ts';
 
 /** Linger before an auto-resolved (consumed/dropped) steer badge is cleared from the tab. */
 export const STEER_BADGE_LINGER_MS = 4_000;
@@ -33,6 +34,38 @@ export function steerBadgeTone(status: SteerBadgeStatus, palette: PanelPalette):
   }
 }
 
+/** Labels of the currently live, steerable agent nodes other than `excludeNodeId` — offered when a steer target has gone inactive (WO UX-A item 4). */
+export function liveSteerableLabels(nodes: readonly ProcessNode[], excludeNodeId: string): string[] {
+  return nodes
+    .filter((node) => node.id !== excludeNodeId && node.kind === 'agent' && node.capabilities.steerable && !isTerminalProcessState(node.state))
+    .map((node) => node.label);
+}
+
+/** Refusal message for a steer that could not be queued: states why + preserves the draft + suggests live targets. */
+export function steerRefusalMessage(reason: string, siblingLabels: readonly string[]): string {
+  const suggestion = siblingLabels.length > 0
+    ? ` Draft kept — steerable now: ${siblingLabels.slice(0, 3).join(', ')}${siblingLabels.length > 3 ? '…' : ''}.`
+    : ' Draft kept — no other agents are currently steerable.';
+  return `${reason}.${suggestion}`;
+}
+
+/** One-line honest status for a tab's steer badge; the queued line names the target and points at the ⧗ delivery badge (WO UX-A item 4). */
+export function renderSteerBadgeLine(badge: SteerBadge, width: number, palette: PanelPalette, targetLabel?: string): Line {
+  const glyph = steerBadgeGlyph(badge.status);
+  const tone = steerBadgeTone(badge.status, palette);
+  const forTarget = targetLabel ? ` for ${targetLabel}` : '';
+  const label = badge.status === 'queued'
+    ? `steer queued${forTarget} — delivers on its next turn (watch the ${glyph} badge)`
+    : badge.status === 'consumed'
+      ? 'steer consumed'
+      : `steer dropped — ${badge.note ?? 'the target ended before delivery'}`;
+  return buildPanelLine(width, [
+    [' ', palette.dim],
+    [glyph, tone],
+    [` ${label}`, palette.dim],
+  ]);
+}
+
 /**
  * Wave-3 (W3.2, risk #2 — "dropped inference"): the SDK emits no
  * cancelled/expired signal for a queued steer, so a badge left `queued`

package/src/panels/fleet-stop.ts

@@ -8,7 +8,7 @@
 // ---------------------------------------------------------------------------
 
 import type { ProcessNode, ProcessState } from '@pellux/goodvibes-sdk/platform/runtime/fleet';
-import { fleetStateGlyph, fleetStateTone, isTerminalProcessState, type FleetStateTone } from './fleet-read-model.ts';
+import { fleetStateGlyph, fleetStateTone, isTerminalProcessState, type FleetStateTone, type FleetTreeRow } from './fleet-read-model.ts';
 
 /** How long 'stopping…' lingers after a stop keypress before the true state is shown regardless (never masks a stuck kill). */
 export const STOP_SETTLE_MS = 1500;
@@ -115,6 +115,7 @@ export function buildFleetTreeHints(
     { keys: 'j/k', label: 'navigate' },
     { keys: 'Enter', label: 'attach' },
   ];
+  if (live && selected.capabilities.steerable) hints.push({ keys: 's', label: 'steer' }); // D4: discoverable from the tree (attach-and-steer)
   if (live && selected.capabilities.interruptible) hints.push({ keys: 'i', label: 'interrupt' });
   if (live && selected.capabilities.killable) hints.push({ keys: 'K', label: 'kill' });
   if (live && !isPaused && selected.capabilities.pausable) hints.push({ keys: 'p', label: 'pause' });
@@ -123,3 +124,30 @@ export function buildFleetTreeHints(
   if (hasTabs) hints.push({ keys: '[ ]', label: 'tabs' });
   return hints;
 }
+
+/** K-confirm descendant stats (UX-C item 6): total = every non-terminal descendant (what a cascade kill takes down); active = the individually-killable subset. Was "active only" (Wave-3 C7), undercounting a mixed subtree. */
+export function countDescendantStats(rows: readonly FleetTreeRow[], nodeId: string): { total: number; active: number } {
+  const byParent = new Map<string, string[]>();
+  for (const row of rows) {
+    if (!row.node.parentId) continue;
+    const siblings = byParent.get(row.node.parentId) ?? [];
+    siblings.push(row.node.id);
+    byParent.set(row.node.parentId, siblings);
+  }
+  const byId = new Map(rows.map((row) => [row.node.id, row] as const));
+  let total = 0, active = 0;
+  const stack = [...(byParent.get(nodeId) ?? [])];
+  const seen = new Set<string>();
+  while (stack.length > 0) {
+    const id = stack.pop()!;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const row = byId.get(id);
+    if (row && !isTerminalProcessState(row.node.state)) {
+      total++;
+      if (row.node.capabilities.killable) active++;
+    }
+    for (const child of byParent.get(id) ?? []) stack.push(child);
+  }
+  return { total, active };
+}

package/src/panels/modals/keybindings-modal.ts

@@ -111,7 +111,22 @@ class KeybindingsModalSurface implements ConfigModalSurface {
   onAction(id: string, ctx: ConfigModalActionContext): void {
     if (id === 'refresh') { ctx.setStatus('Docs & shortcuts are read live.'); ctx.requestRender(); return; }
     if (id !== 'activate') return;
-    if (ctx.tabId === 'tools') { void ctx.executeCommand?.('panel', ['open', 'fleet']); ctx.setStatus('Opened the tool inspector (fleet).'); return; }
+    if (ctx.tabId === 'tools') {
+      // DEBT-5 item 4: pass the tool name through as a deep-link target.
+      // Honest caveat (documented, not a bug to silently paper over): fleet's
+      // ProcessKind set has no 'tool' node — a docs Tools row names a static
+      // tool DEFINITION, not a live process, so FleetPanel.receiveDeepLink
+      // will not currently find a match and shows its honest "node no longer
+      // present" line. The plumbing is still worth wiring now (matches the
+      // work-plan agent/wrfc jumps' shape) — it starts resolving for free the
+      // day fleet grows a per-tool-call node (the retired DocsPanel's own
+      // comment already anticipated this: "no filter-by-tool equivalent
+      // there yet").
+      const toolName = ctx.row?.id.startsWith('tool:') ? ctx.row.id.slice('tool:'.length) : null;
+      void ctx.executeCommand?.('panel', toolName ? ['open', 'fleet', '--target', `${toolName}:tool`] : ['open', 'fleet']);
+      ctx.setStatus('Opened the tool inspector (fleet).');
+      return;
+    }
     if (ctx.tabId === 'models') {
       const key = ctx.row?.id.startsWith('model:') ? ctx.row.id.slice('model:'.length) : null;
       if (!key) return;

package/src/panels/modals/modal-theme.ts

@@ -1,36 +1,42 @@
-import { resolveUiTones } from '../../renderer/theme.ts';
+import { activeUiTones, registerThemeRefresh } from '../../renderer/theme.ts';
 
 // ---------------------------------------------------------------------------
 // Semantic tone tokens for the W6.1 group-B config modals.
 //
-// Derived entirely from the chrome token set (resolveUiTones) so the builders
-// carry NO raw hex color literals (architecture: no-raw-hex-literal-growth).
-// Mode is fixed to 'dark' — the single read path the whole renderer uses until
-// the terminal-bg-probe lands (see renderer/modal-factory.ts, which resolves
-// the same way).
+// Derived entirely from the chrome token set so the builders carry NO raw hex
+// color literals (architecture: no-raw-hex-literal-growth). Rebuilt IN PLACE
+// on theme flips via registerThemeRefresh — the group-B surfaces read
+// MODAL_TONES by reference at render time, so a dark-pinned module const here
+// left them rendering dark accents on light chrome (batch refutation
+// finding 2). Mirrors the polish-core/overlay-box/modal-factory pattern.
 // ---------------------------------------------------------------------------
 
-const T = resolveUiTones('dark');
+function buildModalTones() {
+  const T = activeUiTones();
+  return {
+    /** Informational / accent (blue). */
+    info: T.state.info,
+    /** Positive / healthy (green). */
+    good: T.state.good,
+    /** Caution (amber). */
+    warn: T.state.warn,
+    /** Error / danger (red). */
+    bad: T.state.bad,
+    /** Reasoning / secondary accent (purple). */
+    reasoning: T.state.reasoning,
+    /** Muted secondary text. */
+    muted: T.fg.muted,
+    /** Dim tertiary text. */
+    dim: T.fg.dim,
+    /** Primary text. */
+    primary: T.fg.primary,
+    /** QR module foreground — high-contrast, mode-appropriate. */
+    qrDark: T.fg.inverse,
+    /** QR field background — high-contrast, mode-appropriate. */
+    qrLight: T.fg.primary,
+  };
+}
 
-export const MODAL_TONES = {
-  /** Informational / accent (blue). */
-  info: T.state.info,
-  /** Positive / healthy (green). */
-  good: T.state.good,
-  /** Caution (amber). */
-  warn: T.state.warn,
-  /** Error / danger (red). */
-  bad: T.state.bad,
-  /** Reasoning / secondary accent (purple). */
-  reasoning: T.state.reasoning,
-  /** Muted secondary text. */
-  muted: T.fg.muted,
-  /** Dim tertiary text. */
-  dim: T.fg.dim,
-  /** Primary (near-white) text. */
-  primary: T.fg.primary,
-  /** QR module foreground — high-contrast dark, not pure black. */
-  qrDark: T.fg.inverse,
-  /** QR field background — high-contrast light, not pure white. */
-  qrLight: T.fg.primary,
-} as const;
+export const MODAL_TONES: Readonly<ReturnType<typeof buildModalTones>> = buildModalTones();
+
+registerThemeRefresh(() => Object.assign(MODAL_TONES as Record<string, string>, buildModalTones()));

package/src/panels/modals/pairing-modal.ts

@@ -18,9 +18,11 @@ import { encodeConnectionPayload, generateQrMatrix, renderQrToString } from '@pe
 // buildView, cached) so a missing daemon home degrades honestly rather than
 // throwing at modal-registration time.
 //
-// KNOWN GAP (flagged in the report): src/input/commands/qrcode-runtime.ts only
-// registers `/qrcode` (open); it has no `regenerate` subcommand yet, and this
-// surface cannot observe a regenerated token without being re-opened.
+// DEBT-3: the regenerate action now dispatches the real `/qrcode regenerate`
+// verb (which rotates the shared operator-token store) and, once it resolves,
+// RE-PULLS the lazy connection-info thunk so the modal shows the rotated token +
+// QR in place without being re-opened. `confirm: true` keeps the two-press
+// guard so a stray keystroke never rotates a live companion's token.
 // ---------------------------------------------------------------------------
 
 export interface PairingModalConnectionInfo {
@@ -58,7 +60,7 @@ class PairingModalSurface implements ConfigModalSurface {
   readonly actions = [
     { key: 'v', id: 'toggleReveal', label: 'reveal token' },
     { key: 'c', id: 'copyToken', label: 'copy token', enabledFor: () => Boolean(this.deps.copyToClipboard) },
-    { key: 'r', id: 'regenerate', label: 'regenerate token' },
+    { key: 'r', id: 'regenerate', label: 'regenerate token', confirm: true },
   ];
 
   onOpen(requestRender: () => void): void { this.requestRender = requestRender; }
@@ -117,8 +119,25 @@ class PairingModalSurface implements ConfigModalSurface {
       return;
     }
     if (id === 'regenerate') {
-      void ctx.executeCommand?.('qrcode', ['regenerate']);
-      ctx.setStatus('Dispatched /qrcode regenerate (reopen to see the new token).');
+      const dispatched = ctx.executeCommand?.('qrcode', ['regenerate']);
+      if (!dispatched) {
+        ctx.setStatus('Token rotation is unavailable in this runtime.');
+        return;
+      }
+      ctx.setStatus('Rotating pairing token…');
+      void dispatched
+        .then((ok) => {
+          if (ok === false) { ctx.setStatus('Token rotation did not complete.'); return; }
+          // Re-pull the lazy connection-info thunk: /qrcode regenerate rewrote
+          // the shared token store, so a fresh getConnectionInfo() reflects the
+          // rotated token + QR. ensureInfo caches on first build — clear it.
+          this.info = undefined;
+          this.revealed = false;
+          this.ensureInfo();
+          this.requestRender();
+          ctx.setStatus('Pairing token rotated — new token and QR loaded.');
+        })
+        .catch(() => { ctx.setStatus('Token rotation failed.'); });
     }
   }
 }