@cline/core 0.0.75 → 0.0.76

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

@@ -1,9 +1,14 @@
 import type { HubCommandEnvelope, HubReplyEnvelope } from "@cline/shared";
+import type { HubConnectionAuthority } from "../../hub/server/command-transport";
 import type { HubScheduleService } from "./schedule-service";
 export declare class HubScheduleCommandService {
     private readonly schedules;
     constructor(schedules: HubScheduleService);
-    handleCommand(envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+    handleCommand(envelope: HubCommandEnvelope, authority?: HubConnectionAuthority): Promise<HubReplyEnvelope>;
+    private resolveScope;
+    private requireScopedSchedule;
+    private scopedScheduleIds;
+    private listScopedExecutions;
     private toCreateInput;
     private toUpdateInput;
 }

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

@@ -63,6 +63,7 @@ export interface ListSchedulesOptions {
     enabled?: boolean;
     limit?: number;
     tags?: string[];
+    workspaceRoot?: string;
 }
 export interface ListScheduleExecutionsOptions {
     scheduleId?: string;

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

@@ -0,0 +1,81 @@
+import type { AgentTool, GatewayModelSelection, HubScheduleCreateInput, HubScheduleUpdateInput, ITelemetryService, ScheduleExecutionRecord, ScheduleRecord } from "@cline/shared";
+import { z } from "zod";
+import type { ListSchedulesOptions } from "./schedule-service";
+export declare const ScheduledTaskInputSchema: z.ZodObject<{
+    operation: z.ZodEnum<{
+        update: "update";
+        create: "create";
+        list: "list";
+        pause: "pause";
+        resume: "resume";
+        get: "get";
+        delete: "delete";
+        run_now: "run_now";
+    }>;
+    schedule_id: z.ZodOptional<z.ZodString>;
+    schedule_type: z.ZodOptional<z.ZodEnum<{
+        once: "once";
+        recurring: "recurring";
+    }>>;
+    name: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+    run_at: z.ZodOptional<z.ZodString>;
+    cron_pattern: z.ZodOptional<z.ZodString>;
+    timezone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        plan: "plan";
+        act: "act";
+        yolo: "yolo";
+    }>>;
+    system_prompt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    max_iterations: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    timeout_seconds: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    max_parallel: z.ZodOptional<z.ZodNumber>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    model_selection: z.ZodOptional<z.ZodObject<{
+        provider_id: z.ZodString;
+        model_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ScheduledTaskInput = z.infer<typeof ScheduledTaskInputSchema>;
+export interface ScheduleSessionDefaults {
+    workspaceRoot: string;
+    cwd?: string;
+    modelSelection?: GatewayModelSelection;
+    interactive: boolean;
+}
+export interface AgentScheduleServiceApi {
+    createSchedule(input: HubScheduleCreateInput): ScheduleRecord;
+    getSchedule(scheduleId: string): ScheduleRecord | undefined;
+    listSchedules(options?: ListSchedulesOptions): ScheduleRecord[];
+    updateSchedule(scheduleId: string, updates: HubScheduleUpdateInput): ScheduleRecord | undefined;
+    deleteSchedule(scheduleId: string): boolean;
+    pauseSchedule(scheduleId: string): ScheduleRecord | undefined;
+    resumeSchedule(scheduleId: string): ScheduleRecord | undefined;
+    triggerScheduleNowDetached(scheduleId: string): ScheduleExecutionRecord | undefined;
+}
+export interface ScheduleTaskOperationOptions {
+    schedules: AgentScheduleServiceApi;
+    telemetry?: ITelemetryService;
+    resolveSessionDefaults: (sessionId: string) => Promise<ScheduleSessionDefaults | undefined>;
+    publish?: (event: "schedule.created" | "schedule.updated" | "schedule.deleted" | "schedule.triggered", payload: Record<string, unknown>, sessionId: string) => void;
+}
+export type ScheduledTaskResult = {
+    ok: true;
+    operation: ScheduledTaskInput["operation"];
+    schedule?: ScheduleRecord;
+    schedules?: ScheduleRecord[];
+    execution?: ScheduleExecutionRecord;
+    deleted?: boolean;
+} | {
+    ok: false;
+    operation?: ScheduledTaskInput["operation"];
+    error: {
+        code: string;
+        message: string;
+    };
+};
+/** Execute a scheduled-work operation through the Hub schedule service. */
+export declare function executeScheduleOperation(options: ScheduleTaskOperationOptions, rawInput: unknown, context: Parameters<AgentTool<ScheduledTaskInput, ScheduledTaskResult>["execute"]>[1]): Promise<ScheduledTaskResult>;

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

@@ -168,6 +168,7 @@ export declare class SqliteCronStore {
         enabled?: boolean;
         limit?: number;
         tags?: string[];
+        workspaceRoot?: string;
     }): CronSpecRecord[];
     updateHubSchedule(scheduleId: string, updates: HubScheduleUpdateInput): CronSpecRecord | undefined;
     private initializeHubScheduleNextRun;

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

@@ -1,4 +1,4 @@
-export type { AvailableRuntimeCommand, RuntimeCommandKind, } from "./runtime-commands";
+export type { AvailableRuntimeCommand, ResolveRuntimeSlashCommandOptions, RuntimeCommandKind, } from "./runtime-commands";
 export type { UnifiedConfigDefinition, UnifiedConfigFileCandidate, UnifiedConfigFileContext, UnifiedConfigRecord, UnifiedConfigWatcherEvent, UnifiedConfigWatcherOptions, } from "./unified-config-file-watcher";
 export { UnifiedConfigFileWatcher } from "./unified-config-file-watcher";
 export type { CreateInstructionWatcherOptions, CreateRulesConfigDefinitionOptions, CreateSkillsConfigDefinitionOptions, CreateWorkflowsConfigDefinitionOptions, ParseMarkdownFrontmatterResult, RuleConfig, SkillConfig, UserInstructionConfig, UserInstructionConfigType, WorkflowConfig, } from "./user-instruction-config-loader";

package/dist/extensions/config/runtime-commands.d.ts

@@ -9,4 +9,15 @@ export type AvailableRuntimeCommand = {
 };
 export declare function normalizeRuntimeCommandName(name: string): string;
 export declare function listAvailableRuntimeCommandsFromWatcher(watcher: UserInstructionConfigWatcher): AvailableRuntimeCommand[];
-export declare function resolveRuntimeSlashCommandFromWatcher(input: string, watcher: UserInstructionConfigWatcher): string;
+export type ResolveRuntimeSlashCommandOptions = {
+    /**
+     * Whether a matched skill command is textually expanded into the prompt.
+     * Hosts pass false when the session registers the runtime's `skills`
+     * tool: the typed `/skill args` then goes through as-is and the model
+     * loads the instructions via the tool, so the persisted transcript keeps
+     * the typed command instead of the skill body. Workflows always expand —
+     * the skills tool does not serve them. Defaults to true.
+     */
+    expandSkillCommands?: boolean;
+};
+export declare function resolveRuntimeSlashCommandFromWatcher(input: string, watcher: UserInstructionConfigWatcher, options?: ResolveRuntimeSlashCommandOptions): string;

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

@@ -1,6 +1,6 @@
 import type { AgentExtension } from "@cline/shared";
 import type { SkillsExecutorWithMetadata } from "../tools";
-import { type AvailableRuntimeCommand } from "./runtime-commands";
+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";
 export interface UserInstructionConfigRecord<TConfig extends UserInstructionConfig = UserInstructionConfig> {
@@ -17,7 +17,7 @@ export interface UserInstructionConfigService {
     refreshType(type: UserInstructionConfigType): Promise<void>;
     listRecords<TConfig extends UserInstructionConfig = UserInstructionConfig>(type: UserInstructionConfigType): UserInstructionConfigRecord<TConfig>[];
     listRuntimeCommands(): AvailableRuntimeCommand[];
-    resolveRuntimeSlashCommand(input: string): string;
+    resolveRuntimeSlashCommand(input: string, options?: ResolveRuntimeSlashCommandOptions): string;
     hasConfiguredSkills(allowedSkillNames?: ReadonlyArray<string>): boolean;
     createSkillsExecutor?(allowedSkillNames?: ReadonlyArray<string>): SkillsExecutorWithMetadata;
     createExtension(options: Omit<CreateUserInstructionPluginOptions, "watcher" | "watcherReady">): AgentExtension;

package/dist/extensions/tools/executors/bash.d.ts

@@ -3,7 +3,25 @@
  *
  * Built-in implementation for running shell commands using Node.js spawn.
  */
+import { type ProcessStartTokenProbeResult } from "../../../runtime/process-start-token";
 import type { ShellExecutor } from "../types";
+import type { RunCommandExecutionController } from "./run-command-execution-controller";
+export type ProcessStartTokenProbe = (pid: number) => ProcessStartTokenProbeResult | Promise<ProcessStartTokenProbeResult>;
+export interface DetachedCommandLogCleanupOptions {
+    tempDirectory?: string;
+    retentionMs?: number;
+    nowMs?: number;
+    processStartTokenProbe?: ProcessStartTokenProbe;
+    activeCommandPollIntervalMs?: number;
+}
+/**
+ * Reaps completed detached command logs outside the retention window,
+ * schedules retained logs for their remaining lifetime, and follows active
+ * command identities until they exit. Local runtime hosts call this at startup
+ * so cleanup survives host exits and restarts instead of depending only on the
+ * process that launched the command.
+ */
+export declare function cleanupStaleDetachedCommandLogs(options?: DetachedCommandLogCleanupOptions): Promise<number>;
 export declare class CommandExitError extends Error {
     readonly exitCode: number;
     readonly output: string;
@@ -46,6 +64,20 @@ export interface ShellExecutorOptions {
      * @default true
      */
     combineOutput?: boolean;
+    /**
+     * Optional host-scoped controller that can release an in-flight command
+     * from its tool call while continuing to drain output to a bounded log.
+     */
+    executionController?: RunCommandExecutionController;
+    /**
+     * How long a completed detached command log remains available before its
+     * temporary directory is removed.
+     *
+     * @default 24 hours
+     */
+    detachedLogRetentionMs?: number;
+    /** Process identity provider used to enable safe command detachment. */
+    processStartTokenProbe?: ProcessStartTokenProbe;
 }
 /**
  * Create a shell executor using Node.js spawn

package/dist/extensions/tools/executors/index.d.ts

@@ -17,6 +17,7 @@ export { PATCH_MARKERS, PatchActionType } from "./apply-patch-parser";
 export { CommandExitError, createShellExecutor, type ShellExecutorOptions, } from "./bash";
 export { createEditorExecutor, type EditorExecutorOptions } from "./editor";
 export { createFileReadExecutor, type FileReadExecutorOptions, } from "./file-read";
+export { RunCommandExecutionController, type RunningCommandRegistration, } from "./run-command-execution-controller";
 export { createSearchExecutor, type SearchExecutorOptions } from "./search";
 export { createWebFetchExecutor, type WebFetchExecutorOptions, } from "./web-fetch";
 /**

package/dist/extensions/tools/executors/run-command-execution-controller.d.ts

@@ -0,0 +1,16 @@
+export interface RunningCommandRegistration {
+    executionId: string;
+    sessionId: string;
+    toolCallId?: string;
+    detach: () => boolean;
+}
+/**
+ * Tracks shell processes that can release their owning tool call while the
+ * process keeps running. The controller is host-scoped so hub commands can
+ * target only commands owned by a particular session/tool call.
+ */
+export declare class RunCommandExecutionController {
+    private readonly commands;
+    register(command: RunningCommandRegistration): () => void;
+    proceedWhileRunning(sessionId: string, toolCallId?: string): number;
+}

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

@@ -7,11 +7,11 @@ export { validateWithZod, zodToJsonSchema } from "@cline/shared";
 export { createPlanModeCommandGuardExtension, PLAN_MODE_COMMAND_GUARD_EXTENSION_NAME, type PlanModeCommandGuardOptions, } from "./command-guard-extension";
 export { ALL_DEFAULT_TOOL_NAMES, DefaultToolNames } from "./constants";
 export { createApplyPatchTool, createAskQuestionTool, createDefaultTools, createEditorTool, createReadFilesTool, createSearchTool, createShellTool, createSkillsTool, createSubmitAndExitTool, createWebFetchTool, } from "./definitions";
-export { type ApplyPatchExecutorOptions, CommandExitError, computePatchChanges, createApplyPatchExecutor, createDefaultExecutors, createDefaultShellExecutor, createEditorExecutor, createFileReadExecutor, createSearchExecutor, createShellExecutor, createWebFetchExecutor, type DefaultExecutorsOptions, type EditorExecutorOptions, type FileReadExecutorOptions, PATCH_MARKERS, PatchActionType, type PatchFileChange, type SearchExecutorOptions, type ShellExecutorOptions, type WebFetchExecutorOptions, } from "./executors/index";
+export { type ApplyPatchExecutorOptions, CommandExitError, computePatchChanges, createApplyPatchExecutor, createDefaultExecutors, createDefaultShellExecutor, createEditorExecutor, createFileReadExecutor, createSearchExecutor, createShellExecutor, createWebFetchExecutor, type DefaultExecutorsOptions, type EditorExecutorOptions, type FileReadExecutorOptions, PATCH_MARKERS, PatchActionType, type PatchFileChange, RunCommandExecutionController, type RunningCommandRegistration, type SearchExecutorOptions, type ShellExecutorOptions, type WebFetchExecutorOptions, } from "./executors/index";
 export { MAX_COMMAND_OUTPUT_CHARS, truncateCommandOutput, } from "./executors/output-limits";
 export { DEFAULT_MODEL_TOOL_ROUTING_RULES, resolveToolRoutingConfig, type ToolRoutingRule, } from "./model-tool-routing";
 export { createDefaultToolsWithPreset, createToolPoliciesWithPreset, resolveToolPresetName, type ToolPolicyPresetName, type ToolPresetName, ToolPresets, } from "./presets";
-export { type BuiltinToolAvailabilityContext, getCoreAcpToolNames, getCoreBuiltinToolCatalog, getCoreDefaultEnabledToolIds, getCoreHeadlessToolNames, resolveCoreSelectedToolIds, type ToolCatalogEntry, } from "./runtime";
+export { type BuiltinToolAvailabilityContext, getCoreAcpToolNames, getCoreBuiltinToolCatalog, getCoreDefaultEnabledToolIds, getCoreHeadlessToolNames, isSkillsToolAvailable, resolveCoreSelectedToolIds, type ToolCatalogEntry, } from "./runtime";
 export { type ApplyPatchInput, ApplyPatchInputSchema, type AskQuestionInput, AskQuestionInputSchema, type EditFileInput, EditFileInputSchema, type FetchWebContentInput, FetchWebContentInputSchema, type ReadFileRequest, ReadFileRequestSchema, type ReadFilesInput, ReadFilesInputSchema, type RunCommandsInput, RunCommandsInputSchema, type SearchCodebaseInput, SearchCodebaseInputSchema, type SkillsInput, SkillsInputSchema, type StructuredCommandInput, StructuredCommandInputSchema, type SubmitInput, SubmitInputSchema, type WebFetchRequest, WebFetchRequestSchema, } from "./schemas";
 export { TEAM_TOOL_NAMES } from "./team/team-tools";
 export type { ApplyPatchExecutor, AskQuestionExecutor, CreateDefaultToolsOptions, DefaultToolName, DefaultToolsConfig, EditorExecutor, FileReadExecutor, SearchExecutor, ShellExecutor, SkillsExecutor, SkillsExecutorSkillMetadata, SkillsExecutorWithMetadata, ToolExecutors, ToolOperationResult, VerifySubmitExecutor, WebFetchExecutor, } from "./types";

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

@@ -15,6 +15,15 @@ export interface BuiltinToolAvailabilityContext {
     enabledModelToolIds?: ReadonlySet<string>;
 }
 export declare function getCoreBuiltinToolCatalog(context?: BuiltinToolAvailabilityContext): ToolCatalogEntry[];
+/**
+ * Whether the `skills` tool is part of a session's default toolset for this
+ * availability context. Hosts consult this before dispatching a typed
+ * `/skill` command: when the tool is available the command passes through as
+ * typed and the model loads the instructions via the tool; when it is not
+ * (e.g. the yolo preset or a user toggle disables it), textual expansion is
+ * the only delivery path left.
+ */
+export declare function isSkillsToolAvailable(context?: BuiltinToolAvailabilityContext): boolean;
 export declare function getCoreDefaultEnabledToolIds(context?: BuiltinToolAvailabilityContext): string[];
 export declare function resolveCoreSelectedToolIds(input: {
     enabled: boolean;

package/dist/hooks/subprocess.d.ts

@@ -1,6 +1,12 @@
 import { type AgentAbortHookPayload, type AgentEndHookPayload, type AgentErrorHookPayload, type AgentHooks, type AgentResumeHookPayload, type AgentStartHookPayload, type HookEventName, HookEventNameSchema, type HookEventPayload, type HookEventPayloadBase, HookEventPayloadSchema, type HookSessionContextProvider, type PostToolUseData, type PreCompactData, type PreCompactHookPayload, type PreToolUseData, type PromptSubmitHookPayload, parseHookEventPayload, type SessionShutdownHookPayload, type TaskCancelData, type TaskCompleteData, type TaskResumeData, type TaskStartData, type ToolCallHookPayload, type ToolResultHookPayload, type UserPromptSubmitData, type WorkspaceInfo } from "@cline/shared";
 import { z } from "zod";
 import { type RunSubprocessEventResult } from "./subprocess-runner";
+/**
+ * Maximum size for a hook's injected context (`contextModification`), matching
+ * the legacy extension's cap. Prevents a hook from overflowing the prompt.
+ */
+export declare const MAX_HOOK_CONTEXT_SIZE = 50000;
+export declare function truncateHookContext(context: string | undefined): string | undefined;
 export interface HookOutput {
     contextModification: string;
     cancel: boolean;

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

@@ -1,4 +1,4 @@
-import { type HubCommandEnvelope, type HubEventEnvelope, type HubReplyEnvelope } from "@cline/shared";
+import { type HubClientRegistration, type HubCommandEnvelope, type HubEventEnvelope, type HubReplyEnvelope } from "@cline/shared";
 import { type HubOwnerContext } from "../discovery";
 export interface HubClientOptions {
     url: string;
@@ -8,6 +8,7 @@ export interface HubClientOptions {
     workspaceRoot?: string;
     cwd?: string;
     authToken?: string;
+    capabilities?: HubClientRegistration["capabilities"];
 }
 export interface LocalHubResolutionOptions {
     endpoint?: string;
@@ -51,11 +52,13 @@ export declare class NodeHubClient {
     private lastCloseError;
     private sawSocketClose;
     private registered;
+    private capabilities;
     constructor(options: HubClientOptions);
     getClientId(): string;
     getUrl(): string;
     isConnected(): boolean;
     getConnectionError(): HubTransportError | null;
+    updateCapabilities(capabilities: NonNullable<HubClientRegistration["capabilities"]>): Promise<void>;
     connect(): Promise<void>;
     subscribe(listener: (event: HubEventEnvelope) => void, options?: {
         sessionId?: string;

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

@@ -1,5 +1,5 @@
 import type * as LlmsProviders from "@cline/llms";
-import type { ChatRunTurnRequest, ChatStartSessionRequest, ChatStartSessionResponse, ChatTurnResult, TeamProgressProjectionEvent } from "@cline/shared";
+import type { AgendaAutomationPolicy, AgendaTaskListInput, AgendaTaskRecord, AgendaTaskRunRecord, ChatRunTurnRequest, ChatStartSessionRequest, ChatStartSessionResponse, ChatTurnResult, HubTaskCreateInput, HubTaskUpdateInput, TeamProgressProjectionEvent } from "@cline/shared";
 import type { CheckpointEntry } from "../../hooks/checkpoint-hooks";
 type ScheduleClientRecord = Record<string, unknown> & {
     metadata?: Record<string, unknown>;
@@ -62,6 +62,7 @@ export declare class HubSessionClient {
     constructor(options: HubSessionClientOptions);
     private ensureMetadataApplied;
     connect(): Promise<void>;
+    private taskCommand;
     close(): void;
     dispose(): Promise<void>;
     startRuntimeSession(request: ChatStartSessionRequest): Promise<ChatStartSessionResponse>;
@@ -116,5 +117,17 @@ export declare class HubSessionClient {
     getScheduleStats(): Promise<Record<string, unknown> | undefined>;
     getActiveScheduledExecutions(): Promise<Array<Record<string, unknown>>>;
     getUpcomingScheduledRuns(limit?: number): Promise<Array<Record<string, unknown>>>;
+    createTask(input: HubTaskCreateInput): Promise<AgendaTaskRecord>;
+    listTasks(input?: AgendaTaskListInput): Promise<AgendaTaskRecord[]>;
+    getTask(taskId: string): Promise<AgendaTaskRecord | undefined>;
+    updateTask(input: HubTaskUpdateInput): Promise<AgendaTaskRecord>;
+    approveTask(taskId: string, expectedRevision: number): Promise<AgendaTaskRecord>;
+    cancelTask(taskId: string, expectedRevision: number, reason?: string): Promise<AgendaTaskRecord>;
+    runTask(taskId: string, expectedRevision: number): Promise<{
+        task: AgendaTaskRecord;
+        run?: AgendaTaskRunRecord;
+    }>;
+    getTaskAutomation(): Promise<AgendaAutomationPolicy>;
+    setTaskAutomation(policy: Omit<AgendaAutomationPolicy, "updatedAt">): Promise<AgendaAutomationPolicy>;
 }
 export {};