@jsonstudio/llms 0.6.1739 → 0.6.1890

package/dist/router/virtual-router/stop-message-stage-template-files.d.ts

@@ -0,0 +1,12 @@
+export type StopMessageStageTemplateName = 'status_probe' | 'active_continue' | 'loop_self_check';
+export interface StopMessageStageTemplateLoadResult {
+    stage: StopMessageStageTemplateName;
+    ref: string;
+    text?: string;
+    error?: string;
+}
+export declare function loadStopMessageStageTemplate(stage: StopMessageStageTemplateName): StopMessageStageTemplateLoadResult;
+export declare function validateStopMessageStageTemplatesCompleteness(): {
+    ok: boolean;
+    missing: StopMessageStageTemplateLoadResult[];
+};

package/dist/router/virtual-router/stop-message-stage-template-files.js

@@ -0,0 +1,67 @@
+import { resolveStopMessageText } from './stop-message-file-resolver.js';
+const DEFAULT_STAGE_TEMPLATE_REFS = {
+    status_probe: '<file://stopMessage/stage-status-check.md>',
+    active_continue: '<file://stopMessage/stage-active-continue.md>',
+    loop_self_check: '<file://stopMessage/stage-loop-self-check.md>'
+};
+const STAGE_ENV_KEYS = {
+    status_probe: 'ROUTECODEX_STOPMESSAGE_STAGE_STATUS_REF',
+    active_continue: 'ROUTECODEX_STOPMESSAGE_STAGE_ACTIVE_REF',
+    loop_self_check: 'ROUTECODEX_STOPMESSAGE_STAGE_LOOP_REF'
+};
+export function loadStopMessageStageTemplate(stage) {
+    const ref = resolveStopMessageStageTemplateRef(stage);
+    if (!ref) {
+        return {
+            stage,
+            ref: '',
+            error: `missing template reference for ${stage}`
+        };
+    }
+    try {
+        const text = resolveStopMessageText(ref);
+        const normalized = typeof text === 'string' ? text.trim() : '';
+        if (!normalized) {
+            return {
+                stage,
+                ref,
+                error: `template is empty for ${stage}`
+            };
+        }
+        return {
+            stage,
+            ref,
+            text: normalized
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error ?? 'unknown error');
+        return {
+            stage,
+            ref,
+            error: message
+        };
+    }
+}
+export function validateStopMessageStageTemplatesCompleteness() {
+    const requiredStages = ['status_probe', 'active_continue', 'loop_self_check'];
+    const missing = [];
+    for (const stage of requiredStages) {
+        const loaded = loadStopMessageStageTemplate(stage);
+        if (!loaded.text) {
+            missing.push(loaded);
+        }
+    }
+    return {
+        ok: missing.length === 0,
+        missing
+    };
+}
+function resolveStopMessageStageTemplateRef(stage) {
+    const envKey = STAGE_ENV_KEYS[stage];
+    const envRef = normalizeText(process.env[envKey]);
+    return envRef || DEFAULT_STAGE_TEMPLATE_REFS[stage];
+}
+function normalizeText(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}

package/dist/router/virtual-router/stop-message-state-sync.d.ts

@@ -1,5 +1,5 @@
 import type { RoutingInstructionState } from './routing-instructions.js';
-type StopMessageSubset = Pick<RoutingInstructionState, 'stopMessageSource' | 'stopMessageText' | 'stopMessageMaxRepeats' | 'stopMessageUsed' | 'stopMessageUpdatedAt' | 'stopMessageLastUsedAt'>;
+type StopMessageSubset = Pick<RoutingInstructionState, 'stopMessageSource' | 'stopMessageText' | 'stopMessageMaxRepeats' | 'stopMessageUsed' | 'stopMessageStage' | 'stopMessageStageMode' | 'stopMessageObservationHash' | 'stopMessageObservationStableCount' | 'stopMessageBdWorkState' | 'stopMessageUpdatedAt' | 'stopMessageLastUsedAt'>;
 /**
  * Decide whether we should overwrite in-memory stopMessage fields with persisted ones.
  *

package/dist/router/virtual-router/stop-message-state-sync.js

@@ -41,6 +41,11 @@ export function mergeStopMessageFromPersisted(existing, persisted) {
             stopMessageText: persisted.stopMessageText,
             stopMessageMaxRepeats: persisted.stopMessageMaxRepeats,
             stopMessageUsed: persisted.stopMessageUsed,
+            stopMessageStage: persisted.stopMessageStage,
+            stopMessageStageMode: persisted.stopMessageStageMode,
+            stopMessageObservationHash: persisted.stopMessageObservationHash,
+            stopMessageObservationStableCount: persisted.stopMessageObservationStableCount,
+            stopMessageBdWorkState: persisted.stopMessageBdWorkState,
             stopMessageUpdatedAt: persisted.stopMessageUpdatedAt,
             stopMessageLastUsedAt: persisted.stopMessageLastUsedAt
         };

package/dist/router/virtual-router/token-file-scanner.d.ts

@@ -13,3 +13,12 @@ export interface OAuthTokenFileMatch {
  * 仅在 Node 环境下使用；如果环境不满足，返回空列表。
  */
 export declare function scanOAuthTokenFiles(oauthProviderId: string, authDir?: string): OAuthTokenFileMatch[];
+/**
+ * 扫描 DeepSeek account token 文件。
+ *
+ * 约定:
+ * - 目录: ~/.routecodex/auth
+ * - 文件名: deepseek-account-<alias>.json
+ *   例如: deepseek-account-1.json, deepseek-account-2-work.json
+ */
+export declare function scanDeepSeekAccountTokenFiles(authDir?: string): OAuthTokenFileMatch[];

package/dist/router/virtual-router/token-file-scanner.js

@@ -2,6 +2,17 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 const TOKEN_FILE_PATTERN = /^([a-z0-9_-]+)-oauth-(\d+)(?:-(.+))?\.json$/i;
+const DEEPSEEK_ACCOUNT_TOKEN_PATTERN = /^deepseek-account-(.+)\.json$/i;
+function resolveAuthDir(authDir) {
+    if (authDir && authDir.trim()) {
+        return authDir.trim();
+    }
+    const envDir = (process.env.ROUTECODEX_AUTH_DIR || process.env.RCC_AUTH_DIR || '').trim();
+    if (envDir) {
+        return envDir;
+    }
+    return path.join(os.homedir(), '.routecodex', 'auth');
+}
 /**
  * 扫描本地 RouteCodex auth 目录中的 OAuth token 文件。
  *
@@ -19,9 +30,7 @@ export function scanOAuthTokenFiles(oauthProviderId, authDir) {
     if (!provider) {
         return [];
     }
-    const baseDir = authDir && authDir.trim()
-        ? authDir.trim()
-        : path.join(os.homedir(), '.routecodex', 'auth');
+    const baseDir = resolveAuthDir(authDir);
     let entries;
     try {
         entries = fs.readdirSync(baseDir);
@@ -51,6 +60,58 @@ export function scanOAuthTokenFiles(oauthProviderId, authDir) {
     matches.sort((a, b) => a.sequence - b.sequence);
     return matches;
 }
+/**
+ * 扫描 DeepSeek account token 文件。
+ *
+ * 约定:
+ * - 目录: ~/.routecodex/auth
+ * - 文件名: deepseek-account-<alias>.json
+ *   例如: deepseek-account-1.json, deepseek-account-2-work.json
+ */
+export function scanDeepSeekAccountTokenFiles(authDir) {
+    if (!isNodeEnvironment()) {
+        return [];
+    }
+    const baseDir = resolveAuthDir(authDir);
+    let entries;
+    try {
+        entries = fs.readdirSync(baseDir);
+    }
+    catch {
+        return [];
+    }
+    const matches = [];
+    for (const entry of entries) {
+        if (!entry.endsWith('.json'))
+            continue;
+        const match = entry.match(DEEPSEEK_ACCOUNT_TOKEN_PATTERN);
+        if (!match)
+            continue;
+        const aliasRaw = (match[1] || '').trim();
+        if (!aliasRaw.length)
+            continue;
+        const numericMatch = aliasRaw.match(/^(\d+)(?:-|$)/);
+        const numericPrefix = numericMatch ? Number.parseInt(numericMatch[1], 10) : undefined;
+        matches.push({
+            filePath: path.join(baseDir, entry),
+            alias: aliasRaw,
+            ...(Number.isFinite(numericPrefix) ? { numericPrefix } : {})
+        });
+    }
+    matches.sort((a, b) => {
+        const aNum = typeof a.numericPrefix === 'number' ? a.numericPrefix : Number.POSITIVE_INFINITY;
+        const bNum = typeof b.numericPrefix === 'number' ? b.numericPrefix : Number.POSITIVE_INFINITY;
+        if (aNum !== bNum) {
+            return aNum - bNum;
+        }
+        return a.alias.localeCompare(b.alias);
+    });
+    return matches.map((entry, index) => ({
+        filePath: entry.filePath,
+        sequence: index + 1,
+        alias: entry.alias
+    }));
+}
 function isNodeEnvironment() {
     return typeof process !== 'undefined' && !!process.release && process.release.name === 'node';
 }

package/dist/router/virtual-router/tool-signals.d.ts

@@ -8,6 +8,11 @@ export type ToolClassification = {
 export declare function detectVisionTool(request: StandardizedRequest): boolean;
 export declare function detectCodingTool(request: StandardizedRequest): boolean;
 export declare function detectWebTool(request: StandardizedRequest): boolean;
+/**
+ * Detect if a web_search tool is explicitly declared in the request tools list.
+ * This is used for routing decisions in the classifier.
+ */
+export declare function detectWebSearchToolDeclared(request: StandardizedRequest): boolean;
 export declare function extractMeaningfulDeclaredToolNames(tools: StandardizedRequest['tools'] | undefined): string[];
 export declare function detectLastAssistantToolCategory(messages: StandardizedMessage[]): ToolClassification | undefined;
 export declare function classifyToolCallForReport(call: StandardizedMessage['tool_calls'][number]): ToolClassification | undefined;

package/dist/router/virtual-router/tool-signals.js

@@ -61,6 +61,8 @@ const COMMAND_ALIASES = new Map([
     ['perl5', 'perl']
 ]);
 const GIT_WRITE_SUBCOMMANDS = new Set(['add', 'commit', 'apply', 'am', 'rebase', 'checkout', 'merge']);
+const GIT_SEARCH_SUBCOMMANDS = new Set(['grep', 'log', 'shortlog', 'reflog', 'blame']);
+const BD_SEARCH_SUBCOMMANDS = new Set(['search']);
 const PACKAGE_MANAGER_COMMANDS = new Map([
     ['npm', new Set(['install'])],
     ['pnpm', new Set(['install'])],
@@ -113,6 +115,21 @@ export function detectWebTool(request) {
             WEB_TOOL_KEYWORDS.some((keyword) => normalizedDesc.includes(keyword)));
     });
 }
+/**
+ * Detect if a web_search tool is explicitly declared in the request tools list.
+ * This is used for routing decisions in the classifier.
+ */
+export function detectWebSearchToolDeclared(request) {
+    if (!Array.isArray(request.tools)) {
+        return false;
+    }
+    return request.tools.some((tool) => {
+        const functionName = extractToolName(tool);
+        const normalizedName = functionName.toLowerCase().replace(/[-_]/g, '');
+        // Match exact web_search tool name (with or without underscore/dash)
+        return normalizedName === 'websearch';
+    });
+}
 export function extractMeaningfulDeclaredToolNames(tools) {
     if (!Array.isArray(tools) || tools.length === 0) {
         return [];
@@ -547,9 +564,31 @@ function isSearchBinary(binary, args) {
     if (SHELL_SEARCH_COMMANDS.has(normalized)) {
         return true;
     }
-    if (normalized === 'git' && args.length > 0) {
-        const sub = args[0].toLowerCase();
-        if (sub === 'grep') {
+    if (normalized === 'git') {
+        if (containsSubcommand(args, GIT_SEARCH_SUBCOMMANDS)) {
+            return true;
+        }
+    }
+    if (normalized === 'bd') {
+        if (containsSubcommand(args, BD_SEARCH_SUBCOMMANDS)) {
+            return true;
+        }
+    }
+    return false;
+}
+function containsSubcommand(args, candidates) {
+    if (!Array.isArray(args) || args.length === 0 || !candidates.size) {
+        return false;
+    }
+    for (const raw of args) {
+        if (typeof raw !== 'string') {
+            continue;
+        }
+        const token = raw.trim().toLowerCase();
+        if (!token || token.startsWith('-')) {
+            continue;
+        }
+        if (candidates.has(token)) {
             return true;
         }
     }

package/dist/router/virtual-router/types.d.ts

@@ -44,6 +44,10 @@ export interface ProviderAuthConfig {
     oauthProviderId?: string;
     rawType?: string;
 }
+export interface DeepSeekCompatRuntimeOptions {
+    strictToolRequired?: boolean;
+    textToolFallback?: boolean;
+}
 export interface ProviderProfile {
     providerKey: string;
     providerType: string;
@@ -57,6 +61,7 @@ export interface ProviderProfile {
     responsesConfig?: ResponsesProviderConfig;
     streaming?: StreamingPreference;
     maxContextTokens?: number;
+    deepseek?: DeepSeekCompatRuntimeOptions;
     /**
      * When true, this provider must be skipped for any request that
      * requires server-side tool orchestration (e.g. web_search).
@@ -83,6 +88,7 @@ export interface ProviderRuntimeProfile {
     modelContextTokens?: Record<string, number>;
     defaultContextTokens?: number;
     maxContextTokens?: number;
+    deepseek?: DeepSeekCompatRuntimeOptions;
     /**
      * Provider-level flag propagated from virtualrouter.providers[*].
      * When true, VirtualRouterEngine will skip this runtime for any
@@ -381,6 +387,7 @@ export interface RoutingFeatures {
     hasVisionTool: boolean;
     hasImageAttachment: boolean;
     hasWebTool: boolean;
+    hasWebSearchToolDeclared?: boolean;
     hasCodingTool: boolean;
     hasThinkingKeyword: boolean;
     estimatedTokens: number;
@@ -417,6 +424,7 @@ export interface TargetMetadata {
     responsesConfig?: ResponsesProviderConfig;
     streaming?: StreamingPreference;
     maxContextTokens?: number;
+    deepseek?: DeepSeekCompatRuntimeOptions;
     /**
      * Route-level flags propagated from the virtual router.
      * These are derived from routing pools and webSearch config and
@@ -449,7 +457,7 @@ export interface RoutingDiagnostics {
     confidence: number;
 }
 export interface StopMessageStateSnapshot {
-    stopMessageText: string;
+    stopMessageText?: string;
     stopMessageMaxRepeats: number;
     /**
      * stopMessage 来源：
@@ -460,6 +468,16 @@ export interface StopMessageStateSnapshot {
     stopMessageUsed?: number;
     stopMessageUpdatedAt?: number;
     stopMessageLastUsedAt?: number;
+    stopMessageStage?: string;
+    stopMessageStageMode?: 'on' | 'off' | 'auto';
+    stopMessageObservationHash?: string;
+    stopMessageObservationStableCount?: number;
+    stopMessageBdWorkState?: string;
+}
+export interface PreCommandStateSnapshot {
+    preCommandScriptPath: string;
+    preCommandSource?: string;
+    preCommandUpdatedAt?: number;
 }
 export interface RoutingStatusSnapshot {
     routes: Record<string, {

package/dist/router/virtual-router/types.js

@@ -4,6 +4,7 @@
 export const DEFAULT_MODEL_CONTEXT_TOKENS = 200_000;
 export const DEFAULT_ROUTE = 'default';
 export const ROUTE_PRIORITY = [
+    'multimodal',
     'vision',
     'longcontext',
     'web_search',

package/dist/servertool/clock/config.d.ts

@@ -1,7 +1,7 @@
 import type { ClockConfigSnapshot } from './types.js';
 export declare const CLOCK_CONFIG_DEFAULTS: {
     readonly retentionMs: number;
-    readonly dueWindowMs: 60000;
+    readonly dueWindowMs: 0;
     readonly tickMs: 60000;
     readonly holdNonStreaming: true;
     readonly holdMaxMs: 60000;

package/dist/servertool/clock/config.js

@@ -1,10 +1,35 @@
 export const CLOCK_CONFIG_DEFAULTS = {
     retentionMs: 20 * 60_000,
-    dueWindowMs: 60_000,
+    dueWindowMs: 0,
     tickMs: 60_000,
     holdNonStreaming: true,
     holdMaxMs: 60_000
 };
+function parseBooleanWithDefault(value, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        if (value === 1)
+            return true;
+        if (value === 0)
+            return false;
+        return fallback;
+    }
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on') {
+            return true;
+        }
+        if (normalized === 'false' || normalized === '0' || normalized === 'no' || normalized === 'off') {
+            return false;
+        }
+    }
+    return fallback;
+}
 export function normalizeClockConfig(raw) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
         return null;
@@ -25,9 +50,7 @@ export function normalizeClockConfig(raw) {
     const tickMs = typeof record.tickMs === 'number' && Number.isFinite(record.tickMs) && record.tickMs >= 0
         ? Math.floor(record.tickMs)
         : CLOCK_CONFIG_DEFAULTS.tickMs;
-    const holdNonStreaming = record.holdNonStreaming === true ||
-        (typeof record.holdNonStreaming === 'string' && record.holdNonStreaming.trim().toLowerCase() === 'true') ||
-        (typeof record.holdNonStreaming === 'number' && record.holdNonStreaming === 1);
+    const holdNonStreaming = parseBooleanWithDefault(record.holdNonStreaming, CLOCK_CONFIG_DEFAULTS.holdNonStreaming);
     const holdMaxMs = typeof record.holdMaxMs === 'number' && Number.isFinite(record.holdMaxMs) && record.holdMaxMs >= 0
         ? Math.floor(record.holdMaxMs)
         : CLOCK_CONFIG_DEFAULTS.holdMaxMs;

package/dist/servertool/clock/state.js

@@ -1,4 +1,29 @@
 let clockOffsetMs = 0;
+const CLOCK_OVERDUE_AUTO_REMOVE_MS = 60_000;
+function normalizeRecurrence(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
+    }
+    const record = raw;
+    const rawKind = typeof record.kind === 'string' ? record.kind.trim().toLowerCase() : '';
+    const kind = rawKind === 'daily' || rawKind === 'weekly' || rawKind === 'interval'
+        ? rawKind
+        : undefined;
+    const maxRunsRaw = Number(record.maxRuns);
+    const maxRuns = Number.isFinite(maxRunsRaw) ? Math.floor(maxRunsRaw) : NaN;
+    if (!kind || !Number.isFinite(maxRuns) || maxRuns <= 0) {
+        return undefined;
+    }
+    if (kind === 'interval') {
+        const minutesRaw = Number(record.everyMinutes);
+        const everyMinutes = Number.isFinite(minutesRaw) ? Math.floor(minutesRaw) : NaN;
+        if (!Number.isFinite(everyMinutes) || everyMinutes <= 0) {
+            return undefined;
+        }
+        return { kind, maxRuns, everyMinutes };
+    }
+    return { kind, maxRuns };
+}
 export function setClockOffsetMs(value) {
     if (typeof value !== 'number' || !Number.isFinite(value))
         return;
@@ -42,6 +67,7 @@ export function coerceState(raw, sessionId) {
             ? e.notBeforeRequestId.trim()
             : undefined;
         const deliveryCount = typeof e.deliveryCount === 'number' && Number.isFinite(e.deliveryCount) ? Math.max(0, Math.floor(e.deliveryCount)) : 0;
+        const recurrence = normalizeRecurrence(e.recurrence);
         tasks.push({
             taskId,
             sessionId,
@@ -53,7 +79,8 @@ export function coerceState(raw, sessionId) {
             ...(args ? { arguments: args } : {}),
             ...(deliveredAtMs !== undefined ? { deliveredAtMs } : {}),
             deliveryCount,
-            ...(notBeforeRequestId ? { notBeforeRequestId } : {})
+            ...(notBeforeRequestId ? { notBeforeRequestId } : {}),
+            ...(recurrence ? { recurrence } : {})
         });
     }
     const updatedAtMs = typeof record.updatedAtMs === 'number' && Number.isFinite(record.updatedAtMs) ? Math.floor(record.updatedAtMs) : nowMs();
@@ -66,7 +93,19 @@ export function cleanExpiredTasks(tasks, config, atMs) {
             continue;
         if (!Number.isFinite(task.dueAtMs))
             continue;
-        if (atMs > task.dueAtMs + config.retentionMs) {
+        const recurrence = normalizeRecurrence(task.recurrence);
+        const deliveryCount = typeof task.deliveryCount === 'number' && Number.isFinite(task.deliveryCount)
+            ? Math.max(0, Math.floor(task.deliveryCount))
+            : 0;
+        if (recurrence) {
+            if (deliveryCount >= recurrence.maxRuns) {
+                continue;
+            }
+            out.push({ ...task, recurrence });
+            continue;
+        }
+        const oneShotRetentionMs = Math.max(0, Math.min(config.retentionMs, CLOCK_OVERDUE_AUTO_REMOVE_MS));
+        if (atMs > task.dueAtMs + oneShotRetentionMs) {
             continue;
         }
         out.push(task);

package/dist/servertool/clock/task-store.d.ts

@@ -1,5 +1,5 @@
-export type { ClockConfigSnapshot, ClockReservation, ClockScheduleItem, ClockSessionState, ClockTask } from './types.js';
+export type { ClockConfigSnapshot, ClockReservation, ClockScheduleItem, ClockSessionState, ClockTask, ClockTaskRecurrence, ClockTaskUpdatePatch } from './types.js';
 export { normalizeClockConfig, resolveClockConfig } from './config.js';
 export { startClockDaemonIfNeeded, stopClockDaemonForTests } from './daemon.js';
 export { loadClockSessionState, clearClockSession } from './session-store.js';
-export { cancelClockTask, clearClockTasks, commitClockReservation, findNextUndeliveredDueAtMs, listClockTasks, parseDueAtMs, reserveDueTasksForRequest, scheduleClockTasks, selectDueUndeliveredTasks } from './tasks.js';
+export { cancelClockTask, clearClockTasks, commitClockReservation, findNextUndeliveredDueAtMs, listClockSessionIds, listClockTasks, parseDueAtMs, reserveDueTasksForRequest, scheduleClockTasks, selectDueUndeliveredTasks, updateClockTask } from './tasks.js';

package/dist/servertool/clock/task-store.js

@@ -1,4 +1,4 @@
 export { normalizeClockConfig, resolveClockConfig } from './config.js';
 export { startClockDaemonIfNeeded, stopClockDaemonForTests } from './daemon.js';
 export { loadClockSessionState, clearClockSession } from './session-store.js';
-export { cancelClockTask, clearClockTasks, commitClockReservation, findNextUndeliveredDueAtMs, listClockTasks, parseDueAtMs, reserveDueTasksForRequest, scheduleClockTasks, selectDueUndeliveredTasks } from './tasks.js';
+export { cancelClockTask, clearClockTasks, commitClockReservation, findNextUndeliveredDueAtMs, listClockSessionIds, listClockTasks, parseDueAtMs, reserveDueTasksForRequest, scheduleClockTasks, selectDueUndeliveredTasks, updateClockTask } from './tasks.js';

package/dist/servertool/clock/tasks.d.ts

@@ -1,7 +1,9 @@
-import type { ClockConfigSnapshot, ClockReservation, ClockScheduleItem, ClockTask } from './types.js';
+import type { ClockConfigSnapshot, ClockReservation, ClockScheduleItem, ClockTask, ClockTaskUpdatePatch } from './types.js';
 export declare function parseDueAtMs(value: unknown): number | null;
+export declare function listClockSessionIds(): Promise<string[]>;
 export declare function listClockTasks(sessionId: string, config: ClockConfigSnapshot): Promise<ClockTask[]>;
 export declare function scheduleClockTasks(sessionId: string, items: ClockScheduleItem[], config: ClockConfigSnapshot): Promise<ClockTask[]>;
+export declare function updateClockTask(sessionId: string, taskId: string, patch: ClockTaskUpdatePatch, config: ClockConfigSnapshot): Promise<ClockTask | null>;
 export declare function cancelClockTask(sessionId: string, taskId: string, config: ClockConfigSnapshot): Promise<boolean>;
 export declare function clearClockTasks(sessionId: string, config: ClockConfigSnapshot): Promise<number>;
 export declare function selectDueUndeliveredTasks(tasks: ClockTask[], config: ClockConfigSnapshot, atMs: number): ClockTask[];