feat(advisor): render /advisor calls as tool rows with token accounting

package.json

@@ -45,7 +45,9 @@
     "test:coverage:critical": "vitest run --coverage --config vitest.critical.config.ts",
     "standalone": "tsx src/main/standalone.ts",
     "standalone:build": "electron-vite build && vite build --config vite.standalone.config.ts",
-    "standalone:start": "node dist-standalone/index.cjs"
+    "standalone:start": "node dist-standalone/index.cjs",
+    "standalone:kill": "PIDS=$(lsof -ti :3456); [ -n \"$PIDS\" ] && kill -9 $PIDS || true",
+    "standalone:restart": "pnpm standalone:kill && pnpm standalone:build && pnpm standalone:start"
   },
   "dependencies": {
     "@dnd-kit/core": "^6.3.1",

src/main/services/analysis/SemanticStepExtractor.ts

@@ -90,6 +90,42 @@ export function extractSemanticStepsFromAIChunk(chunk: AIChunk | EnhancedAIChunk
           });
         }
 
+        if (block.type === 'server_tool_use' && block.name === 'advisor' && block.id) {
+          // advisor CALL — input is empty so callTokens stay undefined (fallback estimates ~0)
+          steps.push({
+            id: block.id,
+            type: 'tool_call',
+            startTime: new Date(msg.timestamp),
+            durationMs: 0,
+            content: {
+              toolName: 'advisor',
+              toolInput: {},
+              sourceModel: msg.advisorModel,
+            },
+            context: msg.agentId ? 'subagent' : 'main',
+            agentId: msg.agentId,
+            sourceMessageId: msg.uuid,
+          });
+        }
+
+        if (block.type === 'advisor_tool_result' && block.tool_use_id) {
+          // advisor RESULT — advice text is real consumed context, counted like any tool result
+          const advisorText = block.content?.text ?? '';
+          steps.push({
+            id: block.tool_use_id,
+            type: 'tool_result',
+            startTime: new Date(msg.timestamp),
+            durationMs: 0,
+            content: {
+              toolResultContent: advisorText,
+              isError: false,
+              tokenCount: advisorText ? countContentTokens(advisorText) : 0,
+            },
+            context: msg.agentId ? 'subagent' : 'main',
+            agentId: msg.agentId,
+          });
+        }
+
         if (block.type === 'text' && block.text) {
           // Calculate tokens for text output (Claude's generated text)
           const textTokens = countContentTokens(block.text);

src/main/types/jsonl.ts

@@ -20,7 +20,14 @@ type EntryType =
   | 'file-history-snapshot'
   | 'queue-operation';
 
-type ContentType = 'text' | 'thinking' | 'tool_use' | 'tool_result' | 'image';
+type ContentType =
+  | 'text'
+  | 'thinking'
+  | 'tool_use'
+  | 'tool_result'
+  | 'image'
+  | 'server_tool_use'
+  | 'advisor_tool_result';
 
 type StopReason = 'end_turn' | 'tool_use' | 'max_tokens' | 'stop_sequence' | null;
 
@@ -66,12 +73,27 @@ export interface ImageContent extends BaseContent {
   };
 }
 
+export interface ServerToolUseContent extends BaseContent {
+  type: 'server_tool_use';
+  id: string;
+  name: string;
+  input?: Record<string, unknown>;
+}
+
+export interface AdvisorToolResultContent extends BaseContent {
+  type: 'advisor_tool_result';
+  tool_use_id: string;
+  content: { type: 'advisor_result'; text: string };
+}
+
 export type ContentBlock =
   | TextContent
   | ThinkingContent
   | ToolUseContent
   | ToolResultContent
-  | ImageContent;
+  | ImageContent
+  | ServerToolUseContent
+  | AdvisorToolResultContent;
 
 // =============================================================================
 // Usage Metadata
@@ -178,6 +200,7 @@ export interface AssistantEntry extends ConversationalEntry {
   message: AssistantMessage;
   requestId: string;
   agentId?: string;
+  advisorModel?: string;
 }
 
 export interface SystemEntry extends ConversationalEntry {

src/main/types/messages.ts

@@ -77,6 +77,8 @@ export interface ParsedMessage {
   usage?: TokenUsage;
   /** Model used for this response */
   model?: string;
+  /** Advisor model identifier; set only when this entry invoked the advisor tool. */
+  advisorModel?: string;
   // Metadata
   /** Current working directory when message was created */
   cwd?: string;

src/main/utils/jsonl.ts

@@ -117,6 +117,7 @@ function parseChatHistoryEntry(entry: ChatHistoryEntry): ParsedMessage | null {
   let role: string | undefined;
   let usage: TokenUsage | undefined;
   let model: string | undefined;
+  let advisorModel: string | undefined;
   let requestId: string | undefined;
   let cwd: string | undefined;
   let gitBranch: string | undefined;
@@ -155,6 +156,7 @@ function parseChatHistoryEntry(entry: ChatHistoryEntry): ParsedMessage | null {
       role = entry.message.role;
       usage = entry.message.usage;
       model = entry.message.model;
+      advisorModel = entry.advisorModel;
       agentId = entry.agentId;
       requestId = entry.requestId;
     } else if (entry.type === 'system') {
@@ -175,6 +177,7 @@ function parseChatHistoryEntry(entry: ChatHistoryEntry): ParsedMessage | null {
     content,
     usage,
     model,
+    advisorModel,
     // Metadata
     cwd,
     gitBranch,

src/renderer/components/chat/SessionContextPanel/components/RankedInjectionList.tsx

@@ -10,6 +10,7 @@ import React, { useMemo, useState } from 'react';
 
 import { CopyButton } from '@renderer/components/common/CopyButton';
 import { COLOR_TEXT_MUTED, COLOR_TEXT_SECONDARY } from '@renderer/constants/cssVariables';
+import { capitalize } from '@renderer/utils/stringUtils';
 import { ChevronRight } from 'lucide-react';
 
 import { formatTokens } from '../utils/formatting';
@@ -165,7 +166,7 @@ const ToolOutputRankedItem = ({
                 className="shrink-0 rounded px-1.5 py-0.5 text-[9px] font-medium"
                 style={{ backgroundColor: categoryInfo.bg, color: categoryInfo.text }}
               >
-                {tool.toolName}
+                {capitalize(tool.toolName)}
               </span>
               <span className="flex-1" />
               <span

src/renderer/components/chat/SessionContextPanel/items/ToolBreakdownItem.tsx

@@ -4,6 +4,8 @@
 
 import React from 'react';
 
+import { capitalize } from '@renderer/utils/stringUtils';
+
 import { formatTokens } from '../utils/formatting';
 
 import type { ToolTokenBreakdown } from '@renderer/types/contextInjection';
@@ -17,7 +19,7 @@ export const ToolBreakdownItem = ({
 }: Readonly<ToolBreakdownItemProps>): React.ReactElement => {
   return (
     <div className="flex items-center gap-2 py-0.5 text-xs">
-      <span style={{ color: 'var(--color-text-muted)' }}>{tool.toolName}</span>
+      <span style={{ color: 'var(--color-text-muted)' }}>{capitalize(tool.toolName)}</span>
       <span style={{ color: 'var(--color-text-muted)', opacity: 0.7 }}>
         ~{formatTokens(tool.tokenCount)}
       </span>

src/renderer/components/chat/items/LinkedToolItem.tsx

@@ -10,6 +10,7 @@ import React, { useRef } from 'react';
 
 import { CARD_ICON_MUTED } from '@renderer/constants/cssVariables';
 import { getTeamColorSet } from '@renderer/constants/teamColors';
+import { capitalize } from '@renderer/utils/stringUtils';
 import {
   getToolContextTokens,
   getToolStatus,
@@ -65,7 +66,7 @@ export const LinkedToolItem: React.FC<LinkedToolItemProps> = React.memo(function
   registerRef,
 }) {
   const status = getToolStatus(linkedTool);
-  const summary = getToolSummary(linkedTool.name, linkedTool.input);
+  const summary = getToolSummary(linkedTool.name, linkedTool.input, linkedTool.sourceModel);
   const elementRef = useRef<HTMLDivElement>(null);
 
   // Combined ref callback - handles both internal ref and external registration
@@ -154,7 +155,7 @@ export const LinkedToolItem: React.FC<LinkedToolItemProps> = React.memo(function
             style={{ color: isHighlighted ? getTriggerColorDef(highlightColor).hex : undefined }}
           />
         }
-        label={linkedTool.name}
+        label={capitalize(linkedTool.name)}
         summary={summary}
         tokenCount={getToolContextTokens(linkedTool)}
         status={status}

src/renderer/components/chat/items/linkedTool/renderHelpers.tsx

@@ -15,6 +15,7 @@ import {
 
 /**
  * Renders the input section based on tool type with theme-aware styling.
+ * Returns a "no parameters" placeholder when input is an empty object.
  */
 export function renderInput(toolName: string, input: Record<string, unknown>): React.ReactElement {
   // Special rendering for Edit tool - show diff-like format
@@ -95,6 +96,10 @@ export function renderInput(toolName: string, input: Record<string, unknown>): R
     );
   }
 
+  if (Object.keys(input).length === 0) {
+    return <span style={{ color: COLOR_TEXT_MUTED }}>no parameters</span>;
+  }
+
   // Default: key-value format with readable string values
   return (
     <div className="space-y-2" style={{ color: COLOR_TEXT }}>
@@ -152,7 +157,7 @@ export function extractOutputText(content: string | unknown[]): string {
       .map((block) =>
         typeof block === 'object' && block !== null && 'text' in block
           ? (block as { text: string }).text
-          : JSON.stringify(block, null, 2),
+          : JSON.stringify(block, null, 2)
       )
       .join('\n');
   } else {

src/renderer/utils/displayItemBuilder.ts

@@ -425,8 +425,7 @@ export function buildDisplayItemsFromMessages(
       }
       // Only treat as subagent input if there are NO tool_result blocks in this message
       const hasToolResults =
-        Array.isArray(msg.content) &&
-        msg.content.some((b) => b.type === 'tool_result');
+        Array.isArray(msg.content) && msg.content.some((b) => b.type === 'tool_result');
       if (rawText.trim() && !hasToolResults) {
         displayItems.push({
           type: 'subagent_input',
@@ -460,6 +459,21 @@ export function buildDisplayItemsFromMessages(
             sourceMessageId: msg.uuid,
             sourceModel: msg.model,
           });
+        } else if (block.type === 'server_tool_use' && block.name === 'advisor' && block.id) {
+          toolCallsById.set(block.id, {
+            id: block.id,
+            name: 'advisor',
+            input: {},
+            timestamp: msgTimestamp,
+            sourceMessageId: msg.uuid,
+            sourceModel: msg.advisorModel,
+          });
+        } else if (block.type === 'advisor_tool_result' && block.tool_use_id) {
+          toolResultsById.set(block.tool_use_id, {
+            content: block.content?.text ?? '',
+            isError: false,
+            timestamp: msgTimestamp,
+          });
         } else if (block.type === 'text' && block.text) {
           // Add text output
           displayItems.push({

src/renderer/utils/stringUtils.ts

@@ -21,6 +21,19 @@ export function generateUUID(): string {
   return `${hex.slice(0, 4).join('')}-${hex.slice(4, 6).join('')}-${hex.slice(6, 8).join('')}-${hex.slice(8, 10).join('')}-${hex.slice(10).join('')}`;
 }
 
+/**
+ * Capitalizes the first character of a string, leaving the rest unchanged.
+ * Used for tool-name display labels so server tools like `advisor` render as `Advisor`
+ * while already-PascalCase names (Bash, Read, …) are unaffected.
+ *
+ * @example capitalize('advisor') → 'Advisor'
+ * @example capitalize('Bash') → 'Bash'
+ */
+export function capitalize(text: string): string {
+  if (!text) return text;
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
 const isMacPlatform =
   typeof window !== 'undefined' && window.navigator.userAgent.includes('Macintosh');
 

src/renderer/utils/toolLinkingEngine.ts

@@ -81,13 +81,16 @@ export function linkToolCallsToResults(
 
     // Calculate callTokens directly from tool name + input
     // This reflects what actually enters the context window (not proportioned output_tokens)
-    const callTokens = estimateTokens(toolName + JSON.stringify(toolInput));
+    // advisor input is empty ({}), so callTokens stays undefined and the fallback estimates ~0
+    const callTokens =
+      toolName === 'advisor' ? undefined : estimateTokens(toolName + JSON.stringify(toolInput));
 
     const linkedItem: LinkedToolItem = {
       id: toolCallId,
       name: toolName,
       input: toolInput as Record<string, unknown>,
-      callTokens, // Token count for tool call (what Claude generated)
+      callTokens,
+      sourceModel: callStep.content.sourceModel, // carried from the call step (advisor model)
       result: resultStep
         ? {
             content: resultStep.content.toolResultContent ?? '',

src/renderer/utils/toolRendering/toolSummaryHelpers.ts

@@ -16,9 +16,19 @@ function truncate(str: string, maxLength: number): string {
 
 /**
  * Generates a human-readable summary for a tool call.
+ *
+ * @param sourceModel - For server tools (advisor), the model that served the call;
+ *   shown as the summary so the reader sees which model gave the advice.
  */
-export function getToolSummary(toolName: string, input: Record<string, unknown>): string {
+export function getToolSummary(
+  toolName: string,
+  input: Record<string, unknown>,
+  sourceModel?: string
+): string {
   switch (toolName) {
+    case 'advisor':
+      return sourceModel ?? 'advisor';
+
     case 'Edit': {
       const filePath = input.file_path as string | undefined;
       const oldString = input.old_string as string | undefined;

test/main/services/analysis/SemanticStepExtractor.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest';
+import { extractSemanticStepsFromAIChunk } from '../../../../src/main/services/analysis/SemanticStepExtractor';
+import type { AIChunk } from '../../../../src/main/types/chunks';
+import type { ParsedMessage } from '../../../../src/main/types/messages';
+import {
+  ADVISOR_CALL_ID,
+  ADVISOR_MODEL,
+  ADVISOR_TEXT,
+  advisorCallMessage,
+  advisorResultMessage,
+} from '../../../mocks/advisorBlocks.fixture';
+
+function makeChunk(responses: ParsedMessage[]): AIChunk {
+  return {
+    chunkType: 'ai',
+    id: 'chunk-1',
+    startTime: new Date('2026-06-06T10:00:00Z'),
+    responses,
+    processes: [],
+    sidechainMessages: [],
+    toolExecutions: [],
+    userMessage: null as unknown as ParsedMessage,
+  } as unknown as AIChunk;
+}
+
+describe('SemanticStepExtractor — advisor blocks', () => {
+  it('extracts a tool_call step from server_tool_use(advisor)', () => {
+    const chunk = makeChunk([advisorCallMessage]);
+    const steps = extractSemanticStepsFromAIChunk(chunk);
+
+    const callStep = steps.find((s) => s.type === 'tool_call' && s.content.toolName === 'advisor');
+    expect(callStep).toBeDefined();
+    expect(callStep!.id).toBe(ADVISOR_CALL_ID);
+    expect(callStep!.content.toolInput).toEqual({});
+    expect(callStep!.content.sourceModel).toBe(ADVISOR_MODEL);
+  });
+
+  it('does NOT add tokens to the advisor tool_call step', () => {
+    const chunk = makeChunk([advisorCallMessage]);
+    const steps = extractSemanticStepsFromAIChunk(chunk);
+
+    const callStep = steps.find((s) => s.type === 'tool_call' && s.content.toolName === 'advisor');
+    expect(callStep).toBeDefined();
+    expect(callStep!.tokens).toBeUndefined();
+    expect(callStep!.content.tokenCount).toBeUndefined();
+  });
+
+  it('extracts a tool_result step from advisor_tool_result', () => {
+    const chunk = makeChunk([advisorResultMessage]);
+    const steps = extractSemanticStepsFromAIChunk(chunk);
+
+    const resultStep = steps.find((s) => s.type === 'tool_result' && s.id === ADVISOR_CALL_ID);
+    expect(resultStep).toBeDefined();
+    expect(resultStep!.content.toolResultContent).toBe(ADVISOR_TEXT);
+    expect(resultStep!.content.isError).toBe(false);
+  });
+
+  it('counts the advisor result tokens from the advice text', () => {
+    const chunk = makeChunk([advisorResultMessage]);
+    const steps = extractSemanticStepsFromAIChunk(chunk);
+
+    const resultStep = steps.find((s) => s.type === 'tool_result' && s.id === ADVISOR_CALL_ID);
+    expect(resultStep).toBeDefined();
+    // 40 = countContentTokens(ADVISOR_TEXT) — literal guards against tautological re-import
+    expect(resultStep!.content.tokenCount).toBe(40);
+    expect(resultStep!.content.tokenCount).toBeGreaterThan(0);
+  });
+});