@cerebriline/core 4.100.240

package/dist/services/usage.d.ts

@@ -0,0 +1,19 @@
+import type * as LlmsProviders from "@cerebriline/llms";
+import type { SessionAccumulatedUsage } from "../runtime/host/runtime-host";
+export declare function createInitialAccumulatedUsage(): SessionAccumulatedUsage;
+export declare function accumulateUsageTotals(baseline: SessionAccumulatedUsage, usage: {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    totalCost?: number;
+}): SessionAccumulatedUsage;
+export declare function sumUsageTotals(usages: Iterable<SessionAccumulatedUsage>): SessionAccumulatedUsage;
+export declare function summarizeUsageFromMessages(messages: LlmsProviders.Message[]): SessionAccumulatedUsage;
+/**
+ * Current model context-window usage, derived from the latest assistant LLM
+ * call. Provider usage is normalized so `inputTokens` is already the full
+ * prompt size, including any cache-read/cache-write portions. Do not add cache
+ * fields back on top.
+ */
+export declare function getCurrentContextSize(messages: readonly LlmsProviders.Message[]): number | undefined;

package/dist/services/workspace/agent-schedules-workspace.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Ensure the home workspace for agent-created schedules exists and return its
+ * path. Agent-created schedules are user-level routines: they anchor (and
+ * their unattended sessions run) in `~/.cline/schedules/` instead of
+ * inheriting whichever chat workspace happened to create them, so they
+ * survive chat cleanup and stay in one predictable scope.
+ */
+export declare function ensureAgentSchedulesWorkspace(): Promise<string>;

package/dist/services/workspace/chat-workspace.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeSessionConfig, StartSessionConfig } from "../../runtime/host/runtime-host";
+/**
+ * Ensure the shared chat workspace exists and is seeded with the rules file
+ * that tells the agent how to behave in a project-less session. The rules
+ * file is only written when missing so users can edit it.
+ */
+export declare function ensureChatWorkspace(): Promise<string>;
+/** Resolve the optional workspace fields at the execution-host boundary. */
+export declare function resolveStartSessionWorkspace(config: StartSessionConfig): Promise<RuntimeSessionConfig>;

package/dist/services/workspace/file-indexer.d.ts

@@ -0,0 +1,5 @@
+export interface FastFileIndexOptions {
+    ttlMs?: number;
+}
+export declare function getFileIndex(cwd: string, options?: FastFileIndexOptions): Promise<Set<string>>;
+export declare function prewarmFileIndex(cwd: string, options?: FastFileIndexOptions): Promise<void>;

package/dist/services/workspace/index.d.ts

@@ -0,0 +1,6 @@
+export { ensureAgentSchedulesWorkspace } from "./agent-schedules-workspace";
+export { ensureChatWorkspace } from "./chat-workspace";
+export type { FastFileIndexOptions } from "./file-indexer";
+export { getFileIndex, prewarmFileIndex } from "./file-indexer";
+export type { MentionEnricherOptions, MentionEnrichmentResult, } from "./mention-enricher";
+export { enrichPromptWithMentions } from "./mention-enricher";

package/dist/services/workspace/mention-enricher.d.ts

@@ -0,0 +1,13 @@
+import { type FastFileIndexOptions } from "./file-indexer";
+export interface MentionEnricherOptions extends FastFileIndexOptions {
+    maxFiles?: number;
+    maxFileBytes?: number;
+    maxTotalBytes?: number;
+}
+export interface MentionEnrichmentResult {
+    prompt: string;
+    mentions: string[];
+    matchedFiles: string[];
+    ignoredMentions: string[];
+}
+export declare function enrichPromptWithMentions(input: string, cwd: string, options?: MentionEnricherOptions): Promise<MentionEnrichmentResult>;

package/dist/services/workspace/workspace-manager.d.ts

@@ -0,0 +1,27 @@
+import { type WorkspaceInfo, type WorkspaceManifest } from "@cerebriline/shared";
+export interface WorkspaceManagerEvent {
+    type: "workspace_added" | "workspace_switched";
+    workspace: WorkspaceInfo;
+}
+export interface WorkspaceManager {
+    addWorkspacePath(workspacePath: string): Promise<WorkspaceInfo>;
+    switchWorkspace(workspacePath: string): Promise<WorkspaceInfo>;
+    subscribe(listener: (event: WorkspaceManagerEvent) => void): () => void;
+    getCurrentWorkspace(): WorkspaceInfo | undefined;
+    getWorkspace(workspacePath: string): WorkspaceInfo | undefined;
+    listWorkspaces(): WorkspaceInfo[];
+    getManifest(): WorkspaceManifest;
+}
+export declare class InMemoryWorkspaceManager implements WorkspaceManager {
+    private manifest;
+    private readonly listeners;
+    constructor(manifest?: WorkspaceManifest);
+    addWorkspacePath(workspacePath: string): Promise<WorkspaceInfo>;
+    switchWorkspace(workspacePath: string): Promise<WorkspaceInfo>;
+    subscribe(listener: (event: WorkspaceManagerEvent) => void): () => void;
+    getCurrentWorkspace(): WorkspaceInfo | undefined;
+    getWorkspace(workspacePath: string): WorkspaceInfo | undefined;
+    listWorkspaces(): WorkspaceInfo[];
+    getManifest(): WorkspaceManifest;
+    private emit;
+}

package/dist/services/workspace/workspace-manifest.d.ts

@@ -0,0 +1,42 @@
+import type { WorkspaceInfo } from "@cerebriline/shared";
+export interface WorkspaceInfoDiagnostics {
+    info: WorkspaceInfo;
+    vcsType: "git" | "none";
+    gitState: GitWorkspaceState;
+    error?: {
+        errorType: string;
+        message: string;
+    };
+}
+export interface BuiltWorkspaceMetadata {
+    workspaceInfo: WorkspaceInfo;
+    workspaceMetadata: string;
+    durationMs: number;
+    vcsType: "git" | "none";
+    gitState: GitWorkspaceState;
+    initError?: {
+        errorType: string;
+        message: string;
+    };
+}
+export interface GitWorkspaceState {
+    url?: string;
+    branch?: string;
+}
+export declare function readSessionGitMetadata(metadata: Record<string, unknown> | undefined): GitWorkspaceState;
+export declare function withSessionGitMetadata(metadata: Record<string, unknown> | undefined, state: GitWorkspaceState): Record<string, unknown> | undefined;
+export declare function hasCurrentSessionGitMetadata(metadata: Record<string, unknown> | undefined, state: GitWorkspaceState): boolean;
+export declare function normalizeWorkspacePath(workspacePath: string): string;
+export declare function generateWorkspaceInfo(workspacePath: string): Promise<WorkspaceInfo>;
+export declare function generateWorkspaceInfoWithDiagnostics(workspacePath: string): Promise<WorkspaceInfoDiagnostics>;
+/** Read the mutable git identity persisted with an active session. */
+export declare function readGitWorkspaceState(workspacePath: string): Promise<GitWorkspaceState | undefined>;
+export declare function buildWorkspaceMetadata(cwd: string): Promise<string>;
+/**
+ * Generate workspace metadata as both a structured `WorkspaceInfo` object and
+ * its pre-serialized string form.
+ *
+ * Use this instead of calling `buildWorkspaceMetadata` + `generateWorkspaceInfo`
+ * separately so the git I/O only happens once.
+ */
+export declare function buildWorkspaceMetadataWithInfo(cwd: string): Promise<BuiltWorkspaceMetadata>;

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

@@ -0,0 +1,18 @@
+import type { ITelemetryService, WorkspaceInfo } from "@cerebriline/shared";
+export interface WorkspaceLifecycleTelemetryInput {
+    telemetry?: ITelemetryService;
+    rootPath: string;
+    workspaceInfo?: WorkspaceInfo;
+    rootCount?: number;
+    vcsType?: "git" | "none";
+    vcsTypes?: ReadonlyArray<string>;
+    durationMs?: number;
+    initError?: {
+        errorType: string;
+        message: string;
+    };
+    featureFlagEnabled?: boolean;
+    isRemoteWorkspace?: boolean;
+}
+export declare function emitWorkspaceLifecycleTelemetry(input: WorkspaceLifecycleTelemetryInput): void;
+export declare function resetWorkspaceTelemetryForTests(): void;

package/dist/session/checkpoint-diff.d.ts

@@ -0,0 +1,25 @@
+import type { CheckpointEntry } from "../hooks/checkpoint-hooks";
+import type { SessionRecord } from "../types/sessions";
+export interface CheckpointContentDiff {
+    filePath: string;
+    leftContent: string;
+    rightContent: string;
+}
+export interface CheckpointComparePlan {
+    checkpoint: CheckpointEntry;
+    cwd: string;
+}
+export interface CheckpointWorkspaceCompareResult extends CheckpointComparePlan {
+    diffs: CheckpointContentDiff[];
+}
+export declare function createCheckpointComparePlan(input: {
+    session: SessionRecord;
+    checkpointRunCount: number;
+    cwd?: string;
+}): CheckpointComparePlan;
+export declare function buildCheckpointWorkspaceDiff(cwd: string, checkpoint: CheckpointEntry): Promise<CheckpointContentDiff[]>;
+export declare function compareCheckpointToWorkspace(input: {
+    session: SessionRecord;
+    checkpointRunCount: number;
+    cwd?: string;
+}): Promise<CheckpointWorkspaceCompareResult>;

package/dist/session/checkpoint-restore.d.ts

@@ -0,0 +1,34 @@
+import type * as LlmsProviders from "@cerebriline/llms";
+import type { CheckpointEntry, CheckpointMetadata } from "../hooks/checkpoint-hooks";
+import type { SessionRecord } from "../types/sessions";
+export interface CheckpointRestorePlan {
+    checkpoint: CheckpointEntry;
+    messages?: LlmsProviders.MessageWithMetadata[];
+    cwd: string;
+}
+export interface WorktreeRestoreTransaction {
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}
+/**
+ * Captures the current worktree before a destructive checkpoint restore.
+ *
+ * `git stash create` omits untracked files, but checkpoint restoration runs
+ * `git clean -fd`. Use a short-lived `stash push --include-untracked`, move
+ * its object behind a private ref, and immediately remove it from the user's
+ * visible stash list. The private ref remains only until commit or rollback.
+ */
+export declare function beginWorktreeRestoreTransaction(cwd: string): Promise<WorktreeRestoreTransaction>;
+export declare function readSessionCheckpointHistory(session: Pick<SessionRecord, "metadata"> | undefined): CheckpointEntry[];
+export declare function createRestoredCheckpointMetadata(session: Pick<SessionRecord, "metadata"> | undefined, runCount: number): CheckpointMetadata | undefined;
+export declare function findCheckpointForRun(history: readonly CheckpointEntry[], runCount: number): CheckpointEntry | undefined;
+export declare function trimMessagesToCheckpoint(messages: LlmsProviders.MessageWithMetadata[], runCount: number): LlmsProviders.MessageWithMetadata[];
+export declare function trimMessagesBeforeUserRun(messages: LlmsProviders.MessageWithMetadata[], runCount: number): LlmsProviders.MessageWithMetadata[];
+export declare function createCheckpointRestorePlan(input: {
+    session: SessionRecord;
+    messages?: LlmsProviders.MessageWithMetadata[];
+    checkpointRunCount: number;
+    cwd?: string;
+    restoreMessages?: boolean;
+}): CheckpointRestorePlan;
+export declare function applyCheckpointToWorktree(cwd: string, checkpoint: CheckpointEntry): Promise<void>;

package/dist/session/display-messages.d.ts

@@ -0,0 +1,28 @@
+import type { MessageWithMetadata, ModelToolExecution } from "@cerebriline/shared";
+/**
+ * A message prepared exclusively for transcript presentation.
+ *
+ * The wrapper is intentionally not structurally assignable to `Message`, so a
+ * display projection cannot accidentally be passed to `initialMessages` or a
+ * provider request. Consumers render `message`; runtime/replay code continues
+ * to consume the canonical history directly.
+ */
+export interface SessionDisplayMessage {
+    kind: "session_display_message";
+    origin: "history" | "model_tool_activity";
+    execution?: ModelToolExecution;
+    message: MessageWithMetadata;
+    /** Index of the canonical message that produced this display entry. */
+    sourceIndex: number;
+}
+/**
+ * Project observational model-tool activity into the same persisted
+ * `tool_use` / `tool_result` shapes used by ordinary runtime tools.
+ *
+ * The source history is never mutated. The non-`Message` wrapper keeps this
+ * display representation out of resume, fork, compaction, and model replay by
+ * construction. Since the sidecar metadata does not retain text-relative
+ * positions, projected activities are placed in their recorded order
+ * immediately before the assistant message that owns them.
+ */
+export declare function projectSessionMessagesForDisplay(messages: readonly MessageWithMetadata[]): SessionDisplayMessage[];

package/dist/session/history-origin.d.ts

@@ -0,0 +1,19 @@
+import type { ClientContext } from "@cerebriline/shared";
+import { type SessionSource as SessionSourceValue } from "../types/common";
+export interface SessionHistoryOriginMetadata {
+    mode: string;
+    version?: string;
+    /**
+     * The trigger that initiated the session, when it is not a direct user
+     * action. E.g., the `source` label of the automation spec that started a
+     * scheduled run.
+     */
+    trigger?: string;
+}
+export declare function resolveClientSessionSource(client: ClientContext | undefined): SessionSourceValue | undefined;
+export declare function readSessionHistoryOriginMetadata(metadata: Record<string, unknown> | null | undefined): SessionHistoryOriginMetadata | undefined;
+export declare function withSessionHistoryOriginMetadata(metadata: Record<string, unknown> | null | undefined, origin: {
+    mode?: string;
+    version?: string;
+    trigger?: string;
+}): Record<string, unknown>;

package/dist/session/models/session-compaction.d.ts

@@ -0,0 +1,22 @@
+import { type MessageWithMetadata } from "@cerebriline/shared";
+import { z } from "zod";
+export declare const SessionCompactionStateSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    updated_at: z.ZodString;
+    conversation_id: z.ZodOptional<z.ZodString>;
+    source_message_count: z.ZodNumber;
+    source_prefix_hash: z.ZodOptional<z.ZodString>;
+    source_last_message_key: z.ZodOptional<z.ZodString>;
+    messages: z.ZodArray<z.ZodCustom<MessageWithMetadata, MessageWithMetadata>>;
+    system_prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SessionCompactionState = z.infer<typeof SessionCompactionStateSchema>;
+export declare function createSessionCompactionState(input: {
+    sourceMessages: readonly MessageWithMetadata[];
+    compactedMessages: readonly MessageWithMetadata[];
+    conversationId?: string;
+    systemPrompt?: string;
+    updatedAt?: string;
+}): SessionCompactionState;
+export declare function projectSessionCompactionState(state: SessionCompactionState, sourceMessages: readonly MessageWithMetadata[]): MessageWithMetadata[] | undefined;
+export declare function parseSessionCompactionState(value: unknown): SessionCompactionState | undefined;

package/dist/session/models/session-graph.d.ts

@@ -0,0 +1,15 @@
+import type { HookEventPayload } from "../../hooks";
+import type { SessionStatus } from "../../types/common";
+export declare function sanitizeSessionToken(value: string): string;
+export declare function makeSubSessionId(rootSessionId: string, agentId: string): string;
+export declare function makeTeamTaskSubSessionId(rootSessionId: string, agentId: string): string;
+export declare function parseTeamTaskSubSessionId(sessionId: string): {
+    rootSessionId: string;
+    agentId: string;
+    teamTaskId: string;
+} | null;
+export declare function parseSubSessionId(sessionId: string): {
+    rootSessionId: string;
+    agentId: string;
+} | null;
+export declare function deriveSubsessionStatus(event: HookEventPayload): SessionStatus;

package/dist/session/models/session-manifest.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const SessionManifestSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    session_id: z.ZodString;
+    source: z.ZodString;
+    pid: z.ZodNumber;
+    started_at: z.ZodString;
+    ended_at: z.ZodOptional<z.ZodString>;
+    exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    status: z.ZodEnum<{
+        completed: "completed";
+        running: "running";
+        pending: "pending";
+        idle: "idle";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    interactive: z.ZodBoolean;
+    provider: z.ZodString;
+    model: z.ZodString;
+    cwd: z.ZodString;
+    workspace_root: z.ZodString;
+    team_name: z.ZodOptional<z.ZodString>;
+    enable_tools: z.ZodBoolean;
+    enable_spawn: z.ZodBoolean;
+    enable_teams: z.ZodBoolean;
+    prompt: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    messages_path: z.ZodOptional<z.ZodString>;
+    compaction_path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SessionManifest = z.infer<typeof SessionManifestSchema>;

package/dist/session/models/session-row.d.ts

@@ -0,0 +1,107 @@
+import type { TeamTeammateSpec } from "@cerebriline/shared";
+import type { AgentTeamsRuntime } from "../../extensions/tools/team";
+import type { SessionSource, SessionStatus } from "../../types/common";
+import type { SessionManifest } from "./session-manifest";
+export interface SessionRow {
+    sessionId: string;
+    source: string;
+    pid: number;
+    startedAt: string;
+    endedAt?: string | null;
+    exitCode?: number | null;
+    status: SessionStatus;
+    statusLock: number;
+    interactive: boolean;
+    provider: string;
+    model: string;
+    cwd: string;
+    workspaceRoot: string;
+    teamName?: string | null;
+    enableTools: boolean;
+    enableSpawn: boolean;
+    enableTeams: boolean;
+    parentSessionId?: string | null;
+    parentAgentId?: string | null;
+    agentId?: string | null;
+    conversationId?: string | null;
+    isSubagent: boolean;
+    prompt?: string | null;
+    metadata?: Record<string, unknown> | null;
+    hookPath?: string;
+    messagesPath?: string | null;
+    updatedAt: string;
+}
+export interface CreateRootSessionInput {
+    sessionId: string;
+    source: SessionSource;
+    mode?: string;
+    version?: string;
+    pid: number;
+    startedAt: string;
+    interactive: boolean;
+    provider: string;
+    model: string;
+    cwd: string;
+    workspaceRoot: string;
+    teamName?: string;
+    enableTools: boolean;
+    enableSpawn: boolean;
+    enableTeams: boolean;
+    prompt?: string;
+    metadata?: Record<string, unknown>;
+    messagesPath: string;
+}
+export interface CreateRootSessionWithArtifactsInput {
+    sessionId: string;
+    source: SessionSource;
+    mode?: string;
+    version?: string;
+    pid: number;
+    interactive: boolean;
+    provider: string;
+    model: string;
+    cwd: string;
+    workspaceRoot: string;
+    teamName?: string;
+    enableTools: boolean;
+    enableSpawn: boolean;
+    enableTeams: boolean;
+    prompt?: string;
+    metadata?: Record<string, unknown>;
+    startedAt?: string;
+    /**
+     * Create the session already in a terminal state (defaults to "running").
+     * Sessions that are pure history from birth — imports — use this so they
+     * never pass through a transient running/pid-0 state that the
+     * stale-session reconciler (in any process sharing the DB) could flip to
+     * failed before the creator finishes writing.
+     */
+    status?: SessionStatus;
+    endedAt?: string;
+    exitCode?: number;
+}
+export interface RootSessionArtifacts {
+    manifestPath: string;
+    messagesPath: string;
+    compactionPath?: string;
+    manifest: SessionManifest;
+}
+export interface UpsertSubagentInput {
+    agentId: string;
+    parentAgentId: string;
+    conversationId: string;
+    prompt?: string;
+    rootSessionId?: string;
+}
+/** SELECT clause that aliases snake_case columns to camelCase SessionRow keys. */
+export declare const SESSION_SELECT_COLUMNS = "\n\tsession_id    AS sessionId,\n\tsource,\n\tpid,\n\tstarted_at    AS startedAt,\n\tended_at      AS endedAt,\n\texit_code     AS exitCode,\n\tstatus,\n\tstatus_lock   AS statusLock,\n\tinteractive,\n\tprovider,\n\tmodel,\n\tcwd,\n\tworkspace_root AS workspaceRoot,\n\tteam_name      AS teamName,\n\tenable_tools   AS enableTools,\n\tenable_spawn   AS enableSpawn,\n\tenable_teams   AS enableTeams,\n\tparent_session_id AS parentSessionId,\n\tparent_agent_id   AS parentAgentId,\n\tagent_id       AS agentId,\n\tconversation_id AS conversationId,\n\tis_subagent    AS isSubagent,\n\tprompt,\n\tmetadata_json  AS metadata,\n\thook_path       AS hookPath,\n\tmessages_path   AS messagesPath,\n\tupdated_at      AS updatedAt";
+export declare function patchSqliteRow(raw: Record<string, unknown>): SessionRow;
+export declare function stringifyMetadata(metadata: Record<string, unknown> | null | undefined): string | null;
+export type TeamRuntimeState = ReturnType<AgentTeamsRuntime["exportState"]>;
+export interface PersistedTeamEnvelope {
+    version: 1;
+    updatedAt: string;
+    teamState: TeamRuntimeState;
+    teammates: TeamTeammateSpec[];
+}
+export { reviveTeamStateDates } from "../../extensions/tools/team/team-state-dates";

package/dist/session/persisted-tool-result-content.d.ts

@@ -0,0 +1,8 @@
+import type { ToolResultContent } from "@cerebriline/shared";
+/**
+ * Preserve the runtime tool-output serialization used by canonical session
+ * persistence. This intentionally remains internal to Core because the
+ * historical codec accepts a wider runtime value set than the public
+ * `ToolResultContent` type describes.
+ */
+export declare function toPersistedToolResultContent(output: unknown): ToolResultContent["content"];

package/dist/session/search/index.d.ts

@@ -0,0 +1 @@
+export * from "./session-history-search";

package/dist/session/search/session-history-search.d.ts

@@ -0,0 +1,51 @@
+import type { RuntimeHost } from "../../runtime/host/runtime-host";
+export interface SessionSearchInput {
+    query: string;
+    limit?: number;
+    workspaceRoot?: string;
+}
+export interface SessionSearchHit {
+    sessionId: string;
+    documentId: string;
+    ordinal: number;
+    role: string;
+    startedAt: string;
+    workspaceRoot: string;
+    title: string;
+    snippet: string;
+    score: number;
+}
+export interface SessionHistorySearchOptions {
+    dbPath?: string;
+    reconcileIntervalMs?: number;
+}
+export declare class SessionHistorySearchService {
+    private readonly host;
+    private readonly db;
+    private readonly initializationError;
+    private readonly intervalMs;
+    private readonly removedDuringRefresh;
+    private readonly failedEvictionSessionIds;
+    private timer;
+    private refreshPromise;
+    private readyPromise;
+    constructor(host: Pick<RuntimeHost, "listSessions" | "readSessionMessages">, options?: SessionHistorySearchOptions);
+    start(): void;
+    dispose(): Promise<void>;
+    refreshNow(): Promise<void>;
+    /**
+     * Removes one session from the derived index without scanning canonical
+     * history. The temporary tombstone prevents an in-flight reconciliation
+     * that captured the session before deletion from writing it back.
+     */
+    removeSession(sessionId: string): void;
+    waitUntilReady(): Promise<void>;
+    isAvailable(): boolean;
+    getInitializationError(): unknown | undefined;
+    search(input: SessionSearchInput): SessionSearchHit[];
+    private isSessionSuppressed;
+    private reconcile;
+    private sourceRevision;
+    private indexSession;
+    private deleteIndexedSession;
+}

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

@@ -0,0 +1,10 @@
+import type { BasicLogger } from "@cerebriline/shared";
+import type { SessionMessagesArtifactUploader } from "../../types/session";
+import { UnifiedSessionPersistenceService } from "./persistence-service";
+export declare class FileSessionService extends UnifiedSessionPersistenceService {
+    constructor(sessionsDir?: string, options?: {
+        messagesArtifactUploader?: SessionMessagesArtifactUploader;
+        logger?: BasicLogger;
+    });
+    ensureSessionsDir(): string;
+}