feat(telemetry): wire up telemetry to Event Bus and bootstrap

Complete the telemetry integration with OpenCode:

Integration module (integration.ts):
- Subscribe to Session, Message, and File events from Event Bus
- Automatic tracking of sessions, turns, tool calls, and file changes
- Uses Instance.state for automatic cleanup on disposal
- Graceful shutdown flushes pending telemetry data

Bootstrap integration:
- Initialize telemetry during InstanceBootstrap
- Telemetry is now automatically enabled on startup (respects consent)
- Errors during initialization are logged but don't block startup

Exports:
- Telemetry.initIntegration() - Initialize with Event Bus integration
- Telemetry.shutdownIntegration() - Explicit shutdown (automatic via Instance.dispose)
- Telemetry.completeTurn() - Finalize assistant response
- Telemetry.userMessage() - Record user input
- Telemetry.retry() - Record turn retry

Implements: [CodeQ] Wire up telemetry module

Author: Kenny-Heitritter

packages/opencode/src/project/bootstrap.ts

@@ -13,6 +13,7 @@ import { Log } from "@/util/log"
 import { ShareNext } from "@/share/share-next"
 import { Snapshot } from "../snapshot"
 import { Truncate } from "../tool/truncation"
+import { Telemetry } from "@/telemetry"
 
 export async function InstanceBootstrap() {
   Log.Default.info("bootstrapping", { directory: Instance.directory })
@@ -27,6 +28,12 @@ export async function InstanceBootstrap() {
   Snapshot.init()
   Truncate.init()
 
+  // Initialize qBraid telemetry (CodeQ-specific)
+  // This is a no-op if telemetry is disabled by consent or config
+  await Telemetry.initIntegration().catch((error) => {
+    Log.Default.warn("telemetry initialization failed", { error })
+  })
+
   Bus.subscribe(Command.Event.Executed, async (payload) => {
     if (payload.properties.name === Command.Default.INIT) {
       await Project.setInitialized(Instance.project.id)

packages/opencode/src/telemetry/index.ts

@@ -7,7 +7,10 @@
  * Usage:
  *   import { Telemetry } from "./telemetry"
  *
- *   // Initialize at startup
+ *   // Initialize at startup (with Event Bus integration)
+ *   await Telemetry.initIntegration()
+ *
+ *   // Or initialize manually without Event Bus
  *   await Telemetry.initialize(authToken)
  *
  *   // Start a session
@@ -33,14 +36,43 @@ import {
   type TelemetryCollector,
 } from "./collector"
 import { getConsentStatus, isTelemetryEnabled, clearConsentCache } from "./consent"
+import {
+  initTelemetryIntegration,
+  shutdownTelemetryIntegration,
+  finalizeTurn,
+  recordUserTurn,
+  recordRetry,
+} from "./integration"
 import type { ConsentStatus, TelemetrySession, TelemetryTurn } from "./types"
 
 export namespace Telemetry {
   /**
-   * Initialize the telemetry system
+   * Initialize the telemetry system with Event Bus integration
+   *
+   * This is the recommended way to initialize telemetry. It:
+   * - Checks consent based on user tier
+   * - Subscribes to relevant Event Bus events
+   * - Automatically tracks sessions, messages, tool calls, and file changes
+   */
+  export async function initIntegration(): Promise<void> {
+    await initTelemetryIntegration()
+  }
+
+  /**
+   * Shutdown the telemetry system with Event Bus integration
+   *
+   * Unsubscribes from events and flushes pending data.
+   * Should be called on application exit.
+   */
+  export async function shutdownIntegration(): Promise<void> {
+    await shutdownTelemetryIntegration()
+  }
+
+  /**
+   * Initialize the telemetry system (manual mode, no Event Bus)
    *
-   * Must be called before any other telemetry functions.
-   * Will check consent and configure collection accordingly.
+   * Use this if you want to manually control telemetry collection
+   * without automatic Event Bus integration.
    *
    * @param authToken - Optional qBraid auth token for consent lookup
    */
@@ -49,7 +81,7 @@ export namespace Telemetry {
   }
 
   /**
-   * Shutdown the telemetry system
+   * Shutdown the telemetry system (manual mode)
    *
    * Flushes any pending data and cleans up resources.
    * Should be called on application exit.
@@ -58,6 +90,26 @@ export namespace Telemetry {
     await shutdownTelemetry()
   }
 
+  /**
+   * Finalize a turn when assistant response is complete
+   *
+   * Called to record the assistant's response and complete the turn.
+   * This should be called after the LLM streaming is complete.
+   */
+  export const completeTurn = finalizeTurn
+
+  /**
+   * Record a user message (start of a turn)
+   *
+   * Use this for manual recording when not using Event Bus integration.
+   */
+  export const userMessage = recordUserTurn
+
+  /**
+   * Record that a turn was retried
+   */
+  export const retry = recordRetry
+
   /**
    * Start collecting for a new session
    *