@pellux/goodvibes-tui 1.21.1 → 1.23.0

package/src/input/commands/operator-rpc.ts

@@ -46,11 +46,22 @@ export interface OperatorRpcAvailable {
 export type OperatorRpc = OperatorRpcUnavailable | OperatorRpcAvailable;
 
 function resolveControlPlaneBaseUrl(configManager: ConfigManager): string | null {
-  const explicit = String(configManager.get('controlPlane.baseUrl') ?? '').trim();
-  if (explicit) return explicit;
+  // An explicitly declared external address wins; otherwise the URL is DERIVED
+  // from hostMode/host/port/tls.mode. This used to prefer a stored
+  // `controlPlane.baseUrl`, which had no writers and so drifted from the bind
+  // on port, scheme, and host at once.
+  // The cast drops once a published SDK carries this key in ConfigKey; the
+  // installed 1.14.0 predates it (same idiom cloudflare-control-plane.ts uses).
+  const explicit = String(configManager.get('controlPlane.publicBaseUrl' as never) ?? '').trim();
+  if (explicit) return explicit.replace(/\/+$/, '');
   const host = String(configManager.get('controlPlane.host') ?? '').trim();
   const port = configManager.get('controlPlane.port');
-  if (host && typeof port === 'number' && port > 0) return `http://${host}:${port}`;
+  if (host && typeof port === 'number' && port > 0) {
+    const scheme = String(configManager.get('controlPlane.tls.mode') ?? 'off') !== 'off' ? 'https' : 'http';
+    // A wildcard bind is not a dial target; loopback is the interface it answers on.
+    const dialHost = host === '0.0.0.0' || host === '::' ? '127.0.0.1' : host;
+    return `${scheme}://${dialHost.includes(':') && !dialHost.startsWith('[') ? `[${dialHost}]` : dialHost}:${port}`;
+  }
   return null;
 }
 
@@ -70,7 +81,7 @@ export function resolveOperatorRpc(deps: { readonly configManager: ConfigManager
   }
   const baseUrl = resolveControlPlaneBaseUrl(configManager);
   if (!baseUrl) {
-    return { available: false, reason: 'no control-plane base URL is configured (controlPlane.baseUrl / controlPlane.host+port) — cannot reach the operator surface.' };
+    return { available: false, reason: 'no control-plane base URL is configured (controlPlane.publicBaseUrl / controlPlane.host+port) — cannot reach the operator surface.' };
   }
   // Resolve the home directory only AFTER the static refusals — a caller whose
   // shell paths are not wired (a disabled-daemon path) must still get the honest

package/src/input/daemon-owned-settings-descriptions.ts

@@ -0,0 +1,53 @@
+/**
+ * daemon-owned-settings-descriptions.ts — appends an honest storage-location
+ * note to any settings-modal entry whose config key is daemon-owned (see
+ * `@pellux/goodvibes-sdk/platform/config`'s `isDaemonOwnedConfigKey`).
+ *
+ * Before the daemon-owned-config migration, every product wrote every key
+ * into its own per-surface silo, and a value like `surfaces.telegram.token`
+ * looked — from the settings modal — exactly like any other TUI-local
+ * setting. It never was: the daemon is the only process that reads it, so a
+ * value the TUI wrote to its own surface file could silently do nothing.
+ * This enrichment tells the truth in the one place a user checks: the
+ * setting's own detail text says the value lives in the daemon's store and
+ * applies to every client, naming the actual file path via
+ * `ConfigManager.getDaemonTierPath()`.
+ *
+ * Entries are shallow-cloned (never mutating the shared `ConfigSetting`
+ * objects CONFIG_SCHEMA exports), following the same pattern as
+ * relay-settings-descriptions.ts, so re-running this on the same groups map
+ * stays idempotent.
+ */
+
+import { isDaemonOwnedConfigKey, type ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import type { SettingEntry, SettingsCategory } from './settings-modal-types.ts';
+
+/** Build the daemon-owned disclosure note for a given daemon store path. */
+export function daemonOwnedSettingNote(daemonTierPath: string | null): string {
+  return daemonTierPath
+    ? `This value is stored in the daemon's own configuration (${daemonTierPath}) and applies to every client — not just this one.`
+    : "This value is stored in the daemon's own configuration and applies to every client — not just this one.";
+}
+
+/**
+ * Append the daemon-owned disclosure note to every entry whose config key is
+ * daemon-owned, across every category in `groups`, in place.
+ */
+export function enrichDaemonOwnedSettingDescriptions(
+  groups: Map<SettingsCategory, SettingEntry[]>,
+  configManager: Pick<ConfigManager, 'getDaemonTierPath'>,
+): void {
+  const note = daemonOwnedSettingNote(configManager.getDaemonTierPath());
+  for (const entries of groups.values()) {
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (!entry) continue;
+      if (!isDaemonOwnedConfigKey(entry.setting.key)) continue;
+      if (entry.setting.description.includes(note)) continue;
+      entries[i] = {
+        ...entry,
+        setting: { ...entry.setting, description: `${entry.setting.description} ${note}` },
+      };
+    }
+  }
+}

package/src/input/handler-content-actions.ts

@@ -254,8 +254,10 @@ export function describeBlockForReceipt(block: BlockMeta): string {
   switch (block.type) {
     case 'tool':
       return block.toolName ? `tool result: ${block.toolName} (${lineText})` : `tool result (${lineText})`;
-    case 'tool_group':
-      return `tool result group (${lineText})`;
+    case 'assistant_turn':
+      return block.toolName
+        ? `assistant turn: ${block.toolName} (${lineText})`
+        : `assistant turn (${lineText})`;
     case 'diff':
       return block.filePath ? `diff: ${block.filePath} (${lineText})` : `diff (${lineText})`;
     case 'code':

package/src/input/handler-onboarding-daemon-adopt.ts

@@ -7,6 +7,7 @@
 import { join } from 'node:path';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { resolveDaemonCompanionToken } from '../runtime/operator-token-cleanup.ts';
+import { isLoopbackAddress } from './onboarding/onboarding-wizard-helpers.ts';
 import {
   buildManagedDaemonServiceManager,
   detectLegacyUnit,
@@ -60,6 +61,15 @@ export async function handleConnectExistingDaemonForHandler(handler: InputHandle
   try {
     const daemonHomeDir = join(handler.uiServices.environment.homeDirectory, '.goodvibes', 'daemon');
     resolveDaemonCompanionToken(daemonHomeDir, token);
+    // hostMode has to move with the host. The control-plane URL is DERIVED from
+    // hostMode/host/port, and 'local' pins the dial target to 127.0.0.1 no
+    // matter what host is stored — so adopting a daemon on another machine
+    // while leaving hostMode alone would derive a loopback URL for a remote
+    // daemon. Adopting a loopback address stays 'local'.
+    handler.uiServices.platform.configManager.setDynamic(
+      'controlPlane.hostMode',
+      isLoopbackAddress(host) ? 'local' : 'custom',
+    );
     handler.uiServices.platform.configManager.setDynamic('controlPlane.host', host);
     handler.uiServices.platform.configManager.setDynamic('controlPlane.port', port);
 

package/src/input/onboarding/onboarding-feature-units.ts

@@ -281,6 +281,13 @@ export const FEATURE_ONBOARDING_SECTIONS: readonly FeatureSection[] = [
         hint: 'Managed watcher/listener services with checkpointing and recovery. Enabling this turns on watchers.enabled.',
         impliedConfig: [{ key: 'watchers.enabled' as ConfigKey, value: true }],
       },
+      {
+        flagId: 'watcher-triggers',
+        label: 'Trigger family',
+        hint: 'Three unattended watcher kinds over one supervision spine: stream watchers that regex-filter and batch a long-lived command\'s output, model-free condition checks running a probe/extract/rule pipeline with no LLM in the loop, and one-shot on-exit triggers that fire exactly one payload when a launched command terminates. A firing trigger runs an agent turn or a pre-registered digest-pinned action grant — never a command composed at fire time. Off by default because a trigger supervises real processes with nobody watching; with it on and no triggers defined the supervisor idles and consumes nothing.',
+        note: 'Backoff ladder, strike breaker, retention bounds, batching and process caps are tuned through watchers.triggers.* in /settings.',
+        impliedConfig: [{ key: 'watchers.triggers.enabled' as ConfigKey, value: true }],
+      },
       {
         flagId: 'integration-delivery-slo',
         label: 'Integration delivery SLO',
@@ -315,6 +322,37 @@ export const FEATURE_ONBOARDING_SECTIONS: readonly FeatureSection[] = [
       },
     ],
   },
+  {
+    stepId: 'features-devices',
+    title: 'Paired devices and voice input',
+    shortLabel: 'Devices',
+    description: 'What a paired phone may be asked to do on your behalf, and whether GoodVibes listens for a spoken wake phrase. Every phone capability asks the person holding the phone before it runs; the wake word is off and states plainly that it is not wired up in this build.',
+    units: [
+      {
+        flagId: 'paired-device-capabilities',
+        label: 'Paired phone capabilities',
+        hint: 'Turning this on grants access to nothing by itself — it lets the agent ASK to use a paired phone as a tool: either camera, its screen, its location, its clipboard, and a small set of device effects (notification, link, buzz). It rides the existing peer transport as a native contract, never an MCP server. Every capture and every effect asks the person holding the phone first, and answering one request grants nothing beyond it; choosing "always allow" is a separate, explicit choice you make later on that prompt, and it writes one durable, revocable grant for that one capability on that one phone, with an age limit and a count cap so nothing is granted forever.',
+        note: 'Captures are kept 24 hours by default and then deleted, and every housekeeping sweep records exactly what it removed and why. Retention, grant limits, clipboard and location posture are tuned through device.* in /settings.',
+        subOptions: [
+          {
+            key: 'mode',
+            configKey: 'device.capabilities.mode' as ConfigKey,
+            label: 'Consent posture',
+            hint: 'honor-grants (stock) asks the first time and every time after unless you chose "always allow" for that capability on that phone; ask-every-time prompts on every single request and never consults a durable grant — use it when someone else is holding the phone; off stops any capability request reaching any paired device.',
+            valueType: 'enum',
+            options: ['off', 'ask-every-time', 'honor-grants'],
+            defaultValue: 'honor-grants',
+          },
+        ],
+      },
+      {
+        flagId: 'wake-word-detection',
+        label: 'Wake-word detection',
+        hint: 'Listen continuously on a capture device for the pinned "hey goodvibes" phrase and hand the utterance that follows to speech-to-text. Off by default because holding a microphone open must be an explicit act.',
+        note: 'NOT AVAILABLE IN THIS BUILD — turning this on does nothing yet. The detector is complete, but no surface captures microphone audio or supplies it an inference runtime, so nothing is listening. Your choice is remembered and takes effect in the release that adds capture.',
+      },
+    ],
+  },
   {
     stepId: 'features-provider',
     title: 'Provider and runtime behavior',

package/src/input/onboarding/onboarding-wizard-types.ts

@@ -30,6 +30,7 @@ export type OnboardingWizardStepId =
   | 'features-context'
   | 'features-telemetry'
   | 'features-automation'
+  | 'features-devices'
   | 'features-provider'
   | 'features-advanced'
   | 'review';

package/src/input/search.ts

@@ -140,7 +140,7 @@ export class SearchManager {
       for (const block of registry) {
         if (!conversationManager.isCollapsed(block.blockIndex)) continue;
 
-        if (block.type === 'tool_group' && block.groupMemberIndexes) {
+        if (block.type === 'assistant_turn' && block.groupMemberIndexes) {
           // The header's own synthetic summary rarely matches, but count it
           // honestly too — expanding the whole group is the only way to even
           // attempt to reveal a header-corpus hit, since there is no single

package/src/input/settings-modal-data.ts

@@ -52,6 +52,7 @@ import {
   type SubscriptionEntry,
 } from './settings-modal-types.ts';
 import { enrichRelaySettingDescriptions } from './relay-settings-descriptions.ts';
+import { enrichDaemonOwnedSettingDescriptions } from './daemon-owned-settings-descriptions.ts';
 import { applyFeatureUnitLayout } from './feature-unit-layout.ts';
 import { FEATURE_SETTINGS_BY_ID } from '../runtime/feature-settings.ts';
 
@@ -123,6 +124,14 @@ export function buildSettingGroups(
     }
     // fleet.maxSize (was orchestration.maxActiveAgents) surfaces under orchestration.
     if (rawCat === 'fleet' && groups.has('orchestration')) groups.get('orchestration')!.push(entry);
+    // push.* configures the delivery side of the very notifications the
+    // notifications.* keys already shape (pushApproval, pushNeedsInput,
+    // pushCompletion), so the contact address and the subscription
+    // housekeeping bounds belong in that same category rather than in one of
+    // their own. Without this they match no category at all and would be
+    // dropped from the workspace entirely — reachable only by editing the
+    // config file by hand.
+    if (rawCat === 'push' && groups.has('notifications')) groups.get('notifications')!.push(entry);
   }
 
   // Synthetic display.themeMode enum (auto|dark|light) — TUI-local, see theme-mode-config.ts.
@@ -238,6 +247,10 @@ export function buildSettingGroups(
   // the SDK's own descriptions don't carry (see relay-settings-descriptions.ts).
   enrichRelaySettingDescriptions(groups);
 
+  // Daemon-owned keys (e.g. surfaces.telegram.*) live only in the daemon's
+  // own config store — say so in the detail text (daemon-owned-settings-descriptions.ts).
+  enrichDaemonOwnedSettingDescriptions(groups, configManager);
+
   // Feature-unit presentation: each capability becomes ONE unit (its real
   // enablement row + the settings keys it tunes) in its settings domain,
   // sourced from FEATURE_SETTINGS. Runs AFTER synthetic injection so
@@ -698,93 +711,10 @@ export function updateEntryForKey(
 }
 
 // ---------------------------------------------------------------------------
-// fuzzyScoreSettingEntry — score an entry against a query for ranked search
+// Ranked settings search (see settings-modal-search.ts)
 // ---------------------------------------------------------------------------
 
-/**
- * Score a single SettingEntry against a search query.
- *
- * Score tiers (higher = better match):
- *   - 3000–3999: exact key substring match (3000 + position bonus 0–999)
- *   - 2000–2999: exact label substring match (2000 + position bonus 0–999)
- *   - 1000–1999: exact description substring match (1000 + position bonus 0–999)
- *   - 1–99:      subsequence match across key+label+description
- *
- * Returns null when the query does not match at all.
- *
- * @param query - The search string (already lowercased).
- * @param entry - The setting entry to test.
- * @param getLabel - Pure function mapping an entry to its display label.
- */
-export function fuzzyScoreSettingEntry(
-  query: string,
-  entry: SettingEntry,
-  getLabel: (e: SettingEntry) => string,
-): number | null {
-  if (query.length === 0) return 0;
-  const lq = query.toLowerCase();
-  const key = entry.setting.key.toLowerCase();
-  const label = getLabel(entry).toLowerCase();
-  const description = (entry.setting.description ?? '').toLowerCase();
-
-  // Tier 1: key substring — base 3000, position bonus up to 999
-  // A key match at position 0 scores 3999; at position 999 scores 3000.
-  const keyIdx = key.indexOf(lq);
-  if (keyIdx !== -1) return 3000 + Math.max(0, 999 - keyIdx);
-
-  // Tier 2: label substring — base 2000, position bonus up to 999
-  const labelIdx = label.indexOf(lq);
-  if (labelIdx !== -1) return 2000 + Math.max(0, 999 - labelIdx);
-
-  // Tier 3: description substring — base 1000, position bonus up to 999
-  const descIdx = description.indexOf(lq);
-  if (descIdx !== -1) return 1000 + Math.max(0, 999 - descIdx);
-
-  // Tier 4: subsequence across concatenated key + label + description — 1..99
-  const haystack = `${key} ${label} ${description}`;
-  let qi = 0;
-  let score = 0;
-  for (let ci = 0; ci < haystack.length && qi < lq.length; ci++) {
-    if (haystack[ci] === lq[qi]) {
-      qi++;
-      score++;
-    }
-  }
-  if (qi === lq.length) return Math.min(99, score);
-  return null;
-}
-
-/**
- * Search all setting entries across all groups, returning results ranked by
- * relevance score (highest first). Excludes the flags, mcp, and subscriptions
- * special categories (which have their own entry types).
- *
- * @param query - User input string. Empty string returns []. 
- * @param groups - The settings group map from buildSettingGroups.
- * @param getLabel - Pure function mapping an entry to its display label.
- */
-export function searchSettingEntries(
-  query: string,
-  groups: Map<SettingsCategory, SettingEntry[]>,
-  getLabel: (e: SettingEntry) => string,
-): SettingEntry[] {
-  if (query.trim().length === 0) return [];
-  const lq = query.trim().toLowerCase();
-  const seen = new Set<string>();
-  const scored: Array<{ entry: SettingEntry; score: number }> = [];
-  for (const entries of groups.values()) {
-    for (const entry of entries) {
-      // Deduplicate: network tab cross-lists keys already in controlPlane/httpListener/web
-      if (seen.has(entry.setting.key)) continue;
-      seen.add(entry.setting.key);
-      const score = fuzzyScoreSettingEntry(lq, entry, getLabel);
-      if (score !== null) scored.push({ entry, score });
-    }
-  }
-  scored.sort((a, b) => b.score - a.score);
-  return scored.map(r => r.entry);
-}
-
+export { fuzzyScoreSettingEntry, searchSettingEntries } from './settings-modal-search.ts';
 // ---------------------------------------------------------------------------
 // Re-export SubscriptionEntry for convenience
 // ---------------------------------------------------------------------------

package/src/input/settings-modal-search.ts

@@ -0,0 +1,99 @@
+/**
+ * settings-modal-search — ranked search over the settings workspace.
+ *
+ * Split out of settings-modal-data.ts, which had reached its 800-line ceiling.
+ * Scoring and search are a self-contained unit: they read a SettingEntry and a
+ * label function and depend on nothing else in the assembly path, so moving
+ * them changes no behavior. Both are re-exported from settings-modal-data.ts,
+ * so no import site moved.
+ */
+
+import type { SettingEntry, SettingsCategory } from './settings-modal-types.ts';
+
+// ---------------------------------------------------------------------------
+// fuzzyScoreSettingEntry — score an entry against a query for ranked search
+// ---------------------------------------------------------------------------
+
+/**
+ * Score a single SettingEntry against a search query.
+ *
+ * Score tiers (higher = better match):
+ *   - 3000–3999: exact key substring match (3000 + position bonus 0–999)
+ *   - 2000–2999: exact label substring match (2000 + position bonus 0–999)
+ *   - 1000–1999: exact description substring match (1000 + position bonus 0–999)
+ *   - 1–99:      subsequence match across key+label+description
+ *
+ * Returns null when the query does not match at all.
+ *
+ * @param query - The search string (already lowercased).
+ * @param entry - The setting entry to test.
+ * @param getLabel - Pure function mapping an entry to its display label.
+ */
+export function fuzzyScoreSettingEntry(
+  query: string,
+  entry: SettingEntry,
+  getLabel: (e: SettingEntry) => string,
+): number | null {
+  if (query.length === 0) return 0;
+  const lq = query.toLowerCase();
+  const key = entry.setting.key.toLowerCase();
+  const label = getLabel(entry).toLowerCase();
+  const description = (entry.setting.description ?? '').toLowerCase();
+
+  // Tier 1: key substring — base 3000, position bonus up to 999
+  // A key match at position 0 scores 3999; at position 999 scores 3000.
+  const keyIdx = key.indexOf(lq);
+  if (keyIdx !== -1) return 3000 + Math.max(0, 999 - keyIdx);
+
+  // Tier 2: label substring — base 2000, position bonus up to 999
+  const labelIdx = label.indexOf(lq);
+  if (labelIdx !== -1) return 2000 + Math.max(0, 999 - labelIdx);
+
+  // Tier 3: description substring — base 1000, position bonus up to 999
+  const descIdx = description.indexOf(lq);
+  if (descIdx !== -1) return 1000 + Math.max(0, 999 - descIdx);
+
+  // Tier 4: subsequence across concatenated key + label + description — 1..99
+  const haystack = `${key} ${label} ${description}`;
+  let qi = 0;
+  let score = 0;
+  for (let ci = 0; ci < haystack.length && qi < lq.length; ci++) {
+    if (haystack[ci] === lq[qi]) {
+      qi++;
+      score++;
+    }
+  }
+  if (qi === lq.length) return Math.min(99, score);
+  return null;
+}
+
+/**
+ * Search all setting entries across all groups, returning results ranked by
+ * relevance score (highest first). Excludes the flags, mcp, and subscriptions
+ * special categories (which have their own entry types).
+ *
+ * @param query - User input string. Empty string returns []. 
+ * @param groups - The settings group map from buildSettingGroups.
+ * @param getLabel - Pure function mapping an entry to its display label.
+ */
+export function searchSettingEntries(
+  query: string,
+  groups: Map<SettingsCategory, SettingEntry[]>,
+  getLabel: (e: SettingEntry) => string,
+): SettingEntry[] {
+  if (query.trim().length === 0) return [];
+  const lq = query.trim().toLowerCase();
+  const seen = new Set<string>();
+  const scored: Array<{ entry: SettingEntry; score: number }> = [];
+  for (const entries of groups.values()) {
+    for (const entry of entries) {
+      // Deduplicate: network tab cross-lists keys already in controlPlane/httpListener/web
+      if (seen.has(entry.setting.key)) continue;
+      seen.add(entry.setting.key);
+      const score = fuzzyScoreSettingEntry(lq, entry, getLabel);
+      if (score !== null) scored.push({ entry, score });
+    }
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.map(r => r.entry);
+}

package/src/input/settings-modal-types.ts

@@ -27,6 +27,7 @@ export type SettingsCategory =
   | 'network'
   | 'relay'
   | 'surfaces'
+  | 'device'
   | 'conversationGate'
   | 'cloudflare'
   | 'batch'
@@ -61,7 +62,7 @@ export const SETTINGS_CATEGORY_GROUPS: ReadonlyArray<{
   { label: 'Interface', categories: ['display', 'ui', 'behavior', 'notifications', 'permissions', 'policy', 'security'] },
   { label: 'AI Routing', categories: ['provider', 'pricing', 'subscriptions', 'helper', 'tools', 'tts', 'voice'] },
   { label: 'Service & Network', categories: ['service', 'daemon', 'network', 'controlPlane', 'httpListener', 'web', 'relay'] },
-  { label: 'Surfaces & Cloud', categories: ['surfaces', 'conversationGate', 'integrations', 'mcp', 'cloudflare'] },
+  { label: 'Surfaces & Cloud', categories: ['surfaces', 'device', 'conversationGate', 'integrations', 'mcp', 'cloudflare'] },
   { label: 'Automation', categories: ['batch', 'automation', 'checkin', 'watchers', 'orchestration', 'planner', 'wrfc'] },
   { label: 'Runtime & Data', categories: ['storage', 'atRest', 'sandbox', 'fetch', 'agents', 'runtime', 'power', 'memory', 'cache', 'telemetry', 'diagnostics', 'learning'] },
   { label: 'Advanced', categories: ['release', 'update', 'danger'] },

package/src/renderer/conversation-surface.ts

@@ -102,10 +102,14 @@ export function renderConversationFragment(
   content: string,
   width: number,
   palette: ConversationFragmentPalette,
+  indentCols = 0,
 ): Line[] {
-  const margin = LAYOUT.USER_BOX_MARGIN;
+  const margin = LAYOUT.USER_BOX_MARGIN + Math.max(0, indentCols);
   const prefixWidth = getDisplayWidth(palette.prefix);
-  const maxContentWidth = Math.max(1, width - (margin * 2) - prefixWidth - 2);
+  // The indent is charged to the content budget rather than allowed to push the
+  // fragment past the right edge — a narrow terminal shrinks the preview text
+  // instead of silently truncating its tail.
+  const maxContentWidth = Math.max(1, width - margin - LAYOUT.USER_BOX_MARGIN - prefixWidth - 2);
   const wrapped = wrapText(content, maxContentWidth);
   const contentWidth = wrapped.length > 0 ? Math.max(...wrapped.map((line) => getDisplayWidth(line))) : 0;
   const fragmentWidth = Math.max(prefixWidth + 2, prefixWidth + contentWidth + 2);
@@ -173,6 +177,8 @@ export function renderConversationCollapsedFragment(
     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, {
@@ -182,7 +188,7 @@ export function renderConversationCollapsedFragment(
     bodyBg: options.bodyBg ?? '#1a1a1a',
     dim: options.dim ?? true,
     italic: options.italic ?? false,
-  });
+  }, options.indentCols ?? 0);
 }
 
 export function renderConversationStatusLine(
@@ -193,17 +199,28 @@ export function renderConversationStatusLine(
     readonly markerFg?: string;
     readonly markerBg?: string;
     readonly bodyBg?: string;
+    /**
+     * Tree-branch indent in columns (see conversation-tree.ts). Shifts the
+     * marker and content columns together, so a branch row keeps the same
+     * marker→content relationship a flush row has. Callers pass an indent
+     * already clamped by treeIndentCols(), so this never eats the content
+     * budget below the guaranteed minimum.
+     */
+    readonly indentCols?: number;
   } = {},
 ): Line {
   const line = createEmptyLine(width);
-  const markerCol = LAYOUT.LEFT_MARGIN - 1;
-  const startCol = LAYOUT.LEFT_MARGIN + 1;
+  const indent = Math.max(0, options.indentCols ?? 0);
+  const markerCol = LAYOUT.LEFT_MARGIN - 1 + indent;
+  const startCol = LAYOUT.LEFT_MARGIN + 1 + indent;
   const endCol = Math.max(startCol, width - LAYOUT.RIGHT_MARGIN);
-  line[markerCol] = createStyledCell(options.marker ?? '▌', {
-    fg: options.markerFg ?? '#64748b',
-    bg: options.markerBg ?? options.bodyBg ?? '',
-    bold: true,
-  });
+  if (markerCol >= 0 && markerCol < width) {
+    line[markerCol] = createStyledCell(options.marker ?? '▌', {
+      fg: options.markerFg ?? '#64748b',
+      bg: options.markerBg ?? options.bodyBg ?? '',
+      bold: true,
+    });
+  }
   let col = startCol;
   for (const segment of segments) {
     if (col >= endCol) break;
@@ -222,11 +239,19 @@ export function renderConversationEventLine(
   width: number,
   tone: ConversationEventTone,
   details: readonly ConversationStatusSegment[] = [],
+  indentCols = 0,
 ): Line {
+  // An empty label is legitimate on a branch row: the tree already says what
+  // the row is (a result hanging under its call), so repeating "tool result"
+  // on every one of them is exactly the boilerplate this layout removes. The
+  // row then leads with its own first informative detail segment.
+  const labelSegments = tone.label
+    ? [{ text: ` ${tone.label} `, fg: tone.labelFg, bold: true }]
+    : [];
   return renderConversationStatusLine(
     width,
     [
-      { text: ` ${tone.label} `, fg: tone.labelFg, bold: true },
+      ...labelSegments,
       ...details.map((segment) => ({
         ...segment,
         fg: segment.fg || tone.detailFg || tone.labelFg,
@@ -235,6 +260,7 @@ export function renderConversationEventLine(
     {
       marker: tone.marker,
       markerFg: tone.markerFg,
+      indentCols,
     },
   );
 }