Hold fleet updates to one row each and let bursts settle

Running a real fleet showed both halves of the noise boundary leaking.
A parallel dispatch arrives as one store change per lane, so six lanes
printed six dispatch lines instead of the one decision they were; the
report now settles briefly before observing, and six lanes read as
"6 dispatched". Long worker summaries also wrapped, costing two rows an
update, so a line is clipped to the width a transcript row has.

Author: TheGreatAxios

src/subagent/fleet-report.test.ts

@@ -104,6 +104,23 @@ describe("observeFleet", () => {
     expect(busy.updates).toEqual([]);
   });
 
+  test("an update is one row — a long outcome is clipped, never wrapped", () => {
+    const seeded = observeFleet(createFleetWatch(), [lane({ id: "api" })], T0).watch;
+    const { updates } = observeFleet(
+      seeded,
+      [
+        lane({
+          id: "api",
+          status: "done",
+          report: "Rewired the reporter, added the digest, wired the poll, and updated every affected test in the suite.",
+        }),
+      ],
+      T0 + 1000,
+    );
+    expect(updates[0]!.length).toBeLessThanOrEqual(76);
+    expect(updates[0]).toContain("…");
+  });
+
   test("a dozen lanes landing at once collapse into one tally", () => {
     const before = Array.from({ length: 12 }, (_, i) => lane({ id: `l${i}` }));
     const seeded = observeFleet(createFleetWatch(), before, T0).watch;

src/subagent/fleet-report.ts

@@ -56,7 +56,13 @@ export function createFleetWatch(): FleetWatch {
 const COALESCE_ABOVE = 3;
 
 /** Enough of an outcome to judge it; past this the operator opens the lane. */
-const OUTCOME_CHARS = 72;
+const OUTCOME_CHARS = 56;
+
+/**
+ * One update is one row. A line that wraps doubles the cost of every update on
+ * screen, which is how a report meant to be glanced at turns into a scroll.
+ */
+const MAX_UPDATE_CHARS = 76;
 
 const PREFIX = "fleet";
 
@@ -67,6 +73,13 @@ const PREFIX = "fleet";
  */
 export const FLEET_STALL_POLL_MS = 5_000;
 
+/**
+ * A parallel dispatch lands as one store change per lane, so observing each
+ * one on its own turns a single decision into a line per lane. Settling first
+ * is what lets the tally do its job.
+ */
+export const FLEET_REPORT_SETTLE_MS = 400;
+
 /** Lanes named in a digest before it starts counting instead of listing. */
 const DIGEST_NAMED_LANES = 4;
 
@@ -177,7 +190,10 @@ export function observeFleet(
     lines.push(`${idleSummary(lanes)} — nothing running`);
   }
 
-  return { watch, updates: lines.map((line) => `${PREFIX} · ${line}`) };
+  return {
+    watch,
+    updates: lines.map((line) => clip(`${PREFIX} · ${line}`, MAX_UPDATE_CHARS)),
+  };
 }
 
 function tally(changes: readonly Change[]): string {

src/subagent/index.ts

@@ -10,6 +10,7 @@ export { createSubAgentSessionStore } from "./session-store.js";
 export {
   createFleetWatch,
   fleetDigest,
+  FLEET_REPORT_SETTLE_MS,
   FLEET_STALL_POLL_MS,
   observeFleet,
   type FleetLane,

src/tui/runner.ts

@@ -121,6 +121,7 @@ import {
   createFleetWatch,
   createSubAgentSessionStore,
   fleetDigest,
+  FLEET_REPORT_SETTLE_MS,
   FLEET_STALL_POLL_MS,
   observeFleet,
   taskToolDefinition,
@@ -2212,7 +2213,15 @@ export async function runTUI(initialConfig: Config): Promise<number> {
     fleetWatch = observation.watch;
     for (const update of observation.updates) surfaceSystemNotice(host.shell, update);
   };
-  const unsubscribeFleetReport = subAgentSessions.subscribe(reportFleet);
+  let fleetSettle: ReturnType<typeof setTimeout> | null = null;
+  const unsubscribeFleetReport = subAgentSessions.subscribe(() => {
+    if (fleetSettle !== null) return;
+    fleetSettle = setTimeout(() => {
+      fleetSettle = null;
+      reportFleet();
+    }, FLEET_REPORT_SETTLE_MS);
+    if (typeof fleetSettle.unref === "function") fleetSettle.unref();
+  });
   const fleetStallPoll = setInterval(reportFleet, FLEET_STALL_POLL_MS);
   if (typeof fleetStallPoll.unref === "function") fleetStallPoll.unref();
 
@@ -2317,6 +2326,7 @@ export async function runTUI(initialConfig: Config): Promise<number> {
 
   await host.waitUntilExit();
   clearInterval(fleetStallPoll);
+  if (fleetSettle !== null) clearTimeout(fleetSettle);
   unsubscribeFleetReport();
   // Quitting mid-stream is an abnormal end for the in-flight cycle: nothing
   // downstream delivers its terminal event once the app is gone.