@sctg/cline-core 3.84.0-beta.20260524130712

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

@@ -0,0 +1,20 @@
+import type * as LlmsProviders from "@cline/llms";
+import type { CheckpointEntry, CheckpointMetadata } from "../hooks/checkpoint-hooks";
+import type { SessionRecord } from "../types/sessions";
+export interface CheckpointRestorePlan {
+    checkpoint: CheckpointEntry;
+    messages?: LlmsProviders.Message[];
+    cwd: string;
+}
+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 trimMessagesToCheckpoint(messages: LlmsProviders.Message[], runCount: number): LlmsProviders.Message[];
+export declare function trimMessagesBeforeCheckpoint(messages: LlmsProviders.Message[], runCount: number): LlmsProviders.Message[];
+export declare function createCheckpointRestorePlan(input: {
+    session: SessionRecord;
+    messages?: LlmsProviders.Message[];
+    checkpointRunCount: number;
+    cwd?: string;
+    restoreMessages?: boolean;
+}): CheckpointRestorePlan;
+export declare function applyCheckpointToWorktree(cwd: string, checkpoint: CheckpointEntry): Promise<void>;

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,31 @@
+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<{
+        failed: "failed";
+        running: "running";
+        cancelled: "cancelled";
+        pending: "pending";
+        completed: "completed";
+        idle: "idle";
+    }>;
+    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>;
+}, z.core.$strip>;
+export type SessionManifest = z.infer<typeof SessionManifestSchema>;

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

@@ -0,0 +1,92 @@
+import type { TeamTeammateSpec } from "@cline/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;
+    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;
+    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;
+}
+export interface RootSessionArtifacts {
+    manifestPath: string;
+    messagesPath: 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 declare function reviveTeamStateDates(state: TeamRuntimeState): TeamRuntimeState;

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

@@ -0,0 +1,10 @@
+import type { BasicLogger } from "@cline/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;
+}

package/dist/session/services/message-builder.d.ts

@@ -0,0 +1,66 @@
+/**
+ * API-safe message builder for provider payloads.
+ *
+ * @see PLAN.md §3.1 — moved from `packages/agents/src/context/message-builder.ts`.
+ * @see PLAN.md §3.2.3 — public surface of `MessageBuilder`.
+ *
+ * Walks the conversation to produce provider-ready messages, handling
+ * tool-result truncation and outdated-file-content rewrite for compaction.
+ * Per-instance caches make this host state.
+ */
+import { type Message } from "@cline/shared";
+/**
+ * Builds an API-safe message copy without mutating original conversation history.
+ */
+export declare class MessageBuilder {
+    private readonly maxToolResultChars;
+    private readonly targetToolNames;
+    private readonly maxTotalTextBytes;
+    private indexedMessageCount;
+    private indexedTailRef;
+    private readonly toolNameByIdCache;
+    private readonly readLocatorsByToolUseIdCache;
+    private readonly latestReadToolUseByLocatorCache;
+    private readonly latestFullContentOwnerByPathCache;
+    private readResultLocatorCache;
+    constructor(maxToolResultChars?: number, targetToolNames?: Set<string>, maxTotalTextBytes?: number);
+    buildForApi(messages: Message[]): Message[];
+    private transformBlock;
+    private reindex;
+    private addMissingToolResults;
+    private appendMissingToolResults;
+    private shouldMergeUserAfterToolResults;
+    private contentBlocksForUserMerge;
+    private collectToolResultIds;
+    private isToolResultOnlyMessage;
+    private trackMissingToolCalls;
+    private createMissingToolResultMessage;
+    private createMissingToolResultBlocks;
+    private formatMissingToolResultText;
+    private resetIndexes;
+    private getReadLocators;
+    private extractLocatorsFromReadToolInput;
+    private extractReadLocatorsFromToolResultContent;
+    private tryParseReadLocators;
+    private extractLocatorsFromParsedReadResult;
+    private extractLocatorFromReadRequest;
+    private extractLocatorFromResultEntry;
+    private extractPath;
+    private extractLineNumber;
+    private parseReadQuery;
+    private dedupeReadLocators;
+    private toReadLocatorKey;
+    private isFullFileRead;
+    private isOutdatedReadLocator;
+    private replaceOutdatedReadContent;
+    private countOutdatedImageEntries;
+    private replaceOutdatedInString;
+    private replaceOutdatedReadEntry;
+    private isReadTool;
+    private shouldTruncateTool;
+    private truncateToolResultContent;
+    private truncateMiddle;
+    private truncateToTotalTextBudget;
+    private countMessageTextBytes;
+    private collectTruncationCandidates;
+}

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

@@ -0,0 +1,59 @@
+import type * as LlmsProviders from "@cline/llms";
+import type { AgentResult, BasicLogger } from "@cline/shared";
+import type { SubAgentEndContext, SubAgentStartContext } from "../../extensions/tools/team";
+import type { HookEventPayload } from "../../hooks";
+import { type SessionStatus, type TerminalSessionStatus } 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;
+        logger?: BasicLogger;
+    });
+    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: TerminalSessionStatus): 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,15 @@
+import type { BasicLogger } from "@cline/shared";
+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;
+        logger?: BasicLogger;
+    });
+    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,59 @@
+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;
+    aggregateUsage?: SessionAccumulatedUsage;
+    checkpoint?: CoreSessionCheckpointSnapshot;
+}
+export declare function createCoreSessionSnapshot(input: {
+    session: SessionRecord;
+    messages?: LlmsProviders.Message[];
+    usage?: SessionAccumulatedUsage;
+    aggregateUsage?: 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,23 @@
+import type * as LlmsProviders from "@cline/llms";
+import type { BasicLogger } from "@cline/shared";
+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?;
+    private readonly logger?;
+    readonly artifacts: SessionArtifacts;
+    constructor(adapter: SessionPersistenceAdapter, messagesArtifactUploader?: SessionMessagesArtifactUploader | undefined, logger?: BasicLogger | 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, type TerminalSessionStatus } 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: TerminalSessionStatus): 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,43 @@
+import type { UserInstructionConfigService } from "../extensions/config";
+import type { BuiltinToolAvailabilityContext } from "../extensions/tools";
+export type CoreSettingsType = "skills" | "workflows" | "rules" | "tools" | "mcp";
+export type CoreSettingsItemKind = "skill" | "workflow" | "rule" | "tool" | "mcp";
+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[];
+    mcp: 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>;
+}