@cad0p/pi-subagents-tintinweb 0.14.2 → 0.22.0

package/src/types.ts

@@ -17,8 +17,18 @@ export const DEFAULT_AGENT_NAMES = ["general-purpose", "Explore", "Plan"] as con
 /** Memory scope for persistent agent memory. */
 export type MemoryScope = "user" | "project" | "local";
 
-/** Isolation mode for agent execution. */
-export type IsolationMode = "worktree";
+/**
+ * Isolation mode for agent execution.
+ *
+ * `"off"` exists for the caller's benefit, not the runtime's: models that fill
+ * every optional parameter had no legal way to decline a single-value
+ * `isolation` field and kept spawning worktrees they had just reasoned their
+ * way out of. It is an input spelling only — `resolveAgentInvocationConfig`
+ * collapses it to `undefined`, so nothing downstream sees a value other than
+ * `"worktree"`. In an agent file it is a genuine veto, since agent config
+ * outranks tool-call params.
+ */
+export type IsolationMode = "worktree" | "off";
 
 /** Unified agent configuration — used for both default and user-defined agents. */
 export interface AgentConfig {
@@ -38,26 +48,44 @@ export interface AgentConfig {
   excludeExtensions?: string[];
   /** true = inherit all, string[] = only listed, false = none */
   skills: true | string[] | false;
+  /** Child-session model scope (`ctx.scopedModels`). true/undefined = inherit
+   *  the parent session's resolved scope, string[] = only the listed
+   *  `provider/modelId` entries, false = no scope. Controls which models the
+   *  child session offers for cycling and to in-session extensions that read
+   *  the scope (e.g. pi-fallback-provider's settle-boundary fallback). */
+  scopedModels?: true | string[] | false;
   model?: string;
   thinking?: ThinkingLevel;
   maxTurns?: number;
-  /** Persist this subagent as a normal pi session instead of keeping it in memory only. */
+  /** Keep this subagent's pi session file after the run settles. Every run
+   *  writes a session file while it runs (crash recovery); without this the file
+   *  is deleted when the agent record is removed — the 10-minute eviction or a
+   *  session switch. */
   persistSession?: boolean;
   /** Write the subagent's .output transcript. Defaults to true; false suppresses only that transcript. */
   outputTranscript?: boolean;
-  /** Optional session directory used when persistSession is true. Omitted = pi's normal session location. */
+  /** Optional directory for the run's pi session file. Omitted = pi's normal session location. */
   sessionDir?: string;
+  /**
+   * Nested delegation, off by default: undefined = no nested tools;
+   * "all" = any enabled agent; string[] = only those agent types.
+   */
+  allowedSubagents?: "all" | string[];
+  /** Per-agent nesting cap. Can only tighten the inherited
+   *  `maxSubagentDepth`, never raise it. Omitted = inherit. */
+  maxSubagentDepth?: number;
   systemPrompt: string;
   promptMode: "replace" | "append";
   /** Default for spawn: fork parent conversation. undefined = caller decides. */
   inheritContext?: boolean;
-  /** Default for spawn: run in background. undefined = caller decides. */
-  runInBackground?: boolean;
   /** Default for spawn: no extension tools. undefined = caller decides. */
   isolated?: boolean;
   /** Persistent memory scope — agents with memory get a persistent directory and MEMORY.md */
   memory?: MemoryScope;
-  /** Isolation mode — "worktree" runs the agent in a temporary git worktree */
+  /**
+   * Isolation mode — "worktree" runs the agent in a temporary git worktree,
+   * "off" refuses one even when the caller asks (frontmatter outranks params).
+   */
   isolation?: IsolationMode;
   /** true = this is an embedded default agent (informational) */
   isDefault?: boolean;
@@ -65,20 +93,16 @@ export interface AgentConfig {
   enabled?: boolean;
   /** Where this agent was loaded from */
   source?: "default" | "project" | "global";
+  /** Path of the .md it was loaded from. Unset for embedded defaults. */
+  sourcePath?: string;
 }
 
-export type JoinMode = 'async' | 'group' | 'smart';
-
-export type ResultPreviewMode = "plain" | "markdown";
-
 /**
  * Display mode for the persistent above-editor agent widget.
- * - `all`: show every agent (foreground + background).
- * - `background`: hide foreground agents (they already render inline as the
- *   Agent tool result, #118); show background/queued/scheduled/RPC.
+ * - `all`: show every agent.
  * - `off`: hide the widget entirely.
  */
-export type WidgetMode = 'all' | 'background' | 'off';
+export type WidgetMode = 'all' | 'off';
 
 export interface AgentRecord {
   id: string;
@@ -91,10 +115,21 @@ export interface AgentRecord {
   startedAt: number;
   completedAt?: number;
   session?: AgentSession;
+  /** Resolved `persist_session` for this run, captured at spawn so the removal
+   *  path never re-resolves the agent registry. A resume reuses the record and
+   *  therefore its first run's decision. */
+  persistSession?: boolean;
   abortController?: AbortController;
   promise?: Promise<string>;
-  groupId?: string;
-  joinMode?: JoinMode;
+  /** Whether the run promise has fully unwound. Tri-state: `undefined` = no run
+   *  began — a fresh queued record, or a start that failed in `drainQueue`
+   *  before the counter/`settled` write; `false` = a run is in flight or a
+   *  `stopped` run's promise is still settling; `true` = the completion tail
+   *  finished, or a queued record was stopped before it ever started.
+   *  `startAgent` and `resume` set `false`; `afterRun` and a queued stop set
+   *  `true`. Resuming keys on `=== false` so a record that never ran is not
+   *  blocked. */
+  settled?: boolean;
   /** Set when result was already consumed via get_subagent_result — suppresses completion notification. */
   resultConsumed?: boolean;
   /** Steering messages queued before the session was ready. */
@@ -103,8 +138,6 @@ export interface AgentRecord {
   worktree?: { path: string; branch: string; baseSha: string; workPath: string };
   /** Worktree cleanup result after agent completion. */
   worktreeResult?: { hasChanges: boolean; branch?: string };
-  /** The tool_use_id from the original Agent tool call. */
-  toolCallId?: string;
   /** Path to the streaming output transcript file. */
   outputFile?: string;
   /** Cleanup function for the output file stream subscription. */
@@ -117,14 +150,16 @@ export interface AgentRecord {
   lifetimeUsage: LifetimeUsage;
   /** Number of times this agent's session has compacted. Initialized to 0 at spawn. */
   compactionCount: number;
-  /** Cumulative agentic turn count, incremented via the `onTurnEnd` callback.
-   *  Initialized to 1 at spawn (record construction) to match the activity
-   *  tracker's `turnCount: 1`, then stamped with the completed-turn count as
-   *  each turn ends. A second source exists in the `Agent` tool's execute
-   *  closure (the closure-local `AgentActivity.turnCount` used for the live
-   *  widget), which is unreachable from `get_subagent_result`'s separate execute
-   *  — hence the record needs its own field. `get_subagent_result` surfaces it
-   *  in its running header; the `checkpoint` tool reads it as the turn label. */
+  /** Run-local agentic turn count, stamped via the `onTurnEnd` callback.
+   *  Initialized to 1 at spawn and reset to 1 when a resume starts, and zeroed
+   *  when a record is stopped before its run starts (a never-started report
+   *  carries no turn), so it describes the current run; the record's `toolUses`
+   *  stays cumulative across resumes. A second source exists in the `Agent`
+   *  tool's execute closure (the closure-local `AgentActivity.turnCount` used
+   *  for the live widget), which is unreachable from `get_subagent_result`'s
+   *  separate execute — hence the record needs its own field.
+   *  `get_subagent_result` surfaces it in its running header;
+   *  the `checkpoint` tool reads it as the turn label. */
   turnCount?: number;
   /** Latest checkpoint written by the subagent's `checkpoint` tool call.
    *  Undefined until the subagent calls the tool. The full history lives in
@@ -146,19 +181,22 @@ export interface AgentRecord {
   /** The child session's ID, set at spawn. The `checkpoint` tool reads
    *  ctx.sessionManager.getSessionId() to find its own record. */
   sessionId?: string;
-  /**
-   * Whether this agent was spawned to run in the background. Tri-state, set at
-   * spawn from `SpawnOptions.isBackground`: `true` = background, `false` =
-   * foreground (has an inline Agent tool-result surface), `undefined` = the
-   * caller never declared it (e.g. a cross-extension RPC spawn, which is detached
-   * and has no inline surface). The widget's background-only filter keys off this
-   * — and excludes only explicit `false`, so `undefined` agents stay visible.
-   * Reliable across ALL spawn paths, unlike the UI-only `invocation` snapshot,
-   * which only the Agent-tool path populates.
-   */
-  isBackground?: boolean;
   /** Resolved spawn params, captured for UI display. Fixed at spawn time. */
   invocation?: AgentInvocation;
+  /** Nesting depth: a top-level subagent is 1, its children 2, and so on. */
+  depth?: number;
+  /** Set on records spawned by a nested delegation tool: the owning agent's id.
+   *  Nested records are reachable only through their parent's scoped tools, so
+   *  every top-level surface (notification, widget, `/agents`, RPC, the Agent
+   *  tool) filters them out. */
+  parentAgentId?: string;
+  /** Effective nesting cap inherited by this branch, so a child hands its own
+   *  cap down instead of re-reading the process setting. */
+  maxSubagentDepth?: number;
+  /** Session id of the root (main) session this branch descends from. Nested
+   *  spawns inherit it so their transcripts file under the same session
+   *  directory as their ancestors' instead of the child session's own id. */
+  rootSessionId?: string;
   /** Effective max turns applied to the agent's run — caller-supplied value,
    *  then the agent-config value, then the settings default
    *  (`getDefaultMaxTurns()`), then normalized. Captured at spawn so
@@ -169,34 +207,33 @@ export interface AgentRecord {
   effectiveMaxTurns?: number;
 }
 
+/**
+ * What a session reports as its level: pi's `ThinkingLevel` plus the `"off"` a
+ * model with thinking disabled reports. Display-only — spawning still takes a
+ * `ThinkingLevel`, so this widening cannot leak into an invocation.
+ */
+export type EffectiveThinkingLevel = ThinkingLevel | "off";
+
 export interface AgentInvocation {
-  /** Short display name, e.g. "haiku" — only set when different from parent. */
+  /** Short display name for tight rows, e.g. "haiku 4.5". Always set once known. */
   modelName?: string;
-  thinking?: ThinkingLevel;
+  /** Canonical `provider/id`, for surfaces with room to disambiguate providers. */
+  modelId?: string;
+  /** The level actually in effect, once a session exists to report one. */
+  thinking?: EffectiveThinkingLevel;
+  /**
+   * What the caller asked for, kept only when they did not get it — pi clamped
+   * the level to the model's capabilities. The snapshot exists to answer "did
+   * the spawn honor my instructions?", which it cannot do if the request is
+   * lost, so it is never overwritten once set.
+   */
+  requestedThinking?: EffectiveThinkingLevel;
   maxTurns?: number;
   isolated?: boolean;
   inheritContext?: boolean;
-  runInBackground?: boolean;
   isolation?: IsolationMode;
 }
 
-/** Details attached to custom notification messages for visual rendering. */
-export interface NotificationDetails {
-  id: string;
-  description: string;
-  status: string;
-  toolUses: number;
-  turnCount: number;
-  maxTurns?: number;
-  totalTokens: number;
-  durationMs: number;
-  outputFile?: string;
-  error?: string;
-  resultPreview: string;
-  /** Additional agents in a group notification. */
-  others?: NotificationDetails[];
-}
-
 export interface EnvInfo {
   isGitRepo: boolean;
   branch: string;
@@ -244,4 +281,10 @@ export interface ScheduleStoreData {
   /** For future migrations. */
   version: 1;
   jobs: ScheduledSubagent[];
+  /**
+   * Records shadowed by an earlier duplicate with the same id. Written back
+   * verbatim, never promoted to live jobs; deleting an id purges its shadowed
+   * records too.
+   */
+  shadowed?: ScheduledSubagent[];
 }

package/src/ui/agent-widget.ts

@@ -8,8 +8,9 @@
 import { truncateToWidth } from "@earendil-works/pi-tui";
 import type { AgentManager } from "../agent-manager.js";
 import { getConfig } from "../agent-types.js";
+import { safeTruncate, stripControlChars, toSingleLine } from "../text-safety.js";
 import type { AgentInvocation, SubagentType, WidgetMode } from "../types.js";
-import { getLifetimeTotal, getSessionContextPercent, type LifetimeUsage, type SessionLike } from "../usage.js";
+import { getLifetimeCost, getLifetimeTotal, getSessionContextPercent, type LifetimeUsage, type SessionLike } from "../usage.js";
 
 // ---- Constants ----
 
@@ -71,12 +72,8 @@ export interface AgentDetails {
   toolUses: number;
   tokens: string;
   durationMs: number;
-  status: "queued" | "running" | "completed" | "steered" | "aborted" | "stopped" | "error" | "background";
-  /** Human-readable description of what the agent is currently doing. */
-  activity?: string;
-  /** Current spinner frame index (for animated running indicator). */
-  spinnerFrame?: number;
-  /** Short model name if different from parent (e.g. "haiku", "sonnet"). */
+  status: "running" | "completed" | "steered" | "aborted" | "stopped" | "error" | "background";
+  /** Short label for the model the run used, e.g. "haiku 4.5". */
   modelName?: string;
   /** Notable config tags (e.g. ["thinking: high", "isolated"]). */
   tags?: string[];
@@ -84,6 +81,8 @@ export interface AgentDetails {
   turnCount?: number;
   /** Effective max turns (undefined = unlimited). */
   maxTurns?: number;
+  /** Estimated cost in USD; 0 when the model has no pricing data. */
+  cost?: number;
   agentId?: string;
   error?: string;
 }
@@ -104,6 +103,33 @@ export function formatTokens(count: number): string {
   return `${count} token`;
 }
 
+/**
+ * Format a cost as `~$0.0042`, or "" when there is nothing to show.
+ *
+ * The tilde is load-bearing: this is pi's own estimate from the model's listed
+ * rates, not a billed figure, and the surfaces that print it sit next to token
+ * counts that ARE exact.
+ *
+ * Nothing is printed for zero, which is also what a model with no pricing data
+ * reports: `$0.00` beside a local model's tokens would claim its cost was
+ * measured and found to be nothing, rather than never measured at all. For the
+ * same reason a real cost too small for four decimals reads `<$0.0001` — it was
+ * measured, and rounding it to `~$0.0000` would say the opposite.
+ */
+export function formatCost(cost: number): string {
+  // Also catches NaN and Infinity: a non-finite total would otherwise render
+  // "~$Infinity" through toFixed.
+  if (!Number.isFinite(cost) || cost <= 0) return "";
+  if (cost < 0.0001) return "<$0.0001";
+  if (cost >= 1) return `~$${cost.toFixed(2)}`;
+  // Under a dollar: cents at minimum, four decimals at most, nothing trailing.
+  // Most single runs land between a tenth of a cent and a dime, where rounding
+  // to cents would collapse a 4x difference in spend into the same figure.
+  const rounded = Number(cost.toFixed(4));
+  const decimals = (String(rounded).split(".")[1] ?? "").length;
+  return `~$${rounded.toFixed(Math.max(2, decimals))}`;
+}
+
 /**
  * Token count with optional context-fill % and compaction-count annotations.
  * Thresholds for percent: <70% dim, 70–85% warning, ≥85% error.
@@ -160,26 +186,37 @@ export function getPromptModeLabel(type: SubagentType): string | undefined {
   return config.promptMode === "append" ? "twin" : undefined;
 }
 
-/** Mode label is not included — callers add it where they want it. */
+/**
+ * Mode label is not included — callers add it where they want it.
+ *
+ * Both model forms come back so each surface can pick by width; the
+ * "(asked X)" annotation is applied here rather than by callers, so a level the
+ * spawn did not honor cannot be rendered as though it had been.
+ */
 export function buildInvocationTags(
   invocation: AgentInvocation | undefined,
-): { modelName?: string; tags: string[] } {
+): { modelName?: string; modelId?: string; tags: string[] } {
   const tags: string[] = [];
   if (!invocation) return { tags };
-  if (invocation.thinking) tags.push(`thinking: ${invocation.thinking}`);
+  // The effective value with the request kept beside it, e.g. "low (asked max)":
+  // pi clamped the level to what the model supports.
+  const thinking = invocation.thinking && invocation.requestedThinking && invocation.requestedThinking !== invocation.thinking
+    ? `${invocation.thinking} (asked ${invocation.requestedThinking})`
+    : invocation.thinking;
+  if (thinking) tags.push(`thinking: ${thinking}`);
   if (invocation.isolated) tags.push("isolated");
   if (invocation.isolation === "worktree") tags.push("worktree");
   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, tags };
+  return { modelName: invocation.modelName, modelId: invocation.modelId, tags };
 }
 
 /** Truncate text to a single line, max `len` chars. */
 function truncateLine(text: string, len = 60): string {
-  const line = text.split("\n").find(l => l.trim())?.trim() ?? "";
+  const raw = text.split("\n").find(l => l.trim())?.trim() ?? "";
+  const line = stripControlChars(raw);
   if (line.length <= len) return line;
-  return line.slice(0, len) + "…";
+  return safeTruncate(line, len) + "…";
 }
 
 /** Build a human-readable activity string from currently-running tools or response text. */
@@ -233,30 +270,35 @@ export class AgentWidget {
     private agentActivity: Map<string, AgentActivity>,
     /**
      * Read live at render time. Selects which agents the widget shows — see
-     * `WidgetMode`. Defaults to `"all"` when a caller supplies no policy; the
-     * extension supplies one defaulting to `"background"`.
+     * `WidgetMode`. Defaults to `"all"`; the extension supplies the same default.
      */
     private mode: () => WidgetMode = () => "all",
+    /**
+     * Read live at render time, like `mode`. Whether running agents show an
+     * estimated cost beside their token count. Defaults to off — the extension
+     * supplies the user's `showCost` setting.
+     */
+    private showCost: () => boolean = () => false,
+    /**
+     * Read live at render time, like `mode`. Whether running agents name the
+     * model driving them and the thinking level it is running at. Defaults to
+     * off — the extension supplies the user's `showModel` setting — because the
+     * row is already dense and the same pair is on the tool result and in the
+     * conversation viewer unconditionally.
+     */
+    private showModel: () => boolean = () => false,
   ) {}
 
   /**
    * Agents eligible for the widget, per the current `WidgetMode`:
    *   - `off`: none (the widget's existing empty-state path hides it entirely).
-   *   - `background`: drop only agents *known* to be foreground
-   *     (`isBackground === false`); keep everything else — background, queued,
-   *     scheduled, or RPC-spawned (`undefined`). Keying off the `isBackground`
-   *     record flag rather than the UI-only `invocation` snapshot (which only the
-   *     Agent-tool path sets), and excluding rather than allow-listing, means
-   *     only proven-foreground runs drop out — nothing else silently vanishes.
    *   - `all`: every agent.
    */
   private widgetAgents() {
-    const all = this.manager.listAgents();
-    switch (this.mode()) {
-      case "off": return [];
-      case "background": return all.filter(a => a.isBackground !== false);
-      default: return all;
-    }
+    if (this.mode() === "off") return [];
+    // Nested children are reachable only through their parent's scoped tools;
+    // showing them here would offer rows nothing in this session can act on.
+    return this.manager.listAgents().filter((a) => !a.parentAgentId);
   }
 
   /** Set the UI context (grabbed from first tool execution). */
@@ -305,9 +347,14 @@ export class AgentWidget {
     }
   }
 
+  /** Clear the finished-linger latch when a record starts a new run (resume). */
+  markRunning(agentId: string) {
+    this.finishedTurnAge.delete(agentId);
+  }
+
   /** Render a finished agent line. */
-  private renderFinishedLine(a: { id: string; type: SubagentType; status: string; description: string; toolUses: number; startedAt: number; completedAt?: number; error?: string }, theme: Theme): string {
-    const name = getDisplayName(a.type);
+  private renderFinishedLine(a: { id: string; type: SubagentType; status: string; description: string; toolUses: number; startedAt: number; completedAt?: number; error?: string; lifetimeUsage?: LifetimeUsage }, theme: Theme): string {
+    const name = toSingleLine(getDisplayName(a.type));
     const modeLabel = getPromptModeLabel(a.type);
     const duration = formatMs((a.completedAt ?? Date.now()) - a.startedAt);
 
@@ -324,7 +371,8 @@ export class AgentWidget {
       statusText = theme.fg("dim", " stopped");
     } else if (a.status === "error") {
       icon = theme.fg("error", "✗");
-      const errMsg = a.error ? `: ${a.error.slice(0, 60)}` : "";
+      const err = a.error ? toSingleLine(a.error) : "";
+      const errMsg = err ? `: ${safeTruncate(err, 60)}` : "";
       statusText = theme.fg("error", ` error${errMsg}`);
     } else {
       // aborted
@@ -336,10 +384,15 @@ 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"}`);
+    // 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.
+    const costText = this.showCost() ? formatCost(getLifetimeCost(a.lifetimeUsage)) : "";
+    if (costText) parts.push(costText);
     parts.push(duration);
 
     const modeTag = modeLabel ? ` ${theme.fg("dim", `(${modeLabel})`)}` : "";
-    return `${icon} ${theme.fg("dim", name)}${modeTag}  ${theme.fg("dim", a.description)} ${theme.fg("dim", "·")} ${theme.fg("dim", parts.join(" · "))}${statusText}`;
+    return `${icon} ${theme.fg("dim", name)}${modeTag}  ${theme.fg("dim", toSingleLine(a.description))} ${theme.fg("dim", "·")} ${theme.fg("dim", parts.join(" · "))}${statusText}`;
   }
 
   /**
@@ -377,28 +430,43 @@ export class AgentWidget {
 
     const runningLines: string[][] = []; // each entry is [header, activity]
     for (const a of running) {
-      const name = getDisplayName(a.type);
+      const name = toSingleLine(getDisplayName(a.type));
       const modeLabel = getPromptModeLabel(a.type);
       const modeTag = modeLabel ? ` ${theme.fg("dim", `(${modeLabel})`)}` : "";
       const elapsed = formatMs(Date.now() - a.startedAt);
 
       const bg = this.agentActivity.get(a.id);
       const toolUses = bg?.toolUses ?? a.toolUses;
-      const tokens = getLifetimeTotal(bg?.lifetimeUsage);
+      // Falls back to the record: only Agent-tool spawns get an activity entry,
+      // so a scheduled or RPC-started agent would otherwise render with no
+      // stats at all — and, with the setting on, no cost.
+      const usage = bg?.lifetimeUsage ?? a.lifetimeUsage;
+      const tokens = getLifetimeTotal(usage);
       const contextPercent = getSessionContextPercent(bg?.session);
       const tokenText = tokens > 0 ? formatSessionTokens(tokens, contextPercent, theme, a.compactionCount) : "";
+      const costText = this.showCost() ? formatCost(getLifetimeCost(usage)) : "";
 
       const parts: string[] = [];
+      if (this.showModel()) {
+        // Leading, and paired: a thinking level means nothing without the model
+        // it applies to. The tag is taken from buildInvocationTags rather than
+        // 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: "));
+        if (thinkingTag) parts.push(thinkingTag);
+      }
       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);
       parts.push(elapsed);
       const statsText = parts.join(" · ");
 
-      const activity = bg ? describeActivity(bg.activeTools, bg.responseText) : "thinking…";
+      const activity = toSingleLine(bg ? describeActivity(bg.activeTools, bg.responseText) : "thinking…");
 
       runningLines.push([
-        truncate(theme.fg("dim", "├─") + ` ${theme.fg("accent", frame)} ${theme.bold(name)}${modeTag}  ${theme.fg("muted", a.description)} ${theme.fg("dim", "·")} ${fgPreservingNestedStyles(theme, "dim", statsText)}`),
+        truncate(theme.fg("dim", "├─") + ` ${theme.fg("accent", frame)} ${theme.bold(name)}${modeTag}  ${theme.fg("muted", toSingleLine(a.description))} ${theme.fg("dim", "·")} ${fgPreservingNestedStyles(theme, "dim", statsText)}`),
         truncate(theme.fg("dim", "│  ") + theme.fg("dim", `  ⎿  ${activity}`)),
       ]);
     }

package/src/ui/conversation-viewer.ts

@@ -8,10 +8,11 @@
 import type { AgentSession } from "@earendil-works/pi-coding-agent";
 import { type Component, Input, matchesKey, type TUI, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { extractText } from "../context.js";
+import { safeTruncate, stripControlChars, toSingleLine } from "../text-safety.js";
 import type { AgentRecord } from "../types.js";
-import { getLifetimeTotal, getSessionContextPercent } from "../usage.js";
+import { getLifetimeCost, getLifetimeTotal, getSessionContextPercent } from "../usage.js";
 import type { Theme } from "./agent-widget.js";
-import { type AgentActivity, buildInvocationTags, describeActivity, fgPreservingNestedStyles, formatDuration, formatSessionTokens, getDisplayName, getPromptModeLabel } from "./agent-widget.js";
+import { type AgentActivity, buildInvocationTags, describeActivity, fgPreservingNestedStyles, formatCost, formatDuration, formatSessionTokens, getDisplayName, getPromptModeLabel } from "./agent-widget.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. */
@@ -45,6 +46,12 @@ export class ConversationViewer implements Component {
     keybindings?: ViewerKeybindings,
     /** Send a steering message to the agent. Omitted → no compose affordance. */
     private onSteer?: (message: string) => void,
+    /**
+     * Whether the header shows an estimated cost after the token count. Read
+     * once, at construction: the overlay is opened from a menu or the fleet
+     * list, so the setting cannot change while it is on screen.
+     */
+    private showCost = false,
   ) {
     this.keys = createViewerKeys(keybindings);
     this.unsubscribe = session.subscribe(() => {
@@ -137,7 +144,7 @@ export class ConversationViewer implements Component {
 
     // Header
     lines.push(hrTop);
-    const name = getDisplayName(this.record.type);
+    const name = toSingleLine(getDisplayName(this.record.type));
     const modeLabel = getPromptModeLabel(this.record.type);
     const modeTag = modeLabel ? ` ${th.fg("dim", `(${modeLabel})`)}` : "";
     const statusIcon = this.record.status === "running"
@@ -152,14 +159,19 @@ export class ConversationViewer implements Component {
     const headerParts: string[] = [duration];
     const toolUses = this.activity?.toolUses ?? this.record.toolUses;
     if (toolUses > 0) headerParts.unshift(`${toolUses} tool${toolUses === 1 ? "" : "s"}`);
-    const tokens = getLifetimeTotal(this.activity?.lifetimeUsage);
+    // The viewer opens on finished agents too, whose activity entry is long
+    // gone — the record is the only place their totals survive.
+    const usage = this.activity?.lifetimeUsage ?? this.record.lifetimeUsage;
+    const tokens = getLifetimeTotal(usage);
     if (tokens > 0) {
       const percent = getSessionContextPercent(this.activity?.session);
       headerParts.push(formatSessionTokens(tokens, percent, th, this.record.compactionCount));
     }
+    const cost = this.showCost ? formatCost(getLifetimeCost(usage)) : "";
+    if (cost) headerParts.push(cost);
 
     lines.push(row(
-      `${statusIcon} ${th.bold(name)}${modeTag}  ${th.fg("muted", this.record.description)} ${th.fg("dim", "·")} ${fgPreservingNestedStyles(th, "dim", headerParts.join(" · "))}`,
+      `${statusIcon} ${th.bold(name)}${modeTag}  ${th.fg("muted", toSingleLine(this.record.description))} ${th.fg("dim", "·")} ${fgPreservingNestedStyles(th, "dim", headerParts.join(" · "))}`,
     ));
     const invocationLine = this.invocationLine();
     if (invocationLine) lines.push(row(invocationLine));
@@ -274,8 +286,13 @@ export class ConversationViewer implements Component {
   }
 
   private invocationLine(): string | undefined {
-    const { modelName, tags } = buildInvocationTags(this.record.invocation);
-    const parts = modelName ? [modelName, ...tags] : tags;
+    // Canonical id here, short label everywhere else: this overlay is opened to
+    // inspect one agent and has the width for it, and two providers can serve
+    // models whose short names read alike.
+    const { modelName, modelId, tags } = buildInvocationTags(this.record.invocation);
+    const sanitizedTags = tags.map(t => toSingleLine(t));
+    const model = modelId ?? modelName;
+    const parts = model ? [toSingleLine(model), ...sanitizedTags] : sanitizedTags;
     if (parts.length === 0) return undefined;
     return this.theme.fg("dim", `  ↳ ${parts.join(" · ")}`);
   }
@@ -295,9 +312,9 @@ export class ConversationViewer implements Component {
     let needsSeparator = false;
     for (const msg of messages) {
       if (msg.role === "user") {
-        const text = typeof msg.content === "string"
+        const text = stripControlChars(typeof msg.content === "string"
           ? msg.content
-          : extractText(msg.content);
+          : extractText(msg.content));
         if (!text.trim()) continue;
         if (needsSeparator) lines.push(th.fg("dim", "───"));
         lines.push(th.fg("accent", "[User]"));
@@ -308,9 +325,9 @@ export class ConversationViewer implements Component {
         const textParts: string[] = [];
         const toolCalls: string[] = [];
         for (const c of msg.content) {
-          if (c.type === "text" && c.text) textParts.push(c.text);
+          if (c.type === "text" && c.text) textParts.push(stripControlChars(c.text));
           else if (c.type === "toolCall") {
-            toolCalls.push((c as any).name ?? (c as any).toolName ?? "unknown");
+            toolCalls.push(toSingleLine((c as any).name ?? (c as any).toolName) || "unknown");
           }
         }
         if (needsSeparator) lines.push(th.fg("dim", "───"));
@@ -324,8 +341,8 @@ export class ConversationViewer implements Component {
           lines.push(truncateToWidth(th.fg("muted", `  [Tool: ${name}]`), width));
         }
       } else if (msg.role === "toolResult") {
-        const text = extractText(msg.content);
-        const truncated = text.length > 500 ? text.slice(0, 500) + "... (truncated)" : text;
+        const text = stripControlChars(extractText(msg.content));
+        const truncated = text.length > 500 ? safeTruncate(text, 500) + "... (truncated)" : text;
         if (!truncated.trim()) continue;
         if (needsSeparator) lines.push(th.fg("dim", "───"));
         lines.push(th.fg("dim", "[Result]"));
@@ -335,11 +352,12 @@ export class ConversationViewer implements Component {
       } else if ((msg as any).role === "bashExecution") {
         const bash = msg as any;
         if (needsSeparator) lines.push(th.fg("dim", "───"));
-        lines.push(truncateToWidth(th.fg("muted", `  $ ${bash.command}`), width));
+        lines.push(truncateToWidth(th.fg("muted", `  $ ${toSingleLine(bash.command)}`), width));
         if (bash.output?.trim()) {
-          const out = bash.output.length > 500
-            ? bash.output.slice(0, 500) + "... (truncated)"
-            : bash.output;
+          const rawOut = stripControlChars(bash.output);
+          const out = rawOut.length > 500
+            ? safeTruncate(rawOut, 500) + "... (truncated)"
+            : rawOut;
           for (const line of wrapTextWithAnsi(out.trim(), width)) {
             lines.push(th.fg("dim", line));
           }
@@ -352,7 +370,7 @@ export class ConversationViewer implements Component {
 
     // Streaming indicator for running agents
     if (this.record.status === "running" && this.activity) {
-      const act = describeActivity(this.activity.activeTools, this.activity.responseText);
+      const act = toSingleLine(describeActivity(this.activity.activeTools, this.activity.responseText));
       lines.push("");
       lines.push(truncateToWidth(th.fg("accent", "▍ ") + th.fg("dim", act), width));
     }