@nredd/pi-subagents 0.22.0-nredd.8 → 0.22.0-nredd.9

package/src/ui/agent-widget.ts

@@ -114,11 +114,21 @@ export function fgPreservingNestedStyles(theme: Theme, color: string, text: stri
   return theme.fg(color, text.replace(/\u001b\[(?:0|39)m/g, reset => `${reset}${styleStart}`));
 }
 
+/**
+ * Format a token count as a bare magnitude: "950", "18.4k", "1.2M". The unit is
+ * picked against the ROUNDED thousands, so 999,999 reads "1.0M", never "1000.0k".
+ * Every token formatter wraps this one so the boundary is fixed in one place.
+ */
+export function formatCompactTokens(count: number): string {
+  const thousands = Number((count / 1_000).toFixed(1));
+  if (thousands >= 1_000) return `${(count / 1_000_000).toFixed(1)}M`;
+  if (count >= 1_000) return `${thousands.toFixed(1)}k`;
+  return `${count}`;
+}
+
 /** Format a token count compactly: "33.8k token", "1.2M token". */
 export function formatTokens(count: number): string {
-  if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M token`;
-  if (count >= 1_000) return `${(count / 1_000).toFixed(1)}k token`;
-  return `${count} token`;
+  return `${formatCompactTokens(count)} token`;
 }
 
 /**
@@ -220,15 +230,27 @@ export function buildInvocationTags(
   if (thinking) tags.push(`thinking: ${thinking}`);
   if (invocation.isolated) tags.push("isolated");
   if (invocation.isolation === "worktree") tags.push("worktree");
+  if (invocation.planMode) tags.push("plan");
   if (invocation.inheritContext) tags.push("inherit context");
   if (invocation.runInBackground) tags.push("background");
   if (invocation.maxTurns != null) tags.push(`max turns: ${invocation.maxTurns}`);
   return { modelName: invocation.modelName, modelId: invocation.modelId, tags };
 }
 
-/** Truncate text to a single line, max `len` chars. */
+/**
+ * The thinking tag from {@link buildInvocationTags} as `think:high`, or "" when
+ * there is none. Both agent lists use it so the configured level cannot read as
+ * a duplicate of the live `thinking · 4s` activity on the same row (#144).
+ */
+export function compactThinkingTag(tags: readonly string[]): string {
+  return (tags.find(tag => tag.startsWith("thinking: ")) ?? "").replace(/^thinking: /, "think:");
+}
+
+/** Truncate text to its first non-blank line, max `len` chars. */
 function truncateLine(text: string, len = 60): string {
-  const line = text.split("\n").find(l => l.trim())?.trim() ?? "";
+  // Trimming the whole text first drops any leading blank lines, so its first
+  // line is the first non-blank one (or "" for blank text).
+  const line = text.trim().split("\n")[0].trimEnd();
   if (line.length <= len) return line;
   return line.slice(0, len) + "…";
 }
@@ -397,9 +419,9 @@ export class AgentWidget {
   }
 
   /** Render a finished agent line. */
-  private renderFinishedLine(a: { id: string; type: SubagentType; status: string; description: string; toolUses: number; startedAt: number; completedAt?: number; error?: string; lifetimeUsage?: LifetimeUsage; modelFallback?: ModelFallback; modelTier?: TierDisclosure }, theme: Theme): string {
+  private renderFinishedLine(a: { id: string; type: SubagentType; status: string; description: string; toolUses: number; startedAt: number; completedAt: number; error?: string; lifetimeUsage?: LifetimeUsage; modelFallback?: ModelFallback; modelTier?: TierDisclosure }, theme: Theme): string {
     const modeLabel = getPromptModeLabel(a.type);
-    const duration = formatMs((a.completedAt ?? this.clock.now()) - a.startedAt);
+    const duration = formatMs(a.completedAt - a.startedAt);
 
     let icon: string;
     let statusText: string;
@@ -447,8 +469,8 @@ export class AgentWidget {
     const allAgents = this.widgetAgents();
     const running = allAgents.filter(a => a.status === "running");
     const queued = allAgents.filter(a => a.status === "queued");
-    const finished = allAgents.filter(a =>
-      a.status !== "running" && a.status !== "queued" && a.completedAt
+    const finished = allAgents.filter((a): a is typeof a & { completedAt: number } =>
+      a.status !== "running" && a.status !== "queued" && !!a.completedAt
       && this.shouldShowFinished(a.id, a.status),
     );
 
@@ -497,7 +519,7 @@ export class AgentWidget {
         // rebuilt so the "(asked X)" annotation survives.
         const { modelName, tags } = buildInvocationTags(a.invocation);
         if (modelName) parts.push(modelName);
-        const thinkingTag = tags.find(tag => tag.startsWith("thinking: "));
+        const thinkingTag = compactThinkingTag(tags);
         if (thinkingTag) parts.push(thinkingTag);
       }
         if (bg) parts.push(formatTurns(bg.turnCount, bg.maxTurns));
@@ -532,18 +554,15 @@ export class AgentWidget {
       if (queuedLine) lines.push(queuedLine);
 
       // Fix last connector: swap ├─ → └─ and │ → space for activity lines.
-      if (lines.length > 1) {
-        const last = lines.length - 1;
-        lines[last] = lines[last].replace("├─", "└─");
-        // If last item is a running agent activity line, fix indent of that line
-        // and fix the header line above it.
-        if (runningLines.length > 0 && !queuedLine) {
-          // The last two lines are the last running agent's header + activity.
-          if (last >= 2) {
-            lines[last - 1] = lines[last - 1].replace("├─", "└─");
-            lines[last] = lines[last].replace("│  ", "   ");
-          }
-        }
+      // Something is active or finished (checked above), so the body is never
+      // empty and `last` is past the heading.
+      const last = lines.length - 1;
+      lines[last] = lines[last].replace("├─", "└─");
+      // If the last item is a running agent, its header and activity are the
+      // last two lines: fix the header's connector and the activity's indent.
+      if (runningLines.length > 0 && !queuedLine) {
+        lines[last - 1] = lines[last - 1].replace("├─", "└─");
+        lines[last] = lines[last].replace("│  ", "   ");
       }
     } else {
       // Overflow — prioritize: running > queued > finished.

package/src/ui/conversation-viewer.ts

@@ -546,7 +546,8 @@ export class ConversationViewer implements Component, Focusable {
     if (this.composer) {
       // Composer row: the Input renders its own `> ` prompt and cursor.
       this.composer.focused = this.focused;
-      lines.push(row(this.composer.render(innerW)[0] ?? ""));
+      // Input always renders exactly one row.
+      lines.push(row(this.composer.render(innerW)[0]));
       footerActions.push({ label: "Enter send", key: "\r" }, { label: "Esc cancel", key: "\x1b" });
       const composeHint = th.fg("dim", "Enter send · Esc cancel");
       const composeLeft = th.fg("accent", "✎ steer");
@@ -590,7 +591,8 @@ export class ConversationViewer implements Component, Focusable {
       return lines;
     }
     // Keep the footer on screen even in a terminal shorter than the chrome.
-    const footer = lines.pop() ?? row("");
+    // Never empty: the header and footer rows were pushed above.
+    const footer = lines.pop()!;
     const output = rows > 0 ? [...lines.slice(0, rows - 1), footer] : [];
     const footerText = stripTerminalSequences(footer);
     for (const action of footerActions) {

package/src/ui/fallback-flag.ts

@@ -9,7 +9,7 @@
  * building their own marker; `test/fallback-flag-renderers.test.ts` walks every
  * renderer and fails the ones that do not.
  */
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { stripTerminalSequences, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import type { TierDisclosure } from "../model-tiers.js";
 
 /** Minimal theme surface, so this module has no dependency on the widgets that use it. */
@@ -56,6 +56,29 @@ export function fallbackFlag(theme: FlagTheme, carrier: FallbackCarrier | undefi
 /** What a flag degrades to when even it does not fit; plain so it cannot depend on a theme. */
 const MINIMAL_FLAGS = ["[fb]", "!"] as const;
 
+/**
+ * Wrap control text into a fixed row budget while preserving both its opening
+ * and final diagnosis around an explicit omitted-rows marker. The budget is at
+ * least three rows: one each for the opening, the marker and the diagnosis.
+ * A non-finite `maxRows` gets that floor rather than poisoning the slices.
+ */
+export function boundedWrappedRows(text: string, width: number, maxRows: number, marker: string): string[] {
+  const rows = wrapTextWithAnsi(text, width);
+  const budget = Number.isFinite(maxRows) ? Math.max(3, Math.trunc(maxRows)) : 3;
+  if (rows.length <= budget) return rows;
+
+  // Reserve a row for the omission marker and favor the final rows: fallback
+  // diagnoses live at the end, while the first row still names the control text.
+  // At least two rows are omitted, so the marker never replaces a single row.
+  const firstCount = Math.max(1, Math.floor((budget - 1) / 2));
+  const lastCount = budget - firstCount - 1;
+  const omitted = rows.length - firstCount - lastCount;
+  const omission = stripTerminalSequences(
+    truncateToWidth(`${marker} ${omitted} more lines`, width, ""),
+  );
+  return [...rows.slice(0, firstCount), omission, ...rows.slice(-lastCount)];
+}
+
 /**
  * `prefix + flag + rest`, never wider than `width`, and the flag is never cut.
  *
@@ -65,7 +88,8 @@ const MINIMAL_FLAGS = ["[fb]", "!"] as const;
  * Narrow case, when `prefix + flag + " "` exceeds `width`: the prefix and then
  * the rest are dropped before the flag is. If the flag alone still does not
  * fit, it degrades to a plain `[fb]`, then `!`. Only a zero width renders
- * nothing.
+ * nothing. An empty string `rest` renders no separator after the flag, so a
+ * caller sizing the flag alone gets just the flag.
  */
 export function withLeadingFlag(
   prefix: string,
@@ -73,7 +97,7 @@ export function withLeadingFlag(
   rest: string | ((inner: number) => string),
   width: number,
 ): string {
-  const lead = flag ? `${prefix}${flag} ` : prefix;
+  const lead = flag ? `${prefix}${flag}${rest === "" ? "" : " "}` : prefix;
   if (!flag || visibleWidth(lead) <= width) {
     const inner = Math.max(0, width - visibleWidth(lead));
     const body = typeof rest === "function" ? rest(inner) : truncateToWidth(rest, inner);
@@ -82,7 +106,7 @@ export function withLeadingFlag(
   const flagWidth = visibleWidth(flag);
   if (flagWidth <= width) {
     const inner = width - flagWidth - 1;
-    if (inner < 1) return flag;
+    if (inner < 1 || rest === "") return flag;
     const body = typeof rest === "function" ? rest(inner) : truncateToWidth(rest, inner);
     return truncateToWidth(`${flag} ${body}`, width);
   }

package/src/ui/fleet-list.ts

@@ -2,6 +2,7 @@
  * fleet-list.ts — Claude Code-style "FleetView" list rendered below the editor.
  *
  * Starts as a one-line state/count summary; ctrl+shift+a toggles the full list.
+ * ctrl+shift+k, pressed twice within three seconds, stops every running agent and workflow.
  * Shows `main` + each running/queued subagent as a navigable list. Pressing ↓ (or
  * ←) at an empty prompt activates the list; ↑/↓ move the selection (filled ● marker),
  * Enter opens the selected agent's live conversation overlay, Esc returns to the prompt.
@@ -20,13 +21,17 @@ import type { RunningDetached } from "../detached-results.js";
 import { describeModelCall } from "../model-call.js";
 import type { AgentRecord, ViewerMarkdownMode } from "../types.js";
 import { getLifetimeCost, getLifetimeTotal } from "../usage.js";
-import { type AgentActivity, buildInvocationTags, fgPreservingNestedStyles, formatCost, type Theme } from "./agent-widget.js";
+import { type AgentActivity, buildInvocationTags, compactThinkingTag, fgPreservingNestedStyles, formatCompactTokens, formatCost, type Theme } from "./agent-widget.js";
 import { ConversationViewer, getConversationOverlayOptions, type ViewerBackgroundAction } from "./conversation-viewer.js";
 import { fallbackFlag, hasFallback, withLeadingFlag } from "./fallback-flag.js";
 import { FleetJournal, type FleetJournalEntry, type FleetSnapshot, fleetAlert, MAX_COMPACT_ALERT_COUNT } from "./fleet-state.js";
 
 /** Matches the todo/monitor disclosure shortcut family; arrows keep their navigation roles. */
 export const FLEET_COLLAPSE_KEY = "ctrl+shift+a";
+/** Stop every running agent and workflow: Claude Code's `ctrl+x ctrl+k`, minus pi's `ctrl+x` (copy). */
+export const STOP_ALL_KEY = "ctrl+shift+k";
+/** A second stop-all press within this window confirms the first. */
+export const STOP_ALL_CONFIRM_MS = 3000;
 /** Quiet-period debounce bounds journal writes per toggle burst; shutdown flushes immediately. */
 export const FLEET_DISCLOSURE_SETTLE_MS = 300;
 
@@ -96,11 +101,7 @@ export function formatFleetElapsed(ms: number): string {
 
 /** `↓ 13.1k tokens` — down-arrow prefix, compact magnitude, plural "tokens". */
 export function formatFleetTokens(count: number): string {
-  let compact: string;
-  if (count >= 1_000_000) compact = `${(count / 1_000_000).toFixed(1)}M`;
-  else if (count >= 1_000) compact = `${(count / 1_000).toFixed(1)}k`;
-  else compact = `${count}`;
-  return `↓ ${compact} tokens`;
+  return `↓ ${formatCompactTokens(count)} tokens`;
 }
 
 /**
@@ -116,21 +117,31 @@ function rightAlign(left: string, right: string, width: number): string {
   return truncateToWidth(leftClamped + " ".repeat(gap) + right, width);
 }
 
-/**
- * Agent-row tail columns, left to right; text pads right, numbers pad left.
- * `drop` ranks how early a column goes on a narrow terminal (1 first); an
- * undefined rank is never dropped, so state, elapsed, tokens and cost survive
- * and the description is what truncates (#144).
- */
-const TAIL_SLOTS = [
-  { align: "end" }, // state: glyph + label
-  { align: "end", drop: 3 }, // model
-  { align: "end", drop: 2 }, // thinking level
-  { align: "end", drop: 1 }, // live model-call activity
-  { align: "start" }, // elapsed
-  { align: "start" }, // tokens
-  { align: "start" }, // cost
-] as const;
+/** One agent-row tail column. */
+interface TailSlot {
+  /**
+   * Pad after the cell, left-aligning it. Unset pads before the cell, so every
+   * other column ends on the same right edge whether or not a row has a value.
+   */
+  readonly padEnd?: true;
+  /**
+   * How early the column goes on a narrow terminal (1 first). Unset is never
+   * dropped, so state, elapsed, tokens and cost survive and the description is
+   * what truncates (#144).
+   */
+  readonly drop?: number;
+}
+
+/** Agent-row tail columns, left to right. */
+const TAIL_SLOTS: readonly TailSlot[] = [
+  { padEnd: true }, // state: glyph + label
+  { drop: 3 }, // model
+  { drop: 2 }, // thinking level
+  { drop: 1 }, // live model-call activity
+  {}, // elapsed
+  {}, // tokens
+  {}, // cost
+];
 
 /** Columns reserved for the bullet, name and the start of the description. */
 const MIN_LEFT_WIDTH = 24;
@@ -220,7 +231,8 @@ export function renderFleetSummary(
       compact.pop();
       flagText = `[${compact.join("")}]`;
     }
-    if (visibleWidth(flagText) > width) flagText = width > 0 ? "!" : "";
+    // `withLeadingFlag` renders nothing at all at zero width.
+    if (visibleWidth(flagText) > width) flagText = "!";
   }
   const flag = theme.fg(failed ? "error" : "warning", flagText);
   const cost = showCost ? formatCost(agents.reduce((sum, agent) => sum + getLifetimeCost(agent.lifetimeUsage), 0)) : "";
@@ -247,6 +259,10 @@ export class FleetList {
   private readonly observedWorkflows = new WeakMap<object, number>();
   /** Quota parking has no AgentRecord; the scheduler supplies its enabled-job count. */
   private parkedSource: () => number = () => 0;
+  /** What the stop-all chord stops; the extension supplies it. */
+  private stopAll: () => { agents: number; workflows: number } = () => ({ agents: 0, workflows: 0 });
+  /** When the stop-all chord was first pressed, while its confirmation window is open. */
+  private stopAllArmedAt: number | undefined;
   /** Whether arrow keys currently navigate the list (vs. flow to the editor). */
   private active = false;
   /** 0 = `main`, 1..N = subagents. */
@@ -357,6 +373,29 @@ export class FleetList {
     this.parkedSource = source;
   }
 
+  /** Inject what the stop-all chord stops, without coupling the fleet to workflows or orphans. */
+  setStopAll(stop: () => { agents: number; workflows: number }): void {
+    this.stopAll = stop;
+  }
+
+  /**
+   * The stop-all chord: the first press arms it and says so, a second within
+   * {@link STOP_ALL_CONFIRM_MS} stops everything. A press after the window
+   * re-arms rather than stopping, so a stray key never costs a run.
+   */
+  private pressStopAll(): void {
+    const now = this.clock.now();
+    if (this.stopAllArmedAt === undefined || now - this.stopAllArmedAt > STOP_ALL_CONFIRM_MS) {
+      this.stopAllArmedAt = now;
+      this.ui?.notify(`Press ${STOP_ALL_KEY} again within ${STOP_ALL_CONFIRM_MS / 1000}s to stop every running agent and workflow.`, "warning");
+      return;
+    }
+    this.stopAllArmedAt = undefined;
+    const { agents, workflows } = this.stopAll();
+    this.ui?.notify(agents + workflows === 0 ? "Nothing was running." : `Stopped ${agents} agent(s) and ${workflows} workflow(s).`, "info");
+    this.update();
+  }
+
   // ---- Lifecycle ----
 
   setEnabled(enabled: boolean): void {
@@ -422,12 +461,10 @@ export class FleetList {
         this.widgetRegistered = false;
         this.tui = undefined;
       }
-      // A just-spawned agent has no session until its runner finishes binding
-      // extensions, and nothing else calls update() until the child's first model
-      // event, which a slow first response delays by minutes. Keep ticking while
-      // one is starting so its row appears as soon as the session exists.
-      if (this.enabled && this.hasStartingAgent()) this.ensureTimer();
-      else if (this.timer) { this.timer.cancel(); this.timer = undefined; }
+      // A just-spawned agent with no session yet counts in `hasRows` (the
+      // summary includes pending starts), and that path's `ensureTimer()` keeps
+      // ticking until its session appears. So nothing here is starting: stop.
+      if (this.timer) { this.timer.cancel(); this.timer = undefined; }
       this.active = false;
       this.selectedIndex = 0;
       return;
@@ -462,12 +499,6 @@ export class FleetList {
     }
   }
 
-  /** Whether a top-level agent is live but not yet listable (no session yet). */
-  private hasStartingAgent(): boolean {
-    return this.manager.listAgents().some(a =>
-      isTopLevelAgent(a) && !a.session && (a.status === "running" || a.status === "queued"));
-  }
-
   // ---- Roster ----
 
   /**
@@ -499,7 +530,7 @@ export class FleetList {
       const live = records.get(alert.id);
       if (!live || !isOutstandingFailure(live)) records.set(`fleet-alert:${alert.id}`, {
         id: alert.id, type: alert.type, description: alert.description, status: alert.state,
-        startedAt: alert.timestamp, completedAt: alert.timestamp, toolUses: 0, compactionCount: 0,
+        startedAt: alert.timestamp, completedAt: alert.timestamp, toolUses: 0, compactionCount: 0, depth: 1,
         lifetimeUsage: { input: 0, output: 0, cacheWrite: 0, cost: 0 },
       });
     }
@@ -587,7 +618,6 @@ export class FleetList {
   private clampSelection(): void {
     const max = this.roster().length - 1;
     if (this.selectedIndex > max) this.selectedIndex = Math.max(0, max);
-    if (this.selectedIndex < 0) this.selectedIndex = 0;
   }
 
   // ---- Key handling ----
@@ -618,6 +648,11 @@ export class FleetList {
       this.toggleCollapse();
       return { consume: true };
     }
+    if (matchesKey(data, STOP_ALL_KEY)) {
+      // A held key must not confirm its own first press.
+      if (!isKeyRepeat(data)) this.pressStopAll();
+      return { consume: true };
+    }
 
     if (!this.active) {
       // Activate: ↓ or ← at an empty prompt moves focus into the list.
@@ -648,7 +683,7 @@ export class FleetList {
       return { consume: true };
     }
     if (matchesKey(data, "escape")) { this.deactivate(); return { consume: true }; }
-    if (matchesKey(data, Key.enter)) { this.openSelected(); return { consume: true }; }
+    if (matchesKey(data, Key.enter)) { this.openSelected(this.ui); return { consume: true }; }
 
     // Any other key cancels navigation and flows to the editor.
     this.deactivate();
@@ -677,7 +712,7 @@ export class FleetList {
     this.update();
   }
 
-  private openSelected(): void {
+  private openSelected(ui: FleetUICtx): void {
     const entry = this.roster()[this.selectedIndex];
     if (!entry || entry.kind === "main") {
       // `main` = return to the prompt; the native transcript is already shown.
@@ -686,7 +721,7 @@ export class FleetList {
     }
     if (entry.kind === "workflow") {
       if (!this.workflowSource?.().some(run => run.id === entry.workflow.id) || !this.openWorkflow) {
-        this.ui?.notify(`workflow: ${entry.workflow.name} (${entry.workflow.status}).`, "error");
+        ui.notify(`workflow: ${entry.workflow.name} (${entry.workflow.status}).`, "error");
         this.acknowledgeFailure(entry.workflow.id);
         this.update();
         return;
@@ -702,17 +737,16 @@ export class FleetList {
       return;
     }
     const record = entry.record;
-    if (!this.ui) return;
     const session = this.options.sessionFor ? this.options.sessionFor(record) : record.session;
     if (!session) {
       if (isOutstandingFailure(record)) {
-        this.ui.notify(record.error ?? `${record.type}: ${record.description} (${record.status}).`, "error");
+        ui.notify(record.error ?? `${record.type}: ${record.description} (${record.status}).`, "error");
         markConsumed(record, this.clock.now());
         this.acknowledgeFailure(record.id);
         this.update();
         return;
       }
-      this.ui.notify(`Agent is ${record.status} — no session available.`, "info");
+      ui.notify(`Agent is ${record.status} — no session available.`, "info");
       return;
     }
     const activity = this.activityFor(record.id);
@@ -720,7 +754,7 @@ export class FleetList {
     this.viewingAgentId = record.id;
     let overlayOptions = getConversationOverlayOptions({ mode: "regular" });
 
-    void this.ui.custom<undefined>(
+    void ui.custom<undefined>(
       (tui, theme, keybindings, done) => {
         overlayOptions = getConversationOverlayOptions(tui);
         this.viewerClose = () => done(undefined);
@@ -814,8 +848,8 @@ export class FleetList {
     const start = selRow < visible ? 0 : selRow - visible + 1;
     const hiddenBelow = rows.length - (start + visible);
 
-    // Both indicator slots remain in the row block, blank at an edge, so every
-    // overflowing roster has the same height.
+    // Keep both indicator slots in the row-block budget. Empty edge slots go
+    // below the visible content, never between main and the first child.
     // Column widths come from EVERY agent row, not the window, so scrolling
     // never shifts a column; a column too wide for the terminal is dropped
     // lowest-value first, never state, elapsed, tokens or cost.
@@ -835,18 +869,20 @@ export class FleetList {
     );
     if (start > 0) {
       lines.push(rightAlign("", theme.fg("dim", `↑ ${start} more: ${summarizeHidden(rows.slice(0, start))}`), width));
-    } else if (overflow) lines.push("");
+    }
     for (let a = start; a < start + visible; a++) {
       const row = rows[a];
       lines.push(
         row.kind === "workflow" ?
           this.renderWorkflowRow(a + 1, sel, row.workflow, width, theme)
-        : this.renderAgentRow(a + 1, sel, row.record, width, theme, cells.get(row.record) ?? [], colWidths),
+        // Every agent row's cells were computed above.
+        : this.renderAgentRow(a + 1, sel, row.record, width, theme, cells.get(row.record)!, colWidths),
       );
     }
     if (hiddenBelow > 0) {
       lines.push(rightAlign("", theme.fg("dim", `↓ ${hiddenBelow} more: ${summarizeHidden(rows.slice(start + visible))}`), width));
     } else if (overflow) lines.push("");
+    if (start === 0 && overflow) lines.push("");
     // pi stacks below-editor widgets directly on its footer with no spacer (#351).
     lines.push("");
 
@@ -888,7 +924,7 @@ export class FleetList {
       return used.reduce((sum, w) => sum + w, 0) + 3 * Math.max(0, used.length - 1);
     };
     const droppable = TAIL_SLOTS
-      .map((slot, i) => ({ i, rank: "drop" in slot ? slot.drop : 0 }))
+      .map((slot, i) => ({ i, rank: slot.drop ?? 0 }))
       .filter(c => c.rank > 0)
       .sort((x, y) => x.rank - y.rank);
     for (const { i } of droppable) {
@@ -911,9 +947,7 @@ export class FleetList {
       // Leading, and paired: a thinking level means nothing without its model.
       const { modelName, tags } = buildInvocationTags(record.invocation);
       model = modelName ?? "";
-      // `think:high` here, so the configured level cannot read as a duplicate
-      // of the live `thinking · 4s` activity beside it.
-      thinking = (tags.find(tag => tag.startsWith("thinking: ")) ?? "").replace(/^thinking: /, "think:");
+      thinking = compactThinkingTag(tags);
     }
     const state = agentState(record.status);
     // What the in-flight model call is doing, only while the agent is running:
@@ -952,8 +986,9 @@ export class FleetList {
     // same cells on every row; an all-empty column is dropped.
     let stats = TAIL_SLOTS.map((slot, i) => {
       if (colWidths[i] === 0) return undefined;
-      const pad = " ".repeat(colWidths[i] - visibleWidth(cells[i] ?? ""));
-      return slot.align === "end" ? (cells[i] ?? "") + pad : pad + (cells[i] ?? "");
+      // `tailCells` fills every slot, with "" where a row has no value.
+      const pad = " ".repeat(colWidths[i] - visibleWidth(cells[i]));
+      return slot.padEnd ? cells[i] + pad : pad + cells[i];
     }).filter((c): c is string => c !== undefined).join(" · ");
     let flag = fallbackFlag(theme, record);
     if (flag && visibleWidth(prefix + flag) + 1 + visibleWidth(stats) > width) {
@@ -962,7 +997,7 @@ export class FleetList {
       // the flag, before sacrificing any spend cell. Rendering an empty body in
       // the flag budget selects [fb] or ! with the same policy as every renderer.
       const flagBudget = Math.max(1, width - visibleWidth(prefix) - visibleWidth(stats) - 1);
-      flag = withLeadingFlag("", flag, "", flagBudget).trimEnd();
+      flag = withLeadingFlag("", flag, "", flagBudget);
     }
     // Every row preserves spend, not just rows carrying a fallback marker.
     const markerWidth = flag ? visibleWidth(flag) + 1 : 0;

package/src/ui/notification-view.ts

@@ -46,8 +46,10 @@ export function noticeSummary(d: NotificationDetails, theme: Theme, showCost: bo
   // from the right, and a substituted model must not be what gets cut.
   const flag = fallbackFlag(theme, d) ? `${fallbackFlag(theme, d)} ` : "";
   const head = `${icon(d, theme)} ${flag}${theme.bold(d.description)}`;
+  // Ahead of the stats for the same reason: truncation must not cut it.
+  const resume = d.resumeHint ? [theme.fg("warning", `resume ${d.id} to continue`)] : [];
   const stats = statParts(d, showCost).map(p => theme.fg("dim", p));
-  return [head, ...stats].join(dot);
+  return [head, ...resume, ...stats].join(dot);
 }
 
 /** `3 agents finished · ✓ a, ✓ b, ✗ c`. */
@@ -83,6 +85,7 @@ function detailLines(d: NotificationDetails, theme: Theme, showCost: boolean, in
   stats.push(...statParts(d, showCost));
   if (stats.length > 0) lines.push(indent + theme.fg("dim", stats.join(" · ")));
   if (d.error) lines.push(indent + theme.fg("error", d.error));
+  if (d.resumeHint) lines.push(indent + theme.fg("warning", d.resumeHint));
   if (d.modelNote) lines.push(indent + theme.fg("warning", d.modelNote));
   for (const line of d.resultPreview.split("\n").slice(0, EXPANDED_PREVIEW_LINES)) {
     lines.push(indent + theme.fg("dim", line));

package/src/ui/workflow-card.ts

@@ -45,7 +45,7 @@ import {
   type WorkflowEntry,
   type WorkflowRunStatus,
 } from "../workflow/progress.js";
-import type { Theme } from "./agent-widget.js";
+import { formatCompactTokens, type Theme } from "./agent-widget.js";
 import { fallbackFlagText, hasFallback } from "./fallback-flag.js";
 
 /**
@@ -184,13 +184,6 @@ export interface WorkflowCardInput {
  * Formatting
  * ------------------------------------------------------------------------- */
 
-/** `18.4k` / `1.2M` — bare magnitude, since the row already reads as a stat. */
-export function formatCompactTokens(count: number): string {
-  if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
-  if (count >= 1_000) return `${(count / 1_000).toFixed(1)}k`;
-  return `${count}`;
-}
-
 /**
  * One label for the model pair. A fallback that never differed from the primary
  * would just be noise, so it only shows when the run actually has two models in