circuschief 0.6.0 → 0.8.0

package/packages/server/src/services/sessionPrompts.js

@@ -1,5 +1,6 @@
 import { sessions, attachments, projects, kanbanBoards, kanbanLanes } from '../database.js';
 import { DEFAULT_SERVER_PORT, DEFAULT_SYSTEM_PROMPT } from '../../../shared/src/index.js';
+import { buildCommandButtonApiInstructions } from './commandButtonPrompts.js';
 
 /**
  * Get the base API URL for canvas and session operations.
@@ -161,10 +162,7 @@ CRITICAL: Do NOT start coding until you have presented a plan and received appro
  */
 function buildCanvasWriteSystemPrompt(session) {
   const apiUrl = getApiBaseUrl();
-  // Use root session ID, fall back to session.id if getRootSessionId returns null, fall back to 'unknown-session' if session is null
-  const sessionId = session
-    ? (sessions.getRootSessionId(session.id) || session.id)
-    : 'unknown-session';
+  const sessionId = session?.id || 'unknown-session';
   return `When you generate artifacts that should be displayed on the canvas (images, markdown documents, code snippets, data visualizations, PDFs), POST them to:
 
 POST ${apiUrl}/api/sessions/${sessionId}/canvas
@@ -186,10 +184,7 @@ The file type is automatically detected from the file extension. Supported forma
  */
 function buildCanvasReadSystemPrompt(session) {
   const apiUrl = getApiBaseUrl();
-  // Use root session ID, fall back to session.id if getRootSessionId returns null, fall back to 'unknown-session' if session is null
-  const sessionId = session
-    ? (sessions.getRootSessionId(session.id) || session.id)
-    : 'unknown-session';
+  const sessionId = session?.id || 'unknown-session';
   return `## Reading from Canvas
 
 To list all files on the canvas:
@@ -224,9 +219,10 @@ function buildSessionCrudOps(apiUrl, projectId) {
 \`\`\`bash
 curl -X POST ${apiUrl}/api/projects/${projectId}/sessions \\
   -H "Content-Type: application/json" \\
-  -d '{"prompt": "Your task description here", "name": "Optional session name"}'
+  -d '{"prompt": "Your task description here"}'
 \`\`\`
-Optional fields: \`name\`, \`mode\`, \`thinkingEnabled\` (boolean), \`effortLevel\` (low/medium/high/max/auto), \`gitBranch\`, \`gitMode\`, \`parentSessionId\` (to create a child session)
+Only \`prompt\` is required. Omitted settings are automatically derived from the project's session defaults, then system defaults, matching UI behavior.
+Optional override fields: \`name\`, \`mode\`, \`thinkingEnabled\` (boolean), \`effortLevel\` (low/medium/high/max/auto), \`model\`, \`providerId\`, \`gitBranch\`, \`gitMode\`, \`templateId\`, \`nextTemplateId\`, \`parentSessionId\` (to create a related follow-up session from the current session), \`startImmediately\`, \`scheduledAt\`, \`autoRescheduleEnabled\`, \`rescheduleDelayMinutes\`, \`rescheduleOnTokenLimit\`, \`rescheduleOnServiceError\`, \`maxRescheduleCount\`, \`maxTotalTokens\`, and \`rescheduleAtTokenCount\`.
 
 ### Send a Follow-up Message
 \`\`\`bash
@@ -257,8 +253,8 @@ curl -X PATCH ${apiUrl}/api/sessions/<session_id> \\
 \`\`\``;
 }
 
-/** Build project, notes, and summary operations section */
-function buildProjectNotesOps(apiUrl) {
+/** Build project and summary operations section */
+function buildProjectOps(apiUrl, sessionId) {
   return `### Project Operations
 \`\`\`bash
 curl ${apiUrl}/api/projects                          # List all projects
@@ -270,18 +266,10 @@ curl -X POST ${apiUrl}/api/projects \\
 \`\`\`
 Optional field: \`systemPrompt\`
 
-### Session Notes
+### Workflow Summary
 \`\`\`bash
-curl ${apiUrl}/api/sessions/<session_id>/notes       # Get notes
-curl -X POST ${apiUrl}/api/sessions/<session_id>/notes \\
-  -H "Content-Type: application/json" \\
-  -d '{"content": "Note content"}'
-\`\`\`
-
-### Session Summary
-\`\`\`bash
-curl "${apiUrl}/api/sessions/<session_id>/summary?generate=true"
-curl -X POST ${apiUrl}/api/sessions/<session_id>/summary  # Regenerate
+curl "${apiUrl}/api/sessions/${sessionId}/summary?generate=true"
+curl -X POST ${apiUrl}/api/sessions/${sessionId}/summary  # Regenerate
 \`\`\``;
 }
 
@@ -298,7 +286,7 @@ You can create and modify sessions in this system using curl or similar HTTP too
 
 ${buildSessionCrudOps(apiUrl, projectId)}
 
-${buildProjectNotesOps(apiUrl)}`;
+${buildProjectOps(apiUrl, sessionId)}`;
 }
 
 /**
@@ -335,7 +323,7 @@ ${laneContext}
 curl ${apiUrl}/api/projects/${projectId}/kanban
 \`\`\`
 
-### Add This Session to the Board
+### Add Current Workflow to the Board
 \`\`\`bash
 curl -X POST ${apiUrl}/api/projects/${projectId}/kanban/cards \\
   -H "Content-Type: application/json" \\
@@ -393,26 +381,6 @@ This session is running in an isolated git worktree:
 CRITICAL: Do NOT use \`cd\` to navigate to the main repository. Your working directory is already set to the worktree. Running \`cd /home/ubuntu/workspace/circus-chief && ...\` will escape the worktree isolation and affect the main repository instead.`;
 }
 
-/**
- * Build child session context for system prompt
- * @param {Object} session - Session object
- * @returns {string} Child session context or empty string
- */
-function buildChildSessionContext(session) {
-  if (!session || !session.parentSessionId) {
-    return '';
-  }
-
-  // Get root session ID using existing method
-  const rootSessionId = sessions.getRootSessionId(session.id);
-
-  return `## Child Session
-
-This session is part of a multi-session workflow:
-- Parent Session ID: ${session.parentSessionId}
-- Root Session ID: ${rootSessionId}`;
-}
-
 /**
  * Build the full system prompt configuration
  * @param {string} sessionId
@@ -422,14 +390,15 @@ This session is part of a multi-session workflow:
  * @returns {string} System prompt string
  */
 export function buildSystemPromptConfig(sessionId, projectId, customSystemPrompt, mode) {
+  const apiUrl = getApiBaseUrl();
   const session = sessions.getById(sessionId);
   const canvasWriteInstructions = buildCanvasWriteSystemPrompt(session);  // Pass session object
   const canvasReadInstructions = buildCanvasReadSystemPrompt(session);    // Pass session object
   const sessionApiInstructions = buildSessionApiInstructions(sessionId, projectId);
+  const commandButtonApiInstructions = buildCommandButtonApiInstructions(apiUrl, sessionId, projectId);
   const kanbanApiInstructions = buildKanbanApiInstructions(sessionId, projectId);
   const attachmentsContext = getSessionAttachmentsContext(sessionId);
   const worktreeContext = buildWorktreeContext(session);
-  const childSessionContext = buildChildSessionContext(session);
   const basePrompt = customSystemPrompt || DEFAULT_SYSTEM_PROMPT;
 
   // Prepend plan mode instructions if in plan mode
@@ -439,12 +408,12 @@ export function buildSystemPromptConfig(sessionId, projectId, customSystemPrompt
   const parts = [
     modePrompt,
     basePrompt,
-    childSessionContext,
     worktreeContext,
     attachmentsContext,
     canvasWriteInstructions,
     canvasReadInstructions,
     sessionApiInstructions,
+    commandButtonApiInstructions,
     kanbanApiInstructions
   ].filter(Boolean);
 

package/packages/server/src/services/sessionProvider.js

@@ -11,6 +11,16 @@ export function resolveProviderFromModel(modelId) {
   return modelProviders.getProviderByModelId(modelId);
 }
 
+export function resolveProviderMetadataFromModel(modelId) {
+  if (!modelId) {
+    return modelProviders.getById?.('anthropic-default') || null;
+  }
+  if (typeof modelProviders.getProviderMetadataByModelId === 'function') {
+    return modelProviders.getProviderMetadataByModelId(modelId);
+  }
+  return modelProviders.getProviderByModelId(modelId);
+}
+
 /**
  * Resolve the agent type (claude-code vs codex) for a given model ID.
  * Uses the owning provider's kind:
@@ -204,14 +214,12 @@ function stripAnthropicHostEnv(env) {
 
 function replaceWithCodexCliEnv(sessionEnv, providerEnv) {
   const target = sessionEnv;
-  const allowed = ['HOME', 'PATH', 'USER', 'LOGNAME', 'SHELL', 'TERM', 'LANG', 'LC_ALL', 'TMPDIR'];
-  const cleaned = {};
-  for (const key of allowed) {
-    if (target[key] !== undefined) cleaned[key] = target[key];
-  }
-  Object.assign(cleaned, providerEnv);
-  for (const key of Object.keys(target)) delete target[key];
-  Object.assign(target, cleaned);
+  delete target.OPENAI_API_KEY;
+  delete target.OPENAI_BASE_URL;
+  delete target.OPENAI_API_BASE;
+  delete target.OPENAI_ORG_ID;
+  delete target.OPENAI_PROJECT;
+  Object.assign(target, providerEnv);
 }
 
 function stripOpenAIBaseUrlUnlessProvided(sessionEnv, providerEnv) {

package/packages/server/src/services/streamEventCallbacks.js

@@ -3,71 +3,102 @@ import { broadcastToSession } from '../websocket.js';
 import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
 import * as summaryService from './summaryService.js';
 import * as kanbanService from './kanbanService.js';
+import { createVisibleFinalErrorMessage } from './visibleFinalErrorMessage.js';
 import {
   lastMessageIds,
   activeSessions,
   activeConversationIds,
+  finalErrorSessionIds,
   associateAndBroadcastWorkLogs,
   broadcastSessionStatus,
   broadcastChangesUpdate,
 } from './streamEventHandler.js';
 
 /**
- * Handle post-turn completion logic (after stream loop ends successfully)
- * Encapsulates the duplicated completion block from runSession/continueSession/continueSessionWithExistingMessage
+ * Associate work logs with the last message and clean up tracking state.
  * @param {string} sessionId
- * @param {string} workingDirectory
- * @param {{ handleTemplateTriggerIfNeeded?: Function, checkProactiveReschedule?: Function, handleAutoSendIfNeeded?: Function }} callbacks
  */
-export async function handleTurnCompletion(sessionId, workingDirectory, callbacks = {}) {
-  const { handleTemplateTriggerIfNeeded, checkProactiveReschedule: _checkProactiveReschedule, handleAutoSendIfNeeded } = callbacks;
-  // Associate work logs with the last message now that the turn is complete
+function associateAndCleanupWorkLogs(sessionId) {
   const lastMessageId = lastMessageIds.get(sessionId);
   if (lastMessageId) {
     associateAndBroadcastWorkLogs(sessionId, lastMessageId);
     lastMessageIds.delete(sessionId);
   }
+}
 
-  // Session ready for follow-up - set to waiting instead of completed
-  const activeSession = activeSessions.get(sessionId);
-  if (activeSession && !activeSession.controller?.signal?.aborted) {
-    sessions.update(sessionId, { status: 'waiting' });
-    broadcastSessionStatus(sessionId, 'waiting');
-
-    // Check if session should be proactively rescheduled based on token threshold
-    if (_checkProactiveReschedule) {
-      const wasRescheduled = await _checkProactiveReschedule(sessionId);
-      if (wasRescheduled) {
-        return true; // Session was rescheduled, don't continue with normal completion
-      }
+/**
+ * Handle post-turn activities for a session that's ready for follow-up.
+ * @param {string} sessionId
+ * @param {string} workingDirectory
+ * @param {{ checkProactiveReschedule?: Function, handleAutoSendIfNeeded?: Function, handleTemplateTriggerIfNeeded?: Function }} callbacks
+ * @returns {Promise<boolean>} True if rescheduled, false otherwise
+ */
+async function handleActiveSessionCompletion(sessionId, workingDirectory, callbacks) {
+  sessions.update(sessionId, { status: 'waiting', error: null });
+  broadcastSessionStatus(sessionId, 'waiting');
+
+  // Check if session should be proactively rescheduled based on token threshold
+  const { checkProactiveReschedule } = callbacks;
+  if (checkProactiveReschedule) {
+    const wasRescheduled = await checkProactiveReschedule(sessionId);
+    if (wasRescheduled) {
+      return true; // Session was rescheduled, don't continue with normal completion
     }
+  }
 
-    // Extract PR URL immediately (lightweight, no API call)
-    summaryService.extractPrUrlIfNeeded(sessionId);
-    // Trigger debounced summary generation on turn completion (not complete yet)
-    summaryService.onSessionActivity(sessionId);
+  // Extract PR URL immediately (lightweight, no API call)
+  summaryService.extractPrUrlIfNeeded(sessionId);
+  // Trigger debounced summary generation on turn completion (not complete yet)
+  summaryService.onSessionActivity(sessionId);
 
-    // Broadcast changes update when turn completes (real-time indicator)
-    const currentSession = sessions.getById(sessionId);
-    if (currentSession) {
-      await broadcastChangesUpdate(sessionId, currentSession.projectId, workingDirectory);
-    }
+  // Broadcast changes update when turn completes (real-time indicator)
+  const currentSession = sessions.getById(sessionId);
+  if (currentSession) {
+    await broadcastChangesUpdate(sessionId, currentSession.projectId, workingDirectory);
+  }
 
-    // Handle kanban lane movements based on targetLaneId
-    await kanbanService.handleTurnCompletion(sessionId);
+  // Handle kanban lane movements based on targetLaneId
+  await kanbanService.handleTurnCompletion(sessionId);
 
-    // Auto-send queued prompt if enabled (runs BEFORE template trigger)
-    let autoSendFired = false;
-    if (handleAutoSendIfNeeded) {
-      autoSendFired = await handleAutoSendIfNeeded(sessionId);
-    }
+  // Auto-send queued prompt if enabled (runs BEFORE template trigger)
+  const { handleAutoSendIfNeeded, handleTemplateTriggerIfNeeded } = callbacks;
+  let autoSendFired = false;
+  if (handleAutoSendIfNeeded) {
+    autoSendFired = await handleAutoSendIfNeeded(sessionId);
+  }
 
-    // Only trigger next template if auto-send did NOT fire
-    // (if auto-send fired, template will trigger after that turn completes)
-    if (!autoSendFired && handleTemplateTriggerIfNeeded) {
-      await handleTemplateTriggerIfNeeded(sessionId);
-    }
+  // Only trigger next template if auto-send did NOT fire
+  // (if auto-send fired, template will trigger after that turn completes)
+  if (!autoSendFired && handleTemplateTriggerIfNeeded) {
+    await handleTemplateTriggerIfNeeded(sessionId);
   }
+
+  return false;
+}
+
+/**
+ * Handle post-turn completion logic (after stream loop ends successfully)
+ * Encapsulates the duplicated completion block from runSession/continueSession/continueSessionWithExistingMessage
+ * @param {string} sessionId
+ * @param {string} workingDirectory
+ * @param {{ handleTemplateTriggerIfNeeded?: Function, checkProactiveReschedule?: Function, handleAutoSendIfNeeded?: Function }} callbacks
+ */
+export async function handleTurnCompletion(sessionId, workingDirectory, callbacks = {}) {
+  // Associate work logs with the last message now that the turn is complete
+  associateAndCleanupWorkLogs(sessionId);
+
+  // Sessions with final errors should not transition to waiting
+  if (finalErrorSessionIds.has(sessionId)) {
+    finalErrorSessionIds.delete(sessionId);
+    return false;
+  }
+
+  // Session ready for follow-up - set to waiting instead of completed
+  const activeSession = activeSessions.get(sessionId);
+  if (activeSession && !activeSession.controller?.signal?.aborted) {
+    return handleActiveSessionCompletion(sessionId, workingDirectory, callbacks);
+  }
+
   return false;
 }
 
@@ -149,6 +180,7 @@ export async function handleSessionError(sessionId, error, options = {}) {
 
   // Normal error handling (no reschedule or reschedule limits reached)
   sessions.update(sessionId, { status: 'error', error: error.message });
+  createVisibleFinalErrorMessage(sessionId, error, activeConversationIds);
   broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_ERROR, { sessionId, error: error.message });
 
   // Optionally broadcast final conversation state (continueSession does this)

package/packages/server/src/services/streamEventHandler.js

@@ -10,6 +10,10 @@ import {
   handleTextDelta as _handleTextDelta,
   handleResultUsage,
 } from './streamUsageHandler.js';
+import {
+  createVisibleFinalErrorMessage,
+  normalizeFinalErrorMessage,
+} from './visibleFinalErrorMessage.js';
 
 // ── Shared module-level state ──────────────────────────────────────────────
 
@@ -34,6 +38,9 @@ export const currentModels = new Map();
 /** @type {Map<string, Set<string>>} Track tool_use IDs that have already been logged per session */
 export const loggedToolUseIds = new Map();
 
+/** @type {Set<string>} Track sessions that received a final result.error event */
+export const finalErrorSessionIds = new Set();
+
 // ── Helper functions ───────────────────────────────────────────────────────
 
 /**
@@ -404,8 +411,11 @@ function handleResultEvent(sessionId, event) {
  * @param {Object} event
  */
 function handleResultError(sessionId, event) {
-  sessions.update(sessionId, { status: 'error', error: event.error });
-  broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_ERROR, { sessionId, error: event.error });
+  const errorMessage = normalizeFinalErrorMessage(event.error);
+  finalErrorSessionIds.add(sessionId);
+  sessions.update(sessionId, { status: 'error', error: errorMessage });
+  createVisibleFinalErrorMessage(sessionId, errorMessage, activeConversationIds);
+  broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_ERROR, { sessionId, error: errorMessage });
   // Broadcast error status to project subscribers for session list updates
   broadcastSessionStatus(sessionId, 'error');
   // Extract PR URL before generating summary (PR may have been created before error)
@@ -481,6 +491,7 @@ export function cleanupSessionState(sessionId, includeConversationId = false) {
   thinkingAccumulators.delete(sessionId);
   currentModels.delete(sessionId);
   loggedToolUseIds.delete(sessionId);
+  finalErrorSessionIds.delete(sessionId);
   activeSessions.delete(sessionId);
   if (includeConversationId) {
     activeConversationIds.delete(sessionId);

package/packages/server/src/services/streamUsageHandler.js

@@ -74,6 +74,7 @@ export function handleTextDelta(sessionId, delta, textAccumulators) {
   const turnData = currentTurnUsage.get(conversationId) || {
     inputTokens: 0,
     outputTokens: 0,
+    thinkingTokens: 0,
     lastMessageOutput: 0,
     cacheReadInputTokens: 0,
     cacheCreationInputTokens: 0,
@@ -83,6 +84,7 @@ export function handleTextDelta(sessionId, delta, textAccumulators) {
   const broadcastUsage = {
     inputTokens: turnData.inputTokens,
     outputTokens: turnData.outputTokens + Math.max(turnData.lastMessageOutput, newEstimate),
+    thinkingTokens: turnData.thinkingTokens,
     cacheReadInputTokens: turnData.cacheReadInputTokens,
     cacheCreationInputTokens: turnData.cacheCreationInputTokens,
   };
@@ -123,6 +125,7 @@ export function extractTurnUsage(sessionId, event) {
   return {
     inputTokens: resolveTokenField(modelUsageEntry, event.usage, { camel: 'inputTokens', snake: 'input_tokens' }),
     outputTokens: resolveTokenField(modelUsageEntry, event.usage, { camel: 'outputTokens', snake: 'output_tokens' }),
+    thinkingTokens: resolveTokenField(modelUsageEntry, event.usage, { camel: 'thinkingTokens', snake: 'thinking_tokens' }),
     cacheReadInputTokens: resolveTokenField(modelUsageEntry, event.usage, { camel: 'cacheReadInputTokens', snake: 'cache_read_input_tokens' }),
     cacheCreationInputTokens: resolveTokenField(modelUsageEntry, event.usage, { camel: 'cacheCreationInputTokens', snake: 'cache_creation_input_tokens' }),
     webSearchRequests: modelUsageEntry?.webSearchRequests || 0,
@@ -142,6 +145,7 @@ export function buildCumulativeSessionUsage(sessionId, turnUsage) {
   return {
     inputTokens: (currentSession.inputTokens || 0) + turnUsage.inputTokens,
     outputTokens: (currentSession.outputTokens || 0) + turnUsage.outputTokens,
+    thinkingTokens: (currentSession.thinkingTokens || 0) + turnUsage.thinkingTokens,
     cacheReadInputTokens: (currentSession.cacheReadInputTokens || 0) + turnUsage.cacheReadInputTokens,
     cacheCreationInputTokens: (currentSession.cacheCreationInputTokens || 0) + turnUsage.cacheCreationInputTokens,
     webSearchRequests: (currentSession.webSearchRequests || 0) + turnUsage.webSearchRequests,
@@ -162,6 +166,7 @@ export function updateConversationUsage(conversationId, currentConversation, tur
   const cumulativeConversationUsage = {
     inputTokens: (currentConversation.inputTokens || 0) + turnUsage.inputTokens,
     outputTokens: (currentConversation.outputTokens || 0) + turnUsage.outputTokens,
+    thinkingTokens: (currentConversation.thinkingTokens || 0) + turnUsage.thinkingTokens,
     cacheReadInputTokens: (currentConversation.cacheReadInputTokens || 0) + turnUsage.cacheReadInputTokens,
     cacheCreationInputTokens: (currentConversation.cacheCreationInputTokens || 0) + turnUsage.cacheCreationInputTokens,
     webSearchRequests: (currentConversation.webSearchRequests || 0) + turnUsage.webSearchRequests,
@@ -197,6 +202,7 @@ export function handleResultUsage(sessionId, event) {
     usage: updatedConversation ? {
       inputTokens: updatedConversation.inputTokens,
       outputTokens: updatedConversation.outputTokens,
+      thinkingTokens: updatedConversation.thinkingTokens,
       cacheReadInputTokens: updatedConversation.cacheReadInputTokens,
       cacheCreationInputTokens: updatedConversation.cacheCreationInputTokens,
       webSearchRequests: updatedConversation.webSearchRequests,

package/packages/server/src/services/summaryClaudeClient.js

@@ -49,11 +49,16 @@ function logResultUsage(callId, event) {
 /**
  * Build the query parameters for the Claude SDK call.
  * @param {string} prompt - The prompt to send
- * @param {{ systemPrompt?: string, jsonSchema?: Object }} options
+ * @param {{ systemPrompt?: string, jsonSchema?: Object, model?: string, env?: Object }} options
  * @returns {Object} queryParams ready for the SDK query function
  */
 function buildClaudeRequest(prompt, options) {
-  const { systemPrompt = null, jsonSchema = null } = options || {};
+  const {
+    systemPrompt = null,
+    jsonSchema = null,
+    model = 'claude-haiku-4-5-20251001',
+    env = null,
+  } = options || {};
   const schema = jsonSchema || SESSION_SUMMARY_SCHEMA;
 
   return {
@@ -62,7 +67,8 @@ function buildClaudeRequest(prompt, options) {
       cwd: process.cwd(),
       permissionMode: 'bypassPermissions',
       maxTurns: 1,
-      model: 'claude-haiku-4-5-20251001',
+      model,
+      ...(env && { env }),
       ...(systemPrompt && { systemPrompt }),
       outputFormat: {
         type: 'json_schema',
@@ -108,6 +114,21 @@ async function handleClaudeResponse(eventStream, callId) {
   return state.responseText;
 }
 
+function buildSummaryCallMetadata({ logMeta, model, providerId, selectionReason, promptLength }) {
+  return {
+    sessionId: logMeta.sessionId,
+    conversationId: logMeta.conversationId || null,
+    agentType: 'summary',
+    model,
+    callType: logMeta.callType,
+    promptLength,
+    metadata: {
+      ...(providerId ? { providerId } : {}),
+      ...(selectionReason ? { selectionReason } : {}),
+    },
+  };
+}
+
 export const SESSION_SUMMARY_SCHEMA = {
   type: 'object',
   properties: {
@@ -130,11 +151,16 @@ export const SESSION_SUMMARY_SCHEMA = {
  * @param {string} prompt - The prompt to send
  * @param {Array} recentMessages - Messages (for mock mode context)
  * @param {string} sessionStatus - Session status (for mock mode context)
- * @param {{ logMeta?: Object, systemPrompt?: string, jsonSchema?: Object }} options - Optional parameters
+ * @param {{ logMeta?: Object, systemPrompt?: string, jsonSchema?: Object, model?: string, env?: Object, providerId?: string|null, selectionReason?: string }} options - Optional parameters
  * @returns {Promise<string>} The text response (JSON string)
  */
 export async function callClaude(prompt, recentMessages, sessionStatus, options = {}) {
-  const { logMeta = null } = options || {};
+  const {
+    logMeta = null,
+    model = 'claude-haiku-4-5-20251001',
+    providerId = null,
+    selectionReason = null,
+  } = options || {};
   // Build stable key for VCR cassette (session prompts are hardcoded strings in E2E tests)
   let keyHint = null;
   if (process.env.VCR_MODE && logMeta?.sessionId) {
@@ -151,14 +177,13 @@ export async function callClaude(prompt, recentMessages, sessionStatus, options
   // Start logging if metadata provided
   let callId = null;
   if (logMeta) {
-    callId = agentCallLogger.startCall({
-      sessionId: logMeta.sessionId,
-      conversationId: logMeta.conversationId || null,
-      agentType: 'summary',
-      model: 'claude-haiku-4-5-20251001',
-      callType: logMeta.callType,
+    callId = agentCallLogger.startCall(buildSummaryCallMetadata({
+      logMeta,
+      model,
+      providerId,
+      selectionReason,
       promptLength: prompt.length,
-    });
+    }));
   }
 
   try {