bingocode 1.1.200-beta.9 → 1.1.201

package/src/screens/ResumeConversation.tsx

@@ -100,6 +100,7 @@ export function ResumeConversation({
     agentName?: string;
     agentColor?: AgentColorName;
     mainThreadAgentDefinition?: AgentDefinition;
+    brainMode?: boolean;
   } | null>(null);
   const [crossProjectCommand, setCrossProjectCommand] = React.useState<string | null>(null);
   const sessionLogResultRef = React.useRef<SessionLogResult | null>(null);
@@ -250,6 +251,10 @@ export function ResumeConversation({
           standaloneAgentContext
         }));
       }
+      setAppState(prev_2 => ({
+        ...prev_2,
+        brainMode: result_3.brainMode ?? false
+      }));
       void updateSessionName(result_3.agentName);
       restoreSessionMetadata(forkSession ? {
         ...result_3,
@@ -279,7 +284,8 @@ export function ResumeConversation({
         contentReplacements: result_3.contentReplacements,
         agentName: result_3.agentName,
         agentColor: (result_3.agentColor === 'default' ? undefined : result_3.agentColor) as AgentColorName | undefined,
-        mainThreadAgentDefinition: resolvedAgentDef
+        mainThreadAgentDefinition: resolvedAgentDef,
+        brainMode: result_3.brainMode ?? false
       });
     } catch (e) {
       logEvent('tengu_session_resumed', {

package/src/server/api/providers.ts

@@ -25,6 +25,7 @@ import {
 import type { SlotName } from '../types/provider.js'
 import { ApiError, errorResponse } from '../middleware/errorHandler.js'
 
+
 const providerService = new ProviderService()
 providerService.init().catch((err) =>
   console.error('[ProviderService] init failed:', err),
@@ -42,6 +43,22 @@ function sanitizeProvider(provider: Record<string, unknown>): Record<string, unk
   return provider
 }
 
+function isLocalhostRequest(req: Request): boolean {
+  const origin = req.headers.get('Origin')
+  const host = req.headers.get('Host')
+  const isLocalOrigin =
+    !!origin &&
+    (origin.startsWith('http://localhost') ||
+      origin.startsWith('http://127.0.0.1') ||
+      origin.startsWith('http://[::1]'))
+  const isLocalHost =
+    !!host &&
+    (host.startsWith('localhost') ||
+      host.startsWith('127.0.0.1') ||
+      host.startsWith('[::1]'))
+  return isLocalOrigin || isLocalHost
+}
+
 export async function handleProvidersApi(
   req: Request,
   _url: URL,
@@ -81,6 +98,13 @@ export async function handleProvidersApi(
 
     // /api/providers/link-vscode — manage VS Code linking
     if (id === 'link-vscode' && !action) {
+      // Defense-in-depth: deny requests from non-localhost origins unconditionally
+      if (!isLocalhostRequest(req)) {
+        return Response.json(
+          { error: 'Forbidden', message: 'link-vscode only accessible from localhost' },
+          { status: 403 },
+        )
+      }
       if (req.method === 'GET') {
         const status = await providerService.getVscodeStatus()
         return Response.json(status)

package/src/server/config/providers.yaml

@@ -118,6 +118,27 @@ presets:
         secret: true
         placeholder: 'sk-...'
 
+  - id: nvidia
+    name: NVIDIA API
+    baseUrl: https://integrate.api.nvidia.com/v1
+    apiFormat: openai_chat
+    needsApiKey: true
+    websiteUrl: https://build.nvidia.com/explore/discover
+    modelsUrl: /models
+    modelsAuthStyle: bearer
+    modelsDataPath: data
+    fields:
+      - key: name
+        label: Provider Nickname
+        required: true
+        secret: false
+        placeholder: 'e.g. My NVIDIA'
+      - key: apiKey
+        label: API Key
+        required: true
+        secret: true
+        placeholder: 'nvapi-...'
+
   - id: zhipuglm
     name: Zhipu GLM
     baseUrl: https://open.bigmodel.cn/api/paas/v4

package/src/server/proxy/handler.ts

@@ -35,6 +35,19 @@ async function logToFile(message: string) {
   // Disabled log output for production
 }
 
+/**
+ * Normalize a base URL that may already contain a /v1 suffix,
+ * then append /v1/<path> so that double /v1 segments are avoided.
+ *
+ * Example:
+ *   "https://integrate.api.nvidia.com/v1" + "chat/completions"
+ *   => "https://integrate.api.nvidia.com/v1/chat/completions"   (not /v1/v1/...)
+ */
+function v1Url(baseUrl: string, path: string): string {
+  const normalized = baseUrl.replace(/\/v1\/?$/, '')
+  return `${normalized}/v1/${path.replace(/^\//, '')}`
+}
+
 function sendAnthropicError(message: string, _model: string | undefined, status = 502): Response {
   const fullMessage = `[Bingo Proxy] ${message}`
   void logToFile(`ERROR: ${fullMessage} (status: ${status})`)
@@ -176,7 +189,7 @@ async function handleAnthropicPassthrough(
   uiLabel: string | null = null,
   betaHeader: string | null = null,
 ): Promise<Response> {
-  const url = `${baseUrl}/v1/messages`
+  const url = v1Url(baseUrl, 'messages')
   const upstreamHeaders: Record<string, string> = {
     'Content-Type': 'application/json',
     'x-api-key': apiKey,
@@ -226,7 +239,7 @@ async function handleOpenaiChat(
   uiLabel: string | null = null,
 ): Promise<Response> {
   const transformed = anthropicToOpenaiChat(body)
-  const url = `${baseUrl}/v1/chat/completions`
+  const url = v1Url(baseUrl, 'chat/completions')
 
   const upstream = await fetch(url, {
     method: 'POST',
@@ -277,7 +290,7 @@ async function handleOpenaiResponses(
   uiLabel: string | null = null,
 ): Promise<Response> {
   const transformed = anthropicToOpenaiResponses(body)
-  const url = `${baseUrl}/v1/responses`
+  const url = v1Url(baseUrl, 'responses')
 
   const upstream = await fetch(url, {
     method: 'POST',

package/src/server/services/providerService.ts

@@ -9,6 +9,7 @@
 import * as fs from 'fs/promises'
 import * as path from 'path'
 import * as os from 'os'
+import { parse as parseJsonc } from 'jsonc-parser/lib/esm/main.js'
 import { getDirectFetchOptions } from '../../utils/proxy.ts'
 import { ApiError } from '../middleware/errorHandler.js'
 import { anthropicToOpenaiChat } from '../proxy/transform/anthropicToOpenaiChat.js'
@@ -32,6 +33,10 @@ import type {
 } from '../types/provider.ts'
 import { SlotTableSchema } from '../types/provider.ts'
 
+// NOTE: When the proxy is active, ANTHROPIC_AUTH_TOKEN is written as "proxy-managed"
+// (a sentinel placeholder). This tells the proxy to resolve the real API key from the
+// active provider config at request time. It is NOT a real credential and is expected
+// to be overwritten every time a provider is activated or VS Code is linked.
 const MANAGED_ENV_KEYS = [
   'ANTHROPIC_BASE_URL',
   'ANTHROPIC_AUTH_TOKEN',
@@ -264,6 +269,18 @@ export class ProviderService {
   // --- Settings sync ---
 
   private async syncToSettings(provider: SavedProvider): Promise<void> {
+    // Prefer slot-based model IDs when slots are configured, so that the
+    // slot table (set via "Configure Model Slots" in the TUI) is the single
+    // source of truth.  Falling back to provider.models only when no slots
+    // exist keeps things working for users who haven't configured slots yet.
+    const slots = await this.readSlots()
+    const hasSlots = Object.keys(slots).length > 0
+    if (hasSlots) {
+      await this.syncSettingsForSlots(slots)
+      return
+    }
+
+    // Legacy fallback: no slots configured — use provider.models directly
     const settings = await this.readSettings()
     const existingEnv = (settings.env as Record<string, string>) || {}
 
@@ -584,17 +601,24 @@ export class ProviderService {
    * Write claudeCode settings into ALL detected VS Code editor instances
    * (stable, Insiders, Cursor). Persists linked state in bingo settings so
    * it survives restarts.
+   *
+   * Fixes applied:
+   *   #8  - Saves deep copy of original settings.claudeCode as vscodePreLinkClaudeCode
+   *         so unlink can restore exactly what was there before.
+   *   #9  - Collects failed paths; on partial failure rollback successful writes.
+   *   #11 - Creates .bak backup before mutating VS Code settings.json; restores from
+   *         .bak or in-memory copy on write failure.
    */
-  async linkVscode(): Promise<{ paths: string[]; linked: boolean }> {
+  async linkVscode(): Promise<{ paths: string[]; linked: boolean; failedPaths?: string[] }> {
     const envVars = await this.buildVscodeEnvVars()
     const candidatePaths = getVscodeSettingsPaths()
     const writtenPaths: string[] = []
+    const failedPaths: string[] = []
 
-    // Save pre-link bingo env so we can restore it on disconnect.
-    const bingoSettings = await this.readSettings()
-    const preLinkEnv = bingoSettings.env ?? null
-    bingoSettings.vscodePreLinkEnv = preLinkEnv
-    await this.writeSettings(bingoSettings)
+    // Fix #8: Snapshot original VS Code claudeCode per path for unlink restore.
+    const vscodePreLinkClaudeCode: Record<string, unknown> = {}
+    // Fix #9: Backup original contents for rollback on partial failure.
+    const originalContents = new Map<string, string | null>()
 
     for (const settingsPath of candidatePaths) {
       // Only write if the editor config directory exists (editor is installed)
@@ -606,12 +630,31 @@ export class ProviderService {
       }
 
       let settings: Record<string, unknown> = {}
+      let originalContent: string | null = null
       try {
-        const raw = await fs.readFile(settingsPath, "utf-8")
-        settings = JSON.parse(raw)
+        originalContent = await fs.readFile(settingsPath, "utf-8")
+        // VS Code settings.json uses JSONC (JSON with comments) —
+        // parseJsonc handles comments/trailing commas, unlike JSON.parse
+        settings = parseJsonc(originalContent) as Record<string, unknown>
       } catch {
         // File does not exist yet — start fresh
       }
+      originalContents.set(settingsPath, originalContent)
+
+      // Fix #8: Save deep copy of original claudeCode before overwriting
+      vscodePreLinkClaudeCode[settingsPath] = settings.claudeCode !== undefined
+        ? JSON.parse(JSON.stringify(settings.claudeCode))
+        : undefined
+
+      // Fix #11: Write backup before mutating
+      if (originalContent !== null) {
+        const bakPath = `${settingsPath}.bak`
+        try {
+          await fs.writeFile(bakPath, originalContent, "utf-8")
+        } catch {
+          // best-effort backup — proceed without it
+        }
+      }
 
       settings.claudeCode = {
         ...(settings.claudeCode as Record<string, unknown> || {}),
@@ -620,9 +663,73 @@ export class ProviderService {
         environmentVariables: envVars,
       }
 
-      await fs.mkdir(path.dirname(settingsPath), { recursive: true })
-      await fs.writeFile(settingsPath, JSON.stringify(settings, null, 4) + '\n')
-      writtenPaths.push(settingsPath)
+      try {
+        await fs.mkdir(path.dirname(settingsPath), { recursive: true })
+        const tmpPath = `${settingsPath}.tmp.${Date.now()}`
+        await fs.writeFile(tmpPath, JSON.stringify(settings, null, 4) + '\n')
+        await fs.rename(tmpPath, settingsPath)
+        writtenPaths.push(settingsPath)
+      } catch (err) {
+        failedPaths.push(settingsPath)
+        console.error(
+          `[ProviderService] Failed to write VS Code settings to ${settingsPath}: ${err instanceof Error ? err.message : String(err)}`,
+        )
+
+        // Fix #11: Attempt restore from backup on write failure
+        if (originalContent !== null) {
+          try {
+            const tmpPath2 = `${settingsPath}.tmp.${Date.now()}`
+            await fs.writeFile(tmpPath2, originalContent, "utf-8")
+            await fs.rename(tmpPath2, settingsPath)
+            console.error(`[ProviderService] Restored ${settingsPath} from in-memory copy after write failure`)
+          } catch {
+            // In-memory restore failed, try .bak file
+            try {
+              await fs.copyFile(`${settingsPath}.bak`, settingsPath)
+              console.error(`[ProviderService] Restored ${settingsPath} from .bak after write failure`)
+            } catch (restoreErr) {
+              console.error(
+                `[ProviderService] Failed to restore ${settingsPath} after write failure: ${restoreErr instanceof Error ? restoreErr.message : String(restoreErr)}`,
+              )
+            }
+          }
+        }
+      }
+    }
+
+    // Clean up .bak files for successfully written paths
+    for (const p of writtenPaths) {
+      await fs.unlink(`${p}.bak`).catch(() => {})
+    }
+
+    // Fix #9: Rollback successful writes on partial failure for atomicity.
+    // If any writes failed AND some succeeded, attempt to restore originals.
+    if (failedPaths.length > 0 && writtenPaths.length > 0) {
+      console.error(
+        `[ProviderService] Partial VS Code link failure: ${writtenPaths.length} succeeded, ${failedPaths.length} failed. Rolling back successful writes.`,
+      )
+      let allRolledBack = true
+      for (const p of writtenPaths) {
+        const original = originalContents.get(p)
+        try {
+          if (original !== null) {
+            const tmpPath = `${p}.tmp.${Date.now()}`
+            await fs.writeFile(tmpPath, original, "utf-8")
+            await fs.rename(tmpPath, p)
+          } else {
+            await fs.unlink(p).catch(() => {})
+          }
+        } catch (rollbackErr) {
+          allRolledBack = false
+          console.error(
+            `[ProviderService] Rollback failed for ${p}: ${rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr)}`,
+          )
+        }
+      }
+      if (allRolledBack) {
+        writtenPaths.length = 0
+      }
+      // If rollback itself failed we have a mess — leave writtenPaths as-is so caller sees what happened.
     }
 
     if (writtenPaths.length === 0) {
@@ -632,45 +739,52 @@ export class ProviderService {
     }
 
     // Persist so re-sync on restart and unlink work correctly
+    const bingoSettings = await this.readSettings()
     bingoSettings.vscodeLinked = true
     bingoSettings.vscodeLinkedPaths = writtenPaths
+    bingoSettings.vscodePreLinkClaudeCode = vscodePreLinkClaudeCode
     bingoSettings.env = this.buildBingoEnv(envVars)
     await this.writeSettings(bingoSettings)
 
-    return { paths: writtenPaths, linked: true }
+    const result: { paths: string[]; linked: boolean; failedPaths?: string[] } = {
+      paths: writtenPaths,
+      linked: true,
+    }
+    if (failedPaths.length > 0) {
+      result.failedPaths = failedPaths
+    }
+    return result
   }
 
   /**
-   * Restore pre-link bingo env so the CLI no longer routes through the proxy,
-   * and reset VS Code settings to a clean state without disableLoginPrompt.
+   * Reset VS Code settings to pre-link state.  Does NOT touching bingo
+   * settings.env — the CLI keeps routing through the proxy independently.
    *
-   * Without this, the only way to stop VS Code from using bingo would be to
-   * delete ~/.claude/bingo/settings.json entirely — which would also kill CLI
-   * routing.  Saving/restoring the pre-link env keeps CLI and VS Code independent.
+   * Restores the original claudeCode snapshot (vscodePreLinkClaudeCode)
+   * when available, otherwise writes an override that points VS Code to
+   * api.anthropic.com so the extension shows its native login screen.
    */
   async unlinkVscode(): Promise<{ paths: string[]; linked: boolean }> {
     const bingoSettings = await this.readSettings()
     const linkedPaths = (bingoSettings.vscodeLinkedPaths as string[]) || []
 
-    // Restore bingo env to pre-link state
-    const preLinkEnv = bingoSettings.vscodePreLinkEnv
-    if (preLinkEnv !== undefined) {
-      if (preLinkEnv === null || Object.keys(preLinkEnv as Record<string, unknown>).length === 0) {
-        delete bingoSettings.env
-      } else {
-        bingoSettings.env = preLinkEnv
-      }
-      delete bingoSettings.vscodePreLinkEnv
-    }
+    // Restore original claudeCode snapshot per-path. Fall back to a clean
+    const preLinkClaudeCode =
+      (bingoSettings.vscodePreLinkClaudeCode as Record<string, unknown> | undefined) || {}
 
     for (const settingsPath of linkedPaths) {
       try {
         const raw = await fs.readFile(settingsPath, "utf-8")
-        const settings = JSON.parse(raw)
-        settings.claudeCode = {
+        const settings = parseJsonc(raw) as Record<string, unknown>
+        settings.claudeCode = preLinkClaudeCode[settingsPath] ?? {
           preferredLocation: "panel",
+          environmentVariables: [
+            { name: "ANTHROPIC_BASE_URL", value: "https://api.anthropic.com" },
+          ],
         }
-        await fs.writeFile(settingsPath, JSON.stringify(settings, null, 4) + '\n')
+        const tmpPath = `${settingsPath}.tmp.${Date.now()}`
+        await fs.writeFile(tmpPath, JSON.stringify(settings, null, 4) + '\n')
+        await fs.rename(tmpPath, settingsPath)
       } catch {
         // File may have been moved or deleted since linking — harmless
       }
@@ -678,6 +792,8 @@ export class ProviderService {
 
     bingoSettings.vscodeLinked = false
     delete bingoSettings.vscodeLinkedPaths
+    delete bingoSettings.vscodePreLinkClaudeCode
+    delete bingoSettings.vscodePreLinkEnv
     await this.writeSettings(bingoSettings)
 
     return { paths: linkedPaths, linked: false }
@@ -704,12 +820,26 @@ export class ProviderService {
     if (status.linked) {
       try {
         await this.linkVscode()
-      } catch {
-        // VS Code may have been uninstalled — clear stale state
-        const bingoSettings = await this.readSettings()
-        bingoSettings.vscodeLinked = false
-        delete bingoSettings.vscodeLinkedPaths
-        await this.writeSettings(bingoSettings)
+      } catch (err: unknown) {
+        console.error(
+          `[ProviderService] init: failed to re-sync VS Code link: ${err instanceof Error ? err.message : String(err)}`,
+        )
+
+        // Only clear linked state for "VS Code not installed" type errors.
+        // Disk failures, corrupt JSON, etc. are transient and should not
+        // silently destroy the user's linked state.
+        const isNotFound =
+          err instanceof Error &&
+          (err.message.includes('No VS Code installation detected') ||
+            ((err as { statusCode?: number }).statusCode === 400))
+
+        if (isNotFound) {
+          const bingoSettings = await this.readSettings()
+          bingoSettings.vscodeLinked = false
+          delete bingoSettings.vscodeLinkedPaths
+          await this.writeSettings(bingoSettings)
+        }
+        // For other errors, keep existing state — the link may be recoverable.
       }
     }
   }
@@ -903,10 +1033,10 @@ export class ProviderService {
       let transformedBody: unknown
       if (format === 'openai_chat') {
         transformedBody = anthropicToOpenaiChat(anthropicReq)
-        upstreamUrl = `${base}/v1/chat/completions`
+        upstreamUrl = v1Url(base, 'chat/completions')
       } else {
         transformedBody = anthropicToOpenaiResponses(anthropicReq)
-        upstreamUrl = `${base}/v1/responses`
+        upstreamUrl = v1Url(base, 'responses')
       }
 
       // Call upstream with transformed request
@@ -953,6 +1083,15 @@ export class ProviderService {
 
 // ─── Helpers ───────────────────────────────────────────────
 
+/**
+ * Normalize a base URL that may already contain a /v1 suffix,
+ * then append /v1/<path> so that double /v1 segments are avoided.
+ */
+function v1Url(base: string, path: string): string {
+  const normalized = base.replace(/\/v1\/?$/, '')
+  return `${normalized}/v1/${path.replace(/^\//, '')}`
+}
+
 function buildDirectTestRequest(
   base: string,
   apiKey: string,
@@ -963,21 +1102,21 @@ function buildDirectTestRequest(
 
   if (format === 'openai_chat') {
     return {
-      url: `${base}/v1/chat/completions`,
+      url: v1Url(base, 'chat/completions'),
       headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
       body: { model: modelId, max_tokens: 16, messages: [{ role: 'user', content: prompt }] },
     }
   }
   if (format === 'openai_responses') {
     return {
-      url: `${base}/v1/responses`,
+      url: v1Url(base, 'responses'),
       headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
       body: { model: modelId, max_output_tokens: 16, input: [{ type: 'message', role: 'user', content: prompt }] },
     }
   }
   // anthropic
   return {
-    url: `${base}/v1/messages`,
+    url: v1Url(base, 'messages'),
     headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' },
     body: { model: modelId, max_tokens: 16, messages: [{ role: 'user', content: prompt }] },
   }
@@ -1009,5 +1148,4 @@ function validateResponseBody(
     return { ok: false, error: 'Not a valid Anthropic Messages endpoint' }
   }
   return { ok: true, model: (body.model as string) || undefined }
-}
-
+}

package/src/tools/AgentTool/UI.tsx

@@ -5,7 +5,7 @@ import { ConfigurableShortcutHint } from 'src/components/ConfigurableShortcutHin
 import { CtrlOToExpand, SubAgentProvider } from 'src/components/CtrlOToExpand.js';
 import { Byline } from 'src/components/design-system/Byline.js';
 import { KeyboardShortcutHint } from 'src/components/design-system/KeyboardShortcutHint.js';
-import type { z } from 'zod/v4';
+import { z } from 'zod/v4';
 import { AgentProgressLine } from '../../components/AgentProgressLine.js';
 import { FallbackToolUseErrorMessage } from '../../components/FallbackToolUseErrorMessage.js';
 import { FallbackToolUseRejectedMessage } from '../../components/FallbackToolUseRejectedMessage.js';
@@ -15,14 +15,14 @@ import { MessageResponse } from '../../components/MessageResponse.js';
 import { ToolUseLoader } from '../../components/ToolUseLoader.js';
 import { Box, Text } from '../../ink.js';
 import { getDumpPromptsPath } from '../../services/api/dumpPrompts.js';
-import { findToolByName, type Tools } from '../../Tool.js';
+import { buildTool, findToolByName, toolMatchesName, type Tool, type Tools } from '../../Tool.js';
 import type { Message, ProgressMessage } from '../../types/message.js';
 import type { AgentToolProgress } from '../../types/tools.js';
 import { count } from '../../utils/array.js';
 import { getSearchOrReadFromContent, getSearchReadSummaryText } from '../../utils/collapseReadSearch.js';
 import { getDisplayPath } from '../../utils/file.js';
 import { formatDuration, formatNumber } from '../../utils/format.js';
-import { buildSubagentLookups, createAssistantMessage, EMPTY_LOOKUPS } from '../../utils/messages.js';
+import { buildSubagentLookups, createAssistantMessage, EMPTY_LOOKUPS, type MessageLookups } from '../../utils/messages.js';
 import type { ModelAlias } from '../../utils/model/aliases.js';
 import { getMainLoopModel, parseUserSpecifiedModel, renderModelName } from '../../utils/model/model.js';
 import type { Theme, ThemeName } from '../../utils/theme.js';
@@ -32,6 +32,58 @@ import { getAgentColor } from './agentColorManager.js';
 import { GENERAL_PURPOSE_AGENT } from './built-in/generalPurposeAgent.js';
 const MAX_PROGRESS_MESSAGES_TO_SHOW = 3;
 
+/**
+ * Create a minimal fallback Tool object for a sub-agent tool name not present
+ * in the coordinator's tool set. Used in brain mode where the coordinator only
+ * has [Agent, AskUserQuestion] but sub-agents use Read/Grep/Bash/Edit/etc.
+ * Without fallbacks, findToolByName returns null and renders blank lines.
+ */
+function createFallbackTool(name: string): Tool {
+  return buildTool({
+    name,
+    inputSchema: z.object({}).passthrough(),
+    description: async () => `Sub-agent tool: ${name}`,
+    call: async () => ({ data: {} as unknown }) as any,
+    maxResultSizeChars: 100_000,
+    prompt: async () => '',
+    mapToolResultToToolResultBlockParam: (_content: unknown, toolUseID: string) => ({
+      tool_use_id: toolUseID,
+      content: [{ type: 'text' as const, text: '' }],
+      type: 'tool_result' as const,
+    }),
+    renderToolUseMessage: (input: Record<string, unknown>) => {
+      const keys = Object.keys(input);
+      if (keys.length === 0) return '';
+      return keys.map(k => {
+        const v = input[k];
+        let s = typeof v === 'string' ? v : JSON.stringify(v);
+        if (s.length > 80) s = s.slice(0, 80) + '\u2026';
+        return `${k}: ${s}`;
+      }).join(', ');
+    },
+    renderToolResultMessage: () => null,
+  })
+}
+
+/**
+ * Given the result of buildSubagentLookups, create fallback Tool entries
+ * for any tool name not already in `tools`. Returns the original `tools`
+ * array if no new names are found. Avoids re-scanning progress data.
+ */
+function augmentToolsFromLookups(
+  tools: Tools,
+  lookups: MessageLookups,
+): Tools {
+  const toolNames = new Set<string>()
+  for (const block of lookups.toolUseByToolUseID.values()) {
+    toolNames.add(block.name)
+  }
+  if (toolNames.size === 0) return tools
+  const missing = [...toolNames].filter(n => !tools.some(t => toolMatchesName(t, n)))
+  if (missing.length === 0) return tools
+  return [...tools, ...missing.map(createFallbackTool)]
+}
+
 /**
  * Guard: checks if progress data has a `message` field (agent_progress or
  * skill_progress).  Other progress types (e.g. bash_progress forwarded from
@@ -262,12 +314,12 @@ function VerboseAgentTranscript(t0) {
     lookups: agentLookups,
     inProgressToolUseIDs
   } = t1;
-  let t2;
+  const augmentedTools = augmentToolsFromLookups(tools, agentLookups);  let t2;
   if ($[2] !== agentLookups || $[3] !== inProgressToolUseIDs || $[4] !== progressMessages || $[5] !== tools || $[6] !== verbose) {
     const filteredMessages = progressMessages.filter(_temp4);
     let t3;
     if ($[8] !== agentLookups || $[9] !== inProgressToolUseIDs || $[10] !== tools || $[11] !== verbose) {
-      t3 = progressMessage => <MessageResponse key={progressMessage.uuid} height={1}><MessageComponent message={progressMessage.data.message} lookups={agentLookups} addMargin={false} tools={tools} commands={[]} verbose={verbose} inProgressToolUseIDs={inProgressToolUseIDs} progressMessagesForMessage={[]} shouldAnimate={false} shouldShowDot={false} isTranscriptMode={false} isStatic={true} /></MessageResponse>;
+      t3 = progressMessage => <MessageResponse key={progressMessage.uuid} height={1}><MessageComponent message={progressMessage.data.message} lookups={agentLookups} addMargin={false} tools={augmentedTools} commands={[]} verbose={verbose} inProgressToolUseIDs={inProgressToolUseIDs} progressMessagesForMessage={[]} shouldAnimate={false} shouldShowDot={false} isTranscriptMode={false} isStatic={true} /></MessageResponse>;
       $[8] = agentLookups;
       $[9] = inProgressToolUseIDs;
       $[10] = tools;
@@ -384,6 +436,12 @@ export function renderToolResultMessage(data: Output, progressMessagesForMessage
       speed: null
     }
   });
+  const agentProgressData = progressMessagesForMessage
+    .filter((pm): pm is ProgressMessage<AgentToolProgress> => hasProgressMessage(pm.data))
+    .map(pm => pm.data)
+  const { lookups: resultLookups } = buildSubagentLookups(agentProgressData)
+  const augmentedTools = augmentToolsFromLookups(tools, resultLookups)
+
   return <Box flexDirection="column">
       {"external" === 'ant' && <MessageResponse>
           <Text color="warning">
@@ -394,13 +452,13 @@ export function renderToolResultMessage(data: Output, progressMessagesForMessage
           <AgentPromptDisplay prompt={prompt} theme={theme} />
         </MessageResponse>}
       {isTranscriptMode ? <SubAgentProvider>
-          <VerboseAgentTranscript progressMessages={progressMessagesForMessage} tools={tools} verbose={verbose} />
+          <VerboseAgentTranscript progressMessages={progressMessagesForMessage} tools={augmentedTools} verbose={verbose} />
         </SubAgentProvider> : null}
       {isTranscriptMode && content && content.length > 0 && <MessageResponse>
           <AgentResponseDisplay content={content} theme={theme} />
         </MessageResponse>}
       <MessageResponse height={1}>
-        <MessageComponent message={finalAssistantMessage} lookups={EMPTY_LOOKUPS} addMargin={false} tools={tools} commands={[]} verbose={verbose} inProgressToolUseIDs={new Set()} progressMessagesForMessage={[]} shouldAnimate={false} shouldShowDot={false} isTranscriptMode={false} isStatic={true} />
+        <MessageComponent message={finalAssistantMessage} lookups={EMPTY_LOOKUPS} addMargin={false} tools={augmentedTools} commands={[]} verbose={verbose} inProgressToolUseIDs={new Set()} progressMessagesForMessage={[]} shouldAnimate={false} shouldShowDot={false} isTranscriptMode={false} isStatic={true} />
       </MessageResponse>
       {!isTranscriptMode && <Text dimColor>
           {'  '}
@@ -540,6 +598,13 @@ export function renderToolUseProgressMessage(progressMessages: ProgressMessage<P
     lookups: subagentLookups,
     inProgressToolUseIDs: collapsedInProgressIDs
   } = buildSubagentLookups(progressMessages.filter((pm): pm is ProgressMessage<AgentToolProgress> => hasProgressMessage(pm.data)).map(pm => pm.data));
+
+  // Augment tools with fallback entries for sub-agent tools not in the
+  // coordinator's tool set. In brain mode the coordinator only has
+  // [Agent, AskUserQuestion], but sub-agents call Read/Grep/Bash/Edit/etc.
+  // Without fallbacks, findToolByName returns null and renders blank lines.
+  const augmentedTools = augmentToolsFromLookups(tools, subagentLookups);
+
   return <MessageResponse>
       <Box flexDirection="column">
         <SubAgentProvider>
@@ -558,7 +623,7 @@ export function renderToolUseProgressMessage(progressMessages: ProgressMessage<P
           // content (tool not found, renderToolUseMessage returns null)
           // doesn't leave a blank line. Tool call headers are single-line
           // anyway so truncation isn't needed.
-          return <MessageComponent key={processed.message.uuid} message={processed.message.data.message} lookups={subagentLookups} addMargin={false} tools={tools} commands={[]} verbose={verbose} inProgressToolUseIDs={collapsedInProgressIDs} progressMessagesForMessage={[]} shouldAnimate={false} shouldShowDot={false} style="condensed" isTranscriptMode={false} isStatic={true} />;
+          return <MessageComponent key={processed.message.uuid} message={processed.message.data.message} lookups={subagentLookups} addMargin={false} tools={augmentedTools} commands={[]} verbose={verbose} inProgressToolUseIDs={collapsedInProgressIDs} progressMessagesForMessage={[]} shouldAnimate={false} shouldShowDot={false} style="condensed" isTranscriptMode={false} isStatic={true} />;
         })}
         </SubAgentProvider>
         {hiddenToolUseCount > 0 && <Text dimColor>