@triflux/core 10.1.0 → 10.25.1

package/hub/routing-snapshot.mjs

@@ -0,0 +1,261 @@
+// hub/routing-snapshot.mjs
+//
+// PRD: .omx/plans/prd-dynamic-routing-engine.md
+//
+// Phase 0 — pure read-only context projector. Wraps HUD providers and the
+// AccountBroker public snapshot into a single deterministic snapshot that
+// `evaluateDynamicRoute(request, snapshot, policy)` consumes.
+//
+// Phase 0 contract:
+//   - no callers yet (dormant). Only `evaluateDynamicRoute()` is meant to read this.
+//   - lazy import of HUD providers + broker so this module imports cleanly even
+//     when those surfaces are absent in tests.
+//   - never mutates upstream state — strictly read-only.
+//   - all output fields are derivable from `publicSnapshot()` / HUD redacted API,
+//     so writing the resulting snapshot to disk does not leak credentials.
+
+const CLAUDE_HUD_MODULE = "../hud/providers/claude.mjs";
+const CODEX_HUD_MODULE = "../hud/providers/codex.mjs";
+const BROKER_MODULE = "./account-broker.mjs";
+
+async function loadHudClaude() {
+  try {
+    return await import(CLAUDE_HUD_MODULE);
+  } catch {
+    return null;
+  }
+}
+
+async function loadHudCodex() {
+  try {
+    return await import(CODEX_HUD_MODULE);
+  } catch {
+    return null;
+  }
+}
+
+async function loadBroker() {
+  try {
+    const mod = await import(BROKER_MODULE);
+    return mod.broker ?? mod.default ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function normalizeClaudeUsage(raw, now) {
+  if (!raw || typeof raw !== "object") return null;
+  const data = raw.data ?? raw;
+  if (!data) return null;
+  return {
+    fiveHourPercent: numericOrNull(data.fiveHourPercent),
+    weeklyPercent: numericOrNull(data.weeklyPercent),
+    fiveHourResetsAt: toEpoch(data.fiveHourResetsAt),
+    weeklyResetsAt: toEpoch(data.weeklyResetsAt),
+    observedAt: toEpoch(data.observedAt) ?? now,
+    isStale: Boolean(raw.isStale ?? data.isStale),
+    source: data.source ?? "hud/providers/claude.mjs",
+  };
+}
+
+function normalizeCodexUsage(raw, now) {
+  if (!raw || typeof raw !== "object") return null;
+  const buckets = raw.buckets ?? raw.data?.buckets ?? raw;
+  if (!buckets || typeof buckets !== "object") return null;
+  const entries = Object.entries(buckets);
+  if (entries.length === 0) return null;
+  const out = {};
+  for (const [id, bucket] of entries) {
+    if (!bucket || typeof bucket !== "object") continue;
+    out[id] = {
+      primary: normalizeCodexBucketLeg(bucket.primary),
+      secondary: normalizeCodexBucketLeg(bucket.secondary),
+    };
+  }
+  return {
+    buckets: out,
+    observedAt: toEpoch(raw.observedAt) ?? now,
+    isStale: Boolean(raw.shouldRefresh === false ? false : raw.isStale),
+    source: raw.source ?? "hud/providers/codex.mjs",
+  };
+}
+
+function normalizeCodexBucketLeg(leg) {
+  if (!leg || typeof leg !== "object") return null;
+  return {
+    usedPercent: numericOrNull(leg.used_percent ?? leg.usedPercent),
+    resetsAt: toEpoch(leg.resets_at ?? leg.resetsAt),
+  };
+}
+
+function normalizeBrokerSnapshot(raw) {
+  if (!Array.isArray(raw)) return null;
+  const grouped = { codex: [], claude: [], gemini: [] };
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object") continue;
+    const provider = entry.provider;
+    if (!grouped[provider]) continue;
+    grouped[provider].push({
+      id: entry.id,
+      tier: entry.tier ?? "unknown",
+      busy: Boolean(entry.busy),
+      cooldownUntil: toEpoch(entry.cooldownUntil),
+      lastUsedAt: toEpoch(entry.lastUsedAt),
+      remainingMs: numericOrNull(entry.remainingMs),
+      circuitState: entry.circuitState ?? "closed",
+      failureCount: numericOrNull(entry.failureCount) ?? 0,
+      expiresAt: toEpoch(entry.expiresAt),
+      drainAfter: toEpoch(entry.drainAfter),
+    });
+  }
+  return grouped;
+}
+
+function numericOrNull(v) {
+  if (v === null || v === undefined) return null;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : null;
+}
+
+function toEpoch(v) {
+  if (v === null || v === undefined) return null;
+  if (typeof v === "number") return Number.isFinite(v) ? v : null;
+  const parsed = Date.parse(v);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+
+export async function buildRoutingSnapshot({
+  forceRefresh = false,
+  now = Date.now(),
+} = {}) {
+  const [hudClaude, hudCodex, broker] = await Promise.all([
+    loadHudClaude(),
+    loadHudCodex(),
+    loadBroker(),
+  ]);
+
+  let claude = null;
+  if (hudClaude?.readClaudeUsageSnapshot) {
+    try {
+      claude = normalizeClaudeUsage(
+        hudClaude.readClaudeUsageSnapshot({ forceRefresh }),
+        now,
+      );
+    } catch (err) {
+      claude = {
+        error: String(err?.message ?? err),
+        observedAt: now,
+        isStale: true,
+      };
+    }
+  }
+
+  let codex = null;
+  if (hudCodex?.readCodexRateLimitSnapshot) {
+    try {
+      codex = normalizeCodexUsage(
+        hudCodex.readCodexRateLimitSnapshot({ forceRefresh }),
+        now,
+      );
+    } catch (err) {
+      codex = {
+        error: String(err?.message ?? err),
+        observedAt: now,
+        isStale: true,
+      };
+    }
+  }
+
+  let brokerState = null;
+  if (broker?.publicSnapshot) {
+    try {
+      brokerState = normalizeBrokerSnapshot(broker.publicSnapshot());
+    } catch (err) {
+      brokerState = { error: String(err?.message ?? err) };
+    }
+  }
+
+  return {
+    schemaVersion: 1,
+    observedAt: now,
+    claude,
+    codex,
+    broker: brokerState,
+  };
+}
+
+// Phase 1 — in-process snapshot cache.
+// 의도: caller (Phase 1+ conductor / swarm-hypervisor) 가 spawn loop 에서
+// 매번 HUD/broker IO 를 트리거하지 않도록 정해진 TTL 안에서 같은 snapshot
+// 을 재사용한다. cache 는 모듈-local 이라 process 단위 (테스트 격리 위해
+// `resetSnapshotCache()` 노출).
+
+const DEFAULT_CACHE_TTL_MS = 900_000; // policy freshness max 와 정합
+
+let _cache = null; // { snapshot, fetchedAt }
+
+export function resetSnapshotCache() {
+  _cache = null;
+}
+
+/**
+ * Cached snapshot shortcut. cache TTL 안이면 재사용, 아니면 새로 빌드.
+ *
+ * @param {{
+ *   forceRefresh?: boolean,        // true 면 cache 무시하고 새로 빌드
+ *   maxAgeMs?: number,             // override cache TTL (default 900_000)
+ *   now?: number,                  // pure-fn: caller 가 epoch 주입 (default Date.now())
+ *   builder?: function,            // 테스트용 builder 주입 (default buildRoutingSnapshot)
+ * }} [opts]
+ * @returns {Promise<object>}
+ */
+export async function getDefaultSnapshot(opts = {}) {
+  const now = typeof opts.now === "number" ? opts.now : Date.now();
+  const maxAgeMs =
+    typeof opts.maxAgeMs === "number" ? opts.maxAgeMs : DEFAULT_CACHE_TTL_MS;
+  const builder = opts.builder || buildRoutingSnapshot;
+  const forceRefresh = Boolean(opts.forceRefresh);
+
+  if (!forceRefresh && _cache && now - _cache.fetchedAt < maxAgeMs) {
+    return _cache.snapshot;
+  }
+
+  const snapshot = await builder({ forceRefresh, now });
+  _cache = { snapshot, fetchedAt: now };
+  return snapshot;
+}
+
+/**
+ * Synchronous cache shortcut. cache TTL 안에 fresh snapshot이 있으면 즉시 반환,
+ * 아니면 null. caller (sync hot path — e.g. conductor.spawnSession) 가 broker.lease
+ * atomic 인변량을 깨지 않고 dynamic routing decision 을 sync 로 평가할 수 있도록 한다.
+ * builder 호출(IO)은 하지 않는다 — cache miss 면 caller 가 fallback decision 사용.
+ *
+ * @param {{
+ *   maxAgeMs?: number,             // override cache TTL (default 900_000)
+ *   now?: number,                  // pure-fn: caller 가 epoch 주입 (default Date.now())
+ * }} [opts]
+ * @returns {object|null} cache fresh이면 snapshot, 아니면 null
+ */
+export function tryGetCachedSnapshot(opts = {}) {
+  const now = typeof opts.now === "number" ? opts.now : Date.now();
+  const maxAgeMs =
+    typeof opts.maxAgeMs === "number" ? opts.maxAgeMs : DEFAULT_CACHE_TTL_MS;
+  if (_cache && now - _cache.fetchedAt < maxAgeMs) {
+    return _cache.snapshot;
+  }
+  return null;
+}
+
+// Test helpers — pure normalizers exposed so unit tests can build snapshots
+// from mock provider responses without running real HUD I/O.
+export const __internal__ = {
+  normalizeClaudeUsage,
+  normalizeCodexUsage,
+  normalizeBrokerSnapshot,
+  // Phase 1 cache 테스트 helpers
+  getCacheStateForTest: () => (_cache ? { ..._cache } : null),
+  setCacheForTest: (state) => {
+    _cache = state ? { ...state } : null;
+  },
+};

package/hub/session-fingerprint.mjs

@@ -1,21 +1,21 @@
-import { createHash } from 'node:crypto';
+import { createHash } from "node:crypto";
 
-import { normalizePath } from './platform.mjs';
-import { withRetry } from './workers/worker-utils.mjs';
+import { normalizePath } from "./platform.mjs";
+import { withRetry } from "./workers/worker-utils.mjs";
 
 const ADAPTIVE_FINGERPRINT_VERSION = 1;
-const DEFAULT_SCOPE = 'default';
-const META_PREFIX = 'adaptive_fingerprint:';
+const DEFAULT_SCOPE = "default";
+const META_PREFIX = "adaptive_fingerprint:";
 const DEFAULT_RETRY_OPTIONS = Object.freeze({
   maxAttempts: 3,
   baseDelayMs: 50,
   maxDelayMs: 250,
 });
 const TIME_WINDOWS = Object.freeze([
-  { name: 'overnight', start: 0, end: 5 },
-  { name: 'morning', start: 6, end: 11 },
-  { name: 'afternoon', start: 12, end: 17 },
-  { name: 'evening', start: 18, end: 23 },
+  { name: "overnight", start: 0, end: 5 },
+  { name: "morning", start: 6, end: 11 },
+  { name: "afternoon", start: 12, end: 17 },
+  { name: "evening", start: 18, end: 23 },
 ]);
 const MEMORY_FINGERPRINT_CACHE = new WeakMap();
 
@@ -30,8 +30,8 @@ function toIsoTimestamp(value = Date.now()) {
 
 function toTimestamp(value) {
   if (value instanceof Date) return value.getTime();
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value === 'string') {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
     const parsed = Date.parse(value);
     return Number.isFinite(parsed) ? parsed : null;
   }
@@ -39,9 +39,21 @@ function toTimestamp(value) {
 }
 
 function normalizeRetryOptions(options = {}) {
-  const maxAttempts = Math.max(1, Number(options.maxAttempts ?? DEFAULT_RETRY_OPTIONS.maxAttempts) || DEFAULT_RETRY_OPTIONS.maxAttempts);
-  const baseDelayMs = Math.max(0, Number(options.baseDelayMs ?? DEFAULT_RETRY_OPTIONS.baseDelayMs) || DEFAULT_RETRY_OPTIONS.baseDelayMs);
-  const maxDelayMs = Math.max(baseDelayMs, Number(options.maxDelayMs ?? DEFAULT_RETRY_OPTIONS.maxDelayMs) || DEFAULT_RETRY_OPTIONS.maxDelayMs);
+  const maxAttempts = Math.max(
+    1,
+    Number(options.maxAttempts ?? DEFAULT_RETRY_OPTIONS.maxAttempts) ||
+      DEFAULT_RETRY_OPTIONS.maxAttempts,
+  );
+  const baseDelayMs = Math.max(
+    0,
+    Number(options.baseDelayMs ?? DEFAULT_RETRY_OPTIONS.baseDelayMs) ||
+      DEFAULT_RETRY_OPTIONS.baseDelayMs,
+  );
+  const maxDelayMs = Math.max(
+    baseDelayMs,
+    Number(options.maxDelayMs ?? DEFAULT_RETRY_OPTIONS.maxDelayMs) ||
+      DEFAULT_RETRY_OPTIONS.maxDelayMs,
+  );
   return { maxAttempts, baseDelayMs, maxDelayMs };
 }
 
@@ -55,21 +67,23 @@ function metaKey(scope) {
 }
 
 function hashValue(value) {
-  const hash = createHash('sha256');
+  const hash = createHash("sha256");
   hash.update(JSON.stringify(value));
-  return `sha256:${hash.digest('hex')}`;
+  return `sha256:${hash.digest("hex")}`;
 }
 
 function normalizeContextPath(value) {
-  const normalized = normalizePath(String(value ?? ''));
-  return normalized.replace(/\/+/gu, '/').replace(/\/+$/u, '') || '/';
+  const normalized = normalizePath(String(value ?? ""));
+  return normalized.replace(/\/+/gu, "/").replace(/\/+$/u, "") || "/";
 }
 
 function toRelativePath(targetPath, cwd) {
   if (!cwd) return targetPath;
   const base = normalizeContextPath(cwd);
-  if (targetPath === base) return '.';
-  return targetPath.startsWith(`${base}/`) ? targetPath.slice(base.length + 1) : targetPath;
+  if (targetPath === base) return ".";
+  return targetPath.startsWith(`${base}/`)
+    ? targetPath.slice(base.length + 1)
+    : targetPath;
 }
 
 function toUniqueList(values) {
@@ -84,29 +98,49 @@ function toUniqueList(values) {
 }
 
 function collectRawPathCandidates(context = {}) {
-  const direct = [context.file_path, context.filePath, context.path, context.target_path, context.targetPath];
+  const direct = [
+    context.file_path,
+    context.filePath,
+    context.path,
+    context.target_path,
+    context.targetPath,
+  ];
   const fromArrays = [context.files, context.paths, context.targets]
     .filter(Array.isArray)
     .flat()
-    .map((entry) => (typeof entry === 'string' ? entry : entry?.path));
-  return [...direct, ...fromArrays].filter((entry) => typeof entry === 'string' && entry.trim().length > 0);
+    .map((entry) => (typeof entry === "string" ? entry : entry?.path));
+  return [...direct, ...fromArrays].filter(
+    (entry) => typeof entry === "string" && entry.trim().length > 0,
+  );
 }
 
 function collectPathPattern(context = {}) {
   const normalized = toUniqueList(
     collectRawPathCandidates(context)
       .map((entry) => normalizeContextPath(entry))
-      .map((entry) => toRelativePath(entry, context.cwd || context.project_root || context.projectRoot)),
+      .map((entry) =>
+        toRelativePath(
+          entry,
+          context.cwd || context.project_root || context.projectRoot,
+        ),
+      ),
   ).sort();
 
   const primaryPath = normalized[0] ?? null;
   const extensions = normalized
-    .map((entry) => entry.split('/').pop() || '')
-    .map((entry) => (entry.includes('.') ? entry.slice(entry.lastIndexOf('.')).toLowerCase() : 'none'));
-  const extensionCounts = extensions.reduce((acc, ext) => ({
-    ...acc,
-    [ext]: (acc[ext] || 0) + 1,
-  }), {});
+    .map((entry) => entry.split("/").pop() || "")
+    .map((entry) =>
+      entry.includes(".")
+        ? entry.slice(entry.lastIndexOf(".")).toLowerCase()
+        : "none",
+    );
+  const extensionCounts = extensions.reduce(
+    (acc, ext) => ({
+      ...acc,
+      [ext]: (acc[ext] || 0) + 1,
+    }),
+    {},
+  );
 
   return {
     count: normalized.length,
@@ -118,17 +152,24 @@ function collectPathPattern(context = {}) {
 }
 
 function normalizeWorkType(value) {
-  const text = String(value ?? '').trim().toLowerCase();
+  const text = String(value ?? "")
+    .trim()
+    .toLowerCase();
   if (!text) {
-    return { raw: null, normalized: 'general' };
+    return { raw: null, normalized: "general" };
   }
-  const normalized = text.replace(/\s+/gu, '-').replace(/[^a-z0-9-]/gu, '') || 'general';
+  const normalized =
+    text.replace(/\s+/gu, "-").replace(/[^a-z0-9-]/gu, "") || "general";
   return { raw: value, normalized };
 }
 
 function collectActivityTimestamps(context = {}, now = Date.now) {
-  const nowValue = typeof now === 'function' ? now() : now;
-  const fromList = [context.activity_timestamps, context.activityTimestamps, context.timestamps]
+  const nowValue = typeof now === "function" ? now() : now;
+  const fromList = [
+    context.activity_timestamps,
+    context.activityTimestamps,
+    context.timestamps,
+  ]
     .filter(Array.isArray)
     .flat()
     .map(toTimestamp)
@@ -136,17 +177,24 @@ function collectActivityTimestamps(context = {}, now = Date.now) {
   const singles = [context.timestamp, context.started_at, context.startedAt]
     .map(toTimestamp)
     .filter((entry) => entry != null);
-  return fromList.length || singles.length ? [...fromList, ...singles] : [Number(nowValue)];
+  return fromList.length || singles.length
+    ? [...fromList, ...singles]
+    : [Number(nowValue)];
 }
 
 function classifyHour(hour) {
   const safeHour = Number.isFinite(Number(hour)) ? Number(hour) : 0;
-  const matched = TIME_WINDOWS.find((window) => safeHour >= window.start && safeHour <= window.end);
-  return matched?.name || 'overnight';
+  const matched = TIME_WINDOWS.find(
+    (window) => safeHour >= window.start && safeHour <= window.end,
+  );
+  return matched?.name || "overnight";
 }
 
 function buildWindowHistogram(timestamps = []) {
-  const histogram = TIME_WINDOWS.reduce((acc, window) => ({ ...acc, [window.name]: 0 }), {});
+  const histogram = TIME_WINDOWS.reduce(
+    (acc, window) => ({ ...acc, [window.name]: 0 }),
+    {},
+  );
   for (const timestamp of timestamps) {
     const bucket = classifyHour(new Date(timestamp).getHours());
     histogram[bucket] = (histogram[bucket] || 0) + 1;
@@ -155,14 +203,16 @@ function buildWindowHistogram(timestamps = []) {
 }
 
 function dominantWindow(histogram) {
-  const sorted = Object.entries(histogram)
-    .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]));
-  return sorted[0]?.[0] || 'overnight';
+  const sorted = Object.entries(histogram).sort(
+    (left, right) => right[1] - left[1] || left[0].localeCompare(right[0]),
+  );
+  return sorted[0]?.[0] || "overnight";
 }
 
 function resolveTimezoneName(context = {}) {
-  const fromContext = typeof context.timezone === 'string' ? context.timezone.trim() : '';
-  const fromIntl = Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+  const fromContext =
+    typeof context.timezone === "string" ? context.timezone.trim() : "";
+  const fromIntl = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
   return fromContext || fromIntl;
 }
 
@@ -199,11 +249,13 @@ function getMemoryStoreMap(store) {
 
 function readFingerprintFromStore(store, scope) {
   if (!store) return null;
-  if (typeof store.loadAdaptiveFingerprint === 'function') {
+  if (typeof store.loadAdaptiveFingerprint === "function") {
     return store.loadAdaptiveFingerprint(scope);
   }
   if (store.db?.prepare) {
-    const row = store.db.prepare('SELECT value FROM _meta WHERE key = ?').get(metaKey(scope));
+    const row = store.db
+      .prepare("SELECT value FROM _meta WHERE key = ?")
+      .get(metaKey(scope));
     return row?.value ? JSON.parse(row.value) : null;
   }
   return clone(getMemoryStoreMap(store).get(normalizeScope(scope)) || null);
@@ -211,11 +263,12 @@ function readFingerprintFromStore(store, scope) {
 
 function writeFingerprintToStore(store, scope, record) {
   if (!store) return clone(record);
-  if (typeof store.saveAdaptiveFingerprint === 'function') {
+  if (typeof store.saveAdaptiveFingerprint === "function") {
     return store.saveAdaptiveFingerprint(scope, clone(record));
   }
   if (store.db?.prepare) {
-    store.db.prepare('INSERT OR REPLACE INTO _meta (key, value) VALUES (?, ?)')
+    store.db
+      .prepare("INSERT OR REPLACE INTO _meta (key, value) VALUES (?, ?)")
       .run(metaKey(scope), JSON.stringify(record));
     return clone(record);
   }
@@ -225,7 +278,7 @@ function writeFingerprintToStore(store, scope, record) {
 
 function buildHealthSnapshot(base, patch = {}) {
   return {
-    state: patch.state || base.state || 'healthy',
+    state: patch.state || base.state || "healthy",
     retry: { ...base.retry },
     last_success_at: patch.last_success_at ?? base.last_success_at ?? null,
     last_failure_at: patch.last_failure_at ?? base.last_failure_at ?? null,
@@ -235,7 +288,7 @@ function buildHealthSnapshot(base, patch = {}) {
 
 function createInitialHealth(retryOptions) {
   return {
-    state: 'healthy',
+    state: "healthy",
     retry: { ...retryOptions },
     last_success_at: null,
     last_failure_at: null,
@@ -244,7 +297,7 @@ function createInitialHealth(retryOptions) {
 }
 
 function resolveNowValue(now) {
-  return typeof now === 'function' ? now() : now;
+  return typeof now === "function" ? now() : now;
 }
 
 function mergeFingerprintSnapshot(previous, computed, scope) {
@@ -258,7 +311,7 @@ function mergeFingerprintSnapshot(previous, computed, scope) {
 
 function markHealthyHealth(base, now) {
   return buildHealthSnapshot(base, {
-    state: 'healthy',
+    state: "healthy",
     last_success_at: toIsoTimestamp(resolveNowValue(now)),
     last_error: null,
   });
@@ -266,11 +319,11 @@ function markHealthyHealth(base, now) {
 
 function markDegradedHealth(base, now, error) {
   return buildHealthSnapshot(base, {
-    state: 'degraded',
+    state: "degraded",
     last_failure_at: toIsoTimestamp(resolveNowValue(now)),
     last_error: {
-      name: error?.name || 'Error',
-      message: error?.message || 'unknown adaptive fingerprint error',
+      name: error?.name || "Error",
+      message: error?.message || "unknown adaptive fingerprint error",
     },
   });
 }
@@ -279,7 +332,9 @@ export function buildAdaptiveFingerprint(sessionContext = {}, options = {}) {
   const now = options.now ?? Date.now;
   const capturedAt = toIsoTimestamp(resolveNowValue(now));
   const pathPattern = collectPathPattern(sessionContext);
-  const workType = normalizeWorkType(sessionContext.work_type ?? sessionContext.workType);
+  const workType = normalizeWorkType(
+    sessionContext.work_type ?? sessionContext.workType,
+  );
   const timezonePattern = collectTimezonePattern(sessionContext, now);
   const fingerprintId = computeFingerprintSignature({
     path_pattern: pathPattern,
@@ -303,10 +358,18 @@ export async function loadAdaptiveFingerprint(store, scope = DEFAULT_SCOPE) {
   return clone(loaded);
 }
 
-export async function saveAdaptiveFingerprint(store, scope, fingerprint, options = {}) {
+export async function saveAdaptiveFingerprint(
+  store,
+  scope,
+  fingerprint,
+  options = {},
+) {
   const retryOptions = normalizeRetryOptions(options.retryOptions);
   const normalizedScope = normalizeScope(scope);
-  const write = async () => Promise.resolve(writeFingerprintToStore(store, normalizedScope, fingerprint));
+  const write = async () =>
+    Promise.resolve(
+      writeFingerprintToStore(store, normalizedScope, fingerprint),
+    );
   const saved = await withRetry(write, { ...retryOptions });
   return clone(saved);
 }
@@ -324,7 +387,9 @@ export function createAdaptiveFingerprintService(options = {}) {
     const merged = mergeFingerprintSnapshot(previous, computed, scope);
 
     try {
-      const saved = await saveAdaptiveFingerprint(store, scope, merged, { retryOptions });
+      const saved = await saveAdaptiveFingerprint(store, scope, merged, {
+        retryOptions,
+      });
       health = markHealthyHealth(health, now);
       return saved;
     } catch (error) {
@@ -343,10 +408,11 @@ export function createAdaptiveFingerprintService(options = {}) {
 
   return Object.freeze({
     captureFingerprint: capture,
-    computeFingerprint: (sessionContext = {}) => buildAdaptiveFingerprint(sessionContext, { now }),
+    computeFingerprint: (sessionContext = {}) =>
+      buildAdaptiveFingerprint(sessionContext, { now }),
     loadFingerprint: read,
     getHealth,
   });
 }
 
-export default createAdaptiveFingerprintService;
+export default createAdaptiveFingerprintService;