Keep fleet board disclosures honest under re-clamp

When geometry grants fewer rows than the formatter already folded,
carry the prior +N more / header hidden count into the new total so
operators still see every running lane accounted for. Paint lane
state as operator copy (in tool) rather than the machine token.

Author: TheGreatAxios

src/tui-opentui/chrome-state.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test"
 import {
   annotateAgentTools,
   chromeFromSession,
+  clampBoardRows,
   formatAgentsPanel,
   formatChromeZones,
   formatTasksPanel,
@@ -447,12 +448,14 @@ describe("lane state survives the mapping hops", () => {
       undefined,
       NOW,
     )
-    // Board: header first, then the lane. Expect main's in_tool vocabulary.
+    // Board: header first, then the lane. Operator copy uses "in tool", not
+    // the machine LaneState token.
     expect(rows?.[0]?.kind).toBe("header")
     expect(rows?.[0]?.label).toContain("in tool")
     expect(rows?.[1]?.kind).toBe("lane")
     expect(rows?.[1]?.stalled).toBe(false)
-    expect(rows?.[1]?.tail).toContain("in_tool")
+    expect(rows?.[1]?.tail).toContain("in tool")
+    expect(rows?.[1]?.tail).not.toContain("in_tool")
     expect(rows?.[1]?.tail).toContain("run_shell 1:30")
     expect(rows?.[1]?.tail).not.toContain("stalled")
 
@@ -495,3 +498,42 @@ describe("lane state survives the mapping hops", () => {
     expect(annotated.agents?.[0]?.currentToolStartedAt).toBeNull()
   })
 })
+
+describe("clampBoardRows", () => {
+  test("carries a prior more-row count into a tighter re-clamp", () => {
+    // Formatter already hid 4 of 8; collapse then grants only 4 rows total.
+    // Honest disclosure is 4 prior + 2 newly dropped = 6, not 2.
+    const formatted = [
+      { label: "FLEET  8 lanes · 8 working", tail: "", stalled: false, kind: "header" as const },
+      { label: "a: one", tail: " · working · 0:01", stalled: false, kind: "lane" as const },
+      { label: "b: two", tail: " · working · 0:01", stalled: false, kind: "lane" as const },
+      { label: "c: three", tail: " · working · 0:01", stalled: false, kind: "lane" as const },
+      { label: "d: four", tail: " · working · 0:01", stalled: false, kind: "lane" as const },
+      { label: "+4 more lanes", tail: "", stalled: false, kind: "more" as const },
+    ]
+    const clamped = clampBoardRows(formatted, 4)
+    expect(clamped).toHaveLength(4)
+    expect(clamped[0]?.kind).toBe("header")
+    expect(clamped[0]?.tail).toBe("")
+    expect(clamped[3]).toEqual({
+      label: "+6 more lanes",
+      tail: "",
+      stalled: false,
+      kind: "more",
+    })
+  })
+
+  test("under a tight height the header carries the total hidden count", () => {
+    const formatted = [
+      { label: "FLEET  8 lanes · 8 working", tail: " · +4 hidden", stalled: false, kind: "header" as const },
+      { label: "a: one", tail: " · working · 0:01", stalled: false, kind: "lane" as const },
+      { label: "b: two", tail: " · working · 0:01", stalled: false, kind: "lane" as const },
+    ]
+    const clamped = clampBoardRows(formatted, 2)
+    expect(clamped).toHaveLength(2)
+    // 4 prior + 1 newly dropped lane = 5.
+    expect(clamped[0]?.tail).toBe(" · +5 hidden")
+    expect(clamped.some((r) => r.kind === "more")).toBe(false)
+  })
+})
+

src/tui-opentui/chrome-state.ts

@@ -285,6 +285,11 @@ function boardLaneState(
  * zone's box — rows land on top of each other and on whatever is below. So the
  * granted height is the last word, and the lanes it costs are disclosed rather
  * than dropped in silence.
+ *
+ * When the formatter already folded a fan-out (`+N more lanes` or header
+ * `+N hidden`), that prior count is carried into the re-clamp total so the
+ * operator still sees every running lane accounted for — not only the ones
+ * still present as row objects after the first fold.
  */
 export function clampBoardRows(
   rows: readonly AgentPanelRow[],
@@ -296,27 +301,68 @@ export function clampBoardRows(
   const header = rows[0]
   if (header === undefined) return []
   const lanes = rows.filter((r) => r.kind === "lane")
+  const priorHidden = priorHiddenCount(rows)
+  // Drop any prior disclosure on the header; we restate the total below.
+  const cleanHeader = stripHiddenTail(header)
 
   // Below a few rows the disclosure line costs more than the lane it displaces,
   // so the header carries the count instead — the same trade the formatter makes.
   if (height < 4) {
-    const shown = lanes.slice(0, height - 1)
-    return [withHiddenCount(header, lanes.length - shown.length), ...shown]
+    const shown = lanes.slice(0, Math.max(0, height - 1))
+    const hidden = priorHidden + (lanes.length - shown.length)
+    return [withHiddenCount(cleanHeader, hidden), ...shown]
   }
 
-  const shown = lanes.slice(0, height - 2)
-  const hidden = lanes.length - shown.length
+  const shown = lanes.slice(0, Math.max(0, height - 2))
+  const hidden = priorHidden + (lanes.length - shown.length)
   return [
-    header,
+    cleanHeader,
     ...shown,
     { label: `+${hidden} more lanes`, tail: "", stalled: false, kind: "more" },
   ]
 }
 
+/** Lanes already disclosed by a prior format/clamp fold on these rows. */
+function priorHiddenCount(rows: readonly AgentPanelRow[]): number {
+  let hidden = 0
+  for (const row of rows) {
+    if (row.kind === "more") {
+      const match = /^\+(\d+) more lanes$/.exec(row.label)
+      if (match?.[1] !== undefined) hidden += Number(match[1])
+      continue
+    }
+    if (row.kind === "header") {
+      const match = / · \+(\d+) hidden$/.exec(row.tail)
+      if (match?.[1] !== undefined) hidden += Number(match[1])
+    }
+  }
+  return hidden
+}
+
+function stripHiddenTail(header: AgentPanelRow): AgentPanelRow {
+  const tail = header.tail.replace(/ · \+\d+ hidden$/, "")
+  return tail === header.tail ? header : { ...header, tail }
+}
+
 function withHiddenCount(header: AgentPanelRow, hidden: number): AgentPanelRow {
   return hidden > 0 ? { ...header, tail: ` · +${hidden} hidden` } : header
 }
 
+/**
+ * Operator-facing state word. Machine `LaneState` stays snake_case for code;
+ * the board never paints that vocabulary into the terminal.
+ */
+function laneStateWord(state: LaneState): string {
+  switch (state) {
+    case "in_tool":
+      return "in tool"
+    case "stalled":
+      return "stalled"
+    case "working":
+      return "working"
+  }
+}
+
 /**
  * The one-line answer to "is everything fine". Counts run worst-first so that
  * a narrow terminal ellipsizes away the routine tail rather than the trouble.
@@ -366,12 +412,12 @@ function formatAgentRow(
 
   // Prefer main's agentProgress for tool-clock / in_tool / quiet clocks so the
   // board never invents a second stall path. Board presentation still prefixes
-  // the state word (and kind: lane) the way the fleet board reads.
+  // the operator-facing state word (and kind: lane) the way the fleet board reads.
   const progress = agentProgress(progressSession, nowMs, stallMs)
   if (progress !== null) {
     return {
       label,
-      tail: ` · ${state} · ${progress.stat}`,
+      tail: ` · ${laneStateWord(state)} · ${progress.stat}`,
       stalled,
       kind: "lane",
     }