feat(headless): surface diagnostic monitoring data in non-interactive output

When running Gemini CLI in headless mode (-p), critical diagnostic data
like auth method, API retry attempts, loop detection, and request stats
was invisible despite being tracked internally. This change surfaces
that data across all three output formats (stream-json, json, text).

Changes:
- Add RETRY and LOOP_DETECTED event types to stream-json output
- Include auth_method and user_tier in init events and JSON output
- Add api_requests, api_errors, and retry_count to result stats
- Track and expose detected loop type (tool call, chanting, LLM-detected)
- Emit [RETRY] and [WARNING] messages to stderr in text mode
- Listen to CoreEvent.RetryAttempt in non-interactive CLI
- Add test script (scripts/test_gemini.sh) for manual verification

packages/core/src/core/client.ts

@@ -636,7 +636,11 @@ export class GeminiClient {
 
     const loopDetected = await this.loopDetector.turnStarted(signal);
     if (loopDetected) {
-      yield { type: GeminiEventType.LoopDetected };
+      const loopType = this.loopDetector.getDetectedLoopType();
+      yield {
+        type: GeminiEventType.LoopDetected,
+        value: loopType ? { loopType } : undefined,
+      };
       return turn;
     }
 
@@ -689,7 +693,11 @@ export class GeminiClient {
 
     for await (const event of resultStream) {
       if (this.loopDetector.addAndCheck(event)) {
-        yield { type: GeminiEventType.LoopDetected };
+        const loopType = this.loopDetector.getDetectedLoopType();
+        yield {
+          type: GeminiEventType.LoopDetected,
+          value: loopType ? { loopType } : undefined,
+        };
         controller.abort();
         return turn;
       }

packages/core/src/core/turn.ts

@@ -207,6 +207,7 @@ export type ServerGeminiFinishedEvent = {
 
 export type ServerGeminiLoopDetectedEvent = {
   type: GeminiEventType.LoopDetected;
+  value?: { loopType: string };
 };
 
 export type ServerGeminiCitationEvent = {

packages/core/src/output/json-formatter.ts

@@ -14,6 +14,8 @@ export class JsonFormatter {
     response?: string,
     stats?: SessionMetrics,
     error?: JsonError,
+    authMethod?: string,
+    userTier?: string,
   ): string {
     const output: JsonOutput = {};
 
@@ -21,6 +23,14 @@ export class JsonFormatter {
       output.session_id = sessionId;
     }
 
+    if (authMethod) {
+      output.auth_method = authMethod;
+    }
+
+    if (userTier) {
+      output.user_tier = userTier;
+    }
+
     if (response !== undefined) {
       output.response = stripAnsi(response);
     }

packages/core/src/output/stream-json-formatter.ts

@@ -39,23 +39,28 @@ export class StreamJsonFormatter {
   convertToStreamStats(
     metrics: SessionMetrics,
     durationMs: number,
+    retryCount?: number,
   ): StreamStats {
     let totalTokens = 0;
     let inputTokens = 0;
     let outputTokens = 0;
     let cached = 0;
     let input = 0;
+    let apiRequests = 0;
+    let apiErrors = 0;
 
-    // Aggregate token counts across all models
+    // Aggregate token counts and API stats across all models
     for (const modelMetrics of Object.values(metrics.models)) {
       totalTokens += modelMetrics.tokens.total;
       inputTokens += modelMetrics.tokens.prompt;
       outputTokens += modelMetrics.tokens.candidates;
       cached += modelMetrics.tokens.cached;
       input += modelMetrics.tokens.input;
+      apiRequests += modelMetrics.api.totalRequests;
+      apiErrors += modelMetrics.api.totalErrors;
     }
 
-    return {
+    const stats: StreamStats = {
       total_tokens: totalTokens,
       input_tokens: inputTokens,
       output_tokens: outputTokens,
@@ -63,6 +68,14 @@ export class StreamJsonFormatter {
       input,
       duration_ms: durationMs,
       tool_calls: metrics.tools.totalCalls,
+      api_requests: apiRequests,
+      api_errors: apiErrors,
     };
+
+    if (retryCount && retryCount > 0) {
+      stats.retry_count = retryCount;
+    }
+
+    return stats;
   }
 }

packages/core/src/output/types.ts

@@ -20,6 +20,8 @@ export interface JsonError {
 
 export interface JsonOutput {
   session_id?: string;
+  auth_method?: string;
+  user_tier?: string;
   response?: string;
   stats?: SessionMetrics;
   error?: JsonError;
@@ -33,6 +35,8 @@ export enum JsonStreamEventType {
   TOOL_RESULT = 'tool_result',
   ERROR = 'error',
   RESULT = 'result',
+  RETRY = 'retry',
+  LOOP_DETECTED = 'loop_detected',
 }
 
 export interface BaseJsonStreamEvent {
@@ -44,6 +48,8 @@ export interface InitEvent extends BaseJsonStreamEvent {
   type: JsonStreamEventType.INIT;
   session_id: string;
   model: string;
+  auth_method?: string;
+  user_tier?: string;
 }
 
 export interface MessageEvent extends BaseJsonStreamEvent {
@@ -86,6 +92,9 @@ export interface StreamStats {
   input: number;
   duration_ms: number;
   tool_calls: number;
+  api_requests?: number;
+  api_errors?: number;
+  retry_count?: number;
 }
 
 export interface ResultEvent extends BaseJsonStreamEvent {
@@ -98,10 +107,26 @@ export interface ResultEvent extends BaseJsonStreamEvent {
   stats?: StreamStats;
 }
 
+export interface RetryEvent extends BaseJsonStreamEvent {
+  type: JsonStreamEventType.RETRY;
+  attempt: number;
+  max_attempts: number;
+  delay_ms: number;
+  error?: string;
+  model: string;
+}
+
+export interface LoopDetectedStreamEvent extends BaseJsonStreamEvent {
+  type: JsonStreamEventType.LOOP_DETECTED;
+  loop_type?: string;
+}
+
 export type JsonStreamEvent =
   | InitEvent
   | MessageEvent
   | ToolUseEvent
   | ToolResultEvent
   | ErrorEvent
-  | ResultEvent;
+  | ResultEvent
+  | RetryEvent
+  | LoopDetectedStreamEvent;

packages/core/src/services/loopDetectionService.ts

@@ -118,6 +118,9 @@ export class LoopDetectionService {
   private llmCheckInterval = DEFAULT_LLM_CHECK_INTERVAL;
   private lastCheckTurn = 0;
 
+  // Detected loop type tracking
+  private detectedLoopType: string | null = null;
+
   // Session-level disable flag
   private disabledForSession = false;
 
@@ -208,6 +211,7 @@ export class LoopDetectionService {
       this.toolCallRepetitionCount = 1;
     }
     if (this.toolCallRepetitionCount >= TOOL_CALL_LOOP_THRESHOLD) {
+      this.detectedLoopType = 'consecutive_identical_tool_calls';
       logLoopDetected(
         this.config,
         new LoopDetectedEvent(
@@ -321,6 +325,7 @@ export class LoopDetectionService {
       const chunkHash = createHash('sha256').update(currentChunk).digest('hex');
 
       if (this.isLoopDetectedForChunk(currentChunk, chunkHash)) {
+        this.detectedLoopType = 'chanting_identical_sentences';
         logLoopDetected(
           this.config,
           new LoopDetectedEvent(
@@ -575,6 +580,7 @@ export class LoopDetectionService {
     result: Record<string, unknown>,
     modelName: string,
   ): void {
+    this.detectedLoopType = 'llm_detected_loop';
     if (
       typeof result['unproductive_state_analysis'] === 'string' &&
       result['unproductive_state_analysis']
@@ -599,6 +605,13 @@ export class LoopDetectionService {
     );
   }
 
+  /**
+   * Returns the type of the most recently detected loop, or null if none.
+   */
+  getDetectedLoopType(): string | null {
+    return this.detectedLoopType;
+  }
+
   /**
    * Resets all loop detection state.
    */
@@ -608,6 +621,7 @@ export class LoopDetectionService {
     this.resetContentTracking();
     this.resetLlmCheckTracking();
     this.loopDetected = false;
+    this.detectedLoopType = null;
   }
 
   private resetToolCallCount(): void {