@cline/core 0.0.75-nightly.1787107092 → 0.0.76

package/dist/runtime/host/local-runtime-host.d.ts

@@ -53,6 +53,7 @@ export declare class LocalRuntimeHost implements RuntimeHost {
     private readonly pendingPromptsController;
     private readonly eventBridge;
     private readonly sessionVersioning;
+    private readonly runCommandExecutionController;
     constructor(options: LocalRuntimeHostOptions);
     private applyInitialOAuthCredentials;
     startSession(input: StartSessionInput): Promise<StartSessionResult>;
@@ -61,6 +62,7 @@ export declare class LocalRuntimeHost implements RuntimeHost {
     runTurn(input: SendSessionInput): Promise<AgentResult | undefined>;
     getAccumulatedUsage(sessionId: string): Promise<SessionUsageSummary | undefined>;
     abort(sessionId: string, reason?: unknown): Promise<void>;
+    proceedWhileRunning(sessionId: string, toolCallId?: string): Promise<number>;
     stopSession(sessionId: string): Promise<void>;
     dispose(reason?: string): Promise<void>;
     getSession(sessionId: string): Promise<SessionRecord | undefined>;

package/dist/runtime/host/runtime-host.d.ts

@@ -157,6 +157,9 @@ export interface SessionModelRuntimeService {
 export interface SessionConnectionRuntimeService {
     updateSessionConnection(sessionId: string, updates: SessionConnectionUpdate): Promise<void>;
 }
+export interface CommandExecutionRuntimeService {
+    proceedWhileRunning(sessionId: string, toolCallId?: string): Promise<number>;
+}
 export interface RuntimeHostSubscribeOptions {
     sessionId?: string;
 }

package/dist/runtime/orchestration/session-runtime.d.ts

@@ -1,6 +1,6 @@
 import type { AgentConfig, AgentEvent, AgentHooks, AgentResult, AgentTool, BasicLogger, ITelemetryService, ModelTool, RuntimeConfigExtensionKind, ToolApprovalRequest, ToolApprovalResult } from "@cline/shared";
 import type { UserInstructionConfigService } from "../../extensions/config";
-import type { ToolExecutors } from "../../extensions/tools";
+import type { RunCommandExecutionController, ToolExecutors } from "../../extensions/tools";
 import type { AgentTeamsRuntime, DelegatedAgentConfigProvider, SubAgentEndContext, SubAgentStartContext, TeamEvent } from "../../extensions/tools/team";
 import type { WorkspaceManager } from "../../services/workspace/workspace-manager";
 import type { CoreSessionConfig } from "../../types/config";
@@ -44,6 +44,7 @@ export interface RuntimeBuilderInput {
     pluginSkillDirectories?: ReadonlyArray<string>;
     configExtensions?: RuntimeConfigExtensionKind[];
     toolExecutors?: Partial<ToolExecutors>;
+    runCommandExecutionController?: RunCommandExecutionController;
     toolPolicies?: CoreSessionConfig["toolPolicies"];
     workspaceManager?: WorkspaceManager;
     logger?: BasicLogger;

package/dist/runtime/process-start-token.d.ts

@@ -0,0 +1,23 @@
+export type ProcessStartTokenProbeResult = {
+    status: "found";
+    token: string;
+} | {
+    status: "missing";
+} | {
+    status: "unavailable";
+};
+export declare function parseLinuxProcessStartToken(stat: string, bootId: string): string | undefined;
+/** Distinguishes an absent process from an unavailable identity probe. */
+export declare function probeProcessStartToken(pid: number): ProcessStartTokenProbeResult;
+/**
+ * Returns a token for one generation of a process ID.
+ *
+ * A PID alone is not an identity because the operating system can reuse it
+ * after a process exits. The token is derived from the kernel-reported process
+ * start time so callers can distinguish a live process from a later process
+ * that inherited the same PID.
+ */
+export declare function getProcessStartToken(pid: number): string | undefined;
+/** Non-blocking probe for latency-sensitive runtime paths. */
+export declare function probeProcessStartTokenAsync(pid: number): Promise<ProcessStartTokenProbeResult>;
+export declare function getProcessStartTokenAsync(pid: number): Promise<string | undefined>;

package/dist/services/llms/cline-recommended-models.d.ts

@@ -1,3 +1,4 @@
+import { type ProviderModel } from "@cline/shared";
 import { ProviderSettingsManager } from "../storage/provider-settings-manager";
 import type { ModelInfo } from "./provider-settings";
 export interface ClineRecommendedModel {
@@ -26,4 +27,36 @@ export interface FetchClineRecommendedModelsOptions {
 }
 export declare const FALLBACK_CLINE_RECOMMENDED_MODELS: ClineRecommendedModelsData;
 export declare function fetchClineRecommendedModels(options?: FetchClineRecommendedModelsOptions): Promise<ClineRecommendedModelsData>;
+/**
+ * `fetchClineRecommendedModels` with a shared in-memory cache, for callers on
+ * the model-list path (every picker open) where a per-call network round-trip
+ * — or its 5s offline timeout — is unacceptable. The bundled offline fallback
+ * is cached too: paying the timeout once per TTL beats paying it on every
+ * model list while offline, and a recovered network is picked up within the
+ * TTL.
+ */
+export declare function getCachedClineRecommendedModels(options?: FetchClineRecommendedModelsOptions): Promise<ClineRecommendedModelsData>;
+/**
+ * Synchronous, never-blocking view of the feed: the cached live data when
+ * fresh, otherwise the bundled fallback. For callers that build model lists
+ * eagerly and must not wait on the network (the provider catalog at startup),
+ * so even a cold boot renders tiered sections instead of a flat list. The
+ * async `getCachedClineRecommendedModels` path refreshes the cache, after
+ * which peeks serve live data for the TTL.
+ */
+export declare function peekClineRecommendedModels(): ClineRecommendedModelsData;
+export declare function resetClineRecommendedModelsCacheForTests(): void;
+/**
+ * Stamps recommended-feed tiers onto a provider's model list so clients can
+ * render Recommended/Free/Subscribed sections straight off `ProviderModel`
+ * instead of fetching and joining the feed themselves. Feed ids are matched
+ * through the Vercel/OpenRouter alias rules (the feed can spell a model
+ * differently from the catalog), with a fallback on the id's slug after "/"
+ * when that slug is unambiguous — the feed and the catalog can carry
+ * different vendor prefixes for the same model (`kwaipilot/kat-coder-pro`
+ * vs `cline-free/kat-coder-pro`), most visibly when the bundled fallback
+ * feed is stamped against a live-fetched catalog. Models the feed does not
+ * mention are returned unchanged; unknown providers pass through untouched.
+ */
+export declare function applyClineFeaturedModels(providerId: string, models: ProviderModel[], data: ClineRecommendedModelsData): ProviderModel[];
 export {};

package/dist/services/providers/local-provider-registry.d.ts

@@ -325,7 +325,7 @@ export declare function readModelsFileSync(filePath: string): StoredModelsFile;
 export declare function readModelsFile(filePath: string): Promise<StoredModelsFile>;
 export declare function writeModelsFileSync(filePath: string, state: StoredModelsFile): void;
 export declare function writeModelsFile(filePath: string, state: StoredModelsFile): Promise<void>;
-export declare function toProviderModel(modelId: string, info: Pick<ModelInfo, "name" | "contextWindow" | "capabilities" | "thinkingConfig" | "operation" | "operationModes" | "modalities">): ProviderModel;
+export declare function toProviderModel(modelId: string, info: Pick<ModelInfo, "name" | "description" | "contextWindow" | "capabilities" | "thinkingConfig" | "operation" | "operationModes" | "modalities">): ProviderModel;
 export declare function registerProviderSettingsProvider(settings: ProviderSettings): void;
 export declare function registerConfiguredProvidersFromSettings(state: StoredProviderSettings): void;
 /**

package/dist/tasks/agenda-task-api.d.ts

@@ -0,0 +1,20 @@
+import type { AgendaAutomationPolicy, AgendaTaskActor, AgendaTaskCreateInput, AgendaTaskListInput, AgendaTaskRecord, AgendaTaskRunRecord, AgendaTaskUpdateInput } from "@cline/shared";
+/**
+ * The single mutation boundary for agenda tasks. File reconciliation, Hub
+ * commands, and agent tools all route through this interface so lifecycle
+ * invariants are enforced in one place.
+ */
+export interface AgendaTaskManagerApi {
+    createTask(input: AgendaTaskCreateInput): Promise<AgendaTaskRecord>;
+    listTasks(input?: AgendaTaskListInput): Promise<AgendaTaskRecord[]>;
+    getTask(taskId: string): Promise<AgendaTaskRecord | undefined>;
+    updateTask(input: AgendaTaskUpdateInput): Promise<AgendaTaskRecord>;
+    approveTask(taskId: string, actor: AgendaTaskActor, expectedRevision: number): Promise<AgendaTaskRecord>;
+    cancelTask(taskId: string, actor: AgendaTaskActor, expectedRevision: number, reason?: string): Promise<AgendaTaskRecord>;
+    runTask(taskId: string, actor: AgendaTaskActor, expectedRevision: number, requestedByClientId?: string): Promise<{
+        task: AgendaTaskRecord;
+        run?: AgendaTaskRunRecord;
+    }>;
+    getAutomationPolicy(scopeKey?: string): Promise<AgendaAutomationPolicy>;
+    setAutomationPolicy(policy: Omit<AgendaAutomationPolicy, "updatedAt">, actor: AgendaTaskActor): Promise<AgendaAutomationPolicy>;
+}

package/dist/tasks/agenda-task-manager.d.ts

@@ -0,0 +1,102 @@
+import type { AgendaAutomationPolicy, AgendaTaskActor, AgendaTaskCreateInput, AgendaTaskListInput, AgendaTaskRecord, AgendaTaskRunRecord, AgendaTaskUpdateInput, BasicLogger } from "@cline/shared";
+import type { AgendaTaskManagerApi } from "./agenda-task-api";
+import { SqliteAgendaTaskStore } from "./store/sqlite-task-store";
+export type AgendaTaskManagerEventName = "task.created" | "task.updated" | "task.deleted" | "task.run.started" | "task.run.completed" | "task.run.failed" | "task.automation.updated";
+export interface AgendaTaskRuntimeResult {
+    status: "completed" | "failed" | "cancelled";
+    summary?: string;
+    error?: string;
+}
+export interface AgendaTaskRuntime {
+    isInteractiveClientAvailable?(): boolean;
+    startSession(task: AgendaTaskRecord, run: AgendaTaskRunRecord, requestedByClientId?: string, options?: {
+        unattended: boolean;
+    }): Promise<{
+        sessionId: string;
+    }>;
+    runSession(sessionId: string, task: AgendaTaskRecord, run: AgendaTaskRunRecord): Promise<AgendaTaskRuntimeResult>;
+    abortSession(sessionId: string, reason: string): Promise<void>;
+}
+export interface AgendaTaskManagerOptions {
+    runtime: AgendaTaskRuntime;
+    store?: SqliteAgendaTaskStore;
+    dbPath?: string;
+    globalSpecsDir?: string;
+    watcherDebounceMs?: number;
+    watchFiles?: boolean;
+    logger?: BasicLogger;
+    publish?: (event: AgendaTaskManagerEventName, payload: Record<string, unknown>, sessionId?: string) => void;
+}
+/** Hub-owned lifecycle coordinator and the only operational task writer. */
+export declare class AgendaTaskManager implements AgendaTaskManagerApi {
+    private readonly runtime;
+    private readonly store;
+    private readonly ownsStore;
+    private readonly globalSpecsDir?;
+    private readonly watcherDebounceMs;
+    private readonly watchFiles;
+    private readonly logger;
+    private readonly publishEvent;
+    private readonly scopes;
+    private readonly activeRuns;
+    private readonly backgroundRuns;
+    private maintenanceTimer?;
+    private readonly queuedAutomationScopes;
+    private automationPumping;
+    private automationPolicyGeneration;
+    private started;
+    private disposed;
+    constructor(options: AgendaTaskManagerOptions);
+    start(): Promise<void>;
+    dispose(): Promise<void>;
+    createTask(input: AgendaTaskCreateInput): Promise<AgendaTaskRecord>;
+    listTasks(input?: AgendaTaskListInput): Promise<AgendaTaskRecord[]>;
+    getTask(taskId: string): Promise<AgendaTaskRecord | undefined>;
+    updateTask(input: AgendaTaskUpdateInput): Promise<AgendaTaskRecord>;
+    approveTask(taskId: string, actor: AgendaTaskActor, expectedRevision: number): Promise<AgendaTaskRecord>;
+    cancelTask(taskId: string, actor: AgendaTaskActor, expectedRevision: number, reason?: string): Promise<AgendaTaskRecord>;
+    runTask(taskId: string, actor: AgendaTaskActor, expectedRevision: number, requestedByClientId?: string): Promise<{
+        task: AgendaTaskRecord;
+        run?: AgendaTaskRunRecord;
+    }>;
+    getAutomationPolicy(scopeKey?: string): Promise<AgendaAutomationPolicy>;
+    setAutomationPolicy(policy: Omit<AgendaAutomationPolicy, "updatedAt">, actor: AgendaTaskActor): Promise<AgendaAutomationPolicy>;
+    /** Re-evaluate auto-start work after Hub client readiness changes. */
+    notifyAutomationReadinessChanged(): void;
+    private finishRun;
+    private finishRunFailure;
+    private ensureScope;
+    private reconcileScope;
+    private reconcileSourceForProjection;
+    private reconcileFileStore;
+    private expireTasks;
+    private expireTask;
+    private isExpired;
+    private recoverInterruptedRuns;
+    private queueAutomation;
+    private pumpAutomation;
+    private canAutomaticallyApprove;
+    private taskChainDepth;
+    private fileStoreForTask;
+    /**
+     * Approval is bound to the current user-editable Markdown intent, not just
+     * the last SQLite projection. Reconcile synchronously to close the watcher
+     * debounce window, then fail closed if the source is missing, malformed, or
+     * still differs from the projection that will be approved/executed.
+     */
+    private refreshAndVerifyTaskIntent;
+    private requireTask;
+    private assertRevision;
+    private publish;
+    /**
+     * fs.watch must be handed the fully resolved form of a path: on Windows,
+     * libuv aborts the entire process (fs-event.c assertion) when the watched
+     * path contains 8.3 short components such as C:\Users\RUNNER~1, because
+     * event filenames come back in long form and fail its prefix check. When
+     * the path cannot be resolved, going without the watcher is safer than
+     * handing libuv the unresolved path.
+     */
+    private resolveWatchRoot;
+    private logError;
+    private assertUsable;
+}

package/dist/tasks/agenda-task-tool.d.ts

@@ -0,0 +1,94 @@
+import type { AgentTool, GatewayModelSelection, ITelemetryService } from "@cline/shared";
+import { z } from "zod";
+import type { AgendaTaskManagerApi } from "./agenda-task-api";
+export declare const TodoTaskInputSchema: z.ZodObject<{
+    operation: z.ZodEnum<{
+        update: "update";
+        create: "create";
+        list: "list";
+        get: "get";
+    }>;
+    task_id: z.ZodOptional<z.ZodString>;
+    expected_revision: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodOptional<z.ZodEnum<{
+        handoff: "handoff";
+        suggestion: "suggestion";
+        "follow-up": "follow-up";
+        todo: "todo";
+        idea: "idea";
+        reminder: "reminder";
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    instructions: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        workspace: "workspace";
+        global: "global";
+    }>>;
+    workspace_root: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    cwd: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    resource_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    priority: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>>;
+    assignee: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    model_selection: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        provider_id: z.ZodString;
+        model_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    mode: z.ZodOptional<z.ZodNullable<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>>;
+    available_at: z.ZodOptional<z.ZodString>;
+    expires_at: z.ZodOptional<z.ZodString>;
+    automation_eligible: z.ZodOptional<z.ZodBoolean>;
+    statuses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        failed: "failed";
+        completed: "completed";
+        in_progress: "in_progress";
+        cancelled: "cancelled";
+        approved: "approved";
+        pending_approval: "pending_approval";
+        expired: "expired";
+    }>>>;
+    types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        handoff: "handoff";
+        suggestion: "suggestion";
+        "follow-up": "follow-up";
+        todo: "todo";
+        idea: "idea";
+        reminder: "reminder";
+    }>>>;
+    priorities: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type TodoTaskInput = z.infer<typeof TodoTaskInputSchema>;
+export interface AgendaTaskSessionDefaults {
+    workspaceRoot?: string;
+    cwd?: string;
+    modelSelection?: GatewayModelSelection;
+    originTaskId?: string;
+}
+export interface TodoTaskOperationOptions {
+    manager: AgendaTaskManagerApi;
+    telemetry?: ITelemetryService;
+    resolveSessionDefaults: (sessionId: string) => Promise<AgendaTaskSessionDefaults | undefined>;
+}
+export type TodoTaskResult = {
+    ok: true;
+    operation: TodoTaskInput["operation"];
+    task?: Awaited<ReturnType<AgendaTaskManagerApi["getTask"]>>;
+    tasks?: Awaited<ReturnType<AgendaTaskManagerApi["listTasks"]>>;
+} | {
+    ok: false;
+    operation?: TodoTaskInput["operation"];
+    error: {
+        code: string;
+        message: string;
+    };
+};
+/** Execute a Todo operation while preserving Agenda scope and authority rules. */
+export declare function executeTodoTaskOperation(options: TodoTaskOperationOptions, rawInput: unknown, context: Parameters<AgentTool<TodoTaskInput, TodoTaskResult>["execute"]>[1]): Promise<TodoTaskResult>;

package/dist/tasks/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./agenda-task-api";
+export * from "./agenda-task-manager";
+export * from "./agenda-task-tool";
+export * from "./specs/task-spec-file-store";
+export * from "./specs/task-spec-parser";
+export * from "./store/sqlite-task-store";
+export * from "./store/task-schema";
+export * from "./task-location";
+export * from "./task-tool";

package/dist/tasks/specs/task-spec-file-store.d.ts

@@ -0,0 +1,38 @@
+import type { AgendaTaskScope } from "@cline/shared";
+import { type AgendaTaskSpec, type AgendaTaskSpecParseResult, type AgendaTaskSpecWriteInput } from "./task-spec-parser";
+export interface AgendaTaskSpecFileStoreOptions {
+    scope: AgendaTaskScope;
+    workspaceRoot?: string;
+    taskSpecsDir?: string;
+}
+export interface WriteAgendaTaskSpecOptions {
+    /** Existing path or a filename under this store's directory. */
+    specPath?: string;
+    /** Refuse to replace a file whose parsed content changed since it was read. */
+    expectedContentHash?: string;
+    /** Atomically fail instead of replacing an existing target. */
+    createOnly?: boolean;
+}
+export type WrittenAgendaTaskSpec = AgendaTaskSpec & {
+    taskId: string;
+};
+export declare class AgendaTaskSpecFileStore {
+    readonly specsDir: string;
+    readonly scope: AgendaTaskScope;
+    readonly workspaceRoot?: string;
+    constructor(options: AgendaTaskSpecFileStoreOptions);
+    listSpecPaths(): string[];
+    listSpecs(): AgendaTaskSpecParseResult[];
+    readSpec(specPath: string): AgendaTaskSpecParseResult;
+    writeSpec(input: AgendaTaskSpecWriteInput, options?: WriteAgendaTaskSpecOptions): WrittenAgendaTaskSpec;
+    /** Resolve the canonical target before a manager reserves it in SQLite. */
+    resolveWritePath(taskId: string, specPath?: string): string;
+    /** Validate the root both before and after creating missing directories. */
+    ensureSpecsDir(): void;
+    deleteSpec(specPath: string, options?: {
+        expectedContentHash?: string;
+    }): boolean;
+    private assertExpectedContent;
+    private assertSpecsDirSafe;
+    private resolveSpecPath;
+}

package/dist/tasks/specs/task-spec-parser.d.ts

@@ -0,0 +1,65 @@
+import type { AgendaTaskActor, AgendaTaskCreateInput, AgendaTaskPriority, AgendaTaskScope, AgendaTaskType, GatewayModelSelection } from "@cline/shared";
+export interface AgendaTaskSpec {
+    taskId?: string;
+    type: AgendaTaskType;
+    title: string;
+    description?: string;
+    instructions: string;
+    scope: AgendaTaskScope;
+    workspaceRoot?: string;
+    cwd?: string;
+    resourcePaths: string[];
+    priority: AgendaTaskPriority;
+    assignee?: string;
+    modelSelection?: GatewayModelSelection;
+    mode?: "act" | "plan" | "yolo";
+    systemPrompt?: string;
+    maxIterations?: number;
+    timeoutSeconds?: number;
+    availableAt?: string;
+    expiresAt: string;
+    automationEligible: boolean;
+    specPath: string;
+    contentHash: string;
+}
+export interface ParseAgendaTaskSpecInput {
+    specPath: string;
+    raw: string;
+    scope: AgendaTaskScope;
+    workspaceRoot?: string;
+}
+export type AgendaTaskSpecParseResult = {
+    ok: true;
+    specPath: string;
+    contentHash: string;
+    spec: AgendaTaskSpec;
+} | {
+    ok: false;
+    specPath: string;
+    contentHash: string;
+    error: string;
+};
+export interface AgendaTaskSpecWriteInput {
+    taskId: string;
+    type: AgendaTaskType;
+    title: string;
+    description?: string;
+    instructions: string;
+    cwd?: string;
+    resourcePaths?: string[];
+    priority?: AgendaTaskPriority;
+    assignee?: string;
+    modelSelection?: GatewayModelSelection;
+    mode?: "act" | "plan" | "yolo";
+    systemPrompt?: string;
+    maxIterations?: number;
+    timeoutSeconds?: number;
+    availableAt?: string;
+    expiresAt: string;
+    automationEligible?: boolean;
+}
+/** Parse one task Markdown file without throwing for invalid user content. */
+export declare function parseAgendaTaskSpec(input: ParseAgendaTaskSpecInput): AgendaTaskSpecParseResult;
+/** Render the canonical, user-editable task spec representation. */
+export declare function serializeAgendaTaskSpec(input: AgendaTaskSpecWriteInput): string;
+export declare function agendaTaskSpecToCreateInput(spec: AgendaTaskSpec, createdBy: AgendaTaskActor): AgendaTaskCreateInput;

package/dist/tasks/store/sqlite-task-store.d.ts

@@ -0,0 +1,73 @@
+import type { AgendaAutomationPolicy, AgendaTaskActor, AgendaTaskCreateInput, AgendaTaskListInput, AgendaTaskRecord, AgendaTaskRunRecord, AgendaTaskRunStatus, AgendaTaskStatus, AgendaTaskUpdateInput } from "@cline/shared";
+export interface SqliteAgendaTaskStoreOptions {
+    dbPath?: string;
+}
+export declare class AgendaTaskRevisionConflictError extends Error {
+    readonly current: AgendaTaskRecord;
+    constructor(current: AgendaTaskRecord);
+}
+export interface AgendaTaskStatePatch {
+    status?: AgendaTaskStatus;
+    approvedRevision?: number | null;
+    currentRunId?: string | null;
+    lastRunId?: string | null;
+    lastSessionId?: string | null;
+    specPath?: string | null;
+    error?: string | null;
+    completedAt?: string | null;
+    archivedAt?: string | null;
+    updatedBy?: AgendaTaskActor;
+}
+export interface CreateAgendaTaskRunInput {
+    taskId: string;
+    taskRevision: number;
+    status?: AgendaTaskRunStatus;
+    claimToken?: string;
+    claimUntilAt?: string;
+    requestedByClientId?: string;
+    sessionId?: string;
+    claimedAt?: string;
+}
+export interface UpdateAgendaTaskRunInput {
+    status?: AgendaTaskRunStatus;
+    claimToken?: string | null;
+    claimUntilAt?: string | null;
+    requestedByClientId?: string | null;
+    sessionId?: string | null;
+    startedAt?: string | null;
+    completedAt?: string | null;
+    resultSummary?: string | null;
+    error?: string | null;
+}
+export interface ListAgendaTaskRunsInput {
+    taskId?: string;
+    status?: AgendaTaskRunStatus | AgendaTaskRunStatus[];
+    sessionId?: string;
+    limit?: number;
+}
+export declare class SqliteAgendaTaskStore {
+    private readonly db;
+    constructor(options?: SqliteAgendaTaskStoreOptions);
+    close(): void;
+    createTask(input: AgendaTaskCreateInput): AgendaTaskRecord;
+    getTask(taskId: string): AgendaTaskRecord | undefined;
+    getTaskBySpecPath(specPath: string): AgendaTaskRecord | undefined;
+    /**
+     * Return every workspace that has ever owned a task. Archived rows are
+     * intentionally included so the Hub can restore file watchers after a restart.
+     */
+    listWorkspaceRoots(): string[];
+    listTasks(input?: AgendaTaskListInput): AgendaTaskRecord[];
+    /** Apply user-editable fields, increment revision, and revoke old approval. */
+    updateTask(input: AgendaTaskUpdateInput): AgendaTaskRecord | undefined;
+    /** Mutate manager-owned lifecycle fields without changing the task revision. */
+    updateTaskState(taskId: string, patch: AgendaTaskStatePatch, expectedRevision?: number): AgendaTaskRecord | undefined;
+    deleteTask(taskId: string): boolean;
+    createRun(input: CreateAgendaTaskRunInput): AgendaTaskRunRecord;
+    getRun(runId: string): AgendaTaskRunRecord | undefined;
+    updateRun(runId: string, input: UpdateAgendaTaskRunInput): AgendaTaskRunRecord | undefined;
+    listRuns(input?: ListAgendaTaskRunsInput): AgendaTaskRunRecord[];
+    getAutomationPolicy(scopeKey?: string): AgendaAutomationPolicy;
+    listAutomationPolicies(): AgendaAutomationPolicy[];
+    setAutomationPolicy(input: Omit<AgendaAutomationPolicy, "updatedAt">): AgendaAutomationPolicy;
+}

package/dist/tasks/store/task-schema.d.ts

@@ -0,0 +1,2 @@
+import type { SqliteDb } from "@cline/shared/db";
+export declare function ensureAgendaTaskSchema(db: SqliteDb): void;

package/dist/tasks/task-location.d.ts

@@ -0,0 +1,14 @@
+import type { AgendaTaskScope } from "@cline/shared";
+export interface AgendaTaskLocationInput {
+    scope: AgendaTaskScope;
+    workspaceRoot?: string;
+    cwd?: string;
+    resourcePaths?: readonly string[];
+}
+export interface NormalizedAgendaTaskLocation {
+    workspaceRoot?: string;
+    cwd?: string;
+    resourcePaths: string[];
+}
+/** Enforce the queue's global/chat and workspace filesystem boundaries. */
+export declare function normalizeAgendaTaskLocation(input: AgendaTaskLocationInput): NormalizedAgendaTaskLocation;