@cerebriline/core 4.100.240

package/dist/cline-core/types.d.ts

@@ -0,0 +1,236 @@
+import type { MessageWithMetadata } from "@cerebriline/llms";
+import type { AgentConfig, AutomationEventEnvelope, BasicLogger, ITelemetryService } from "@cerebriline/shared";
+import type { CronEventSuppression } from "../cron/events/cron-event-ingress";
+import type { CronEventLogRecord, CronRunRecord, CronSpecRecord } from "../cron/store/sqlite-cron-store";
+import type { CheckpointEntry } from "../hooks/checkpoint-hooks";
+import type { RuntimeCapabilities } from "../runtime/capabilities";
+import type { SessionHistoryListOptions } from "../runtime/host/history";
+import type { SessionBackend } from "../runtime/host/host";
+import type { LocalRuntimeStartOptions, RuntimeHostMode, StartSessionInput, StartSessionResult } from "../runtime/host/runtime-host";
+import type { FeatureFlagsService } from "../services/feature-flags";
+import type { CheckpointWorkspaceCompareResult } from "../session/checkpoint-diff";
+import type { ClineCoreStartConfig } from "../types/config";
+import type { SessionMessagesArtifactUploader } from "../types/session";
+export type { RuntimeHostMode } from "../runtime/host/runtime-host";
+export type { ClineCoreSettingsApi } from "../settings";
+export interface HubOptions {
+    endpoint?: string;
+    authToken?: string;
+    strategy?: "prefer-hub" | "require-hub";
+    clientType?: string;
+    displayName?: string;
+    workspaceRoot?: string;
+    cwd?: string;
+}
+export interface RemoteOptions {
+    endpoint: string;
+    authToken?: string;
+    clientType?: string;
+    displayName?: string;
+    workspaceRoot?: string;
+    cwd?: string;
+}
+export interface ClineCoreAutomationOptions {
+    /** @deprecated Use `cronSpecsDir`. */
+    cronDir?: string;
+    cronSpecsDir?: string;
+    /** @deprecated Reports are written under the resolved cron specs directory. */
+    reportsDir?: string;
+    cronScope?: "global" | "user" | "workspace";
+    workspaceRoot?: string;
+    dbPath?: string;
+    pollIntervalMs?: number;
+    claimLeaseSeconds?: number;
+    globalMaxConcurrency?: number;
+    watcherDebounceMs?: number;
+    autoStart?: boolean;
+}
+export type ClineAutomationSpec = CronSpecRecord;
+export type ClineAutomationRun = CronRunRecord;
+export type ClineAutomationEventLog = CronEventLogRecord;
+export type ClineAutomationEventSuppression = CronEventSuppression;
+export type ClineAutomationRunStatus = "queued" | "running" | "done" | "failed" | "cancelled";
+export interface ClineAutomationListSpecsOptions {
+    triggerKind?: "one_off" | "schedule" | "event";
+    enabled?: boolean;
+    parseStatus?: "valid" | "invalid";
+    includeRemoved?: boolean;
+    limit?: number;
+}
+export interface ClineAutomationListRunsOptions {
+    specId?: string;
+    status?: ClineAutomationRunStatus | ClineAutomationRunStatus[];
+    limit?: number;
+}
+export interface ClineAutomationListEventsOptions {
+    eventType?: string;
+    source?: string;
+    processingStatus?: "received" | "unmatched" | "queued" | "suppressed" | "failed";
+    limit?: number;
+}
+export interface ClineAutomationEventIngressResult {
+    event: ClineAutomationEventLog;
+    duplicate: boolean;
+    matchedSpecIds: string[];
+    queuedRuns: ClineAutomationRun[];
+    suppressions: ClineAutomationEventSuppression[];
+}
+export interface ClineCoreAutomationApi {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    reconcileNow(): Promise<void>;
+    ingestEvent(event: AutomationEventEnvelope): ClineAutomationEventIngressResult;
+    listEvents(options?: ClineAutomationListEventsOptions): ClineAutomationEventLog[];
+    getEvent(eventId: string): ClineAutomationEventLog | undefined;
+    listSpecs(options?: ClineAutomationListSpecsOptions): ClineAutomationSpec[];
+    listRuns(options?: ClineAutomationListRunsOptions): ClineAutomationRun[];
+}
+export type ClineCoreListHistoryOptions = SessionHistoryListOptions;
+export interface ClineCoreStartInput extends Omit<StartSessionInput, "config" | "localRuntime"> {
+    config: ClineCoreStartConfig;
+    localRuntime?: LocalRuntimeStartOptions;
+}
+export interface RestoreOptions {
+    /**
+     * Restore the message history by starting a new session fork trimmed to
+     * `checkpointRunCount`. Defaults to true.
+     */
+    messages?: boolean;
+    /**
+     * Restore the workspace files from the checkpoint's git snapshot.
+     * Defaults to true.
+     */
+    workspace?: boolean;
+    /**
+     * Start the forked session with messages before the checkpoint user message
+     * while still returning messages through that user message. This is for
+     * clients that put the checkpoint message back into a compose box so it can
+     * be edited and submitted again without duplicating it in session history.
+     */
+    omitCheckpointMessageFromSession?: boolean;
+}
+export interface RestoreInput {
+    sessionId: string;
+    checkpointRunCount: number;
+    start?: ClineCoreStartInput;
+    cwd?: string;
+    restore?: RestoreOptions;
+}
+export interface RestoreResult {
+    sessionId?: string;
+    startResult?: StartSessionResult;
+    messages?: MessageWithMetadata[];
+    checkpoint: CheckpointEntry;
+}
+export interface CompareCheckpointInput {
+    sessionId: string;
+    checkpointRunCount: number;
+    cwd?: string;
+}
+export type CompareCheckpointResult = CheckpointWorkspaceCompareResult;
+export interface ClineCoreOptions {
+    /**
+     * A human-readable name for this SDK client (e.g. `"my-app"`, `"acme-bot"`).
+     * Used to identify the consumer in telemetry and logs.
+     */
+    clientName?: string;
+    /**
+     * A stable identifier for this machine or user, used for telemetry attribution.
+     * Defaults to the system machine ID, falling back to a generated `cl-<nanoid>` persisted
+     * at `~/.cline/data/machine-id`.
+     */
+    distinctId?: string;
+    /**
+     * Controls how the runtime host is selected:
+     * - `"auto"` (default) — prefers a compatible local hub when one is available and falls
+     *   back to local in-process execution when not.
+     * - `"hub"` — requires a compatible websocket hub runtime; throws if one is not reachable.
+     * - `"remote"` — requires an explicit remote websocket hub endpoint.
+     * - `"local"` — always uses local in-process execution and local SQLite/file storage.
+     */
+    backendMode?: RuntimeHostMode;
+    /**
+     * Hub runtime connection options. Used when `backendMode` is `"hub"` or when `"auto"`
+     * should prefer a shared local hub if available.
+     */
+    hub?: HubOptions;
+    /**
+     * Remote hub connection options. Only relevant when `backendMode` is `"remote"`.
+     */
+    remote?: RemoteOptions;
+    /**
+     * Client-owned runtime capabilities. Core adapts these handlers to the
+     * selected runtime backend so apps implement interactive behavior once.
+     */
+    capabilities?: RuntimeCapabilities;
+    /**
+     * Telemetry service instance to use for capturing events and usage.
+     * If omitted, telemetry is a no-op.
+     */
+    telemetry?: ITelemetryService;
+    /**
+     * Feature flags service for this ClineCore instance.
+     * If omitted, Core uses a no-op provider with default flag values.
+     */
+    featureFlags?: FeatureFlagsService;
+    /**
+     * Optional structured logger for core-side operational diagnostics such as
+     * runtime-host selection and fallback decisions.
+     */
+    logger?: BasicLogger;
+    /**
+     * Per-tool approval policies that control whether a tool runs automatically,
+     * requires user confirmation, or is blocked entirely.
+     */
+    toolPolicies?: AgentConfig["toolPolicies"];
+    /**
+     * Optional hook invoked after `messages.json` is persisted to disk.
+     * Consumers can use this to mirror session transcripts into remote storage.
+     */
+    messagesArtifactUploader?: SessionMessagesArtifactUploader;
+    /**
+     * Enables file-based and event-driven automation through this ClineCore
+     * instance. When configured, callers use `cline.automation.*` instead of
+     * constructing cron services directly.
+     */
+    automation?: boolean | ClineCoreAutomationOptions;
+    /**
+     * Custom `fetch` implementation forwarded to the AI gateway providers used
+     * by local sessions. When supplied, it is threaded into each
+     * `ProviderConfig.fetch` built during session bootstrap, which in turn
+     * populates `GatewayProviderSettings.fetch` (and the top-level
+     * `GatewayConfig.fetch` fallback) so hosts can inject custom HTTP behavior
+     * such as proxies, retries, tracing, or test doubles.
+     *
+     * Per-session or per-provider overrides still win: an explicit
+     * `config.fetch` on `CoreSessionConfig` or a stored provider-level `fetch`
+     * takes precedence over this default.
+     *
+     * Applies only to sessions executed in this process (local and fallback-
+     * to-local auto mode). For hub and remote runtimes the HTTP call happens
+     * inside the process that owns the gateway, so configure `fetch` there:
+     *   - `startHubServer({ fetch })` / `ensureHubServer({ fetch })` from
+     *     `@cline/hub`
+     *   - `createLocalHubScheduleRuntimeHandlers({ fetch })` from
+     *     `@cerebriline/core/hub` for the scheduler
+     */
+    fetch?: typeof fetch;
+    /**
+     * An already-constructed session backend to use instead of resolving one automatically.
+     * Intended for testing or embedding a custom persistence layer.
+     * @internal
+     */
+    sessionService?: SessionBackend;
+    /**
+     * Optional hook invoked before each session starts.
+     * Use this to prepare workspace-scoped runtime state and then return an
+     * adapter that mutates the shared session input before core starts the run.
+     * This runs before the execution host resolves an omitted workspace, so
+     * pathless starts expose neither `cwd` nor `workspaceRoot` to this hook.
+     */
+    prepare?: (input: ClineCoreStartInput) => Promise<StartSessionBootstrap | undefined> | StartSessionBootstrap | undefined;
+}
+export interface StartSessionBootstrap {
+    applyToStartSessionInput(input: ClineCoreStartInput): Promise<ClineCoreStartInput> | ClineCoreStartInput;
+    dispose?(): Promise<void> | void;
+}

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

@@ -0,0 +1,37 @@
+import type { AutomationEventEnvelope, BasicLogger } from "@cerebriline/shared";
+import type { CronEventLogRecord, CronRunRecord, CronSpecRecord, SqliteCronStore } from "../store/sqlite-cron-store";
+/**
+ * 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
+ * execute agents; the normal runner claim loop owns execution.
+ */
+export interface CronEventIngressOptions {
+    store: SqliteCronStore;
+    now?: () => number;
+    logger?: BasicLogger;
+}
+export type CronEventSuppressionReason = "duplicate_event" | "filter_mismatch" | "dedupe_window" | "cooldown";
+export interface CronEventSuppression {
+    specId?: string;
+    externalId?: string;
+    reason: CronEventSuppressionReason;
+    dedupeKey?: string;
+}
+export interface CronEventIngressResult {
+    event: CronEventLogRecord;
+    duplicate: boolean;
+    matchedSpecs: CronSpecRecord[];
+    queuedRuns: CronRunRecord[];
+    suppressions: CronEventSuppression[];
+}
+export declare function automationEventMatchesFilters(event: AutomationEventEnvelope, filters: Record<string, unknown> | undefined): boolean;
+export declare class CronEventIngress {
+    private readonly store;
+    private readonly nowFn;
+    private readonly logger?;
+    constructor(options: CronEventIngressOptions);
+    ingestEvent(event: AutomationEventEnvelope): CronEventIngressResult;
+    private materializeForSpec;
+}

package/dist/cron/reports/cron-report-writer.d.ts

@@ -0,0 +1,42 @@
+import { type ResolveCronSpecsDirOptions } from "@cerebriline/shared/storage";
+import type { CronEventLogRecord, CronRunRecord, CronSpecRecord } from "../store/sqlite-cron-store";
+/**
+ * Writes a markdown report for a completed or failed cron run.
+ * Reports live under `<cron-specs-dir>/reports/<run-id>.md`.
+ * By default that is `~/.cline/cron/reports/<run-id>.md`.
+ * and are derived artifacts — the database is still the operational source
+ * of truth.
+ */
+export interface CronRunReportData {
+    finalText?: string;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cacheReadTokens?: number;
+        cacheWriteTokens?: number;
+        totalCost?: number;
+    };
+    toolCalls?: Array<{
+        name: string;
+        error?: string;
+        durationMs?: number;
+    }>;
+    durationMs?: number;
+    error?: string;
+    /** Optional context for where in the run lifecycle the error occurred. */
+    errorContext?: string;
+    triggerEvent?: CronEventLogRecord;
+}
+export interface WriteReportOptions {
+    /**
+     * Cron spec source/report location. Defaults to global `~/.cline/cron`.
+     * Pass `{ scope: "workspace", workspaceRoot }` to write reports beside a
+     * future workspace-scoped cron specs directory.
+     */
+    specs?: ResolveCronSpecsDirOptions;
+    workspaceRoot: string;
+    run: CronRunRecord;
+    spec: CronSpecRecord;
+    data: CronRunReportData;
+}
+export declare function writeCronRunReport(options: WriteReportOptions): string;

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

@@ -0,0 +1,35 @@
+import type { CronSpecRecord, SqliteCronStore } from "../store/sqlite-cron-store";
+/**
+ * Queue materialization rules shared between the reconciler, watcher, and
+ * periodic runner tick. Execution stays trigger-agnostic once a row is
+ * queued; this module is the only place that decides when to create a row.
+ */
+export interface CronMaterializerOptions {
+    store: SqliteCronStore;
+    now?: () => number;
+}
+export interface MaterializeSummary {
+    oneOffQueued: number;
+    scheduleQueued: number;
+}
+export declare class CronMaterializer {
+    private readonly store;
+    private readonly nowFn;
+    constructor(options: CronMaterializerOptions);
+    /**
+     * Run materialization for every valid/enabled spec. Typically called at
+     * startup (after reconciliation) and on each runner tick.
+     */
+    materializeAll(): MaterializeSummary;
+    /**
+     * Ensure a single one-off spec has exactly one run record for its current
+     * revision unless an explicit rerun path creates a different trigger kind.
+     * Returns true if a new queued run was created.
+     */
+    materializeOneOff(spec: CronSpecRecord): boolean;
+    /**
+     * Materialize schedule runs. Implements the "one overdue catch-up on
+     * startup, then advance" policy described in PLAN.md.
+     */
+    materializeSchedule(spec: CronSpecRecord): boolean;
+}

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

@@ -0,0 +1,60 @@
+import type { BasicLogger } from "@cerebriline/shared";
+import type { ResolveCronSpecsDirOptions } from "@cerebriline/shared/storage";
+import type { HubScheduleRuntimeHandlers } from "../service/schedule-service";
+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;
+    runtimeHandlers: HubScheduleRuntimeHandlers;
+    eventPublisher?: (eventType: string, payload: Record<string, unknown>) => void;
+    /** Default runtime workspace for the hub/daemon process. */
+    workspaceRoot: string;
+    /** Cron spec source/report location. Defaults to global `~/.cline/cron`. */
+    specs?: ResolveCronSpecsDirOptions;
+    logger?: BasicLogger;
+    pollIntervalMs?: number;
+    claimLeaseSeconds?: number;
+    globalMaxConcurrency?: number;
+}
+export declare class CronRunner {
+    private readonly store;
+    private readonly materializer;
+    private readonly options;
+    private readonly limiter;
+    private readonly claimLeaseMs;
+    private timer;
+    private started;
+    private ticking;
+    private disposed;
+    private stopping;
+    private readonly activeRuns;
+    constructor(options: CronRunnerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    dispose(): Promise<void>;
+    tick(): Promise<void>;
+    getActiveRuns(): Array<CronRunRecord & {
+        claimToken: string;
+        sessionId?: string;
+    }>;
+    private executeClaim;
+    private publishScheduleExecutionEvent;
+    private buildPrompt;
+    private startClaimLeaseHeartbeat;
+    private buildSystemPrompt;
+    private buildStartRequest;
+}

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

@@ -0,0 +1,8 @@
+export declare class ResourceLimiter {
+    private readonly globalMaxConcurrency;
+    private readonly activeExecutions;
+    constructor(globalMaxConcurrency: number);
+    acquire(scheduleId: string, executionId: string, maxParallel: number): boolean;
+    release(scheduleId: string, executionId: string): void;
+    getGlobalActiveCount(): number;
+}

package/dist/cron/schedule/scheduler.d.ts

@@ -0,0 +1,12 @@
+export interface ParsedCron {
+    minutes: number[];
+    hours: number[];
+    daysOfMonth: number[];
+    months: number[];
+    daysOfWeek: number[];
+}
+export declare function parseCron(pattern: string): ParsedCron;
+export declare function validateCronPattern(pattern: string): void;
+export declare function validateCronSchedule(pattern: string, timezone?: string, after?: number): void;
+export declare function validateTimezone(timezone: string | undefined): void;
+export declare function getNextCronTime(pattern: string, after: number, timezone?: string): number;

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

@@ -0,0 +1,56 @@
+import type { AutomationEventEnvelope, BasicLogger } from "@cerebriline/shared";
+import type { ResolveCronSpecsDirOptions } from "@cerebriline/shared/storage";
+import { type CronEventIngressResult } from "../events/cron-event-ingress";
+import type { CronRunRecord, CronSpecRecord, ListEventLogsOptions, ListRunsOptions, ListSpecsOptions } from "../store/sqlite-cron-store";
+import type { HubScheduleRuntimeHandlers } from "./schedule-service";
+/**
+ * Top-level orchestrator for file-based cron automation.
+ *
+ * Wires together:
+ *   - `SqliteCronStore` (cron.db)
+ *   - `CronReconciler` (disk -> DB)
+ *   - `CronWatcher` (cron specs directory filesystem events)
+ *   - `CronMaterializer` (queue materialization)
+ *   - `CronRunner` (claim + execute + report)
+ *
+ * This service is the forward path: the legacy `HubScheduleService`
+ * continues to serve programmatic schedules, while `CronService` handles
+ * everything sourced from the configured file-based cron directory.
+ */
+export interface CronServiceOptions {
+    /** Default runtime workspace for the hub/daemon process. */
+    workspaceRoot: string;
+    /** Cron spec source/report location. Defaults to global `~/.cline/cron`. */
+    specs?: ResolveCronSpecsDirOptions;
+    runtimeHandlers: HubScheduleRuntimeHandlers;
+    dbPath?: string;
+    logger?: BasicLogger;
+    pollIntervalMs?: number;
+    claimLeaseSeconds?: number;
+    globalMaxConcurrency?: number;
+    watcherDebounceMs?: number;
+}
+export declare class CronService {
+    private readonly store;
+    private readonly reconciler;
+    private readonly watcher;
+    private readonly eventIngress;
+    private readonly materializer;
+    private readonly runner;
+    private started;
+    private disposed;
+    constructor(options: CronServiceOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    dispose(): Promise<void>;
+    listSpecs(options?: ListSpecsOptions): CronSpecRecord[];
+    getSpec(specId: string): CronSpecRecord | undefined;
+    listRuns(options?: ListRunsOptions): CronRunRecord[];
+    getRun(runId: string): CronRunRecord | undefined;
+    listActiveRuns(): CronRunRecord[];
+    listUpcomingRuns(limit?: number): CronRunRecord[];
+    reconcileNow(): Promise<void>;
+    ingestEvent(event: AutomationEventEnvelope): CronEventIngressResult;
+    listEventLogs(options?: ListEventLogsOptions): import("../store/sqlite-cron-store").CronEventLogRecord[];
+    getEventLog(eventId: string): import("../store/sqlite-cron-store").CronEventLogRecord | undefined;
+}

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

@@ -0,0 +1,14 @@
+import type { HubCommandEnvelope, HubReplyEnvelope } from "@cerebriline/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, authority?: HubConnectionAuthority): Promise<HubReplyEnvelope>;
+    private resolveScope;
+    private requireScopedSchedule;
+    private scopedScheduleIds;
+    private listScopedExecutions;
+    private toCreateInput;
+    private toUpdateInput;
+}

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

@@ -0,0 +1,116 @@
+import { type BasicLogger, type ChatRunTurnRequest, type ChatStartSessionArtifacts, type ChatStartSessionRequest, type HubScheduleCreateInput, type HubScheduleUpdateInput, type ScheduleExecutionRecord, type ScheduleExecutionStatus, type ScheduleRecord } from "@cerebriline/shared";
+import type { ResolveCronSpecsDirOptions } from "@cerebriline/shared/storage";
+type HubScheduleTurnResult = {
+    text: string;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cacheReadTokens?: number;
+        cacheWriteTokens?: number;
+        totalCost?: number;
+    };
+    inputTokens?: number;
+    outputTokens?: number;
+    iterations?: number;
+    finishReason?: string;
+    messages?: unknown[];
+    toolCalls?: Array<{
+        name: string;
+        input?: unknown;
+        output?: unknown;
+        error?: string;
+        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, options?: HubScheduleStartSessionOptions): Promise<{
+        sessionId: string;
+        startResult?: ChatStartSessionArtifacts;
+    }>;
+    sendSession(sessionId: string, request: ChatRunTurnRequest): Promise<{
+        result: HubScheduleTurnResult;
+    }>;
+    abortSession(sessionId: string): Promise<{
+        applied: boolean;
+    }>;
+    stopSession(sessionId: string): Promise<{
+        applied: boolean;
+    }>;
+}
+export interface ActiveScheduledExecution {
+    executionId: string;
+    scheduleId: string;
+    sessionId: string;
+    startedAt: string;
+    timeoutAt?: string;
+}
+export interface HubScheduleServiceOptions {
+    runtimeHandlers: HubScheduleRuntimeHandlers;
+    eventPublisher?: (eventType: string, payload: Record<string, unknown>) => void;
+    logger?: BasicLogger;
+    dbPath?: string;
+    /**
+     * Cron spec source/report location forwarded to the runner. Defaults to
+     * the global `~/.cline/cron` directory — tests must override this so run
+     * reports land in a temp directory instead of the user's real one.
+     */
+    specs?: ResolveCronSpecsDirOptions;
+    pollIntervalMs?: number;
+    globalMaxConcurrency?: number;
+    claimLeaseSeconds?: number;
+}
+export interface ListSchedulesOptions {
+    enabled?: boolean;
+    limit?: number;
+    tags?: string[];
+    workspaceRoot?: string;
+}
+export interface ListScheduleExecutionsOptions {
+    scheduleId?: string;
+    status?: ScheduleExecutionStatus;
+    limit?: number;
+}
+export interface ScheduleExecutionStats {
+    totalRuns: number;
+    successRate: number;
+    avgDurationSeconds: number;
+    lastFailure?: ScheduleExecutionRecord;
+}
+export declare class HubScheduleService {
+    private readonly store;
+    private readonly materializer;
+    private readonly runner;
+    private started;
+    private disposed;
+    constructor(options: HubScheduleServiceOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    dispose(): Promise<void>;
+    createSchedule(input: HubScheduleCreateInput): ScheduleRecord;
+    getSchedule(scheduleId: string): ScheduleRecord | undefined;
+    listSchedules(options?: ListSchedulesOptions): ScheduleRecord[];
+    updateSchedule(scheduleId: string, updates: HubScheduleUpdateInput): ScheduleRecord | undefined;
+    private validateScheduleTiming;
+    deleteSchedule(scheduleId: string): boolean;
+    pauseSchedule(scheduleId: string): ScheduleRecord | undefined;
+    resumeSchedule(scheduleId: string): ScheduleRecord | undefined;
+    triggerScheduleNow(scheduleId: string): Promise<ScheduleExecutionRecord | undefined>;
+    triggerScheduleNowDetached(scheduleId: string): ScheduleExecutionRecord | undefined;
+    listScheduleExecutions(options: ListScheduleExecutionsOptions): ScheduleExecutionRecord[];
+    getScheduleStats(scheduleId: string): ScheduleExecutionStats;
+    getActiveExecutions(): ActiveScheduledExecution[];
+    getUpcomingRuns(limit?: number): Array<{
+        scheduleId: string;
+        name: string;
+        nextRunAt: string;
+    }>;
+}
+export {};