@pellux/goodvibes-tui 1.17.0 → 1.19.0

package/src/panels/fleet-observed-render.ts

@@ -0,0 +1,128 @@
+// ---------------------------------------------------------------------------
+// fleet-observed-render.ts — the fleet-pane rows for observed FOREIGN coding
+// agents (kind 'observed-external').
+//
+// goodvibes did NOT spawn these — they are externally-launched Claude Code /
+// Codex / opencode sessions, detected read-only from OS signals. The row's
+// FIRST job is visibility ("it's in claude or codex"): goodvibes never presents
+// itself as the foreign session's cockpit. So an observed row:
+//   - shows its honest external kind + a liveness-derived state (active/quiet),
+//   - is NEVER counted in any of the panel's own-fleet counts,
+//   - carries NO stop affordance, ever,
+//   - offers steer as a DRILL-IN only (in the detail view), and only where a
+//     real channel exists; where steer.kind is 'none' the detail states why.
+// ---------------------------------------------------------------------------
+
+import type { ProcessNode, ProcessObserved, ObservedAgentKind } from '@pellux/goodvibes-sdk/platform/runtime/fleet';
+import type { Line } from '../types/grid.ts';
+import { buildPanelLine, buildSearchInputLine, DEFAULT_PANEL_PALETTE, type PanelPalette } from './polish.ts';
+import { truncateDisplay, wrapText } from '../utils/terminal-width.ts';
+
+/** An observed-external node carries its foreign-agent facts on `observed`. */
+export type ObservedNode = ProcessNode & { readonly observed: ProcessObserved };
+
+/** True for a foreign observed-agent node (never one of our own fleet rows). */
+export function isObservedExternalNode(node: ProcessNode): node is ObservedNode {
+  return node.kind === 'observed-external' && node.observed !== undefined;
+}
+
+/** The honest plain-language label for an observed foreign agent's kind. */
+export function observedKindLabel(kind: ObservedAgentKind): string {
+  switch (kind) {
+    case 'claude-code': return 'Claude Code';
+    case 'codex': return 'Codex';
+    case 'opencode': return 'opencode';
+    default: return 'unknown agent';
+  }
+}
+
+/** Liveness glyph: a filled ring while CPU is advancing, a hollow one while quiet. */
+function livenessGlyph(state: ProcessObserved['liveness']['state']): string {
+  return state === 'active' ? '◉' : '○';
+}
+
+/**
+ * One observed-external row. Deliberately NOT the standard fleet row: no cost/
+ * token/steer-badge columns (a foreign session has no LLM turn we account for),
+ * no stop marker — just the glyph, an "observed" tag, the session label, its
+ * external kind, and its liveness state.
+ */
+export function renderObservedRowLine(node: ObservedNode, width: number, palette: PanelPalette = DEFAULT_PANEL_PALETTE): Line {
+  const C = palette;
+  const observed = node.observed;
+  const glyph = livenessGlyph(observed.liveness.state);
+  const kindLabel = observedKindLabel(observed.externalKind);
+  // The label is width-budgeted so the trailing "kind · state" tell never
+  // overflows the row (the tell is the honesty signal — it must survive).
+  const tell = `${kindLabel} · ${observed.liveness.state}`;
+  const labelBudget = Math.max(4, width - tell.length - 14);
+  return buildPanelLine(width, [
+    [' ', C.dim],
+    [glyph, observed.liveness.state === 'active' ? (C.info ?? DEFAULT_PANEL_PALETTE.info) : C.dim],
+    [' observed ', C.dim],
+    [truncateDisplay(node.label, labelBudget), C.value],
+    ['  ', C.dim],
+    [tell, C.dim],
+  ]);
+}
+
+/**
+ * The detail block for a selected observed-external row. States the foreign
+ * facts (external kind, pid, cwd, liveness meaning), then the steer affordance —
+ * a DRILL-IN: where a real channel exists it names the action; where steer.kind
+ * is 'none' it states the honest reason. It NEVER shows a stop affordance —
+ * observing a foreign session is not owning its lifecycle.
+ */
+/**
+ * Render the observed-row detail. When `steerDraft` is a string the drill-in
+ * steer composer is open on THIS row: an active input line replaces the passive
+ * "s: steer" hint. A channel-less row never shows an input (owner ruling) — its
+ * detail states the honest reason and stops there.
+ */
+export function renderObservedDetailLines(node: ObservedNode, width: number, palette: PanelPalette = DEFAULT_PANEL_PALETTE, steerDraft: string | null = null): Line[] {
+  const C = palette;
+  const observed = node.observed;
+  const lines: Line[] = [];
+  lines.push(buildPanelLine(width, [
+    [' ', C.dim],
+    [livenessGlyph(observed.liveness.state), observed.liveness.state === 'active' ? (C.info ?? DEFAULT_PANEL_PALETTE.info) : C.dim],
+    [' observed ', C.dim],
+    [observedKindLabel(observed.externalKind), C.value],
+    ['  pid ', C.label],
+    [String(observed.pid), C.value],
+    ['  state ', C.label],
+    [observed.liveness.state, C.value],
+  ]));
+  if (observed.cwd) {
+    lines.push(buildPanelLine(width, [[' cwd ', C.label], [truncateDisplay(observed.cwd, Math.max(0, width - 6)), C.dim]]));
+  }
+  // Liveness meaning, verbatim — honest about what 'quiet' can and cannot tell.
+  for (const segment of wrapText(observed.liveness.detail, Math.max(1, width - 2))) {
+    lines.push(buildPanelLine(width, [[' ', C.dim], [segment, C.dim]]));
+  }
+  // Steer is a drill-in: a real channel is named here (a message sent from this
+  // detail travels over it — fleet.observed.steer), and where none exists the
+  // honest reason is stated instead of a dead action. Wrapped so a long reason
+  // is never clipped at a narrow width.
+  const steerText = observed.steer.kind === 'tmux'
+    ? `available via tmux pane ${observed.steer.paneId} (send-keys)`
+    : `unavailable — ${observed.steer.reason}`;
+  const steerFg = observed.steer.kind === 'tmux' ? (C.info ?? DEFAULT_PANEL_PALETTE.info) : C.dim;
+  const steerSegments = wrapText(steerText, Math.max(1, width - 8));
+  steerSegments.forEach((segment, i) => {
+    lines.push(buildPanelLine(width, [[i === 0 ? ' steer ' : '       ', C.label], [segment, steerFg]]));
+  });
+  // Drill-in compose input: only where a real channel exists. An active draft
+  // renders the input line + send/cancel hint; otherwise a discoverability hint.
+  if (observed.steer.kind === 'tmux') {
+    if (steerDraft !== null) {
+      lines.push(buildSearchInputLine(width, ' send ', `${steerDraft}_`, C, { active: true, bg: C.inputBg, valueColor: C.info }));
+      lines.push(buildPanelLine(width, [['       ', C.label], ['Enter: send  Esc: cancel', C.dim]]));
+    } else {
+      lines.push(buildPanelLine(width, [['       ', C.label], ['s: steer this session', C.dim]]));
+    }
+  }
+  // Visibility, not a cockpit: there is no stop here, by design.
+  lines.push(buildPanelLine(width, [[' stop ', C.label], ['not offered — goodvibes only observes this foreign session', C.dim]]));
+  return lines;
+}

package/src/panels/fleet-panel-format.ts

@@ -7,7 +7,7 @@
 // renderItem/renderDetail call, with no `this` dependency.
 // ---------------------------------------------------------------------------
 
-import type { ProcessCostState, ProcessNode, ProcessUsage } from '@pellux/goodvibes-sdk/platform/runtime/fleet';
+import type { ProcessCostState, ProcessNode, ProcessReviewSummary, ProcessUsage } from '@pellux/goodvibes-sdk/platform/runtime/fleet';
 import type { Line } from '../types/grid.ts';
 import { formatAgentCost } from './agent-inspector-shared.ts';
 import { buildPanelLine, DEFAULT_PANEL_PALETTE, type ColumnSpec, type PanelPalette } from './polish.ts';
@@ -15,12 +15,15 @@ import { fleetAttentionText, fleetNodeAttention, fleetStallMarker, fleetUsageTok
 import { fleetStateDisplay } from './fleet-stop.ts';
 import { formatElapsed } from '../utils/format-elapsed.ts';
 import { truncateDisplay } from '../utils/terminal-width.ts';
-import { formatWorkItemIsolationDetailFromRaw } from './fleet-panel-worktree-detail.ts';
+import { conflictFilesFromRaw, formatWorkItemIsolationDetailFromRaw } from './fleet-panel-worktree-detail.ts';
+import { wrapText } from '../utils/terminal-width.ts';
 import { buildAlignedRow } from './polish.ts';
 import { fleetKindTag } from './fleet-read-model.ts';
 import { steerBadgeGlyph, steerBadgeTone } from './fleet-steer.ts';
 import type { SteerBadge } from './fleet-tabs.ts';
 import type { FleetTreeRow } from './fleet-read-model.ts';
+import { isObservedExternalNode, renderObservedDetailLines, renderObservedRowLine } from './fleet-observed-render.ts';
+import { renderPoolSummary, type WorkstreamGraphSnapshot } from './workstream-graph-render.ts';
 
 // Column widths for the tree row layout. `label` absorbs whatever width is
 // left over after the fixed columns + gaps; on hostile (narrow) widths the
@@ -88,6 +91,9 @@ export function renderFleetRowLine(
 ): Line {
   const C = palette;
   const node = row.node;
+  // Observed foreign agents render as their own visibility row (no cost/steer
+  // columns, no stop marker) — see fleet-observed-render.ts.
+  if (isObservedExternalNode(node)) return renderObservedRowLine(node, width, palette);
   const disp = fleetStateDisplay(node.state, stopping, blocked);
   const color = toneColor(disp.tone, C);
   // Best-of-N grouping: badge a sibling attempt so the N candidates read as one
@@ -153,16 +159,103 @@ export function renderFleetRowLine(
  * 'state' text never claims a past-tense outcome mid-write, and a
  * blocked-on-user node reads 'blocked on you' here too.
  */
+/**
+ * The reviewer's acceptance checklist + verdict, from the fleet node's served
+ * `review` field (ProcessReviewSummary, rides fleet.snapshot/list). Rendered
+ * only when a review has completed — never an empty shell. Each item shows
+ * whether it was verified, the evidence, and (when present) how it was
+ * exercised, matching what the webui's review detail surfaces.
+ */
+export function renderReviewLines(review: ProcessReviewSummary, width: number, palette: PanelPalette = DEFAULT_PANEL_PALETTE): Line[] {
+  const C = palette;
+  const passTone = C.good ?? C.info;
+  const failTone = C.bad ?? C.warn ?? DEFAULT_PANEL_PALETTE.warn;
+  const cyclesLabel = review.cycles === 1 ? '1 cycle' : `${review.cycles} cycles`;
+  const lines: Line[] = [
+    buildPanelLine(width, [
+      [' review ', C.label],
+      [review.passed ? '✓ passed' : '✗ not passed', review.passed ? passTone : failTone],
+      ['  score ', C.label], [String(review.score), C.value],
+      ['  ', C.dim], [cyclesLabel, C.dim],
+    ]),
+  ];
+  if (review.checklist.length === 0) {
+    // Empty checklist is itself a gate failure — say so honestly, don't hide it.
+    lines.push(buildPanelLine(width, [['   ', C.dim], ['(the reviewer emitted no acceptance checklist — a gate failure)', failTone]]));
+    return lines;
+  }
+  for (const it of review.checklist) {
+    const mark = it.verified ? '[verified]  ' : '[unverified]';
+    const markTone = it.verified ? passTone : failTone;
+    wrapText(it.item, Math.max(1, width - 16)).forEach((seg, i) => {
+      lines.push(buildPanelLine(width, i === 0
+        ? [['   ', C.dim], [`${mark} `, markTone], [seg, C.value]]
+        : [['                ', C.dim], [seg, C.value]]));
+    });
+    if (it.evidence) {
+      for (const seg of wrapText(`evidence: ${it.evidence}`, Math.max(1, width - 6))) {
+        lines.push(buildPanelLine(width, [['     ', C.dim], [seg, C.dim]]));
+      }
+    }
+    if (it.howExercised) {
+      for (const seg of wrapText(`exercised: ${it.howExercised}`, Math.max(1, width - 6))) {
+        lines.push(buildPanelLine(width, [['     ', C.dim], [seg, C.dim]]));
+      }
+    }
+  }
+  return lines;
+}
+
+/**
+ * The task graph's edges + elastic-pool posture for a workstream row, rendered
+ * IN the fleet detail (the tree shows nodes; edges/pool used to be reachable
+ * only via /graph — /graph still works). Fetched lazily and cached by fleet-acts;
+ * rendered only once a snapshot is in hand. An empty graph states so honestly.
+ */
+export function renderGraphPostureLines(graph: WorkstreamGraphSnapshot, width: number, palette: PanelPalette = DEFAULT_PANEL_PALETTE): Line[] {
+  const C = palette;
+  const lines: Line[] = [
+    buildPanelLine(width, [[' graph ', C.label], [renderPoolSummary(graph.pool), C.value]]),
+  ];
+  if (graph.edges.length === 0) {
+    lines.push(buildPanelLine(width, [['   ', C.dim], ['no dependency edges', C.dim]]));
+    return lines;
+  }
+  const titleById = new Map(graph.nodes.map((n) => [n.id, n.title]));
+  lines.push(buildPanelLine(width, [[' edges ', C.label], [`${graph.edges.length} dependency link(s)`, C.value]]));
+  for (const edge of graph.edges) {
+    const from = titleById.get(edge.from) ?? edge.from;
+    const to = titleById.get(edge.to) ?? edge.to;
+    for (const seg of wrapText(`${from} → ${to}`, Math.max(1, width - 5))) {
+      lines.push(buildPanelLine(width, [['   ', C.dim], [seg, C.dim]]));
+    }
+  }
+  return lines;
+}
+
 export function renderFleetDetailLines(
   node: ProcessNode,
   width: number,
   stopping: boolean,
   blocked: boolean,
   palette: PanelPalette = DEFAULT_PANEL_PALETTE,
+  observedSteerDraft: string | null = null,
+  graphSnapshot: WorkstreamGraphSnapshot | null = null,
 ): Line[] {
   const C = palette;
+  // Observed foreign agents drill into their own detail (facts + steer-or-reason,
+  // never a stop) — see fleet-observed-render.ts. The drill-in steer draft (when
+  // the composer is open on this row) renders an input line in that detail.
+  if (isObservedExternalNode(node)) return renderObservedDetailLines(node, width, palette, observedSteerDraft);
   const disp = fleetStateDisplay(node.state, stopping, blocked);
   const color = toneColor(disp.tone, C);
+  // A blocked node's state text names WHY in the reason's own words
+  // ('needs your pick' / 'merge conflict waiting on you' / …) so the detail
+  // block never contradicts the row's reason-specific badge; the shared ⚑
+  // glyph/tone (disp) is unchanged. 'stopping' still wins over the reason.
+  const stateLabel = blocked && !stopping
+    ? fleetAttentionText(fleetNodeAttention(node) ?? { reason: 'approval' })
+    : disp.label;
 
   const line1 = buildPanelLine(width, [
     [' ', C.dim],
@@ -171,7 +264,7 @@ export function renderFleetDetailLines(
     ['  id ', C.label],
     [node.id, C.value],
     ['  state ', C.label],
-    [disp.label, color],
+    [stateLabel, color],
     ['  elapsed ', C.label],
     [formatElapsed(node.elapsedMs), C.value],
   ]);
@@ -206,5 +299,28 @@ export function renderFleetDetailLines(
   // 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, ...headlineLine, line3, line4, ...(isolationDetail ? [buildPanelLine(width, [[' isolation ', C.label], [isolationDetail, C.dim]])] : [])];
+  // A merge-conflict row shows its STRUCTURED conflicting-path list, wrapped so a
+  // long path is fully readable — never clipped (STEP 4: the conflict row acts,
+  // and the operator sees exactly which files need resolving before pressing Enter).
+  const conflictFiles = node.kind === 'work-item' ? conflictFilesFromRaw(node.raw) : null;
+  const conflictLines: Line[] = conflictFiles
+    ? [
+      buildPanelLine(width, [[' conflicts ', C.label], [`${conflictFiles.length} file(s) — press Enter to resolve`, C.warn ?? DEFAULT_PANEL_PALETTE.warn]]),
+      // Prefix is 3 spaces of indent + a 2-col bullet/continuation marker, so
+      // wrap the path at width-5 to keep the composed line within `width`
+      // (a hard-wrapped long path is fully readable, never clipped).
+      ...conflictFiles.flatMap((file) =>
+        wrapText(file, Math.max(1, width - 5)).map((segment, i) =>
+          buildPanelLine(width, [['   ', C.dim], [i === 0 ? `• ${segment}` : `  ${segment}`, C.value]]),
+        ),
+      ),
+    ]
+    : [];
+  // The reviewer's acceptance checklist + verdict, when a review has completed
+  // (served on node.review; absent before any review — never an empty shell).
+  const reviewLines = node.review ? renderReviewLines(node.review, width, C) : [];
+  // The task graph's edges/pool posture for a workstream row (fetched + cached
+  // by fleet-acts); rendered in-panel under the chain, /graph still available.
+  const graphLines = graphSnapshot ? renderGraphPostureLines(graphSnapshot, width, C) : [];
+  return [line1, line2, ...headlineLine, line3, line4, ...(isolationDetail ? [buildPanelLine(width, [[' isolation ', C.label], [isolationDetail, C.dim]])] : []), ...conflictLines, ...reviewLines, ...graphLines];
 }

package/src/panels/fleet-panel-worktree-detail.ts

@@ -46,3 +46,17 @@ export function formatWorkItemIsolationDetailFromRaw(raw: unknown): string | nul
   const item = (raw as { item?: WorkItem } | undefined)?.item;
   return item ? formatWorkItemIsolationDetail(item) : null;
 }
+
+/**
+ * The STRUCTURED conflicting-path list a merge-conflict work item recorded
+ * (WorkItem.conflictFiles), for the Fleet detail block to show a human exactly
+ * which files need resolving. Null when the node is not a conflicted work item
+ * or recorded no files. The caller wraps these (never clips) so a long path is
+ * always fully readable.
+ */
+export function conflictFilesFromRaw(raw: unknown): readonly string[] | null {
+  const item = (raw as { item?: WorkItem } | undefined)?.item;
+  if (!item || item.mergeState !== 'conflict') return null;
+  const files = item.conflictFiles;
+  return files && files.length > 0 ? files : null;
+}

package/src/panels/fleet-panel.ts

@@ -27,6 +27,8 @@ import {
   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,13 +97,10 @@ 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;
 
@@ -112,6 +111,11 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
     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; // visible ▸ focus indicator
@@ -232,11 +236,10 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
   }
 
   /**
-   * (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 (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();
@@ -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;
 
@@ -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,25 +495,16 @@ 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: 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;
     }
 
@@ -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.
@@ -659,7 +669,11 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
     // so the detail's literal state text never contradicts the row glyph.
     const stopping = this.stopTracker.isStopping(node.id);
     const blocked = !stopping && isBlockedOnUserNode(node);
-    return renderFleetDetailLines(node, width, stopping, blocked, C);
+    // 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. */
@@ -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

@@ -167,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 {
@@ -213,9 +224,27 @@ export function isBlockedOnUserNode(node: ProcessNode): boolean {
   return fleetNodeAttention(node) !== null;
 }
 
-/** The literal badge text for a waiting-on-human node, by reason. */
+/**
+ * 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 {
-  return attention.reason === 'input' ? 'needs your input' : 'blocked on you';
+  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';
+  }
 }
 
 /**
@@ -470,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. */