@cline/core 0.0.82 → 0.0.83

package/dist/ClineCore.d.ts

@@ -300,6 +300,15 @@ export declare class ClineCore {
      * ```
      */
     subscribe(listener: (event: CoreSessionEvent) => void, options?: RuntimeHostSubscribeOptions): () => void;
+    /**
+     * Whether this instance is subscribed to a session's live events.
+     *
+     * In hub mode ClineCore subscribes to a session when it starts, sends to,
+     * or lists pending prompts for it, and unsubscribes on stop. A client that
+     * also observes the hub directly can use this to render one copy of the
+     * session's events instead of both.
+     */
+    hasSessionSubscription(sessionId: string): boolean;
     /**
      * Updates the AI model used by an active session.
      *

package/dist/account/index.d.ts

@@ -1,3 +1,4 @@
 export { ClineAccountService, type ClineAccountServiceOptions, } from "./cline-account-service";
 export { type ClineAccountOperations, executeClineAccountAction, isClineAccountActionRequest, type ProviderActionExecutor, RpcClineAccountService, } from "./rpc";
+export { type ClineAccountTelemetryIdentity, persistClineAccountTelemetryIdentity, resolveClineAccountTelemetryIdentity, } from "./telemetry";
 export type { ClineAccountBalance, ClineAccountOrganization, ClineAccountOrganizationBalance, ClineAccountOrganizationUsageTransaction, ClineAccountPaymentTransaction, ClineAccountUsageTransaction, ClineAccountUser, ClineOrganization, ClineSubscriptionPlan, FeaturebaseTokenResponse, UserCurrentPlan, UserRemoteConfigOrganization, UserRemoteConfigResponse, } from "./types";

package/dist/account/telemetry.d.ts

@@ -0,0 +1,22 @@
+import type { ProviderSettingsManager } from "../services/storage/provider-settings-manager";
+import type { ClineAccountUser } from "./types";
+/** Account identity shared by telemetry and feature-flag integrations. */
+export interface ClineAccountTelemetryIdentity {
+    id: string;
+    email?: string;
+    provider: "cline";
+    organizationId?: string;
+    organizationName?: string;
+    memberId?: string;
+}
+/**
+ * Resolve the authenticated user and active organization once so every client
+ * applies the same cross-surface account dimensions.
+ */
+export declare function resolveClineAccountTelemetryIdentity(user: ClineAccountUser): ClineAccountTelemetryIdentity;
+/**
+ * Persist the latest active organization alongside OAuth settings. Detached
+ * runtime processes (notably the shared Hub) can then enrich task telemetry
+ * without making their own account API request.
+ */
+export declare function persistClineAccountTelemetryIdentity(manager: Pick<ProviderSettingsManager, "getProviderSettings" | "saveProviderSettings">, identity: ClineAccountTelemetryIdentity): boolean;

package/dist/cron/events/cron-event-ingress.d.ts

@@ -3,8 +3,9 @@ import type { CronEventLogRecord, CronRunRecord, CronSpecRecord, SqliteCronStore
 /**
  * Durable ingress for normalized automation events.
  *
- * This layer persists the incoming event before matching, then materializes
- * queued `cron_runs` for matching event specs. It deliberately does not
+ * This layer atomically persists the incoming event and materializes queued
+ * `cron_runs` for matching event specs. Failed acceptance rolls back so the
+ * same event can be redelivered without partial fan-out. It deliberately does not
  * execute agents; the normal runner claim loop owns execution.
  */
 export interface CronEventIngressOptions {
@@ -33,5 +34,6 @@ export declare class CronEventIngress {
     private readonly logger?;
     constructor(options: CronEventIngressOptions);
     ingestEvent(event: AutomationEventEnvelope): CronEventIngressResult;
+    private materializeEvent;
     private materializeForSpec;
 }

package/dist/cron/runner/cron-runner.d.ts

@@ -1,4 +1,4 @@
-import type { BasicLogger } from "@cline/shared";
+import type { BasicLogger, ITelemetryService } from "@cline/shared";
 import type { ResolveCronSpecsDirOptions } from "@cline/shared/storage";
 import type { HubScheduleRuntimeHandlers } from "../service/schedule-service";
 import type { CronRunRecord, CronSpecRecord, SqliteCronStore } from "../store/sqlite-cron-store";
@@ -26,6 +26,7 @@ export interface CronRunnerOptions {
     /** Cron spec source/report location. Defaults to global `~/.cline/cron`. */
     specs?: ResolveCronSpecsDirOptions;
     logger?: BasicLogger;
+    telemetry?: ITelemetryService;
     pollIntervalMs?: number;
     claimLeaseSeconds?: number;
     globalMaxConcurrency?: number;
@@ -34,7 +35,6 @@ export declare class CronRunner {
     private readonly store;
     private readonly materializer;
     private readonly options;
-    private readonly limiter;
     private readonly claimLeaseMs;
     private timer;
     private started;
@@ -42,6 +42,7 @@ export declare class CronRunner {
     private disposed;
     private stopping;
     private readonly activeRuns;
+    private readonly executions;
     constructor(options: CronRunnerOptions);
     start(): Promise<void>;
     stop(): Promise<void>;
@@ -52,6 +53,8 @@ export declare class CronRunner {
         sessionId?: string;
     }>;
     private executeClaim;
+    private writeReport;
+    private cleanupSession;
     private publishScheduleExecutionEvent;
     private buildPrompt;
     private startClaimLeaseHeartbeat;

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

@@ -1,4 +1,4 @@
-import type { AutomationEventEnvelope, BasicLogger } from "@cline/shared";
+import type { AutomationEventEnvelope, BasicLogger, ITelemetryService } from "@cline/shared";
 import type { ResolveCronSpecsDirOptions } from "@cline/shared/storage";
 import { type CronEventIngressResult } from "../events/cron-event-ingress";
 import type { CronRunRecord, CronSpecRecord, ListEventLogsOptions, ListRunsOptions, ListSpecsOptions } from "../store/sqlite-cron-store";
@@ -25,6 +25,7 @@ export interface CronServiceOptions {
     runtimeHandlers: HubScheduleRuntimeHandlers;
     dbPath?: string;
     logger?: BasicLogger;
+    telemetry?: ITelemetryService;
     pollIntervalMs?: number;
     claimLeaseSeconds?: number;
     globalMaxConcurrency?: number;

package/dist/cron/service/schedule-service.d.ts

@@ -1,4 +1,4 @@
-import { type BasicLogger, type ChatRunTurnRequest, type ChatStartSessionArtifacts, type ChatStartSessionRequest, type HubScheduleCreateInput, type HubScheduleUpdateInput, type ScheduleExecutionRecord, type ScheduleExecutionStatus, type ScheduleRecord } from "@cline/shared";
+import { type BasicLogger, type ChatRunTurnRequest, type ChatStartSessionArtifacts, type ChatStartSessionRequest, type HubScheduleCreateInput, type HubScheduleUpdateInput, type ITelemetryService, type ScheduleExecutionRecord, type ScheduleExecutionStatus, type ScheduleRecord } from "@cline/shared";
 import type { ResolveCronSpecsDirOptions } from "@cline/shared/storage";
 type HubScheduleTurnResult = {
     text: string;
@@ -56,6 +56,7 @@ export interface HubScheduleServiceOptions {
     runtimeHandlers: HubScheduleRuntimeHandlers;
     eventPublisher?: (eventType: string, payload: Record<string, unknown>) => void;
     logger?: BasicLogger;
+    telemetry?: ITelemetryService;
     dbPath?: string;
     /**
      * Cron spec source/report location forwarded to the runner. Defaults to

package/dist/cron/store/sqlite-cron-store.d.ts

@@ -128,6 +128,8 @@ export interface ListRunsOptions {
     limit?: number;
 }
 export interface ClaimRunOptions {
+    /** Database-wide concurrency limit; defaults to 10. Per-spec limits always apply. */
+    maxConcurrency?: number;
     nowIso: string;
     leaseMs: number;
     limit?: number;
@@ -206,6 +208,8 @@ export declare class SqliteCronStore {
      * for an unknown run.
      */
     getRunOrdinal(runId: string): number | undefined;
+    /** Execute synchronous event acceptance and materialization as one atomic write. */
+    eventTransaction<T>(work: () => T): T;
     insertEventLog(event: AutomationEventEnvelope, options?: {
         receivedAtIso?: string;
     }): InsertEventLogResult;
@@ -254,8 +258,10 @@ export declare class SqliteCronStore {
     requeueRun(update: ClaimBoundUpdate & {
         error?: string;
         scheduledFor?: string;
+        /** Undo the claim's attempt increment when execution never started. */
+        releaseAttempt?: boolean;
     }): boolean;
-    attachSessionIdToRun(runId: string, sessionId: string): void;
+    attachSessionIdToRun(runId: string, sessionId: string, claimToken: string): boolean;
     attachReportPathToRun(runId: string, reportPath: string): void;
 }
 export {};

package/dist/extensions/agent-plugin/agent-skill.d.ts

@@ -0,0 +1,21 @@
+export interface AgentSkillMetadata {
+    name: string;
+    description: string;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+    "allowed-tools"?: string;
+}
+export interface ParsedAgentSkill {
+    metadata: AgentSkillMetadata;
+    instructions: string;
+    frontmatter: Record<string, unknown>;
+}
+/**
+ * Parse and validate one Agent Skills specification `SKILL.md` document.
+ *
+ * Cline's own skill files intentionally remain backwards-compatible and more
+ * permissive. Agent Plugin skills go through this strict path because the
+ * Agent Plugins contract requires an invalid skill to be skipped in isolation.
+ */
+export declare function parseAgentSkillMarkdown(content: string, directoryName: string): ParsedAgentSkill;

package/dist/extensions/agent-plugin/index.d.ts

@@ -0,0 +1,4 @@
+export type { AgentSkillMetadata, ParsedAgentSkill } from "./agent-skill";
+export { parseAgentSkillMarkdown } from "./agent-skill";
+export { AGENT_PLUGINS_V1_MANIFEST_SCHEMA, AGENT_PLUGINS_V1_MCP_SCHEMA, getAgentPluginPackageDisplayName, loadAgentPluginPackages, } from "./loader";
+export type { AgentPluginPackageDiagnostic, AgentPluginPackageDiagnosticScope, AgentPluginPackageLoadReport, AgentPluginPackageManifest, AgentPluginPackageMcpServer, AgentPluginPackageSkill, LoadAgentPluginPackagesOptions, LoadedAgentPluginPackage, } from "./types";

package/dist/extensions/agent-plugin/loader.d.ts

@@ -0,0 +1,10 @@
+import type { AgentPluginPackageLoadReport, LoadAgentPluginPackagesOptions } from "./types";
+export declare const AGENT_PLUGINS_V1_MANIFEST_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
+export declare const AGENT_PLUGINS_V1_MCP_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
+/**
+ * Discover and load Agent Plugins v1 from runtime-host-local filesystem paths.
+ * No schema is fetched over the network: canonical identifiers select the
+ * validation code bundled with this SDK build.
+ */
+export declare function loadAgentPluginPackages(options?: LoadAgentPluginPackagesOptions): Promise<AgentPluginPackageLoadReport>;
+export declare function getAgentPluginPackageDisplayName(path: string): string;

package/dist/extensions/agent-plugin/types.d.ts

@@ -0,0 +1,67 @@
+import type { McpServerRegistration } from "../mcp";
+import type { AgentSkillMetadata } from "./agent-skill";
+export interface AgentPluginPackageManifest {
+    $schema: string;
+    name: string;
+    version?: string;
+    description?: string;
+    author?: {
+        name?: string;
+        email?: string;
+        url?: string;
+    };
+    homepage?: string;
+    repository?: string;
+    license?: string;
+    keywords?: string[];
+    extensions?: Record<string, unknown>;
+}
+export interface AgentPluginPackageSkill {
+    pluginName: string;
+    pluginRoot: string;
+    directoryPath: string;
+    filePath: string;
+    metadata: AgentSkillMetadata;
+}
+export interface AgentPluginPackageMcpServer {
+    pluginName: string;
+    pluginRoot: string;
+    pluginDataPath?: string;
+    serverName: string;
+    registration: McpServerRegistration;
+}
+export type AgentPluginPackageDiagnosticScope = "plugin" | "manifest" | "skills" | "skill" | "mcp" | "mcp-server";
+export interface AgentPluginPackageDiagnostic {
+    level: "warning" | "error";
+    scope: AgentPluginPackageDiagnosticScope;
+    pluginPath: string;
+    pluginName?: string;
+    componentPath?: string;
+    componentName?: string;
+    message: string;
+}
+export interface LoadedAgentPluginPackage {
+    rootPath: string;
+    manifestPath: string;
+    manifest: AgentPluginPackageManifest;
+    skills: AgentPluginPackageSkill[];
+    mcpServers: AgentPluginPackageMcpServer[];
+}
+export interface AgentPluginPackageLoadReport {
+    plugins: LoadedAgentPluginPackage[];
+    skills: AgentPluginPackageSkill[];
+    mcpServers: AgentPluginPackageMcpServer[];
+    diagnostics: AgentPluginPackageDiagnostic[];
+}
+export interface LoadAgentPluginPackagesOptions {
+    /** Explicit plugin roots, resolved on the runtime host relative to `cwd`. */
+    pluginPaths?: ReadonlyArray<string>;
+    /** Base directory for resolving relative explicit plugin paths. */
+    cwd?: string;
+    /** Override automatic search roots. Primarily useful to embedded hosts/tests. */
+    searchPaths?: ReadonlyArray<string>;
+    /** Override the client-managed persistent Agent Plugin data root. */
+    pluginDataRoot?: string;
+    /** Manifest names disabled by the runtime host. Disabled names still reserve precedence. */
+    disabledPluginNames?: ReadonlyArray<string>;
+}

package/dist/extensions/config/index.d.ts

@@ -4,4 +4,4 @@ export { UnifiedConfigFileWatcher } from "./unified-config-file-watcher";
 export type { CreateInstructionWatcherOptions, CreateRulesConfigDefinitionOptions, CreateSkillsConfigDefinitionOptions, CreateWorkflowsConfigDefinitionOptions, ParseMarkdownFrontmatterResult, RuleConfig, SkillConfig, UserInstructionConfig, UserInstructionConfigType, WorkflowConfig, } from "./user-instruction-config-loader";
 export { createRulesConfigDefinition, createSkillsConfigDefinition, createWorkflowsConfigDefinition, parseRuleConfigFromMarkdown, parseSkillConfigFromMarkdown, parseWorkflowConfigFromMarkdown, RULES_CONFIG_DIRECTORY_NAME, resolveRulesConfigSearchPaths, resolveSkillsConfigSearchPaths, resolveWorkflowsConfigSearchPaths, SKILLS_CONFIG_DIRECTORY_NAME, WORKFLOWS_CONFIG_DIRECTORY_NAME, } from "./user-instruction-config-loader";
 export type { CreateUserInstructionConfigServiceOptions, UserInstructionConfigRecord, UserInstructionConfigService, } from "./user-instruction-service";
-export { createUserInstructionConfigService } from "./user-instruction-service";
+export { combineUserInstructionConfigServices, createUserInstructionConfigService, } from "./user-instruction-service";

package/dist/extensions/config/user-instruction-config-loader.d.ts

@@ -1,4 +1,5 @@
 import { RULES_CONFIG_DIRECTORY_NAME, SKILLS_CONFIG_DIRECTORY_NAME, WORKFLOWS_CONFIG_DIRECTORY_NAME } from "@cline/shared/storage";
+import { type AgentPluginPackageSkill } from "../agent-plugin";
 import { type UnifiedConfigDefinition, UnifiedConfigFileWatcher, type UnifiedConfigWatcherEvent } from "./unified-config-file-watcher";
 export { RULES_CONFIG_DIRECTORY_NAME, SKILLS_CONFIG_DIRECTORY_NAME, WORKFLOWS_CONFIG_DIRECTORY_NAME, };
 export interface ParseMarkdownFrontmatterResult {
@@ -13,6 +14,13 @@ export interface SkillConfig {
     disabled?: boolean;
     instructions: string;
     frontmatter: Record<string, unknown>;
+    source?: {
+        type: "agent-plugin";
+        pluginName: string;
+        pluginRoot: string;
+        skillRoot: string;
+        filePath: string;
+    };
 }
 export interface RuleConfig {
     name: string;
@@ -40,6 +48,7 @@ export interface CreateSkillsConfigDefinitionOptions {
     workspacePath?: string;
     includePluginSkills?: boolean;
     pluginSkillDirectories?: ReadonlyArray<string>;
+    agentPluginSkills?: ReadonlyArray<AgentPluginPackageSkill>;
     pluginPaths?: ReadonlyArray<string>;
     cwd?: string;
 }

package/dist/extensions/config/user-instruction-plugin.d.ts

@@ -10,6 +10,7 @@ type SkillsExecutorMetadataItem = {
 type ConfiguredSkill = SkillsExecutorMetadataItem & {
     skill: SkillConfig;
 };
+export declare function formatSkillInvocation(skill: Pick<SkillConfig, "name" | "description" | "instructions" | "source">, args?: string): string;
 export interface CreateUserInstructionPluginOptions {
     watcher: UserInstructionConfigWatcher;
     watcherReady?: Promise<void>;

package/dist/extensions/config/user-instruction-service.d.ts

@@ -1,5 +1,5 @@
 import type { AgentExtension } from "@cline/shared";
-import type { SkillsExecutorWithMetadata } from "../tools";
+import { type SkillsExecutorWithMetadata } from "../tools";
 import { type AvailableRuntimeCommand, type ResolveRuntimeSlashCommandOptions } from "./runtime-commands";
 import { type CreateUserInstructionConfigWatcherOptions, type UserInstructionConfig, type UserInstructionConfigType } from "./user-instruction-config-loader";
 import { type CreateUserInstructionPluginOptions } from "./user-instruction-plugin";
@@ -22,4 +22,10 @@ export interface UserInstructionConfigService {
     createSkillsExecutor?(allowedSkillNames?: ReadonlyArray<string>): SkillsExecutorWithMetadata;
     createExtension(options: Omit<CreateUserInstructionPluginOptions, "watcher" | "watcherReady">): AgentExtension;
 }
+/**
+ * Present multiple instruction sources as one extension/tool surface. This is
+ * used by the hub to overlay host-local Agent Plugin skills on a client-owned
+ * instruction snapshot without moving package discovery into each client.
+ */
+export declare function combineUserInstructionConfigServices(services: ReadonlyArray<UserInstructionConfigService>): UserInstructionConfigService;
 export declare function createUserInstructionConfigService(options?: CreateUserInstructionConfigServiceOptions): UserInstructionConfigService;

package/dist/extensions/context/compaction.d.ts

@@ -45,6 +45,26 @@ export interface ContextCompactionPrepareTurnOptions {
  * plugin/hook pipelines must be instrumented separately.
  */
 export declare function createContextCompactionPrepareTurn(config: Pick<CoreSessionConfig, "providerConfig" | "providerId" | "modelId" | "compaction" | "logger" | "telemetry" | "sessionId">, options?: ContextCompactionPrepareTurnOptions): ((context: ContextPipelinePrepareTurnInput) => Promise<ContextPipelinePrepareTurnResult | undefined>) | undefined;
+/**
+ * Compaction policy for resuming a session imported from another coding agent.
+ * The imported transcript keeps that agent's tool names and input schemas
+ * verbatim, which a model continuing it may try to call, so the first turn
+ * folds the whole foreign history into a summary before the model request
+ * (manual mode, agentic strategy, nothing preserved but the new prompt).
+ * Runs regardless of the session's auto-compaction setting, tags its status
+ * notices with `importedFrom` so clients can label the wait, and on failure
+ * falls back to the raw transcript. It makes one attempt per session start
+ * (an aborted attempt does not count) and stands down once the working
+ * context already opens with a compaction summary, which is how a resumed
+ * sidecar presents; every other turn defers to `next`, the session's normal
+ * compaction (if any).
+ */
+export declare function createImportedHistoryCompactionPrepareTurn(input: {
+    config: Parameters<typeof createContextCompactionPrepareTurn>[0];
+    /** Source tool id from the session's `importedFrom` metadata. */
+    importedFrom: string;
+    next?: ContextPipelinePrepareTurn;
+}): ContextPipelinePrepareTurn;
 export declare function createCompactionStateAwarePrepareTurn(input: {
     compact?: ContextPipelinePrepareTurn;
     getState?: () => SessionCompactionState | undefined;

package/dist/extensions/index.d.ts

@@ -1,3 +1,5 @@
+export type { AgentPluginPackageDiagnostic, AgentPluginPackageDiagnosticScope, AgentPluginPackageLoadReport, AgentPluginPackageManifest, AgentPluginPackageMcpServer, AgentPluginPackageSkill, AgentSkillMetadata, LoadAgentPluginPackagesOptions, LoadedAgentPluginPackage, ParsedAgentSkill, } from "./agent-plugin";
+export { AGENT_PLUGINS_V1_MANIFEST_SCHEMA, AGENT_PLUGINS_V1_MCP_SCHEMA, loadAgentPluginPackages, parseAgentSkillMarkdown, } from "./agent-plugin";
 export type { ResolveAgentPluginPathsOptions } from "./plugin/plugin-config-loader";
 export { discoverPluginModulePaths, getPluginDisplayName, resolveAgentPluginPaths, resolveAndLoadAgentPlugins, resolvePluginConfigSearchPaths, resolvePluginSkillDirectoriesFromPaths, } from "./plugin/plugin-config-loader";
 export type { PluginInitializationFailure, PluginInitializationWarning, PluginLoadDiagnostics, } from "./plugin/plugin-load-report";

package/dist/extensions/mcp/client.d.ts

@@ -7,6 +7,8 @@ export interface DefaultMcpServerClientFactoryOptions {
     clientName?: string;
     clientVersion?: string;
     fetch?: FetchLike;
+    /** Keep literal configured headers on the declared MCP origin only. */
+    restrictConfiguredHeadersToOrigin?: boolean;
 }
 export interface ProbeMcpServerConnectionOptions extends Omit<DefaultMcpServerClientFactoryOptions, "settingsPath"> {
     serverName: string;

package/dist/extensions/mcp/oauth.d.ts

@@ -6,6 +6,11 @@ import type { FetchLike } from "@modelcontextprotocol/sdk/shared/transport.js";
 import { type OAuthServerCloseInfo, type OAuthServerListeningInfo } from "../../auth/server";
 import type { McpServerOAuthClientConfig, McpServerRegistration } from "./types";
 export type McpSdkAuthCapableTransport = SSEClientTransport | StreamableHTTPClientTransport;
+export declare function createOriginBoundMcpHeadersFetch(input: {
+    endpointUrl: string;
+    configuredHeaders: Record<string, string>;
+    baseFetch?: FetchLike;
+}): FetchLike;
 export interface CreateMcpOAuthProviderContextOptions {
     settingsPath?: string;
     serverName: string;
@@ -50,6 +55,7 @@ export declare function createMcpSdkTransport(input: {
     registration: McpServerRegistration;
     oauthProvider?: OAuthClientProvider;
     fetch?: FetchLike;
+    restrictConfiguredHeadersToOrigin?: boolean;
 }): McpSdkAuthCapableTransport;
 /**
  * Recognizes a 401 from a remote MCP server across transports. The streamable

package/dist/extensions/tools/definitions.d.ts

@@ -3,7 +3,7 @@
  *
  * Factory functions for creating the default tools.
  */
-import { type AgentTool, type ShellKind } from "@cline/shared";
+import { type AgentTool } from "@cline/shared";
 import { type ApplyPatchInput, type AskQuestionInput, type EditFileInput, type FetchWebContentInput, type ReadFilesInput, type SearchCodebaseInput, type SkillsInput, type SubmitInput } from "./schemas";
 import type { ApplyPatchExecutor, AskQuestionExecutor, CreateDefaultToolsOptions, DefaultToolsConfig, EditorExecutor, FileReadExecutor, SearchExecutor, ShellExecutor, SkillsExecutorWithMetadata, ToolOperationResult, VerifySubmitExecutor, WebFetchExecutor } from "./types";
 /**
@@ -20,11 +20,11 @@ export declare function createReadFilesTool(executor: FileReadExecutor, config?:
 export declare function createSearchTool(executor: SearchExecutor, config?: Pick<DefaultToolsConfig, "cwd" | "searchTimeoutMs">): AgentTool<SearchCodebaseInput, ToolOperationResult[]>;
 /**
  * Build the run_commands tool description for the shell that will actually
- * execute the commands. The shell kind decides the syntax guidance (quoting,
- * sequencing, heredocs), and isWindows adds environment context for POSIX
- * shells running on a Windows host (e.g. Git Bash).
+ * execute the commands. Derive the edition and wrapper guidance from the
+ * same executable, without probing a version or adding volatile prompt text.
+ * isWindows describes the host, not the shell's edition.
  */
-export declare function buildRunCommandsDescription(shellKind: ShellKind, isWindows: boolean): string;
+export declare function buildRunCommandsDescription(shell: string, isWindows: boolean): string;
 /**
  * Create the run_commands shell tool for the current platform.
  *

package/dist/hooks/checkpoint-hooks.d.ts

@@ -1,5 +1,20 @@
-import type { AgentHooks, BasicLogger } from "@cline/shared";
+import type { AgentHooks, BasicLogger, ITelemetryService } from "@cline/shared";
 export declare function isCheckpointStashMessage(message: string): boolean;
+/**
+ * Per-session scratch directory holding the persistent `GIT_INDEX_FILE` used
+ * to snapshot untracked files. Persisting the index across turns lets git's
+ * stat cache skip re-reading (and re-hashing) untracked files that have not
+ * changed since the previous checkpoint — without it, every turn re-hashes
+ * every untracked byte in the workspace.
+ *
+ * Lives under the user's Cline data dir (never the world-shared OS tmpdir:
+ * the index and pathspec files enumerate workspace paths) and is keyed by a
+ * hash of cwd + session id: hashing avoids sanitization collisions between
+ * distinct ids, and folding in cwd keeps a session restored against a
+ * different workspace from inheriting a foreign index. Removed by
+ * `deleteCheckpointRefs` and by the age-based reaper.
+ */
+export declare function checkpointScratchDir(cwd: string, sessionId: string): string;
 export interface CheckpointEntry {
     ref: string;
     createdAt: number;
@@ -26,6 +41,13 @@ type CreateCheckpointHooksOptions = {
         sessionId: string;
         runCount: number;
     }) => Promise<CheckpointEntry | undefined> | CheckpointEntry | undefined;
+    /**
+     * Emits one `checkpoint.snapshot` event per built-in snapshot attempt so
+     * snapshot cost and degradations (HEAD fallbacks, skipped turns) are
+     * observable in the field, not only in local logs. Properties carry
+     * outcome and duration — never file paths or contents.
+     */
+    telemetry?: Pick<ITelemetryService, "capture">;
 };
 /**
  * Deletes all private git refs under refs/cline/checkpoints/{sessionId}/ that

package/dist/hub/client/index.d.ts

@@ -7,7 +7,15 @@ export interface HubClientOptions {
     displayName?: string;
     workspaceRoot?: string;
     cwd?: string;
+    /** Hub token sent with the `cline-hub-auth.*` WebSocket subprotocol. */
     authToken?: string;
+    /**
+     * Resolves HTTP headers for each new WebSocket, including reconnects.
+     * This Node-only transport option is mutually exclusive with `authToken`.
+     * Resolver failures are surfaced by `connect()` and `getConnectionError()`;
+     * `Sec-WebSocket-Protocol` must be configured through `authToken` instead.
+     */
+    resolveConnectionHeaders?: () => Readonly<Record<string, string>> | Promise<Readonly<Record<string, string>>>;
     capabilities?: HubClientRegistration["capabilities"];
 }
 export interface LocalHubResolutionOptions {
@@ -57,6 +65,7 @@ export declare class NodeHubClient {
     private reconnectTimer;
     private reconnectAttempt;
     private closedByClient;
+    private connectGeneration;
     private lastCloseError;
     private sawSocketClose;
     private registered;
@@ -68,6 +77,7 @@ export declare class NodeHubClient {
     getConnectionError(): HubTransportError | null;
     updateCapabilities(capabilities: NonNullable<HubClientRegistration["capabilities"]>): Promise<void>;
     connect(): Promise<void>;
+    private openSocket;
     subscribe(listener: (event: HubEventEnvelope) => void, options?: {
         sessionId?: string;
     }): () => void;