@pellux/goodvibes-tui 2.0.3 → 2.0.5

package/CHANGELOG.md

@@ -4,6 +4,37 @@ All notable changes to GoodVibes TUI.
 
 ---
 
+## [2.0.5] - 2026-08-02
+
+### Changes
+
+- Fixed: a corrupt watcher snapshot no longer takes down the process that
+  reads it. Snapshots save atomically, and a torn file — the live case was a
+  host freeze leaving valid JSON followed by NUL bytes — is quarantined with
+  a receipt while watcher state rebuilds from live registrations (platform
+  runtime 2.0.4).
+- Fixed: refusing an unknown owner-profile field id names the valid ids
+  instead of citing a documentation section.
+
+## [2.0.4] - 2026-08-01
+
+### Changes
+
+- **Collapsed output is compact.** A folded block — tool result, thinking
+  block, or compaction handoff — now renders as exactly one row: its header,
+  with the `▸ N lines` badge as the only count and the head of the content
+  riding the same line (thinking folds keep their content behind the toggle
+  by design). The frame rows, the interior preview row with its second
+  hidden-count marker, and the blank rows between consecutive folded results
+  are gone: three collapsed tool results that took nineteen rows now take
+  ten. Expanded rendering is unchanged. The fold decisions — threshold,
+  default, separators, preview rule — now come from the shared platform
+  policy in `@pellux/goodvibes-terminal-shell` (2.0.3), the same module the
+  Agent reads, so the two renderers cannot drift apart again.
+- Fixed: a client that inherited the daemon's bind host is no longer refused
+  as "insecure PUBLIC transport" when that host is a wildcard (platform
+  runtime 2.0.3).
+
 ## [2.0.3] - 2026-08-01
 
 ### Changes

package/README.md

@@ -2,7 +2,7 @@
 
 [![CI](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml/badge.svg)](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Version](https://img.shields.io/badge/version-2.0.3-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
+[![Version](https://img.shields.io/badge/version-2.0.5-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
 
 GoodVibes is a terminal console for coding and operations work with an AI model. You run `goodvibes` in a project directory and get a full-screen terminal app where you talk to a model that can read and edit your files, run shell commands, search the web, and hand work off to background agents — asking your permission before anything that writes or executes. It talks to many model providers (OpenAI, Anthropic, Gemini, Bedrock, Copilot, OpenRouter and other OpenAI-compatible gateways, plus local servers like Ollama and LM Studio that it finds on startup), keeps its settings, sessions, and secrets on your own machine, and shows you the token count and running cost of every turn. Alongside the conversation, panels turn background work — running agents, git state, diffs, tokens, cost — into live control rooms.
 

package/docs/foundation-artifacts/operator-contract.json

@@ -3,7 +3,7 @@
   "product": {
     "id": "goodvibes",
     "surface": "operator",
-    "version": "2.0.2"
+    "version": "2.0.4"
   },
   "auth": {
     "modes": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "Terminal-native GoodVibes client for coding, operations, knowledge and channel workflows — a pure client of the GoodVibes daemon.",
   "type": "module",
   "main": "src/main.ts",
@@ -95,11 +95,11 @@
     "@anthropic-ai/bedrock-sdk": "^0.29.1",
     "@anthropic-ai/sdk": "^0.92.0",
     "@ast-grep/napi": "^0.42.0",
-    "@pellux/goodvibes-sdk": "2.0.2",
-    "@pellux/goodvibes-terminal-shell": "2.0.2",
+    "@pellux/goodvibes-sdk": "2.0.4",
+    "@pellux/goodvibes-terminal-shell": "2.0.4",
     "bash-language-server": "^5.6.0",
     "fuse.js": "^7.1.0",
-    "@pellux/goodvibes-daemon": "1.28.4",
+    "@pellux/goodvibes-daemon": "1.28.6",
     "graphql": "^16.13.2",
     "jszip": "^3.10.1",
     "node-edge-tts": "^1.2.10",
@@ -124,10 +124,10 @@
     "typescript": "^5.9.3"
   },
   "optionalDependencies": {
-    "@pellux/goodvibes-tui-linux-x64": "2.0.3",
-    "@pellux/goodvibes-tui-linux-arm64": "2.0.3",
-    "@pellux/goodvibes-tui-darwin-x64": "2.0.3",
-    "@pellux/goodvibes-tui-darwin-arm64": "2.0.3"
+    "@pellux/goodvibes-tui-linux-x64": "2.0.5",
+    "@pellux/goodvibes-tui-linux-arm64": "2.0.5",
+    "@pellux/goodvibes-tui-darwin-x64": "2.0.5",
+    "@pellux/goodvibes-tui-darwin-arm64": "2.0.5"
   },
   "trustedDependencies": [],
   "overrides": {

package/src/core/conversation-compaction-render.ts

@@ -9,7 +9,7 @@
 
 import { activeTheme } from '../renderer/theme.ts';
 import { renderMarkdownTracked } from '../renderer/markdown.ts';
-import { renderConversationCollapsedFragment, renderConversationEventLine } from '../renderer/conversation-surface.ts';
+import { renderConversationEventLine, renderConversationFoldedRow } from '../renderer/conversation-surface.ts';
 import { GLYPHS } from '../renderer/ui-primitives.ts';
 import type { Line } from '@pellux/goodvibes-sdk/platform/types';
 import type { BlockMeta } from './conversation-types.ts';
@@ -49,30 +49,30 @@ export function renderCompactionContinuationMessage(
     context.collapseState.set(collapseKey, true);
   }
 
-  context.history.addLine(renderConversationEventLine(width, {
+  const tone = {
     marker: GLYPHS.status.active,
     markerFg: T.toolAccent,
     label: 'compaction handoff',
     labelFg: T.toolAccent,
     detailFg: '244',
-  }, [
+  };
+  const details = [
     { text: ` ${isCollapsed ? GLYPHS.navigation.collapsed : GLYPHS.navigation.expanded} ${lineCount} line${lineCount === 1 ? '' : 's'} `, fg: '244', dim: true },
-  ]));
+  ];
 
   if (isCollapsed) {
-    const rendered = renderConversationCollapsedFragment(
-      'compacted-context handoff (re-injected instructions + session summary)',
+    // One row. This used to be the header PLUS a framed fragment holding a
+    // single static sentence — three rows of chrome to say what the label and
+    // the badge already said. The distinguishing half of that sentence folds
+    // onto the header instead.
+    context.history.addLine(renderConversationFoldedRow(
       width,
-      {
-        prefix: ` ${GLYPHS.navigation.collapsed} `,
-        prefixFg: T.toolAccent,
-        text: '244',
-        bodyBg: T.collapsedBodyBg,
-        dim: true,
-      },
-    );
-    context.history.addLines(rendered);
+      tone,
+      details,
+      're-injected instructions + session summary',
+    ));
   } else {
+    context.history.addLine(renderConversationEventLine(width, tone, details));
     context.history.addLines(renderMarkdownTracked(content, width).lines);
   }
 

package/src/core/conversation-fold.ts

@@ -0,0 +1,101 @@
+/**
+ * conversation-fold.ts — which transcript rows render FOLDED, and what spacing
+ * that earns them.
+ *
+ * A folded tool result is exactly ONE row: its header, with the preview riding
+ * on the same line after the `▸ N lines` badge. It used to be four rows — a
+ * `▄▄▄` cap, an interior preview line carrying a second `[▸ N hidden]` count, a
+ * `▀▀▀` cap, and a blank after all of it — for one line of text the header had
+ * already sized.
+ *
+ * These predicates live in their own leaf module because TWO callers must agree
+ * on them and neither may depend on the other: the row renderer
+ * (conversation-rendering.ts) decides how to draw the row, and the line cache
+ * (conversation-line-cache.ts) decides the blank separator that follows it. If
+ * those two ever disagreed about which rows are folded, a warm cache and a cold
+ * rebuild would space the transcript differently — the exact class of bug the
+ * cache's byte-identical contract exists to rule out.
+ *
+ * Everything here is PURE: collapse state is read, never written, so a row can
+ * be asked about before it has rendered.
+ */
+
+import { foldedToolResult, trailingBlankAfterRow } from '@pellux/goodvibes-terminal-shell';
+import { summarizeToolResult } from '../renderer/tool-result-summary.ts';
+import { isTurnCollapsed, type ConversationRenderContext } from './conversation-render-context.ts';
+import { collapseKeyForNode, type RenderNode } from './conversation-turn-structure.ts';
+import type { ConversationMessageSnapshot } from '@pellux/goodvibes-sdk/platform/core';
+
+/** The subset of a render context these predicates read. */
+type FoldContext = Pick<ConversationRenderContext, 'assistantTurns' | 'collapseState'>;
+
+/**
+ * Does a tool-result row render FOLDED — one compact header row with its preview
+ * on it — rather than header-plus-expanded-body?
+ *
+ * An unset collapse key answers the same as the default the row itself will
+ * store (collapsed), so asking before and asking after the row renders give the
+ * same answer.
+ */
+export function isToolResultFolded(
+  message: Extract<ConversationMessageSnapshot, { role: 'tool' }>,
+  collapseState: ReadonlyMap<string, boolean>,
+  collapseKey: string,
+): boolean {
+  // Threading only — the decision, the short-content threshold and the
+  // unset-key default all belong to foldedToolResult(). summarizeToolResult is
+  // this product's own renderer concern, so resolving it stays here: a
+  // summarizable result stays folded even when short, because the one-line
+  // summary is the better row and the raw payload belongs behind the toggle.
+  return foldedToolResult({
+    contentLength: message.content.length,
+    hasSummary: summarizeToolResult(message.toolName, message.content) !== null,
+    storedCollapsed: collapseState.get(collapseKey),
+  });
+}
+
+/** A row that belongs to a tool run: the call itself, or the result under it. */
+function isToolRunNode(node: RenderNode): boolean {
+  return node.kind === 'toolcall' || node.message.role === 'tool';
+}
+
+/**
+ * Does this planned row emit exactly one folded tool-result line?
+ *
+ * A collapsed turn hides the row entirely, so there is no folded row to butt up
+ * against the next one.
+ */
+function rendersFoldedToolRow(node: RenderNode, context: FoldContext): boolean {
+  if (node.kind === 'toolcall') return false;
+  const message = node.message;
+  if (message.role !== 'tool') return false;
+  if (isTurnCollapsed(context.assistantTurns?.get(node.absIdx), context.collapseState)) return false;
+  return isToolResultFolded(message, context.collapseState, collapseKeyForNode(node));
+}
+
+/**
+ * The blank separator that follows a planned row.
+ *
+ * Branch rows sit tight under their parent, so the blank lands only after the
+ * last row of a top-level unit — that is what keeps a turn's whole subtree
+ * reading as one block. On top of that, a folded row followed by more tool
+ * machinery gets NO blank at all: N consecutive folded results stack as N
+ * adjacent single rows. A folded row followed by anything that is not tool
+ * machinery keeps its blank, so the run still separates from the prose around
+ * it.
+ */
+export function trailingBlankAfter(
+  node: RenderNode,
+  next: RenderNode | undefined,
+  context: FoldContext,
+): boolean {
+  // Adaptation only — RenderNode is this product's shape, so reading depth and
+  // node kind off it stays here; the rule those facts feed belongs to
+  // trailingBlankAfterRow(). No `next` at all means end of transcript: neither
+  // a branch row nor tool machinery follows, which is the plain-blank case.
+  return trailingBlankAfterRow({
+    nextIsBranchRow: next !== undefined && next.depth !== 0,
+    nextIsToolMachinery: next !== undefined && isToolRunNode(next),
+    rowRendersFolded: rendersFoldedToolRow(node, context),
+  });
+}

package/src/core/conversation-line-cache.ts

@@ -58,6 +58,7 @@ import {
   isTurnCollapsed,
   type ToolCallOutcome,
 } from './conversation-rendering.ts';
+import { trailingBlankAfter } from './conversation-fold.ts';
 import {
   buildRenderPlan,
   computeAssistantTurns,
@@ -373,8 +374,9 @@ export class MessageLineCache {
         }
       }
 
-      const next = plan[i + 1];
-      const trailingBlank = !next || next.depth === 0;
+      // Same rule appendConversationMessages uses, from the same function, so a
+      // warm cache and a cold rebuild space rows identically.
+      const trailingBlank = trailingBlankAfter(node, plan[i + 1], renderContext);
       const uncacheable = isRoot && node.kind === 'message' && node.absIdx === streamingPlaceholderAbsIdx;
       const kind = isRoot ? context.messageKindRegistry.get(node.absIdx) : undefined;
       const pendingToolKey = pendingToolKeyOf(node.message, toolCallOutcomes);

package/src/core/conversation-rendering.ts

@@ -10,9 +10,9 @@ import { renderSystemMessage } from '../renderer/system-message.ts';
 import { createEmptyLine, type Line, type Cell } from '@pellux/goodvibes-sdk/platform/types';
 import { getSplashLines, type SplashOptions } from '../utils/splash-lines.ts';
 import { interpolateColor, getDisplayWidth, wrapText } from '../utils/terminal-width.ts';
-import { LAYOUT, TOOL_STATUS } from '../renderer/layout.ts';
+import { BORDERS, LAYOUT, TOOL_STATUS } from '../renderer/layout.ts';
 import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
-import { renderConversationCollapsedFragment, renderConversationEventLine } from '../renderer/conversation-surface.ts';
+import { renderConversationEventLine, renderConversationFoldedRow } from '../renderer/conversation-surface.ts';
 import { GLYPHS } from '../renderer/ui-primitives.ts';
 import type { BlockMeta } from './conversation-types.ts';
 import {
@@ -21,6 +21,9 @@ import {
   type ConversationRenderContext,
 } from './conversation-render-context.ts';
 import { renderCompactionContinuationMessage } from './conversation-compaction-render.ts';
+// Which rows fold, and the blank separator that earns — shared verbatim with
+// conversation-line-cache.ts so a warm cache and a cold rebuild space alike.
+import { isToolResultFolded, trailingBlankAfter } from './conversation-fold.ts';
 import { drawTreeRails, treeIndentCols, treeTextCol } from '@pellux/goodvibes-terminal-shell';
 import {
   MAX_NEST_DEPTH,
@@ -209,19 +212,24 @@ export function renderConversationAssistantMessage(
       context.collapseState.set(thinkingCollapseKey, true);
     }
     if (isThinkingCollapsed) {
+      // One row: label plus size badge, no frame and no interior line.
+      //
+      // Deliberately NO preview, unlike a folded tool result. Reasoning text
+      // stays behind the toggle until it is asked for — the fold is the quiet
+      // state of an already-opt-in display, and previewing the first reasoning
+      // line here would disclose content the collapsed form has never shown.
       const thinkingLineCount = message.reasoningContent.split('\n').length;
-      const rendered = renderConversationCollapsedFragment(
-        `thinking · ${thinkingLineCount} line${thinkingLineCount === 1 ? '' : 's'}`,
-        width,
-        {
-          prefix: ' ▌ ',
-          prefixFg: T.reasoningAccent,
-          text: '244',
-          bodyBg: T.collapsedBodyBg,
-          dim: true,
-        },
-      );
-      context.history.addLines(rendered);
+      context.history.addLine(renderConversationFoldedRow(width, {
+        // The same ▌ the EXPANDED block draws (BORDERS.THINKING), so folding
+        // changes the row count without changing what the block reads as.
+        marker: BORDERS.THINKING.char,
+        markerFg: T.reasoningAccent,
+        label: 'thinking',
+        labelFg: T.reasoningAccent,
+        detailFg: '244',
+      }, [
+        { text: ` ${GLYPHS.navigation.collapsed} ${thinkingLineCount} line${thinkingLineCount === 1 ? '' : 's'} `, fg: '244', dim: true },
+      ], ''));
     } else {
       const thinkingLines = renderThinkingBlock(message.reasoningContent, width);
       context.history.addLines(thinkingLines);
@@ -495,17 +503,14 @@ export function renderConversationToolMessage(
     ? summarizeToolResult(message.toolName, message.content)
     : null;
 
-  // A summarizable result is kept collapsed-by-default even when short, so the
-  // one-line summary wins and the raw JSON is tucked behind the expand toggle.
-  const isShort = message.content.length <= 200 && resultSummary === null;
-  const isCollapsed = isShort
-    ? false
-    : context.collapseState.has(collapseKey)
-      ? context.collapseState.get(collapseKey)!
-      : true;
+  const isCollapsed = isToolResultFolded(message, context.collapseState, collapseKey);
 
+  // The fold decision IS the stored default: with nothing stored,
+  // isToolResultFolded() already resolved to exactly the value this key should
+  // hold. Recomputing "is it short?" here would be a second copy of the
+  // threshold that the policy module owns.
   if (!context.collapseState.has(collapseKey)) {
-    context.collapseState.set(collapseKey, isShort ? false : true);
+    context.collapseState.set(collapseKey, isCollapsed);
   }
 
   // A per-call user cancellation settles as a tool result whose content leads
@@ -529,16 +534,24 @@ export function renderConversationToolMessage(
       ? [{ text: ` ${message.toolName} `, fg: T.toolNameFg }]
       : [{ text: ` ${summarizeCallId(message.callId || 'standalone')} `, fg: '244' as const, dim: true }]);
 
-  const headerLine = renderConversationEventLine(width, {
+  // A FOLDED result is exactly one row: this header, with its preview riding on
+  // the same line right after the `▸ N lines` badge (see
+  // renderConversationFoldedRow). The badge is the count — the old fold also
+  // carried a separate `[▸ N hidden]` marker, which restated it.
+  const headerTone = {
     marker: isCancelled ? GLYPHS.status.blocked : (blockType === 'diff' ? GLYPHS.status.dualPane : GLYPHS.status.active),
     markerFg: isCancelled ? warnTone : (blockType === 'diff' ? T.diffAccent : T.toolAccent),
     label,
     labelFg: isCancelled ? warnTone : (blockType === 'diff' ? T.diffAccent : T.toolAccent),
     detailFg: '244',
-  }, [
+  };
+  const headerDetails = [
     ...nameSegments,
     { text: ` ${isCollapsed ? GLYPHS.navigation.collapsed : GLYPHS.navigation.expanded} ${lineCount} line${lineCount === 1 ? '' : 's'} `, fg: '244', dim: true },
-  ], indent);
+  ];
+  const headerLine = isCollapsed
+    ? renderConversationFoldedRow(width, headerTone, headerDetails, resultSummary ?? contentLines[0] ?? '', indent)
+    : renderConversationEventLine(width, headerTone, headerDetails, indent);
   // Every line this row emits, gathered before anything is committed, so the
   // rails can be drawn across all of them in one pass (see drawTreeRails). The
   // result row deliberately carries NO status marker of its own: the call row
@@ -546,32 +559,7 @@ export function renderConversationToolMessage(
   // and a second marker one row down only doubles it.
   const rows: Line[] = [headerLine];
 
-  if (isCollapsed) {
-    const collapseSuffixReserve = 30;
-    const avail = Math.max(0, width - LAYOUT.LEFT_MARGIN - LAYOUT.RIGHT_MARGIN - indent - collapseSuffixReserve);
-    const hiddenCount = lineCount - 1;
-    let collapsedText: string;
-    if (resultSummary !== null) {
-      // Summary line — the header already shows "▸ N lines", so no hidden badge.
-      collapsedText = resultSummary.length > avail
-        ? `${resultSummary.slice(0, Math.max(0, avail - 1))}…`
-        : resultSummary;
-    } else {
-      const preview = contentLines[0].slice(0, avail);
-      collapsedText = hiddenCount > 0
-        ? `${preview}...  [${GLYPHS.navigation.collapsed} ${hiddenCount} hidden]`
-        : preview;
-    }
-    const rendered = renderConversationCollapsedFragment(collapsedText, width, {
-      prefix: blockType === 'diff' ? ` ${GLYPHS.status.dualPane} ` : ` ${GLYPHS.navigation.collapsed} `,
-      prefixFg: blockType === 'diff' ? T.diffAccent : T.toolAccent,
-      text: '244',
-      bodyBg: T.collapsedBodyBg,
-      dim: true,
-      indentCols: indent,
-    });
-    for (const line of rendered) rows.push(line);
-  } else {
+  if (!isCollapsed) {
     // Diff or plain result — either way this is exactly `expandedLines`,
     // already computed above (and already what the header's line count is
     // honest about), so there is nothing left to render here.
@@ -683,8 +671,9 @@ export function appendConversationMessages(
     // Branch rows sit tight under their parent; the blank separator lands only
     // after the last row of a top-level unit, which is what keeps a turn's
     // whole subtree reading as one block instead of a run of spaced-out rows.
-    const next = plan[i + 1];
-    if (!next || next.depth === 0) {
+    // A folded result followed by more tool machinery gets no blank at all —
+    // consecutive folded results stack as adjacent single rows.
+    if (trailingBlankAfter(node, plan[i + 1], turnContext)) {
       turnContext.history.addLine(createEmptyLine(width));
     }
   }

package/src/renderer/conversation-surface.ts

@@ -2,7 +2,7 @@ import { type Line, createEmptyLine, createStyledCell } from '@pellux/goodvibes-
 import { getDisplayWidth, wrapText } from '../utils/terminal-width.ts';
 import { LAYOUT } from './layout.ts';
 import { GLYPHS } from './ui-primitives.ts';
-import { treeBranchCol, treeContentCol } from '@pellux/goodvibes-terminal-shell';
+import { foldPreviewText, treeBranchCol, treeContentCol } from '@pellux/goodvibes-terminal-shell';
 
 export interface ConversationSurfacePalette {
   readonly accent: string;
@@ -173,28 +173,49 @@ export function renderConversationFragment(
   return lines;
 }
 
-export function renderConversationCollapsedFragment(
-  content: string,
+/**
+ * A COLLAPSED block, as exactly one row: the event line, with its preview
+ * riding on the same line right after the badges.
+ *
+ * Collapsed blocks used to render as a framed fragment — a `▄▄▄` cap, an
+ * interior line of text, a `▀▀▀` cap — around what was, in every case, a single
+ * line. Four rows of chrome per fold made a screen of collapsed output mostly
+ * frame. The text those rows carried moves onto the event line and the frame
+ * goes; the `▸ N lines` badge is the count, so nothing restates it.
+ *
+ * The preview is TRUNCATED to fit, never wrapped: wrapping would put the row
+ * back to two lines, which is the thing being removed. Whitespace is flattened
+ * by the caller's choice of preview text — a raw tab or newline would blow the
+ * column out.
+ */
+export function renderConversationFoldedRow(
   width: number,
-  options: {
-    readonly prefix?: string;
-    readonly prefixFg?: string;
-    readonly text?: string;
-    readonly bodyBg?: string;
-    readonly dim?: boolean;
-    readonly italic?: boolean;
-    /** Tree-branch indent, in columns (see conversation-tree.ts). */
-    readonly indentCols?: number;
-  } = {},
-): Line[] {
-  return renderConversationFragment(content, width, {
-    prefix: options.prefix ?? ` ${GLYPHS.navigation.selected} `,
-    prefixFg: options.prefixFg ?? '#38bdf8',
-    text: options.text ?? '244',
-    bodyBg: options.bodyBg ?? '#1a1a1a',
-    dim: options.dim ?? true,
-    italic: options.italic ?? false,
-  }, options.indentCols ?? 0);
+  tone: ConversationEventTone,
+  details: readonly ConversationStatusSegment[],
+  preview: string,
+  indentCols = 0,
+): Line {
+  // What is left of the row after the marker, the label and the badges.
+  const usedCols = (tone.label ? getDisplayWidth(` ${tone.label} `) : 0)
+    + details.reduce((sum, segment) => sum + getDisplayWidth(segment.text), 0);
+  const availCols = width - LAYOUT.RIGHT_MARGIN - treeContentCol(Math.max(0, indentCols)) - usedCols - 1;
+  // Whether a preview renders at all, and its flattening, are the policy's call
+  // (foldPreviewText returns null for "no preview"). Only the TRUNCATION is
+  // ours: display width is a product-local rule the policy deliberately leaves
+  // to the caller — and it must truncate, never wrap.
+  const trimmed = foldPreviewText(preview, availCols);
+  if (trimmed === null) {
+    return renderConversationEventLine(width, tone, details, indentCols);
+  }
+  const text = getDisplayWidth(trimmed) > availCols
+    ? `${trimmed.slice(0, Math.max(1, availCols - 1))}…`
+    : trimmed;
+  return renderConversationEventLine(
+    width,
+    tone,
+    [...details, { text: `${text} `, fg: tone.detailFg ?? '244', dim: true }],
+    indentCols,
+  );
 }
 
 export function renderConversationStatusLine(

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '2.0.3';
+let _version = '2.0.5';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   // Only trust a version read from OUR OWN package.json. A Bun single-file