feat(proxy): implement metrics persistence, traffic logs DB, and advanced monitoring

- Add SQLite schema for proxy metrics and traffic logs
- Implement ProxyMetricsRepo with historical aggregates
- Add TrafficLogsRepo for DB-backed traffic log queries
- Create proxy-advanced IPC handlers (metrics, traffic logs, circuit breaker, parity)
- Add ProxyMetricsService with connection snapshots and cleanup
- Add ProxyReplayService and ProxyIdeConfigService
- Implement MonitorTab and ToolsTab for advanced proxy features
- Add TrafficLogTable with sorting and filtering
- Fix i18n keys for proxy metrics
- Fix generateIdeConfig type mapping
- Update proxy routes with advanced tab integration

src/ipc/database/cloudHandler.ts

@@ -144,7 +144,11 @@ export function ensureDatabaseInitialized(dbPath: string): void {
 
     // Migration: Check if request_type column exists on token_usage
     const tokenUsageTableInfoRaw = db.pragma('table_info(token_usage)') as any[];
-    const tokenUsageTableInfo = parseRows(TableInfoRowSchema, tokenUsageTableInfoRaw, 'cloud.token_usage.tableInfo');
+    const tokenUsageTableInfo = parseRows(
+      TableInfoRowSchema,
+      tokenUsageTableInfoRaw,
+      'cloud.token_usage.tableInfo',
+    );
     const hasRequestType = tokenUsageTableInfo.some((col) => col.name === 'request_type');
     if (!hasRequestType) {
       db.exec('ALTER TABLE token_usage ADD COLUMN request_type TEXT');
@@ -154,7 +158,9 @@ export function ensureDatabaseInitialized(dbPath: string): void {
     db.exec(`CREATE INDEX IF NOT EXISTS idx_token_usage_account ON token_usage(account_id);`);
     db.exec(`CREATE INDEX IF NOT EXISTS idx_token_usage_timestamp ON token_usage(timestamp);`);
     db.exec(`CREATE INDEX IF NOT EXISTS idx_token_usage_model ON token_usage(model);`);
-    db.exec(`CREATE INDEX IF NOT EXISTS idx_token_usage_account_timestamp ON token_usage(account_id, timestamp);`);
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_token_usage_account_timestamp ON token_usage(account_id, timestamp);`,
+    );
   } catch (error) {
     logger.error('Failed to initialize cloud database schema', error);
     throw error;
@@ -551,9 +557,7 @@ export class CloudAccountRepo {
       const rows = orm.select().from(accounts).orderBy(desc(accounts.lastUsed)).all();
 
       const activeRows = rows.filter((r) => r.isActive);
-      logger.debug(
-        `getAccounts: Found ${rows.length} accounts, ${activeRows.length} active.`,
-      );
+      logger.debug(`getAccounts: Found ${rows.length} accounts, ${activeRows.length} active.`);
 
       // Auto-activate the single account if none are active
       if (rows.length > 0 && activeRows.length === 0) {

src/ipc/database/proxyMetricsHandler.ts

@@ -0,0 +1,452 @@
+import { logger } from '../../utils/logger';
+import Database from 'better-sqlite3';
+import type { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
+import { openDrizzleConnection } from './dbConnection';
+import { getCloudAccountsDbPath } from '../../utils/paths';
+import { ensureDatabaseInitialized } from './cloudHandler';
+import { proxyRequestMetrics, proxyConnectionSnapshots, trafficLogs } from './schema';
+
+export interface RecordProxyRequestParams {
+  endpoint: string;
+  statusCode: number;
+  durationMs: number;
+  timestamp: number;
+  accountId?: string | null;
+  tokensPrompt?: number | null;
+  tokensCompletion?: number | null;
+  errorMessage?: string | null;
+}
+
+let proxyMetricsDbConnection: {
+  raw: Database.Database;
+  orm: BetterSQLite3Database<typeof import('./schema')>;
+} | null = null;
+
+function getProxyMetricsDb() {
+  if (!proxyMetricsDbConnection) {
+    const dbPath = getCloudAccountsDbPath();
+    ensureDatabaseInitialized(dbPath);
+    const conn = openDrizzleConnection(
+      dbPath,
+      { readonly: false, fileMustExist: false },
+      { busyTimeoutMs: 3000 },
+    );
+    ensureProxyMetricsTable(conn.raw);
+    proxyMetricsDbConnection = conn;
+  }
+  return proxyMetricsDbConnection;
+}
+
+export function ensureProxyMetricsTable(rawDb: Database.Database): void {
+  try {
+    rawDb.exec(`
+      CREATE TABLE IF NOT EXISTS proxy_request_metrics (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        endpoint TEXT NOT NULL,
+        status_code INTEGER NOT NULL,
+        duration_ms INTEGER NOT NULL,
+        timestamp INTEGER NOT NULL,
+        account_id TEXT,
+        tokens_prompt INTEGER,
+        tokens_completion INTEGER,
+        error_message TEXT
+      );
+    `);
+    rawDb.exec(
+      `CREATE INDEX IF NOT EXISTS idx_proxy_metrics_timestamp ON proxy_request_metrics(timestamp);`,
+    );
+    rawDb.exec(
+      `CREATE INDEX IF NOT EXISTS idx_proxy_metrics_status ON proxy_request_metrics(status_code);`,
+    );
+
+    rawDb.exec(`
+      CREATE TABLE IF NOT EXISTS proxy_connection_snapshots (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp INTEGER NOT NULL,
+        count INTEGER NOT NULL DEFAULT 0
+      );
+    `);
+    rawDb.exec(
+      `CREATE INDEX IF NOT EXISTS idx_proxy_conn_timestamp ON proxy_connection_snapshots(timestamp);`,
+    );
+
+    rawDb.exec(`
+      CREATE TABLE IF NOT EXISTS traffic_logs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp INTEGER NOT NULL,
+        direction TEXT NOT NULL,
+        request_id TEXT NOT NULL,
+        endpoint TEXT NOT NULL,
+        method TEXT,
+        status INTEGER,
+        headers_json TEXT,
+        body_json TEXT,
+        chunk_json TEXT,
+        duration_ms INTEGER,
+        error_message TEXT,
+        error_stack TEXT,
+        error_status INTEGER,
+        metadata_json TEXT
+      );
+    `);
+    rawDb.exec(
+      `CREATE INDEX IF NOT EXISTS idx_traffic_logs_timestamp ON traffic_logs(timestamp);`,
+    );
+    rawDb.exec(
+      `CREATE INDEX IF NOT EXISTS idx_traffic_logs_direction ON traffic_logs(direction);`,
+    );
+  } catch (error) {
+    logger.error('Failed to ensure proxy_request_metrics table', error);
+    throw error;
+  }
+}
+
+export class ProxyMetricsRepo {
+  static recordRequest(params: RecordProxyRequestParams): boolean {
+    const { orm } = getProxyMetricsDb();
+    try {
+      orm
+        .insert(proxyRequestMetrics)
+        .values({
+          endpoint: params.endpoint,
+          statusCode: params.statusCode,
+          durationMs: params.durationMs,
+          timestamp: params.timestamp,
+          accountId: params.accountId ?? null,
+          tokensPrompt: params.tokensPrompt ?? null,
+          tokensCompletion: params.tokensCompletion ?? null,
+          errorMessage: params.errorMessage ?? null,
+        })
+        .run();
+      return true;
+    } catch (error) {
+      logger.error('Failed to record proxy request metric', error);
+      return false;
+    }
+  }
+
+  static getRecentAggregates(): {
+    requestsPerMinute: number;
+    avgLatencyMs: number;
+    errorRatePercent: number;
+  } {
+    const { raw } = getProxyMetricsDb();
+    const now = Date.now();
+    const oneMinuteAgo = now - 60_000;
+    const fiveMinutesAgo = now - 5 * 60_000;
+
+    try {
+      const requestsPerMinuteRow = raw
+        .prepare(`SELECT COUNT(*) as count FROM proxy_request_metrics WHERE timestamp >= ?`)
+        .get(oneMinuteAgo) as { count: number } | undefined;
+      const requestsPerMinute = requestsPerMinuteRow?.count ?? 0;
+
+      const aggregatesRow = raw
+        .prepare(
+          `SELECT
+            COUNT(*) as total,
+            AVG(duration_ms) as avgLatency,
+            CASE
+              WHEN COUNT(*) = 0 THEN 0
+              ELSE (COUNT(CASE WHEN status_code >= 400 THEN 1 END) * 100.0 / COUNT(*))
+            END as errorRate
+          FROM proxy_request_metrics
+          WHERE timestamp >= ?`,
+        )
+        .get(fiveMinutesAgo) as
+        | { total: number; avgLatency: number | null; errorRate: number }
+        | undefined;
+
+      const avgLatencyMs = aggregatesRow?.avgLatency ? Math.round(aggregatesRow.avgLatency) : 0;
+      const errorRatePercent = aggregatesRow?.errorRate ?? 0;
+
+      return {
+        requestsPerMinute,
+        avgLatencyMs,
+        errorRatePercent,
+      };
+    } catch (error) {
+      logger.error('Failed to get recent proxy metrics aggregates', error);
+      return {
+        requestsPerMinute: 0,
+        avgLatencyMs: 0,
+        errorRatePercent: 0,
+      };
+    }
+  }
+
+  static recordConnectionSnapshot(count: number): boolean {
+    const { orm } = getProxyMetricsDb();
+    try {
+      orm.insert(proxyConnectionSnapshots).values({ timestamp: Date.now(), count }).run();
+      return true;
+    } catch (error) {
+      logger.error('Failed to record connection snapshot', error);
+      return false;
+    }
+  }
+
+  static getHistoricalAggregates(windowMs: number = 60 * 60 * 1000): {
+    totalRequests: number;
+    requestsPerMinute: number;
+    avgLatencyMs: number;
+    errorRatePercent: number;
+    avgActiveConnections: number;
+  } {
+    const { raw } = getProxyMetricsDb();
+    const now = Date.now();
+    const cutoff = now - windowMs;
+
+    try {
+      const reqRow = raw
+        .prepare(
+          `SELECT COUNT(*) as total, AVG(duration_ms) as avgLatency,
+           CASE WHEN COUNT(*) = 0 THEN 0
+           ELSE (COUNT(CASE WHEN status_code >= 400 THEN 1 END) * 100.0 / COUNT(*))
+           END as errorRate
+           FROM proxy_request_metrics WHERE timestamp >= ?`,
+        )
+        .get(cutoff) as
+        | { total: number; avgLatency: number | null; errorRate: number }
+        | undefined;
+
+      const totalRequests = reqRow?.total ?? 0;
+      const minutes = Math.max(windowMs / 60_000, 1);
+      const requestsPerMinute = Math.round((totalRequests / minutes) * 100) / 100;
+      const avgLatencyMs = reqRow?.avgLatency ? Math.round(reqRow.avgLatency) : 0;
+      const errorRatePercent = reqRow?.errorRate ?? 0;
+
+      const connRow = raw
+        .prepare(`SELECT AVG(count) as avg FROM proxy_connection_snapshots WHERE timestamp >= ?`)
+        .get(cutoff) as { avg: number | null } | undefined;
+      const avgActiveConnections = connRow?.avg ? Math.round(connRow.avg) : 0;
+
+      return {
+        totalRequests,
+        requestsPerMinute,
+        avgLatencyMs,
+        errorRatePercent,
+        avgActiveConnections,
+      };
+    } catch (error) {
+      logger.error('Failed to get historical proxy metrics aggregates', error);
+      return {
+        totalRequests: 0,
+        requestsPerMinute: 0,
+        avgLatencyMs: 0,
+        errorRatePercent: 0,
+        avgActiveConnections: 0,
+      };
+    }
+  }
+
+  static deleteOldRecords(cutoffTimestamp: number): boolean {
+    const { raw } = getProxyMetricsDb();
+    try {
+      raw.prepare(`DELETE FROM proxy_request_metrics WHERE timestamp < ?`).run(cutoffTimestamp);
+      raw.prepare(`DELETE FROM proxy_connection_snapshots WHERE timestamp < ?`).run(cutoffTimestamp);
+      return true;
+    } catch (error) {
+      logger.error('Failed to delete old proxy metrics records', error);
+      return false;
+    }
+  }
+}
+
+export interface InsertTrafficLogParams {
+  timestamp: number;
+  direction: string;
+  requestId: string;
+  endpoint: string;
+  method?: string;
+  status?: number;
+  headers?: Record<string, unknown>;
+  body?: unknown;
+  chunk?: unknown;
+  durationMs?: number;
+  error?: { message: string; stack?: string; status?: number; body?: unknown };
+  metadata?: Record<string, unknown>;
+}
+
+export class TrafficLogsRepo {
+  static insert(params: InsertTrafficLogParams): boolean {
+    const { orm } = getProxyMetricsDb();
+    try {
+      orm
+        .insert(trafficLogs)
+        .values({
+          timestamp: params.timestamp,
+          direction: params.direction,
+          requestId: params.requestId,
+          endpoint: params.endpoint,
+          method: params.method ?? null,
+          status: params.status ?? null,
+          headersJson: params.headers ? JSON.stringify(params.headers) : null,
+          bodyJson: params.body != null ? JSON.stringify(params.body) : null,
+          chunkJson: params.chunk != null ? JSON.stringify(params.chunk) : null,
+          durationMs: params.durationMs ?? null,
+          errorMessage: params.error?.message ?? null,
+          errorStack: params.error?.stack ?? null,
+          errorStatus: params.error?.status ?? null,
+          metadataJson: params.metadata ? JSON.stringify(params.metadata) : null,
+        })
+        .run();
+      return true;
+    } catch (error) {
+      logger.error('Failed to insert traffic log', error);
+      return false;
+    }
+  }
+
+  static getRecent(limit: number = 50, direction?: string): Array<{
+    timestamp: number;
+    direction: string;
+    requestId: string;
+    endpoint: string;
+    method?: string;
+    status?: number;
+    headers?: Record<string, unknown>;
+    body?: unknown;
+    chunk?: unknown;
+    durationMs?: number;
+    error?: { message: string; stack?: string; status?: number; body?: unknown };
+    metadata?: Record<string, unknown>;
+  }> {
+    const { raw } = getProxyMetricsDb();
+    try {
+      let sql = `SELECT * FROM traffic_logs`;
+      const args: (number | string)[] = [];
+      if (direction) {
+        sql += ` WHERE direction = ?`;
+        args.push(direction);
+      }
+      sql += ` ORDER BY timestamp DESC LIMIT ?`;
+      args.push(limit);
+      const rows = raw.prepare(sql).all(...args) as Array<{
+        timestamp: number;
+        direction: string;
+        request_id: string;
+        endpoint: string;
+        method: string | null;
+        status: number | null;
+        headers_json: string | null;
+        body_json: string | null;
+        chunk_json: string | null;
+        duration_ms: number | null;
+        error_message: string | null;
+        error_stack: string | null;
+        error_status: number | null;
+        metadata_json: string | null;
+      }>;
+      return rows.map((r) => ({
+        timestamp: r.timestamp,
+        direction: r.direction,
+        requestId: r.request_id,
+        endpoint: r.endpoint,
+        method: r.method ?? undefined,
+        status: r.status ?? undefined,
+        headers: r.headers_json ? JSON.parse(r.headers_json) : undefined,
+        body: r.body_json ? JSON.parse(r.body_json) : undefined,
+        chunk: r.chunk_json ? JSON.parse(r.chunk_json) : undefined,
+        durationMs: r.duration_ms ?? undefined,
+        error:
+          r.error_message
+            ? { message: r.error_message, stack: r.error_stack ?? undefined, status: r.error_status ?? undefined }
+            : undefined,
+        metadata: r.metadata_json ? JSON.parse(r.metadata_json) : undefined,
+      }));
+    } catch (error) {
+      logger.error('Failed to get recent traffic logs', error);
+      return [];
+    }
+  }
+
+  static getStats(): { byDirection: Record<string, number>; byEndpoint: Record<string, number>; total: number } {
+    const { raw } = getProxyMetricsDb();
+    try {
+      const rows = raw.prepare(`SELECT direction, endpoint, COUNT(*) as cnt FROM traffic_logs GROUP BY direction, endpoint`).all() as Array<{
+        direction: string;
+        endpoint: string;
+        cnt: number;
+      }>;
+      const byDirection: Record<string, number> = {};
+      const byEndpoint: Record<string, number> = {};
+      let total = 0;
+      for (const r of rows) {
+        total += r.cnt;
+        byDirection[r.direction] = (byDirection[r.direction] || 0) + r.cnt;
+        byEndpoint[r.endpoint] = (byEndpoint[r.endpoint] || 0) + r.cnt;
+      }
+      return { byDirection, byEndpoint, total };
+    } catch (error) {
+      logger.error('Failed to get traffic log stats', error);
+      return { byDirection: {}, byEndpoint: {}, total: 0 };
+    }
+  }
+
+  static getAllForExport(): Array<{
+    timestamp: number;
+    direction: string;
+    requestId: string;
+    endpoint: string;
+    method?: string;
+    status?: number;
+    headers?: Record<string, unknown>;
+    body?: unknown;
+    chunk?: unknown;
+    durationMs?: number;
+    error?: { message: string; stack?: string; status?: number; body?: unknown };
+    metadata?: Record<string, unknown>;
+  }> {
+    const { raw } = getProxyMetricsDb();
+    try {
+      const rows = raw.prepare(`SELECT * FROM traffic_logs ORDER BY timestamp DESC`).all() as Array<{
+        timestamp: number;
+        direction: string;
+        request_id: string;
+        endpoint: string;
+        method: string | null;
+        status: number | null;
+        headers_json: string | null;
+        body_json: string | null;
+        chunk_json: string | null;
+        duration_ms: number | null;
+        error_message: string | null;
+        error_stack: string | null;
+        error_status: number | null;
+        metadata_json: string | null;
+      }>;
+      return rows.map((r) => ({
+        timestamp: r.timestamp,
+        direction: r.direction,
+        requestId: r.request_id,
+        endpoint: r.endpoint,
+        method: r.method ?? undefined,
+        status: r.status ?? undefined,
+        headers: r.headers_json ? JSON.parse(r.headers_json) : undefined,
+        body: r.body_json ? JSON.parse(r.body_json) : undefined,
+        chunk: r.chunk_json ? JSON.parse(r.chunk_json) : undefined,
+        durationMs: r.duration_ms ?? undefined,
+        error:
+          r.error_message
+            ? { message: r.error_message, stack: r.error_stack ?? undefined, status: r.error_status ?? undefined }
+            : undefined,
+        metadata: r.metadata_json ? JSON.parse(r.metadata_json) : undefined,
+      }));
+    } catch (error) {
+      logger.error('Failed to get all traffic logs for export', error);
+      return [];
+    }
+  }
+
+  static deleteOld(cutoffTimestamp: number): boolean {
+    const { raw } = getProxyMetricsDb();
+    try {
+      raw.prepare(`DELETE FROM traffic_logs WHERE timestamp < ?`).run(cutoffTimestamp);
+      return true;
+    } catch (error) {
+      logger.error('Failed to delete old traffic logs', error);
+      return false;
+    }
+  }
+}

src/ipc/database/schema.ts

@@ -39,3 +39,39 @@ export const tokenUsage = sqliteTable('token_usage', {
   requestType: text('request_type'),
   isEstimated: integer('is_estimated'),
 });
+
+export const proxyRequestMetrics = sqliteTable('proxy_request_metrics', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+  endpoint: text('endpoint').notNull(),
+  statusCode: integer('status_code').notNull(),
+  durationMs: integer('duration_ms').notNull(),
+  timestamp: integer('timestamp').notNull(),
+  accountId: text('account_id'),
+  tokensPrompt: integer('tokens_prompt'),
+  tokensCompletion: integer('tokens_completion'),
+  errorMessage: text('error_message'),
+});
+
+export const proxyConnectionSnapshots = sqliteTable('proxy_connection_snapshots', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+  timestamp: integer('timestamp').notNull(),
+  count: integer('count').notNull().default(0),
+});
+
+export const trafficLogs = sqliteTable('traffic_logs', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+  timestamp: integer('timestamp').notNull(),
+  direction: text('direction').notNull(),
+  requestId: text('request_id').notNull(),
+  endpoint: text('endpoint').notNull(),
+  method: text('method'),
+  status: integer('status'),
+  headersJson: text('headers_json'),
+  bodyJson: text('body_json'),
+  chunkJson: text('chunk_json'),
+  durationMs: integer('duration_ms'),
+  errorMessage: text('error_message'),
+  errorStack: text('error_stack'),
+  errorStatus: integer('error_status'),
+  metadataJson: text('metadata_json'),
+});

src/ipc/database/usageHandler.ts

@@ -24,7 +24,10 @@ export interface RecordUsageParams {
   isEstimated?: boolean;
 }
 
-let usageDbConnection: { raw: Database.Database; orm: BetterSQLite3Database<typeof import('./schema')> } | null = null;
+let usageDbConnection: {
+  raw: Database.Database;
+  orm: BetterSQLite3Database<typeof import('./schema')>;
+} | null = null;
 
 function getUsageDb() {
   if (!usageDbConnection) {
@@ -57,9 +60,7 @@ function buildDateFilter(start?: number, end?: number): { sql: string; params: n
 }
 
 function buildAccountFilter(accountId?: string): { sql: string; params: unknown[] } {
-  return accountId
-    ? { sql: 'AND account_id = ?', params: [accountId] }
-    : { sql: '', params: [] };
+  return accountId ? { sql: 'AND account_id = ?', params: [accountId] } : { sql: '', params: [] };
 }
 
 export class TokenUsageRepo {

src/ipc/proxy-advanced/handler.ts

@@ -0,0 +1,325 @@
+import { logger } from '../../utils/logger';
+import { proxyAdvancedRegistry } from './service-registry';
+import type { IdeConfigResult } from '../../server/modules/proxy/proxy-ide-config.service';
+import { TrafficLogsRepo } from '../database/proxyMetricsHandler';
+
+export interface TrafficLogEntryParsed {
+  timestamp: string;
+  direction: string;
+  requestId: string;
+  endpoint: string;
+  method?: string;
+  status?: number;
+  headers?: Record<string, unknown>;
+  body?: unknown;
+  chunk?: unknown;
+  durationMs?: number;
+  error?: {
+    message: string;
+    stack?: string;
+    status?: number;
+    body?: unknown;
+  };
+  metadata?: Record<string, unknown>;
+}
+
+export async function getRecentTrafficLogs(
+  limit: number = 50,
+  direction?: string,
+): Promise<{ success: boolean; data?: TrafficLogEntryParsed[]; error?: string }> {
+  try {
+    const rows = TrafficLogsRepo.getRecent(limit, direction);
+    const entries: TrafficLogEntryParsed[] = rows.map((r) => ({
+      timestamp: new Date(r.timestamp).toISOString(),
+      direction: r.direction,
+      requestId: r.requestId,
+      endpoint: r.endpoint,
+      method: r.method,
+      status: r.status,
+      headers: r.headers,
+      body: r.body,
+      chunk: r.chunk,
+      durationMs: r.durationMs,
+      error: r.error,
+      metadata: r.metadata,
+    }));
+
+    return { success: true, data: entries };
+  } catch (error) {
+    logger.error('Failed to get recent traffic logs', error);
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export async function getTrafficLogStats(): Promise<{
+  success: boolean;
+  data?: { byDirection: Record<string, number>; byEndpoint: Record<string, number>; total: number };
+  error?: string;
+}> {
+  try {
+    const stats = TrafficLogsRepo.getStats();
+    return { success: true, data: stats };
+  } catch (error) {
+    logger.error('Failed to get traffic log stats', error);
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export async function exportTrafficLogs(
+  format: 'json' | 'csv',
+): Promise<{ success: boolean; data?: string; error?: string }> {
+  try {
+    const rows = TrafficLogsRepo.getAllForExport();
+
+    if (format === 'json') {
+      return { success: true, data: JSON.stringify(rows, null, 2) };
+    }
+
+    // CSV format
+    const headers = ['timestamp', 'direction', 'requestId', 'endpoint', 'method', 'status', 'durationMs'];
+    const rowsCsv = rows.map((e) =>
+      [
+        new Date(e.timestamp).toISOString(),
+        e.direction,
+        e.requestId,
+        e.endpoint,
+        e.method || '',
+        e.status != null ? e.status : '',
+        e.durationMs != null ? e.durationMs : '',
+      ]
+        .map((v) => `"${String(v).replace(/"/g, '""')}"`)
+        .join(','),
+    );
+
+    return { success: true, data: [headers.join(','), ...rowsCsv].join('\n') };
+  } catch (error) {
+    logger.error('Failed to export traffic logs', error);
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export async function getParityCounters(): Promise<{
+  success: boolean;
+  data?: { totalRequests: number; matchedRequests: number; parityViolations: number; lastUpdated: string };
+  error?: string;
+}> {
+  try {
+    const tokenManager = proxyAdvancedRegistry.tokenManager;
+    if (!tokenManager) {
+      return {
+        success: true,
+        data: {
+          totalRequests: 0,
+          matchedRequests: 0,
+          parityViolations: 0,
+          lastUpdated: new Date().toISOString(),
+        },
+      };
+    }
+    return {
+      success: true,
+      data: tokenManager.getParityCounters(),
+    };
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export async function getCircuitBreakerStatus(): Promise<{
+  success: boolean;
+  data?: { states: Record<string, { state: string; failures: number; lastFailure: string | null }>; globalEnabled: boolean };
+  error?: string;
+}> {
+  try {
+    const tokenManager = proxyAdvancedRegistry.tokenManager;
+    if (!tokenManager) {
+      return {
+        success: true,
+        data: {
+          states: {},
+          globalEnabled: true,
+        },
+      };
+    }
+
+    const rawStatus = tokenManager.getCircuitBreakerStatus();
+    const states: Record<string, { state: string; failures: number; lastFailure: string | null }> = {};
+    for (const [accountId, entry] of Object.entries(rawStatus)) {
+      states[accountId] = {
+        state: entry.state,
+        failures: entry.failureCount,
+        lastFailure: entry.lastFailureTime ? new Date(entry.lastFailureTime).toISOString() : null,
+      };
+    }
+
+    return {
+      success: true,
+      data: {
+        states,
+        globalEnabled: true,
+      },
+    };
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export async function getProxyMetrics(): Promise<{
+  success: boolean;
+  data?: {
+    uptimeSeconds: number;
+    totalRequests: number;
+    activeConnections: number;
+    avgLatency: number;
+    errorRate: number;
+    requestsPerMinute: number;
+  };
+  error?: string;
+}> {
+  try {
+    const proxyMetrics = proxyAdvancedRegistry.proxyMetrics;
+    if (!proxyMetrics) {
+      return {
+        success: true,
+        data: {
+          uptimeSeconds: 0,
+          totalRequests: 0,
+          activeConnections: 0,
+          avgLatency: 0,
+          errorRate: 0,
+          requestsPerMinute: 0,
+        },
+      };
+    }
+
+    const metrics = proxyMetrics.getMetrics();
+    return {
+      success: true,
+      data: {
+        uptimeSeconds: Math.floor(process.uptime()),
+        totalRequests: metrics.totalRequests,
+        activeConnections: metrics.activeConnections,
+        avgLatency: metrics.avgLatency,
+        errorRate: metrics.errorRate,
+        requestsPerMinute: metrics.requestsPerMinute,
+      },
+    };
+  } catch (error) {
+    logger.error('Failed to get proxy metrics', error);
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export async function getRecentRequests(): Promise<{ success: boolean; data?: unknown[]; error?: string }> {
+  try {
+    const proxyReplay = proxyAdvancedRegistry.proxyReplay;
+    if (!proxyReplay) {
+      return {
+        success: true,
+        data: [],
+      };
+    }
+    return {
+      success: true,
+      data: proxyReplay.getRecentRequests(20),
+    };
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+function mapIdeConfigResult(
+  result: IdeConfigResult,
+): {
+  name: string;
+  settingsPath: string;
+  proxySetting: string;
+  apiKeySetting: string;
+  instructions: string;
+} {
+  switch (result.ide) {
+    case 'vscode':
+      return {
+        name: 'VS Code',
+        settingsPath: 'settings.json',
+        proxySetting: 'openai.url',
+        apiKeySetting: 'openai.apiKey',
+        instructions: 'Add these settings to your VS Code settings.json',
+      };
+    case 'cursor':
+      return {
+        name: 'Cursor',
+        settingsPath: 'settings.json',
+        proxySetting: 'OPENAI_BASE_URL',
+        apiKeySetting: 'OPENAI_API_KEY',
+        instructions: 'Set these environment variables for Cursor',
+      };
+    case 'claude-code':
+      return {
+        name: 'Claude Code',
+        settingsPath: 'Shell environment',
+        proxySetting: 'ANTHROPIC_BASE_URL',
+        apiKeySetting: 'ANTHROPIC_API_KEY',
+        instructions: 'Run these export commands before starting Claude Code',
+      };
+    case 'jetbrains':
+      return {
+        name: 'JetBrains',
+        settingsPath: 'IDE Settings',
+        proxySetting: 'Base URL',
+        apiKeySetting: 'API Key',
+        instructions: String(result.content),
+      };
+    case 'opencide':
+      return {
+        name: 'Opencide',
+        settingsPath: '.env',
+        proxySetting: 'OPENAI_BASE_URL',
+        apiKeySetting: 'OPENAI_API_KEY',
+        instructions: 'Add these lines to your .env file',
+      };
+    default: {
+      const exhaustiveCheck: never = result.ide;
+      throw new Error(`Unsupported IDE: ${String(exhaustiveCheck)}`);
+    }
+  }
+}
+
+export async function generateIdeConfig(
+  ide: string,
+): Promise<{
+  success: boolean;
+  data?: {
+    name: string;
+    settingsPath: string;
+    proxySetting: string;
+    apiKeySetting: string;
+    instructions: string;
+  };
+  error?: string;
+}> {
+  try {
+    const proxyIdeConfig = proxyAdvancedRegistry.proxyIdeConfig;
+    if (!proxyIdeConfig) {
+      return { success: false, error: 'IDE config service not available' };
+    }
+
+    const supportedIdes = ['cursor', 'vscode', 'claude-code', 'jetbrains', 'opencide'] as const;
+    const normalizedIde = ide.toLowerCase() as typeof supportedIdes[number];
+    if (!supportedIdes.includes(normalizedIde)) {
+      return { success: false, error: `Unsupported IDE: ${ide}` };
+    }
+
+    const result = proxyIdeConfig.generateConfigForCurrentServer(normalizedIde);
+    if (!result) {
+      return { success: false, error: 'Failed to generate IDE config: server not configured' };
+    }
+
+    return {
+      success: true,
+      data: mapIdeConfigResult(result),
+    };
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}

src/ipc/proxy-advanced/router.ts

@@ -0,0 +1,172 @@
+import { z } from 'zod';
+import { os } from '@orpc/server';
+import {
+  getRecentTrafficLogs,
+  getTrafficLogStats,
+  exportTrafficLogs,
+  getParityCounters,
+  getCircuitBreakerStatus,
+  getProxyMetrics,
+  getRecentRequests,
+  generateIdeConfig,
+} from './handler';
+
+const TrafficLogEntrySchema = z.object({
+  timestamp: z.string(),
+  direction: z.string(),
+  requestId: z.string(),
+  endpoint: z.string(),
+  method: z.string().optional(),
+  status: z.number().optional(),
+  headers: z.record(z.string(), z.unknown()).optional(),
+  body: z.unknown().optional(),
+  chunk: z.unknown().optional(),
+  durationMs: z.number().optional(),
+  error: z
+    .object({
+      message: z.string(),
+      stack: z.string().optional(),
+      status: z.number().optional(),
+      body: z.unknown().optional(),
+    })
+    .optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+const TrafficLogsResponseSchema = z.object({
+  success: z.boolean(),
+  data: z.array(TrafficLogEntrySchema).optional(),
+  error: z.string().optional(),
+});
+
+const TrafficLogStatsResponseSchema = z.object({
+  success: z.boolean(),
+  data: z
+    .object({
+      byDirection: z.record(z.string(), z.number()),
+      byEndpoint: z.record(z.string(), z.number()),
+      total: z.number(),
+    })
+    .optional(),
+  error: z.string().optional(),
+});
+
+const ExportTrafficLogsResponseSchema = z.object({
+  success: z.boolean(),
+  data: z.string().optional(),
+  error: z.string().optional(),
+});
+
+const ParityCountersResponseSchema = z.object({
+  success: z.boolean(),
+  data: z
+    .object({
+      totalRequests: z.number(),
+      matchedRequests: z.number(),
+      parityViolations: z.number(),
+      lastUpdated: z.string(),
+    })
+    .optional(),
+  error: z.string().optional(),
+});
+
+const CircuitBreakerStatusResponseSchema = z.object({
+  success: z.boolean(),
+  data: z
+    .object({
+      states: z.record(
+        z.string(),
+        z.object({
+          state: z.string(),
+          failures: z.number(),
+          lastFailure: z.string().nullable(),
+        }),
+      ),
+      globalEnabled: z.boolean(),
+    })
+    .optional(),
+  error: z.string().optional(),
+});
+
+const ProxyMetricsResponseSchema = z.object({
+  success: z.boolean(),
+  data: z
+    .object({
+      uptimeSeconds: z.number(),
+      totalRequests: z.number(),
+      activeConnections: z.number(),
+      avgLatency: z.number(),
+      errorRate: z.number(),
+      requestsPerMinute: z.number(),
+    })
+    .optional(),
+  error: z.string().optional(),
+});
+
+const RecentRequestsResponseSchema = z.object({
+  success: z.boolean(),
+  data: z.array(z.unknown()).optional(),
+  error: z.string().optional(),
+});
+
+const IdeConfigResponseSchema = z.object({
+  success: z.boolean(),
+  data: z
+    .object({
+      name: z.string(),
+      settingsPath: z.string(),
+      proxySetting: z.string(),
+      apiKeySetting: z.string(),
+      instructions: z.string(),
+    })
+    .optional(),
+  error: z.string().optional(),
+});
+
+export const proxyAdvancedRouter = os.router({
+  getRecentTrafficLogs: os
+    .input(
+      z.object({
+        limit: z.number().int().min(1).max(1000).optional(),
+        direction: z.string().optional(),
+      }),
+    )
+    .output(TrafficLogsResponseSchema)
+    .handler(async ({ input }) => {
+      return getRecentTrafficLogs(input.limit, input.direction);
+    }),
+
+  getTrafficLogStats: os.output(TrafficLogStatsResponseSchema).handler(async () => {
+    return getTrafficLogStats();
+  }),
+
+  exportTrafficLogs: os
+    .input(z.object({ format: z.enum(['json', 'csv']) }))
+    .output(ExportTrafficLogsResponseSchema)
+    .handler(async ({ input }) => {
+      return exportTrafficLogs(input.format);
+    }),
+
+  getParityCounters: os.output(ParityCountersResponseSchema).handler(async () => {
+    return getParityCounters();
+  }),
+
+  getCircuitBreakerStatus: os.output(CircuitBreakerStatusResponseSchema).handler(async () => {
+    return getCircuitBreakerStatus();
+  }),
+
+  getProxyMetrics: os.output(ProxyMetricsResponseSchema).handler(async () => {
+    return getProxyMetrics();
+  }),
+
+  getRecentRequests: os.output(RecentRequestsResponseSchema).handler(async () => {
+    return getRecentRequests();
+  }),
+
+  generateIdeConfig: os
+    .input(z.object({ ide: z.string() }))
+    .output(IdeConfigResponseSchema)
+    .handler(async ({ input }) => {
+      return generateIdeConfig(input.ide);
+    }),
+});

src/ipc/proxy-advanced/service-registry.ts

@@ -0,0 +1,31 @@
+/**
+ * Service registry for proxy-advanced IPC handlers to access
+ * NestJS service instances without DI coupling.
+ *
+ * Services auto-register on construction.
+ */
+import type { TokenManagerService } from '../../server/modules/proxy/token-manager.service';
+import type { ProxyMetricsService } from '../../server/modules/proxy/proxy-metrics.service';
+import type { ProxyReplayService } from '../../server/modules/proxy/proxy-replay.service';
+import type { ProxyIdeConfigService } from '../../server/modules/proxy/proxy-ide-config.service';
+
+interface ProxyAdvancedRegistry {
+  tokenManager: TokenManagerService | null;
+  proxyMetrics: ProxyMetricsService | null;
+  proxyReplay: ProxyReplayService | null;
+  proxyIdeConfig: ProxyIdeConfigService | null;
+}
+
+export const proxyAdvancedRegistry: ProxyAdvancedRegistry = {
+  tokenManager: null,
+  proxyMetrics: null,
+  proxyReplay: null,
+  proxyIdeConfig: null,
+};
+
+export function registerProxyAdvancedService<K extends keyof ProxyAdvancedRegistry>(
+  key: K,
+  instance: ProxyAdvancedRegistry[K],
+): void {
+  proxyAdvancedRegistry[key] = instance;
+}

src/ipc/router.ts

@@ -7,6 +7,7 @@ import { cloudRouter } from './cloud/router';
 import { configRouter } from './config/router';
 import { gatewayRouter } from './gateway/router';
 import { usageRouter } from './usage/router';
+import { proxyAdvancedRouter } from './proxy-advanced/router';
 
 import { os } from '@orpc/server';
 import { z } from 'zod';
@@ -55,5 +56,6 @@ export const router = os.use(logMiddleware).router({
   config: configRouter,
   gateway: gatewayRouter,
   usage: usageRouter,
+  proxyAdvanced: proxyAdvancedRouter,
   system: systemHandler,
 });