@pellux/goodvibes-tui 1.16.1 → 1.18.0

package/src/panels/fleet-panel.ts

@@ -1,14 +1,14 @@
 // ---------------------------------------------------------------------------
 // fleet-panel.ts
 //
-// W2.2 — FleetPanel: the live unified observability tree. Renders the
+// — 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. Session tabs (W3.1 Part C): Enter on an
+// with a selected-row detail region. Session tabs (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).
+// cross-panel jump target (item 4).
 // ---------------------------------------------------------------------------
 
 import { readFile } from 'node:fs/promises';
@@ -21,12 +21,14 @@ import { PanelConfirmOverlay } from './panel-confirm-overlay.ts';
 import { isPanelSearchBackspace, isPanelSearchCancel, isPanelSearchCommit, isPanelSearchPrintable } from './search-focus.ts';
 import { buildKeyboardHints, buildPanelWorkspace, buildSearchInputLine, DEFAULT_PANEL_PALETTE, getPanelWorkspaceContentBudget, type PanelPalette } from './polish.ts';
 import {
-  isBlockedOnUserState,
+  isBlockedOnUserNode,
   isRunningProcessState,
   isTerminalProcessState,
   type FleetReadModel,
   type FleetTreeRow,
 } from './fleet-read-model.ts';
+import type { FleetActs } from './fleet-acts.ts';
+import type { FleetSpawn } from './fleet-spawn.ts';
 import {
   activeFleetTab,
   appendSteerText,
@@ -40,7 +42,7 @@ import {
   type SteerBadge,
 } from './fleet-tabs.ts';
 import { liveSteerableLabels, reconcileSteerBadges as reconcileSteerBadgesPure, renderSteerBadgeLine, steerRefusalMessage } from './fleet-steer.ts';
-import { FleetStopTracker, toggleFleetPause, buildFleetTreeHints, countDescendantStats } from './fleet-stop.ts';
+import { FleetStopTracker, toggleFleetPause, buildFleetTreeHints, fleetKillConfirmArgs } 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';
@@ -95,26 +97,28 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
   private tickTimer: ReturnType<typeof setInterval> | null = null;
   /**
    * The node id the cursor is anchored to, independent of its row index.
-   * `selectedIndex` is a plain offset into `getItems()`'s current order —
-   * every snapshot rebuilds that array from scratch (new nodes, completed
-   * nodes pruned, tree re-sorted), so a stale index silently points at
-   * whatever row now happens to occupy that slot. `reanchorSelection()`
-   * re-locates this id in every fresh snapshot and repoints selectedIndex
-   * there; null means "no anchor yet" (follows the base class's index-0
-   * default until the first navigation/tick establishes one).
+   * `selectedIndex` is a plain offset into `getItems()`'s current (rebuilt-every-
+   * snapshot) order, so a stale index silently drifts; `reanchorSelection()`
+   * re-locates this id each snapshot and repoints selectedIndex. null means "no
+   * anchor yet" (base class index-0 default until first navigation/tick).
    */
   private selectedNodeId: string | null = null;
 
-  /** d1 (W6.2): the "stopping…" write-window overlay tracker (see fleet-stop.ts). */
+  /** d1: the "stopping…" write-window overlay tracker (see fleet-stop.ts). */
   private readonly stopTracker = new FleetStopTracker();
 
   public constructor(
     private readonly readModel: FleetReadModel,
     actions: Partial<FleetActionCallbacks> = {},
     private readonly configManager: ConfigManager | null = null,
+    // The waiting-on-human acts (pick / conflict / discard). Null in a runtime
+    // with no daemon gateway wired — those keys then fall through honestly.
+    private readonly acts: FleetActs | null = null,
+    // The ACP spawn affordance ('n' hosts a discovered third-party agent); null with no gateway wired.
+    private readonly spawn: FleetSpawn | null = null,
   ) {
     super('fleet', 'Fleet', '⊟', 'runtime-ops');
-    this.showSelectionGutter = true; // W0.8: visible ▸ focus indicator
+    this.showSelectionGutter = true; // visible ▸ focus indicator
     this.actions = { ...NOOP_ACTIONS, ...actions };
     this.confirmOverlay = new PanelConfirmOverlay(() => this.markDirty());
     this.unsub = readModel.subscribe(() => {
@@ -232,11 +236,10 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
   }
 
   /**
-   * 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.
+   * (cross-restart honesty): a restart starts from an empty `AgentManager` Map
+   * (no bridge from a prior registry), so a completed process from a previous
+   * session can never reappear here — a real, permanent limitation, documented
+   * rather than implying "nothing has ever run" or that a restart brings it back.
    */
   protected override getEmptyStateActions(): Array<{ command: string; summary: string }> {
     return [
@@ -275,15 +278,11 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
   }
 
   /**
-   * Re-locate `selectedNodeId` in the current (possibly just-changed)
-   * snapshot and repoint `selectedIndex` at its new position — this is what
-   * makes the selection follow a specific process across adds/removes/
-   * reorders instead of drifting onto whatever row now occupies the old
-   * index. When the anchored node is no longer present (completed and
-   * pruned, killed and pruned, etc.) — or no anchor has been established
-   * yet — falls back to the base class's clampSelection() (nearest valid
-   * index, never an out-of-bounds/vanished selection) and re-anchors to
-   * whatever that lands on.
+   * Re-locate `selectedNodeId` in the current snapshot and repoint
+   * `selectedIndex` at it, so the selection follows a specific process across
+   * adds/removes/reorders instead of drifting onto whatever row occupies the old
+   * index. When the anchored node is gone (pruned) — or no anchor exists yet —
+   * falls back to clampSelection() (nearest valid index) and re-anchors there.
    */
   private reanchorSelection(): void {
     const rows = this.getItems();
@@ -303,7 +302,7 @@ 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). */
+  /** 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; }
@@ -317,12 +316,10 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
 
   /**
    * Focus the next node blocked on the operator (awaiting approval/input),
-   * cycling top-to-bottom in display order and wrapping. Always resolves
-   * against the LIVE fleet (blocked nodes never live in the archive), and
-   * returns to the tree view from any attached tab so the reveal is visible —
-   * mirrors receiveDeepLink's "make it visible" contract. Honest no-op with a
-   * message when nothing is currently waiting on the operator. Returns true
-   * (the 'b' key is always consumed by the panel).
+   * cycling in display order and wrapping. Resolves against the LIVE fleet
+   * (blocked nodes never live in the archive) and returns to the tree view from
+   * any attached tab so the reveal is visible (receiveDeepLink's contract).
+   * Honest no-op message when nothing waits; always consumes 'b' (returns true).
    */
   private jumpToNextBlocked(): boolean {
     const snapshot = this.readModel.getSnapshot();
@@ -384,6 +381,13 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
   public override handleInput(key: string): boolean {
     if (this.lastError !== null) this.clearError();
 
+    // The candidate picker (a flagged pick decision) owns the view + input while active.
+    if (this.acts?.pickModeActive()) return this.acts.handlePickInput(key);
+    // The observed-agent steer composer (a drill-in) likewise owns EVERY key until Enter/Esc.
+    if (this.acts?.observedSteerActive()) return this.acts.handleObservedSteerInput(key);
+    // The ACP spawn picker (host a third-party agent) likewise owns view + input.
+    if (this.spawn?.spawnModeActive()) return this.spawn.handleSpawnInput(key);
+
     // Confirm overlay owns input first (K-armed kill confirm).
     if (this.confirmOverlay.handleInput(key)) return true;
 
@@ -391,7 +395,7 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
     // owns EVERY key (same full-priority-while-composing contract as
     // git-panel.ts's commitMessage entry) until Enter (submit) or Esc
     // (cancel) — a burst/paste and single hotkeys like 'j'/'s'/'[' all land
-    // in the draft, never as tree/tab navigation (W0.8 focus rule).
+    // in the draft, never as tree/tab navigation (focus rule).
     const composingTab = activeFleetTab(this.tabsState);
     if (composingTab && composingTab.steerDraft !== null) {
       return this.handleSteerInput(composingTab, key);
@@ -425,6 +429,18 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
 
     const selected = this.getSelectedItem();
 
+    // Waiting-on-human acts on the selected row: Enter on a flagged pick/conflict
+    // row, D on a worktree-owning row. Returns false (falls through to attach /
+    // ordinary handling) for any other row, so Enter still opens an agent tab.
+    if (this.acts && selected && this.acts.handleTreeKey(key, selected.node)) {
+      this.captureSelectionAnchor();
+      return true;
+    }
+
+    // Host a third-party ACP agent: lists discovered agents, then a known dir,
+    // then spawns it as an acp-agent row. Quiet when none are discovered.
+    if (key === 'n' && this.spawn) { void this.spawn.begin(); return true; }
+
     // Archive controls: v toggles the live fleet <-> session archive view;
     // a archives the selected finished subtree (or restores it from the
     // archive view); A archives every fully-finished root subtree.
@@ -479,29 +495,20 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
 
     if (key === 'K') {
       if (!selected || isTerminalProcessState(selected.node.state)) return false;
+      // Observed foreign agents have killable:false — the refusal below reads
+      // honestly; goodvibes only observes them, so stop is never offered.
       if (!selected.node.capabilities.killable) {
         this.setError(`${selected.node.kind} does not support kill.`);
         return true;
       }
-      const node = selected.node;
-      const shortId = node.id.length > 8 ? node.id.slice(-8) : node.id;
-      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}`,
-        verb: 'Kill',
-        // d1 (W6.2): mark 'stopping…' only once the kill is confirmed, not while
-        // the confirm overlay is merely armed.
-        onConfirm: () => {
-          this.actions.kill(node.id, { cascade: true });
-          this.stopTracker.mark(node.id);
-        },
-      });
+      this.confirmOverlay.arm(fleetKillConfirmArgs(selected.node, this.getItems(), {
+        kill: (id) => this.actions.kill(id, { cascade: true }),
+        markStopping: (id) => this.stopTracker.mark(id),
+      }));
       return true;
     }
 
-    // d2 (W6.2): 'p' toggles pause<->resume by the selected node's state (see
+    // d2: 'p' toggles pause<->resume by the selected node's state (see
     // toggleFleetPause in fleet-stop.ts).
     if (key === 'p') {
       if (!selected) return false;
@@ -539,6 +546,9 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
       // one press for a steerable node; honest refusal otherwise.
       if (!selected) return false;
       const node = selected.node;
+      // Observed foreign agents steer as a DRILL-IN only; that 's' is handled by
+      // acts.handleTreeKey above (opens the composer in the row's detail), so it
+      // never reaches this attach path.
       // 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.
@@ -621,7 +631,7 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
 
   /**
    * 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
+   * clears the draft only on a confirmed send (WO 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.
@@ -644,7 +654,7 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
     // Display-only overrides (stopping wins, then blocked-on-user) are derived
     // here from panel state and passed into the pure row renderer.
     const stopping = this.stopTracker.isStopping(row.node.id);
-    const blocked = !stopping && isBlockedOnUserState(row.node.state);
+    const blocked = !stopping && isBlockedOnUserNode(row.node);
     return renderFleetRowLine(row, width, stopping, blocked, this.steerBadgeForNode(row.node.id), C);
   }
 
@@ -658,8 +668,12 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
     // Mirror the tree row's display-only overrides (stopping wins, then blocked)
     // so the detail's literal state text never contradicts the row glyph.
     const stopping = this.stopTracker.isStopping(node.id);
-    const blocked = !stopping && isBlockedOnUserState(node.state);
-    return renderFleetDetailLines(node, width, stopping, blocked, C);
+    const blocked = !stopping && isBlockedOnUserNode(node);
+    // The drill-in observed-steer draft (when the composer is open on this row)
+    // renders an input line in the observed detail. For a workstream row, lazily
+    // fetch its task graph so the edges/pool posture renders in-panel.
+    this.acts?.ensureGraphFor(node);
+    return renderFleetDetailLines(node, width, stopping, blocked, C, this.acts?.observedSteerDraftFor(node.id) ?? null, this.acts?.graphFor(node.id) ?? null);
   }
 
   /** Renders the active session tab's content (transcript / chain summary / ledger fallback) in place of the tree. */
@@ -718,7 +732,7 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
 
     if (tab.kind === 'wrfc-chain') {
       const memberRows = snapshotRows.filter((row) => row.node.parentId === tab.nodeId);
-      // d3 (W6.2): a completed chain prunes its wrapper node, so an empty member
+      // d3: a completed chain prunes its wrapper node, so an empty member
       // list can mean "finished", not "not started yet". Absent (pruned) OR
       // terminal => the honest "completed" wording; present + non-terminal with
       // no members yet => the "not started" wording.
@@ -777,6 +791,8 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
   }
 
   public override render(width: number, height: number): Line[] {
+    if (this.acts?.pickModeActive()) return this.acts.renderPickMode(width, height, C);
+    if (this.spawn?.spawnModeActive()) return this.spawn.renderSpawnMode(width, height, C);
     if (this.tabsState.activeTabIndex > 0) return this.renderTabView(width, height);
     return this.renderTreeView(width, height);
   }

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

@@ -1,14 +1,14 @@
 // ---------------------------------------------------------------------------
 // fleet-read-model.ts
 //
-// W2.2 (Fleet tree panel) — pure, testable read-model over the SDK's live
+// (Fleet tree panel) — pure, testable read-model over the SDK's live
 // process registry (@pellux/goodvibes-sdk/platform/runtime/fleet, landed on
-// SDK main as W2.1). No BasePanel/rendering dependency: this module owns the
+// SDK main as). No BasePanel/rendering dependency: this module owns the
 // flat ProcessNode[] -> tree transformation, the honest cost/token
 // aggregates, and the state->glyph/tone mapping that FleetPanel renders.
 //
 // Design notes:
-//   - The W2.2 brief predates the real SDK API and sketched a bespoke
+//   - The brief predates the real SDK API and sketched a bespoke
 //     FleetRegistryNode/FleetRegistry adapter pair. The real
 //     createProcessRegistry() ProcessNode already carries elapsedMs,
 //     usage, costUsd, costState, and currentActivity directly, so no
@@ -30,6 +30,7 @@
 
 import type {
   ArchivableProcessRegistry,
+  ProcessAttention,
   ProcessCostState,
   ProcessKind,
   ProcessNode,
@@ -136,13 +137,11 @@ const STATE_TONES: Record<ProcessState, FleetStateTone> = {
 const TERMINAL_STATES = new Set<ProcessState>(['done', 'failed', 'killed', 'interrupted']);
 
 /**
- * States that mean "this node is waiting on ME right now" — a user approval or
- * user input. Today the registry derives exactly one such state,
- * `awaiting-approval` (an agent parked at a permission prompt). This is the
- * single place that mapping lives, so if the SDK adds a distinct
- * awaiting-user-input state later it joins here and every "blocked on me"
- * surface (badge, sort, jump) picks it up for free. Kept as a set for that
- * forward-compatibility, not because more than one state qualifies today.
+ * States that mean "this node is waiting on ME right now" via the state field
+ * alone. The registry now also publishes the canonical `needsAttention`
+ * projection (reason 'approval' | 'input' — see fleetNodeAttention below),
+ * which every surface prefers; this set remains only as the fallback mapping
+ * for nodes without the projection, so nothing regresses on older registries.
  */
 const BLOCKED_ON_USER_STATES = new Set<ProcessState>(['awaiting-approval']);
 
@@ -168,6 +167,17 @@ const KIND_TAGS: Record<ProcessKind, string> = {
   // A single leaf node — never a rollup of other flat-list nodes (see
   // ROLLUP_KINDS below) — so no other list in this module needs updating.
   'code-index': 'index',
+  // A hosted third-party coding agent (Claude Code / Codex / opencode) spawned
+  // over ACP (adapters/acp-host.ts). A plain leaf row — steer/stop/attention
+  // ride on its node capabilities and the SDK's needsAttention projection, so
+  // this glyph/label is the only read-model special-casing it needs.
+  'acp-agent': 'acp',
+  // An externally-launched foreign coding agent (Claude Code / Codex / opencode)
+  // that goodvibes did NOT spawn — observed read-only from OS signals. The row's
+  // first job is visibility ("it's in claude or codex"); it is never counted in
+  // any our-fleet count, never carries a stop affordance, and steer is drill-in
+  // only. See ObservedProcess handling in fleet-panel-format.ts.
+  'observed-external': 'observed',
 };
 
 export function fleetStateGlyph(state: ProcessState): string {
@@ -195,8 +205,66 @@ export function isBlockedOnUserState(state: ProcessState): boolean {
   return BLOCKED_ON_USER_STATES.has(state);
 }
 
+/**
+ * The node's waiting-on-human classification, preferring the SDK's canonical
+ * `needsAttention` projection (reason 'approval' | 'input' — broader than the
+ * awaiting-approval state alone: it also covers a session waiting on user
+ * input). Falls back to the state-derived mapping for registries that predate
+ * the projection, so nothing regresses. This is THE membership every
+ * "blocked on me" surface (badge, sort, jump) derives from.
+ */
+export function fleetNodeAttention(node: ProcessNode): ProcessAttention | null {
+  if (node.needsAttention) return node.needsAttention;
+  if (isBlockedOnUserState(node.state)) return { reason: 'approval' };
+  return null;
+}
+
+/** True when the node is waiting on the operator right now (approval or input). */
+export function isBlockedOnUserNode(node: ProcessNode): boolean {
+  return fleetNodeAttention(node) !== null;
+}
+
+/**
+ * The literal badge text for a waiting-on-human node, by reason. Every reason
+ * is a first-class member of the ONE waiting-on-human state class (same ⚑
+ * glyph, same jump key, same count) but names WHY in its own words:
+ *   - 'approval' — a tool call is held for an approve/deny decision.
+ *   - 'input'    — the node is otherwise blocked on operator input.
+ *   - 'pick'     — a best-of-N attempt group is ready and only a human's
+ *                  winner pick advances it.
+ *   - 'conflict' — a merge conflict needs a human resolution before the work
+ *                  can land.
+ * The pick/conflict wording is deliberately DISTINCT from the bare
+ * 'blocked on you' so an operator reads the required act, not just the state.
+ */
+export function fleetAttentionText(attention: ProcessAttention): string {
+  switch (attention.reason) {
+    case 'input': return 'needs your input';
+    case 'pick': return 'needs your pick';
+    case 'conflict': return 'merge conflict waiting on you';
+    case 'approval': return 'blocked on you';
+    default: return 'blocked on you';
+  }
+}
+
+/**
+ * The stall marker for a row — 'quiet Nm' (or 'quiet NhMm' past an hour),
+ * derived from the read-model's stall tell (pure timestamp comparison on the
+ * registry side; a live node whose last observable output is older than the
+ * threshold). Null when the node is not stalled-quiet.
+ */
+export function fleetStallMarker(node: ProcessNode): string | null {
+  const stall = node.stall;
+  if (!stall) return null;
+  const minutes = Math.max(1, Math.floor(stall.quietForMs / 60_000));
+  if (minutes < 60) return `quiet ${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const rest = minutes % 60;
+  return rest > 0 ? `quiet ${hours}h${rest}m` : `quiet ${hours}h`;
+}
+
 // ---------------------------------------------------------------------------
-// Honest usage/cost helpers (W0.9 convention, ported from agent-inspector-shared.ts)
+// Honest usage/cost helpers (convention, ported from agent-inspector-shared.ts)
 // ---------------------------------------------------------------------------
 
 /**
@@ -261,7 +329,7 @@ function collectBlockedSubtrees(
     if (cached !== undefined) return cached;
     if (visiting.has(node.id)) return false; // cycle guard
     visiting.add(node.id);
-    let has = isBlockedOnUserState(node.state);
+    let has = isBlockedOnUserNode(node);
     for (const child of childrenByParent.get(node.id) ?? []) {
       if (dfs(child)) has = true;
     }
@@ -431,7 +499,9 @@ function isFleetAggregateRollupNode(node: ProcessNode): boolean {
  * count in the way summing its rolled-up usage/cost would be.
  */
 function isFleetRunningLeaf(node: ProcessNode): boolean {
-  return !ROLLUP_KINDS.has(node.kind) && isRunningProcessState(node.state);
+  // Observed foreign agents are NEVER counted in our own fleet counts — they
+  // are externally-launched sessions goodvibes only watches, not work it runs.
+  return node.kind !== 'observed-external' && !ROLLUP_KINDS.has(node.kind) && isRunningProcessState(node.state);
 }
 
 /** Build the full FleetSnapshot (rows + honest aggregates) from a flat node list. */
@@ -458,7 +528,7 @@ export function buildFleetSnapshot(nodes: readonly ProcessNode[], capturedAt: nu
   // Blocked ids in display (row) order so the panel's jump key steps through
   // them top-to-bottom exactly as they appear on screen.
   const blockedNodeIds = rows
-    .filter((row) => isBlockedOnUserState(row.node.state))
+    .filter((row) => isBlockedOnUserNode(row.node))
     .map((row) => row.node.id);
 
   return { rows, totalCost, totalTokens, runningCount, blockedNodeIds, capturedAt };