@cline/core 0.0.38-nightly.1778113663

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

@@ -0,0 +1,58 @@
+import type * as LlmsProviders from "@cline/llms";
+import type { AgentResult } from "@cline/shared";
+import type { SubAgentEndContext, SubAgentStartContext } from "../../extensions/tools/team";
+import type { HookEventPayload } from "../../hooks";
+import type { SessionStatus } from "../../types/common";
+import type { PersistedSessionUpdateInput, SessionMessagesArtifactUploader, SessionPersistenceAdapter } from "../../types/session";
+import type { SessionRow } from "../models/session-row";
+export type { PersistedSessionUpdateInput, SessionPersistenceAdapter };
+export declare class UnifiedSessionPersistenceService {
+    private readonly adapter;
+    private readonly manifestStore;
+    private readonly teamChildren;
+    private static readonly STALE_REASON;
+    private static readonly STALE_SOURCE;
+    private static readonly TEAM_HEARTBEAT_LOG_INTERVAL_MS;
+    constructor(adapter: SessionPersistenceAdapter, options?: {
+        messagesArtifactUploader?: SessionMessagesArtifactUploader;
+    });
+    private toPersistedMessages;
+    ensureSessionsDir(): string;
+    writeSessionManifest(manifestPath: string, manifest: import("../models/session-manifest").SessionManifest): void;
+    readSessionManifest(sessionId: string): import("../models/session-manifest").SessionManifest | undefined;
+    createRootSessionWithArtifacts(input: import("../models/session-row").CreateRootSessionWithArtifactsInput): Promise<import("../models/session-row").RootSessionArtifacts>;
+    updateSessionStatus(sessionId: string, status: SessionStatus, exitCode?: number | null): Promise<{
+        updated: boolean;
+        endedAt?: string;
+    }>;
+    updateSession(input: {
+        sessionId: string;
+        prompt?: string | null;
+        metadata?: Record<string, unknown> | null;
+        title?: string | null;
+    }): Promise<{
+        updated: boolean;
+    }>;
+    queueSpawnRequest(event: HookEventPayload): Promise<void>;
+    upsertSubagentSession(input: import("../models/session-row").UpsertSubagentInput): Promise<string | undefined>;
+    upsertSubagentSessionFromHook(event: HookEventPayload): Promise<string | undefined>;
+    appendSubagentHookAudit(_subSessionId: string, event: HookEventPayload): Promise<void>;
+    persistSessionMessages(sessionId: string, messages: LlmsProviders.Message[], systemPrompt?: string): Promise<void>;
+    applySubagentStatus(subSessionId: string, event: HookEventPayload): Promise<void>;
+    applySubagentStatusBySessionId(subSessionId: string, status: SessionStatus): Promise<void>;
+    applyStatusToRunningChildSessions(parentSessionId: string, status: Exclude<SessionStatus, "running">): Promise<void>;
+    onTeamTaskStart(rootSessionId: string, agentId: string, message: string): Promise<void>;
+    onTeamTaskEnd(rootSessionId: string, agentId: string, status: SessionStatus, summary?: string, result?: AgentResult, messages?: LlmsProviders.Message[]): Promise<void>;
+    onTeamTaskProgress(rootSessionId: string, agentId: string, progress: string, options?: {
+        kind?: "heartbeat" | "progress" | "text";
+    }): Promise<void>;
+    handleSubAgentStart(rootSessionId: string, context: SubAgentStartContext): Promise<void>;
+    handleSubAgentEnd(rootSessionId: string, context: SubAgentEndContext): Promise<void>;
+    private isPidAlive;
+    private reconcileDeadRunningSession;
+    listSessions(limit?: number): Promise<SessionRow[]>;
+    reconcileDeadSessions(limit?: number): Promise<number>;
+    deleteSession(sessionId: string): Promise<{
+        deleted: boolean;
+    }>;
+}

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

@@ -0,0 +1,13 @@
+import type { SqliteSessionStore } from "../../services/storage/sqlite-session-store";
+import type { SessionMessagesArtifactUploader } from "../../types/session";
+import { type CreateRootSessionInput } from "../models/session-row";
+import { UnifiedSessionPersistenceService } from "./persistence-service";
+export declare class CoreSessionService extends UnifiedSessionPersistenceService {
+    private readonly store;
+    constructor(store: SqliteSessionStore, options?: {
+        sessionArtifactsDir?: string;
+        messagesArtifactUploader?: SessionMessagesArtifactUploader;
+    });
+    createRootSession(input: CreateRootSessionInput): void;
+}
+export type { CreateRootSessionInput, CreateRootSessionWithArtifactsInput, RootSessionArtifacts, SessionRow, UpsertSubagentInput, } from "../models/session-row";

package/dist/session/session-snapshot.d.ts

@@ -0,0 +1,57 @@
+import type * as LlmsProviders from "@cline/llms";
+import type { CheckpointEntry } from "../hooks/checkpoint-hooks";
+import type { SessionAccumulatedUsage } from "../runtime/host/runtime-host";
+import type { SessionRecord } from "../types/sessions";
+export interface CoreSessionCheckpointSnapshot {
+    enabled?: boolean;
+    latest?: CheckpointEntry;
+    history: CheckpointEntry[];
+}
+export interface CoreSessionSnapshot {
+    version: 1;
+    sessionId: string;
+    source: SessionRecord["source"];
+    status: SessionRecord["status"];
+    createdAt: string;
+    updatedAt: string;
+    endedAt?: string | null;
+    exitCode?: number | null;
+    interactive: boolean;
+    workspace: {
+        cwd: string;
+        root: string;
+    };
+    model: {
+        providerId: string;
+        modelId: string;
+    };
+    capabilities: {
+        enableTools: boolean;
+        enableSpawn: boolean;
+        enableTeams: boolean;
+    };
+    lineage: {
+        parentSessionId?: string;
+        parentAgentId?: string;
+        agentId?: string;
+        conversationId?: string;
+        isSubagent: boolean;
+    };
+    team?: {
+        name: string;
+    };
+    prompt?: string;
+    metadata?: Record<string, unknown>;
+    artifacts?: {
+        messagesPath?: string;
+    };
+    messages?: LlmsProviders.Message[];
+    usage?: SessionAccumulatedUsage;
+    checkpoint?: CoreSessionCheckpointSnapshot;
+}
+export declare function createCoreSessionSnapshot(input: {
+    session: SessionRecord;
+    messages?: LlmsProviders.Message[];
+    usage?: SessionAccumulatedUsage;
+}): CoreSessionSnapshot;
+export declare function coreSessionSnapshotToRecord(snapshot: CoreSessionSnapshot): SessionRecord;

package/dist/session/session-versioning-service.d.ts

@@ -0,0 +1,48 @@
+import type * as LlmsProviders from "@cline/llms";
+import type { CheckpointEntry, CheckpointMetadata } from "../hooks/checkpoint-hooks";
+import type { RestoreSessionInput } from "../runtime/host/runtime-host";
+import type { SessionRecord } from "../types/sessions";
+import { type CheckpointRestorePlan } from "./checkpoint-restore";
+import { type CoreSessionSnapshot } from "./session-snapshot";
+export type SessionVersioningErrorCode = "invalid_restore" | "session_not_found" | "session_messages_not_found";
+export declare class SessionVersioningError extends Error {
+    readonly code: SessionVersioningErrorCode;
+    constructor(code: SessionVersioningErrorCode, message: string);
+}
+export interface SessionCheckpointRestoreContext {
+    sourceSession: SessionRecord;
+    sourceMessages?: LlmsProviders.Message[];
+    sourceSnapshot: CoreSessionSnapshot;
+    plan: CheckpointRestorePlan;
+    restoredCheckpointMetadata?: CheckpointMetadata;
+    initialMessages: LlmsProviders.Message[];
+    restoreMessages: boolean;
+    restoreWorkspace: boolean;
+    checkpointRunCount: number;
+}
+export interface SessionCheckpointRestoreResult<TStartResult = unknown> {
+    sessionId?: string;
+    startResult?: TStartResult;
+    messages?: LlmsProviders.Message[];
+    checkpoint: CheckpointEntry;
+    sourceSnapshot: CoreSessionSnapshot;
+    restoredSnapshot?: CoreSessionSnapshot;
+}
+export interface SessionCheckpointRestoreInput<TRestoreStartInput, TStartInput, TStartResult> {
+    sessionId: string;
+    checkpointRunCount: number;
+    cwd?: string;
+    restore?: RestoreSessionInput["restore"];
+    start?: TRestoreStartInput;
+    getSession(sessionId: string): Promise<SessionRecord | undefined>;
+    readMessages(sessionId: string): Promise<LlmsProviders.Message[]>;
+    buildStartInput?: (context: SessionCheckpointRestoreContext, start: TRestoreStartInput) => TStartInput | Promise<TStartInput>;
+    startSession?: (input: TStartInput) => Promise<TStartResult>;
+    getStartedSessionId?: (result: TStartResult) => string | undefined;
+    readRestoredSession?: (sessionId: string) => Promise<SessionRecord | undefined>;
+    applyWorkspaceCheckpoint?: (cwd: string, checkpoint: CheckpointEntry) => Promise<void>;
+    retainCheckpointRefs?: (cwd: string, sessionId: string, history: CheckpointEntry[]) => Promise<void>;
+}
+export declare class SessionVersioningService {
+    restoreCheckpoint<TRestoreStartInput, TStartInput, TStartResult>(input: SessionCheckpointRestoreInput<TRestoreStartInput, TStartInput, TStartResult>): Promise<SessionCheckpointRestoreResult<TStartResult>>;
+}

package/dist/session/stores/conversation-store.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Per-session conversation transcript store.
+ *
+ * @see PLAN.md §3.1 — moved from `packages/agents/src/runtime/conversation-store.ts`.
+ * @see PLAN.md §3.2.3 — public surface of `ConversationStore`.
+ *
+ * Pure port of the old agents implementation. Owns the message list,
+ * conversation id, and "session started" gate that today's `Agent`
+ * class uses to decide when to fire `session_start` hooks.
+ */
+import type { MessageWithMetadata } from "@cline/shared";
+/** Generate a fresh conversation id. Exported for reuse by `SessionRuntime`. */
+export declare function createConversationId(): string;
+export declare class ConversationStore {
+    private messages;
+    private conversationId;
+    private sessionStarted;
+    constructor(initialMessages?: readonly MessageWithMetadata[]);
+    getConversationId(): string;
+    getMessages(): MessageWithMetadata[];
+    appendMessage(message: MessageWithMetadata): void;
+    appendMessages(messages: readonly MessageWithMetadata[]): void;
+    replaceMessages(messages: readonly MessageWithMetadata[]): void;
+    resetForRun(): void;
+    clearHistory(): void;
+    restore(messages: readonly MessageWithMetadata[]): void;
+    isSessionStarted(): boolean;
+    markSessionStarted(): void;
+}

package/dist/session/stores/session-manifest-store.d.ts

@@ -0,0 +1,21 @@
+import type * as LlmsProviders from "@cline/llms";
+import { SessionArtifacts } from "../../services/session-artifacts";
+import type { SessionMessagesArtifactUploader, SessionPersistenceAdapter } from "../../types/session";
+import { type SessionManifest } from "../models/session-manifest";
+export declare class SessionManifestStore {
+    private readonly adapter;
+    private readonly messagesArtifactUploader?;
+    readonly artifacts: SessionArtifacts;
+    constructor(adapter: SessionPersistenceAdapter, messagesArtifactUploader?: SessionMessagesArtifactUploader | undefined);
+    ensureSessionsDir(): string;
+    initializeMessagesFile(sessionId: string, path: string, startedAt: string): void;
+    writeSessionManifest(manifestPath: string, manifest: SessionManifest): void;
+    readSessionManifest(sessionId: string): SessionManifest | undefined;
+    readManifestFile(sessionId: string): {
+        path: string;
+        manifest?: SessionManifest;
+    };
+    resolveArtifactPath(sessionId: string, kind: "messagesPath", fallback: (id: string) => string): Promise<string>;
+    persistSessionMessages(sessionId: string, messages: LlmsProviders.Message[], systemPrompt?: string): Promise<void>;
+    appendStaleSessionHookLog(detectedAt: string, sessionId: string, pid: number, reason: string, source: string): void;
+}

package/dist/session/stores/team-persistence-store.d.ts

@@ -0,0 +1,23 @@
+import type { TeamTeammateSpec } from "@cline/shared";
+import type { AgentTeamsRuntime, TeamEvent } from "../../extensions/tools/team";
+import { type TeamRuntimeState } from "../models/session-row";
+export interface FileTeamPersistenceStoreOptions {
+    teamName: string;
+    baseDir?: string;
+}
+export declare class FileTeamPersistenceStore {
+    private readonly dirPath;
+    private readonly statePath;
+    private readonly taskHistoryPath;
+    private readonly teammateSpecs;
+    constructor(options: FileTeamPersistenceStoreOptions);
+    loadState(): TeamRuntimeState | undefined;
+    getTeammateSpecs(): TeamTeammateSpec[];
+    upsertTeammateSpec(spec: TeamTeammateSpec): void;
+    removeTeammateSpec(agentId: string): void;
+    persist(runtime: AgentTeamsRuntime): void;
+    appendTaskHistory(event: TeamEvent): void;
+    private ensureDir;
+    private hasPersistableState;
+    private clearPersistedState;
+}

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

@@ -0,0 +1,2 @@
+export { TeamChildSessionManager } from "./team-child-session-manager";
+export { buildTeamRunContinuationPrompt, dispatchTeamEventToBackend, emitTeamProgress, formatModePrompt, hasPendingTeamRunWork, notifyTeamRunWaiters, shouldAutoContinueTeamRuns, trackTeamRunState, waitForTeamRunUpdates, } from "./team-session-coordinator";

package/dist/session/team/team-child-session-manager.d.ts

@@ -0,0 +1,35 @@
+import type * as LlmsProviders from "@cline/llms";
+import type { AgentResult } from "@cline/shared";
+import type { SubAgentEndContext, SubAgentStartContext } from "../../extensions/tools/team";
+import type { HookEventPayload } from "../../hooks";
+import type { SessionStatus } from "../../types/common";
+import type { SessionPersistenceAdapter, StoredMessageWithMetadata } from "../../types/session";
+import type { UpsertSubagentInput } from "../models/session-row";
+import type { SessionManifestStore } from "../stores/session-manifest-store";
+export declare class TeamChildSessionManager {
+    private readonly adapter;
+    private readonly manifestStore;
+    private readonly toPersistedMessages;
+    private readonly heartbeatLogIntervalMs;
+    private readonly teamTaskSessionsByAgent;
+    private readonly teamTaskLastHeartbeatBySession;
+    private readonly teamTaskLastProgressLineBySession;
+    constructor(adapter: SessionPersistenceAdapter, manifestStore: SessionManifestStore, toPersistedMessages: (messages: LlmsProviders.Message[] | undefined, result?: AgentResult, previousMessages?: LlmsProviders.Message[]) => StoredMessageWithMetadata[] | undefined, heartbeatLogIntervalMs: number);
+    private teamTaskQueueKey;
+    private activeTeamTaskSessionId;
+    private buildSubsessionRow;
+    queueSpawnRequest(event: HookEventPayload): Promise<void>;
+    upsertSubagentSession(input: UpsertSubagentInput): Promise<string | undefined>;
+    upsertSubagentSessionFromHook(event: HookEventPayload): Promise<string | undefined>;
+    applySubagentStatus(subSessionId: string, event: HookEventPayload): Promise<void>;
+    applySubagentStatusBySessionId(subSessionId: string, status: SessionStatus): Promise<void>;
+    applyStatusToRunningChildSessions(parentSessionId: string, status: Exclude<SessionStatus, "running">): Promise<void>;
+    onTeamTaskStart(rootSessionId: string, agentId: string, message: string): Promise<void>;
+    onTeamTaskEnd(rootSessionId: string, agentId: string, status: SessionStatus, _summary?: string, result?: AgentResult, messages?: LlmsProviders.Message[]): Promise<void>;
+    onTeamTaskProgress(rootSessionId: string, agentId: string, progress: string, options?: {
+        kind?: "heartbeat" | "progress" | "text";
+    }): Promise<void>;
+    handleSubAgentStart(rootSessionId: string, context: SubAgentStartContext): Promise<void>;
+    handleSubAgentEnd(rootSessionId: string, context: SubAgentEndContext): Promise<void>;
+    appendSubagentHookAudit(event: HookEventPayload): void;
+}

package/dist/session/team/team-session-coordinator.d.ts

@@ -0,0 +1,13 @@
+import { type AgentMode, type AgentResult } from "@cline/shared";
+import type { TeamEvent } from "../../extensions/tools/team";
+import type { CoreSessionEvent } from "../../types/events";
+import type { ActiveSession, TeamRunUpdate } from "../../types/session";
+export declare function trackTeamRunState(session: ActiveSession, event: TeamEvent): void;
+export declare function dispatchTeamEventToBackend(rootSessionId: string, event: TeamEvent, invokeOptional: (method: string, ...args: unknown[]) => Promise<void>): Promise<void>;
+export declare function emitTeamProgress(session: ActiveSession, rootSessionId: string, event: TeamEvent, emit: (event: CoreSessionEvent) => void): void;
+export declare function hasPendingTeamRunWork(session: ActiveSession): boolean;
+export declare function shouldAutoContinueTeamRuns(session: ActiveSession, finishReason: AgentResult["finishReason"]): boolean;
+export declare function notifyTeamRunWaiters(session: ActiveSession): void;
+export declare function waitForTeamRunUpdates(session: ActiveSession): Promise<TeamRunUpdate[]>;
+export declare function buildTeamRunContinuationPrompt(session: ActiveSession, updates: TeamRunUpdate[]): string;
+export declare function formatModePrompt(prompt: string, mode: AgentMode | undefined): string;

package/dist/settings/index.d.ts

@@ -0,0 +1,2 @@
+export { CoreSettingsService, createCoreSettingsService, } from "./settings-service";
+export type { ClineCoreSettingsApi, CoreSettingsItem, CoreSettingsItemKind, CoreSettingsItemSource, CoreSettingsListInput, CoreSettingsMutationResult, CoreSettingsSnapshot, CoreSettingsToggleInput, CoreSettingsType, } from "./types";

package/dist/settings/settings-service.d.ts

@@ -0,0 +1,6 @@
+import type { CoreSettingsListInput, CoreSettingsMutationResult, CoreSettingsSnapshot, CoreSettingsToggleInput } from "./types";
+export declare class CoreSettingsService {
+    list(input?: CoreSettingsListInput): Promise<CoreSettingsSnapshot>;
+    toggle(input: CoreSettingsToggleInput): Promise<CoreSettingsMutationResult>;
+}
+export declare function createCoreSettingsService(): CoreSettingsService;

package/dist/settings/types.d.ts

@@ -0,0 +1,42 @@
+import type { UserInstructionConfigService } from "../extensions/config";
+import type { BuiltinToolAvailabilityContext } from "../extensions/tools";
+export type CoreSettingsType = "skills" | "workflows" | "rules" | "tools";
+export type CoreSettingsItemKind = "skill" | "workflow" | "rule" | "tool";
+export type CoreSettingsItemSource = "global" | "workspace" | "builtin" | "global-plugin" | "workspace-plugin";
+export interface CoreSettingsItem {
+    id: string;
+    name: string;
+    path: string;
+    kind: CoreSettingsItemKind;
+    source: CoreSettingsItemSource;
+    enabled?: boolean;
+    description?: string;
+    toggleable?: boolean;
+}
+export interface CoreSettingsSnapshot {
+    workflows: CoreSettingsItem[];
+    rules: CoreSettingsItem[];
+    skills: CoreSettingsItem[];
+    tools: CoreSettingsItem[];
+}
+export interface CoreSettingsListInput {
+    cwd?: string;
+    workspaceRoot?: string;
+    userInstructionService?: UserInstructionConfigService;
+    availabilityContext?: BuiltinToolAvailabilityContext;
+}
+export interface CoreSettingsToggleInput extends CoreSettingsListInput {
+    type: CoreSettingsType;
+    id?: string;
+    path?: string;
+    name?: string;
+    enabled?: boolean;
+}
+export interface CoreSettingsMutationResult {
+    snapshot: CoreSettingsSnapshot;
+    changedTypes: CoreSettingsType[];
+}
+export interface ClineCoreSettingsApi {
+    list(input?: CoreSettingsListInput): Promise<CoreSettingsSnapshot>;
+    toggle(input: CoreSettingsToggleInput): Promise<CoreSettingsMutationResult>;
+}

package/dist/types/chat-schema.d.ts

@@ -0,0 +1,161 @@
+import { z } from "zod";
+export declare const ChatSessionConfigSchema: z.ZodObject<{
+    workspaceRoot: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    provider: z.ZodString;
+    model: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<{
+        act: "act";
+        plan: "plan";
+    }>>;
+    apiKey: z.ZodString;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    rules: z.ZodOptional<z.ZodString>;
+    maxIterations: z.ZodOptional<z.ZodNumber>;
+    enableTools: z.ZodBoolean;
+    enableSpawn: z.ZodOptional<z.ZodBoolean>;
+    enableTeams: z.ZodOptional<z.ZodBoolean>;
+    autoApproveTools: z.ZodOptional<z.ZodBoolean>;
+    missionStepInterval: z.ZodOptional<z.ZodNumber>;
+    missionTimeIntervalMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const ChatSessionStatusSchema: z.ZodEnum<{
+    error: "error";
+    idle: "idle";
+    running: "running";
+    completed: "completed";
+    failed: "failed";
+    starting: "starting";
+    stopping: "stopping";
+    cancelled: "cancelled";
+}>;
+export declare const ChatMessageRoleSchema: z.ZodEnum<{
+    system: "system";
+    status: "status";
+    error: "error";
+    user: "user";
+    assistant: "assistant";
+    tool: "tool";
+}>;
+export declare const ChatMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    sessionId: z.ZodNullable<z.ZodString>;
+    role: z.ZodEnum<{
+        system: "system";
+        status: "status";
+        error: "error";
+        user: "user";
+        assistant: "assistant";
+        tool: "tool";
+    }>;
+    content: z.ZodString;
+    createdAt: z.ZodNumber;
+    meta: z.ZodOptional<z.ZodObject<{
+        stream: z.ZodOptional<z.ZodEnum<{
+            stdout: "stdout";
+            stderr: "stderr";
+        }>>;
+        toolName: z.ZodOptional<z.ZodString>;
+        iteration: z.ZodOptional<z.ZodNumber>;
+        agentId: z.ZodOptional<z.ZodString>;
+        conversationId: z.ZodOptional<z.ZodString>;
+        hookEventName: z.ZodOptional<z.ZodString>;
+        inputTokens: z.ZodOptional<z.ZodNumber>;
+        outputTokens: z.ZodOptional<z.ZodNumber>;
+        checkpoint: z.ZodOptional<z.ZodObject<{
+            ref: z.ZodString;
+            createdAt: z.ZodNumber;
+            runCount: z.ZodNumber;
+            kind: z.ZodOptional<z.ZodEnum<{
+                commit: "commit";
+                stash: "stash";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ChatSummarySchema: z.ZodObject<{
+    toolCalls: z.ZodNumber;
+    tokensIn: z.ZodNumber;
+    tokensOut: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ChatViewStateSchema: z.ZodObject<{
+    sessionId: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        error: "error";
+        idle: "idle";
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        starting: "starting";
+        stopping: "stopping";
+        cancelled: "cancelled";
+    }>;
+    config: z.ZodObject<{
+        workspaceRoot: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        provider: z.ZodString;
+        model: z.ZodString;
+        mode: z.ZodDefault<z.ZodEnum<{
+            act: "act";
+            plan: "plan";
+        }>>;
+        apiKey: z.ZodString;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        rules: z.ZodOptional<z.ZodString>;
+        maxIterations: z.ZodOptional<z.ZodNumber>;
+        enableTools: z.ZodBoolean;
+        enableSpawn: z.ZodOptional<z.ZodBoolean>;
+        enableTeams: z.ZodOptional<z.ZodBoolean>;
+        autoApproveTools: z.ZodOptional<z.ZodBoolean>;
+        missionStepInterval: z.ZodOptional<z.ZodNumber>;
+        missionTimeIntervalMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    messages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sessionId: z.ZodNullable<z.ZodString>;
+        role: z.ZodEnum<{
+            system: "system";
+            status: "status";
+            error: "error";
+            user: "user";
+            assistant: "assistant";
+            tool: "tool";
+        }>;
+        content: z.ZodString;
+        createdAt: z.ZodNumber;
+        meta: z.ZodOptional<z.ZodObject<{
+            stream: z.ZodOptional<z.ZodEnum<{
+                stdout: "stdout";
+                stderr: "stderr";
+            }>>;
+            toolName: z.ZodOptional<z.ZodString>;
+            iteration: z.ZodOptional<z.ZodNumber>;
+            agentId: z.ZodOptional<z.ZodString>;
+            conversationId: z.ZodOptional<z.ZodString>;
+            hookEventName: z.ZodOptional<z.ZodString>;
+            inputTokens: z.ZodOptional<z.ZodNumber>;
+            outputTokens: z.ZodOptional<z.ZodNumber>;
+            checkpoint: z.ZodOptional<z.ZodObject<{
+                ref: z.ZodString;
+                createdAt: z.ZodNumber;
+                runCount: z.ZodNumber;
+                kind: z.ZodOptional<z.ZodEnum<{
+                    commit: "commit";
+                    stash: "stash";
+                }>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    rawTranscript: z.ZodString;
+    error: z.ZodNullable<z.ZodString>;
+    summary: z.ZodObject<{
+        toolCalls: z.ZodNumber;
+        tokensIn: z.ZodNumber;
+        tokensOut: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ChatSessionConfig = z.infer<typeof ChatSessionConfigSchema>;
+export type ChatSessionStatus = z.infer<typeof ChatSessionStatusSchema>;
+export type ChatMessage = z.infer<typeof ChatMessageSchema>;
+export type ChatSummary = z.infer<typeof ChatSummarySchema>;
+export type ChatViewState = z.infer<typeof ChatViewStateSchema>;

package/dist/types/common.d.ts

@@ -0,0 +1,19 @@
+export declare const SESSION_STATUSES: readonly ["running", "completed", "failed", "cancelled"];
+export type SessionStatus = (typeof SESSION_STATUSES)[number];
+export declare const SessionSource: {
+    readonly CORE: "core";
+    readonly CLI: "cli";
+    readonly SUBAGENT: "subagent";
+    readonly DESKTOP: "desktop";
+    readonly KANBAN: "kanban";
+    readonly API: "api";
+    readonly WEB: "web";
+    readonly VSCODE: "vscode";
+    readonly ENTERPRISE: "enterprise";
+    readonly IDE: "ide";
+    readonly JETBRAINS: "jetbrains";
+    readonly NEOVIM: "neovim";
+    readonly UNKNOWN: "unknown";
+};
+export type BuiltinSessionSource = (typeof SessionSource)[keyof typeof SessionSource];
+export type SessionSource = BuiltinSessionSource | (string & {});