@cline/core 0.0.81 → 0.0.82

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

@@ -1,8 +1,21 @@
 import type { BasicLogger } from "@cline/shared";
 import type { ResolveCronSpecsDirOptions } from "@cline/shared/storage";
 import type { HubScheduleRuntimeHandlers } from "../service/schedule-service";
-import type { CronRunRecord, SqliteCronStore } from "../store/sqlite-cron-store";
+import type { CronRunRecord, CronSpecRecord, SqliteCronStore } from "../store/sqlite-cron-store";
 import type { CronMaterializer } from "./cron-materializer";
+/**
+ * Session metadata keys that identify the automation run a session belongs
+ * to. Clients (e.g. the desktop sidebar) read these to group a schedule's
+ * runs together and label each one, so they are part of the session
+ * metadata contract; keep them in sync with the readers.
+ */
+export declare const RUN_SESSION_METADATA_KEYS: {
+    readonly scheduleId: "scheduleId";
+    readonly scheduleName: "scheduleName";
+    readonly scheduleExecutionId: "scheduleExecutionId";
+    readonly scheduleRunNumber: "scheduleRunNumber";
+};
+export declare function buildRunSessionMetadata(spec: Pick<CronSpecRecord, "externalId" | "title">, run: Pick<CronRunRecord, "runId">, runNumber: number | undefined): Record<string, unknown>;
 export interface CronRunnerOptions {
     store: SqliteCronStore;
     materializer: CronMaterializer;

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

@@ -22,8 +22,16 @@ type HubScheduleTurnResult = {
         durationMs?: number;
     }>;
 };
+export interface HubScheduleStartSessionOptions {
+    /**
+     * Provenance the runner knows about the automation run that is starting
+     * this session (schedule id/name, run id, run number). Handlers merge it
+     * into the session metadata so clients can group runs by schedule.
+     */
+    sessionMetadata?: Record<string, unknown>;
+}
 export interface HubScheduleRuntimeHandlers {
-    startSession(request: ChatStartSessionRequest): Promise<{
+    startSession(request: ChatStartSessionRequest, options?: HubScheduleStartSessionOptions): Promise<{
         sessionId: string;
         startResult?: ChatStartSessionArtifacts;
     }>;

package/dist/cron/specs/cron-reconciler.d.ts

@@ -1,6 +1,6 @@
 import type { CronSpecParseResult } from "@cline/shared";
 import { type ResolveCronSpecsDirOptions } from "@cline/shared/storage";
-import type { CronSpecRecord, SqliteCronStore, UpsertSpecResult } from "../store/sqlite-cron-store";
+import { type CronSpecRecord, type SqliteCronStore, type UpsertSpecResult } from "../store/sqlite-cron-store";
 /**
  * Scan the configured cron specs directory on disk, parse every file, and
  * upsert spec state into the cron DB. This is the startup source of truth:

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

@@ -106,6 +106,15 @@ export interface UpsertSpecResult {
 export interface SqliteCronStoreOptions {
     dbPath?: string;
 }
+/**
+ * DB-native hub schedules (created via the schedule tools/UI) live only in
+ * cron.db under a virtual sourcePath that never exists on disk. File-backed
+ * specs can spoof `source: hub-schedule` in frontmatter — even inside a
+ * physical `hub/schedules/` directory — but reconciliation always records
+ * their source file's mtime, which DB-native rows never have. All three
+ * markers are required to identify a DB-native hub schedule.
+ */
+export declare function isHubManagedSpec(spec: Pick<CronSpecRecord, "source" | "sourcePath" | "sourceMtimeMs">): boolean;
 export interface ListSpecsOptions {
     triggerKind?: CronTriggerKind;
     enabled?: boolean;
@@ -189,6 +198,14 @@ export declare class SqliteCronStore {
         nowMs: number;
     }): MaterializeScheduleRunResult;
     getRun(runId: string): CronRunRecord | undefined;
+    /**
+     * 1-based position of a run among every run ever created for its spec,
+     * in creation order. Counts runs of every status (including cancelled and
+     * failed ones) so the number is stable: a later cancellation never shifts
+     * the numbers already stamped onto earlier sessions. Returns undefined
+     * for an unknown run.
+     */
+    getRunOrdinal(runId: string): number | undefined;
     insertEventLog(event: AutomationEventEnvelope, options?: {
         receivedAtIso?: string;
     }): InsertEventLogResult;

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

@@ -1,6 +1,7 @@
 import type { FetchLike } from "@modelcontextprotocol/sdk/shared/transport.js";
 import type { McpServerClientFactory } from "./types";
 export declare const DEFAULT_MCP_CONNECT_TIMEOUT_MS = 3000;
+export declare const DEFAULT_HTTP_MCP_CONNECT_TIMEOUT_MS = 10000;
 export interface DefaultMcpServerClientFactoryOptions {
     settingsPath?: string;
     clientName?: string;

package/dist/extensions/tools/executors/line-endings.d.ts

@@ -1,6 +1,6 @@
 /**
- * Line-ending normalization for files created from scratch, shared by the
- * file-writing executors (editor, apply_patch). Internal to the executors.
+ * Line-ending helpers shared by the file-writing executors (editor,
+ * apply_patch). Internal to the executors.
  *
  * Models emit LF-only text (reads strip "\r", so they never see a file's
  * CRLF endings). Existing files keep their own detected EOL, but a new file
@@ -9,3 +9,15 @@
  * (github.com/cline/cline/issues/13504). No-op on LF platforms.
  */
 export declare function normalizeNewFileLineEndings(content: string): string;
+export type LineEnding = "\r\n" | "\n";
+/**
+ * Returns "\r\n" if "\r\n" appears anywhere in the content, otherwise "\n" —
+ * including for content with no line breaks at all. Files are uniformly CRLF
+ * or uniformly LF in practice; the mixed case that matters is a CRLF file
+ * with LF-only lines inserted by earlier releases of these tools, and any
+ * surviving "\r\n" — wherever it sits — should pull such a file back to
+ * CRLF, which is why this checks for "\r\n" anywhere rather than looking at
+ * the first line break.
+ */
+export declare function detectLineEnding(content: string): LineEnding;
+export declare function normalizeLineEndings(text: string, eol: LineEnding): string;

package/dist/extensions/tools/team/multi-agent.d.ts

@@ -20,6 +20,7 @@ export interface TaskResult {
     error?: Error;
     metadata?: Record<string, unknown>;
 }
+type TeamTaskEndStatus = "completed" | "failed" | "cancelled";
 export type TeamEvent = {
     type: TeamMessageType.TaskStart;
     agentId: string;
@@ -27,6 +28,7 @@ export type TeamEvent = {
 } | {
     type: TeamMessageType.TaskEnd;
     agentId: string;
+    status?: TeamTaskEndStatus;
     result?: AgentResult;
     error?: Error;
     messages?: AgentResult["messages"];
@@ -202,6 +204,11 @@ export declare class AgentTeamsRuntime {
     getRun(runId: string): TeamRunRecord | undefined;
     awaitRun(runId: string, pollIntervalMs?: number): Promise<TeamRunRecord>;
     awaitAllRuns(pollIntervalMs?: number): Promise<TeamRunRecord[]>;
+    /**
+     * Cancel work owned by this team runtime without removing teammate or
+     * conversation state. Used when the owning lead session is aborted.
+     */
+    cancelOutstandingWork(reason?: unknown): void;
     cancelRun(runId: string, reason?: string): TeamRunRecord;
     recoverActiveRuns(reason?: string): TeamRunRecord[];
     markStaleRunsInterrupted(reason?: string): TeamRunRecord[];

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

@@ -91,10 +91,17 @@ export declare class NodeHubClient {
 }
 export declare function normalizeHubWebSocketUrl(url: string): string;
 export declare function verifyHubConnection(url: string, options?: Pick<HubClientOptions, "workspaceRoot" | "cwd" | "authToken">): Promise<boolean>;
+export interface HubSessionActivity {
+    /** Sessions with at least one live participant attached. */
+    activeSessionCount: number;
+    /** Distinct client ids attached to those sessions. */
+    participantClientCount: number;
+}
 /**
- * Whether any client is attached to a session on the hub - the one signal
- * that cannot go stale, because participants are live socket subscriptions
- * the hub drops the moment a client's connection closes.
+ * Summarize live activity from a `session.list` payload. A session counts as
+ * active only while a client is attached to it - the one signal that cannot
+ * go stale, because participants are live socket subscriptions the hub drops
+ * the moment a client's connection closes.
  *
  * Deliberately NOT based on session status: a client that dies without
  * stopping its session leaves the hub-side runtime behind in a non-terminal
@@ -104,7 +111,17 @@ export declare function verifyHubConnection(url: string, options?: Pick<HubClien
  * exact moment of a hub swap dies with the old hub - rare, and its next
  * scheduled tick runs normally on the replacement.
  */
+export declare function summarizeHubSessionActivity(payload: unknown): HubSessionActivity;
 export declare function hasActiveHubSessions(payload: unknown): boolean;
+/**
+ * Ask a hub how much live work it is serving. Throws when the hub cannot
+ * answer (unreachable, auth rejected, or too old to serve `session.list`),
+ * because the safe default points in opposite directions per caller: a
+ * replacement path treats an unanswerable hub as idle and retires it, while
+ * a recovery path treats it as busy and leaves it alone. Callers pick their
+ * own fallback instead of inheriting a hidden one.
+ */
+export declare function queryHubSessionActivity(url: string, authToken?: string, options?: Pick<HubClientOptions, "workspaceRoot" | "cwd">): Promise<HubSessionActivity>;
 export declare function localHubHasNoActiveSessions(url: string, authToken?: string, options?: Pick<HubClientOptions, "workspaceRoot" | "cwd">): Promise<boolean>;
 export declare function resolveCompatibleLocalHubUrl(options?: LocalHubResolutionOptions): Promise<string | undefined>;
 export declare function ensureCompatibleLocalHubUrl(options?: LocalHubResolutionOptions): Promise<string | undefined>;

package/dist/hub/client/managed-hub-build-watcher.d.ts

@@ -17,6 +17,14 @@ export interface ManagedHubBuildMismatchEvent {
     hubCoreVersion?: string;
     /** Build identity this client expects a managed Hub to match. */
     expectedBuildId: string;
+    /**
+     * Sessions with live participants on the Hub (best-effort, `outdated_hub`
+     * only): the work that replacing the Hub would interrupt. Unset when the
+     * Hub cannot answer the query.
+     */
+    activeSessionCount?: number;
+    /** Distinct clients attached to those sessions (best-effort, `outdated_hub` only). */
+    participantClientCount?: number;
 }
 /**
  * Probe the managed local Hub once and report whether a live Hub is running

package/dist/hub/client/session-client.d.ts

@@ -1,5 +1,5 @@
 import type * as LlmsProviders from "@cline/llms";
-import type { AgendaAutomationPolicy, AgendaTaskListInput, AgendaTaskRecord, AgendaTaskRunRecord, ChatRunTurnRequest, ChatStartSessionRequest, ChatStartSessionResponse, ChatTurnResult, HubTaskCreateInput, HubTaskUpdateInput, TeamProgressProjectionEvent } from "@cline/shared";
+import type { AgendaAutomationPolicy, AgendaTaskListInput, AgendaTaskRecord, AgendaTaskRunRecord, ChatRunTurnRequest, ChatStartSessionRequest, ChatStartSessionResponse, ChatTurnResult, HubSessionSearchHit, HubTaskCreateInput, HubTaskUpdateInput, TeamProgressProjectionEvent } from "@cline/shared";
 import type { CheckpointEntry } from "../../hooks/checkpoint-hooks";
 type ScheduleClientRecord = Record<string, unknown> & {
     metadata?: Record<string, unknown>;
@@ -89,6 +89,11 @@ export declare class HubSessionClient {
     listSessions(input?: {
         limit?: number;
     }): Promise<HubSessionRow[]>;
+    searchSessions(input: {
+        query: string;
+        limit?: number;
+        workspaceRoot?: string;
+    }): Promise<HubSessionSearchHit[]>;
     deleteSession(sessionId: string, deleteCheckpointRefs?: boolean): Promise<boolean>;
     respondToolApproval(input: {
         approvalId: string;

package/dist/hub/client/ui-client.d.ts

@@ -1,4 +1,4 @@
-import type { HubClientRecord, HubUINotifyPayload, HubUIShowWindowPayload, SessionRecord } from "@cline/shared";
+import type { HubClientRecord, HubSessionSearchHit, HubUINotifyPayload, HubUIShowWindowPayload, SessionRecord } from "@cline/shared";
 import type { CoreSettingsMutationResult, CoreSettingsToggleInput } from "../../settings";
 export interface HubUIClientOptions {
     address: string;
@@ -30,6 +30,11 @@ export declare class HubUIClient {
     sendShowWindow(payload?: HubUIShowWindowPayload): Promise<void>;
     listClients(): Promise<HubClientRecord[]>;
     listSessions(limit?: number): Promise<SessionRecord[]>;
+    searchSessions(input: {
+        query: string;
+        limit?: number;
+        workspaceRoot?: string;
+    }): Promise<HubSessionSearchHit[]>;
     toggleSetting(input: CoreSettingsToggleInput): Promise<CoreSettingsMutationResult>;
     /**
      * Subscribe to UI-relevant hub events.