@pellux/goodvibes-tui 1.16.1 → 1.18.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,20 +7,23 @@
 // 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';
-import { fleetUsageTokens, hasFleetCost, type FleetStateTone } from './fleet-read-model.ts';
+import { fleetAttentionText, fleetNodeAttention, fleetStallMarker, fleetUsageTokens, hasFleetCost, type FleetStateTone } from './fleet-read-model.ts';
 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
@@ -96,16 +102,39 @@ export function renderFleetRowLine(
     ? ` [attempt ${node.attemptGroup.index + 1}/${node.attemptGroup.total}${node.attemptGroup.held ? ', held' : ''}]`
     : '';
   const label = `${row.treePrefix}${node.label}${attemptBadge}`;
-  // Activity column doubles as the badge slot: 'blocked on you' shouts the
-  // wait louder than the raw currentActivity text ('awaiting approval …').
+  // Activity column doubles as the badge slot, in priority order:
+  //   stopping > waiting-on-human text ('blocked on you' / 'needs your input')
+  //   > the read-model HEADLINE (derived from task/phase identity only —
+  //   replaced in place, never a scrolling feed) with the stall marker
+  //   ('quiet Nm') appended when the node has gone observably silent.
+  // Nodes without a headline fall back to the live currentActivity text.
+  const attention = fleetNodeAttention(node);
+  const stallMarker = fleetStallMarker(node);
+  const steadyText = node.headline?.text ?? node.currentActivity?.text ?? '';
+  // The stall marker must survive the 20-char activity cell: budget the
+  // headline around it (the marker is the honesty signal; a stalled node must
+  // never render as if it were healthily mid-headline).
+  const steadyWithStall = stallMarker
+    ? (steadyText
+        ? `${truncateDisplay(steadyText, Math.max(1, ACTIVITY_W - stallMarker.length - 3))} · ${stallMarker}`
+        : stallMarker)
+    : steadyText;
   const activity = stopping
     ? disp.label
     : blocked
-      ? 'blocked on you'
+      ? fleetAttentionText(attention ?? { reason: 'approval' })
       : badge
-        ? `${steerBadgeGlyph(badge.status)} ${node.currentActivity?.text ?? ''}`.trimEnd()
-        : (node.currentActivity?.text ?? '');
-  const activityColor = stopping ? color : blocked ? color : badge ? steerBadgeTone(badge.status, C) : C.dim;
+        ? `${steerBadgeGlyph(badge.status)} ${steadyWithStall}`.trimEnd()
+        : steadyWithStall;
+  const activityColor = stopping
+    ? color
+    : blocked
+      ? color
+      : badge
+        ? steerBadgeTone(badge.status, C)
+        : stallMarker
+          ? (C.warn ?? DEFAULT_PANEL_PALETTE.warn)
+          : C.dim;
 
   return buildAlignedRow(
     width,
@@ -130,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],
@@ -148,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],
   ]);
@@ -160,6 +276,19 @@ export function renderFleetDetailLines(
     ['  cost ', C.label],
     [formatFleetCost(node.costUsd, node.costState), C.value],
   ]);
+  // The headline (task/phase identity, replaced in place) gets its own row
+  // when present, with the stall marker appended — the detail block mirrors
+  // exactly what the tree row's steady slot shows.
+  const stallMarker = fleetStallMarker(node);
+  const headlineText = node.headline
+    ? `${node.headline.text}${stallMarker ? ` · ${stallMarker}` : ''}`
+    : stallMarker;
+  const headlineLine = headlineText
+    ? [buildPanelLine(width, [
+        [' headline ', C.label],
+        [truncateDisplay(headlineText, Math.max(0, width - 11)), stallMarker ? (C.warn ?? DEFAULT_PANEL_PALETTE.warn) : C.value],
+      ])]
+    : [];
   const activityText = node.currentActivity
     ? `${node.currentActivity.kind}: ${node.currentActivity.text}`
     : '(no recent activity)';
@@ -170,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, 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;
+}