@triflux/core 10.50.2 → 10.52.0

package/hub/routing-snapshot.mjs

@@ -1,261 +0,0 @@
-// 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,418 +0,0 @@
-import { createHash } from "node:crypto";
-
-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_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 },
-]);
-const MEMORY_FINGERPRINT_CACHE = new WeakMap();
-
-function clone(value) {
-  return value == null ? value : JSON.parse(JSON.stringify(value));
-}
-
-function toIsoTimestamp(value = Date.now()) {
-  const time = Number.isFinite(Number(value)) ? Number(value) : Date.now();
-  return new Date(time).toISOString();
-}
-
-function toTimestamp(value) {
-  if (value instanceof Date) return value.getTime();
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (typeof value === "string") {
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? parsed : null;
-  }
-  return null;
-}
-
-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,
-  );
-  return { maxAttempts, baseDelayMs, maxDelayMs };
-}
-
-function normalizeScope(scope) {
-  const text = String(scope ?? DEFAULT_SCOPE).trim();
-  return text || DEFAULT_SCOPE;
-}
-
-function metaKey(scope) {
-  return `${META_PREFIX}${normalizeScope(scope)}`;
-}
-
-function hashValue(value) {
-  const hash = createHash("sha256");
-  hash.update(JSON.stringify(value));
-  return `sha256:${hash.digest("hex")}`;
-}
-
-function normalizeContextPath(value) {
-  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;
-}
-
-function toUniqueList(values) {
-  const seen = new Set();
-  const next = [];
-  for (const value of values) {
-    if (!value || seen.has(value)) continue;
-    seen.add(value);
-    next.push(value);
-  }
-  return next;
-}
-
-function collectRawPathCandidates(context = {}) {
-  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,
-  );
-}
-
-function collectPathPattern(context = {}) {
-  const normalized = toUniqueList(
-    collectRawPathCandidates(context)
-      .map((entry) => normalizeContextPath(entry))
-      .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,
-    }),
-    {},
-  );
-
-  return {
-    count: normalized.length,
-    primary_path: primaryPath,
-    sample_paths: normalized.slice(0, 5),
-    extension_counts: extensionCounts,
-    checksum: hashValue(normalized),
-  };
-}
-
-function normalizeWorkType(value) {
-  const text = String(value ?? "")
-    .trim()
-    .toLowerCase();
-  if (!text) {
-    return { raw: null, normalized: "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,
-  ]
-    .filter(Array.isArray)
-    .flat()
-    .map(toTimestamp)
-    .filter((entry) => entry != null);
-  const singles = [context.timestamp, context.started_at, context.startedAt]
-    .map(toTimestamp)
-    .filter((entry) => entry != null);
-  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";
-}
-
-function buildWindowHistogram(timestamps = []) {
-  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;
-  }
-  return histogram;
-}
-
-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";
-}
-
-function resolveTimezoneName(context = {}) {
-  const fromContext =
-    typeof context.timezone === "string" ? context.timezone.trim() : "";
-  const fromIntl = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
-  return fromContext || fromIntl;
-}
-
-function collectTimezonePattern(context = {}, now = Date.now) {
-  const timestamps = collectActivityTimestamps(context, now);
-  const firstTimestamp = timestamps[0] ?? Date.now();
-  const histogram = buildWindowHistogram(timestamps);
-  return {
-    timezone: resolveTimezoneName(context),
-    offset_minutes: -new Date(firstTimestamp).getTimezoneOffset(),
-    sample_count: timestamps.length,
-    window_histogram: histogram,
-    dominant_window: dominantWindow(histogram),
-  };
-}
-
-function computeFingerprintSignature(input) {
-  const source = {
-    file_checksum: input.path_pattern.checksum,
-    work_type: input.work_type.normalized,
-    timezone: input.timezone_pattern.timezone,
-    dominant_window: input.timezone_pattern.dominant_window,
-  };
-  return hashValue(source);
-}
-
-function getMemoryStoreMap(store) {
-  const current = MEMORY_FINGERPRINT_CACHE.get(store);
-  if (current) return current;
-  const next = new Map();
-  MEMORY_FINGERPRINT_CACHE.set(store, next);
-  return next;
-}
-
-function readFingerprintFromStore(store, scope) {
-  if (!store) return null;
-  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));
-    return row?.value ? JSON.parse(row.value) : null;
-  }
-  return clone(getMemoryStoreMap(store).get(normalizeScope(scope)) || null);
-}
-
-function writeFingerprintToStore(store, scope, record) {
-  if (!store) return clone(record);
-  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 (?, ?)")
-      .run(metaKey(scope), JSON.stringify(record));
-    return clone(record);
-  }
-  getMemoryStoreMap(store).set(normalizeScope(scope), clone(record));
-  return clone(record);
-}
-
-function buildHealthSnapshot(base, patch = {}) {
-  return {
-    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,
-    last_error: patch.last_error ?? base.last_error ?? null,
-  };
-}
-
-function createInitialHealth(retryOptions) {
-  return {
-    state: "healthy",
-    retry: { ...retryOptions },
-    last_success_at: null,
-    last_failure_at: null,
-    last_error: null,
-  };
-}
-
-function resolveNowValue(now) {
-  return typeof now === "function" ? now() : now;
-}
-
-function mergeFingerprintSnapshot(previous, computed, scope) {
-  return {
-    ...computed,
-    scope,
-    observation_count: (previous?.observation_count || 0) + 1,
-    first_captured_at: previous?.first_captured_at || computed.captured_at,
-  };
-}
-
-function markHealthyHealth(base, now) {
-  return buildHealthSnapshot(base, {
-    state: "healthy",
-    last_success_at: toIsoTimestamp(resolveNowValue(now)),
-    last_error: null,
-  });
-}
-
-function markDegradedHealth(base, now, error) {
-  return buildHealthSnapshot(base, {
-    state: "degraded",
-    last_failure_at: toIsoTimestamp(resolveNowValue(now)),
-    last_error: {
-      name: error?.name || "Error",
-      message: error?.message || "unknown adaptive fingerprint error",
-    },
-  });
-}
-
-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 timezonePattern = collectTimezonePattern(sessionContext, now);
-  const fingerprintId = computeFingerprintSignature({
-    path_pattern: pathPattern,
-    work_type: workType,
-    timezone_pattern: timezonePattern,
-  });
-
-  return {
-    version: ADAPTIVE_FINGERPRINT_VERSION,
-    captured_at: capturedAt,
-    scope: normalizeScope(sessionContext.scope),
-    fingerprint_id: fingerprintId,
-    path_pattern: pathPattern,
-    work_type: workType,
-    timezone_pattern: timezonePattern,
-  };
-}
-
-export async function loadAdaptiveFingerprint(store, scope = DEFAULT_SCOPE) {
-  const loaded = await Promise.resolve(readFingerprintFromStore(store, scope));
-  return clone(loaded);
-}
-
-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 saved = await withRetry(write, { ...retryOptions });
-  return clone(saved);
-}
-
-export function createAdaptiveFingerprintService(options = {}) {
-  const store = options.store ?? null;
-  const retryOptions = normalizeRetryOptions(options.retryOptions);
-  const now = options.now ?? Date.now;
-  let health = createInitialHealth(retryOptions);
-
-  async function capture(sessionContext = {}) {
-    const computed = buildAdaptiveFingerprint(sessionContext, { now });
-    const scope = normalizeScope(sessionContext.scope ?? computed.scope);
-    const previous = await loadAdaptiveFingerprint(store, scope);
-    const merged = mergeFingerprintSnapshot(previous, computed, scope);
-
-    try {
-      const saved = await saveAdaptiveFingerprint(store, scope, merged, {
-        retryOptions,
-      });
-      health = markHealthyHealth(health, now);
-      return saved;
-    } catch (error) {
-      health = markDegradedHealth(health, now, error);
-      throw error;
-    }
-  }
-
-  async function read(scope = DEFAULT_SCOPE) {
-    return loadAdaptiveFingerprint(store, scope);
-  }
-
-  function getHealth() {
-    return clone(health);
-  }
-
-  return Object.freeze({
-    captureFingerprint: capture,
-    computeFingerprint: (sessionContext = {}) =>
-      buildAdaptiveFingerprint(sessionContext, { now }),
-    loadFingerprint: read,
-    getHealth,
-  });
-}
-
-export default createAdaptiveFingerprintService;