circuschief 0.1.0

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

@@ -0,0 +1,228 @@
+import { sessions, conversations } from '../database.js';
+import { broadcastToSession, broadcastToProject } from '../websocket.js';
+import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
+import { updateTurnUsage, currentTurnUsage, estimatedOutputTokens, estimateTokens } from './usageTracker.js';
+import { activeConversationIds, currentModels } from './streamEventHandler.js';
+
+// ── Stream usage helpers ────────────────────────────────────────────────────
+// Extracted from streamEventHandler.js to keep it under the max-lines limit.
+
+/**
+ * Handle stream_event > message_start — initial usage (input tokens)
+ * @param {string} sessionId
+ * @param {Object} event
+ */
+export function handleMessageStart(sessionId, event) {
+  const usage = event.event?.message?.usage;
+  if (usage) {
+    const conversationId = activeConversationIds.get(sessionId);
+    const turnUsage = updateTurnUsage(conversationId, usage, 'message_start');
+    broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_USAGE_UPDATE, {
+      sessionId,
+      conversationId,
+      usage: turnUsage,
+      isFinal: false,
+    });
+  }
+}
+
+/**
+ * Handle stream_event > message_delta — streaming output tokens
+ * @param {string} sessionId
+ * @param {Object} event
+ */
+export function handleMessageDelta(sessionId, event) {
+  const usage = event.event?.usage;
+  if (usage) {
+    const conversationId = activeConversationIds.get(sessionId);
+    const turnUsage = updateTurnUsage(conversationId, usage, 'message_delta');
+    broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_USAGE_UPDATE, {
+      sessionId,
+      conversationId,
+      usage: turnUsage,
+      isFinal: false,
+    });
+  }
+}
+
+/**
+ * Handle text_delta within content_block_delta — accumulate text and estimate tokens
+ * @param {string} sessionId
+ * @param {Object} delta
+ * @param {Map} textAccumulators
+ */
+export function handleTextDelta(sessionId, delta, textAccumulators) {
+  // Accumulate text content
+  const current = textAccumulators.get(sessionId) || '';
+  const accumulated = current + delta.text;
+  textAccumulators.set(sessionId, accumulated);
+
+  broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_PARTIAL, {
+    sessionId,
+    text: accumulated,
+  });
+
+  // Estimate tokens from streamed content for real-time output token updates
+  const conversationId = activeConversationIds.get(sessionId);
+  if (!conversationId) return;
+
+  const currentEstimate = estimatedOutputTokens.get(conversationId) || 0;
+  const newEstimate = currentEstimate + estimateTokens(delta.text);
+  estimatedOutputTokens.set(conversationId, newEstimate);
+
+  // Get current turn usage and add estimated output
+  const turnData = currentTurnUsage.get(conversationId) || {
+    inputTokens: 0,
+    outputTokens: 0,
+    lastMessageOutput: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0,
+  };
+
+  // Broadcast usage update with estimated tokens
+  const broadcastUsage = {
+    inputTokens: turnData.inputTokens,
+    outputTokens: turnData.outputTokens + Math.max(turnData.lastMessageOutput, newEstimate),
+    cacheReadInputTokens: turnData.cacheReadInputTokens,
+    cacheCreationInputTokens: turnData.cacheCreationInputTokens,
+  };
+
+  broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_USAGE_UPDATE, {
+    sessionId,
+    conversationId,
+    usage: broadcastUsage,
+    isFinal: false,
+    isEstimate: true,  // Flag so UI can show "~" prefix if desired
+  });
+}
+
+/**
+ * Resolve a token field from modelUsageEntry (camelCase) or event.usage (snake_case).
+ */
+function resolveTokenField(modelUsageEntry, eventUsage, keys) {
+  return modelUsageEntry?.[keys.camel] || eventUsage?.[keys.snake] || 0;
+}
+
+/**
+ * Extract turn usage from result event's modelUsage or usage fields
+ * @param {string} sessionId
+ * @param {Object} event
+ * @returns {Object} turnUsage
+ */
+export function extractTurnUsage(sessionId, event) {
+  // Extract from modelUsage if available (has more detail)
+  const modelUsageEntry = event.modelUsage
+    ? Object.values(event.modelUsage)[0]
+    : null;
+
+  // Use the model from system.init (stored in currentModels) rather than modelUsage keys
+  // because modelUsage can contain multiple models when sub-agents are used (e.g., Opus using Haiku)
+  // and Object.keys()[0] would pick the wrong model
+  const primaryModel = currentModels.get(sessionId) || Object.keys(event.modelUsage || {})[0] || null;
+
+  return {
+    inputTokens: resolveTokenField(modelUsageEntry, event.usage, { camel: 'inputTokens', snake: 'input_tokens' }),
+    outputTokens: resolveTokenField(modelUsageEntry, event.usage, { camel: 'outputTokens', snake: 'output_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,
+    contextWindow: modelUsageEntry?.contextWindow || 200000,
+    model: primaryModel,
+  };
+}
+
+/**
+ * Build cumulative session-level usage by adding turn usage to existing session usage
+ * @param {string} sessionId
+ * @param {Object} turnUsage
+ * @returns {Object} cumulativeSessionUsage
+ */
+export function buildCumulativeSessionUsage(sessionId, turnUsage) {
+  const currentSession = sessions.getById(sessionId);
+  return {
+    inputTokens: (currentSession.inputTokens || 0) + turnUsage.inputTokens,
+    outputTokens: (currentSession.outputTokens || 0) + turnUsage.outputTokens,
+    cacheReadInputTokens: (currentSession.cacheReadInputTokens || 0) + turnUsage.cacheReadInputTokens,
+    cacheCreationInputTokens: (currentSession.cacheCreationInputTokens || 0) + turnUsage.cacheCreationInputTokens,
+    webSearchRequests: (currentSession.webSearchRequests || 0) + turnUsage.webSearchRequests,
+    contextWindow: turnUsage.contextWindow,
+  };
+}
+
+/**
+ * Update conversation with cumulative usage from turn
+ * @param {string|undefined} conversationId
+ * @param {Object|null} currentConversation
+ * @param {Object} turnUsage
+ * @returns {Object|null} updatedConversation
+ */
+export function updateConversationUsage(conversationId, currentConversation, turnUsage) {
+  if (!currentConversation) return null;
+
+  const cumulativeConversationUsage = {
+    inputTokens: (currentConversation.inputTokens || 0) + turnUsage.inputTokens,
+    outputTokens: (currentConversation.outputTokens || 0) + turnUsage.outputTokens,
+    cacheReadInputTokens: (currentConversation.cacheReadInputTokens || 0) + turnUsage.cacheReadInputTokens,
+    cacheCreationInputTokens: (currentConversation.cacheCreationInputTokens || 0) + turnUsage.cacheCreationInputTokens,
+    webSearchRequests: (currentConversation.webSearchRequests || 0) + turnUsage.webSearchRequests,
+    contextWindow: turnUsage.contextWindow,
+  };
+
+  return conversations.updateUsage(conversationId, cumulativeConversationUsage);
+}
+
+/**
+ * Handle final usage stats from result event — update conversation and session usage
+ * @param {string} sessionId
+ * @param {Object} event
+ */
+export function handleResultUsage(sessionId, event) {
+  const turnUsage = extractTurnUsage(sessionId, event);
+
+  // Get the conversation ID for this session's current turn
+  const conversationId = activeConversationIds.get(sessionId);
+  const currentConversation = conversationId ? conversations.getById(conversationId) : null;
+
+  // Update conversation with cumulative usage (add to existing)
+  const updatedConversation = updateConversationUsage(conversationId, currentConversation, turnUsage);
+
+  // Also update session-level usage (aggregate of all conversations) for backward compatibility
+  const cumulativeSessionUsage = buildCumulativeSessionUsage(sessionId, turnUsage);
+  const updatedSession = sessions.updateUsage(sessionId, cumulativeSessionUsage);
+
+  // Broadcast final usage update with conversationId
+  broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_USAGE_UPDATE, {
+    sessionId,
+    conversationId,
+    usage: updatedConversation ? {
+      inputTokens: updatedConversation.inputTokens,
+      outputTokens: updatedConversation.outputTokens,
+      cacheReadInputTokens: updatedConversation.cacheReadInputTokens,
+      cacheCreationInputTokens: updatedConversation.cacheCreationInputTokens,
+      webSearchRequests: updatedConversation.webSearchRequests,
+      contextWindow: updatedConversation.contextWindow,
+    } : cumulativeSessionUsage,
+    turnUsage,
+    isFinal: true,
+  });
+
+  // Also broadcast session update for session list
+  broadcastToProject(updatedSession.projectId, WS_MESSAGE_TYPES.SESSION_UPDATED, {
+    projectId: updatedSession.projectId,
+    sessionId,
+    session: updatedSession,
+  });
+
+  // Broadcast conversation update for real-time UI updates
+  if (updatedConversation) {
+    broadcastToSession(sessionId, WS_MESSAGE_TYPES.CONVERSATION_UPDATED, {
+      sessionId,
+      conversation: updatedConversation,
+    });
+  }
+
+  // Clean up turn usage and estimated tokens
+  currentTurnUsage.delete(conversationId);
+  estimatedOutputTokens.delete(conversationId);
+  activeConversationIds.delete(sessionId);
+}

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

@@ -0,0 +1,61 @@
+/**
+ * Broadcast helpers for summary-related WebSocket events.
+ * Consolidates repeated broadcast patterns from summaryService.
+ */
+
+import { broadcastToSession, broadcastToProject } from '../websocket.js';
+import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
+
+/**
+ * Broadcast summary update to session and project subscribers
+ * @param {string} sessionId - The session ID
+ * @param {string|null} projectId - The project ID (null skips project broadcast)
+ * @param {Object} summary - The summary object
+ */
+export function broadcastSummaryUpdate(sessionId, projectId, summary) {
+  broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_SUMMARY_UPDATED, {
+    sessionId,
+    summary,
+  });
+
+  if (projectId) {
+    broadcastToProject(projectId, WS_MESSAGE_TYPES.SESSION_SUMMARY_UPDATED, {
+      projectId,
+      sessionId,
+      summary,
+    });
+  }
+}
+
+/**
+ * Broadcast generating status to session subscribers
+ * @param {string} sessionId - The session ID
+ * @param {boolean} generating - Whether generation is in progress
+ */
+export function broadcastGeneratingStatus(sessionId, generating) {
+  broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_SUMMARY_GENERATING, {
+    sessionId,
+    generating,
+  });
+}
+
+/**
+ * Broadcast session update to session and project subscribers
+ * @param {string} sessionId - The session ID
+ * @param {string|null} projectId - The project ID (null skips project broadcast)
+ * @param {Object} session - The session object
+ */
+export function broadcastSessionUpdate(sessionId, projectId, session) {
+  broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_UPDATED, {
+    sessionId,
+    session,
+  });
+
+  if (projectId) {
+    broadcastToProject(projectId, WS_MESSAGE_TYPES.SESSION_UPDATED, {
+      projectId,
+      sessionId,
+      session,
+    });
+  }
+}

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

@@ -0,0 +1,180 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { sessions } from '../database.js';
+import { agentCallLogger } from './agentCallLogger.js';
+import { createVCRQueryFn } from '../agents/vcr/VCRSummaryWrapper.js';
+
+/**
+ * Default JSON schema for session summary structured output
+ */
+/**
+ * Process a content block from Claude's response
+ * @param {Object} block - Content block
+ * @param {Object} stateInput - Mutable state object { responseText, structuredOutput }
+ */
+function processContentBlock(block, stateInput) {
+  const state = stateInput;
+  if (block.type === 'tool_use' && block.name === 'StructuredOutput') {
+    state.structuredOutput = block.input;
+  } else if (block.type === 'text') {
+    state.responseText += block.text;
+  }
+}
+
+/**
+ * Log usage metrics from a result event
+ * @param {string} callId - The call ID for logging
+ * @param {Object} event - The result event
+ */
+function logResultUsage(callId, event) {
+  const modelUsageEntry = event.modelUsage
+    ? Object.values(event.modelUsage)[0]
+    : null;
+  if (!modelUsageEntry && !event.usage) return;
+
+  agentCallLogger.updateUsage(callId, {
+    inputTokens: modelUsageEntry?.inputTokens || event.usage?.input_tokens || 0,
+    outputTokens: modelUsageEntry?.outputTokens || event.usage?.output_tokens || 0,
+    thinkingTokens: 0,
+    cacheReadInputTokens:
+      modelUsageEntry?.cacheReadInputTokens ||
+      event.usage?.cache_read_input_tokens ||
+      0,
+    cacheCreationInputTokens:
+      modelUsageEntry?.cacheCreationInputTokens ||
+      event.usage?.cache_creation_input_tokens ||
+      0,
+  });
+}
+
+/**
+ * Build the query parameters for the Claude SDK call.
+ * @param {string} prompt - The prompt to send
+ * @param {{ systemPrompt?: string, jsonSchema?: Object }} options
+ * @returns {Object} queryParams ready for the SDK query function
+ */
+function buildClaudeRequest(prompt, options) {
+  const { systemPrompt = null, jsonSchema = null } = options || {};
+  const schema = jsonSchema || SESSION_SUMMARY_SCHEMA;
+
+  return {
+    prompt,
+    options: {
+      cwd: process.cwd(),
+      permissionMode: 'bypassPermissions',
+      maxTurns: 1,
+      model: 'claude-haiku-4-5-20251001',
+      ...(systemPrompt && { systemPrompt }),
+      outputFormat: {
+        type: 'json_schema',
+        schema,
+      },
+    },
+  };
+}
+
+/**
+ * Process the Claude SDK event stream and extract the response.
+ * @param {AsyncIterable} eventStream - The async iterable from the SDK query
+ * @param {string|null} callId - The agent call logger ID (null if not logging)
+ * @returns {Promise<string>} The text response (JSON string)
+ */
+async function handleClaudeResponse(eventStream, callId) {
+  const state = { responseText: '', structuredOutput: null };
+
+  for await (const event of eventStream) {
+    switch (event.type) {
+      case 'assistant': {
+        const content = event.message?.content || [];
+        for (const block of content) {
+          processContentBlock(block, state);
+        }
+        break;
+      }
+      case 'result': {
+        if (event.subtype === 'error') {
+          throw new Error(event.error || 'Claude SDK query failed');
+        }
+        if (callId) {
+          logResultUsage(callId, event);
+        }
+        break;
+      }
+    }
+  }
+
+  if (state.structuredOutput) {
+    return JSON.stringify(state.structuredOutput);
+  }
+  return state.responseText;
+}
+
+export const SESSION_SUMMARY_SCHEMA = {
+  type: 'object',
+  properties: {
+    short_summary: { type: 'string', description: '1-2 sentence preview for list view (max 150 characters)' },
+    full_summary: { type: 'string', description: 'Detailed summary with key accomplishments and current state (max 500 characters)' },
+    key_actions: { type: 'array', items: { type: 'string' }, description: 'List of key actions taken' },
+    files_modified: { type: 'array', items: { type: 'string' }, description: 'List of files that were modified' },
+    outcome: { type: 'string', enum: ['completed', 'partial', 'failed', 'ongoing'], description: 'Session outcome status' },
+    pr_url: { type: ['string', 'null'], description: 'GitHub PR URL if one was created' },
+    session_title: { type: ['string', 'null'], description: 'Concise title for this session (max 60 characters)' },
+  },
+  required: ['short_summary', 'full_summary', 'key_actions', 'files_modified', 'outcome'],
+};
+
+/**
+ * Call Claude via SDK and extract text response.
+ * Unified function that handles both default session summary schema
+ * and custom schemas (e.g., combined session+conversation summary).
+ *
+ * @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
+ * @returns {Promise<string>} The text response (JSON string)
+ */
+export async function callClaude(prompt, recentMessages, sessionStatus, options = {}) {
+  const { logMeta = 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) {
+    const session = sessions.getById(logMeta.sessionId);
+    keyHint = session ? `${logMeta.callType}:${session.prompt}` : null;
+  }
+  // Use VCR wrapper if in VCR mode, otherwise use real SDK query
+  const queryFn = process.env.VCR_MODE
+    ? createVCRQueryFn(query, 'tests/e2e/cassettes/summaries', keyHint)
+    : query;
+
+  const queryParams = buildClaudeRequest(prompt, 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,
+      promptLength: prompt.length,
+    });
+  }
+
+  try {
+    const result = await handleClaudeResponse(queryFn(queryParams), callId);
+
+    // Complete the logged call on success
+    if (callId) {
+      agentCallLogger.completeCall(callId, { success: true });
+    }
+
+    return result;
+  } catch (error) {
+    // Complete the logged call on error
+    if (callId) {
+      agentCallLogger.completeCall(callId, { success: false, error });
+    }
+    throw error;
+  }
+}

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

@@ -0,0 +1,169 @@
+/**
+ * Prompt templates and message formatting for summary generation.
+ * Pure functions with no side effects.
+ */
+
+import { DEFAULT_SESSION_TITLE_PROMPT } from '../../../shared/src/index.js';
+
+// Maximum retry attempts for failed parsing
+export const MAX_RETRIES = 2;
+
+// Minimum number of messages before generating a summary (skip trivial sessions)
+export const MIN_MESSAGES_FOR_SUMMARY = 3;
+
+// Maximum number of recent messages to include in generation (optimized for token efficiency)
+export const MAX_MESSAGES = 10;
+
+// Re-export from shared for backward compatibility
+export { DEFAULT_SESSION_TITLE_PROMPT };
+
+// System prompt for summary generation (static instructions that benefit from prompt caching)
+export const SUMMARY_SYSTEM_PROMPT = `You are updating a session summary for a Claude Code session.
+
+Generate an updated summary that:
+1. Preserves important context from the existing summary
+2. Incorporates new actions and progress from recent messages
+3. Updates the outcome status if changed
+4. Maintains a coherent narrative of the full session
+
+Outcome guidelines:
+- "completed": Task was fully accomplished
+- "partial": Some progress made but task incomplete
+- "failed": Task encountered errors and couldn't proceed
+- "ongoing": Session is still active/waiting for user input`;
+
+/**
+ * Format messages for the prompt
+ * @param {Array} messageList - List of messages
+ * @returns {string}
+ */
+export function formatMessages(messageList) {
+  return messageList
+    .map((msg) => {
+      const role = msg.role === 'user' ? 'User' : 'Assistant';
+      let content = msg.content;
+
+      // Truncate very long messages (optimized for token efficiency)
+      if (content.length > 500) {
+        content = `${content.substring(0, 500)  }... [truncated]`;
+      }
+
+      // Add tool use info if present
+      if (msg.toolUse && msg.toolUse.length > 0) {
+        const tools = msg.toolUse.map((t) => t.name).join(', ');
+        content += `\n[Tools used: ${tools}]`;
+      }
+
+      return `${role}: ${content}`;
+    })
+    .join('\n\n');
+}
+
+/**
+ * Build the prompt for incremental summary generation
+ * @param {Object|null} existingSummary - Existing summary if any
+ * @param {Array} recentMessages - Recent messages to summarize
+ * @param {string} sessionStatus - Current session status
+ * @param {{ projectTitlePrompt?: string|null, childContext?: string }} options - Optional parameters
+ * @returns {string}
+ */
+export function buildIncrementalPrompt(existingSummary, recentMessages, sessionStatus, options = {}) {
+  const { projectTitlePrompt = null, childContext = '' } = options || {};
+  const existingContext = existingSummary
+    ? `EXISTING SUMMARY:
+${existingSummary.fullSummary}
+
+Key actions so far: ${JSON.stringify(existingSummary.keyActions || [])}
+Files modified: ${JSON.stringify(existingSummary.filesModified || [])}
+Previous outcome: ${existingSummary.outcome}
+Previous title: ${existingSummary.sessionTitle || 'Not set'}`
+    : 'EXISTING SUMMARY:\nNo previous summary - this is the first generation.';
+
+  const formattedMessages = formatMessages(recentMessages);
+
+  // Use custom prompt if provided, otherwise use default
+  const sessionTitlePrompt = projectTitlePrompt || DEFAULT_SESSION_TITLE_PROMPT;
+
+  // Return only dynamic content - static instructions are in SUMMARY_SYSTEM_PROMPT
+  return `Current session status: ${sessionStatus}
+
+${existingContext}
+${childContext}
+RECENT CONVERSATION:
+${formattedMessages}
+
+Session title guidelines:
+${sessionTitlePrompt}`;
+}
+
+/**
+ * Strip markdown code block wrapping (```json ... ```) from response text
+ * @param {string} text - Raw response text
+ * @returns {string} Text with code block wrapper removed if present
+ */
+export function stripMarkdownCodeBlock(text) {
+  let cleaned = text.trim();
+  if (cleaned.startsWith('```')) {
+    const codeBlockMatch = cleaned.match(/^```(?:json)?\s*\n?([\s\S]*?)\n?```$/);
+    if (codeBlockMatch) {
+      cleaned = codeBlockMatch[1].trim();
+      console.log('[SummaryPrompts] Stripped markdown code block from response');
+    }
+  }
+  return cleaned;
+}
+
+/**
+ * Add message count and last message ID to summary data for staleness tracking
+ * @param {Object} summaryDataInput - Summary data to augment
+ * @param {Array} allMessages - All messages in session
+ */
+export function trackMessageMetadata(summaryDataInput, allMessages) {
+  const summaryData = summaryDataInput;
+  summaryData.messageCount = allMessages.length;
+  const lastMessage = allMessages.length > 0 ? allMessages[allMessages.length - 1] : null;
+  summaryData.lastSummarizedMessageId = lastMessage ? lastMessage.id : null;
+}
+
+/**
+ * Parse the Claude API response into a summary object
+ * Handles markdown code block wrapping (```json ... ```) that Claude sometimes returns
+ * @param {string} responseText
+ * @returns {Object}
+ */
+export function parseSummaryResponse(responseText) {
+  const textToParse = stripMarkdownCodeBlock(responseText);
+
+  try {
+    const parsed = JSON.parse(textToParse);
+    return {
+      shortSummary: parsed.short_summary || 'Summary generation failed',
+      fullSummary: parsed.full_summary || 'Unable to generate summary',
+      keyActions: Array.isArray(parsed.key_actions) ? parsed.key_actions :
+        (typeof parsed.key_actions === 'string' ? [parsed.key_actions] : []),
+      filesModified: Array.isArray(parsed.files_modified) ? parsed.files_modified :
+        (typeof parsed.files_modified === 'string' ? [parsed.files_modified] : []),
+      outcome: parsed.outcome || 'ongoing',
+      prUrl: parsed.pr_url || null,
+      sessionTitle: parsed.session_title || null,
+      _parseFailed: false,
+    };
+  } catch {
+    // If JSON parsing fails, return fallback with flag for retry logic
+    console.warn('[SummaryPrompts] Failed to parse summary response as JSON, using fallback');
+    return {
+      shortSummary: responseText.substring(0, 150),
+      fullSummary: responseText.substring(0, 500),
+      keyActions: [],
+      filesModified: [],
+      outcome: 'ongoing',
+      prUrl: null,
+      sessionTitle: null,
+      _parseFailed: true,
+    };
+  }
+}
+
+// Backward-compatible aliases for internal/test usage
+export { stripMarkdownCodeBlock as _stripMarkdownCodeBlock };
+export { trackMessageMetadata as _trackMessageMetadata };