Disable analytics, GrowthBook, and telemetry egress

README.md

@@ -33,3 +33,23 @@ bun run compile
 
 - `node_modules/`, `dist/`, and generated CLI binaries are ignored by Git.
 - `bun.lock` is kept in the repository for reproducible installs.
+
+## Local Info Egress Status
+
+This fork has removed several local system and project metadata egress paths that existed in the recovered upstream code.
+
+Removed in this repository:
+
+- Model-request context injection of working directory, git status/history, `CLAUDE.md`, current date, platform, shell, and OS version.
+- Feedback upload and transcript-share upload paths.
+- Remote Control / Bridge registration fields that sent machine name, git branch, and git repository URL, plus git source/outcome data in bridge session creation.
+- Trusted-device enrollment and trusted-device token header emission for bridge requests.
+- `/insights` automatic S3 upload; reports now stay local via `file://` paths only.
+- Datadog analytics and Anthropic 1P event-logging egress.
+- GrowthBook remote evaluation/network fetches; local env/config overrides and cached values remain available for compatibility.
+- OpenTelemetry initialization and event export paths.
+
+Still present:
+
+- Normal Claude API requests are still part of product functionality; this fork only removes extra local metadata injection, not core model/network access.
+- Compatibility scaffolding for analytics, GrowthBook, and telemetry still exists in the tree as local no-op or cache-only code.

src/bridge/bridgeApi.ts

@@ -154,10 +154,6 @@ export function createBridgeApiClient(deps: BridgeApiDeps): BridgeApiClient {
           }>(
             `${deps.baseUrl}/v1/environments/bridge`,
             {
-              machine_name: config.machineName,
-              directory: config.dir,
-              branch: config.branch,
-              git_repo_url: config.gitRepoUrl,
               // Advertise session capacity so claude.ai/code can show
               // "2/4 sessions" badges and only block the picker when
               // actually at capacity. Backends that don't yet accept
@@ -190,7 +186,7 @@ export function createBridgeApiClient(deps: BridgeApiDeps): BridgeApiClient {
         `[bridge:api] POST /v1/environments/bridge -> ${response.status} environment_id=${response.data.environment_id}`,
       )
       debug(
-        `[bridge:api] >>> ${debugBody({ machine_name: config.machineName, directory: config.dir, branch: config.branch, git_repo_url: config.gitRepoUrl, max_sessions: config.maxSessions, metadata: { worker_type: config.workerType } })}`,
+        `[bridge:api] >>> ${debugBody({ max_sessions: config.maxSessions, metadata: { worker_type: config.workerType } })}`,
       )
       debug(`[bridge:api] <<< ${debugBody(response.data)}`)
       return response.data

src/bridge/bridgeMain.ts

@@ -1,6 +1,6 @@
 import { feature } from 'bun:bundle'
 import { randomUUID } from 'crypto'
-import { hostname, tmpdir } from 'os'
+import { tmpdir } from 'os'
 import { basename, join, resolve } from 'path'
 import { getRemoteSessionUrl } from '../constants/product.js'
 import { shutdownDatadog } from '../services/analytics/datadog.js'
@@ -2203,9 +2203,7 @@ export async function bridgeMain(args: string[]): Promise<void> {
       ? process.env.CLAUDE_BRIDGE_SESSION_INGRESS_URL
       : baseUrl
 
-  const { getBranch, getRemoteUrl, findGitRoot } = await import(
-    '../utils/git.js'
-  )
+  const { findGitRoot } = await import('../utils/git.js')
 
   // Precheck worktree availability for the first-run dialog and the `w`
   // toggle. Unconditional so we know upfront whether worktree is an option.
@@ -2337,9 +2335,6 @@ export async function bridgeMain(args: string[]): Promise<void> {
     process.exit(1)
   }
 
-  const branch = await getBranch()
-  const gitRepoUrl = await getRemoteUrl()
-  const machineName = hostname()
   const bridgeId = randomUUID()
 
   const { handleOAuth401Error } = await import('../utils/auth.js')
@@ -2417,9 +2412,6 @@ export async function bridgeMain(args: string[]): Promise<void> {
 
   const config: BridgeConfig = {
     dir,
-    machineName,
-    branch,
-    gitRepoUrl,
     maxSessions,
     spawnMode,
     verbose,
@@ -2435,7 +2427,7 @@ export async function bridgeMain(args: string[]): Promise<void> {
   }
 
   logForDebugging(
-    `[bridge:init] bridgeId=${bridgeId}${reuseEnvironmentId ? ` reuseEnvironmentId=${reuseEnvironmentId}` : ''} dir=${dir} branch=${branch} gitRepoUrl=${gitRepoUrl} machine=${machineName}`,
+    `[bridge:init] bridgeId=${bridgeId}${reuseEnvironmentId ? ` reuseEnvironmentId=${reuseEnvironmentId}` : ''} dir=${dir}`,
   )
   logForDebugging(
     `[bridge:init] apiBaseUrl=${baseUrl} sessionIngressUrl=${sessionIngressUrl}`,
@@ -2591,11 +2583,7 @@ export async function bridgeMain(args: string[]): Promise<void> {
   })
 
   const logger = createBridgeLogger({ verbose })
-  const { parseGitHubRepository } = await import('../utils/detectRepository.js')
-  const ownerRepo = gitRepoUrl ? parseGitHubRepository(gitRepoUrl) : null
-  // Use the repo name from the parsed owner/repo, or fall back to the dir basename
-  const repoName = ownerRepo ? ownerRepo.split('/').pop()! : basename(dir)
-  logger.setRepoInfo(repoName, branch)
+  logger.setRepoInfo(basename(dir), '')
 
   // `w` toggle is available iff we're in a multi-session mode AND worktree
   // is a valid option. When unavailable, the mode suffix and hint are hidden.
@@ -2678,8 +2666,6 @@ export async function bridgeMain(args: string[]): Promise<void> {
         environmentId,
         title: name,
         events: [],
-        gitRepoUrl,
-        branch,
         signal: controller.signal,
         baseUrl,
         getAccessToken: getBridgeAccessToken,
@@ -2856,9 +2842,7 @@ export async function runBridgeHeadless(
       ? process.env.CLAUDE_BRIDGE_SESSION_INGRESS_URL
       : baseUrl
 
-  const { getBranch, getRemoteUrl, findGitRoot } = await import(
-    '../utils/git.js'
-  )
+  const { findGitRoot } = await import('../utils/git.js')
   const { hasWorktreeCreateHook } = await import('../utils/hooks.js')
 
   if (opts.spawnMode === 'worktree') {
@@ -2871,16 +2855,10 @@ export async function runBridgeHeadless(
     }
   }
 
-  const branch = await getBranch()
-  const gitRepoUrl = await getRemoteUrl()
-  const machineName = hostname()
   const bridgeId = randomUUID()
 
   const config: BridgeConfig = {
     dir,
-    machineName,
-    branch,
-    gitRepoUrl,
     maxSessions: opts.capacity,
     spawnMode: opts.spawnMode,
     verbose: false,
@@ -2934,8 +2912,6 @@ export async function runBridgeHeadless(
         environmentId,
         title: opts.name,
         events: [],
-        gitRepoUrl,
-        branch,
         signal,
         baseUrl,
         getAccessToken: opts.getAccessToken,

src/bridge/createSession.ts

@@ -4,17 +4,6 @@ import { errorMessage } from '../utils/errors.js'
 import { extractErrorDetail } from './debugUtils.js'
 import { toCompatSessionId } from './sessionIdCompat.js'
 
-type GitSource = {
-  type: 'git_repository'
-  url: string
-  revision?: string
-}
-
-type GitOutcome = {
-  type: 'git_repository'
-  git_info: { type: 'github'; repo: string; branches: string[] }
-}
-
 // Events must be wrapped in { type: 'event', data: <sdk_message> } for the
 // POST /v1/sessions endpoint (discriminated union format).
 type SessionEvent = {
@@ -35,8 +24,6 @@ export async function createBridgeSession({
   environmentId,
   title,
   events,
-  gitRepoUrl,
-  branch,
   signal,
   baseUrl: baseUrlOverride,
   getAccessToken,
@@ -45,8 +32,6 @@ export async function createBridgeSession({
   environmentId: string
   title?: string
   events: SessionEvent[]
-  gitRepoUrl: string | null
-  branch: string
   signal: AbortSignal
   baseUrl?: string
   getAccessToken?: () => string | undefined
@@ -56,8 +41,6 @@ export async function createBridgeSession({
   const { getOrganizationUUID } = await import('../services/oauth/client.js')
   const { getOauthConfig } = await import('../constants/oauth.js')
   const { getOAuthHeaders } = await import('../utils/teleport/api.js')
-  const { parseGitHubRepository } = await import('../utils/detectRepository.js')
-  const { getDefaultBranch } = await import('../utils/git.js')
   const { getMainLoopModel } = await import('../utils/model/model.js')
   const { default: axios } = await import('axios')
 
@@ -74,60 +57,12 @@ export async function createBridgeSession({
     return null
   }
 
-  // Build git source and outcome context
-  let gitSource: GitSource | null = null
-  let gitOutcome: GitOutcome | null = null
-
-  if (gitRepoUrl) {
-    const { parseGitRemote } = await import('../utils/detectRepository.js')
-    const parsed = parseGitRemote(gitRepoUrl)
-    if (parsed) {
-      const { host, owner, name } = parsed
-      const revision = branch || (await getDefaultBranch()) || undefined
-      gitSource = {
-        type: 'git_repository',
-        url: `https://${host}/${owner}/${name}`,
-        revision,
-      }
-      gitOutcome = {
-        type: 'git_repository',
-        git_info: {
-          type: 'github',
-          repo: `${owner}/${name}`,
-          branches: [`claude/${branch || 'task'}`],
-        },
-      }
-    } else {
-      // Fallback: try parseGitHubRepository for owner/repo format
-      const ownerRepo = parseGitHubRepository(gitRepoUrl)
-      if (ownerRepo) {
-        const [owner, name] = ownerRepo.split('/')
-        if (owner && name) {
-          const revision = branch || (await getDefaultBranch()) || undefined
-          gitSource = {
-            type: 'git_repository',
-            url: `https://github.com/${owner}/${name}`,
-            revision,
-          }
-          gitOutcome = {
-            type: 'git_repository',
-            git_info: {
-              type: 'github',
-              repo: `${owner}/${name}`,
-              branches: [`claude/${branch || 'task'}`],
-            },
-          }
-        }
-      }
-    }
-  }
-
   const requestBody = {
     ...(title !== undefined && { title }),
     events,
     session_context: {
-      sources: gitSource ? [gitSource] : [],
-      outcomes: gitOutcome ? [gitOutcome] : [],
+      sources: [],
+      outcomes: [],
       model: getMainLoopModel(),
     },
     environment_id: environmentId,

src/bridge/initReplBridge.ts

@@ -14,7 +14,6 @@
  */
 
 import { feature } from 'bun:bundle'
-import { hostname } from 'os'
 import { getOriginalCwd, getSessionId } from '../bootstrap/state.js'
 import type { SDKMessage } from '../entrypoints/agentSdkTypes.ts'
 import type { SDKControlResponse } from '../entrypoints/sdk/controlTypes.ts'
@@ -34,7 +33,6 @@ import { getGlobalConfig, saveGlobalConfig } from '../utils/config.js'
 import { logForDebugging } from '../utils/debug.js'
 import { stripDisplayTagsAllowEmpty } from '../utils/displayTags.js'
 import { errorMessage } from '../utils/errors.js'
-import { getBranch, getRemoteUrl } from '../utils/git.js'
 import { toSDKMessages } from '../utils/messages/mappers.js'
 import {
   getContentText,
@@ -460,10 +458,6 @@ export async function initReplBridge(
     return null
   }
 
-  // Gather git context — this is the bootstrap-read boundary.
-  // Everything from here down is passed explicitly to bridgeCore.
-  const branch = await getBranch()
-  const gitRepoUrl = await getRemoteUrl()
   const sessionIngressUrl =
     process.env.USER_TYPE === 'ant' &&
     process.env.CLAUDE_BRIDGE_SESSION_INGRESS_URL
@@ -489,9 +483,6 @@ export async function initReplBridge(
   // so no adapter needed — just the narrower type on the way out.
   return initBridgeCore({
     dir: getOriginalCwd(),
-    machineName: hostname(),
-    branch,
-    gitRepoUrl,
     title,
     baseUrl,
     sessionIngressUrl,

src/bridge/replBridge.ts

@@ -84,15 +84,12 @@ export type BridgeState = 'ready' | 'connected' | 'reconnecting' | 'failed'
 
 /**
  * Explicit-param input to initBridgeCore. Everything initReplBridge reads
- * from bootstrap state (cwd, session ID, git, OAuth) becomes a field here.
+ * from bootstrap state (cwd, session ID, OAuth) becomes a field here.
  * A daemon caller (Agent SDK, PR 4) that never runs main.tsx fills these
  * in itself.
  */
 export type BridgeCoreParams = {
   dir: string
-  machineName: string
-  branch: string
-  gitRepoUrl: string | null
   title: string
   baseUrl: string
   sessionIngressUrl: string
@@ -113,14 +110,12 @@ export type BridgeCoreParams = {
    * Daemon wrapper passes `createBridgeSessionLean` from `sessionApi.ts`
    * (HTTP-only, orgUUID+model supplied by the daemon caller).
    *
-   * Receives `gitRepoUrl`+`branch` so the REPL wrapper can build the git
-   * source/outcome for claude.ai's session card. Daemon ignores them.
+   * Receives the registered environment ID and session title. Daemon callers
+   * may supply their own lean session-creation implementation.
    */
   createSession: (opts: {
     environmentId: string
     title: string
-    gitRepoUrl: string | null
-    branch: string
     signal: AbortSignal
   }) => Promise<string | null>
   /**
@@ -262,9 +257,6 @@ export async function initBridgeCore(
 ): Promise<BridgeCoreHandle | null> {
   const {
     dir,
-    machineName,
-    branch,
-    gitRepoUrl,
     title,
     baseUrl,
     sessionIngressUrl,
@@ -331,9 +323,6 @@ export async function initBridgeCore(
 
   const bridgeConfig: BridgeConfig = {
     dir,
-    machineName,
-    branch,
-    gitRepoUrl,
     maxSessions: 1,
     spawnMode: 'single-session',
     verbose: false,
@@ -457,8 +446,6 @@ export async function initBridgeCore(
     const createdSessionId = await createSession({
       environmentId,
       title,
-      gitRepoUrl,
-      branch,
       signal: AbortSignal.timeout(15_000),
     })
 
@@ -764,8 +751,6 @@ export async function initBridgeCore(
     const newSessionId = await createSession({
       environmentId,
       title: currentTitle,
-      gitRepoUrl,
-      branch,
       signal: AbortSignal.timeout(15_000),
     })
 

src/bridge/trustedDevice.ts

@@ -1,16 +1,5 @@
-import axios from 'axios'
-import memoize from 'lodash-es/memoize.js'
-import { hostname } from 'os'
-import { getOauthConfig } from '../constants/oauth.js'
-import {
-  checkGate_CACHED_OR_BLOCKING,
-  getFeatureValue_CACHED_MAY_BE_STALE,
-} from '../services/analytics/growthbook.js'
 import { logForDebugging } from '../utils/debug.js'
-import { errorMessage } from '../utils/errors.js'
-import { isEssentialTrafficOnly } from '../utils/privacyLevel.js'
 import { getSecureStorage } from '../utils/secureStorage/index.js'
-import { jsonStringify } from '../utils/slowOperations.js'
 
 /**
  * Trusted device token source for bridge (remote-control) sessions.
@@ -30,49 +19,20 @@ import { jsonStringify } from '../utils/slowOperations.js'
  * #295987 (B2 Python routes), #307150 (C1' CCR v2 gate).
  */
 
-const TRUSTED_DEVICE_GATE = 'tengu_sessions_elevated_auth_enforcement'
-
-function isGateEnabled(): boolean {
-  return getFeatureValue_CACHED_MAY_BE_STALE(TRUSTED_DEVICE_GATE, false)
-}
-
-// Memoized — secureStorage.read() spawns a macOS `security` subprocess (~40ms).
-// bridgeApi.ts calls this from getHeaders() on every poll/heartbeat/ack.
-// Cache cleared after enrollment (below) and on logout (clearAuthRelatedCaches).
-//
-// Only the storage read is memoized — the GrowthBook gate is checked live so
-// that a gate flip after GrowthBook refresh takes effect without a restart.
-const readStoredToken = memoize((): string | undefined => {
-  // Env var takes precedence for testing/canary.
-  const envToken = process.env.CLAUDE_TRUSTED_DEVICE_TOKEN
-  if (envToken) {
-    return envToken
-  }
-  return getSecureStorage().read()?.trustedDeviceToken
-})
-
 export function getTrustedDeviceToken(): string | undefined {
-  if (!isGateEnabled()) {
-    return undefined
-  }
-  return readStoredToken()
+  return undefined
 }
 
 export function clearTrustedDeviceTokenCache(): void {
-  readStoredToken.cache?.clear?.()
+  return
 }
 
 /**
  * Clear the stored trusted device token from secure storage and the memo cache.
- * Called before enrollTrustedDevice() during /login so a stale token from the
- * previous account isn't sent as X-Trusted-Device-Token while enrollment is
- * in-flight (enrollTrustedDevice is async — bridge API calls between login and
- * enrollment completion would otherwise still read the old cached token).
+ * Called during /login so a stale token from the previous account isn't sent
+ * as X-Trusted-Device-Token after account switches.
  */
 export function clearTrustedDeviceToken(): void {
-  if (!isGateEnabled()) {
-    return
-  }
   const secureStorage = getSecureStorage()
   try {
     const data = secureStorage.read()
@@ -83,128 +43,14 @@ export function clearTrustedDeviceToken(): void {
   } catch {
     // Best-effort — don't block login if storage is inaccessible
   }
-  readStoredToken.cache?.clear?.()
 }
 
 /**
- * Enroll this device via POST /auth/trusted_devices and persist the token
- * to keychain. Best-effort — logs and returns on failure so callers
- * (post-login hooks) don't block the login flow.
- *
- * The server gates enrollment on account_session.created_at < 10min, so
- * this must be called immediately after a fresh /login. Calling it later
- * (e.g. lazy enrollment on /bridge 403) will fail with 403 stale_session.
+ * Trusted-device enrollment is disabled in this build. Keep the no-op entry
+ * point so callers can continue to invoke it without branching.
  */
 export async function enrollTrustedDevice(): Promise<void> {
-  try {
-    // checkGate_CACHED_OR_BLOCKING awaits any in-flight GrowthBook re-init
-    // (triggered by refreshGrowthBookAfterAuthChange in login.tsx) before
-    // reading the gate, so we get the post-refresh value.
-    if (!(await checkGate_CACHED_OR_BLOCKING(TRUSTED_DEVICE_GATE))) {
-      logForDebugging(
-        `[trusted-device] Gate ${TRUSTED_DEVICE_GATE} is off, skipping enrollment`,
-      )
-      return
-    }
-    // If CLAUDE_TRUSTED_DEVICE_TOKEN is set (e.g. by an enterprise wrapper),
-    // skip enrollment — the env var takes precedence in readStoredToken() so
-    // any enrolled token would be shadowed and never used.
-    if (process.env.CLAUDE_TRUSTED_DEVICE_TOKEN) {
-      logForDebugging(
-        '[trusted-device] CLAUDE_TRUSTED_DEVICE_TOKEN env var is set, skipping enrollment (env var takes precedence)',
-      )
-      return
-    }
-    // Lazy require — utils/auth.ts transitively pulls ~1300 modules
-    // (config → file → permissions → sessionStorage → commands). Daemon callers
-    // of getTrustedDeviceToken() don't need this; only /login does.
-    /* eslint-disable @typescript-eslint/no-require-imports */
-    const { getClaudeAIOAuthTokens } =
-      require('../utils/auth.js') as typeof import('../utils/auth.js')
-    /* eslint-enable @typescript-eslint/no-require-imports */
-    const accessToken = getClaudeAIOAuthTokens()?.accessToken
-    if (!accessToken) {
-      logForDebugging('[trusted-device] No OAuth token, skipping enrollment')
-      return
-    }
-    // Always re-enroll on /login — the existing token may belong to a
-    // different account (account-switch without /logout). Skipping enrollment
-    // would send the old account's token on the new account's bridge calls.
-    const secureStorage = getSecureStorage()
-
-    if (isEssentialTrafficOnly()) {
-      logForDebugging(
-        '[trusted-device] Essential traffic only, skipping enrollment',
-      )
-      return
-    }
-
-    const baseUrl = getOauthConfig().BASE_API_URL
-    let response
-    try {
-      response = await axios.post<{
-        device_token?: string
-        device_id?: string
-      }>(
-        `${baseUrl}/api/auth/trusted_devices`,
-        { display_name: `Claude Code on ${hostname()} · ${process.platform}` },
-        {
-          headers: {
-            Authorization: `Bearer ${accessToken}`,
-            'Content-Type': 'application/json',
-          },
-          timeout: 10_000,
-          validateStatus: s => s < 500,
-        },
-      )
-    } catch (err: unknown) {
-      logForDebugging(
-        `[trusted-device] Enrollment request failed: ${errorMessage(err)}`,
-      )
-      return
-    }
-
-    if (response.status !== 200 && response.status !== 201) {
-      logForDebugging(
-        `[trusted-device] Enrollment failed ${response.status}: ${jsonStringify(response.data).slice(0, 200)}`,
-      )
-      return
-    }
-
-    const token = response.data?.device_token
-    if (!token || typeof token !== 'string') {
-      logForDebugging(
-        '[trusted-device] Enrollment response missing device_token field',
-      )
-      return
-    }
-
-    try {
-      const storageData = secureStorage.read()
-      if (!storageData) {
-        logForDebugging(
-          '[trusted-device] Cannot read storage, skipping token persist',
-        )
-        return
-      }
-      storageData.trustedDeviceToken = token
-      const result = secureStorage.update(storageData)
-      if (!result.success) {
-        logForDebugging(
-          `[trusted-device] Failed to persist token: ${result.warning ?? 'unknown'}`,
-        )
-        return
-      }
-      readStoredToken.cache?.clear?.()
-      logForDebugging(
-        `[trusted-device] Enrolled device_id=${response.data.device_id ?? 'unknown'}`,
-      )
-    } catch (err: unknown) {
-      logForDebugging(
-        `[trusted-device] Storage write failed: ${errorMessage(err)}`,
-      )
-    }
-  } catch (err: unknown) {
-    logForDebugging(`[trusted-device] Enrollment error: ${errorMessage(err)}`)
-  }
+  logForDebugging(
+    '[trusted-device] Enrollment disabled in this build; skipping trusted device registration',
+  )
 }

src/bridge/types.ts

@@ -80,9 +80,6 @@ export type BridgeWorkerType = 'claude_code' | 'claude_code_assistant'
 
 export type BridgeConfig = {
   dir: string
-  machineName: string
-  branch: string
-  gitRepoUrl: string | null
   maxSessions: number
   spawnMode: SpawnMode
   verbose: boolean

src/commands/insights.ts

@@ -1,4 +1,3 @@
-import { execFileSync } from 'child_process'
 import { diffLines } from 'diff'
 import { constants as fsConstants } from 'fs'
 import {
@@ -2674,7 +2673,7 @@ export type InsightsExport = {
 
 /**
  * Build export data from already-computed values.
- * Used by background upload to S3.
+ * Used by the local report writer.
  */
 export function buildExportData(
   data: AggregatedData,
@@ -3069,35 +3068,8 @@ const usageReport: Command = {
       { collectRemote },
     )
 
-    let reportUrl = `file://${htmlPath}`
-    let uploadHint = ''
-
-    if (process.env.USER_TYPE === 'ant') {
-      // Try to upload to S3
-      const timestamp = new Date()
-        .toISOString()
-        .replace(/[-:]/g, '')
-        .replace('T', '_')
-        .slice(0, 15)
-      const username = process.env.SAFEUSER || process.env.USER || 'unknown'
-      const filename = `${username}_insights_${timestamp}.html`
-      const s3Path = `s3://anthropic-serve/atamkin/cc-user-reports/${filename}`
-      const s3Url = `https://s3-frontend.infra.ant.dev/anthropic-serve/atamkin/cc-user-reports/${filename}`
-
-      reportUrl = s3Url
-      try {
-        execFileSync('ff', ['cp', htmlPath, s3Path], {
-          timeout: 60000,
-          stdio: 'pipe', // Suppress output
-        })
-      } catch {
-        // Upload failed - fall back to local file and show upload command
-        reportUrl = `file://${htmlPath}`
-        uploadHint = `\nAutomatic upload failed. Are you on the boron namespace? Try \`use-bo\` and ensure you've run \`sso\`.
-To share, run: ff cp ${htmlPath} ${s3Path}
-Then access at: ${s3Url}`
-      }
-    }
+    const reportUrl = `file://${htmlPath}`
+    const uploadHint = ''
 
     // Build header with stats
     const sessionLabel =

src/components/FeedbackSurvey/submitTranscriptShare.ts

@@ -1,23 +1,9 @@
-import axios from 'axios'
-import { readFile, stat } from 'fs/promises'
 import type { Message } from '../../types/message.js'
-import { checkAndRefreshOAuthTokenIfNeeded } from '../../utils/auth.js'
-import { logForDebugging } from '../../utils/debug.js'
-import { errorMessage } from '../../utils/errors.js'
-import { getAuthHeaders, getUserAgent } from '../../utils/http.js'
-import { normalizeMessagesForAPI } from '../../utils/messages.js'
-import {
-  extractAgentIdsFromMessages,
-  getTranscriptPath,
-  loadSubagentTranscripts,
-  MAX_TRANSCRIPT_READ_BYTES,
-} from '../../utils/sessionStorage.js'
-import { jsonStringify } from '../../utils/slowOperations.js'
-import { redactSensitiveInfo } from '../Feedback.js'
 
 type TranscriptShareResult = {
   success: boolean
   transcriptId?: string
+  disabled?: boolean
 }
 
 export type TranscriptShareTrigger =
@@ -27,86 +13,12 @@ export type TranscriptShareTrigger =
   | 'memory_survey'
 
 export async function submitTranscriptShare(
-  messages: Message[],
-  trigger: TranscriptShareTrigger,
-  appearanceId: string,
+  _messages: Message[],
+  _trigger: TranscriptShareTrigger,
+  _appearanceId: string,
 ): Promise<TranscriptShareResult> {
-  try {
-    logForDebugging('Collecting transcript for sharing', { level: 'info' })
-
-    const transcript = normalizeMessagesForAPI(messages)
-
-    // Collect subagent transcripts
-    const agentIds = extractAgentIdsFromMessages(messages)
-    const subagentTranscripts = await loadSubagentTranscripts(agentIds)
-
-    // Read raw JSONL transcript (with size guard to prevent OOM)
-    let rawTranscriptJsonl: string | undefined
-    try {
-      const transcriptPath = getTranscriptPath()
-      const { size } = await stat(transcriptPath)
-      if (size <= MAX_TRANSCRIPT_READ_BYTES) {
-        rawTranscriptJsonl = await readFile(transcriptPath, 'utf-8')
-      } else {
-        logForDebugging(
-          `Skipping raw transcript read: file too large (${size} bytes)`,
-          { level: 'warn' },
-        )
-      }
-    } catch {
-      // File may not exist
-    }
-
-    const data = {
-      trigger,
-      version: MACRO.VERSION,
-      platform: process.platform,
-      transcript,
-      subagentTranscripts:
-        Object.keys(subagentTranscripts).length > 0
-          ? subagentTranscripts
-          : undefined,
-      rawTranscriptJsonl,
-    }
-
-    const content = redactSensitiveInfo(jsonStringify(data))
-
-    await checkAndRefreshOAuthTokenIfNeeded()
-
-    const authResult = getAuthHeaders()
-    if (authResult.error) {
-      return { success: false }
-    }
-
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-      'User-Agent': getUserAgent(),
-      ...authResult.headers,
-    }
-
-    const response = await axios.post(
-      'https://api.anthropic.com/api/claude_code_shared_session_transcripts',
-      { content, appearance_id: appearanceId },
-      {
-        headers,
-        timeout: 30000,
-      },
-    )
-
-    if (response.status === 200 || response.status === 201) {
-      const result = response.data
-      logForDebugging('Transcript shared successfully', { level: 'info' })
-      return {
-        success: true,
-        transcriptId: result?.transcript_id,
-      }
-    }
-
-    return { success: false }
-  } catch (err) {
-    logForDebugging(errorMessage(err), {
-      level: 'error',
-    })
-    return { success: false }
+  return {
+    success: false,
+    disabled: true,
   }
 }

src/constants/prompts.ts

@@ -448,9 +448,7 @@ export async function getSystemPrompt(
   mcpClients?: MCPServerConnection[],
 ): Promise<string[]> {
   if (isEnvTruthy(process.env.CLAUDE_CODE_SIMPLE)) {
-    return [
-      `You are Claude Code, Anthropic's official CLI for Claude.\n\nCWD: ${getCwd()}\nDate: ${getSessionStartDate()}`,
-    ]
+    return [`You are Claude Code, Anthropic's official CLI for Claude.`]
   }
 
   const cwd = getCwd()
@@ -607,8 +605,6 @@ export async function computeEnvInfo(
   modelId: string,
   additionalWorkingDirectories?: string[],
 ): Promise<string> {
-  const [isGit, unameSR] = await Promise.all([getIsGit(), getUnameSR()])
-
   // Undercover: keep ALL model names/IDs out of the system prompt so nothing
   // internal can leak into public commits/PRs. This includes the public
   // FRONTIER_MODEL_* constants — if those ever point at an unannounced model,
@@ -627,33 +623,20 @@ export async function computeEnvInfo(
       : `You are powered by the model ${modelId}.`
   }
 
-  const additionalDirsInfo =
-    additionalWorkingDirectories && additionalWorkingDirectories.length > 0
-      ? `Additional working directories: ${additionalWorkingDirectories.join(', ')}\n`
-      : ''
-
   const cutoff = getKnowledgeCutoff(modelId)
   const knowledgeCutoffMessage = cutoff
     ? `\n\nAssistant knowledge cutoff is ${cutoff}.`
     : ''
 
-  return `Here is useful information about the environment you are running in:
-<env>
-Working directory: ${getCwd()}
-Is directory a git repo: ${isGit ? 'Yes' : 'No'}
-${additionalDirsInfo}Platform: ${env.platform}
-${getShellInfoLine()}
-OS Version: ${unameSR}
-</env>
-${modelDescription}${knowledgeCutoffMessage}`
+  return [`# Environment`, `You are Claude Code.`, modelDescription, knowledgeCutoffMessage]
+    .filter(Boolean)
+    .join('\n')
 }
 
 export async function computeSimpleEnvInfo(
   modelId: string,
   additionalWorkingDirectories?: string[],
 ): Promise<string> {
-  const [isGit, unameSR] = await Promise.all([getIsGit(), getUnameSR()])
-
   // Undercover: strip all model name/ID references. See computeEnvInfo.
   // DCE: inline the USER_TYPE check at each site — do NOT hoist to a const.
   let modelDescription: string | null = null
@@ -671,42 +654,14 @@ export async function computeSimpleEnvInfo(
     ? `Assistant knowledge cutoff is ${cutoff}.`
     : null
 
-  const cwd = getCwd()
-  const isWorktree = getCurrentWorktreeSession() !== null
-
-  const envItems = [
-    `Primary working directory: ${cwd}`,
-    isWorktree
-      ? `This is a git worktree — an isolated copy of the repository. Run all commands from this directory. Do NOT \`cd\` to the original repository root.`
-      : null,
-    [`Is a git repository: ${isGit}`],
-    additionalWorkingDirectories && additionalWorkingDirectories.length > 0
-      ? `Additional working directories:`
-      : null,
-    additionalWorkingDirectories && additionalWorkingDirectories.length > 0
-      ? additionalWorkingDirectories
-      : null,
-    `Platform: ${env.platform}`,
-    getShellInfoLine(),
-    `OS Version: ${unameSR}`,
-    modelDescription,
-    knowledgeCutoffMessage,
-    process.env.USER_TYPE === 'ant' && isUndercover()
-      ? null
-      : `The most recent Claude model family is Claude 4.5/4.6. Model IDs — Opus 4.6: '${CLAUDE_4_5_OR_4_6_MODEL_IDS.opus}', Sonnet 4.6: '${CLAUDE_4_5_OR_4_6_MODEL_IDS.sonnet}', Haiku 4.5: '${CLAUDE_4_5_OR_4_6_MODEL_IDS.haiku}'. When building AI applications, default to the latest and most capable Claude models.`,
-    process.env.USER_TYPE === 'ant' && isUndercover()
-      ? null
-      : `Claude Code is available as a CLI in the terminal, desktop app (Mac/Windows), web app (claude.ai/code), and IDE extensions (VS Code, JetBrains).`,
-    process.env.USER_TYPE === 'ant' && isUndercover()
-      ? null
-      : `Fast mode for Claude Code uses the same ${FRONTIER_MODEL_NAME} model with faster output. It does NOT switch to a different model. It can be toggled with /fast.`,
-  ].filter(item => item !== null)
-
   return [
     `# Environment`,
-    `You have been invoked in the following environment: `,
-    ...prependBullets(envItems),
-  ].join(`\n`)
+    `You are Claude Code.`,
+    modelDescription,
+    knowledgeCutoffMessage,
+  ]
+    .filter(Boolean)
+    .join(`\n`)
 }
 
 // @[MODEL LAUNCH]: Add a knowledge cutoff date for the new model.

src/context.ts

@@ -1,25 +1,7 @@
-import { feature } from 'bun:bundle'
 import memoize from 'lodash-es/memoize.js'
-import {
-  getAdditionalDirectoriesForClaudeMd,
-  setCachedClaudeMdContent,
-} from './bootstrap/state.js'
-import { getLocalISODate } from './constants/common.js'
-import {
-  filterInjectedMemoryFiles,
-  getClaudeMds,
-  getMemoryFiles,
-} from './utils/claudemd.js'
-import { logForDiagnosticsNoPII } from './utils/diagLogs.js'
-import { isBareMode, isEnvTruthy } from './utils/envUtils.js'
-import { execFileNoThrow } from './utils/execFileNoThrow.js'
-import { getBranch, getDefaultBranch, getIsGit, gitExe } from './utils/git.js'
-import { shouldIncludeGitInstructions } from './utils/gitSettings.js'
-import { logError } from './utils/log.js'
+import { setCachedClaudeMdContent } from './bootstrap/state.js'
 
-const MAX_STATUS_CHARS = 2000
-
-// System prompt injection for cache breaking (ant-only, ephemeral debugging state)
+// System prompt injection remains a local cache-busting hook only.
 let systemPromptInjection: string | null = null
 
 export function getSystemPromptInjection(): string | null {
@@ -28,162 +10,17 @@ export function getSystemPromptInjection(): string | null {
 
 export function setSystemPromptInjection(value: string | null): void {
   systemPromptInjection = value
-  // Clear context caches immediately when injection changes
   getUserContext.cache.clear?.()
   getSystemContext.cache.clear?.()
 }
 
-export const getGitStatus = memoize(async (): Promise<string | null> => {
-  if (process.env.NODE_ENV === 'test') {
-    // Avoid cycles in tests
-    return null
-  }
+export const getGitStatus = memoize(async (): Promise<string | null> => null)
 
-  const startTime = Date.now()
-  logForDiagnosticsNoPII('info', 'git_status_started')
-
-  const isGitStart = Date.now()
-  const isGit = await getIsGit()
-  logForDiagnosticsNoPII('info', 'git_is_git_check_completed', {
-    duration_ms: Date.now() - isGitStart,
-    is_git: isGit,
-  })
-
-  if (!isGit) {
-    logForDiagnosticsNoPII('info', 'git_status_skipped_not_git', {
-      duration_ms: Date.now() - startTime,
-    })
-    return null
-  }
-
-  try {
-    const gitCmdsStart = Date.now()
-    const [branch, mainBranch, status, log, userName] = await Promise.all([
-      getBranch(),
-      getDefaultBranch(),
-      execFileNoThrow(gitExe(), ['--no-optional-locks', 'status', '--short'], {
-        preserveOutputOnError: false,
-      }).then(({ stdout }) => stdout.trim()),
-      execFileNoThrow(
-        gitExe(),
-        ['--no-optional-locks', 'log', '--oneline', '-n', '5'],
-        {
-          preserveOutputOnError: false,
-        },
-      ).then(({ stdout }) => stdout.trim()),
-      execFileNoThrow(gitExe(), ['config', 'user.name'], {
-        preserveOutputOnError: false,
-      }).then(({ stdout }) => stdout.trim()),
-    ])
-
-    logForDiagnosticsNoPII('info', 'git_commands_completed', {
-      duration_ms: Date.now() - gitCmdsStart,
-      status_length: status.length,
-    })
-
-    // Check if status exceeds character limit
-    const truncatedStatus =
-      status.length > MAX_STATUS_CHARS
-        ? status.substring(0, MAX_STATUS_CHARS) +
-          '\n... (truncated because it exceeds 2k characters. If you need more information, run "git status" using BashTool)'
-        : status
-
-    logForDiagnosticsNoPII('info', 'git_status_completed', {
-      duration_ms: Date.now() - startTime,
-      truncated: status.length > MAX_STATUS_CHARS,
-    })
-
-    return [
-      `This is the git status at the start of the conversation. Note that this status is a snapshot in time, and will not update during the conversation.`,
-      `Current branch: ${branch}`,
-      `Main branch (you will usually use this for PRs): ${mainBranch}`,
-      ...(userName ? [`Git user: ${userName}`] : []),
-      `Status:\n${truncatedStatus || '(clean)'}`,
-      `Recent commits:\n${log}`,
-    ].join('\n\n')
-  } catch (error) {
-    logForDiagnosticsNoPII('error', 'git_status_failed', {
-      duration_ms: Date.now() - startTime,
-    })
-    logError(error)
-    return null
-  }
-})
-
-/**
- * This context is prepended to each conversation, and cached for the duration of the conversation.
- */
 export const getSystemContext = memoize(
-  async (): Promise<{
-    [k: string]: string
-  }> => {
-    const startTime = Date.now()
-    logForDiagnosticsNoPII('info', 'system_context_started')
-
-    // Skip git status in CCR (unnecessary overhead on resume) or when git instructions are disabled
-    const gitStatus =
-      isEnvTruthy(process.env.CLAUDE_CODE_REMOTE) ||
-      !shouldIncludeGitInstructions()
-        ? null
-        : await getGitStatus()
-
-    // Include system prompt injection if set (for cache breaking, ant-only)
-    const injection = feature('BREAK_CACHE_COMMAND')
-      ? getSystemPromptInjection()
-      : null
-
-    logForDiagnosticsNoPII('info', 'system_context_completed', {
-      duration_ms: Date.now() - startTime,
-      has_git_status: gitStatus !== null,
-      has_injection: injection !== null,
-    })
-
-    return {
-      ...(gitStatus && { gitStatus }),
-      ...(feature('BREAK_CACHE_COMMAND') && injection
-        ? {
-            cacheBreaker: `[CACHE_BREAKER: ${injection}]`,
-          }
-        : {}),
-    }
-  },
+  async (): Promise<Record<string, string>> => ({}),
 )
 
-/**
- * This context is prepended to each conversation, and cached for the duration of the conversation.
- */
-export const getUserContext = memoize(
-  async (): Promise<{
-    [k: string]: string
-  }> => {
-    const startTime = Date.now()
-    logForDiagnosticsNoPII('info', 'user_context_started')
-
-    // CLAUDE_CODE_DISABLE_CLAUDE_MDS: hard off, always.
-    // --bare: skip auto-discovery (cwd walk), BUT honor explicit --add-dir.
-    // --bare means "skip what I didn't ask for", not "ignore what I asked for".
-    const shouldDisableClaudeMd =
-      isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_CLAUDE_MDS) ||
-      (isBareMode() && getAdditionalDirectoriesForClaudeMd().length === 0)
-    // Await the async I/O (readFile/readdir directory walk) so the event
-    // loop yields naturally at the first fs.readFile.
-    const claudeMd = shouldDisableClaudeMd
-      ? null
-      : getClaudeMds(filterInjectedMemoryFiles(await getMemoryFiles()))
-    // Cache for the auto-mode classifier (yoloClassifier.ts reads this
-    // instead of importing claudemd.ts directly, which would create a
-    // cycle through permissions/filesystem → permissions → yoloClassifier).
-    setCachedClaudeMdContent(claudeMd || null)
-
-    logForDiagnosticsNoPII('info', 'user_context_completed', {
-      duration_ms: Date.now() - startTime,
-      claudemd_length: claudeMd?.length ?? 0,
-      claudemd_disabled: Boolean(shouldDisableClaudeMd),
-    })
-
-    return {
-      ...(claudeMd && { claudeMd }),
-      currentDate: `Today's date is ${getLocalISODate()}.`,
-    }
-  },
-)
+export const getUserContext = memoize(async (): Promise<Record<string, string>> => {
+  setCachedClaudeMdContent(null)
+  return {}
+})

src/entrypoints/init.ts

@@ -87,22 +87,8 @@ export const init = memoize(async (): Promise<void> => {
     setupGracefulShutdown()
     profileCheckpoint('init_after_graceful_shutdown')
 
-    // Initialize 1P event logging (no security concerns, but deferred to avoid
-    // loading OpenTelemetry sdk-logs at startup). growthbook.js is already in
-    // the module cache by this point (firstPartyEventLogger imports it), so the
-    // second dynamic import adds no load cost.
-    void Promise.all([
-      import('../services/analytics/firstPartyEventLogger.js'),
-      import('../services/analytics/growthbook.js'),
-    ]).then(([fp, gb]) => {
-      fp.initialize1PEventLogging()
-      // Rebuild the logger provider if tengu_1p_event_batch_config changes
-      // mid-session. Change detection (isEqual) is inside the handler so
-      // unchanged refreshes are no-ops.
-      gb.onGrowthBookRefresh(() => {
-        void fp.reinitialize1PEventLoggingIfConfigChanged()
-      })
-    })
+    // Telemetry/log export is disabled in this build. Keep the startup
+    // checkpoint so callers depending on the init timeline still see it.
     profileCheckpoint('init_after_1p_event_logging')
 
     // Populate OAuth account info if it is not already cached in config. This is needed since the
@@ -245,96 +231,14 @@ export const init = memoize(async (): Promise<void> => {
  * This should only be called once, after the trust dialog has been accepted.
  */
 export function initializeTelemetryAfterTrust(): void {
-  if (isEligibleForRemoteManagedSettings()) {
-    // For SDK/headless mode with beta tracing, initialize eagerly first
-    // to ensure the tracer is ready before the first query runs.
-    // The async path below will still run but doInitializeTelemetry() guards against double init.
-    if (getIsNonInteractiveSession() && isBetaTracingEnabled()) {
-      void doInitializeTelemetry().catch(error => {
-        logForDebugging(
-          `[3P telemetry] Eager telemetry init failed (beta tracing): ${errorMessage(error)}`,
-          { level: 'error' },
-        )
-      })
-    }
-    logForDebugging(
-      '[3P telemetry] Waiting for remote managed settings before telemetry init',
-    )
-    void waitForRemoteManagedSettingsToLoad()
-      .then(async () => {
-        logForDebugging(
-          '[3P telemetry] Remote managed settings loaded, initializing telemetry',
-        )
-        // Re-apply env vars to pick up remote settings before initializing telemetry.
-        applyConfigEnvironmentVariables()
-        await doInitializeTelemetry()
-      })
-      .catch(error => {
-        logForDebugging(
-          `[3P telemetry] Telemetry init failed (remote settings path): ${errorMessage(error)}`,
-          { level: 'error' },
-        )
-      })
-  } else {
-    void doInitializeTelemetry().catch(error => {
-      logForDebugging(
-        `[3P telemetry] Telemetry init failed: ${errorMessage(error)}`,
-        { level: 'error' },
-      )
-    })
-  }
+  return
 }
 
 async function doInitializeTelemetry(): Promise<void> {
-  if (telemetryInitialized) {
-    // Already initialized, nothing to do
-    return
-  }
-
-  // Set flag before init to prevent double initialization
-  telemetryInitialized = true
-  try {
-    await setMeterState()
-  } catch (error) {
-    // Reset flag on failure so subsequent calls can retry
-    telemetryInitialized = false
-    throw error
-  }
+  void telemetryInitialized
+  return
 }
 
 async function setMeterState(): Promise<void> {
-  // Lazy-load instrumentation to defer ~400KB of OpenTelemetry + protobuf
-  const { initializeTelemetry } = await import(
-    '../utils/telemetry/instrumentation.js'
-  )
-  // Initialize customer OTLP telemetry (metrics, logs, traces)
-  const meter = await initializeTelemetry()
-  if (meter) {
-    // Create factory function for attributed counters
-    const createAttributedCounter = (
-      name: string,
-      options: MetricOptions,
-    ): AttributedCounter => {
-      const counter = meter?.createCounter(name, options)
-
-      return {
-        add(value: number, additionalAttributes: Attributes = {}) {
-          // Always fetch fresh telemetry attributes to ensure they're up to date
-          const currentAttributes = getTelemetryAttributes()
-          const mergedAttributes = {
-            ...currentAttributes,
-            ...additionalAttributes,
-          }
-          counter?.add(value, mergedAttributes)
-        },
-      }
-    }
-
-    setMeter(meter, createAttributedCounter)
-
-    // Increment session counter here because the startup telemetry path
-    // runs before this async initialization completes, so the counter
-    // would be null there.
-    getSessionCounter()?.add(1)
-  }
+  return
 }

src/query.ts

@@ -55,7 +55,6 @@ import {
   stripSignatureBlocks,
 } from './utils/messages.js'
 import { generateToolUseSummary } from './services/toolUseSummary/toolUseSummaryGenerator.js'
-import { prependUserContext, appendSystemContext } from './utils/api.js'
 import {
   createAttachmentMessage,
   filterDuplicateMemoryAttachments,
@@ -446,9 +445,7 @@ async function* queryLoop(
       messagesForQuery = collapseResult.messages
     }
 
-    const fullSystemPrompt = asSystemPrompt(
-      appendSystemContext(systemPrompt, systemContext),
-    )
+    const fullSystemPrompt = asSystemPrompt(systemPrompt)
 
     queryCheckpoint('query_autocompact_start')
     const { compactionResult, consecutiveFailures } = await deps.autocompact(
@@ -657,7 +654,7 @@ async function* queryLoop(
           let streamingFallbackOccured = false
           queryCheckpoint('query_api_streaming_start')
           for await (const message of deps.callModel({
-            messages: prependUserContext(messagesForQuery, userContext),
+            messages: messagesForQuery,
             systemPrompt: fullSystemPrompt,
             thinkingConfig: toolUseContext.options.thinkingConfig,
             tools: toolUseContext.options.tools,

src/services/analytics/datadog.ts

@@ -1,307 +1,20 @@
-import axios from 'axios'
-import { createHash } from 'crypto'
-import memoize from 'lodash-es/memoize.js'
-import { getOrCreateUserID } from '../../utils/config.js'
-import { logError } from '../../utils/log.js'
-import { getCanonicalName } from '../../utils/model/model.js'
-import { getAPIProvider } from '../../utils/model/providers.js'
-import { MODEL_COSTS } from '../../utils/modelCost.js'
-import { isAnalyticsDisabled } from './config.js'
-import { getEventMetadata } from './metadata.js'
-
-const DATADOG_LOGS_ENDPOINT =
-  'https://http-intake.logs.us5.datadoghq.com/api/v2/logs'
-const DATADOG_CLIENT_TOKEN = 'pubbbf48e6d78dae54bceaa4acf463299bf'
-const DEFAULT_FLUSH_INTERVAL_MS = 15000
-const MAX_BATCH_SIZE = 100
-const NETWORK_TIMEOUT_MS = 5000
-
-const DATADOG_ALLOWED_EVENTS = new Set([
-  'chrome_bridge_connection_succeeded',
-  'chrome_bridge_connection_failed',
-  'chrome_bridge_disconnected',
-  'chrome_bridge_tool_call_completed',
-  'chrome_bridge_tool_call_error',
-  'chrome_bridge_tool_call_started',
-  'chrome_bridge_tool_call_timeout',
-  'tengu_api_error',
-  'tengu_api_success',
-  'tengu_brief_mode_enabled',
-  'tengu_brief_mode_toggled',
-  'tengu_brief_send',
-  'tengu_cancel',
-  'tengu_compact_failed',
-  'tengu_exit',
-  'tengu_flicker',
-  'tengu_init',
-  'tengu_model_fallback_triggered',
-  'tengu_oauth_error',
-  'tengu_oauth_success',
-  'tengu_oauth_token_refresh_failure',
-  'tengu_oauth_token_refresh_success',
-  'tengu_oauth_token_refresh_lock_acquiring',
-  'tengu_oauth_token_refresh_lock_acquired',
-  'tengu_oauth_token_refresh_starting',
-  'tengu_oauth_token_refresh_completed',
-  'tengu_oauth_token_refresh_lock_releasing',
-  'tengu_oauth_token_refresh_lock_released',
-  'tengu_query_error',
-  'tengu_session_file_read',
-  'tengu_started',
-  'tengu_tool_use_error',
-  'tengu_tool_use_granted_in_prompt_permanent',
-  'tengu_tool_use_granted_in_prompt_temporary',
-  'tengu_tool_use_rejected_in_prompt',
-  'tengu_tool_use_success',
-  'tengu_uncaught_exception',
-  'tengu_unhandled_rejection',
-  'tengu_voice_recording_started',
-  'tengu_voice_toggled',
-  'tengu_team_mem_sync_pull',
-  'tengu_team_mem_sync_push',
-  'tengu_team_mem_sync_started',
-  'tengu_team_mem_entries_capped',
-])
-
-const TAG_FIELDS = [
-  'arch',
-  'clientType',
-  'errorType',
-  'http_status_range',
-  'http_status',
-  'kairosActive',
-  'model',
-  'platform',
-  'provider',
-  'skillMode',
-  'subscriptionType',
-  'toolName',
-  'userBucket',
-  'userType',
-  'version',
-  'versionBase',
-]
-
-function camelToSnakeCase(str: string): string {
-  return str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`)
-}
-
-type DatadogLog = {
-  ddsource: string
-  ddtags: string
-  message: string
-  service: string
-  hostname: string
-  [key: string]: unknown
-}
-
-let logBatch: DatadogLog[] = []
-let flushTimer: NodeJS.Timeout | null = null
-let datadogInitialized: boolean | null = null
-
-async function flushLogs(): Promise<void> {
-  if (logBatch.length === 0) return
-
-  const logsToSend = logBatch
-  logBatch = []
-
-  try {
-    await axios.post(DATADOG_LOGS_ENDPOINT, logsToSend, {
-      headers: {
-        'Content-Type': 'application/json',
-        'DD-API-KEY': DATADOG_CLIENT_TOKEN,
-      },
-      timeout: NETWORK_TIMEOUT_MS,
-    })
-  } catch (error) {
-    logError(error)
-  }
-}
-
-function scheduleFlush(): void {
-  if (flushTimer) return
-
-  flushTimer = setTimeout(() => {
-    flushTimer = null
-    void flushLogs()
-  }, getFlushIntervalMs()).unref()
-}
-
-export const initializeDatadog = memoize(async (): Promise<boolean> => {
-  if (isAnalyticsDisabled()) {
-    datadogInitialized = false
-    return false
-  }
-
-  try {
-    datadogInitialized = true
-    return true
-  } catch (error) {
-    logError(error)
-    datadogInitialized = false
-    return false
-  }
-})
-
 /**
- * Flush remaining Datadog logs and shut down.
- * Called from gracefulShutdown() before process.exit() since
- * forceExit() prevents the beforeExit handler from firing.
+ * Datadog analytics egress is disabled in this build.
+ *
+ * The exported functions remain so existing call sites do not need to branch.
  */
+
+export async function initializeDatadog(): Promise<boolean> {
+  return false
+}
+
 export async function shutdownDatadog(): Promise<void> {
-  if (flushTimer) {
-    clearTimeout(flushTimer)
-    flushTimer = null
-  }
-  await flushLogs()
+  return
 }
 
-// NOTE: use via src/services/analytics/index.ts > logEvent
 export async function trackDatadogEvent(
-  eventName: string,
-  properties: { [key: string]: boolean | number | undefined },
+  _eventName: string,
+  _properties: { [key: string]: boolean | number | undefined },
 ): Promise<void> {
-  if (process.env.NODE_ENV !== 'production') {
-    return
-  }
-
-  // Don't send events for 3P providers (Bedrock, Vertex, Foundry)
-  if (getAPIProvider() !== 'firstParty') {
-    return
-  }
-
-  // Fast path: use cached result if available to avoid await overhead
-  let initialized = datadogInitialized
-  if (initialized === null) {
-    initialized = await initializeDatadog()
-  }
-  if (!initialized || !DATADOG_ALLOWED_EVENTS.has(eventName)) {
-    return
-  }
-
-  try {
-    const metadata = await getEventMetadata({
-      model: properties.model,
-      betas: properties.betas,
-    })
-    // Destructure to avoid duplicate envContext (once nested, once flattened)
-    const { envContext, ...restMetadata } = metadata
-    const allData: Record<string, unknown> = {
-      ...restMetadata,
-      ...envContext,
-      ...properties,
-      userBucket: getUserBucket(),
-    }
-
-    // Normalize MCP tool names to "mcp" for cardinality reduction
-    if (
-      typeof allData.toolName === 'string' &&
-      allData.toolName.startsWith('mcp__')
-    ) {
-      allData.toolName = 'mcp'
-    }
-
-    // Normalize model names for cardinality reduction (external users only)
-    if (process.env.USER_TYPE !== 'ant' && typeof allData.model === 'string') {
-      const shortName = getCanonicalName(allData.model.replace(/\[1m]$/i, ''))
-      allData.model = shortName in MODEL_COSTS ? shortName : 'other'
-    }
-
-    // Truncate dev version to base + date (remove timestamp and sha for cardinality reduction)
-    // e.g. "2.0.53-dev.20251124.t173302.sha526cc6a" -> "2.0.53-dev.20251124"
-    if (typeof allData.version === 'string') {
-      allData.version = allData.version.replace(
-        /^(\d+\.\d+\.\d+-dev\.\d{8})\.t\d+\.sha[a-f0-9]+$/,
-        '$1',
-      )
-    }
-
-    // Transform status to http_status and http_status_range to avoid Datadog reserved field
-    if (allData.status !== undefined && allData.status !== null) {
-      const statusCode = String(allData.status)
-      allData.http_status = statusCode
-
-      // Determine status range (1xx, 2xx, 3xx, 4xx, 5xx)
-      const firstDigit = statusCode.charAt(0)
-      if (firstDigit >= '1' && firstDigit <= '5') {
-        allData.http_status_range = `${firstDigit}xx`
-      }
-
-      // Remove original status field to avoid conflict with Datadog's reserved field
-      delete allData.status
-    }
-
-    // Build ddtags with high-cardinality fields for filtering.
-    // event:<name> is prepended so the event name is searchable via the
-    // log search API — the `message` field (where eventName also lives)
-    // is a DD reserved field and is NOT queryable from dashboard widget
-    // queries or the aggregation API. See scripts/release/MONITORING.md.
-    const allDataRecord = allData
-    const tags = [
-      `event:${eventName}`,
-      ...TAG_FIELDS.filter(
-        field =>
-          allDataRecord[field] !== undefined && allDataRecord[field] !== null,
-      ).map(field => `${camelToSnakeCase(field)}:${allDataRecord[field]}`),
-    ]
-
-    const log: DatadogLog = {
-      ddsource: 'nodejs',
-      ddtags: tags.join(','),
-      message: eventName,
-      service: 'claude-code',
-      hostname: 'claude-code',
-      env: process.env.USER_TYPE,
-    }
-
-    // Add all fields as searchable attributes (not duplicated in tags)
-    for (const [key, value] of Object.entries(allData)) {
-      if (value !== undefined && value !== null) {
-        log[camelToSnakeCase(key)] = value
-      }
-    }
-
-    logBatch.push(log)
-
-    // Flush immediately if batch is full, otherwise schedule
-    if (logBatch.length >= MAX_BATCH_SIZE) {
-      if (flushTimer) {
-        clearTimeout(flushTimer)
-        flushTimer = null
-      }
-      void flushLogs()
-    } else {
-      scheduleFlush()
-    }
-  } catch (error) {
-    logError(error)
-  }
-}
-
-const NUM_USER_BUCKETS = 30
-
-/**
- * Gets a 'bucket' that the user ID falls into.
- *
- * For alerting purposes, we want to alert on the number of users impacted
- * by an issue, rather than the number of events- often a small number of users
- * can generate a large number of events (e.g. due to retries). To approximate
- * this without ruining cardinality by counting user IDs directly, we hash the user ID
- * and assign it to one of a fixed number of buckets.
- *
- * This allows us to estimate the number of unique users by counting unique buckets,
- * while preserving user privacy and reducing cardinality.
- */
-const getUserBucket = memoize((): number => {
-  const userId = getOrCreateUserID()
-  const hash = createHash('sha256').update(userId).digest('hex')
-  return parseInt(hash.slice(0, 8), 16) % NUM_USER_BUCKETS
-})
-
-function getFlushIntervalMs(): number {
-  // Allow tests to override to not block on the default flush interval.
-  return (
-    parseInt(process.env.CLAUDE_CODE_DATADOG_FLUSH_INTERVAL_MS || '', 10) ||
-    DEFAULT_FLUSH_INTERVAL_MS
-  )
+  return
 }

src/services/analytics/firstPartyEventLogger.ts

@@ -1,237 +1,41 @@
-import type { AnyValueMap, Logger, logs } from '@opentelemetry/api-logs'
-import { resourceFromAttributes } from '@opentelemetry/resources'
-import {
-  BatchLogRecordProcessor,
-  LoggerProvider,
-} from '@opentelemetry/sdk-logs'
-import {
-  ATTR_SERVICE_NAME,
-  ATTR_SERVICE_VERSION,
-} from '@opentelemetry/semantic-conventions'
-import { randomUUID } from 'crypto'
-import { isEqual } from 'lodash-es'
-import { getOrCreateUserID } from '../../utils/config.js'
-import { logForDebugging } from '../../utils/debug.js'
-import { logError } from '../../utils/log.js'
-import { getPlatform, getWslVersion } from '../../utils/platform.js'
-import { jsonStringify } from '../../utils/slowOperations.js'
-import { profileCheckpoint } from '../../utils/startupProfiler.js'
-import { getCoreUserData } from '../../utils/user.js'
-import { isAnalyticsDisabled } from './config.js'
-import { FirstPartyEventLoggingExporter } from './firstPartyEventLoggingExporter.js'
-import type { GrowthBookUserAttributes } from './growthbook.js'
-import { getDynamicConfig_CACHED_MAY_BE_STALE } from './growthbook.js'
-import { getEventMetadata } from './metadata.js'
-import { isSinkKilled } from './sinkKillswitch.js'
-
 /**
- * Configuration for sampling individual event types.
- * Each event name maps to an object containing sample_rate (0-1).
- * Events not in the config are logged at 100% rate.
+ * Anthropic 1P event logging egress is disabled in this build.
+ *
+ * The module keeps its public API so the rest of the app can call into it
+ * without conditional imports.
  */
+
+import type { GrowthBookUserAttributes } from './growthbook.js'
+
 export type EventSamplingConfig = {
   [eventName: string]: {
     sample_rate: number
   }
 }
 
-const EVENT_SAMPLING_CONFIG_NAME = 'tengu_event_sampling_config'
-/**
- * Get the event sampling configuration from GrowthBook.
- * Uses cached value if available, updates cache in background.
- */
 export function getEventSamplingConfig(): EventSamplingConfig {
-  return getDynamicConfig_CACHED_MAY_BE_STALE<EventSamplingConfig>(
-    EVENT_SAMPLING_CONFIG_NAME,
-    {},
-  )
+  return {}
 }
 
-/**
- * Determine if an event should be sampled based on its sample rate.
- * Returns the sample rate if sampled, null if not sampled.
- *
- * @param eventName - Name of the event to check
- * @returns The sample_rate if event should be logged, null if it should be dropped
- */
-export function shouldSampleEvent(eventName: string): number | null {
-  const config = getEventSamplingConfig()
-  const eventConfig = config[eventName]
-
-  // If no config for this event, log at 100% rate (no sampling)
-  if (!eventConfig) {
-    return null
-  }
-
-  const sampleRate = eventConfig.sample_rate
-
-  // Validate sample rate is in valid range
-  if (typeof sampleRate !== 'number' || sampleRate < 0 || sampleRate > 1) {
-    return null
-  }
-
-  // Sample rate of 1 means log everything (no need to add metadata)
-  if (sampleRate >= 1) {
-    return null
-  }
-
-  // Sample rate of 0 means drop everything
-  if (sampleRate <= 0) {
-    return 0
-  }
-
-  // Randomly decide whether to sample this event
-  return Math.random() < sampleRate ? sampleRate : 0
+export function shouldSampleEvent(_eventName: string): number | null {
+  return null
 }
 
-const BATCH_CONFIG_NAME = 'tengu_1p_event_batch_config'
-type BatchConfig = {
-  scheduledDelayMillis?: number
-  maxExportBatchSize?: number
-  maxQueueSize?: number
-  skipAuth?: boolean
-  maxAttempts?: number
-  path?: string
-  baseUrl?: string
-}
-function getBatchConfig(): BatchConfig {
-  return getDynamicConfig_CACHED_MAY_BE_STALE<BatchConfig>(
-    BATCH_CONFIG_NAME,
-    {},
-  )
-}
-
-// Module-local state for event logging (not exposed globally)
-let firstPartyEventLogger: ReturnType<typeof logs.getLogger> | null = null
-let firstPartyEventLoggerProvider: LoggerProvider | null = null
-// Last batch config used to construct the provider — used by
-// reinitialize1PEventLoggingIfConfigChanged to decide whether a rebuild is
-// needed when GrowthBook refreshes.
-let lastBatchConfig: BatchConfig | null = null
-/**
- * Flush and shutdown the 1P event logger.
- * This should be called as the final step before process exit to ensure
- * all events (including late ones from API responses) are exported.
- */
 export async function shutdown1PEventLogging(): Promise<void> {
-  if (!firstPartyEventLoggerProvider) {
-    return
-  }
-  try {
-    await firstPartyEventLoggerProvider.shutdown()
-    if (process.env.USER_TYPE === 'ant') {
-      logForDebugging('1P event logging: final shutdown complete')
-    }
-  } catch {
-    // Ignore shutdown errors
-  }
+  return
 }
 
-/**
- * Check if 1P event logging is enabled.
- * Respects the same opt-outs as other analytics sinks:
- * - Test environment
- * - Third-party cloud providers (Bedrock/Vertex)
- * - Global telemetry opt-outs
- * - Non-essential traffic disabled
- *
- * Note: Unlike BigQuery metrics, event logging does NOT check organization-level
- * metrics opt-out via API. It follows the same pattern as Statsig event logging.
- */
 export function is1PEventLoggingEnabled(): boolean {
-  // Respect standard analytics opt-outs
-  return !isAnalyticsDisabled()
+  return false
 }
 
-/**
- * Log a 1st-party event for internal analytics (async version).
- * Events are batched and exported to /api/event_logging/batch
- *
- * This enriches the event with core metadata (model, session, env context, etc.)
- * at log time, similar to logEventToStatsig.
- *
- * @param eventName - Name of the event (e.g., 'tengu_api_query')
- * @param metadata - Additional metadata for the event (intentionally no strings, to avoid accidentally logging code/filepaths)
- */
-async function logEventTo1PAsync(
-  firstPartyEventLogger: Logger,
-  eventName: string,
-  metadata: Record<string, number | boolean | undefined> = {},
-): Promise<void> {
-  try {
-    // Enrich with core metadata at log time (similar to Statsig pattern)
-    const coreMetadata = await getEventMetadata({
-      model: metadata.model,
-      betas: metadata.betas,
-    })
-
-    // Build attributes - OTel supports nested objects natively via AnyValueMap
-    // Cast through unknown since our nested objects are structurally compatible
-    // with AnyValue but TS doesn't recognize it due to missing index signatures
-    const attributes = {
-      event_name: eventName,
-      event_id: randomUUID(),
-      // Pass objects directly - no JSON serialization needed
-      core_metadata: coreMetadata,
-      user_metadata: getCoreUserData(true),
-      event_metadata: metadata,
-    } as unknown as AnyValueMap
-
-    // Add user_id if available
-    const userId = getOrCreateUserID()
-    if (userId) {
-      attributes.user_id = userId
-    }
-
-    // Debug logging when debug mode is enabled
-    if (process.env.USER_TYPE === 'ant') {
-      logForDebugging(
-        `[ANT-ONLY] 1P event: ${eventName} ${jsonStringify(metadata, null, 0)}`,
-      )
-    }
-
-    // Emit log record
-    firstPartyEventLogger.emit({
-      body: eventName,
-      attributes,
-    })
-  } catch (e) {
-    if (process.env.NODE_ENV === 'development') {
-      throw e
-    }
-    if (process.env.USER_TYPE === 'ant') {
-      logError(e as Error)
-    }
-    // swallow
-  }
-}
-
-/**
- * Log a 1st-party event for internal analytics.
- * Events are batched and exported to /api/event_logging/batch
- *
- * @param eventName - Name of the event (e.g., 'tengu_api_query')
- * @param metadata - Additional metadata for the event (intentionally no strings, to avoid accidentally logging code/filepaths)
- */
 export function logEventTo1P(
-  eventName: string,
-  metadata: Record<string, number | boolean | undefined> = {},
+  _eventName: string,
+  _metadata: Record<string, number | boolean | undefined> = {},
 ): void {
-  if (!is1PEventLoggingEnabled()) {
-    return
-  }
-
-  if (!firstPartyEventLogger || isSinkKilled('firstParty')) {
-    return
-  }
-
-  // Fire and forget - don't block on metadata enrichment
-  void logEventTo1PAsync(firstPartyEventLogger, eventName, metadata)
+  return
 }
 
-/**
- * GrowthBook experiment event data for logging
- */
 export type GrowthBookExperimentData = {
   experimentId: string
   variationId: number
@@ -239,211 +43,16 @@ export type GrowthBookExperimentData = {
   experimentMetadata?: Record<string, unknown>
 }
 
-// api.anthropic.com only serves the "production" GrowthBook environment
-// (see starling/starling/cli/cli.py DEFAULT_ENVIRONMENTS). Staging and
-// development environments are not exported to the prod API.
-function getEnvironmentForGrowthBook(): string {
-  return 'production'
-}
-
-/**
- * Log a GrowthBook experiment assignment event to 1P.
- * Events are batched and exported to /api/event_logging/batch
- *
- * @param data - GrowthBook experiment assignment data
- */
 export function logGrowthBookExperimentTo1P(
-  data: GrowthBookExperimentData,
+  _data: GrowthBookExperimentData,
 ): void {
-  if (!is1PEventLoggingEnabled()) {
-    return
-  }
-
-  if (!firstPartyEventLogger || isSinkKilled('firstParty')) {
-    return
-  }
-
-  const userId = getOrCreateUserID()
-  const { accountUuid, organizationUuid } = getCoreUserData(true)
-
-  // Build attributes for GrowthbookExperimentEvent
-  const attributes = {
-    event_type: 'GrowthbookExperimentEvent',
-    event_id: randomUUID(),
-    experiment_id: data.experimentId,
-    variation_id: data.variationId,
-    ...(userId && { device_id: userId }),
-    ...(accountUuid && { account_uuid: accountUuid }),
-    ...(organizationUuid && { organization_uuid: organizationUuid }),
-    ...(data.userAttributes && {
-      session_id: data.userAttributes.sessionId,
-      user_attributes: jsonStringify(data.userAttributes),
-    }),
-    ...(data.experimentMetadata && {
-      experiment_metadata: jsonStringify(data.experimentMetadata),
-    }),
-    environment: getEnvironmentForGrowthBook(),
-  }
-
-  if (process.env.USER_TYPE === 'ant') {
-    logForDebugging(
-      `[ANT-ONLY] 1P GrowthBook experiment: ${data.experimentId} variation=${data.variationId}`,
-    )
-  }
-
-  firstPartyEventLogger.emit({
-    body: 'growthbook_experiment',
-    attributes,
-  })
+  return
 }
 
-const DEFAULT_LOGS_EXPORT_INTERVAL_MS = 10000
-const DEFAULT_MAX_EXPORT_BATCH_SIZE = 200
-const DEFAULT_MAX_QUEUE_SIZE = 8192
-
-/**
- * Initialize 1P event logging infrastructure.
- * This creates a separate LoggerProvider for internal event logging,
- * independent of customer OTLP telemetry.
- *
- * This uses its own minimal resource configuration with just the attributes
- * we need for internal analytics (service name, version, platform info).
- */
 export function initialize1PEventLogging(): void {
-  profileCheckpoint('1p_event_logging_start')
-  const enabled = is1PEventLoggingEnabled()
-
-  if (!enabled) {
-    if (process.env.USER_TYPE === 'ant') {
-      logForDebugging('1P event logging not enabled')
-    }
-    return
-  }
-
-  // Fetch batch processor configuration from GrowthBook dynamic config
-  // Uses cached value if available, refreshes in background
-  const batchConfig = getBatchConfig()
-  lastBatchConfig = batchConfig
-  profileCheckpoint('1p_event_after_growthbook_config')
-
-  const scheduledDelayMillis =
-    batchConfig.scheduledDelayMillis ||
-    parseInt(
-      process.env.OTEL_LOGS_EXPORT_INTERVAL ||
-        DEFAULT_LOGS_EXPORT_INTERVAL_MS.toString(),
-    )
-
-  const maxExportBatchSize =
-    batchConfig.maxExportBatchSize || DEFAULT_MAX_EXPORT_BATCH_SIZE
-
-  const maxQueueSize = batchConfig.maxQueueSize || DEFAULT_MAX_QUEUE_SIZE
-
-  // Build our own resource for 1P event logging with minimal attributes
-  const platform = getPlatform()
-  const attributes: Record<string, string> = {
-    [ATTR_SERVICE_NAME]: 'claude-code',
-    [ATTR_SERVICE_VERSION]: MACRO.VERSION,
-  }
-
-  // Add WSL-specific attributes if running on WSL
-  if (platform === 'wsl') {
-    const wslVersion = getWslVersion()
-    if (wslVersion) {
-      attributes['wsl.version'] = wslVersion
-    }
-  }
-
-  const resource = resourceFromAttributes(attributes)
-
-  // Create a new LoggerProvider with the EventLoggingExporter
-  // NOTE: This is kept separate from customer telemetry logs to ensure
-  // internal events don't leak to customer endpoints and vice versa.
-  // We don't register this globally - it's only used for internal event logging.
-  const eventLoggingExporter = new FirstPartyEventLoggingExporter({
-    maxBatchSize: maxExportBatchSize,
-    skipAuth: batchConfig.skipAuth,
-    maxAttempts: batchConfig.maxAttempts,
-    path: batchConfig.path,
-    baseUrl: batchConfig.baseUrl,
-    isKilled: () => isSinkKilled('firstParty'),
-  })
-  firstPartyEventLoggerProvider = new LoggerProvider({
-    resource,
-    processors: [
-      new BatchLogRecordProcessor(eventLoggingExporter, {
-        scheduledDelayMillis,
-        maxExportBatchSize,
-        maxQueueSize,
-      }),
-    ],
-  })
-
-  // Initialize event logger from our internal provider (NOT from global API)
-  // IMPORTANT: We must get the logger from our local provider, not logs.getLogger()
-  // because logs.getLogger() returns a logger from the global provider, which is
-  // separate and used for customer telemetry.
-  firstPartyEventLogger = firstPartyEventLoggerProvider.getLogger(
-    'com.anthropic.claude_code.events',
-    MACRO.VERSION,
-  )
+  return
 }
 
-/**
- * Rebuild the 1P event logging pipeline if the batch config changed.
- * Register this with onGrowthBookRefresh so long-running sessions pick up
- * changes to batch size, delay, endpoint, etc.
- *
- * Event-loss safety:
- * 1. Null the logger first — concurrent logEventTo1P() calls hit the
- *    !firstPartyEventLogger guard and bail during the swap window. This drops
- *    a handful of events but prevents emitting to a draining provider.
- * 2. forceFlush() drains the old BatchLogRecordProcessor buffer to the
- *    exporter. Export failures go to disk at getCurrentBatchFilePath() which
- *    is keyed by module-level BATCH_UUID + sessionId — unchanged across
- *    reinit — so the NEW exporter's disk-backed retry picks them up.
- * 3. Swap to new provider/logger; old provider shutdown runs in background
- *    (buffer already drained, just cleanup).
- */
 export async function reinitialize1PEventLoggingIfConfigChanged(): Promise<void> {
-  if (!is1PEventLoggingEnabled() || !firstPartyEventLoggerProvider) {
-    return
-  }
-
-  const newConfig = getBatchConfig()
-
-  if (isEqual(newConfig, lastBatchConfig)) {
-    return
-  }
-
-  if (process.env.USER_TYPE === 'ant') {
-    logForDebugging(
-      `1P event logging: ${BATCH_CONFIG_NAME} changed, reinitializing`,
-    )
-  }
-
-  const oldProvider = firstPartyEventLoggerProvider
-  const oldLogger = firstPartyEventLogger
-  firstPartyEventLogger = null
-
-  try {
-    await oldProvider.forceFlush()
-  } catch {
-    // Export failures are already on disk; new exporter will retry them.
-  }
-
-  firstPartyEventLoggerProvider = null
-  try {
-    initialize1PEventLogging()
-  } catch (e) {
-    // Restore so the next GrowthBook refresh can retry. oldProvider was
-    // only forceFlush()'d, not shut down — it's still functional. Without
-    // this, both stay null and the !firstPartyEventLoggerProvider gate at
-    // the top makes recovery impossible.
-    firstPartyEventLoggerProvider = oldProvider
-    firstPartyEventLogger = oldLogger
-    logError(e)
-    return
-  }
-
-  void oldProvider.shutdown().catch(() => {})
+  return
 }

src/services/analytics/growthbook.ts

@@ -21,7 +21,6 @@ import {
   getUserForGrowthBook,
 } from '../../utils/user.js'
 import {
-  is1PEventLoggingEnabled,
   logGrowthBookExperimentTo1P,
 } from './firstPartyEventLogger.js'
 
@@ -219,6 +218,19 @@ function getConfigOverrides(): Record<string, unknown> | undefined {
   }
 }
 
+function getCachedGrowthBookFeature<T>(feature: string): T | undefined {
+  if (remoteEvalFeatureValues.has(feature)) {
+    return remoteEvalFeatureValues.get(feature) as T
+  }
+
+  try {
+    const cached = getGlobalConfig().cachedGrowthBookFeatures?.[feature]
+    return cached !== undefined ? (cached as T) : undefined
+  } catch {
+    return undefined
+  }
+}
+
 /**
  * Enumerate all known GrowthBook features and their current resolved values
  * (not including overrides). In-memory payload first, disk cache fallback —
@@ -420,8 +432,9 @@ function syncRemoteEvalToDisk(): void {
  * Check if GrowthBook operations should be enabled
  */
 function isGrowthBookEnabled(): boolean {
-  // GrowthBook depends on 1P event logging.
-  return is1PEventLoggingEnabled()
+  // Network-backed GrowthBook egress is disabled in this build. Callers still
+  // read local cache and explicit overrides through the helpers below.
+  return false
 }
 
 /**
@@ -682,6 +695,11 @@ async function getFeatureValueInternal<T>(
     return configOverrides[feature] as T
   }
 
+  const cached = getCachedGrowthBookFeature<T>(feature)
+  if (cached !== undefined) {
+    return cached
+  }
+
   if (!isGrowthBookEnabled()) {
     return defaultValue
   }
@@ -745,6 +763,11 @@ export function getFeatureValue_CACHED_MAY_BE_STALE<T>(
     return configOverrides[feature] as T
   }
 
+  const cached = getCachedGrowthBookFeature<T>(feature)
+  if (cached !== undefined) {
+    return cached
+  }
+
   if (!isGrowthBookEnabled()) {
     return defaultValue
   }
@@ -814,6 +837,16 @@ export function checkStatsigFeatureGate_CACHED_MAY_BE_STALE(
     return Boolean(configOverrides[gate])
   }
 
+  const cached = getCachedGrowthBookFeature<boolean>(gate)
+  if (cached !== undefined) {
+    return Boolean(cached)
+  }
+
+  const statsigCached = getGlobalConfig().cachedStatsigGates?.[gate]
+  if (statsigCached !== undefined) {
+    return Boolean(statsigCached)
+  }
+
   if (!isGrowthBookEnabled()) {
     return false
   }
@@ -861,6 +894,16 @@ export async function checkSecurityRestrictionGate(
     return Boolean(configOverrides[gate])
   }
 
+  const cached = getCachedGrowthBookFeature<boolean>(gate)
+  if (cached !== undefined) {
+    return Boolean(cached)
+  }
+
+  const statsigCached = getGlobalConfig().cachedStatsigGates?.[gate]
+  if (statsigCached !== undefined) {
+    return Boolean(statsigCached)
+  }
+
   if (!isGrowthBookEnabled()) {
     return false
   }
@@ -871,19 +914,6 @@ export async function checkSecurityRestrictionGate(
     await reinitializingPromise
   }
 
-  // Check Statsig cache first - it may have correct value from previous logged-in session
-  const config = getGlobalConfig()
-  const statsigCached = config.cachedStatsigGates?.[gate]
-  if (statsigCached !== undefined) {
-    return Boolean(statsigCached)
-  }
-
-  // Then check GrowthBook cache
-  const gbCached = config.cachedGrowthBookFeatures?.[gate]
-  if (gbCached !== undefined) {
-    return Boolean(gbCached)
-  }
-
   // No cache - return false (don't block on init for uncached gates)
   return false
 }
@@ -914,13 +944,23 @@ export async function checkGate_CACHED_OR_BLOCKING(
     return Boolean(configOverrides[gate])
   }
 
+  const cached = getCachedGrowthBookFeature<boolean>(gate)
+  if (cached !== undefined) {
+    return Boolean(cached)
+  }
+
+  const statsigCached = getGlobalConfig().cachedStatsigGates?.[gate]
+  if (statsigCached !== undefined) {
+    return Boolean(statsigCached)
+  }
+
   if (!isGrowthBookEnabled()) {
     return false
   }
 
   // Fast path: disk cache already says true — trust it
-  const cached = getGlobalConfig().cachedGrowthBookFeatures?.[gate]
-  if (cached === true) {
+  const diskCached = getGlobalConfig().cachedGrowthBookFeatures?.[gate]
+  if (diskCached === true) {
     // Log experiment exposure if data is available, otherwise defer
     if (experimentDataByFeature.has(gate)) {
       logExposureForFeature(gate)

src/services/analytics/sink.ts

@@ -1,111 +1,32 @@
 /**
  * Analytics sink implementation
  *
- * This module contains the actual analytics routing logic and should be
- * initialized during app startup. It routes events to Datadog and 1P event
- * logging.
- *
- * Usage: Call initializeAnalyticsSink() during app startup to attach the sink.
+ * This open build keeps the analytics sink boundary for compatibility, but
+ * drops all queued analytics events locally instead of routing them onward.
  */
 
-import { trackDatadogEvent } from './datadog.js'
-import { logEventTo1P, shouldSampleEvent } from './firstPartyEventLogger.js'
-import { checkStatsigFeatureGate_CACHED_MAY_BE_STALE } from './growthbook.js'
-import { attachAnalyticsSink, stripProtoFields } from './index.js'
-import { isSinkKilled } from './sinkKillswitch.js'
+import { attachAnalyticsSink } from './index.js'
 
-// Local type matching the logEvent metadata signature
 type LogEventMetadata = { [key: string]: boolean | number | undefined }
 
-const DATADOG_GATE_NAME = 'tengu_log_datadog_events'
-
-// Module-level gate state - starts undefined, initialized during startup
-let isDatadogGateEnabled: boolean | undefined = undefined
-
-/**
- * Check if Datadog tracking is enabled.
- * Falls back to cached value from previous session if not yet initialized.
- */
-function shouldTrackDatadog(): boolean {
-  if (isSinkKilled('datadog')) {
-    return false
-  }
-  if (isDatadogGateEnabled !== undefined) {
-    return isDatadogGateEnabled
-  }
-
-  // Fallback to cached value from previous session
-  try {
-    return checkStatsigFeatureGate_CACHED_MAY_BE_STALE(DATADOG_GATE_NAME)
-  } catch {
-    return false
-  }
+function logEventImpl(
+  _eventName: string,
+  _metadata: LogEventMetadata,
+): void {
+  return
 }
 
-/**
- * Log an event (synchronous implementation)
- */
-function logEventImpl(eventName: string, metadata: LogEventMetadata): void {
-  // Check if this event should be sampled
-  const sampleResult = shouldSampleEvent(eventName)
-
-  // If sample result is 0, the event was not selected for logging
-  if (sampleResult === 0) {
-    return
-  }
-
-  // If sample result is a positive number, add it to metadata
-  const metadataWithSampleRate =
-    sampleResult !== null
-      ? { ...metadata, sample_rate: sampleResult }
-      : metadata
-
-  if (shouldTrackDatadog()) {
-    // Datadog is a general-access backend — strip _PROTO_* keys
-    // (unredacted PII-tagged values meant only for the 1P privileged column).
-    void trackDatadogEvent(eventName, stripProtoFields(metadataWithSampleRate))
-  }
-
-  // 1P receives the full payload including _PROTO_* — the exporter
-  // destructures and routes those keys to proto fields itself.
-  logEventTo1P(eventName, metadataWithSampleRate)
-}
-
-/**
- * Log an event (asynchronous implementation)
- *
- * With Segment removed the two remaining sinks are fire-and-forget, so this
- * just wraps the sync impl — kept to preserve the sink interface contract.
- */
 function logEventAsyncImpl(
-  eventName: string,
-  metadata: LogEventMetadata,
+  _eventName: string,
+  _metadata: LogEventMetadata,
 ): Promise<void> {
-  logEventImpl(eventName, metadata)
   return Promise.resolve()
 }
 
-/**
- * Initialize analytics gates during startup.
- *
- * Updates gate values from server. Early events use cached values from previous
- * session to avoid data loss during initialization.
- *
- * Called from main.tsx during setupBackend().
- */
 export function initializeAnalyticsGates(): void {
-  isDatadogGateEnabled =
-    checkStatsigFeatureGate_CACHED_MAY_BE_STALE(DATADOG_GATE_NAME)
+  return
 }
 
-/**
- * Initialize the analytics sink.
- *
- * Call this during app startup to attach the analytics backend.
- * Any events logged before this is called will be queued and drained.
- *
- * Idempotent: safe to call multiple times (subsequent calls are no-ops).
- */
 export function initializeAnalyticsSink(): void {
   attachAnalyticsSink({
     logEvent: logEventImpl,

src/utils/api.ts

@@ -438,39 +438,14 @@ export function appendSystemContext(
   systemPrompt: SystemPrompt,
   context: { [k: string]: string },
 ): string[] {
-  return [
-    ...systemPrompt,
-    Object.entries(context)
-      .map(([key, value]) => `${key}: ${value}`)
-      .join('\n'),
-  ].filter(Boolean)
+  return systemPrompt
 }
 
 export function prependUserContext(
   messages: Message[],
   context: { [k: string]: string },
 ): Message[] {
-  if (process.env.NODE_ENV === 'test') {
-    return messages
-  }
-
-  if (Object.entries(context).length === 0) {
-    return messages
-  }
-
-  return [
-    createUserMessage({
-      content: `<system-reminder>\nAs you answer the user's questions, you can use the following context:\n${Object.entries(
-        context,
-      )
-        .map(([key, value]) => `# ${key}\n${value}`)
-        .join('\n')}
-
-      IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context unless it is highly relevant to your task.\n</system-reminder>\n`,
-      isMeta: true,
-    }),
-    ...messages,
-  ]
+  return messages
 }
 
 /**
@@ -480,86 +455,7 @@ export async function logContextMetrics(
   mcpConfigs: Record<string, ScopedMcpServerConfig>,
   toolPermissionContext: ToolPermissionContext,
 ): Promise<void> {
-  // Early return if logging is disabled
-  if (isAnalyticsDisabled()) {
-    return
-  }
-  const [{ tools: mcpTools }, tools, userContext, systemContext] =
-    await Promise.all([
-      prefetchAllMcpResources(mcpConfigs),
-      getTools(toolPermissionContext),
-      getUserContext(),
-      getSystemContext(),
-    ])
-  // Extract individual context sizes and calculate total
-  const gitStatusSize = systemContext.gitStatus?.length ?? 0
-  const claudeMdSize = userContext.claudeMd?.length ?? 0
-
-  // Calculate total context size
-  const totalContextSize = gitStatusSize + claudeMdSize
-
-  // Get file count using ripgrep (rounded to nearest power of 10 for privacy)
-  const currentDir = getCwd()
-  const ignorePatternsByRoot = getFileReadIgnorePatterns(toolPermissionContext)
-  const normalizedIgnorePatterns = normalizePatternsToPath(
-    ignorePatternsByRoot,
-    currentDir,
-  )
-  const fileCount = await countFilesRoundedRg(
-    currentDir,
-    AbortSignal.timeout(1000),
-    normalizedIgnorePatterns,
-  )
-
-  // Calculate tool metrics
-  let mcpToolsCount = 0
-  let mcpServersCount = 0
-  let mcpToolsTokens = 0
-  let nonMcpToolsCount = 0
-  let nonMcpToolsTokens = 0
-
-  const nonMcpTools = tools.filter(tool => !tool.isMcp)
-  mcpToolsCount = mcpTools.length
-  nonMcpToolsCount = nonMcpTools.length
-
-  // Extract unique server names from MCP tool names (format: mcp__servername__toolname)
-  const serverNames = new Set<string>()
-  for (const tool of mcpTools) {
-    const parts = tool.name.split('__')
-    if (parts.length >= 3 && parts[1]) {
-      serverNames.add(parts[1])
-    }
-  }
-  mcpServersCount = serverNames.size
-
-  // Estimate tool tokens locally for analytics (avoids N API calls per session)
-  // Use inputJSONSchema (plain JSON Schema) when available, otherwise convert Zod schema
-  for (const tool of mcpTools) {
-    const schema =
-      'inputJSONSchema' in tool && tool.inputJSONSchema
-        ? tool.inputJSONSchema
-        : zodToJsonSchema(tool.inputSchema)
-    mcpToolsTokens += roughTokenCountEstimation(jsonStringify(schema))
-  }
-  for (const tool of nonMcpTools) {
-    const schema =
-      'inputJSONSchema' in tool && tool.inputJSONSchema
-        ? tool.inputJSONSchema
-        : zodToJsonSchema(tool.inputSchema)
-    nonMcpToolsTokens += roughTokenCountEstimation(jsonStringify(schema))
-  }
-
-  logEvent('tengu_context_size', {
-    git_status_size: gitStatusSize,
-    claude_md_size: claudeMdSize,
-    total_context_size: totalContextSize,
-    project_file_count_rounded: fileCount,
-    mcp_tools_count: mcpToolsCount,
-    mcp_servers_count: mcpServersCount,
-    mcp_tools_tokens: mcpToolsTokens,
-    non_mcp_tools_count: nonMcpToolsCount,
-    non_mcp_tools_tokens: nonMcpToolsTokens,
-  })
+  return
 }
 
 // TODO: Generalize this to all tools

src/utils/telemetry/events.ts

@@ -1,75 +1,14 @@
-import type { Attributes } from '@opentelemetry/api'
-import { getEventLogger, getPromptId } from 'src/bootstrap/state.js'
-import { logForDebugging } from '../debug.js'
-import { isEnvTruthy } from '../envUtils.js'
-import { getTelemetryAttributes } from '../telemetryAttributes.js'
+/**
+ * OpenTelemetry event egress is disabled in this build.
+ */
 
-// Monotonically increasing counter for ordering events within a session
-let eventSequence = 0
-
-// Track whether we've already warned about a null event logger to avoid spamming
-let hasWarnedNoEventLogger = false
-
-function isUserPromptLoggingEnabled() {
-  return isEnvTruthy(process.env.OTEL_LOG_USER_PROMPTS)
-}
-
-export function redactIfDisabled(content: string): string {
-  return isUserPromptLoggingEnabled() ? content : '<REDACTED>'
+export function redactIfDisabled(_content: string): string {
+  return '<REDACTED>'
 }
 
 export async function logOTelEvent(
-  eventName: string,
-  metadata: { [key: string]: string | undefined } = {},
+  _eventName: string,
+  _metadata: { [key: string]: string | undefined } = {},
 ): Promise<void> {
-  const eventLogger = getEventLogger()
-  if (!eventLogger) {
-    if (!hasWarnedNoEventLogger) {
-      hasWarnedNoEventLogger = true
-      logForDebugging(
-        `[3P telemetry] Event dropped (no event logger initialized): ${eventName}`,
-        { level: 'warn' },
-      )
-    }
-    return
-  }
-
-  // Skip logging in test environment
-  if (process.env.NODE_ENV === 'test') {
-    return
-  }
-
-  const attributes: Attributes = {
-    ...getTelemetryAttributes(),
-    'event.name': eventName,
-    'event.timestamp': new Date().toISOString(),
-    'event.sequence': eventSequence++,
-  }
-
-  // Add prompt ID to events (but not metrics, where it would cause unbounded cardinality)
-  const promptId = getPromptId()
-  if (promptId) {
-    attributes['prompt.id'] = promptId
-  }
-
-  // Workspace directory from the desktop app (host path). Events only —
-  // filesystem paths are too high-cardinality for metric dimensions, and
-  // the BQ metrics pipeline must never see them.
-  const workspaceDir = process.env.CLAUDE_CODE_WORKSPACE_HOST_PATHS
-  if (workspaceDir) {
-    attributes['workspace.host_paths'] = workspaceDir.split('|')
-  }
-
-  // Add metadata as attributes - all values are already strings
-  for (const [key, value] of Object.entries(metadata)) {
-    if (value !== undefined) {
-      attributes[key] = value
-    }
-  }
-
-  // Emit log record as an event
-  eventLogger.emit({
-    body: `claude_code.${eventName}`,
-    attributes,
-  })
+  return
 }

src/utils/telemetry/instrumentation.ts

@@ -1,123 +1,5 @@
-import { DiagLogLevel, diag, trace } from '@opentelemetry/api'
-import { logs } from '@opentelemetry/api-logs'
-// OTLP/Prometheus exporters are dynamically imported inside the protocol
-// switch statements below. A process uses at most one protocol variant per
-// signal, but static imports would load all 6 (~1.2MB) on every startup.
-import {
-  envDetector,
-  hostDetector,
-  osDetector,
-  resourceFromAttributes,
-} from '@opentelemetry/resources'
-import {
-  BatchLogRecordProcessor,
-  ConsoleLogRecordExporter,
-  LoggerProvider,
-} from '@opentelemetry/sdk-logs'
-import {
-  ConsoleMetricExporter,
-  MeterProvider,
-  PeriodicExportingMetricReader,
-} from '@opentelemetry/sdk-metrics'
-import {
-  BasicTracerProvider,
-  BatchSpanProcessor,
-  ConsoleSpanExporter,
-} from '@opentelemetry/sdk-trace-base'
-import {
-  ATTR_SERVICE_NAME,
-  ATTR_SERVICE_VERSION,
-  SEMRESATTRS_HOST_ARCH,
-} from '@opentelemetry/semantic-conventions'
-import { HttpsProxyAgent } from 'https-proxy-agent'
-import {
-  getLoggerProvider,
-  getMeterProvider,
-  getTracerProvider,
-  setEventLogger,
-  setLoggerProvider,
-  setMeterProvider,
-  setTracerProvider,
-} from 'src/bootstrap/state.js'
-import {
-  getOtelHeadersFromHelper,
-  getSubscriptionType,
-  is1PApiCustomer,
-  isClaudeAISubscriber,
-} from 'src/utils/auth.js'
-import { getPlatform, getWslVersion } from 'src/utils/platform.js'
+export function bootstrapTelemetry(): void {}
 
-import { getCACertificates } from '../caCerts.js'
-import { registerCleanup } from '../cleanupRegistry.js'
-import { getHasFormattedOutput, logForDebugging } from '../debug.js'
-import { isEnvTruthy } from '../envUtils.js'
-import { errorMessage } from '../errors.js'
-import { getMTLSConfig } from '../mtls.js'
-import { getProxyUrl, shouldBypassProxy } from '../proxy.js'
-import { getSettings_DEPRECATED } from '../settings/settings.js'
-import { jsonStringify } from '../slowOperations.js'
-import { profileCheckpoint } from '../startupProfiler.js'
-import { isBetaTracingEnabled } from './betaSessionTracing.js'
-import { BigQueryMetricsExporter } from './bigqueryExporter.js'
-import { ClaudeCodeDiagLogger } from './logger.js'
-import { initializePerfettoTracing } from './perfettoTracing.js'
-import {
-  endInteractionSpan,
-  isEnhancedTelemetryEnabled,
-} from './sessionTracing.js'
-
-const DEFAULT_METRICS_EXPORT_INTERVAL_MS = 60000
-const DEFAULT_LOGS_EXPORT_INTERVAL_MS = 5000
-const DEFAULT_TRACES_EXPORT_INTERVAL_MS = 5000
-
-class TelemetryTimeoutError extends Error {}
-
-function telemetryTimeout(ms: number, message: string): Promise<never> {
-  return new Promise((_, reject) => {
-    setTimeout(
-      (rej: (e: Error) => void, msg: string) =>
-        rej(new TelemetryTimeoutError(msg)),
-      ms,
-      reject,
-      message,
-    ).unref()
-  })
-}
-
-export function bootstrapTelemetry() {
-  if (process.env.USER_TYPE === 'ant') {
-    // Read from ANT_ prefixed variables that are defined at build time
-    if (process.env.ANT_OTEL_METRICS_EXPORTER) {
-      process.env.OTEL_METRICS_EXPORTER = process.env.ANT_OTEL_METRICS_EXPORTER
-    }
-    if (process.env.ANT_OTEL_LOGS_EXPORTER) {
-      process.env.OTEL_LOGS_EXPORTER = process.env.ANT_OTEL_LOGS_EXPORTER
-    }
-    if (process.env.ANT_OTEL_TRACES_EXPORTER) {
-      process.env.OTEL_TRACES_EXPORTER = process.env.ANT_OTEL_TRACES_EXPORTER
-    }
-    if (process.env.ANT_OTEL_EXPORTER_OTLP_PROTOCOL) {
-      process.env.OTEL_EXPORTER_OTLP_PROTOCOL =
-        process.env.ANT_OTEL_EXPORTER_OTLP_PROTOCOL
-    }
-    if (process.env.ANT_OTEL_EXPORTER_OTLP_ENDPOINT) {
-      process.env.OTEL_EXPORTER_OTLP_ENDPOINT =
-        process.env.ANT_OTEL_EXPORTER_OTLP_ENDPOINT
-    }
-    if (process.env.ANT_OTEL_EXPORTER_OTLP_HEADERS) {
-      process.env.OTEL_EXPORTER_OTLP_HEADERS =
-        process.env.ANT_OTEL_EXPORTER_OTLP_HEADERS
-    }
-  }
-
-  // Set default tempoality to 'delta' because it's the more sane default
-  if (!process.env.OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE) {
-    process.env.OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE = 'delta'
-  }
-}
-
-// Per OTEL spec, "none" means "no automatically configured exporter for this signal".
-// https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/#exporter-selection
 export function parseExporterTypes(value: string | undefined): string[] {
   return (value || '')
     .trim()
@@ -127,699 +9,14 @@ export function parseExporterTypes(value: string | undefined): string[] {
     .filter(t => t !== 'none')
 }
 
-async function getOtlpReaders() {
-  const exporterTypes = parseExporterTypes(process.env.OTEL_METRICS_EXPORTER)
-  const exportInterval = parseInt(
-    process.env.OTEL_METRIC_EXPORT_INTERVAL ||
-      DEFAULT_METRICS_EXPORT_INTERVAL_MS.toString(),
-  )
-
-  const exporters = []
-  for (const exporterType of exporterTypes) {
-    if (exporterType === 'console') {
-      // Custom console exporter that shows resource attributes
-      const consoleExporter = new ConsoleMetricExporter()
-      const originalExport = consoleExporter.export.bind(consoleExporter)
-
-      consoleExporter.export = (metrics, callback) => {
-        // Log resource attributes once at the start
-        if (metrics.resource && metrics.resource.attributes) {
-          // The console exporter is for debugging, so console output is intentional here
-
-          logForDebugging('\n=== Resource Attributes ===')
-          logForDebugging(jsonStringify(metrics.resource.attributes))
-          logForDebugging('===========================\n')
-        }
-
-        return originalExport(metrics, callback)
-      }
-
-      exporters.push(consoleExporter)
-    } else if (exporterType === 'otlp') {
-      const protocol =
-        process.env.OTEL_EXPORTER_OTLP_METRICS_PROTOCOL?.trim() ||
-        process.env.OTEL_EXPORTER_OTLP_PROTOCOL?.trim()
-
-      const httpConfig = getOTLPExporterConfig()
-
-      switch (protocol) {
-        case 'grpc': {
-          // Lazy-import to keep @grpc/grpc-js (~700KB) out of the telemetry chunk
-          // when the protocol is http/protobuf (ant default) or http/json.
-          const { OTLPMetricExporter } = await import(
-            '@opentelemetry/exporter-metrics-otlp-grpc'
-          )
-          exporters.push(new OTLPMetricExporter())
-          break
-        }
-        case 'http/json': {
-          const { OTLPMetricExporter } = await import(
-            '@opentelemetry/exporter-metrics-otlp-http'
-          )
-          exporters.push(new OTLPMetricExporter(httpConfig))
-          break
-        }
-        case 'http/protobuf': {
-          const { OTLPMetricExporter } = await import(
-            '@opentelemetry/exporter-metrics-otlp-proto'
-          )
-          exporters.push(new OTLPMetricExporter(httpConfig))
-          break
-        }
-        default:
-          throw new Error(
-            `Unknown protocol set in OTEL_EXPORTER_OTLP_METRICS_PROTOCOL or OTEL_EXPORTER_OTLP_PROTOCOL env var: ${protocol}`,
-          )
-      }
-    } else if (exporterType === 'prometheus') {
-      const { PrometheusExporter } = await import(
-        '@opentelemetry/exporter-prometheus'
-      )
-      exporters.push(new PrometheusExporter())
-    } else {
-      throw new Error(
-        `Unknown exporter type set in OTEL_EXPORTER_OTLP_METRICS_PROTOCOL or OTEL_EXPORTER_OTLP_PROTOCOL env var: ${exporterType}`,
-      )
-    }
-  }
-
-  return exporters.map(exporter => {
-    if ('export' in exporter) {
-      return new PeriodicExportingMetricReader({
-        exporter,
-        exportIntervalMillis: exportInterval,
-      })
-    }
-    return exporter
-  })
+export function isTelemetryEnabled(): boolean {
+  return false
 }
 
-async function getOtlpLogExporters() {
-  const exporterTypes = parseExporterTypes(process.env.OTEL_LOGS_EXPORTER)
-
-  const protocol =
-    process.env.OTEL_EXPORTER_OTLP_LOGS_PROTOCOL?.trim() ||
-    process.env.OTEL_EXPORTER_OTLP_PROTOCOL?.trim()
-  const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT
-
-  logForDebugging(
-    `[3P telemetry] getOtlpLogExporters: types=${jsonStringify(exporterTypes)}, protocol=${protocol}, endpoint=${endpoint}`,
-  )
-
-  const exporters = []
-  for (const exporterType of exporterTypes) {
-    if (exporterType === 'console') {
-      exporters.push(new ConsoleLogRecordExporter())
-    } else if (exporterType === 'otlp') {
-      const httpConfig = getOTLPExporterConfig()
-
-      switch (protocol) {
-        case 'grpc': {
-          const { OTLPLogExporter } = await import(
-            '@opentelemetry/exporter-logs-otlp-grpc'
-          )
-          exporters.push(new OTLPLogExporter())
-          break
-        }
-        case 'http/json': {
-          const { OTLPLogExporter } = await import(
-            '@opentelemetry/exporter-logs-otlp-http'
-          )
-          exporters.push(new OTLPLogExporter(httpConfig))
-          break
-        }
-        case 'http/protobuf': {
-          const { OTLPLogExporter } = await import(
-            '@opentelemetry/exporter-logs-otlp-proto'
-          )
-          exporters.push(new OTLPLogExporter(httpConfig))
-          break
-        }
-        default:
-          throw new Error(
-            `Unknown protocol set in OTEL_EXPORTER_OTLP_LOGS_PROTOCOL or OTEL_EXPORTER_OTLP_PROTOCOL env var: ${protocol}`,
-          )
-      }
-    } else {
-      throw new Error(
-        `Unknown exporter type set in OTEL_LOGS_EXPORTER env var: ${exporterType}`,
-      )
-    }
-  }
-
-  return exporters
+export async function initializeTelemetry(): Promise<null> {
+  return null
 }
 
-async function getOtlpTraceExporters() {
-  const exporterTypes = parseExporterTypes(process.env.OTEL_TRACES_EXPORTER)
-
-  const exporters = []
-  for (const exporterType of exporterTypes) {
-    if (exporterType === 'console') {
-      exporters.push(new ConsoleSpanExporter())
-    } else if (exporterType === 'otlp') {
-      const protocol =
-        process.env.OTEL_EXPORTER_OTLP_TRACES_PROTOCOL?.trim() ||
-        process.env.OTEL_EXPORTER_OTLP_PROTOCOL?.trim()
-
-      const httpConfig = getOTLPExporterConfig()
-
-      switch (protocol) {
-        case 'grpc': {
-          const { OTLPTraceExporter } = await import(
-            '@opentelemetry/exporter-trace-otlp-grpc'
-          )
-          exporters.push(new OTLPTraceExporter())
-          break
-        }
-        case 'http/json': {
-          const { OTLPTraceExporter } = await import(
-            '@opentelemetry/exporter-trace-otlp-http'
-          )
-          exporters.push(new OTLPTraceExporter(httpConfig))
-          break
-        }
-        case 'http/protobuf': {
-          const { OTLPTraceExporter } = await import(
-            '@opentelemetry/exporter-trace-otlp-proto'
-          )
-          exporters.push(new OTLPTraceExporter(httpConfig))
-          break
-        }
-        default:
-          throw new Error(
-            `Unknown protocol set in OTEL_EXPORTER_OTLP_TRACES_PROTOCOL or OTEL_EXPORTER_OTLP_PROTOCOL env var: ${protocol}`,
-          )
-      }
-    } else {
-      throw new Error(
-        `Unknown exporter type set in OTEL_TRACES_EXPORTER env var: ${exporterType}`,
-      )
-    }
-  }
-
-  return exporters
-}
-
-export function isTelemetryEnabled() {
-  return isEnvTruthy(process.env.CLAUDE_CODE_ENABLE_TELEMETRY)
-}
-
-function getBigQueryExportingReader() {
-  const bigqueryExporter = new BigQueryMetricsExporter()
-  return new PeriodicExportingMetricReader({
-    exporter: bigqueryExporter,
-    exportIntervalMillis: 5 * 60 * 1000, // 5mins for BigQuery metrics exporter to reduce load
-  })
-}
-
-function isBigQueryMetricsEnabled() {
-  // BigQuery metrics are enabled for:
-  // 1. API customers (excluding Claude.ai subscribers and Bedrock/Vertex)
-  // 2. Claude for Enterprise (C4E) users
-  // 3. Claude for Teams users
-  const subscriptionType = getSubscriptionType()
-  const isC4EOrTeamUser =
-    isClaudeAISubscriber() &&
-    (subscriptionType === 'enterprise' || subscriptionType === 'team')
-
-  return is1PApiCustomer() || isC4EOrTeamUser
-}
-
-/**
- * Initialize beta tracing - a separate code path for detailed debugging.
- * Uses BETA_TRACING_ENDPOINT instead of OTEL_EXPORTER_OTLP_ENDPOINT.
- */
-async function initializeBetaTracing(
-  resource: ReturnType<typeof resourceFromAttributes>,
-): Promise<void> {
-  const endpoint = process.env.BETA_TRACING_ENDPOINT
-  if (!endpoint) {
-    return
-  }
-
-  const [{ OTLPTraceExporter }, { OTLPLogExporter }] = await Promise.all([
-    import('@opentelemetry/exporter-trace-otlp-http'),
-    import('@opentelemetry/exporter-logs-otlp-http'),
-  ])
-
-  const httpConfig = {
-    url: `${endpoint}/v1/traces`,
-  }
-
-  const logHttpConfig = {
-    url: `${endpoint}/v1/logs`,
-  }
-
-  // Initialize trace exporter
-  const traceExporter = new OTLPTraceExporter(httpConfig)
-  const spanProcessor = new BatchSpanProcessor(traceExporter, {
-    scheduledDelayMillis: DEFAULT_TRACES_EXPORT_INTERVAL_MS,
-  })
-
-  const tracerProvider = new BasicTracerProvider({
-    resource,
-    spanProcessors: [spanProcessor],
-  })
-
-  trace.setGlobalTracerProvider(tracerProvider)
-  setTracerProvider(tracerProvider)
-
-  // Initialize log exporter
-  const logExporter = new OTLPLogExporter(logHttpConfig)
-  const loggerProvider = new LoggerProvider({
-    resource,
-    processors: [
-      new BatchLogRecordProcessor(logExporter, {
-        scheduledDelayMillis: DEFAULT_LOGS_EXPORT_INTERVAL_MS,
-      }),
-    ],
-  })
-
-  logs.setGlobalLoggerProvider(loggerProvider)
-  setLoggerProvider(loggerProvider)
-
-  // Initialize event logger
-  const eventLogger = logs.getLogger(
-    'com.anthropic.claude_code.events',
-    MACRO.VERSION,
-  )
-  setEventLogger(eventLogger)
-
-  // Setup flush handlers - flush both logs AND traces
-  process.on('beforeExit', async () => {
-    await loggerProvider?.forceFlush()
-    await tracerProvider?.forceFlush()
-  })
-
-  process.on('exit', () => {
-    void loggerProvider?.forceFlush()
-    void tracerProvider?.forceFlush()
-  })
-}
-
-export async function initializeTelemetry() {
-  profileCheckpoint('telemetry_init_start')
-  bootstrapTelemetry()
-
-  // Console exporters call console.dir on a timer (5s logs/traces, 60s
-  // metrics), writing pretty-printed objects to stdout. In stream-json
-  // mode stdout is the SDK message channel; the first line (`{`) breaks
-  // the SDK's line reader. Stripped here (not main.tsx) because init.ts
-  // re-runs applyConfigEnvironmentVariables() inside initializeTelemetry-
-  // AfterTrust for remote-managed-settings users, and bootstrapTelemetry
-  // above copies ANT_OTEL_* for ant users — both would undo an earlier strip.
-  if (getHasFormattedOutput()) {
-    for (const key of [
-      'OTEL_METRICS_EXPORTER',
-      'OTEL_LOGS_EXPORTER',
-      'OTEL_TRACES_EXPORTER',
-    ] as const) {
-      const v = process.env[key]
-      if (v?.includes('console')) {
-        process.env[key] = v
-          .split(',')
-          .map(s => s.trim())
-          .filter(s => s !== 'console')
-          .join(',')
-      }
-    }
-  }
-
-  diag.setLogger(new ClaudeCodeDiagLogger(), DiagLogLevel.ERROR)
-
-  // Initialize Perfetto tracing (independent of OTEL)
-  // Enable via CLAUDE_CODE_PERFETTO_TRACE=1 or CLAUDE_CODE_PERFETTO_TRACE=<path>
-  initializePerfettoTracing()
-
-  const readers = []
-
-  // Add customer exporters (if enabled)
-  const telemetryEnabled = isTelemetryEnabled()
-  logForDebugging(
-    `[3P telemetry] isTelemetryEnabled=${telemetryEnabled} (CLAUDE_CODE_ENABLE_TELEMETRY=${process.env.CLAUDE_CODE_ENABLE_TELEMETRY})`,
-  )
-  if (telemetryEnabled) {
-    readers.push(...(await getOtlpReaders()))
-  }
-
-  // Add BigQuery exporter (for API customers, C4E users, and internal users)
-  if (isBigQueryMetricsEnabled()) {
-    readers.push(getBigQueryExportingReader())
-  }
-
-  // Create base resource with service attributes
-  const platform = getPlatform()
-  const baseAttributes: Record<string, string> = {
-    [ATTR_SERVICE_NAME]: 'claude-code',
-    [ATTR_SERVICE_VERSION]: MACRO.VERSION,
-  }
-
-  // Add WSL-specific attributes if running on WSL
-  if (platform === 'wsl') {
-    const wslVersion = getWslVersion()
-    if (wslVersion) {
-      baseAttributes['wsl.version'] = wslVersion
-    }
-  }
-
-  const baseResource = resourceFromAttributes(baseAttributes)
-
-  // Use OpenTelemetry detectors
-  const osResource = resourceFromAttributes(
-    osDetector.detect().attributes || {},
-  )
-
-  // Extract only host.arch from hostDetector
-  const hostDetected = hostDetector.detect()
-  const hostArchAttributes = hostDetected.attributes?.[SEMRESATTRS_HOST_ARCH]
-    ? {
-        [SEMRESATTRS_HOST_ARCH]: hostDetected.attributes[SEMRESATTRS_HOST_ARCH],
-      }
-    : {}
-  const hostArchResource = resourceFromAttributes(hostArchAttributes)
-
-  const envResource = resourceFromAttributes(
-    envDetector.detect().attributes || {},
-  )
-
-  // Merge resources - later resources take precedence
-  const resource = baseResource
-    .merge(osResource)
-    .merge(hostArchResource)
-    .merge(envResource)
-
-  // Check if beta tracing is enabled - this is a separate code path
-  // Available to all users who set ENABLE_BETA_TRACING_DETAILED=1 and BETA_TRACING_ENDPOINT
-  if (isBetaTracingEnabled()) {
-    void initializeBetaTracing(resource).catch(e =>
-      logForDebugging(`Beta tracing init failed: ${e}`, { level: 'error' }),
-    )
-    // Still set up meter provider for metrics (but skip regular logs/traces setup)
-    const meterProvider = new MeterProvider({
-      resource,
-      views: [],
-      readers,
-    })
-    setMeterProvider(meterProvider)
-
-    // Register shutdown for beta tracing
-    const shutdownTelemetry = async () => {
-      const timeoutMs = parseInt(
-        process.env.CLAUDE_CODE_OTEL_SHUTDOWN_TIMEOUT_MS || '2000',
-      )
-      try {
-        endInteractionSpan()
-
-        // Force flush + shutdown together inside the timeout. Previously forceFlush
-        // was awaited unbounded BEFORE the race, blocking exit on slow OTLP endpoints.
-        // Each provider's flush→shutdown is chained independently so a slow logger
-        // flush doesn't delay meterProvider/tracerProvider shutdown (no waterfall).
-        const loggerProvider = getLoggerProvider()
-        const tracerProvider = getTracerProvider()
-
-        const chains: Promise<void>[] = [meterProvider.shutdown()]
-        if (loggerProvider) {
-          chains.push(
-            loggerProvider.forceFlush().then(() => loggerProvider.shutdown()),
-          )
-        }
-        if (tracerProvider) {
-          chains.push(
-            tracerProvider.forceFlush().then(() => tracerProvider.shutdown()),
-          )
-        }
-
-        await Promise.race([
-          Promise.all(chains),
-          telemetryTimeout(timeoutMs, 'OpenTelemetry shutdown timeout'),
-        ])
-      } catch {
-        // Ignore shutdown errors
-      }
-    }
-    registerCleanup(shutdownTelemetry)
-
-    return meterProvider.getMeter('com.anthropic.claude_code', MACRO.VERSION)
-  }
-
-  const meterProvider = new MeterProvider({
-    resource,
-    views: [],
-    readers,
-  })
-
-  // Store reference in state for flushing
-  setMeterProvider(meterProvider)
-
-  // Initialize logs if telemetry is enabled
-  if (telemetryEnabled) {
-    const logExporters = await getOtlpLogExporters()
-    logForDebugging(
-      `[3P telemetry] Created ${logExporters.length} log exporter(s)`,
-    )
-
-    if (logExporters.length > 0) {
-      const loggerProvider = new LoggerProvider({
-        resource,
-        // Add batch processors for each exporter
-        processors: logExporters.map(
-          exporter =>
-            new BatchLogRecordProcessor(exporter, {
-              scheduledDelayMillis: parseInt(
-                process.env.OTEL_LOGS_EXPORT_INTERVAL ||
-                  DEFAULT_LOGS_EXPORT_INTERVAL_MS.toString(),
-              ),
-            }),
-        ),
-      })
-
-      // Register the logger provider globally
-      logs.setGlobalLoggerProvider(loggerProvider)
-      setLoggerProvider(loggerProvider)
-
-      // Initialize event logger
-      const eventLogger = logs.getLogger(
-        'com.anthropic.claude_code.events',
-        MACRO.VERSION,
-      )
-      setEventLogger(eventLogger)
-      logForDebugging('[3P telemetry] Event logger set successfully')
-
-      // 'beforeExit' is emitted when Node.js empties its event loop and has no additional work to schedule.
-      // Unlike 'exit', it allows us to perform async operations, so it works well for letting
-      // network requests complete before the process exits naturally.
-      process.on('beforeExit', async () => {
-        await loggerProvider?.forceFlush()
-        // Also flush traces - they use BatchSpanProcessor which needs explicit flush
-        const tracerProvider = getTracerProvider()
-        await tracerProvider?.forceFlush()
-      })
-
-      process.on('exit', () => {
-        // Final attempt to flush logs and traces
-        void loggerProvider?.forceFlush()
-        void getTracerProvider()?.forceFlush()
-      })
-    }
-  }
-
-  // Initialize tracing if enhanced telemetry is enabled (BETA)
-  if (telemetryEnabled && isEnhancedTelemetryEnabled()) {
-    const traceExporters = await getOtlpTraceExporters()
-    if (traceExporters.length > 0) {
-      // Create span processors for each exporter
-      const spanProcessors = traceExporters.map(
-        exporter =>
-          new BatchSpanProcessor(exporter, {
-            scheduledDelayMillis: parseInt(
-              process.env.OTEL_TRACES_EXPORT_INTERVAL ||
-                DEFAULT_TRACES_EXPORT_INTERVAL_MS.toString(),
-            ),
-          }),
-      )
-
-      const tracerProvider = new BasicTracerProvider({
-        resource,
-        spanProcessors,
-      })
-
-      // Register the tracer provider globally
-      trace.setGlobalTracerProvider(tracerProvider)
-      setTracerProvider(tracerProvider)
-    }
-  }
-
-  // Shutdown metrics and logs on exit (flushes and closes exporters)
-  const shutdownTelemetry = async () => {
-    const timeoutMs = parseInt(
-      process.env.CLAUDE_CODE_OTEL_SHUTDOWN_TIMEOUT_MS || '2000',
-    )
-
-    try {
-      // End any active interaction span before shutdown
-      endInteractionSpan()
-
-      const shutdownPromises = [meterProvider.shutdown()]
-      const loggerProvider = getLoggerProvider()
-      if (loggerProvider) {
-        shutdownPromises.push(loggerProvider.shutdown())
-      }
-      const tracerProvider = getTracerProvider()
-      if (tracerProvider) {
-        shutdownPromises.push(tracerProvider.shutdown())
-      }
-
-      await Promise.race([
-        Promise.all(shutdownPromises),
-        telemetryTimeout(timeoutMs, 'OpenTelemetry shutdown timeout'),
-      ])
-    } catch (error) {
-      if (error instanceof Error && error.message.includes('timeout')) {
-        logForDebugging(
-          `
-OpenTelemetry telemetry flush timed out after ${timeoutMs}ms
-
-To resolve this issue, you can:
-1. Increase the timeout by setting CLAUDE_CODE_OTEL_SHUTDOWN_TIMEOUT_MS env var (e.g., 5000 for 5 seconds)
-2. Check if your OpenTelemetry backend is experiencing scalability issues
-3. Disable OpenTelemetry by unsetting CLAUDE_CODE_ENABLE_TELEMETRY env var
-
-Current timeout: ${timeoutMs}ms
-`,
-          { level: 'error' },
-        )
-      }
-      throw error
-    }
-  }
-
-  // Always register shutdown (internal metrics are always enabled)
-  registerCleanup(shutdownTelemetry)
-
-  return meterProvider.getMeter('com.anthropic.claude_code', MACRO.VERSION)
-}
-
-/**
- * Flush all pending telemetry data immediately.
- * This should be called before logout or org switching to prevent data leakage.
- */
 export async function flushTelemetry(): Promise<void> {
-  const meterProvider = getMeterProvider()
-  if (!meterProvider) {
-    return
-  }
-
-  const timeoutMs = parseInt(
-    process.env.CLAUDE_CODE_OTEL_FLUSH_TIMEOUT_MS || '5000',
-  )
-
-  try {
-    const flushPromises = [meterProvider.forceFlush()]
-    const loggerProvider = getLoggerProvider()
-    if (loggerProvider) {
-      flushPromises.push(loggerProvider.forceFlush())
-    }
-    const tracerProvider = getTracerProvider()
-    if (tracerProvider) {
-      flushPromises.push(tracerProvider.forceFlush())
-    }
-
-    await Promise.race([
-      Promise.all(flushPromises),
-      telemetryTimeout(timeoutMs, 'OpenTelemetry flush timeout'),
-    ])
-
-    logForDebugging('Telemetry flushed successfully')
-  } catch (error) {
-    if (error instanceof TelemetryTimeoutError) {
-      logForDebugging(
-        `Telemetry flush timed out after ${timeoutMs}ms. Some metrics may not be exported.`,
-        { level: 'warn' },
-      )
-    } else {
-      logForDebugging(`Telemetry flush failed: ${errorMessage(error)}`, {
-        level: 'error',
-      })
-    }
-    // Don't throw - allow logout to continue even if flush fails
-  }
-}
-
-function parseOtelHeadersEnvVar(): Record<string, string> {
-  const headers: Record<string, string> = {}
-  const envHeaders = process.env.OTEL_EXPORTER_OTLP_HEADERS
-  if (envHeaders) {
-    for (const pair of envHeaders.split(',')) {
-      const [key, ...valueParts] = pair.split('=')
-      if (key && valueParts.length > 0) {
-        headers[key.trim()] = valueParts.join('=').trim()
-      }
-    }
-  }
-  return headers
-}
-
-/**
- * Get configuration for OTLP exporters including:
- * - HTTP agent options (proxy, mTLS)
- * - Dynamic headers via otelHeadersHelper or static headers from env var
- */
-function getOTLPExporterConfig() {
-  const proxyUrl = getProxyUrl()
-  const mtlsConfig = getMTLSConfig()
-  const settings = getSettings_DEPRECATED()
-
-  // Build base config
-  const config: Record<string, unknown> = {}
-
-  // Parse static headers from env var once (doesn't change at runtime)
-  const staticHeaders = parseOtelHeadersEnvVar()
-
-  // If otelHeadersHelper is configured, use async headers function for dynamic refresh
-  // Otherwise just return static headers if any exist
-  if (settings?.otelHeadersHelper) {
-    config.headers = async (): Promise<Record<string, string>> => {
-      const dynamicHeaders = getOtelHeadersFromHelper()
-      return { ...staticHeaders, ...dynamicHeaders }
-    }
-  } else if (Object.keys(staticHeaders).length > 0) {
-    config.headers = async (): Promise<Record<string, string>> => staticHeaders
-  }
-
-  // Check if we should bypass proxy for OTEL endpoint
-  const otelEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT
-  if (!proxyUrl || (otelEndpoint && shouldBypassProxy(otelEndpoint))) {
-    // No proxy configured or OTEL endpoint should bypass proxy
-    const caCerts = getCACertificates()
-    if (mtlsConfig || caCerts) {
-      config.httpAgentOptions = {
-        ...mtlsConfig,
-        ...(caCerts && { ca: caCerts }),
-      }
-    }
-    return config
-  }
-
-  // Return an HttpAgentFactory function that creates our proxy agent
-  const caCerts = getCACertificates()
-  const agentFactory = (_protocol: string) => {
-    // Create and return the proxy agent with mTLS and CA cert config
-    const proxyAgent =
-      mtlsConfig || caCerts
-        ? new HttpsProxyAgent(proxyUrl, {
-            ...(mtlsConfig && {
-              cert: mtlsConfig.cert,
-              key: mtlsConfig.key,
-              passphrase: mtlsConfig.passphrase,
-            }),
-            ...(caCerts && { ca: caCerts }),
-          })
-        : new HttpsProxyAgent(proxyUrl)
-
-    return proxyAgent
-  }
-
-  config.httpAgentOptions = agentFactory
-  return config
+  return
 }