@clinebot/core 0.0.4 → 0.0.6

package/src/session/default-session-manager.ts

@@ -14,15 +14,14 @@ import {
 	type ToolApprovalResult,
 } from "@clinebot/agents";
 import type { providers as LlmsProviders } from "@clinebot/llms";
-import { formatUserInputBlock, normalizeUserInput } from "@clinebot/shared";
+import {
+	formatUserInputBlock,
+	type ITelemetryService,
+	normalizeUserInput,
+} from "@clinebot/shared";
 import { setHomeDirIfUnset } from "@clinebot/shared/storage";
 import { nanoid } from "nanoid";
 import { resolveAndLoadAgentPlugins } from "../agents/plugin-config-loader";
-import {
-	createBuiltinTools,
-	type ToolExecutors,
-	ToolPresets,
-} from "../default-tools";
 import { enrichPromptWithMentions } from "../input";
 import {
 	createHookAuditHooks,
@@ -36,6 +35,7 @@ import {
 	buildTeamProgressSummary,
 	toTeamProgressLifecycleEvent,
 } from "../team";
+import { createBuiltinTools, type ToolExecutors, ToolPresets } from "../tools";
 import { SessionSource, type SessionStatus } from "../types/common";
 import type { CoreSessionConfig } from "../types/config";
 import type { CoreSessionEvent } from "../types/events";
@@ -93,6 +93,7 @@ export interface DefaultSessionManagerOptions {
 	toolPolicies?: AgentConfig["toolPolicies"];
 	providerSettingsManager?: ProviderSettingsManager;
 	oauthTokenManager?: RuntimeOAuthTokenManager;
+	telemetry?: ITelemetryService;
 	requestToolApproval?: (
 		request: ToolApprovalRequest,
 	) => Promise<ToolApprovalResult>;
@@ -124,6 +125,7 @@ export class DefaultSessionManager implements SessionManager {
 	private readonly defaultToolPolicies?: AgentConfig["toolPolicies"];
 	private readonly providerSettingsManager: ProviderSettingsManager;
 	private readonly oauthTokenManager: RuntimeOAuthTokenManager;
+	private readonly defaultTelemetry?: ITelemetryService;
 	private readonly defaultRequestToolApproval?: (
 		request: ToolApprovalRequest,
 	) => Promise<ToolApprovalResult>;
@@ -147,6 +149,7 @@ export class DefaultSessionManager implements SessionManager {
 			new RuntimeOAuthTokenManager({
 				providerSettingsManager: this.providerSettingsManager,
 			});
+		this.defaultTelemetry = options.telemetry;
 		this.defaultRequestToolApproval = options.requestToolApproval;
 	}
 
@@ -267,6 +270,7 @@ export class DefaultSessionManager implements SessionManager {
 			...input.config,
 			hooks: effectiveHooks,
 			extensions: effectiveExtensions,
+			telemetry: input.config.telemetry ?? this.defaultTelemetry,
 		};
 		const providerConfig =
 			this.buildResolvedProviderConfig(effectiveConfigBase);
@@ -280,6 +284,7 @@ export class DefaultSessionManager implements SessionManager {
 			hooks: effectiveHooks,
 			extensions: effectiveExtensions,
 			logger: effectiveConfig.logger,
+			telemetry: effectiveConfig.telemetry,
 			onTeamEvent: (event: TeamEvent) => {
 				void this.handleTeamEvent(sessionId, event);
 				effectiveConfig.onTeamEvent?.(event);
@@ -291,6 +296,18 @@ export class DefaultSessionManager implements SessionManager {
 				input.defaultToolExecutors ?? this.defaultToolExecutors,
 		});
 		const tools = [...runtime.tools, ...(effectiveConfig.extraTools ?? [])];
+		effectiveConfig.telemetry?.capture({
+			event: "session.started",
+			properties: {
+				sessionId,
+				source,
+				providerId: effectiveConfig.providerId,
+				modelId: effectiveConfig.modelId,
+				enableTools: effectiveConfig.enableTools,
+				enableSpawnAgent: effectiveConfig.enableSpawnAgent,
+				enableAgentTeams: effectiveConfig.enableAgentTeams,
+			},
+		});
 		const agent = this.createAgentInstance({
 			providerId: providerConfig.providerId,
 			modelId: providerConfig.modelId,
@@ -330,6 +347,14 @@ export class DefaultSessionManager implements SessionManager {
 						}),
 					);
 				}
+				if (event.type === "iteration_end") {
+					void this.invoke<void>(
+						"persistSessionMessages",
+						sessionId,
+						liveSession?.agent.getMessages() ?? [],
+						liveSession?.config.systemPrompt,
+					);
+				}
 				this.emit({
 					type: "agent_event",
 					payload: {
@@ -401,6 +426,15 @@ export class DefaultSessionManager implements SessionManager {
 		if (!session) {
 			throw new Error(`session not found: ${input.sessionId}`);
 		}
+		session.config.telemetry?.capture({
+			event: "session.input_sent",
+			properties: {
+				sessionId: input.sessionId,
+				promptLength: input.prompt.length,
+				userImageCount: input.userImages?.length ?? 0,
+				userFileCount: input.userFiles?.length ?? 0,
+			},
+		});
 		try {
 			const result = await this.runTurn(session, {
 				prompt: input.prompt,
@@ -432,6 +466,10 @@ export class DefaultSessionManager implements SessionManager {
 		if (!session) {
 			return;
 		}
+		session.config.telemetry?.capture({
+			event: "session.aborted",
+			properties: { sessionId },
+		});
 		session.aborting = true;
 		session.agent.abort();
 	}
@@ -441,6 +479,10 @@ export class DefaultSessionManager implements SessionManager {
 		if (!session) {
 			return;
 		}
+		session.config.telemetry?.capture({
+			event: "session.stopped",
+			properties: { sessionId },
+		});
 		await this.shutdownSession(session, {
 			status: "cancelled",
 			exitCode: null,
@@ -565,6 +607,9 @@ export class DefaultSessionManager implements SessionManager {
 		if (!prompt) {
 			throw new Error("prompt cannot be empty");
 		}
+		if (!session.artifacts && !session.pendingPrompt) {
+			session.pendingPrompt = prompt;
+		}
 		await this.ensureSessionPersisted(session);
 		await this.syncOAuthCredentials(session);
 
@@ -1201,4 +1246,16 @@ export class DefaultSessionManager implements SessionManager {
 			apiKey: resolved.apiKey,
 		});
 	}
+
+	async updateSessionModel(sessionId: string, modelId: string): Promise<void> {
+		const session = this.sessions.get(sessionId);
+		if (!session) {
+			throw new Error(`session not found: ${sessionId}`);
+		}
+		session.config.modelId = modelId;
+		const agentWithConnection = session.agent as Agent & {
+			updateConnection?: (overrides: { modelId?: string }) => void;
+		};
+		agentWithConnection.updateConnection?.({ modelId });
+	}
 }

package/src/session/session-host.ts

@@ -7,10 +7,11 @@ import type {
 	ToolApprovalResult,
 } from "@clinebot/agents";
 import { getRpcServerDefaultAddress, getRpcServerHealth } from "@clinebot/rpc";
+import type { ITelemetryService } from "@clinebot/shared";
 import { resolveSessionDataDir } from "@clinebot/shared/storage";
 import { nanoid } from "nanoid";
-import type { ToolExecutors } from "../default-tools";
 import { SqliteSessionStore } from "../storage/sqlite-session-store";
+import type { ToolExecutors } from "../tools";
 import { DefaultSessionManager } from "./default-session-manager";
 import { RpcCoreSessionService } from "./rpc-session-service";
 import type { SessionManager } from "./session-manager";
@@ -33,6 +34,7 @@ export interface CreateSessionHostOptions {
 	rpcConnectAttempts?: number;
 	rpcConnectDelayMs?: number;
 	defaultToolExecutors?: Partial<ToolExecutors>;
+	telemetry?: ITelemetryService;
 	toolPolicies?: AgentConfig["toolPolicies"];
 	requestToolApproval?: (
 		request: ToolApprovalRequest,
@@ -190,13 +192,16 @@ export async function resolveSessionBackend(
 export async function createSessionHost(
 	options: CreateSessionHostOptions,
 ): Promise<SessionHost> {
+	const distinctId = resolveHostDistinctId(options.distinctId);
+	options.telemetry?.setDistinctId(distinctId);
 	const backend =
 		options.sessionService ?? (await resolveSessionBackend(options));
 	return new DefaultSessionManager({
 		sessionService: backend,
 		defaultToolExecutors: options.defaultToolExecutors,
+		telemetry: options.telemetry,
 		toolPolicies: options.toolPolicies,
 		requestToolApproval: options.requestToolApproval,
-		distinctId: resolveHostDistinctId(options.distinctId),
+		distinctId,
 	});
 }

package/src/session/session-manager.ts

@@ -16,7 +16,7 @@ export interface StartSessionInput {
 	userFiles?: string[];
 	userInstructionWatcher?: import("../agents").UserInstructionConfigWatcher;
 	onTeamRestored?: () => void;
-	defaultToolExecutors?: Partial<import("../default-tools").ToolExecutors>;
+	defaultToolExecutors?: Partial<import("../tools").ToolExecutors>;
 	toolPolicies?: import("@clinebot/agents").AgentConfig["toolPolicies"];
 	requestToolApproval?: (
 		request: import("@clinebot/agents").ToolApprovalRequest,
@@ -64,4 +64,5 @@ export interface SessionManager {
 	readTranscript(sessionId: string, maxChars?: number): Promise<string>;
 	readHooks(sessionId: string, limit?: number): Promise<unknown[]>;
 	subscribe(listener: (event: CoreSessionEvent) => void): () => void;
+	updateSessionModel?(sessionId: string, modelId: string): Promise<void>;
 }

package/src/session/unified-session-persistence-service.ts

@@ -10,7 +10,7 @@ import type {
 	SubAgentStartContext,
 } from "@clinebot/agents";
 import type { providers as LlmsProviders } from "@clinebot/llms";
-import { resolveRootSessionId } from "@clinebot/shared";
+import { normalizeUserInput, resolveRootSessionId } from "@clinebot/shared";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 import type { SessionStatus } from "../types/common";
@@ -48,6 +48,58 @@ function stringifyMetadataJson(
 	return JSON.stringify(metadata);
 }
 
+function normalizeSessionTitle(title?: string | null): string | undefined {
+	const trimmed = title?.trim();
+	return trimmed ? trimmed.slice(0, 120) : undefined;
+}
+
+function deriveSessionTitleFromPrompt(
+	prompt?: string | null,
+): string | undefined {
+	const normalizedPrompt = normalizeUserInput(prompt ?? "").trim();
+	if (!normalizedPrompt) {
+		return undefined;
+	}
+	const firstLine = normalizedPrompt.split("\n")[0]?.trim();
+	return normalizeSessionTitle(firstLine);
+}
+
+function normalizeMetadataForStorage(
+	metadata: Record<string, unknown> | null | undefined,
+): Record<string, unknown> | undefined {
+	if (!metadata) {
+		return undefined;
+	}
+	const next = { ...metadata };
+	if (typeof next.title === "string") {
+		const normalizedTitle = normalizeSessionTitle(next.title);
+		if (normalizedTitle) {
+			next.title = normalizedTitle;
+		} else {
+			delete next.title;
+		}
+	} else {
+		delete next.title;
+	}
+	return Object.keys(next).length > 0 ? next : undefined;
+}
+
+function metadataWithResolvedTitle(input: {
+	metadata?: Record<string, unknown> | null;
+	title?: string | null;
+	prompt?: string | null;
+}): Record<string, unknown> | undefined {
+	const next = { ...(normalizeMetadataForStorage(input.metadata) ?? {}) };
+	const resolvedTitle =
+		input.title !== undefined
+			? normalizeSessionTitle(input.title)
+			: deriveSessionTitleFromPrompt(input.prompt);
+	if (resolvedTitle) {
+		next.title = resolvedTitle;
+	}
+	return Object.keys(next).length > 0 ? next : undefined;
+}
+
 export interface PersistedSessionUpdateInput {
 	sessionId: string;
 	expectedStatusLock?: number;
@@ -56,6 +108,7 @@ export interface PersistedSessionUpdateInput {
 	exitCode?: number | null;
 	prompt?: string | null;
 	metadataJson?: string | null;
+	title?: string | null;
 	parentSessionId?: string | null;
 	parentAgentId?: string | null;
 	agentId?: string | null;
@@ -173,6 +226,63 @@ export class UnifiedSessionPersistenceService {
 		);
 	}
 
+	private readSessionManifestFile(sessionId: string): {
+		path: string;
+		manifest?: SessionManifest;
+	} {
+		const manifestPath = this.sessionManifestPath(sessionId, false);
+		if (!existsSync(manifestPath)) {
+			return { path: manifestPath };
+		}
+		try {
+			const manifest = SessionManifestSchema.parse(
+				JSON.parse(readFileSync(manifestPath, "utf8")) as SessionManifest,
+			);
+			return { path: manifestPath, manifest };
+		} catch {
+			return { path: manifestPath };
+		}
+	}
+
+	private applyResolvedTitleToRow(row: SessionRowShape): SessionRowShape {
+		const existingMetadata =
+			typeof row.metadata_json === "string" &&
+			row.metadata_json.trim().length > 0
+				? (() => {
+						try {
+							const parsed = JSON.parse(row.metadata_json) as unknown;
+							if (
+								parsed &&
+								typeof parsed === "object" &&
+								!Array.isArray(parsed)
+							) {
+								return parsed as Record<string, unknown>;
+							}
+						} catch {
+							// Ignore malformed metadata payloads.
+						}
+						return undefined;
+					})()
+				: undefined;
+		const sanitizedMetadata = normalizeMetadataForStorage(existingMetadata);
+		const { manifest } = this.readSessionManifestFile(row.session_id);
+		const manifestTitle = normalizeSessionTitle(
+			typeof manifest?.metadata?.title === "string"
+				? (manifest.metadata.title as string)
+				: undefined,
+		);
+		const resolvedMetadata = manifestTitle
+			? {
+					...(sanitizedMetadata ?? {}),
+					title: manifestTitle,
+				}
+			: sanitizedMetadata;
+		return {
+			...row,
+			metadata_json: stringifyMetadataJson(resolvedMetadata),
+		};
+	}
+
 	private createRootSessionId(): string {
 		return `${Date.now()}_${nanoid(5)}`;
 	}
@@ -207,9 +317,13 @@ export class UnifiedSessionPersistenceService {
 			enable_spawn: input.enableSpawn,
 			enable_teams: input.enableTeams,
 			prompt: input.prompt?.trim() || undefined,
-			metadata: input.metadata,
+			metadata: metadataWithResolvedTitle({
+				metadata: input.metadata,
+				prompt: input.prompt,
+			}),
 			messages_path: messagesPath,
 		});
+		const storedMetadata = normalizeMetadataForStorage(manifest.metadata);
 
 		await this.adapter.upsertSession({
 			session_id: sessionId,
@@ -235,7 +349,7 @@ export class UnifiedSessionPersistenceService {
 			conversation_id: null,
 			is_subagent: 0,
 			prompt: manifest.prompt ?? null,
-			metadata_json: stringifyMetadataJson(manifest.metadata),
+			metadata_json: stringifyMetadataJson(storedMetadata),
 			transcript_path: transcriptPath,
 			hook_path: hookPath,
 			messages_path: messagesPath,
@@ -293,40 +407,86 @@ export class UnifiedSessionPersistenceService {
 		sessionId: string;
 		prompt?: string | null;
 		metadata?: Record<string, unknown> | null;
+		title?: string | null;
 	}): Promise<{ updated: boolean }> {
 		for (let attempt = 0; attempt < 4; attempt++) {
 			const row = await this.adapter.getSession(input.sessionId);
 			if (!row || typeof row.status_lock !== "number") {
 				return { updated: false };
 			}
+			const sanitizedMetadata =
+				input.metadata === undefined
+					? undefined
+					: normalizeMetadataForStorage(input.metadata);
+			const existingMetadata = (() => {
+				const raw = row.metadata_json?.trim();
+				if (!raw) {
+					return undefined;
+				}
+				try {
+					const parsed = JSON.parse(raw) as unknown;
+					if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+						return normalizeMetadataForStorage(
+							parsed as Record<string, unknown>,
+						);
+					}
+				} catch {
+					// Ignore malformed metadata payloads.
+				}
+				return undefined;
+			})();
+			const existingTitle = normalizeSessionTitle(
+				typeof existingMetadata?.title === "string"
+					? (existingMetadata.title as string)
+					: undefined,
+			);
+			const nextTitle =
+				input.title !== undefined
+					? normalizeSessionTitle(input.title)
+					: input.prompt !== undefined
+						? deriveSessionTitleFromPrompt(input.prompt)
+						: existingTitle;
+			const nextMetadata =
+				input.metadata !== undefined
+					? { ...(sanitizedMetadata ?? {}) }
+					: { ...(existingMetadata ?? {}) };
+			if (nextTitle) {
+				nextMetadata.title = nextTitle;
+			} else {
+				delete nextMetadata.title;
+			}
 			const changed = await this.adapter.updateSession({
 				sessionId: input.sessionId,
 				prompt: input.prompt,
 				metadataJson:
-					input.metadata === undefined
+					input.metadata === undefined &&
+					input.prompt === undefined &&
+					input.title === undefined
 						? undefined
-						: stringifyMetadataJson(input.metadata),
+						: stringifyMetadataJson(nextMetadata),
+				title: nextTitle,
 				expectedStatusLock: row.status_lock,
 			});
 			if (!changed.updated) {
 				continue;
 			}
-			const manifestPath = this.sessionManifestPath(input.sessionId, false);
-			if (existsSync(manifestPath)) {
-				try {
-					const manifest = SessionManifestSchema.parse(
-						JSON.parse(readFileSync(manifestPath, "utf8")) as SessionManifest,
-					);
-					if (input.prompt !== undefined) {
-						manifest.prompt = input.prompt ?? undefined;
-					}
-					if (input.metadata !== undefined) {
-						manifest.metadata = input.metadata ?? undefined;
-					}
-					this.writeSessionManifestFile(manifestPath, manifest);
-				} catch {
-					// Ignore malformed manifests and keep backend session state as source of truth.
+			const { path: manifestPath, manifest } = this.readSessionManifestFile(
+				input.sessionId,
+			);
+			if (manifest) {
+				if (input.prompt !== undefined) {
+					manifest.prompt = input.prompt ?? undefined;
+				}
+				const nextMetadata =
+					input.metadata !== undefined
+						? { ...(normalizeMetadataForStorage(input.metadata) ?? {}) }
+						: { ...(normalizeMetadataForStorage(manifest.metadata) ?? {}) };
+				if (nextTitle) {
+					nextMetadata.title = nextTitle;
 				}
+				manifest.metadata =
+					Object.keys(nextMetadata).length > 0 ? nextMetadata : undefined;
+				this.writeSessionManifestFile(manifestPath, manifest);
 			}
 			return { updated: true };
 		}
@@ -422,7 +582,9 @@ export class UnifiedSessionPersistenceService {
 				conversation_id: input.conversationId,
 				is_subagent: 1,
 				prompt,
-				metadata_json: null,
+				metadata_json: stringifyMetadataJson(
+					metadataWithResolvedTitle({ prompt }),
+				),
 				transcript_path: artifactPaths.transcriptPath,
 				hook_path: artifactPaths.hookPath,
 				messages_path: artifactPaths.messagesPath,
@@ -444,6 +606,30 @@ export class UnifiedSessionPersistenceService {
 			agentId: input.agentId,
 			conversationId: input.conversationId,
 			prompt: existing.prompt ?? prompt ?? null,
+			metadataJson: stringifyMetadataJson(
+				metadataWithResolvedTitle({
+					metadata: (() => {
+						const raw = existing.metadata_json?.trim();
+						if (!raw) {
+							return undefined;
+						}
+						try {
+							const parsed = JSON.parse(raw) as unknown;
+							if (
+								parsed &&
+								typeof parsed === "object" &&
+								!Array.isArray(parsed)
+							) {
+								return parsed as Record<string, unknown>;
+							}
+						} catch {
+							// Ignore malformed metadata payloads.
+						}
+						return undefined;
+					})(),
+					prompt: existing.prompt ?? prompt ?? null,
+				}),
+			),
 			expectedStatusLock: existing.status_lock,
 		});
 		return sessionId;
@@ -601,7 +787,9 @@ export class UnifiedSessionPersistenceService {
 			conversation_id: null,
 			is_subagent: 1,
 			prompt: message || `Team task for ${agentId}`,
-			metadata_json: null,
+			metadata_json: stringifyMetadataJson(
+				metadataWithResolvedTitle({ prompt: message }),
+			),
 			transcript_path: transcriptPath,
 			hook_path: hookPath,
 			messages_path: messagesPath,
@@ -750,7 +938,9 @@ export class UnifiedSessionPersistenceService {
 			}
 			rows = await this.adapter.listSessions({ limit: scanLimit });
 		}
-		return rows.slice(0, requestedLimit);
+		return rows
+			.slice(0, requestedLimit)
+			.map((row) => this.applyResolvedTitleToRow(row));
 	}
 
 	async deleteSession(sessionId: string): Promise<{ deleted: boolean }> {

package/src/telemetry/ITelemetryAdapter.ts

@@ -0,0 +1,94 @@
+/**
+ * Telemetry adapter interface for the @clinebot/core SDK.
+ *
+ * This is the SDK-side counterpart to the extension's ITelemetryProvider.
+ * It is intentionally free of VS Code / host-provider dependencies so that
+ * any consumer (CLI, tests, third-party integrations) can plug in their own
+ * backend without pulling in the full extension runtime.
+ */
+
+import type { TelemetryProperties } from "@clinebot/shared";
+
+export type {
+	TelemetryArray,
+	TelemetryMetadata,
+	TelemetryObject,
+	TelemetryPrimitive,
+	TelemetryProperties,
+	TelemetryValue,
+} from "@clinebot/shared";
+
+// ---------------------------------------------------------------------------
+// Adapter interface
+// ---------------------------------------------------------------------------
+
+/**
+ * Telemetry adapter that an SDK consumer implements (or uses via the
+ * provided {@link OpenTelemetryAdapter}) to receive Cline telemetry events.
+ *
+ * The interface intentionally mirrors ITelemetryProvider from the extension
+ * so that shared logic can be re-used or compared easily.
+ */
+export interface ITelemetryAdapter {
+	/** Human-readable adapter name used for logging / diagnostics. */
+	readonly name: string;
+
+	/**
+	 * Emit a standard telemetry event.
+	 * Implementations may silently drop events when telemetry is disabled.
+	 */
+	emit(event: string, properties?: TelemetryProperties): void;
+
+	/**
+	 * Emit a *required* telemetry event that must not be suppressed by
+	 * user opt-out settings (e.g. final opt-out confirmation events).
+	 */
+	emitRequired(event: string, properties?: TelemetryProperties): void;
+
+	/**
+	 * Record a monotonically-increasing counter metric.
+	 * Implementations that do not support metrics may treat this as a no-op.
+	 */
+	recordCounter(
+		name: string,
+		value: number,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required?: boolean,
+	): void;
+
+	/**
+	 * Record a histogram (distribution) metric.
+	 * Implementations that do not support metrics may treat this as a no-op.
+	 */
+	recordHistogram(
+		name: string,
+		value: number,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required?: boolean,
+	): void;
+
+	/**
+	 * Record a gauge (point-in-time) metric.
+	 * Pass `null` as `value` to retire the series identified by
+	 * `name + attributes` and prevent stale gauge entries.
+	 * Implementations that do not support metrics may treat this as a no-op.
+	 */
+	recordGauge(
+		name: string,
+		value: number | null,
+		attributes?: TelemetryProperties,
+		description?: string,
+		required?: boolean,
+	): void;
+
+	/** Returns whether the adapter is currently accepting events. */
+	isEnabled(): boolean;
+
+	/** Flush any buffered events/metrics to the backend. */
+	flush(): Promise<void>;
+
+	/** Release all resources held by the adapter. */
+	dispose(): Promise<void>;
+}

package/src/telemetry/LoggerTelemetryAdapter.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it, vi } from "vitest";
+import { LoggerTelemetryAdapter } from "./LoggerTelemetryAdapter";
+
+describe("LoggerTelemetryAdapter", () => {
+	it("logs events and metrics through the provided logger", async () => {
+		const logger = {
+			debug: vi.fn(),
+			info: vi.fn(),
+			warn: vi.fn(),
+		};
+		const adapter = new LoggerTelemetryAdapter({ logger });
+
+		adapter.emit("session.started", { sessionId: "s1" });
+		adapter.emitRequired("user.opt_out", { reason: "manual" });
+		adapter.recordCounter("cline.session.starts.total", 1, {
+			sessionId: "s1",
+		});
+
+		expect(logger.info).toHaveBeenCalledWith("telemetry.event", {
+			adapter: "LoggerTelemetryAdapter",
+			event: "session.started",
+			properties: { sessionId: "s1" },
+		});
+		expect(logger.warn).toHaveBeenCalledWith("telemetry.required_event", {
+			adapter: "LoggerTelemetryAdapter",
+			event: "user.opt_out",
+			properties: { reason: "manual" },
+		});
+		expect(logger.debug).toHaveBeenCalledWith("telemetry.metric", {
+			adapter: "LoggerTelemetryAdapter",
+			instrument: "counter",
+			name: "cline.session.starts.total",
+			value: 1,
+			attributes: { sessionId: "s1" },
+			description: undefined,
+			required: false,
+		});
+
+		await adapter.flush();
+		await adapter.dispose();
+	});
+});