@jsonstudio/llms 0.6.938 → 0.6.1164

package/dist/router/virtual-router/load-balancer.d.ts

@@ -3,6 +3,7 @@ export interface LoadBalancingOptions {
     routeName: string;
     candidates: string[];
     stickyKey?: string;
+    weights?: Record<string, number>;
     availabilityCheck: (providerKey: string) => boolean;
 }
 export declare class RouteLoadBalancer {
@@ -10,6 +11,7 @@ export declare class RouteLoadBalancer {
     private readonly states;
     constructor(policy?: LoadBalancingPolicy);
     updatePolicy(policy?: LoadBalancingPolicy): void;
+    getPolicy(): LoadBalancingPolicy;
     select(options: LoadBalancingOptions, strategyOverride?: LoadBalancingPolicy['strategy']): string | null;
     private selectRoundRobin;
     private selectWeighted;

package/dist/router/virtual-router/load-balancer.js

@@ -9,6 +9,9 @@ export class RouteLoadBalancer {
             this.policy = policy;
         }
     }
+    getPolicy() {
+        return this.policy;
+    }
     select(options, strategyOverride) {
         const available = options.candidates.filter((candidate) => options.availabilityCheck(candidate));
         if (available.length === 0) {
@@ -17,10 +20,16 @@ export class RouteLoadBalancer {
         const strategy = strategyOverride ?? this.policy.strategy;
         switch (strategy) {
             case 'sticky':
-                return this.selectSticky(options.routeName, available, options.stickyKey);
+                return this.selectSticky(options.routeName, available, options.stickyKey, options.weights ?? this.policy.weights);
             case 'weighted':
-                return this.selectWeighted(available);
+                return this.selectWeighted(options.routeName, available, options.weights ?? this.policy.weights);
             default:
+                if (options.weights) {
+                    const distinct = new Set(available.map((candidate) => Math.max(1, options.weights?.[candidate] ?? 1)));
+                    if (distinct.size > 1) {
+                        return this.selectWeighted(options.routeName, available, options.weights);
+                    }
+                }
                 return this.selectRoundRobin(options.routeName, available);
         }
     }
@@ -30,23 +39,41 @@ export class RouteLoadBalancer {
         state.pointer = (state.pointer + 1) % candidates.length;
         return choice;
     }
-    selectWeighted(candidates) {
-        if (!this.policy.weights) {
-            return candidates[0];
+    selectWeighted(routeName, candidates, weights) {
+        // Deterministic smooth weighted round-robin (no randomness) so routing behavior is testable and stable.
+        // Each candidate with a positive weight is guaranteed to be selected eventually.
+        const state = this.getState(routeName);
+        const current = state.weighted.currentWeights;
+        const candidateSet = new Set(candidates);
+        for (const existing of Array.from(current.keys())) {
+            if (!candidateSet.has(existing)) {
+                current.delete(existing);
+            }
+        }
+        for (const key of candidates) {
+            if (!current.has(key)) {
+                current.set(key, 0);
+            }
         }
-        const weights = candidates.map((candidate) => Math.max(1, this.policy.weights?.[candidate] ?? 1));
-        const total = weights.reduce((sum, weight) => sum + weight, 0);
-        const threshold = Math.random() * total;
-        let running = 0;
+        const candidateWeights = candidates.map((candidate) => Math.max(1, weights?.[candidate] ?? 1));
+        const totalWeight = candidateWeights.reduce((sum, w) => sum + w, 0);
+        let bestIndex = 0;
+        let bestScore = Number.NEGATIVE_INFINITY;
         for (let i = 0; i < candidates.length; i += 1) {
-            running += weights[i];
-            if (running >= threshold) {
-                return candidates[i];
+            const key = candidates[i];
+            const w = candidateWeights[i];
+            const next = (current.get(key) ?? 0) + w;
+            current.set(key, next);
+            if (next > bestScore) {
+                bestScore = next;
+                bestIndex = i;
             }
         }
-        return candidates[candidates.length - 1];
+        const selectedKey = candidates[bestIndex];
+        current.set(selectedKey, (current.get(selectedKey) ?? 0) - totalWeight);
+        return selectedKey;
     }
-    selectSticky(routeName, candidates, stickyKey) {
+    selectSticky(routeName, candidates, stickyKey, weights) {
         if (!stickyKey) {
             return this.selectRoundRobin(routeName, candidates);
         }
@@ -55,13 +82,15 @@ export class RouteLoadBalancer {
         if (pinned && candidates.includes(pinned)) {
             return pinned;
         }
-        const choice = this.selectRoundRobin(routeName, candidates);
+        const choice = weights && Object.keys(weights).length > 0
+            ? this.selectWeighted(`${routeName}:sticky`, candidates, weights)
+            : this.selectRoundRobin(routeName, candidates);
         state.stickyMap.set(stickyKey, choice);
         return choice;
     }
     getState(routeName) {
         if (!this.states.has(routeName)) {
-            this.states.set(routeName, { pointer: 0, stickyMap: new Map() });
+            this.states.set(routeName, { pointer: 0, stickyMap: new Map(), weighted: { currentWeights: new Map() } });
         }
         return this.states.get(routeName);
     }

package/dist/router/virtual-router/routing-instructions.js

@@ -1,15 +1,21 @@
 import { extractMessageText } from './message-utils.js';
+import { resolveStopMessageText } from './stop-message-file-resolver.js';
 export function parseRoutingInstructions(messages) {
     const instructions = [];
     // 从最新一条携带路由指令标记（<** ... **>）的 user 消息中解析指令，
     // 而不是简单地取"最后一条 user 消息"。这样可以在服务重启后，通过完整
     // 会话历史恢复 sticky/黑名单状态，同时保持"最后一次指令生效"的语义。
     let sanitized = null;
+    let sanitizedIndex = -1;
+    let lastUserIndex = -1;
     for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
         const message = messages[idx];
         if (!message || message.role !== 'user') {
             continue;
         }
+        if (lastUserIndex < 0) {
+            lastUserIndex = idx;
+        }
         const content = extractMessageText(message);
         if (!content) {
             continue;
@@ -22,6 +28,7 @@ export function parseRoutingInstructions(messages) {
             continue;
         }
         sanitized = candidate;
+        sanitizedIndex = idx;
         break;
     }
     if (!sanitized) {
@@ -38,6 +45,15 @@ export function parseRoutingInstructions(messages) {
         for (const segment of segments) {
             const parsed = parseSingleInstruction(segment);
             if (parsed) {
+                // stopMessage is a "command" and must only be set/cleared from the *latest* user message.
+                // Otherwise, clients that resend full history (including a past "<**stopMessage:...**>" message)
+                // would keep re-applying stopMessage after it has been consumed/cleared.
+                if ((parsed.type === 'stopMessageSet' || parsed.type === 'stopMessageClear') &&
+                    lastUserIndex >= 0 &&
+                    sanitizedIndex >= 0 &&
+                    sanitizedIndex !== lastUserIndex) {
+                    continue;
+                }
                 instructions.push(parsed);
             }
         }
@@ -176,7 +192,7 @@ function parseSingleInstruction(instruction) {
         }
         return {
             type: 'stopMessageSet',
-            stopMessageText: text,
+            stopMessageText: resolveStopMessageText(text),
             stopMessageMaxRepeats: maxRepeats
         };
     }

package/dist/router/virtual-router/sticky-session-store.js

@@ -2,6 +2,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import os from 'node:os';
 import { serializeRoutingInstructionState, deserializeRoutingInstructionState } from './routing-instructions.js';
+const pendingWrites = new Map();
 function isPersistentKey(key) {
     if (!key)
         return false;
@@ -54,7 +55,26 @@ export function loadRoutingInstructionStateSync(key) {
         if (!raw) {
             return null;
         }
-        const parsed = JSON.parse(raw);
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            const recovered = recoverPersistedJson(raw);
+            if (!recovered) {
+                return null;
+            }
+            parsed = recovered;
+            try {
+                const payload = parsed && typeof parsed.version === 'number'
+                    ? parsed
+                    : { version: 1, state: parsed };
+                atomicWriteFileSync(filepath, JSON.stringify(payload));
+            }
+            catch {
+                // ignore rewrite failures
+            }
+        }
         const payload = parsed && typeof parsed.version === 'number'
             ? parsed.state
             : parsed;
@@ -79,34 +99,34 @@ export function saveRoutingInstructionStateAsync(key, state) {
     const filepath = path.join(dir, filename);
     // 空状态意味着清除持久化文件
     if (!state) {
-        try {
-            fs.unlink(filepath, () => {
-                // ignore errors (e.g. ENOENT)
-            });
-        }
-        catch {
-            // ignore sync unlink failures
-        }
+        scheduleWrite(filepath, async () => {
+            try {
+                await fs.promises.unlink(filepath);
+            }
+            catch {
+                // ignore unlink errors (e.g. ENOENT)
+            }
+        });
         return;
     }
     const payload = {
         version: 1,
         state: serializeRoutingInstructionState(state)
     };
-    try {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-    catch {
-        // ignore mkdir errors; write below will fail silently
-    }
-    try {
-        fs.writeFile(filepath, JSON.stringify(payload), { encoding: 'utf8' }, () => {
-            // ignore async write errors
-        });
-    }
-    catch {
-        // ignore sync write failures
-    }
+    scheduleWrite(filepath, async () => {
+        try {
+            await fs.promises.mkdir(dir, { recursive: true });
+        }
+        catch {
+            // ignore mkdir errors; write below will fail silently
+        }
+        try {
+            await atomicWriteFile(filepath, JSON.stringify(payload));
+        }
+        catch {
+            // ignore async write failures
+        }
+    });
 }
 export function saveRoutingInstructionStateSync(key, state) {
     if (!isPersistentKey(key)) {
@@ -138,9 +158,101 @@ export function saveRoutingInstructionStateSync(key, state) {
         // ignore mkdir errors
     }
     try {
-        fs.writeFileSync(filepath, JSON.stringify(payload), { encoding: 'utf8' });
+        atomicWriteFileSync(filepath, JSON.stringify(payload));
     }
     catch {
         // ignore sync write failures
     }
 }
+function scheduleWrite(filepath, task) {
+    const previous = pendingWrites.get(filepath) ?? Promise.resolve();
+    const next = previous
+        .then(task)
+        .catch(() => {
+        // swallow errors
+    })
+        .finally(() => {
+        if (pendingWrites.get(filepath) === next) {
+            pendingWrites.delete(filepath);
+        }
+    });
+    pendingWrites.set(filepath, next);
+}
+async function atomicWriteFile(filepath, content) {
+    const tmp = `${filepath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    try {
+        await fs.promises.writeFile(tmp, content, { encoding: 'utf8' });
+        try {
+            await fs.promises.rename(tmp, filepath);
+        }
+        catch {
+            try {
+                await fs.promises.unlink(filepath);
+            }
+            catch {
+                // ignore unlink failures
+            }
+            await fs.promises.rename(tmp, filepath);
+        }
+    }
+    finally {
+        try {
+            await fs.promises.unlink(tmp);
+        }
+        catch {
+            // ignore tmp cleanup failures
+        }
+    }
+}
+function atomicWriteFileSync(filepath, content) {
+    const tmp = `${filepath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    try {
+        fs.writeFileSync(tmp, content, { encoding: 'utf8' });
+        try {
+            fs.renameSync(tmp, filepath);
+        }
+        catch {
+            try {
+                fs.unlinkSync(filepath);
+            }
+            catch {
+                // ignore unlink failures
+            }
+            fs.renameSync(tmp, filepath);
+        }
+    }
+    finally {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch {
+            // ignore tmp cleanup failures
+        }
+    }
+}
+function recoverPersistedJson(raw) {
+    if (typeof raw !== 'string') {
+        return null;
+    }
+    const text = raw.trim();
+    if (!text.startsWith('{')) {
+        return null;
+    }
+    const maxScan = Math.min(text.length, 256 * 1024);
+    for (let i = maxScan - 1; i >= 1; i -= 1) {
+        if (text[i] !== '}') {
+            continue;
+        }
+        const candidate = text.slice(0, i + 1);
+        try {
+            const parsed = JSON.parse(candidate);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            // keep scanning
+        }
+    }
+    return null;
+}

package/dist/router/virtual-router/stop-message-file-resolver.d.ts

@@ -0,0 +1 @@
+export declare function resolveStopMessageText(raw: string): string;

package/dist/router/virtual-router/stop-message-file-resolver.js

@@ -0,0 +1,74 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import os from 'node:os';
+const cache = new Map();
+function resolveRoutecodexUserDir() {
+    const override = process.env.ROUTECODEX_USER_DIR;
+    if (override && override.trim()) {
+        return override.trim();
+    }
+    const home = os.homedir();
+    if (!home) {
+        throw new Error('stopMessage file://: cannot resolve homedir');
+    }
+    return path.join(home, '.routecodex');
+}
+function resolveStopMessageFilePath(raw) {
+    let text = raw.trim();
+    if (!text)
+        return null;
+    if (text.startsWith('<') && text.endsWith('>') && text.length >= 3) {
+        text = text.slice(1, -1).trim();
+    }
+    if (!/^file:\/\//i.test(text)) {
+        return null;
+    }
+    const relRaw = text.slice('file://'.length).trim();
+    if (!relRaw) {
+        throw new Error('stopMessage file://: missing relative path');
+    }
+    if (relRaw.startsWith('/') || relRaw.startsWith('\\') || /^[a-zA-Z]:[\\/]/.test(relRaw)) {
+        throw new Error('stopMessage file://: only supports paths relative to ~/.routecodex');
+    }
+    const normalizedRel = path.posix.normalize(relRaw.replace(/\\/g, '/'));
+    if (!normalizedRel || normalizedRel === '.' || normalizedRel === '..' || normalizedRel.startsWith('../')) {
+        throw new Error('stopMessage file://: invalid relative path');
+    }
+    const base = path.resolve(resolveRoutecodexUserDir());
+    const abs = path.resolve(base, normalizedRel);
+    if (abs !== base && !abs.startsWith(`${base}${path.sep}`)) {
+        throw new Error('stopMessage file://: path escapes ~/.routecodex');
+    }
+    return abs;
+}
+export function resolveStopMessageText(raw) {
+    const abs = resolveStopMessageFilePath(raw);
+    if (!abs) {
+        return raw;
+    }
+    let stat;
+    try {
+        stat = fs.statSync(abs);
+    }
+    catch (err) {
+        const message = err && typeof err.message === 'string' ? err.message : String(err || 'unknown error');
+        throw new Error(`stopMessage file://: cannot stat ${abs}: ${message}`);
+    }
+    if (!stat.isFile()) {
+        throw new Error(`stopMessage file://: not a file: ${abs}`);
+    }
+    const existing = cache.get(abs);
+    if (existing && existing.mtimeMs === stat.mtimeMs && existing.size === stat.size) {
+        return existing.content;
+    }
+    let content;
+    try {
+        content = fs.readFileSync(abs, 'utf8');
+    }
+    catch (err) {
+        const message = err && typeof err.message === 'string' ? err.message : String(err || 'unknown error');
+        throw new Error(`stopMessage file://: cannot read ${abs}: ${message}`);
+    }
+    cache.set(abs, { mtimeMs: stat.mtimeMs, size: stat.size, content });
+    return content;
+}

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

@@ -0,0 +1,15 @@
+import type { RoutingInstructionState } from './routing-instructions.js';
+type StopMessageSubset = Pick<RoutingInstructionState, 'stopMessageSource' | 'stopMessageText' | 'stopMessageMaxRepeats' | 'stopMessageUsed' | 'stopMessageUpdatedAt' | 'stopMessageLastUsedAt'>;
+/**
+ * Decide whether we should overwrite in-memory stopMessage fields with persisted ones.
+ *
+ * Key invariant:
+ * - In-memory state may be ahead of disk because persistence is async (tmp+rename).
+ * - Persisted state must still be able to update usage counters (stop_message_auto).
+ *
+ * Strategy:
+ * - If existing has a newer stopMessageUpdatedAt than persisted → keep existing config.
+ * - Otherwise → adopt persisted fully.
+ */
+export declare function mergeStopMessageFromPersisted(existing: StopMessageSubset, persisted: StopMessageSubset | null): StopMessageSubset;
+export {};

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

@@ -0,0 +1,57 @@
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function updatedAtOf(state) {
+    if (!state)
+        return null;
+    return isFiniteNumber(state.stopMessageUpdatedAt) ? state.stopMessageUpdatedAt : null;
+}
+function lastUsedAtOf(state) {
+    if (!state)
+        return null;
+    return isFiniteNumber(state.stopMessageLastUsedAt) ? state.stopMessageLastUsedAt : null;
+}
+/**
+ * Decide whether we should overwrite in-memory stopMessage fields with persisted ones.
+ *
+ * Key invariant:
+ * - In-memory state may be ahead of disk because persistence is async (tmp+rename).
+ * - Persisted state must still be able to update usage counters (stop_message_auto).
+ *
+ * Strategy:
+ * - If existing has a newer stopMessageUpdatedAt than persisted → keep existing config.
+ * - Otherwise → adopt persisted fully.
+ */
+export function mergeStopMessageFromPersisted(existing, persisted) {
+    if (!persisted) {
+        return { ...existing };
+    }
+    const existingUpdatedAt = updatedAtOf(existing);
+    const persistedUpdatedAt = updatedAtOf(persisted);
+    const existingIsNewer = existingUpdatedAt !== null && (persistedUpdatedAt === null || persistedUpdatedAt < existingUpdatedAt);
+    if (!existingIsNewer) {
+        return {
+            ...existing,
+            stopMessageSource: persisted.stopMessageSource,
+            stopMessageText: persisted.stopMessageText,
+            stopMessageMaxRepeats: persisted.stopMessageMaxRepeats,
+            stopMessageUsed: persisted.stopMessageUsed,
+            stopMessageUpdatedAt: persisted.stopMessageUpdatedAt,
+            stopMessageLastUsedAt: persisted.stopMessageLastUsedAt
+        };
+    }
+    // Keep existing config, but still allow persisted usage counters to move forward if they are newer.
+    const existingLastUsedAt = lastUsedAtOf(existing);
+    const persistedLastUsedAt = lastUsedAtOf(persisted);
+    const countersAreNewer = persistedLastUsedAt !== null &&
+        (existingLastUsedAt === null || persistedLastUsedAt > existingLastUsedAt);
+    return {
+        ...existing,
+        ...(countersAreNewer
+            ? {
+                stopMessageUsed: persisted.stopMessageUsed,
+                stopMessageLastUsedAt: persisted.stopMessageLastUsedAt
+            }
+            : {})
+    };
+}

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

@@ -100,6 +100,41 @@ export interface VirtualRouterClassifierConfig {
 export interface LoadBalancingPolicy {
     strategy: 'round-robin' | 'weighted' | 'sticky';
     weights?: Record<string, number>;
+    /**
+     * AWRR: health-weighted selection.
+     * - Deterministic (no randomness)
+     * - Penalizes recently failing keys but never to zero
+     * - Gradually recovers weights as time passes without errors
+     */
+    healthWeighted?: HealthWeightedLoadBalancingConfig;
+}
+export interface HealthWeightedLoadBalancingConfig {
+    /**
+     * When false, health-weighted logic is disabled and the engine uses legacy behavior.
+     * When true/undefined, the engine uses health-weighted behavior if quotaView provides error metadata.
+     */
+    enabled?: boolean;
+    /**
+     * Weight resolution. Higher values increase granularity but not semantics.
+     */
+    baseWeight?: number;
+    /**
+     * Lower bound for the health multiplier (0 < minMultiplier <= 1).
+     * Example: 0.5 means a key's share won't be penalized below ~50% baseline within the same pool.
+     */
+    minMultiplier?: number;
+    /**
+     * Penalty slope. Larger beta penalizes errors more aggressively.
+     */
+    beta?: number;
+    /**
+     * Half-life for time-based recovery after the last error.
+     */
+    halfLifeMs?: number;
+    /**
+     * When true, a router-level retry attempt (excludedProviderKeys non-empty) prefers the healthiest candidate first.
+     */
+    recoverToBestOnRetry?: boolean;
 }
 export interface ProviderHealthConfig {
     failureThreshold: number;
@@ -136,6 +171,22 @@ export interface VirtualRouterExecCommandGuardConfig {
      */
     policyFile?: string;
 }
+export interface VirtualRouterClockConfig {
+    enabled: boolean;
+    /**
+     * Task retention after dueAt (ms). Tasks older than (dueAt + retentionMs)
+     * are eligible for cleanup.
+     */
+    retentionMs?: number;
+    /**
+     * "Due window" in ms. A task is considered due when now >= dueAt - dueWindowMs.
+     */
+    dueWindowMs?: number;
+    /**
+     * Daemon tick interval (ms). 0 disables background cleanup tick (still cleans on load).
+     */
+    tickMs?: number;
+}
 export interface VirtualRouterConfig {
     routing: RoutingPools;
     providers: Record<string, ProviderProfile>;
@@ -145,6 +196,7 @@ export interface VirtualRouterConfig {
     contextRouting?: VirtualRouterContextRoutingConfig;
     webSearch?: VirtualRouterWebSearchConfig;
     execCommandGuard?: VirtualRouterExecCommandGuardConfig;
+    clock?: VirtualRouterClockConfig;
 }
 export interface VirtualRouterContextRoutingConfig {
     warnRatio: number;
@@ -161,6 +213,7 @@ export interface VirtualRouterBootstrapInput extends Record<string, unknown> {
     contextRouting?: VirtualRouterContextRoutingConfig;
     webSearch?: VirtualRouterWebSearchConfig | Record<string, unknown>;
     execCommandGuard?: VirtualRouterExecCommandGuardConfig | Record<string, unknown>;
+    clock?: VirtualRouterClockConfig | Record<string, unknown>;
 }
 export type ProviderRuntimeMap = Record<string, ProviderRuntimeProfile>;
 export interface VirtualRouterBootstrapResult {
@@ -409,6 +462,23 @@ export interface ProviderQuotaViewEntry {
     inPool: boolean;
     reason?: string;
     priorityTier?: number;
+    /**
+     * Optional soft penalty hint for selection ordering.
+     * - 0 / undefined means no penalty
+     * - higher means less preferred (e.g. recent transient errors)
+     *
+     * This does NOT exclude the provider from the pool; exclusion is controlled by
+     * inPool/cooldownUntil/blacklistUntil.
+     */
+    selectionPenalty?: number;
+    /**
+     * Optional per-providerKey timestamp of the last error. Used for time-decayed recovery.
+     */
+    lastErrorAtMs?: number | null;
+    /**
+     * Optional per-providerKey consecutive error count. Resets to 0 on success.
+     */
+    consecutiveErrorCount?: number;
     cooldownUntil?: number | null;
     blacklistUntil?: number | null;
 }

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

@@ -0,0 +1,7 @@
+import type { ClockConfigSnapshot } from './types.js';
+export declare const CLOCK_CONFIG_DEFAULTS: {
+    readonly retentionMs: number;
+    readonly dueWindowMs: 60000;
+    readonly tickMs: 60000;
+};
+export declare function normalizeClockConfig(raw: unknown): ClockConfigSnapshot | null;

package/dist/servertool/clock/config.js

@@ -0,0 +1,27 @@
+export const CLOCK_CONFIG_DEFAULTS = {
+    retentionMs: 20 * 60_000,
+    dueWindowMs: 60_000,
+    tickMs: 60_000
+};
+export function normalizeClockConfig(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return null;
+    }
+    const record = raw;
+    const enabled = record.enabled === true ||
+        (typeof record.enabled === 'string' && record.enabled.trim().toLowerCase() === 'true') ||
+        (typeof record.enabled === 'number' && record.enabled === 1);
+    if (!enabled) {
+        return null;
+    }
+    const retentionMs = typeof record.retentionMs === 'number' && Number.isFinite(record.retentionMs) && record.retentionMs >= 0
+        ? Math.floor(record.retentionMs)
+        : CLOCK_CONFIG_DEFAULTS.retentionMs;
+    const dueWindowMs = typeof record.dueWindowMs === 'number' && Number.isFinite(record.dueWindowMs) && record.dueWindowMs >= 0
+        ? Math.floor(record.dueWindowMs)
+        : CLOCK_CONFIG_DEFAULTS.dueWindowMs;
+    const tickMs = typeof record.tickMs === 'number' && Number.isFinite(record.tickMs) && record.tickMs >= 0
+        ? Math.floor(record.tickMs)
+        : CLOCK_CONFIG_DEFAULTS.tickMs;
+    return { enabled: true, retentionMs, dueWindowMs, tickMs };
+}

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

@@ -0,0 +1,3 @@
+import type { ClockConfigSnapshot } from './types.js';
+export declare function startClockDaemonIfNeeded(config: ClockConfigSnapshot): Promise<void>;
+export declare function stopClockDaemonForTests(): Promise<void>;