evolcore 0.0.1 → 0.0.2

package/dist/stats/role-budget.js

@@ -0,0 +1,168 @@
+import { isManagementRole } from '../config/builtin-roles.js';
+import { getRoleDefinition } from '../config/roles.js';
+import { formatPeerKey } from '../core/relation/peer-identity.js';
+import { getDbPath, openReadonlyDb } from './db.js';
+const DEFAULT_COST_BASIS = 'gateway';
+const DEFAULT_SCOPE = 'subject';
+const DEFAULT_RESET_MODE = 'daily';
+const DEFAULT_CURRENCY = 'CNY';
+const RESET_MODES = new Set(['never', 'daily', 'weekly', 'monthly']);
+const CURRENCIES = new Set(['CNY', 'USD']);
+export function formatUsageSubjectKey(channelType, chatType, channelId, peerId) {
+    const subjectId = (peerId || (chatType === 'private' ? channelId : '') || channelId || '').trim();
+    return subjectId ? formatPeerKey(channelType, subjectId) : '';
+}
+export function getRoleBudgetStatus(evolcoreHome, req) {
+    const role = req.role || 'none';
+    const usageSubjectKey = formatUsageSubjectKey(req.channelType, req.chatType, req.channelId, req.peerId);
+    const disabled = (reason, overrides = {}) => ({
+        role,
+        enabled: false,
+        scope: DEFAULT_SCOPE,
+        cost_basis: DEFAULT_COST_BASIS,
+        reset_mode: DEFAULT_RESET_MODE,
+        currency: DEFAULT_CURRENCY,
+        period_start_ts: null,
+        usage_subject_key: usageSubjectKey,
+        limit_amount: -1,
+        used_amount: 0,
+        remaining_amount: -1,
+        pct_used: 0,
+        hard_blocked: false,
+        reason,
+        ...overrides,
+    });
+    if (!req.selfAid || !role || role === 'none')
+        return disabled('no_role');
+    if (isManagementRole(role))
+        return disabled('management_role');
+    const limits = resolveRoleUsageLimits(role, req.selfAid);
+    if (!limits)
+        return disabled('no_limits');
+    const limitAmount = normalizeAmount(limits.limitAmount);
+    const currency = normalizeCurrency(limits.currency);
+    const resetMode = normalizeResetMode(limits.resetMode);
+    const periodStartTs = periodStartTsFor(resetMode);
+    const costBasis = limits.costBasis ?? DEFAULT_COST_BASIS;
+    const scope = limits.scope ?? DEFAULT_SCOPE;
+    const enabled = limits.enabled !== false && limitAmount !== undefined;
+    if (!enabled) {
+        return disabled('disabled', {
+            scope,
+            cost_basis: costBasis,
+            reset_mode: resetMode,
+            currency,
+            period_start_ts: periodStartTs,
+        });
+    }
+    const usage = queryPeriodUsage(evolcoreHome, {
+        selfAid: req.selfAid,
+        role,
+        scope,
+        costBasis,
+        usageSubjectKey,
+        fromTs: periodStartTs,
+    });
+    const usedAmount = currency === 'USD' ? usage.usd : usage.cny;
+    const pct = percentage(usedAmount, limitAmount);
+    return {
+        role,
+        enabled: true,
+        scope,
+        cost_basis: costBasis,
+        reset_mode: resetMode,
+        currency,
+        period_start_ts: periodStartTs,
+        usage_subject_key: usageSubjectKey,
+        limit_amount: limitAmount,
+        used_amount: usedAmount,
+        remaining_amount: Math.max(0, limitAmount - usedAmount),
+        pct_used: pct,
+        hard_blocked: pct >= 100,
+    };
+}
+function resolveRoleUsageLimits(role, selfAid) {
+    const roleDef = getRoleDefinition(role, selfAid);
+    if (!roleDef)
+        return null;
+    if (roleDef.usageLimits && (role === 'member' || role === 'visitor' || hasExplicitUsageLimit(roleDef.usageLimits))) {
+        return roleDef.usageLimits;
+    }
+    if (role !== 'member' && role !== 'visitor') {
+        return getRoleDefinition('member', selfAid)?.usageLimits ?? null;
+    }
+    return null;
+}
+function hasExplicitUsageLimit(limits) {
+    return limits.enabled === false
+        || limits.resetMode != null
+        || limits.currency != null
+        || limits.limitAmount != null
+        || limits.costBasis != null
+        || limits.scope != null;
+}
+function normalizeAmount(value) {
+    if (value == null)
+        return undefined;
+    return Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function percentage(used, limit) {
+    if (limit <= 0)
+        return 100;
+    return (used / limit) * 100;
+}
+function normalizeResetMode(value) {
+    return value && RESET_MODES.has(value) ? value : DEFAULT_RESET_MODE;
+}
+function normalizeCurrency(value) {
+    return value && CURRENCIES.has(value) ? value : DEFAULT_CURRENCY;
+}
+function queryPeriodUsage(evolcoreHome, opts) {
+    const db = openReadonlyDb(getDbPath(evolcoreHome));
+    if (!db)
+        return { cny: 0, usd: 0 };
+    try {
+        const columns = db.prepare(`PRAGMA table_info(usage_events)`).all();
+        const names = new Set(columns.map(c => c.name));
+        if (!names.has('role') || !names.has('usage_subject_key'))
+            return { cny: 0, usd: 0 };
+        const prefix = opts.costBasis === 'official' ? 'cost_official' : 'cost_gateway';
+        const where = ['agent_aid = ?', 'role = ?'];
+        const params = [opts.selfAid, opts.role];
+        if (opts.fromTs !== null) {
+            where.unshift('ts >= ?');
+            params.unshift(opts.fromTs);
+        }
+        if (opts.scope === 'subject') {
+            where.push('usage_subject_key = ?');
+            params.push(opts.usageSubjectKey);
+        }
+        const row = db.prepare(`
+      SELECT
+        COALESCE(SUM(${prefix}_cny), 0) AS cny,
+        COALESCE(SUM(${prefix}_usd), 0) AS usd
+      FROM usage_events
+      WHERE ${where.join(' AND ')}
+    `).get(...params);
+        return {
+            cny: Number(row?.cny ?? 0),
+            usd: Number(row?.usd ?? 0),
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+function periodStartTsFor(resetMode) {
+    if (resetMode === 'never')
+        return null;
+    const now = new Date();
+    if (resetMode === 'weekly') {
+        const daysSinceMonday = (now.getDay() + 6) % 7;
+        return new Date(now.getFullYear(), now.getMonth(), now.getDate() - daysSinceMonday).getTime();
+    }
+    if (resetMode === 'monthly') {
+        return new Date(now.getFullYear(), now.getMonth(), 1).getTime();
+    }
+    return new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+}

package/dist/stats/writer.js

@@ -0,0 +1,151 @@
+/**
+ * writer.ts — 写入 usage_events 和 context_breakdown。
+ */
+import { getDb, resetStatsDb } from './db.js';
+import { resolvePrices } from './price-resolver.js';
+import { logger } from '../utils/logger.js';
+export function insertUsageEvent(evolcoreHome, event, gatewayPricing) {
+    const db = getDb(evolcoreHome);
+    // 写入时计算费用（官方价格 + 网关价格）。即使 DB 不可用也返回价格对，供调用方合入状态回执。
+    const prices = resolvePrices(evolcoreHome, event, gatewayPricing);
+    if (!db)
+        return prices;
+    try {
+        writeUsageEvent(db, event, prices);
+    }
+    catch (e) {
+        // 写入失败不影响主流程
+        try {
+            db.exec('ROLLBACK');
+        }
+        catch { }
+        if (isSchemaMismatchError(e)) {
+            logger.warn(`[StatsWriter] insertUsageEvent schema mismatch, retrying after DB migration: ${e}`);
+            const retryDb = resetStatsDb(evolcoreHome);
+            if (retryDb) {
+                try {
+                    writeUsageEvent(retryDb, event, prices);
+                    return prices;
+                }
+                catch (retryError) {
+                    try {
+                        retryDb.exec('ROLLBACK');
+                    }
+                    catch { }
+                    logger.error(`[StatsWriter] insertUsageEvent retry failed: ${retryError}`);
+                }
+            }
+        }
+        else {
+            logger.warn(`[StatsWriter] insertUsageEvent failed: ${e}`);
+        }
+    }
+    return prices;
+}
+function isSchemaMismatchError(error) {
+    return /no column|no such column|has no column/i.test(String(error));
+}
+function writeUsageEvent(db, event, prices) {
+    // 明细 INSERT + rollup UPSERT 包进同一事务：进程在两者间崩溃也不会让 rollup 与明细漂移。
+    db.exec('BEGIN');
+    db.prepare(`
+    INSERT INTO usage_events
+      (ts, agent_aid, peer_key, usage_subject_key, role, peer_type, session_id, model, billing_fn,
+       input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens,
+       cache_hit_tokens, cache_miss_tokens, image_tokens, total_context_tokens,
+       turns, duration_ms, context_window_pct,
+       cost_official_usd, cost_official_cny, cost_gateway_usd, cost_gateway_cny)
+    VALUES
+      (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(event.ts, event.agent_aid, event.peer_key, event.usage_subject_key ?? event.peer_key ?? '', event.role ?? '', event.peer_type ?? null, event.session_id ?? null, event.model, event.billing_fn, event.input_tokens, event.output_tokens, event.cache_creation_tokens, event.cache_read_tokens, event.cache_hit_tokens ?? null, event.cache_miss_tokens ?? null, event.image_tokens ?? null, event.total_context_tokens ?? null, event.turns, event.duration_ms ?? null, event.context_window_pct ?? null, prices.official?.usd ?? null, prices.official?.cny ?? null, prices.gateway?.usd ?? null, prices.gateway?.cny ?? null);
+    // 写时增量：累加到日级预聚合表（grain 与 db.ts rebuildDailyRollup 一致）。
+    db.prepare(`
+    INSERT INTO usage_daily
+      (day, agent_aid, peer_key, peer_type, session_id, model, billing_fn,
+       input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens,
+       cache_hit_tokens, cache_miss_tokens, image_tokens, total_context_tokens,
+       turns, calls,
+       cost_official_usd, cost_official_cny, cost_gateway_usd, cost_gateway_cny)
+    VALUES
+      (strftime('%Y-%m-%d', ?/1000, 'unixepoch', 'localtime'),
+       ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?)
+    ON CONFLICT(day, agent_aid, peer_key, session_id, model, billing_fn) DO UPDATE SET
+      peer_type             = excluded.peer_type,
+      input_tokens          = input_tokens          + excluded.input_tokens,
+      output_tokens         = output_tokens         + excluded.output_tokens,
+      cache_creation_tokens = cache_creation_tokens + excluded.cache_creation_tokens,
+      cache_read_tokens     = cache_read_tokens     + excluded.cache_read_tokens,
+      cache_hit_tokens      = cache_hit_tokens      + excluded.cache_hit_tokens,
+      cache_miss_tokens     = cache_miss_tokens     + excluded.cache_miss_tokens,
+      image_tokens          = image_tokens          + excluded.image_tokens,
+      total_context_tokens  = total_context_tokens  + excluded.total_context_tokens,
+      turns                 = turns                 + excluded.turns,
+      calls                 = calls                 + 1,
+      cost_official_usd     = COALESCE(cost_official_usd, 0) + COALESCE(excluded.cost_official_usd, 0),
+      cost_official_cny     = COALESCE(cost_official_cny, 0) + COALESCE(excluded.cost_official_cny, 0),
+      cost_gateway_usd      = COALESCE(cost_gateway_usd, 0)  + COALESCE(excluded.cost_gateway_usd, 0),
+      cost_gateway_cny      = COALESCE(cost_gateway_cny, 0)  + COALESCE(excluded.cost_gateway_cny, 0)
+  `).run(event.ts, event.agent_aid, event.peer_key, event.peer_type ?? '', event.session_id ?? '', event.model, event.billing_fn, event.input_tokens, event.output_tokens, event.cache_creation_tokens, event.cache_read_tokens, event.cache_hit_tokens ?? 0, event.cache_miss_tokens ?? 0, event.image_tokens ?? 0, event.total_context_tokens ?? 0, event.turns, prices.official?.usd ?? null, prices.official?.cny ?? null, prices.gateway?.usd ?? null, prices.gateway?.cny ?? null);
+    db.exec('COMMIT');
+}
+export function insertContextBreakdown(evolcoreHome, bd) {
+    const db = getDb(evolcoreHome);
+    if (!db)
+        return;
+    try {
+        db.prepare(`
+      INSERT INTO context_breakdown
+        (ts, agent_aid, session_id, turn_count, model, max_tokens,
+         system_prompt, system_tools, mcp_tools, custom_agents,
+         memory_files, skills, messages, free_space, total_estimated)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(bd.ts, bd.agent_aid, bd.session_id, bd.turn_count, bd.model, bd.max_tokens, bd.system_prompt ?? null, bd.system_tools ?? null, bd.mcp_tools ?? null, bd.custom_agents ?? null, bd.memory_files ?? null, bd.skills ?? null, bd.messages ?? null, bd.free_space ?? null, bd.total_estimated ?? null);
+    }
+    catch (e) {
+        import('../utils/logger.js').then(({ logger }) => logger.warn(`[StatsWriter] insertContextBreakdown failed: ${e}`));
+    }
+}
+export function insertMessageEvent(evolcoreHome, event) {
+    const db = getDb(evolcoreHome);
+    if (!db)
+        return;
+    try {
+        db.prepare(`
+      INSERT INTO message_events
+        (ts, agent_aid, peer_key, direction, msg_type, bytes, encrypted, chatmode)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(event.ts, event.agent_aid, event.peer_key, event.direction, event.msg_type ?? null, event.bytes, event.encrypted ? 1 : 0, event.chatmode ?? null);
+    }
+    catch (e) {
+        import('../utils/logger.js').then(({ logger }) => logger.warn(`[StatsWriter] insertMessageEvent failed: ${e}`));
+    }
+}
+/** 批量写入大模型调用明细。单事务；失败不影响主流程。 */
+export function insertModelCalls(evolcoreHome, rows) {
+    if (!rows.length)
+        return;
+    const db = getDb(evolcoreHome);
+    if (!db)
+        return;
+    try {
+        const stmt = db.prepare(`
+      INSERT INTO model_calls
+        (ts, task_id, session_id, agent_session_id, agent_aid, peer_key, call_index, model,
+         request_id, message_id, input_tokens, output_tokens, cache_creation_tokens,
+         cache_read_tokens, context_tokens, max_tokens, auto_compact_tokens, degraded)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        db.exec('BEGIN');
+        for (const r of rows) {
+            stmt.run(r.ts, r.task_id, r.session_id ?? null, r.agent_session_id ?? null, r.agent_aid, r.peer_key, r.call_index, r.model, r.request_id ?? null, r.message_id ?? null, r.input_tokens, r.output_tokens, r.cache_creation_tokens, r.cache_read_tokens, r.context_tokens ?? null, r.max_tokens ?? null, r.auto_compact_tokens ?? null, r.degraded);
+        }
+        db.exec('COMMIT');
+    }
+    catch (e) {
+        try {
+            db.exec('ROLLBACK');
+        }
+        catch { }
+        import('../utils/logger.js').then(({ logger }) => logger.warn(`[StatsWriter] insertModelCalls failed: ${e}`));
+    }
+}

package/dist/trigger/anomaly-store.js

@@ -0,0 +1,258 @@
+import { logger } from '../utils/logger.js';
+const ENTRY_TTL_MS = 2 * 60 * 60 * 1000;
+const MAX_RUN_ENTRIES = 2_048;
+const MAX_DISTINCT_ANOMALIES_PER_RUN = 100;
+const entries = new Map();
+/**
+ * Returns true when the occurrence is represented in the run audit, either
+ * directly, by same-class aggregation, or by the explicit overflow entry.
+ */
+export function recordTriggerExecutionAnomaly(runId, anomaly) {
+    if (!runId)
+        return false;
+    const now = Date.now();
+    pruneExpired(now);
+    let entry = entries.get(runId);
+    if (!entry) {
+        evictOldestIfFull();
+        entry = { anomalies: [], expiresAt: now + ENTRY_TTL_MS };
+    }
+    else {
+        entries.delete(runId);
+        entry.expiresAt = now + ENTRY_TTL_MS;
+    }
+    appendAnomaly(entry, anomaly);
+    entries.set(runId, entry);
+    return true;
+}
+export function drainTriggerExecutionAnomalies(runId) {
+    pruneExpired(Date.now());
+    const entry = entries.get(runId);
+    if (!entry)
+        return [];
+    entries.delete(runId);
+    return entry.overflow
+        ? [...entry.anomalies, entry.overflow]
+        : entry.anomalies;
+}
+/** Reconciles overlapping anomaly views of the same execution attempt. */
+export function mergeTriggerExecutionAnomalies(...groups) {
+    const classes = new Map();
+    let overflow;
+    for (const group of groups) {
+        const source = accumulateTriggerExecutionAnomalies(group);
+        for (const anomaly of source) {
+            if (anomaly.code === 'anomaly_overflow') {
+                const occurrences = overflowOccurrences(anomaly);
+                overflow ??= {
+                    maxSourceOccurrences: 0,
+                    firstOccurredAt: anomaly.occurredAt,
+                    lastOccurredAt: anomalyLastOccurredAt(anomaly),
+                };
+                overflow.maxSourceOccurrences = Math.max(overflow.maxSourceOccurrences, occurrences);
+                overflow.firstOccurredAt = Math.min(overflow.firstOccurredAt, anomaly.occurredAt);
+                overflow.lastOccurredAt = Math.max(overflow.lastOccurredAt, anomalyLastOccurredAt(anomaly));
+                continue;
+            }
+            const key = anomalyClassKey(anomaly);
+            const occurrences = anomalyOccurrences(anomaly);
+            let state = classes.get(key);
+            if (!state) {
+                state = {
+                    representative: cloneAggregate(anomaly),
+                    firstOccurredAt: anomaly.occurredAt,
+                    lastOccurredAt: anomalyLastOccurredAt(anomaly),
+                    maxSourceOccurrences: occurrences,
+                    requestIds: new Set(),
+                    missingRequestId: false,
+                };
+                classes.set(key, state);
+            }
+            state.maxSourceOccurrences = Math.max(state.maxSourceOccurrences, occurrences);
+            state.firstOccurredAt = Math.min(state.firstOccurredAt, anomaly.occurredAt);
+            state.lastOccurredAt = Math.max(state.lastOccurredAt, anomalyLastOccurredAt(anomaly));
+            if (anomaly.requestId)
+                state.requestIds.add(anomaly.requestId);
+            else
+                state.missingRequestId = true;
+        }
+    }
+    const entry = { anomalies: [], expiresAt: 0 };
+    for (const state of classes.values()) {
+        const occurrences = state.maxSourceOccurrences;
+        const anomaly = cloneAggregate(state.representative);
+        anomaly.occurredAt = state.firstOccurredAt;
+        if (occurrences > 1)
+            anomaly.occurrences = occurrences;
+        else
+            delete anomaly.occurrences;
+        if (state.lastOccurredAt > state.firstOccurredAt || occurrences > 1) {
+            anomaly.lastOccurredAt = state.lastOccurredAt;
+        }
+        else {
+            delete anomaly.lastOccurredAt;
+        }
+        if (state.missingRequestId || state.requestIds.size !== 1)
+            delete anomaly.requestId;
+        else
+            anomaly.requestId = state.requestIds.values().next().value;
+        appendAnomaly(entry, anomaly);
+    }
+    if (overflow) {
+        entry.overflow = mergeOverlappingOverflow(entry.overflow, {
+            code: 'anomaly_overflow',
+            severity: 'warning',
+            phase: 'execution',
+            occurredAt: overflow.firstOccurredAt,
+            lastOccurredAt: overflow.lastOccurredAt,
+            occurrences: overflow.maxSourceOccurrences,
+            overflowCount: overflow.maxSourceOccurrences,
+            summary: `execution anomaly audit capacity exceeded (${MAX_DISTINCT_ANOMALIES_PER_RUN} distinct classes retained)`,
+            effect: 'audit_truncated',
+        });
+    }
+    return entry.overflow
+        ? [...entry.anomalies, entry.overflow]
+        : entry.anomalies;
+}
+/** Accumulates anomaly groups known to represent disjoint attempts or phases. */
+export function accumulateTriggerExecutionAnomalies(...groups) {
+    const entry = { anomalies: [], expiresAt: 0 };
+    for (const group of groups) {
+        for (const anomaly of group ?? [])
+            appendAnomaly(entry, anomaly);
+    }
+    return entry.overflow
+        ? [...entry.anomalies, entry.overflow]
+        : entry.anomalies;
+}
+function appendAnomaly(entry, anomaly) {
+    if (anomaly.code === 'anomaly_overflow') {
+        entry.overflow = mergeOverflow(entry.overflow, anomaly);
+        return;
+    }
+    const key = anomalyClassKey(anomaly);
+    const existing = entry.anomalies.find(candidate => anomalyClassKey(candidate) === key);
+    if (existing) {
+        mergeSameClass(existing, anomaly);
+        return;
+    }
+    if (entry.anomalies.length < MAX_DISTINCT_ANOMALIES_PER_RUN) {
+        entry.anomalies.push(cloneAggregate(anomaly));
+        return;
+    }
+    entry.overflow = mergeOverflow(entry.overflow, anomaly);
+}
+function cloneAggregate(anomaly) {
+    const { occurrences: _occurrences, lastOccurredAt: _lastOccurredAt, overflowCount: _overflowCount, ...base } = anomaly;
+    const occurrences = anomalyOccurrences(anomaly);
+    const firstOccurredAt = anomaly.occurredAt;
+    const lastOccurredAt = anomalyLastOccurredAt(anomaly);
+    return {
+        ...base,
+        occurredAt: firstOccurredAt,
+        ...(occurrences > 1 ? { occurrences } : {}),
+        ...(lastOccurredAt > firstOccurredAt || occurrences > 1 ? { lastOccurredAt } : {}),
+    };
+}
+function mergeSameClass(existing, incoming) {
+    const existingOccurrences = anomalyOccurrences(existing);
+    const incomingOccurrences = anomalyOccurrences(incoming);
+    const firstOccurredAt = Math.min(existing.occurredAt, incoming.occurredAt);
+    const lastOccurredAt = Math.max(anomalyLastOccurredAt(existing), anomalyLastOccurredAt(incoming));
+    existing.occurredAt = firstOccurredAt;
+    existing.occurrences = existingOccurrences + incomingOccurrences;
+    existing.lastOccurredAt = lastOccurredAt;
+    if (existing.requestId !== incoming.requestId)
+        delete existing.requestId;
+}
+function mergeOverflow(existing, incoming) {
+    const incomingOccurrences = overflowOccurrences(incoming);
+    const incomingFirst = incoming.occurredAt;
+    const incomingLast = anomalyLastOccurredAt(incoming);
+    if (!existing) {
+        return {
+            code: 'anomaly_overflow',
+            severity: 'warning',
+            phase: 'execution',
+            occurredAt: incomingFirst,
+            occurrences: incomingOccurrences,
+            overflowCount: incomingOccurrences,
+            ...(incomingLast > incomingFirst ? { lastOccurredAt: incomingLast } : {}),
+            summary: `execution anomaly audit capacity exceeded (${MAX_DISTINCT_ANOMALIES_PER_RUN} distinct classes retained)`,
+            effect: 'audit_truncated',
+        };
+    }
+    const existingOccurrences = overflowOccurrences(existing);
+    const firstOccurredAt = Math.min(existing.occurredAt, incomingFirst);
+    const lastOccurredAt = Math.max(anomalyLastOccurredAt(existing), incomingLast);
+    return {
+        ...existing,
+        occurredAt: firstOccurredAt,
+        lastOccurredAt,
+        occurrences: existingOccurrences + incomingOccurrences,
+        overflowCount: existingOccurrences + incomingOccurrences,
+    };
+}
+function mergeOverlappingOverflow(existing, incoming) {
+    if (!existing)
+        return mergeOverflow(undefined, incoming);
+    const occurrences = Math.max(overflowOccurrences(existing), overflowOccurrences(incoming));
+    const occurredAt = Math.min(existing.occurredAt, incoming.occurredAt);
+    const lastOccurredAt = Math.max(anomalyLastOccurredAt(existing), anomalyLastOccurredAt(incoming));
+    return {
+        ...existing,
+        occurredAt,
+        lastOccurredAt,
+        occurrences,
+        overflowCount: occurrences,
+    };
+}
+function overflowOccurrences(anomaly) {
+    return Number.isSafeInteger(anomaly.overflowCount) && (anomaly.overflowCount ?? 0) > 0
+        ? anomaly.overflowCount
+        : anomalyOccurrences(anomaly);
+}
+function anomalyOccurrences(anomaly) {
+    return Number.isSafeInteger(anomaly.occurrences) && (anomaly.occurrences ?? 0) > 0
+        ? anomaly.occurrences
+        : 1;
+}
+function anomalyLastOccurredAt(anomaly) {
+    return typeof anomaly.lastOccurredAt === 'number'
+        ? Math.max(anomaly.occurredAt, anomaly.lastOccurredAt)
+        : anomaly.occurredAt;
+}
+function pruneExpired(now) {
+    for (const [runId, entry] of entries) {
+        if (entry.expiresAt > now)
+            continue;
+        logger.warn(`[Trigger] undrained execution anomalies expired: run=${runId} occurrences=${entryOccurrences(entry)}`);
+        entries.delete(runId);
+    }
+}
+function evictOldestIfFull() {
+    while (entries.size >= MAX_RUN_ENTRIES) {
+        const oldest = entries.keys().next().value;
+        if (!oldest)
+            return;
+        const entry = entries.get(oldest);
+        logger.warn(`[Trigger] execution anomaly store evicted oldest run: run=${oldest} occurrences=${entry ? entryOccurrences(entry) : 0}`);
+        entries.delete(oldest);
+    }
+}
+function entryOccurrences(entry) {
+    return entry.anomalies.reduce((sum, anomaly) => sum + anomalyOccurrences(anomaly), 0)
+        + (entry.overflow ? overflowOccurrences(entry.overflow) : 0);
+}
+function anomalyClassKey(anomaly) {
+    return JSON.stringify([
+        anomaly.code,
+        anomaly.severity,
+        anomaly.phase,
+        anomaly.toolName,
+        anomaly.policy,
+        anomaly.summary,
+        anomaly.effect,
+    ]);
+}