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

package/src/ui/agent-row.ts

@@ -14,6 +14,7 @@ import { pathToFileURL } from "node:url";
 import { type Component, hyperlink, truncateToWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { type Clock, realClock, type TimerHandle } from "../clock.js";
 import { formatClock } from "../model-call.js";
+import { modelSelectionNote } from "../model-selection.js";
 import type { AgentRecord } from "../types.js";
 import { getLifetimeCost, getLifetimeTotal } from "../usage.js";
 import {
@@ -26,6 +27,7 @@ import {
   SPINNER,
   type Theme,
 } from "./agent-widget.js";
+import { fallbackFlag, withLeadingFlag } from "./fallback-flag.js";
 
 /** Lines of the result shown when expanded; the rest is one `get_subagent_result` away. */
 const EXPANDED_RESULT_LINES = 50;
@@ -89,6 +91,7 @@ export function agentRowSummary(
   live: AgentRowLive,
   theme: Theme,
   now: number = Date.now(),
+  width?: number,
 ): string {
   const record = details.agentId ? live.getRecord(details.agentId) : undefined;
   const activity = details.agentId ? live.getActivity(details.agentId) : undefined;
@@ -106,7 +109,10 @@ export function agentRowSummary(
   if (tokenText) parts.push(tokenText);
   if (cost) parts.push(cost);
   if (!finished && details.backgroundHint && elapsed >= 2000) parts.push("(ctrl+b to run in background)");
-  return `${icon} ${parts.map(p => fgPreservingNestedStyles(theme, "dim", p)).join(` ${theme.fg("dim", "·")} `)}`;
+  // Leading, ahead of the status text, which may carry a 300-char error.
+  const flag = fallbackFlag(theme, record?.modelFallback || record?.modelTier ? record : details);
+  const body = parts.map(p => fgPreservingNestedStyles(theme, "dim", p)).join(` ${theme.fg("dim", "·")} `);
+  return width === undefined ? `${icon} ${flag ? `${flag} ` : ""}${body}` : withLeadingFlag(`${icon} `, flag, body, width);
 }
 
 /**
@@ -116,7 +122,9 @@ export function agentRowSummary(
  */
 function tagsLine(details: AgentDetails, theme: Theme): string | undefined {
   const parts = [...(details.modelName ? [details.modelName] : []), ...(details.tags ?? [])];
-  return parts.length > 0 ? theme.fg("dim", `↳ ${parts.join(" · ")}`) : undefined;
+  const flag = fallbackFlag(theme, details);
+  if (parts.length === 0 && !flag) return undefined;
+  return `${theme.fg("dim", "↳")} ${flag ? `${flag} ` : ""}${theme.fg("dim", parts.join(" · "))}`;
 }
 
 /** The transcript as an OSC 8 hyperlink, so a click opens it. */
@@ -189,12 +197,14 @@ export class AgentResultView implements Component {
   ) {}
 
   render(width: number): string[] {
-    const lines = [truncateToWidth(agentRowSummary(this.details, this.live, this.theme, this.clock.now()), width)];
+    const lines = [agentRowSummary(this.details, this.live, this.theme, this.clock.now(), width)];
     if (!this.expanded) return lines;
 
     const record = this.details.agentId ? this.live.getRecord(this.details.agentId) : undefined;
     const tags = tagsLine(this.details, this.theme);
     if (tags) lines.push(truncateToWidth(tags, width));
+    const note = modelSelectionNote(record) || this.details.modelNote;
+    if (note) lines.push(...wrapTextWithAnsi(this.theme.fg("warning", note), width));
     const transcript = record?.outputFile ?? this.details.outputFile;
     if (transcript) lines.push(truncateToWidth(transcriptLink(transcript, this.theme), width));
 

package/src/ui/agent-widget.ts

@@ -11,8 +11,11 @@ import { type AgentManager, isTopLevelAgent } from "../agent-manager.js";
 import { getConfig } from "../agent-types.js";
 import { type Clock, realClock, type TimerHandle } from "../clock.js";
 import { describeModelCall, type ModelCallState } from "../model-call.js";
+import type { ModelFallback } from "../model-resolver.js";
+import type { TierDisclosure } from "../model-tiers.js";
 import type { AgentInvocation, SubagentType, WidgetMode } from "../types.js";
 import { getLifetimeCost, getLifetimeTotal, getSessionContextPercent, type LifetimeUsage, type SessionLike } from "../usage.js";
+import { fallbackFlag } from "./fallback-flag.js";
 
 // ---- Constants ----
 
@@ -83,6 +86,11 @@ export interface AgentDetails {
   backgroundHint?: boolean;
   /** Short label for the model the run used, e.g. "haiku 4.5". */
   modelName?: string;
+  /** Set when a configured model did not resolve and the run fell back to the parent model. */
+  modelNote?: string;
+  /** The structured form of {@link modelNote}, for the one-line label. */
+  modelFallback?: ModelFallback;
+  modelTier?: TierDisclosure;
   /** Notable config tags (e.g. ["thinking: high", "isolated"]). */
   tags?: string[];
   /** Current turn count. */
@@ -106,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`;
 }
 
 /**
@@ -212,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) + "…";
 }
@@ -389,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 }, 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;
@@ -418,6 +448,7 @@ export class AgentWidget {
     const activity = this.agentActivity.get(a.id);
     if (activity) parts.push(formatTurns(activity.turnCount, activity.maxTurns));
     if (a.toolUses > 0) parts.push(`${a.toolUses} tool use${a.toolUses === 1 ? "" : "s"}`);
+    // Not gated by `showModel`: a substituted model is never a cosmetic detail.
     // From the record, not the activity tracker: that entry is deleted the
     // moment an agent finishes, and "what did it cost" is a question asked
     // about finished agents.
@@ -426,7 +457,8 @@ export class AgentWidget {
     parts.push(duration);
 
     const modeTag = modeLabel ? ` ${theme.fg("dim", `(${modeLabel})`)}` : "";
-    return `${icon} ${renderAgentName(a.type, theme, { fallbackColor: "dim" })}${modeTag}  ${theme.fg("dim", a.description)} ${theme.fg("dim", "·")} ${theme.fg("dim", parts.join(" · "))}${statusText}`;
+    const flag = fallbackFlag(theme, a) ? `${fallbackFlag(theme, a)} ` : "";
+    return `${icon} ${flag}${renderAgentName(a.type, theme, { fallbackColor: "dim" })}${modeTag}  ${theme.fg("dim", a.description)} ${theme.fg("dim", "·")} ${theme.fg("dim", parts.join(" · "))}${statusText}`;
   }
 
   /**
@@ -437,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),
     );
 
@@ -466,6 +498,7 @@ export class AgentWidget {
     for (const a of running) {
       const modeLabel = getPromptModeLabel(a.type);
       const modeTag = modeLabel ? ` ${theme.fg("dim", `(${modeLabel})`)}` : "";
+    const flag = fallbackFlag(theme, a) ? `${fallbackFlag(theme, a)} ` : "";
       const elapsed = formatMs(this.clock.now() - a.startedAt);
 
       const bg = this.agentActivity.get(a.id);
@@ -486,10 +519,10 @@ 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));
+        if (bg) parts.push(formatTurns(bg.turnCount, bg.maxTurns));
       if (toolUses > 0) parts.push(`${toolUses} tool use${toolUses === 1 ? "" : "s"}`);
       if (tokenText) parts.push(tokenText);
       if (costText) parts.push(costText);
@@ -499,7 +532,7 @@ export class AgentWidget {
       const activity = bg ? describeActivity(bg.activeTools, bg.responseText, bg.modelCall, this.clock.now()) : "thinking…";
 
       runningLines.push([
-        truncate(theme.fg("dim", "├─") + ` ${theme.fg("accent", frame)} ${renderAgentName(a.type, theme, { bold: true })}${modeTag}  ${theme.fg("muted", a.description)} ${theme.fg("dim", "·")} ${fgPreservingNestedStyles(theme, "dim", statsText)}`),
+        truncate(theme.fg("dim", "├─") + ` ${theme.fg("accent", frame)} ${flag}${renderAgentName(a.type, theme, { bold: true })}${modeTag}  ${theme.fg("muted", a.description)} ${theme.fg("dim", "·")} ${fgPreservingNestedStyles(theme, "dim", statsText)}`),
         truncate(theme.fg("dim", "│  ") + theme.fg("dim", `  ⎿  ${activity}`)),
       ]);
     }
@@ -521,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

@@ -14,6 +14,7 @@ import type { AgentRecord, ViewerMarkdownMode } from "../types.js";
 import { getLifetimeCost, getLifetimeTotal, getSessionContextPercent } from "../usage.js";
 import type { Theme } from "./agent-widget.js";
 import { type AgentActivity, buildInvocationTags, describeActivity, fgPreservingNestedStyles, formatCost, formatDuration, formatSessionTokens, getPromptModeLabel } from "./agent-widget.js";
+import { fallbackFlag } from "./fallback-flag.js";
 import { createViewerKeys, type ViewerKeybindings, type ViewerKeys } from "./viewer-keys.js";
 
 /** Base lines consumed by chrome: top border + header + header sep + footer sep + footer + bottom border. */
@@ -545,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");
@@ -589,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) {
@@ -727,9 +730,11 @@ export class ConversationViewer implements Component, Focusable {
     // models whose short names read alike.
     const { modelName, modelId, tags } = buildInvocationTags(this.record.invocation);
     const model = modelId ?? modelName;
-    const parts = model ? [model, ...tags] : tags;
-    if (parts.length === 0) return undefined;
-    return this.theme.fg("dim", `  ↳ ${parts.join(" · ")}`);
+    const flag = fallbackFlag(this.theme, this.record);
+    const parts = [...(model ? [model] : []), ...tags];
+    if (parts.length === 0 && !flag) return undefined;
+    // The flag leads the (possibly very long) canonical model id.
+    return `${this.theme.fg("dim", "  ↳")} ${flag ? `${flag} ` : ""}${this.theme.fg("dim", parts.join(" · "))}`;
   }
 
   private buildContentLines(width: number): string[] {

package/src/ui/fallback-flag.ts

@@ -0,0 +1,114 @@
+/**
+ * fallback-flag.ts -- the ONE compact indicator for "this agent ran on another
+ * model than configured", shared by every renderer that shows model info.
+ *
+ * Rows are `label + stats` clamped from the right, so anything appended after
+ * unbounded text (a description, an error, a canonical model id) is the first
+ * thing a narrow terminal cuts. The flag is therefore always rendered FIRST and
+ * the rest is truncated around it. Renderers must use these helpers rather than
+ * building their own marker; `test/fallback-flag-renderers.test.ts` walks every
+ * renderer and fails the ones that do not.
+ */
+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. */
+interface FlagTheme {
+  fg(color: string, text: string): string;
+}
+
+/** Anything that can carry the fallback: a record, details or notice details. */
+export interface FallbackCarrier {
+  modelFallback?: unknown;
+  modelNote?: string;
+  modelTier?: TierDisclosure;
+}
+
+/** Whether this tier's answer differs from the member/profile admitted for it. */
+function switchedWithinTier(tier: TierDisclosure): boolean {
+  if (tier.kind !== "routed" && tier.kind !== "static") return false;
+  const baseline = tier.kind === "routed" ? tier.admitted : tier.member;
+  return baseline !== undefined && tier.answered !== undefined && tier.answered !== baseline;
+}
+
+/** Whether `carrier` needs an actionable fallback warning, not merely tier identity. */
+export const hasFallback = (carrier: FallbackCarrier | undefined): boolean => {
+  if (carrier?.modelFallback !== undefined) return true;
+  const tier = carrier?.modelTier;
+  if (!tier) return carrier?.modelNote !== undefined;
+  return tier.kind === "unmapped" || tier.kind === "unavailable" || switchedWithinTier(tier);
+};
+
+/** Plain tier identity/outcome flag, or `[fallback]`; group counts retain the same identity. */
+export function fallbackFlagText(count = 1, carrier?: FallbackCarrier): string {
+  const tier = carrier?.modelTier;
+  const suffix = count > 1 ? ` x${count}` : "";
+  return tier ? `[@${tier.tier}${tier.kind !== "routed" && tier.kind !== "static" ? ` ${tier.kind}` : ""}${suffix}]`
+    : `[fallback${suffix}]`;
+}
+
+/** The themed tier identity or actionable fallback flag for `carrier`. */
+export function fallbackFlag(theme: FlagTheme, carrier: FallbackCarrier | undefined, count = 1): string {
+  if (carrier?.modelTier) return theme.fg(hasFallback(carrier) ? "warning" : "dim", fallbackFlagText(count, carrier));
+  return hasFallback(carrier) ? theme.fg("warning", fallbackFlagText(count, carrier)) : "";
+}
+
+/** 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.
+ *
+ * Normal case: the prefix and the flag are reserved first and `rest` (a string,
+ * or a function of the width left for it) is truncated to what remains.
+ *
+ * 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. 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,
+  flag: string,
+  rest: string | ((inner: number) => string),
+  width: number,
+): string {
+  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);
+    return truncateToWidth(lead + body, width);
+  }
+  const flagWidth = visibleWidth(flag);
+  if (flagWidth <= width) {
+    const inner = width - flagWidth - 1;
+    if (inner < 1 || rest === "") return flag;
+    const body = typeof rest === "function" ? rest(inner) : truncateToWidth(rest, inner);
+    return truncateToWidth(`${flag} ${body}`, width);
+  }
+  return MINIMAL_FLAGS.find(m => visibleWidth(m) <= width) ?? "";
+}