@cerebriline/core 4.100.240

package/dist/services/providers/provider-config-fields.d.ts

@@ -0,0 +1,37 @@
+export type ProviderConfigFieldKey = "apiKey" | "baseUrl" | "azureApiVersion" | "awsRegion" | "awsProfile" | "gcpProjectId" | "gcpRegion" | "sapClientId" | "sapClientSecret" | "sapTokenUrl" | "sapResourceGroup" | "sapDeploymentId";
+export interface ProviderConfigFieldRequirement {
+    defaultValue?: string;
+    label?: string;
+    note?: string;
+    placeholder?: string;
+    optional?: boolean;
+}
+export interface ProviderConfigFields {
+    providerId: string;
+    authMethod: "api-key" | "oauth" | "local";
+    fields: Partial<Record<ProviderConfigFieldKey, ProviderConfigFieldRequirement>>;
+    /** Optional description shown above the fields (e.g. AWS region auto-fill hint). */
+    description?: string;
+}
+/**
+ * Project a provider into the inputs a configure-dialog should render.
+ *
+ * No fields are marked "required". `llms` no longer pre-flights credentials,
+ * so a missing API key surfaces as the provider's own auth error rather than
+ * a synthetic SDK failure. UIs may still require fields client-side if they
+ * want, but the runtime does not.
+ *
+ * - OAuth providers (`cline`, `oca`, `openai-codex`) return `authMethod:
+ *   "oauth"` with no fields; the configure UI should route to the OAuth
+ *   login flow instead.
+ * - Local auth providers return `authMethod: "local"` with no fields. The
+ *   configure UI should show provider-specific local readiness instead.
+ * - All other providers return `apiKey`. Built-in local/proxy-style providers
+ *   with user-supplied endpoints, plus user-added providers with saved
+ *   endpoints, also return a pre-filled `baseUrl` field.
+ *
+ * Returns the same fallback shape for unknown providers (single `apiKey`
+ * input, no default base URL) so callers can render a reasonable configure
+ * dialog without per-id branches.
+ */
+export declare function getProviderConfigFields(providerId: string): ProviderConfigFields;

package/dist/services/providers/provider-readiness.d.ts

@@ -0,0 +1,10 @@
+import type { ProviderConfig, ProviderSettings } from "../llms/provider-settings";
+/**
+ * Whether persisted provider settings hold enough real credentials or
+ * endpoint configuration for a turn to plausibly succeed. Unlike the mere
+ * existence of a settings entry (which migrations and empty "connect" saves
+ * can create), this requires provider-appropriate evidence: an API key or
+ * OAuth token, cloud credentials (AWS/GCP/Azure/SAP), a local-auth CLI, or a
+ * resolvable endpoint + model for keyless local providers.
+ */
+export declare function isProviderSettingsUsable(providerId: string, settings: ProviderSettings | undefined, config?: Pick<ProviderConfig, "baseUrl" | "modelId">): boolean;

package/dist/services/session-artifacts.d.ts

@@ -0,0 +1,18 @@
+export declare function nowIso(): string;
+export declare function unlinkIfExists(path: string | null | undefined): void;
+export interface SessionArtifactPaths {
+    messagesPath: string;
+}
+export declare class SessionArtifacts {
+    private readonly ensureSessionsDir;
+    constructor(ensureSessionsDir: () => string);
+    sessionArtifactsDir(sessionId: string): string;
+    ensureSessionArtifactsDir(sessionId: string): string;
+    sessionMessagesPath(sessionId: string): string;
+    sessionCompactionPath(sessionId: string): string;
+    sessionManifestPath(sessionId: string, ensureDir?: boolean): string;
+    removeSessionDirIfEmpty(sessionId: string): void;
+    removeSessionDir(sessionId: string): void;
+    removeDir(dir: string): void;
+    subagentArtifactPaths(sessionId: string, subAgentId: string, activeTeamTaskSessionId?: string): SessionArtifactPaths;
+}

package/dist/services/session-data.d.ts

@@ -0,0 +1,61 @@
+import type * as LlmsProviders from "@cerebriline/llms";
+import type { AgentConfig, AgentEvent, AgentResult } from "@cerebriline/shared";
+import { type SessionManifest } from "../session/models/session-manifest";
+import type { SessionRow } from "../session/models/session-row";
+import type { SessionStatus } from "../types/common";
+import type { StoredMessageWithMetadata } from "../types/session";
+import type { SessionRecord } from "../types/sessions";
+export declare function hasRuntimeHooks(hooks: AgentConfig["hooks"]): boolean;
+export declare function mergeAgentExtensions(explicitExtensions: AgentConfig["extensions"] | undefined, loadedExtensions: AgentConfig["extensions"] | undefined): AgentConfig["extensions"];
+export declare function serializeAgentEvent(event: AgentEvent): string;
+export declare function normalizeStoredMessagesForPersistence(messages: LlmsProviders.MessageWithMetadata[]): StoredMessageWithMetadata[];
+export declare function withLatestAssistantTurnMetadata(messages: LlmsProviders.Message[], result: AgentResult, previousMessages?: LlmsProviders.MessageWithMetadata[]): StoredMessageWithMetadata[];
+export declare function toSessionRecord(row: SessionRow): SessionRecord;
+export declare function normalizeTitle(title?: string | null): string | undefined;
+export declare function deriveTitleFromPrompt(prompt?: string | null): string | undefined;
+export declare function sanitizeMetadata(metadata: Record<string, unknown> | null | undefined): Record<string, unknown> | undefined;
+export declare function resolveMetadataWithTitle(input: {
+    metadata?: Record<string, unknown> | null;
+    title?: string | null;
+    prompt?: string | null;
+}): Record<string, unknown> | undefined;
+export type MessagesFileContext = {
+    agent: "lead" | "subagent" | "teammate";
+    sessionId: string;
+    taskType?: string;
+    origin: {
+        source: string;
+        mode: string;
+        sessionId: string;
+        parentThreadId?: string;
+        subagent?: string;
+        version?: string;
+        trigger?: string;
+    };
+};
+export declare function resolveMessagesFileContext(row: SessionRow): MessagesFileContext;
+export declare function buildMessagesFilePayload(input: {
+    updatedAt: string;
+    context: MessagesFileContext;
+    messages: LlmsProviders.MessageWithMetadata[];
+    systemPrompt?: string;
+}): {
+    version: 1;
+    updated_at: string;
+    agent: "lead" | "subagent" | "teammate";
+    sessionId: string;
+    taskType?: string;
+    origin: MessagesFileContext["origin"];
+    messages: StoredMessageWithMetadata[];
+    system_prompt?: string;
+};
+export declare function writeEmptyMessagesFile(path: string, startedAt: string, context: MessagesFileContext): void;
+export declare function buildManifestFromRow(row: SessionRow, overrides?: {
+    status?: SessionStatus;
+    endedAt?: string;
+    exitCode?: number;
+    metadata?: Record<string, unknown>;
+}): SessionManifest;
+export declare function withOccRetry<TFetch, TResult>(load: () => Promise<TFetch | undefined>, update: (loaded: TFetch) => Promise<TResult>, maxRetries: number): Promise<TResult | {
+    updated: false;
+}>;

package/dist/services/session-import/claude-code.d.ts

@@ -0,0 +1,16 @@
+import { type ConvertedImportedSession, type ImportableSessionSummary, type SessionImportAdapter } from "./types";
+export interface ClaudeCodeAdapterOptions {
+    /** Defaults to ~/.claude/projects */
+    projectsDir?: string;
+}
+export declare class ClaudeCodeImportAdapter implements SessionImportAdapter {
+    readonly tool: "claude-code";
+    private readonly projectsDir;
+    constructor(options?: ClaudeCodeAdapterOptions);
+    isInstalled(): boolean;
+    private sessionFiles;
+    private findSessionFile;
+    discover(): ImportableSessionSummary[];
+    private summarizeFile;
+    convert(sourceId: string): ConvertedImportedSession;
+}

package/dist/services/session-import/codex.d.ts

@@ -0,0 +1,34 @@
+import { type ConvertedImportedSession, type ImportableSessionSummary, type SessionImportAdapter } from "./types";
+export interface CodexAdapterOptions {
+    /** Defaults to $CODEX_HOME or ~/.codex */
+    codexHome?: string;
+}
+export declare class CodexImportAdapter implements SessionImportAdapter {
+    readonly tool: "codex";
+    private readonly codexHome;
+    constructor(options?: CodexAdapterOptions);
+    private get sessionsDir();
+    isInstalled(): boolean;
+    /** thread_name by session id, from Codex's own index. */
+    private readTitleIndex;
+    private sessionFiles;
+    /**
+     * Resuming a Codex thread writes a new rollout file that re-embeds the
+     * original session_meta id, so one logical session can span several files.
+     * Prefer the file with the most conversation (the resumed rollout replays
+     * history), tie-breaking on the most recent activity.
+     */
+    private static pickRicherFile;
+    /**
+     * Session id → richest rollout file. Building it means reading every
+     * rollout once (resumed rollouts only carry the original id inside
+     * session_meta, not in their filename), so it is cached for the batch:
+     * without the cache, importing N sessions re-read the whole store N times.
+     */
+    private index?;
+    private buildIndex;
+    dispose(): void;
+    private findSessionFile;
+    discover(): ImportableSessionSummary[];
+    convert(sourceId: string): ConvertedImportedSession;
+}

package/dist/services/session-import/index.d.ts

@@ -0,0 +1,6 @@
+export { type ClaudeCodeAdapterOptions, ClaudeCodeImportAdapter, } from "./claude-code";
+export { type CodexAdapterOptions, CodexImportAdapter } from "./codex";
+export { type OpencodeAdapterOptions, OpencodeImportAdapter, } from "./opencode";
+export { IMPORT_MISSING_TOOL_RESULT_TEXT, sanitizeImportedMessages, } from "./sanitize";
+export { type ImportedFromMetadata, readImportedFromMetadata, SessionImportService, } from "./service";
+export { type ConvertedImportedSession, type ImportableSessionSummary, SESSION_IMPORT_TOOL_LABELS, SESSION_IMPORT_TOOLS, type SessionImportAdapter, type SessionImportOptions, type SessionImportRequest, type SessionImportResult, type SessionImportTool, } from "./types";

package/dist/services/session-import/opencode.d.ts

@@ -0,0 +1,25 @@
+import { type ConvertedImportedSession, type ImportableSessionSummary, type SessionImportAdapter } from "./types";
+export interface OpencodeAdapterOptions {
+    /** Defaults to $XDG_DATA_HOME/opencode or ~/.local/share/opencode */
+    dataDir?: string;
+}
+export declare class OpencodeImportAdapter implements SessionImportAdapter {
+    readonly tool: "opencode";
+    private readonly dbPath;
+    constructor(options?: OpencodeAdapterOptions);
+    isInstalled(): boolean;
+    /**
+     * opencode keeps its database open in WAL mode while the app runs.
+     * Snapshot the db (+ WAL/SHM) into a temp dir and read the copy so we
+     * never contend with — or corrupt — the live store. The snapshot is kept
+     * for the batch (a large db copied once per imported session was the
+     * dominant cost) and released by dispose().
+     */
+    private snapshot?;
+    private openSnapshot;
+    dispose(): void;
+    private withDbCopy;
+    discover(): ImportableSessionSummary[];
+    private firstUserText;
+    convert(sourceId: string): ConvertedImportedSession;
+}

package/dist/services/session-import/sanitize.d.ts

@@ -0,0 +1,16 @@
+import type * as LlmsProviders from "@cerebriline/llms";
+type Message = LlmsProviders.MessageWithMetadata;
+export declare const IMPORT_MISSING_TOOL_RESULT_TEXT = "[import] Tool result was not captured in the source session history.";
+/**
+ * Prepares foreign conversation history for persistence and eventual replay
+ * to a provider:
+ * - cleans blocks (see cleanBlocks) and drops messages left empty,
+ * - guarantees every assistant tool_use has a matching tool_result in the
+ *   user messages that follow (synthesizing placeholders for orphans),
+ * - drops tool_result blocks whose tool_use no longer exists.
+ *
+ * Providers hard-reject histories that violate tool pairing, so this must
+ * run on every imported session regardless of source quality.
+ */
+export declare function sanitizeImportedMessages(messages: Message[]): Message[];
+export {};

package/dist/services/session-import/service.d.ts

@@ -0,0 +1,31 @@
+import type { UnifiedSessionPersistenceService } from "../../session/services/persistence-service";
+import type { ImportableSessionSummary, SessionImportAdapter, SessionImportOptions, SessionImportRequest, SessionImportResult, SessionImportTool } from "./types";
+export interface ImportedFromMetadata {
+    tool: SessionImportTool;
+    sourceSessionId: string;
+    sourcePath: string;
+    importedAt: string;
+    /** Provider/model the source tool ran the session on. */
+    sourceProvider?: string;
+    sourceModel?: string;
+}
+export declare function readImportedFromMetadata(metadata: Record<string, unknown> | null | undefined): ImportedFromMetadata | undefined;
+export declare class SessionImportService {
+    private readonly sessions;
+    private readonly adapters;
+    constructor(sessions: UnifiedSessionPersistenceService, adapters?: SessionImportAdapter[]);
+    installedTools(): SessionImportTool[];
+    /**
+     * `tool:sourceId` → existing Cline session id, from prior imports. Reads
+     * every row's metadata (not the 2000-row listSessions window) so a marker
+     * on an old session still prevents a duplicate.
+     */
+    private existingImports;
+    private disposeAdapters;
+    discover(): Promise<ImportableSessionSummary[]>;
+    importOne(request: SessionImportRequest, options?: SessionImportOptions): Promise<SessionImportResult>;
+    private importOneUnmanaged;
+    private importFresh;
+    importMany(requests: SessionImportRequest[], onProgress?: (result: SessionImportResult, index: number) => void, options?: SessionImportOptions): Promise<SessionImportResult[]>;
+    private persistConverted;
+}

package/dist/services/session-import/types.d.ts

@@ -0,0 +1,87 @@
+import type * as LlmsProviders from "@cerebriline/llms";
+/** External tools whose session history Cline can import. */
+export declare const SESSION_IMPORT_TOOLS: readonly ["claude-code", "codex", "opencode"];
+export type SessionImportTool = (typeof SESSION_IMPORT_TOOLS)[number];
+export declare const SESSION_IMPORT_TOOL_LABELS: Record<SessionImportTool, string>;
+/**
+ * A session found in an external tool's on-disk store, described with just
+ * enough metadata to render an import picker. Discovery must stay cheap; the
+ * full conversation is only parsed when the session is actually imported.
+ */
+export interface ImportableSessionSummary {
+    tool: SessionImportTool;
+    /** Stable identifier within the source tool's store. */
+    sourceId: string;
+    /** File (or database) the session was discovered in. */
+    sourcePath: string;
+    title: string;
+    /** Original working directory, when the source recorded one. */
+    cwd: string;
+    startedAtMs: number;
+    updatedAtMs: number;
+    /** Conversational user/assistant events (not raw store lines). */
+    messageCount: number;
+    /** First real user prompt, trimmed for display. */
+    preview?: string;
+    /** Set when a prior import of this source session already exists. */
+    alreadyImportedSessionId?: string;
+}
+/** A source session fully translated to Cline's native message format. */
+export interface ConvertedImportedSession {
+    tool: SessionImportTool;
+    sourceId: string;
+    sourcePath: string;
+    title: string;
+    /** First real user prompt (used for the session's prompt field). */
+    prompt?: string;
+    provider: string;
+    model: string;
+    cwd: string;
+    gitBranch?: string;
+    startedAtMs: number;
+    endedAtMs: number;
+    messages: LlmsProviders.MessageWithMetadata[];
+}
+export interface SessionImportAdapter {
+    readonly tool: SessionImportTool;
+    /** Whether the tool's session store exists on this machine. */
+    isInstalled(): boolean;
+    discover(): ImportableSessionSummary[];
+    /** Throws if the source session cannot be found or parsed. */
+    convert(sourceId: string): ConvertedImportedSession;
+    /**
+     * Releases per-batch caches (file indexes, database snapshots). Called by
+     * the service after each discover/import batch; adapters stay usable after.
+     */
+    dispose?(): void;
+}
+export interface SessionImportRequest {
+    tool: SessionImportTool;
+    sourceId: string;
+}
+export interface SessionImportOptions {
+    /**
+     * Cline provider/model the imported sessions should resume with. Opening a
+     * history session adopts the row's provider/model, so without this the
+     * session would try to run on the source tool's provider (openai-native,
+     * or an opencode provider id Cline doesn't know) which the user may never
+     * have configured. Both must be set to take effect; the source tool's own
+     * provider/model are always preserved in metadata.importedFrom and in
+     * per-message modelInfo.
+     */
+    provider?: string;
+    model?: string;
+}
+export interface SessionImportResult {
+    tool: SessionImportTool;
+    sourceId: string;
+    ok: boolean;
+    /** Cline session id created for this import (on success). */
+    sessionId?: string;
+    title?: string;
+    error?: string;
+    /** Set when the source session had already been imported; sessionId is
+     * the existing Cline session and nothing new was written. */
+    alreadyImported?: boolean;
+}
+export declare function truncateForDisplay(value: string | undefined, max?: number): string | undefined;

package/dist/services/session-telemetry.d.ts

@@ -0,0 +1,15 @@
+import type { ITelemetryService } from "@cerebriline/shared";
+import type { CoreSessionConfig } from "../types/config";
+import { type TelemetryAgentIdentityProperties } from "./telemetry/core-events";
+import type { enrichPromptWithMentions } from "./workspace";
+/**
+ * Emits local-only session creation telemetry (task.created/restarted and
+ * hook discovery). The transport-agnostic `session.started` event is
+ * emitted from `ClineCore.start` so it fires for every backend (local,
+ * hub, remote) at the outer API boundary.
+ */
+export declare function emitSessionCreationTelemetry(config: CoreSessionConfig, sessionId: string, isRestart: boolean, workspacePath: string, agentIdentity?: Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureHookDiscoveryTelemetry(telemetry: ITelemetryService | undefined, options: {
+    workspacePath: string;
+}): void;
+export declare function emitMentionTelemetry(telemetry: ITelemetryService | undefined, enriched: Awaited<ReturnType<typeof enrichPromptWithMentions>>): void;

package/dist/services/storage/file-team-store.d.ts

@@ -0,0 +1,32 @@
+import type { TeamRuntimeState, TeamTeammateSpec } from "@cerebriline/shared";
+import type { TeamEvent } from "../../extensions/tools/team";
+import type { TeamStore } from "../../types/storage";
+import { type TeamEventsRetention } from "./team-events-retention";
+export interface FileTeamStoreOptions extends TeamEventsRetention {
+    teamDir?: string;
+}
+export interface TeamRuntimeLoadResult {
+    state?: TeamRuntimeState;
+    teammates: TeamTeammateSpec[];
+    interruptedRunIds: string[];
+}
+export declare class FileTeamStore implements TeamStore {
+    private readonly teamDirPath;
+    private readonly eventsPrune;
+    constructor(options?: FileTeamStoreOptions);
+    /** Nothing is held open between calls; present so both stores close alike. */
+    close(): void;
+    init(): void;
+    listTeamNames(): string[];
+    readState(teamName: string): TeamRuntimeState | undefined;
+    readHistory(teamName: string, limit?: number): unknown[];
+    loadRuntime(teamName: string): TeamRuntimeLoadResult;
+    handleTeamEvent(teamName: string, event: TeamEvent): void;
+    persistRuntime(teamName: string, state: TeamRuntimeState, teammates: TeamTeammateSpec[]): void;
+    markInProgressRunsInterrupted(teamName: string, reason: string): string[];
+    private ensureTeamDir;
+    private ensureTeamSubdir;
+    private statePath;
+    private historyPath;
+    private readEnvelope;
+}

package/dist/services/storage/provider-settings-legacy-migration.d.ts

@@ -0,0 +1,38 @@
+import { type ProviderSettings } from "../../types/provider-settings";
+import type { ProviderSettingsManager } from "./provider-settings-manager";
+export interface MigrateLegacyProviderSettingsOptions {
+    providerSettingsManager: ProviderSettingsManager;
+    dataDir?: string;
+    globalStatePath?: string;
+    secretsPath?: string;
+}
+export interface MigrateLegacyProviderSettingsResult {
+    migrated: boolean;
+    providerCount: number;
+    lastUsedProvider?: string;
+}
+export type LegacyClineUserInfo = {
+    idToken: string;
+    expiresAt: number;
+    refreshToken: string;
+    userInfo: {
+        id: string;
+        email: string;
+        displayName: string;
+        termsAcceptedAt: string;
+        clineBenchConsent: boolean;
+        createdAt: string;
+        updatedAt: string;
+    };
+    provider: string;
+    startedAt: number;
+};
+/**
+ * Resolves legacy Cline account auth data from the raw `cline:clineAccountId`
+ * secret string into the auth fields used by `ProviderSettings`.
+ *
+ * Returns `undefined` when the input is missing, empty, whitespace-only, or
+ * unparseable JSON.
+ */
+export declare function resolveLegacyClineAuth(rawAccountData: string | undefined): ProviderSettings["auth"] | undefined;
+export declare function migrateLegacyProviderSettings(options: MigrateLegacyProviderSettingsOptions): MigrateLegacyProviderSettingsResult;

package/dist/services/storage/provider-settings-manager.d.ts

@@ -0,0 +1,31 @@
+import { type ProviderConfig, type ProviderSettings, type ProviderTokenSource, type StoredProviderSettings, type ToProviderConfigOptions, type VoiceInputSettings } from "../../types/provider-settings";
+export interface ProviderSettingsManagerOptions {
+    filePath?: string;
+    dataDir?: string;
+}
+export interface SaveProviderSettingsOptions {
+    setLastUsed?: boolean;
+    tokenSource?: ProviderTokenSource;
+}
+export interface ResolveLastUsedProviderSettingsOptions {
+    isClinePassEnabled?: boolean;
+}
+export declare class ProviderSettingsManager {
+    private readonly filePath;
+    private readonly dataDir?;
+    private cache;
+    constructor(options?: ProviderSettingsManagerOptions);
+    getFilePath(): string;
+    read(): StoredProviderSettings;
+    write(state: StoredProviderSettings): void;
+    saveProviderSettings(settings: unknown, options?: SaveProviderSettingsOptions): StoredProviderSettings;
+    private resolveProviderSettings;
+    getProviderSettings(providerId: string): ProviderSettings | undefined;
+    getVoiceInputSettings(): VoiceInputSettings | undefined;
+    setVoiceInputSettings(settings: VoiceInputSettings | undefined): StoredProviderSettings;
+    private resolveLastUsedProviderId;
+    getLastUsedProviderSettings(options?: ResolveLastUsedProviderSettingsOptions): ProviderSettings | undefined;
+    getProviderConfig(providerId: string, options?: ToProviderConfigOptions): ProviderConfig | undefined;
+    getLastUsedProviderConfig(options?: ToProviderConfigOptions & ResolveLastUsedProviderSettingsOptions): ProviderConfig | undefined;
+    refreshCatalog(): Promise<void>;
+}

package/dist/services/storage/sqlite-session-store.d.ts

@@ -0,0 +1,35 @@
+import { type SqliteDb } from "@cerebriline/shared/db";
+import { type SessionStatus } from "../../types/common";
+import type { SessionRecord } from "../../types/sessions";
+import type { SessionStore } from "../../types/storage";
+export interface SqliteSessionStoreOptions {
+    sessionsDir?: string;
+}
+export declare class SqliteSessionStore implements SessionStore {
+    private readonly sessionsDirPath;
+    private db;
+    constructor(options?: SqliteSessionStoreOptions);
+    init(): void;
+    ensureSessionsDir(): string;
+    sessionDbPath(): string;
+    getRawDb(): SqliteDb;
+    close(): void;
+    run(sql: string, params?: unknown[]): {
+        changes?: number;
+    };
+    queryOne<T>(sql: string, params?: unknown[]): T | undefined;
+    queryAll<T>(sql: string, params?: unknown[]): T[];
+    create(record: SessionRecord): void;
+    update(record: Partial<SessionRecord> & {
+        sessionId: string;
+    }): void;
+    updateStatus(sessionId: string, status: SessionStatus, exitCode?: number | null): void;
+    get(sessionId: string): SessionRecord | undefined;
+    list(limit?: number): SessionRecord[];
+    /**
+     * Child sessions — subagent runs and team-task runs — recorded under a
+     * parent, oldest first so a caller can present them in spawn order.
+     */
+    listChildren(parentSessionId: string, limit?: number): SessionRecord[];
+    delete(sessionId: string, cascade?: boolean): boolean;
+}

package/dist/services/storage/sqlite-team-store.d.ts

@@ -0,0 +1,42 @@
+import { type TeamRuntimeState, type TeamTeammateSpec } from "@cerebriline/shared";
+import type { TeamEvent } from "../../extensions/tools/team";
+import type { TeamStore } from "../../types/storage";
+import { type TeamEventsRetention } from "./team-events-retention";
+export interface SqliteTeamStoreOptions extends TeamEventsRetention {
+    teamDir?: string;
+}
+export interface TeamRuntimeLoadResult {
+    state?: TeamRuntimeState;
+    teammates: TeamTeammateSpec[];
+    interruptedRunIds: string[];
+}
+export declare class SqliteTeamStore implements TeamStore {
+    private readonly teamDirPath;
+    private db;
+    private readonly eventsPrune;
+    constructor(options?: SqliteTeamStoreOptions);
+    init(): void;
+    /**
+     * Releases the database handle. The next call reopens it, so a store that
+     * outlives this is still usable. Until it is called the process holds
+     * teams.db open, which on Windows keeps its directory from being deleted.
+     */
+    close(): void;
+    private ensureTeamDir;
+    private dbPath;
+    private getRawDb;
+    private ensureSchema;
+    private run;
+    private queryOne;
+    private queryAll;
+    /** Runs `work` in a single SQLite transaction (rollback on any error). */
+    private withTransaction;
+    listTeamNames(): string[];
+    readState(teamName: string): TeamRuntimeState | undefined;
+    readHistory(teamName: string, limit?: number): unknown[];
+    loadRuntime(teamName: string): TeamRuntimeLoadResult;
+    appendTeamEvent(teamName: string, eventType: string, payload: unknown, correlationId?: string): void;
+    persistRuntime(teamName: string, state: TeamRuntimeState, teammates: TeamTeammateSpec[]): void;
+    markInProgressRunsInterrupted(teamName: string, reason: string): string[];
+    handleTeamEvent(teamName: string, event: TeamEvent): void;
+}

package/dist/services/storage/team-events-retention.d.ts

@@ -0,0 +1,25 @@
+/**
+ * How much of a team's event log its store keeps.
+ *
+ * Every team event was appended -- a row in `team_events`, a line in
+ * `task-history.jsonl` -- for as long as the team lived, and none was ever
+ * deleted. What reads the log (`readHistory`) reads the newest 200. So each
+ * team keeps its newest {@link TEAM_EVENTS_KEPT}, cut back once every
+ * {@link TEAM_EVENTS_PRUNE_EVERY} appends rather than on each one.
+ */
+export declare const TEAM_EVENTS_KEPT = 1000;
+export declare const TEAM_EVENTS_PRUNE_EVERY = 100;
+/** A store's retention, as its options may set it (tests keep it small). */
+export interface TeamEventsRetention {
+    eventsKept?: number;
+    eventsPruneEvery?: number;
+}
+/**
+ * Counts a store's appends per team, and says when one is due a prune: on
+ * its first append since the store opened (a log left long by an older
+ * build is cut then), and every `eventsPruneEvery` after.
+ */
+export declare function createPruneSchedule(retention?: TeamEventsRetention): {
+    kept: number;
+    due(teamName: string): boolean;
+};

package/dist/services/storage/team-store.d.ts

@@ -0,0 +1,16 @@
+export type { TeamStore } from "../../types/storage";
+export { FileTeamStore, type FileTeamStoreOptions, } from "./file-team-store";
+export { SqliteTeamStore, type SqliteTeamStoreOptions, } from "./sqlite-team-store";
+import { FileTeamStore } from "./file-team-store";
+import { type SqliteTeamStoreOptions } from "./sqlite-team-store";
+export declare function createLocalTeamStore(options?: SqliteTeamStoreOptions): {
+    init(): void;
+    listTeamNames(): string[];
+    readState(teamName: string): ReturnType<FileTeamStore["readState"]>;
+    readHistory(teamName: string, limit?: number): unknown[];
+    loadRuntime(teamName: string): ReturnType<FileTeamStore["loadRuntime"]>;
+    handleTeamEvent: FileTeamStore["handleTeamEvent"];
+    persistRuntime: FileTeamStore["persistRuntime"];
+    markInProgressRunsInterrupted: FileTeamStore["markInProgressRunsInterrupted"];
+    close(): void;
+};

package/dist/services/telemetry/ITelemetryAdapter.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Telemetry adapter interface for the @cline/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 "@cerebriline/shared";
+export type { TelemetryArray, TelemetryMetadata, TelemetryObject, TelemetryPrimitive, TelemetryProperties, TelemetryValue, } from "@cerebriline/shared";
+/**
+ * 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>;
+}