From 8ec91e7ffa9e9a3d55ed08a4250c0fa9116224f3 Mon Sep 17 00:00:00 2001 From: Copilot <198982749+Copilot@users.noreply.github.com> Date: Sun, 19 Apr 2026 12:00:38 -0700 Subject: [PATCH] fix: break infinite summary-retry loop (#1633) (#2072) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Initial plan * fix: break infinite summary-retry loop (#1633) Three-part fix: 1. Parser coercion: When LLM returns tags instead of , coerce observation content into summary fields (root cause fix) 2. Stronger summary prompt: Add clearer tag requirements with warnings 3. Circuit breaker: Track consecutive summary failures per session, skip further attempts after 3 failures to prevent unbounded prompt growth Agent-Logs-Url: https://github.com/thedotmack/claude-mem/sessions/e345e8ec-bc97-4eaa-94bd-6e951fda8f77 Co-authored-by: thedotmack <683968+thedotmack@users.noreply.github.com> * refactor: extract shared constants for summary mode marker and failure threshold Addresses code review feedback: SUMMARY_MODE_MARKER and MAX_CONSECUTIVE_SUMMARY_FAILURES are now defined once in sdk/prompts.ts and imported by ResponseProcessor and SessionManager. Agent-Logs-Url: https://github.com/thedotmack/claude-mem/sessions/e345e8ec-bc97-4eaa-94bd-6e951fda8f77 Co-authored-by: thedotmack <683968+thedotmack@users.noreply.github.com> * fix: guard summary failure counter on summaryExpected (Greptile P1) The circuit breaker counter previously incremented on any response containing or tags — which matches virtually every normal observation response. After 3 observations the breaker would open and permanently block summarization, reproducing the data-loss scenario #1633 was meant to prevent. Gate the increment block on summaryExpected (already computed for parseSummary coercion) so the counter only tracks actual summary attempts. Co-Authored-By: Claude Opus 4.7 (1M context) * test: cover circuit-breaker + apply review polish - Use findLast / at(-1) for last-user-message lookup instead of filter + index (O(1) common case). - Drop redundant `|| 0` fallback — field is required and initialized. - Add comment noting counter is ephemeral by design. - Add ResponseProcessor tests covering: * counter NOT incrementing on normal observation responses (regression guard for the Greptile P1) * counter incrementing when a summary was expected but missing * counter resetting to 0 on successful summary storage Co-Authored-By: Claude Opus 4.7 (1M context) * fix: iterate all observation blocks; don't count skip_summary as failure Addresses CodeRabbit review on #2072: - coerceObservationToSummary now iterates all blocks with a global regex and returns the first block that has title, narrative, or facts. Previously, an empty leading observation would short-circuit and discard populated follow-ups. - Circuit-breaker counter now treats explicit as neutral — neither a failure nor a success — so a run that happens to end on a skip doesn't punish the session or mask a prior bad streak. Real failures (no summary, no skip) still increment. - Tests added for both cases. Co-Authored-By: Claude Opus 4.7 (1M context) * test: reference SUMMARY_MODE_MARKER constant instead of hardcoded string Addresses CodeRabbit nitpick: tests should pull the marker from the canonical source so they don't silently drift when the constant is renamed or edited. Co-Authored-By: Claude Opus 4.7 (1M context) * fix: also coerce observations when has empty sub-tags When the LLM wraps an empty around real observation content, the #1360 empty-subtag guard rejects the summary and returns null — which would lose the observation content and resurrect the #1633 retry loop. Fall back to coerceObservationToSummary in that branch too, mirroring the unmatched- path. Adds a test covering the empty-summary-wraps-observation case and a guard test for empty summary with no observation content. Co-Authored-By: Claude Opus 4.7 (1M context) --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: thedotmack <683968+thedotmack@users.noreply.github.com> Co-authored-by: Alex Newman Co-authored-by: Claude Opus 4.7 (1M context) --- src/sdk/parser.ts | 80 +++++++++++++- src/sdk/prompts.ts | 23 +++- src/services/worker-types.ts | 3 + src/services/worker/SessionManager.ts | 16 ++- .../worker/agents/ResponseProcessor.ts | 39 ++++++- tests/sdk/parse-summary.test.ts | 98 ++++++++++++++++- .../worker/agents/response-processor.test.ts | 103 +++++++++++++++++- 7 files changed, 351 insertions(+), 11 deletions(-) diff --git a/src/sdk/parser.ts b/src/sdk/parser.ts index 7dbd8bcd..63bdb286 100644 --- a/src/sdk/parser.ts +++ b/src/sdk/parser.ts @@ -113,8 +113,13 @@ export function parseObservations(text: string, correlationId?: string): ParsedO /** * Parse summary XML block from SDK response * Returns null if no valid summary found or if summary was skipped + * + * @param coerceFromObservation - When true, attempts to convert tags + * into summary fields if no tags are found. Only set this when the + * response was expected to be a summary (i.e., a summarize message was sent). + * Prevents the infinite retry loop described in #1633. */ -export function parseSummary(text: string, sessionId?: number): ParsedSummary | null { +export function parseSummary(text: string, sessionId?: number, coerceFromObservation: boolean = false): ParsedSummary | null { // Check for skip_summary first const skipRegex = //; const skipMatch = skipRegex.exec(text); @@ -132,10 +137,22 @@ export function parseSummary(text: string, sessionId?: number): ParsedSummary | const summaryMatch = summaryRegex.exec(text); if (!summaryMatch) { - // Log when the response contains instead of - // to help diagnose prompt conditioning issues (see #1312) + // When the LLM returns tags instead of tags, + // coerce the observation content into summary fields rather than discarding it. + // This breaks the infinite retry loop described in #1633: without coercion, + // the summary is silently dropped, the session completes without a summary, + // a new session is spawned with an ever-growing prompt, and the cycle repeats. + // Only coerce when explicitly requested (i.e., when a summarize message was sent). if (//.test(text)) { - logger.warn('PARSER', 'Summary response contained tags instead of — prompt conditioning may need strengthening', { sessionId }); + if (coerceFromObservation) { + const coerced = coerceObservationToSummary(text, sessionId); + if (coerced) { + return coerced; + } + logger.warn('PARSER', 'Summary response contained tags instead of — coercion failed, no usable content', { sessionId }); + } else { + logger.warn('PARSER', 'Summary response contained tags instead of — prompt conditioning may need strengthening', { sessionId }); + } } return null; } @@ -171,6 +188,17 @@ export function parseSummary(text: string, sessionId?: number): ParsedSummary | // This is NOT the same as missing some fields (which we intentionally allow above). // Fix for #1360. if (!request && !investigated && !learned && !completed && !next_steps) { + // If the response also contains tags with real content, fall + // back to coercion rather than discarding the response entirely — this covers + // the case where the LLM wraps empty around observation + // content, which would otherwise resurrect the #1633 retry loop. + if (coerceFromObservation && //.test(text)) { + const coerced = coerceObservationToSummary(text, sessionId); + if (coerced) { + logger.warn('PARSER', 'Empty match rejected — coerced from fallback (#1633)', { sessionId }); + return coerced; + } + } logger.warn('PARSER', 'Summary match has no sub-tags — skipping false positive', { sessionId }); return null; } @@ -185,6 +213,50 @@ export function parseSummary(text: string, sessionId?: number): ParsedSummary | }; } +/** + * Coerce response into a ParsedSummary when tags are missing. + * Maps observation fields to the closest summary equivalents so that a usable + * summary is stored instead of nothing — breaking the retry loop (#1633). + */ +function coerceObservationToSummary(text: string, sessionId?: number): ParsedSummary | null { + // Iterate all blocks — if the LLM emits multiple and the first is + // empty, we still want to salvage the first one that has usable content. + const obsRegex = /([\s\S]*?)<\/observation>/g; + let obsMatch: RegExpExecArray | null; + let blockIndex = 0; + + while ((obsMatch = obsRegex.exec(text)) !== null) { + const obsContent = obsMatch[1]; + const title = extractField(obsContent, 'title'); + const subtitle = extractField(obsContent, 'subtitle'); + const narrative = extractField(obsContent, 'narrative'); + const facts = extractArrayElements(obsContent, 'facts', 'fact'); + + if (title || narrative || facts.length > 0) { + // Map observation fields → summary fields (best-effort) + const request = title || subtitle || null; + const investigated = narrative || null; + const learned = facts.length > 0 ? facts.join('; ') : null; + const completed = title ? `${title}${subtitle ? ' — ' + subtitle : ''}` : null; + const next_steps = null; // No direct observation equivalent + + logger.warn('PARSER', 'Coerced response into to prevent retry loop (#1633)', { + sessionId, + blockIndex, + hasTitle: !!title, + hasNarrative: !!narrative, + factCount: facts.length, + }); + + return { request, investigated, learned, completed, next_steps, notes: null }; + } + + blockIndex++; + } + + return null; +} + /** * Extract a simple field value from XML content * Returns null for missing or empty/whitespace-only fields diff --git a/src/sdk/prompts.ts b/src/sdk/prompts.ts index 023d528e..c552d660 100644 --- a/src/sdk/prompts.ts +++ b/src/sdk/prompts.ts @@ -6,6 +6,20 @@ import { logger } from '../utils/logger.js'; import type { ModeConfig } from '../services/domain/types.js'; +/** + * Marker string embedded in summary prompts — used by ResponseProcessor to detect + * whether the most recent user message was a summary request (enables observation→summary + * coercion for #1633). Keep in sync with buildSummaryPrompt below. + */ +export const SUMMARY_MODE_MARKER = 'MODE SWITCH: PROGRESS SUMMARY'; + +/** + * Maximum consecutive summary failures before the circuit breaker opens. + * After this many failures, SessionManager.queueSummarize will skip further + * summarize requests to prevent the infinite retry loop (#1633). + */ +export const MAX_CONSECUTIVE_SUMMARY_FAILURES = 3; + export interface Observation { id: number; tool_name: string; @@ -134,9 +148,11 @@ export function buildSummaryPrompt(session: SDKSession, mode: ModeConfig): strin return ''; })(); - return `--- MODE SWITCH: PROGRESS SUMMARY --- -Do NOT output tags. This is a summary request, not an observation request. -Your response MUST use tags ONLY. Any output will be discarded. + return `--- ${SUMMARY_MODE_MARKER} --- +⚠️ CRITICAL TAG REQUIREMENT — READ CAREFULLY: +• You MUST wrap your ENTIRE response in ... tags. +• Do NOT use tags. output will be DISCARDED and cause a system error. +• The ONLY accepted root tag is . Any other root tag is a protocol violation. ${mode.prompts.header_summary_checkpoint} ${mode.prompts.summary_instruction} @@ -154,6 +170,7 @@ ${mode.prompts.summary_format_instruction} ${mode.prompts.xml_summary_notes_placeholder} +REMINDER: Your response MUST use as the root tag, NOT . ${mode.prompts.summary_footer}`; } diff --git a/src/services/worker-types.ts b/src/services/worker-types.ts index 79dc9199..8a8562b6 100644 --- a/src/services/worker-types.ts +++ b/src/services/worker-types.ts @@ -46,6 +46,9 @@ export interface ActiveSession { // Track whether the most recent storage operation persisted a summary record. // Used by the status endpoint so the Stop hook can detect silent summary loss (#1633). lastSummaryStored?: boolean; + // Circuit breaker: track consecutive summary failures to prevent infinite retry loops (#1633). + // When this reaches MAX_CONSECUTIVE_SUMMARY_FAILURES, further summarize requests are skipped. + consecutiveSummaryFailures: number; } export interface PendingMessage { diff --git a/src/services/worker/SessionManager.ts b/src/services/worker/SessionManager.ts index 5ef91aaf..f2500524 100644 --- a/src/services/worker/SessionManager.ts +++ b/src/services/worker/SessionManager.ts @@ -16,6 +16,7 @@ import { PendingMessageStore } from '../sqlite/PendingMessageStore.js'; import { SessionQueueProcessor } from '../queue/SessionQueueProcessor.js'; import { getProcessBySession, ensureProcessExit } from './ProcessRegistry.js'; import { getSupervisor } from '../../supervisor/index.js'; +import { MAX_CONSECUTIVE_SUMMARY_FAILURES } from '../../sdk/prompts.js'; /** Idle threshold before a stuck generator (zombie subprocess) is force-killed. */ export const MAX_GENERATOR_IDLE_MS = 5 * 60 * 1000; // 5 minutes @@ -219,7 +220,8 @@ export class SessionManager { currentProvider: null, // Will be set when generator starts consecutiveRestarts: 0, // Track consecutive restart attempts to prevent infinite loops processingMessageIds: [], // CLAIM-CONFIRM: Track message IDs for confirmProcessed() - lastGeneratorActivity: Date.now() // Initialize for stale detection (Issue #1099) + lastGeneratorActivity: Date.now(), // Initialize for stale detection (Issue #1099) + consecutiveSummaryFailures: 0 // Circuit breaker for summary retry loop (#1633) }; logger.debug('SESSION', 'Creating new session object (memorySessionId cleared to prevent stale resume)', { @@ -312,6 +314,18 @@ export class SessionManager { session = this.initializeSession(sessionDbId); } + // Circuit breaker: skip summarize if too many consecutive failures (#1633). + // This prevents the infinite loop where each failed summary spawns a new session + // with an ever-growing prompt. Counter is in-memory per ActiveSession — it resets + // on worker restart, which is acceptable because session state is already ephemeral. + if (session.consecutiveSummaryFailures >= MAX_CONSECUTIVE_SUMMARY_FAILURES) { + logger.warn('SESSION', `Circuit breaker OPEN: skipping summarize after ${session.consecutiveSummaryFailures} consecutive failures (#1633)`, { + sessionId: sessionDbId, + contentSessionId: session.contentSessionId + }); + return; + } + // CRITICAL: Persist to database FIRST const message: PendingMessage = { type: 'summarize', diff --git a/src/services/worker/agents/ResponseProcessor.ts b/src/services/worker/agents/ResponseProcessor.ts index d7f446c3..53803a52 100644 --- a/src/services/worker/agents/ResponseProcessor.ts +++ b/src/services/worker/agents/ResponseProcessor.ts @@ -13,6 +13,7 @@ import { logger } from '../../../utils/logger.js'; import { parseObservations, parseSummary, type ParsedObservation, type ParsedSummary } from '../../../sdk/parser.js'; +import { SUMMARY_MODE_MARKER, MAX_CONSECUTIVE_SUMMARY_FAILURES } from '../../../sdk/prompts.js'; import { updateCursorContextForProject } from '../../integrations/CursorHooksInstaller.js'; import { updateFolderClaudeMdFiles } from '../../../utils/claude-md-utils.js'; import { getWorkerPort } from '../../../shared/worker-utils.js'; @@ -67,7 +68,17 @@ export async function processAgentResponse( // Parse observations and summary const observations = parseObservations(text, session.contentSessionId); - const summary = parseSummary(text, session.sessionDbId); + + // Detect whether the most recent prompt was a summary request. + // If so, enable observation-to-summary coercion to prevent the infinite + // retry loop described in #1633. + const lastMessage = session.conversationHistory.at(-1); + const lastUserMessage = lastMessage?.role === 'user' + ? lastMessage + : session.conversationHistory.findLast(m => m.role === 'user') ?? null; + const summaryExpected = lastUserMessage?.content?.includes(SUMMARY_MODE_MARKER) ?? false; + + const summary = parseSummary(text, session.sessionDbId, summaryExpected); if ( text.trim() && @@ -130,6 +141,32 @@ export async function processAgentResponse( // to the Stop hook for silent-summary-loss detection (#1633) session.lastSummaryStored = result.summaryId !== null; + // Circuit breaker: track consecutive summary failures (#1633). + // Only evaluate when a summary was actually expected (summarize message was sent). + // Without this guard, the counter would increment on every normal observation + // response, tripping the breaker after 3 observations and permanently blocking + // summarization — reproducing the data-loss scenario this fix is meant to prevent. + if (summaryExpected) { + const skippedIntentionally = / is a valid protocol response — neither success + // nor failure. Leave the counter unchanged so we don't mask a bad run that + // happens to end on a skip, but also don't punish intentional skips. + } else { + // Summary was expected but none was stored — count as failure + session.consecutiveSummaryFailures += 1; + if (session.consecutiveSummaryFailures >= MAX_CONSECUTIVE_SUMMARY_FAILURES) { + logger.error('SESSION', `Circuit breaker: ${session.consecutiveSummaryFailures} consecutive summary failures — further summarize requests will be skipped (#1633)`, { + sessionId: session.sessionDbId, + contentSessionId: session.contentSessionId + }); + } + } + } + // CLAIM-CONFIRM: Now that storage succeeded, confirm all processing messages (delete from queue) // This is the critical step that prevents message loss on generator crash const pendingStore = sessionManager.getPendingMessageStore(); diff --git a/tests/sdk/parse-summary.test.ts b/tests/sdk/parse-summary.test.ts index 76e2174c..ac429829 100644 --- a/tests/sdk/parse-summary.test.ts +++ b/tests/sdk/parse-summary.test.ts @@ -8,10 +8,14 @@ import { describe, it, expect } from 'bun:test'; import { parseSummary } from '../../src/sdk/parser.js'; describe('parseSummary', () => { - it('returns null when no tag present', () => { + it('returns null when no tag present and coercion disabled', () => { expect(parseSummary('foo')).toBeNull(); }); + it('returns null when no or tags present', () => { + expect(parseSummary('Some plain text response without any XML tags')).toBeNull(); + }); + it('returns null when has no sub-tags (false positive — fix for #1360)', () => { // This is the bug: observation response accidentally contains some text expect(parseSummary('done some content here')).toBeNull(); @@ -50,4 +54,96 @@ describe('parseSummary', () => { it('returns null when skip_summary tag is present', () => { expect(parseSummary('')).toBeNull(); }); + + // Observation-to-summary coercion tests (#1633) + it('coerces with content into a summary when coerceFromObservation=true (#1633)', () => { + const result = parseSummary('foo', undefined, true); + expect(result).not.toBeNull(); + expect(result?.request).toBe('foo'); + expect(result?.completed).toBe('foo'); + }); + + it('coerces observation with narrative into summary with investigated field (#1633)', () => { + const text = ` + refactor + UObjectArray refactored + Removed local XXXX and migrated to new pattern + `; + const result = parseSummary(text, undefined, true); + expect(result).not.toBeNull(); + expect(result?.request).toBe('UObjectArray refactored'); + expect(result?.investigated).toBe('Removed local XXXX and migrated to new pattern'); + }); + + it('coerces observation with facts into summary with learned field (#1633)', () => { + const text = ` + discovery + JWT token handling + + Tokens expire after 1 hour + Refresh flow uses rotating keys + + `; + const result = parseSummary(text, undefined, true); + expect(result).not.toBeNull(); + expect(result?.request).toBe('JWT token handling'); + expect(result?.learned).toBe('Tokens expire after 1 hour; Refresh flow uses rotating keys'); + }); + + it('coerces observation with subtitle into completed field (#1633)', () => { + const text = ` + config + Database migration + Added new index for performance + `; + const result = parseSummary(text, undefined, true); + expect(result).not.toBeNull(); + expect(result?.completed).toBe('Database migration — Added new index for performance'); + }); + + it('returns null for empty observation even with coercion enabled (#1633)', () => { + const text = `config`; + expect(parseSummary(text, undefined, true)).toBeNull(); + }); + + it('prefers tags over observation coercion when both present (#1633)', () => { + const text = `obs title + summary request`; + const result = parseSummary(text, undefined, true); + expect(result).not.toBeNull(); + expect(result?.request).toBe('summary request'); + }); + + it('falls back to observation coercion when matches but has empty sub-tags (#1633)', () => { + // LLM wraps an empty summary around real observation content — without the + // fallback, the empty-subtag guard (#1360) rejects the summary and we lose + // the observation content, resurrecting the retry loop. + const text = ` + + the real work + what actually happened + `; + const result = parseSummary(text, undefined, true); + expect(result).not.toBeNull(); + expect(result?.request).toBe('the real work'); + expect(result?.investigated).toBe('what actually happened'); + }); + + it('empty with no observation content still returns null (coercion disabled)', () => { + const text = ''; + expect(parseSummary(text, undefined, true)).toBeNull(); + }); + + it('skips empty leading observation blocks and coerces from the first populated one (#1633)', () => { + const text = `discovery + + bugfix + second block has content + fixed the crash + `; + const result = parseSummary(text, undefined, true); + expect(result).not.toBeNull(); + expect(result?.request).toBe('second block has content'); + expect(result?.investigated).toBe('fixed the crash'); + }); }); diff --git a/tests/worker/agents/response-processor.test.ts b/tests/worker/agents/response-processor.test.ts index bd7b30cb..c59f8bd7 100644 --- a/tests/worker/agents/response-processor.test.ts +++ b/tests/worker/agents/response-processor.test.ts @@ -31,6 +31,7 @@ mock.module('../../../src/services/domain/ModeManager.js', () => ({ // Import after mocks import { processAgentResponse } from '../../../src/services/worker/agents/ResponseProcessor.js'; +import { SUMMARY_MODE_MARKER } from '../../../src/sdk/prompts.js'; import type { WorkerRef, StorageResult } from '../../../src/services/worker/agents/types.js'; import type { ActiveSession } from '../../../src/services/worker-types.js'; import type { DatabaseManager } from '../../../src/services/worker/DatabaseManager.js'; @@ -130,8 +131,9 @@ describe('ResponseProcessor', () => { conversationHistory: [], currentProvider: 'claude', processingMessageIds: [], // CLAIM-CONFIRM pattern: track message IDs being processed + consecutiveSummaryFailures: 0, ...overrides, - }; + } as ActiveSession; } describe('parsing observations from XML response', () => { @@ -726,4 +728,103 @@ describe('ResponseProcessor', () => { expect(session.lastSummaryStored).toBe(false); }); }); + + describe('circuit breaker: consecutiveSummaryFailures counter (#1633)', () => { + const SUMMARY_PROMPT = `--- ${SUMMARY_MODE_MARKER} ---\nDo the summary now.`; + + it('does NOT increment the counter on normal observation responses (P1 regression guard)', async () => { + // Session where the last user message is an OBSERVATION request, not a summary request. + // The counter must stay at 0 even though the response has tags and no summary. + mockStoreObservations.mockImplementation(() => ({ + observationIds: [1], + summaryId: null, + createdAtEpoch: 1700000000000, + } as StorageResult)); + + const session = createMockSession({ + conversationHistory: [{ role: 'user', content: 'record a new observation' }], + }); + const obsResponse = ` + + discovery + found a thing + it happened + + + + + + `; + + // Drive multiple observation responses — counter must never increment. + for (let i = 0; i < 5; i++) { + await processAgentResponse(obsResponse, session, mockDbManager, mockSessionManager, mockWorker, 0, null, 'TestAgent'); + } + + expect(session.consecutiveSummaryFailures).toBe(0); + }); + + it('increments the counter when a summary was expected but none was stored', async () => { + mockStoreObservations.mockImplementation(() => ({ + observationIds: [], + summaryId: null, + createdAtEpoch: 1700000000000, + } as StorageResult)); + + const session = createMockSession({ + conversationHistory: [{ role: 'user', content: SUMMARY_PROMPT }], + }); + // LLM returned nothing structured — no summary stored + const badResponse = 'I cannot comply with that request.'; + + await processAgentResponse(badResponse, session, mockDbManager, mockSessionManager, mockWorker, 0, null, 'TestAgent'); + + expect(session.consecutiveSummaryFailures).toBe(1); + }); + + it('does NOT increment the counter on intentional responses', async () => { + mockStoreObservations.mockImplementation(() => ({ + observationIds: [], + summaryId: null, + createdAtEpoch: 1700000000000, + } as StorageResult)); + + const session = createMockSession({ + consecutiveSummaryFailures: 1, + conversationHistory: [{ role: 'user', content: SUMMARY_PROMPT }], + }); + const skipResponse = ''; + + await processAgentResponse(skipResponse, session, mockDbManager, mockSessionManager, mockWorker, 0, null, 'TestAgent'); + + // Skip is neutral — counter stays where it was, no spurious increment + expect(session.consecutiveSummaryFailures).toBe(1); + }); + + it('resets the counter to 0 when a summary is successfully stored', async () => { + mockStoreObservations.mockImplementation(() => ({ + observationIds: [], + summaryId: 42, + createdAtEpoch: 1700000000000, + } as StorageResult)); + + const session = createMockSession({ + consecutiveSummaryFailures: 2, + conversationHistory: [{ role: 'user', content: SUMMARY_PROMPT }], + }); + const goodResponse = ` + + wrap it up + the thing + the answer + the work + none + + `; + + await processAgentResponse(goodResponse, session, mockDbManager, mockSessionManager, mockWorker, 0, null, 'TestAgent'); + + expect(session.consecutiveSummaryFailures).toBe(0); + }); + }); });