@@ -1,6 +1,7 @@
 import { ZodError } from "zod"
 
 import {
+	type ConsecutiveMistakeReason,
 	type TelemetryClient,
 	type TelemetryPropertiesProvider,
 	TelemetryEventName,
@@ -280,8 +281,18 @@ export class TelemetryService {
 		this.captureEvent(TelemetryEventName.SHELL_INTEGRATION_ERROR, { taskId })
 	}
 
-	public captureConsecutiveMistakeError(taskId: string): void {
-		this.captureEvent(TelemetryEventName.CONSECUTIVE_MISTAKE_ERROR, { taskId })
+	public captureConsecutiveMistakeError(
+		taskId: string,
+		reason: ConsecutiveMistakeReason,
+		consecutiveMistakeCount: number,
+		consecutiveMistakeLimit: number,
+	): void {
+		this.captureEvent(TelemetryEventName.CONSECUTIVE_MISTAKE_ERROR, {
+			taskId,
+			reason,
+			consecutiveMistakeCount,
+			consecutiveMistakeLimit,
+		})
 	}
 
 	/**
 
@@ -0,0 +1,40 @@
+// pnpm --filter @roo-code/telemetry test src/__tests__/TelemetryService.consecutive-mistake.test.ts
+
+import { TelemetryEventName, type TelemetryClient } from "@roo-code/types"
+
+import { TelemetryService } from "../TelemetryService"
+
+describe("TelemetryService.captureConsecutiveMistakeError", () => {
+	let mockClient: TelemetryClient
+
+	beforeEach(() => {
+		mockClient = {
+			setProvider: vi.fn(),
+			capture: vi.fn().mockResolvedValue(undefined),
+			captureException: vi.fn().mockResolvedValue(undefined),
+			updateTelemetryState: vi.fn(),
+			isTelemetryEnabled: vi.fn().mockReturnValue(true),
+			shutdown: vi.fn().mockResolvedValue(undefined),
+		}
+	})
+
+	it.each(["no_tools_used", "tool_repetition"] as const)(
+		"sends reason, count and limit for %s without a separate exception",
+		(reason) => {
+			const service = new TelemetryService([mockClient])
+
+			service.captureConsecutiveMistakeError("task_1", reason, 3, 5)
+
+			expect(mockClient.capture).toHaveBeenCalledWith({
+				event: TelemetryEventName.CONSECUTIVE_MISTAKE_ERROR,
+				properties: {
+					taskId: "task_1",
+					reason,
+					consecutiveMistakeCount: 3,
+					consecutiveMistakeLimit: 5,
+				},
+			})
+			expect(mockClient.captureException).not.toHaveBeenCalled()
+		},
+	)
+})
@@ -1566,10 +1566,9 @@ describe("OpenAiNativeHandler", () => {
 				}
 			}).rejects.toThrow()
 
-			// Verify telemetry was captured (may be called multiple times due to error propagation)
-			expect(mockCaptureException).toHaveBeenCalled()
+			// A stream failure must be captured exactly once (handleStreamResponse rethrows to createMessage).
+			expect(mockCaptureException).toHaveBeenCalledTimes(1)
 
-			// Find the call with the stream error message
 			const streamErrorCall = mockCaptureException.mock.calls.find((call: any[]) =>
 				call[0]?.message?.includes("Model overloaded"),
 			)
 
@@ -297,7 +297,12 @@ describe("presentAssistantMessage - Tool Repetition Detection", () => {
 			expect.stringContaining("tools:toolRepetitionLimitReached"),
 		)
 		expect(readFileHandle).not.toHaveBeenCalled()
-		expect(captureConsecutiveMistakeError).toHaveBeenCalledWith("test-task-id")
+		expect(captureConsecutiveMistakeError).toHaveBeenCalledWith(
+			"test-task-id",
+			"tool_repetition",
+			mockTask.consecutiveMistakeCount,
+			HARD_LIMIT,
+		)
 		expect(findToolResult(nextToolCallId)).toBeDefined()
 	})
 
@@ -361,8 +366,14 @@ describe("presentAssistantMessage - Tool Repetition Detection", () => {
 		expect(readFileHandle).not.toHaveBeenCalled()
 
 		// Telemetry escalation should have fired for a hard block.
-		expect(captureConsecutiveMistakeError).toHaveBeenCalledWith("test-task-id")
-		expect(captureException).toHaveBeenCalled()
+		expect(captureConsecutiveMistakeError).toHaveBeenCalledWith(
+			"test-task-id",
+			"tool_repetition",
+			mockTask.consecutiveMistakeCount,
+			HARD_LIMIT,
+		)
+		// The named event is the single capture: no duplicate exception.
+		expect(captureException).not.toHaveBeenCalled()
 
 		// A tool_result describing the repetition limit should have been pushed.
 		const toolResult = findToolResult(toolCallId)
 
@@ -836,7 +836,12 @@ async function presentAssistantMessageBlock(cline: Task): Promise<void> {
 					}
 
 					// Track tool repetition in telemetry via a named event.
-					TelemetryService.instance.captureConsecutiveMistakeError(cline.taskId)
+					TelemetryService.instance.captureConsecutiveMistakeError(
+						cline.taskId,
+						"tool_repetition",
+						cline.consecutiveMistakeCount,
+						cline.consecutiveMistakeLimit,
+					)
 
 					// Return tool result message about the repetition
 					pushToolResult(
 
@@ -3784,7 +3784,12 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 				// Track consecutive mistake errors in telemetry via a named event.
 				// The reason is "no_tools_used" because this limit is reached via initiateTaskLoop
 				// which increments consecutiveMistakeCount when the model doesn't use any tools.
-				TelemetryService.instance.captureConsecutiveMistakeError(this.taskId)
+				TelemetryService.instance.captureConsecutiveMistakeError(
+					this.taskId,
+					"no_tools_used",
+					this.consecutiveMistakeCount,
+					this.consecutiveMistakeLimit,
+				)
 
 				const { response, text, images } = await this.ask(
 					"mistake_limit_reached",
Original file line number	Diff line number	Diff line change
`@@ -1566,10 +1566,9 @@ describe("OpenAiNativeHandler", () => {`
`1566`	`1566`	`}`
`1567`	`1567`	`}).rejects.toThrow()`
`1568`	`1568`
`1569`		`- // Verify telemetry was captured (may be called multiple times due to error propagation)`
`1570`		`- expect(mockCaptureException).toHaveBeenCalled()`
	`1569`	`+ // A stream failure must be captured exactly once (handleStreamResponse rethrows to createMessage).`
	`1570`	`+ expect(mockCaptureException).toHaveBeenCalledTimes(1)`
`1571`	`1571`
`1572`		`- // Find the call with the stream error message`
`1573`	`1572`	`const streamErrorCall = mockCaptureException.mock.calls.find((call: any[]) =>`
`1574`	`1573`	`call[0]?.message?.includes("Model overloaded"),`
`1575`	`1574`	`)`