mister-wolf 2.11.0 → 2.13.0

package/dist/app/use-cases/build-analytics.js

@@ -1,10 +1,9 @@
-import { DEFAULT_PATTERN_THRESHOLD } from '../../adapters/fs/session-metrics-log.js';
+import { DEFAULT_PATTERN_THRESHOLD, mergeRunEntries, silentRuleIds, } from '../../adapters/fs/session-metrics-log.js';
+import { median } from '../../domain/tool-economy.js';
 import { UNCATEGORIZED_ERROR_CLASS } from '../../domain/error-class.js';
 import { runCostUsd } from '../../domain/pricing.js';
-import { silentRuleIds } from './learn-decay.js';
-import { mergeRunEntries } from './run-source.js';
 import { mondayOf } from './generate-insights.js';
-import { extractVote } from './tally-council-votes.js';
+import { toolStats } from './tool-stats.js';
 export const DEFAULT_LIFECYCLE_THRESHOLDS = { newDays: 14, workhorseUses: 3 };
 /** Override из config (analytics.thresholds) поверх дефолтов (D7). */
 export function resolveLifecycleThresholds(override) {
@@ -491,6 +490,155 @@ function buildAcceptance(signals, routerLog, now, signalLogMalformedLines = 0) {
         dataQuality: { malformedLines: signalLogMalformedLines },
     };
 }
+/**
+ * P110: толерантный парсер .wolf/metrics/skill-invocations.jsonl (прецедент readJsonl):
+ * битая строка → malformedLines++, не бросает; agent отсутствует → null.
+ * Валидная строка = JSON-объект с непустой строкой в `skill`.
+ */
+export function parseSkillInvocations(text) {
+    const rows = [];
+    let malformedLines = 0;
+    for (const line of text.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed === '')
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            const rec = typeof parsed === 'object' && parsed !== null ? parsed : null;
+            if (rec === null || typeof rec.skill !== 'string' || rec.skill === '') {
+                malformedLines += 1;
+                continue;
+            }
+            rows.push({
+                ts: typeof rec.ts === 'string' ? rec.ts : '',
+                skill: rec.skill,
+                agent: typeof rec.agent === 'string' && rec.agent !== '' ? rec.agent : null,
+            });
+        }
+        catch {
+            malformedLines += 1;
+        }
+    }
+    return { rows, malformedLines };
+}
+/** P110: панель доставки — чистая агрегация signals + router.log + skill-invocations.
+ * applied-join (только CLI-канал, session_id !== null): доставка (S, name N, ts T)
+ * считается applied, если в той же сессии S есть get(memory_id=N) или
+ * search(memory_ids ∋ N) с ts >= T. Пустые входы → пустые массивы/null-метрики. */
+function buildDelivery(signals, routerLog, skillInvocations) {
+    // индекс get/search-вызовов по сессии (CLI-канал): tsMs + множество затронутых id
+    const callsBySession = new Map();
+    for (const s of signals) {
+        if (s.event !== 'mcp_call' || s.session_id === null)
+            continue;
+        if (s.tool_name !== 'get' && s.tool_name !== 'search')
+            continue;
+        let ids;
+        if (s.tool_name === 'get') {
+            const mid = s.detail?.memory_id;
+            if (typeof mid !== 'string' || mid === '')
+                continue;
+            ids = new Set([mid]);
+        }
+        else {
+            const mids = s.detail?.memory_ids;
+            ids = new Set((Array.isArray(mids) ? mids : []).filter((v) => typeof v === 'string' && v !== ''));
+        }
+        if (ids.size === 0)
+            continue;
+        const tsMs = Date.parse(s.ts);
+        if (Number.isNaN(tsMs))
+            continue;
+        const arr = callsBySession.get(s.session_id) ?? [];
+        arr.push({ tsMs, ids });
+        callsBySession.set(s.session_id, arr);
+    }
+    const byName = new Map();
+    let bytesSum = 0;
+    let bytesCount = 0;
+    for (const s of signals) {
+        if (s.event !== 'delivery')
+            continue;
+        const name = s.detail?.name;
+        if (typeof name !== 'string' || name === '')
+            continue;
+        const acc = byName.get(name) ?? { deliveries: 0, applied: 0 };
+        acc.deliveries += 1;
+        const b = finiteNumber(s.detail?.injection_bytes);
+        if (b !== null) {
+            bytesSum += b;
+            bytesCount += 1;
+        }
+        // ponytail: O(D×G) на логах ~10^4 — достаточно; индекс по id, если вырастет
+        if (s.session_id !== null) {
+            const tMs = Date.parse(s.ts);
+            const calls = callsBySession.get(s.session_id);
+            if (!Number.isNaN(tMs) && calls !== undefined) {
+                for (const c of calls) {
+                    if (c.tsMs >= tMs && c.ids.has(name)) {
+                        acc.applied += 1;
+                        break;
+                    }
+                }
+            }
+        }
+        byName.set(name, acc);
+    }
+    const topDelivered = [...byName.entries()]
+        .map(([name, a]) => ({
+        name,
+        deliveries: a.deliveries,
+        applied: a.applied,
+        appliedPct: a.deliveries > 0 ? (a.applied / a.deliveries) * 100 : null,
+    }))
+        .sort((a, b) => b.deliveries - a.deliveries || a.name.localeCompare(b.name));
+    const underApplied = topDelivered
+        .filter((r) => r.deliveries >= 10 && r.appliedPct !== null && r.appliedPct < 10)
+        .map((r) => r.name);
+    const routerAcc = new Map();
+    let routerBytesSum = 0;
+    let routerBytesCount = 0;
+    const msValues = [];
+    for (const row of routerLog?.rows ?? []) {
+        const acc = routerAcc.get(row.agentId) ?? { fallbacks: 0, total: 0 };
+        acc.total += 1;
+        if (row.variant === 'fallback')
+            acc.fallbacks += 1;
+        routerAcc.set(row.agentId, acc);
+        if (row.bytes !== null && row.bytes > 0) {
+            routerBytesSum += row.bytes;
+            routerBytesCount += 1;
+        }
+        if (row.ms !== null)
+            msValues.push(row.ms);
+    }
+    const missRateByAgent = [...routerAcc.entries()]
+        .map(([agent, a]) => ({
+        agent,
+        fallbacks: a.fallbacks,
+        total: a.total,
+        missRatePct: a.total > 0 ? (a.fallbacks / a.total) * 100 : null,
+    }))
+        .sort((a, b) => b.fallbacks - a.fallbacks || a.agent.localeCompare(b.agent));
+    const msSorted = msValues.sort((x, y) => x - y);
+    const skillsAcc = new Map();
+    for (const row of skillInvocations?.rows ?? []) {
+        skillsAcc.set(row.skill, (skillsAcc.get(row.skill) ?? 0) + 1);
+    }
+    return {
+        topDelivered,
+        underApplied,
+        missRateByAgent,
+        avgInjectionBytes: {
+            deliverySignals: bytesCount > 0 ? bytesSum / bytesCount : null,
+            routerLog: routerBytesCount > 0 ? routerBytesSum / routerBytesCount : null,
+        },
+        routerMs: { p50: percentileInterp(msSorted, 50), p90: percentileInterp(msSorted, 90), count: msSorted.length },
+        skills: [...skillsAcc.entries()]
+            .map(([skill, count]) => ({ skill, count }))
+            .sort((a, b) => b.count - a.count || a.skill.localeCompare(b.skill)),
+    };
+}
 /** Coverage D5: scored = task_evaluated (любой verdict), runs = run-сигналы. */
 function buildCoverage(signals) {
     const scored = signals.filter((s) => s.event === 'task_evaluated').length;
@@ -1069,17 +1217,26 @@ function buildReadiness(signals) {
 // ---------------------------------------------------------------------------
 // Use-case
 // ---------------------------------------------------------------------------
+/** Парсер голоса мнения (поле vote → body `VOTE:` → TIMEOUT).
+ * P203: перенесён из удалённого tally-use-case — чтение council-данных живое. */
+function extractVote(op) {
+    const raw = op.vote;
+    if (typeof raw === 'string' && raw.trim())
+        return raw.trim();
+    const m = op.body.match(/^VOTE:\s*(\S+)/m);
+    return m ? m[1] : 'TIMEOUT';
+}
 /** Консилиумы: вопросы/мнения/синтезы из councils-subdir + relations answers/based_on.
  * Чистая агрегация по уже выгруженным объектам; ровно два вызова relations.list
  * (predicate answers и based_on — без N+1 по вопросам). Голоса — extractVote
- * из tally-council-votes (единственный парсер). */
+ * выше (единственный парсер). */
 async function buildCouncils(objects, relations, now, weeks) {
     const byId = new Map(objects.map((o) => [o.id, o]));
     const questions = objects.filter((o) => o.type === 'council-question');
     const opinions = objects.filter((o) => o.type === 'council-opinion');
     const syntheses = objects.filter((o) => o.type === 'synthesis');
     // вопрос → id его мнений; субъект-реляция засчитывается только если это
-    // существующее в store мнение (прецедент tallyCouncilVotes)
+    // существующее в store мнение (парсер council-голосов — локальный, ниже)
     const answersByQuestion = new Map();
     for (const r of await relations.list({ predicate: 'answers' })) {
         const op = byId.get(r.subject);
@@ -1236,6 +1393,7 @@ export async function buildAnalyticsReport(deps, input) {
     const councils = await buildCouncils(allObjects, deps.relations, now, weeks);
     const coordination = buildCoordination(signals, events); // P2 D5
     const campaign = buildCampaignView(signals); // P3 D2
+    const delivery = buildDelivery(signals, input.routerLog, input.skillInvocations); // P110
     const coverage = buildCoverage(signals);
     // D6: unknown-model и pricing-coverage по дедуплицированным run-сигналам
     const runSignals = signals.filter((s) => s.event === 'run');
@@ -1272,6 +1430,7 @@ export async function buildAnalyticsReport(deps, input) {
         councils,
         coordination,
         campaign,
+        delivery,
         // acceptedByAgent (Map, не-JSON) остаётся внутренним — в отчёт идут публичные поля
         acceptance: {
             accepted: acceptance.accepted,
@@ -1288,6 +1447,234 @@ export async function buildAnalyticsReport(deps, input) {
         dataQuality,
     };
 }
+// ---------------------------------------------------------------------------
+// Effectiveness (P221 §6.5: консолидация панели, ранее отдельный use-case-модуль)
+// ---------------------------------------------------------------------------
+/**
+ * E1.2: панель эффективности памяти по пробегу (`analytics --view effectiveness`).
+ * Только агрегация существующих данных (store, relations, event-log, signals,
+ * run-log), без LLM и без выдуманных чисел: мало данных → null → панель печатает n/a.
+ *
+ * Методика шума: docs/planning/memory-audit-2026-08-29.md «пишется-но-не-читается» —
+ * объект шум, если нет ни одной связи (relations) и ни одного события в event-log
+ * кроме memory.added; memory.scan.updated = подтверждение актуальности сканом =
+ * использование. Объекты document-ref — функциональный «индекс документов»
+ * (использование = регистрация/обновление сканом), исключены из метрики шума
+ * и показываются отдельной строкой documents (калибровка 2026-08-30).
+ * Объекты со статусом archived исключены аналогично (из числителя и знаменателя):
+ * архивация — легитимный способ снижения шума; показываются строкой archived.
+ * Пороги статусов — config learning.effectiveness_thresholds.
+ */
+// Локальные копии из learn-decay.ts (P221: новый импорт оттуда запрещён — файл
+// умирает в параллельном потоке C; существующий импорт silentRuleIds остаётся)
+/** Окно молчания правила для rule_utilization-дрейфа [ВА] (§16). */
+const SILENT_RULE_WINDOW_SESSIONS = 30;
+/** Минимум delivery-событий в логе, чтобы судить об утилизации правил [ВА] (§16). */
+const SILENT_RULE_MIN_DELIVERIES = 20;
+/** Пробег = упорядоченные уникальные session_id из run-событий
+ * (порядок первого появления в логе = хронология). */
+function countSessions(signals) {
+    const seen = new Set();
+    const out = [];
+    for (const ev of signals) {
+        if (ev.event !== 'run' || ev.session_id === null)
+            continue;
+        if (!seen.has(ev.session_id)) {
+            seen.add(ev.session_id);
+            out.push(ev.session_id);
+        }
+    }
+    return out;
+}
+export const DEFAULT_EFFECTIVENESS_THRESHOLDS = {
+    noiseOk: 20,
+    noiseWarn: 40,
+    silentOk: 30,
+};
+/** Шум: null → NO_DATA; <noiseOk → OK; <=noiseWarn → WARN; иначе BAD. */
+export function classifyNoise(share, t) {
+    if (share === null)
+        return 'NO_DATA';
+    if (share < t.noiseOk)
+        return 'OK';
+    return share <= t.noiseWarn ? 'WARN' : 'BAD';
+}
+/** Молчащие правила: null → NO_DATA; <silentOk → OK; иначе BAD. */
+export function classifySilent(share, t) {
+    if (share === null)
+        return 'NO_DATA';
+    return share < t.silentOk ? 'OK' : 'BAD';
+}
+/** Override из config поверх дефолтов (E1.2); битые/чужие поля отбрасываются схемой. */
+export function resolveThresholds(override) {
+    return { ...DEFAULT_EFFECTIVENESS_THRESHOLDS, ...override };
+}
+/** M3: агрегация run-сигналов в блок абсолютов; пустые данные → нули/null, не выдумываем. */
+function buildTotals(signals, pricing) {
+    const runs = signals.filter((s) => s.event === 'run');
+    const processFailures = runs.filter((s) => s.outcome !== 'ok').length;
+    const sumWeighted = runs.reduce((sum, s) => sum + (s.weighted ?? 0), 0);
+    let sumTokens = null;
+    const durations = [];
+    let costUsd = null;
+    const byModelMap = new Map();
+    for (const s of runs) {
+        if (typeof s.duration_ms === 'number' && Number.isFinite(s.duration_ms))
+            durations.push(s.duration_ms);
+        if (s.tokens !== undefined && s.tokens !== null) {
+            if (sumTokens === null)
+                sumTokens = { input: 0, output: 0, cache_read: 0 };
+            sumTokens.input += s.tokens.input;
+            sumTokens.output += s.tokens.output;
+            sumTokens.cache_read += s.tokens.cache_read;
+        }
+        const c = runCostUsd(s.tokens, pricing, s.gen_ai.modelID);
+        if (c !== null)
+            costUsd = (costUsd ?? 0) + c;
+        const model = s.gen_ai.modelID ?? 'unknown';
+        const row = byModelMap.get(model) ?? { runs: 0, processFailures: 0, sumWeighted: 0, durations: [], costUsd: null };
+        row.runs += 1;
+        if (s.outcome !== 'ok')
+            row.processFailures += 1;
+        row.sumWeighted += s.weighted ?? 0;
+        if (typeof s.duration_ms === 'number' && Number.isFinite(s.duration_ms))
+            row.durations.push(s.duration_ms);
+        if (c !== null)
+            row.costUsd = (row.costUsd ?? 0) + c;
+        byModelMap.set(model, row);
+    }
+    const avg = (xs) => (xs.length === 0 ? null : xs.reduce((a, b) => a + b, 0) / xs.length);
+    const denom = sumTokens === null ? 0 : sumTokens.input + sumTokens.cache_read;
+    const byModel = [...byModelMap.entries()]
+        .map(([model, row]) => {
+        const completedRuns = row.runs - row.processFailures;
+        return {
+            model,
+            runs: row.runs,
+            processFailures: row.processFailures,
+            sumWeighted: row.sumWeighted,
+            avgDurationMs: avg(row.durations),
+            costUsd: row.costUsd,
+            costPerCompletedRun: row.costUsd === null || completedRuns === 0 ? null : row.costUsd / completedRuns,
+        };
+    })
+        .sort((a, b) => b.runs - a.runs || a.model.localeCompare(b.model));
+    return {
+        runs: runs.length,
+        processFailures,
+        sumWeighted,
+        sumTokens,
+        cacheHitRatio: sumTokens === null || denom === 0 ? null : (sumTokens.cache_read / denom) * 100,
+        avgDurationMs: avg(durations),
+        costUsd,
+        byModel,
+    };
+}
+/**
+ * Пять блоков отчёта из одних портов: чистая агрегация, детерминированная.
+ * Не падает на пустой памяти — все блоки возвращают нули/null.
+ */
+export async function buildEffectivenessReport(deps, input) {
+    // Блок 1 «Правила»: активные + суммы holdout-полей Ф22 по rule/lesson (все статусы)
+    const activeRuleObjects = await deps.store.list({ type: 'rule', status: 'active' });
+    const activeRules = activeRuleObjects.length;
+    let prevented = 0;
+    let checked = 0;
+    let hasHoldoutData = false;
+    for (const type of ['rule', 'lesson']) {
+        for (const o of await deps.store.list({ type })) {
+            const rec = o;
+            const p = finiteNumber(rec.holdout_prevented);
+            const c = finiteNumber(rec.holdout_checked);
+            if (p !== null || c !== null)
+                hasHoldoutData = true;
+            prevented += p ?? 0;
+            checked += c ?? 0;
+        }
+    }
+    // Блок 2 «Инструменты»: реестр + экономика (переиспользуем toolStats —
+    // P1 D4: сигнальный источник + legacy run-log, insufficient от analyzeEconomy)
+    const { tools: toolRows, economy } = await toolStats({ store: deps.store }, { signals: input.signals, runLogText: input.runLogText });
+    // Блок 3 «Доставка→срабатывание»: сигнальный лог + окно молчания из learn-decay
+    const deliveries = input.signals.filter((s) => s.event === 'delivery');
+    const triggered = new Set();
+    for (const ev of deliveries) {
+        if (typeof ev.detail?.name === 'string')
+            triggered.add(ev.detail.name);
+    }
+    const silent = silentRuleIds(input.signals);
+    // то же пре-условие, что внутри silentRuleIds (ранний выход при малом пробеге):
+    // count=0 в этом случае — «не знаем», а не «нет молчащих»
+    const sessions = countSessions(input.signals).length;
+    const enoughDeliveryData = deliveries.length >= SILENT_RULE_MIN_DELIVERIES && sessions > SILENT_RULE_WINDOW_SESSIONS;
+    // silentRuleIds возвращает ВСЕ молчащие delivery-имена (любой тип — call-injection,
+    // lesson и т.д.); делим только на правила и считаем только правила (прецедент:
+    // runDecayPass фильтрует по active rules) — иначе доля могла бы превысить 100%
+    const activeRuleIds = new Set(activeRuleObjects.map((o) => o.id));
+    const silentRules = [...silent.ids].filter((id) => activeRuleIds.has(id)).length;
+    const silentShare = enoughDeliveryData && activeRules > 0 ? (silentRules / activeRules) * 100 : null;
+    // Блок 4 «Шум памяти»: нет связей И нет событий кроме memory.added (event-log).
+    // document-ref — функциональный «индекс документов» (использование = регистрация/
+    // обновление сканом), из метрики шума исключён и из числителя, и из знаменателя
+    // (калибровка 2026-08-30); показывается отдельной строкой documents.
+    // archived — вне метрики и из числителя, и из знаменателя: архивация —
+    // легитимный способ снижения шума (иначе transition, помечающий объект
+    // «использованным», почти не улучшал метрику); показывается строкой archived.
+    // memory.scan.updated = подтверждение актуальности = использование: readIds-фильтр
+    // («любое событие кроме memory.added») засчитывает scan-события автоматически.
+    const allObjects = await deps.store.list();
+    const documents = allObjects.filter((o) => o.type === 'document-ref').length;
+    const archived = allObjects.filter((o) => o.status === 'archived').length;
+    const noiseBase = allObjects.filter((o) => o.type !== 'document-ref' && o.status !== 'archived');
+    const linked = new Set();
+    for (const r of await deps.relations.list()) {
+        linked.add(r.subject);
+        linked.add(r.object);
+    }
+    const readIds = new Set();
+    for (const ev of await deps.log.readAll()) {
+        if (ev.type === 'memory.added')
+            continue;
+        const mid = ev.payload?.memory_id;
+        if (typeof mid === 'string')
+            readIds.add(mid);
+    }
+    const writeOnly = noiseBase.filter((o) => !linked.has(o.id) && !readIds.has(o.id)).length;
+    const noiseShare = noiseBase.length > 0 ? (writeOnly / noiseBase.length) * 100 : null;
+    // Блок 5 «Роутинг»: группировка run-метрик (P1 D4: сигнальный источник + legacy
+    // run-log) по model, медиана weighted (медианы переиспользуем)
+    const weightedByModel = new Map();
+    for (const entry of mergeRunEntries(input.signals, input.runLogText)) {
+        const w = finiteNumber(entry.weighted);
+        if (w === null)
+            continue;
+        const model = typeof entry.model === 'string' && entry.model !== '' ? entry.model : 'unknown';
+        const arr = weightedByModel.get(model) ?? [];
+        arr.push(w);
+        weightedByModel.set(model, arr);
+    }
+    const routing = [...weightedByModel.entries()]
+        .map(([model, values]) => ({ model, tasks: values.length, medianWeighted: median(values) }))
+        .sort((a, b) => b.tasks - a.tasks || a.model.localeCompare(b.model));
+    const noise = { totalObjects: noiseBase.length, writeOnly, share: noiseShare, documents, archived };
+    return {
+        rules: { activeRules, prevented: hasHoldoutData ? prevented : null, checked: hasHoldoutData ? checked : null },
+        tools: { toolCount: toolRows.length, totalUsage: toolRows.reduce((sum, r) => sum + r.usage_count, 0), economy },
+        delivery: {
+            deliveryEvents: deliveries.length,
+            triggeredObjects: triggered.size,
+            activeRules,
+            silentRules,
+            enoughDeliveryData,
+            silentShare,
+        },
+        noise,
+        noiseStatus: classifyNoise(noiseShare, input.thresholds),
+        silentStatus: classifySilent(silentShare, input.thresholds),
+        routing,
+        totals: buildTotals(input.signals, input.pricing),
+    };
+}
 /** Срез отчёта по view-фильтру (§6.2); top ограничивает строки, дефолт 20. */
 export function filterAnalytics(report, filter) {
     const top = filter.top ?? 20;
@@ -1340,6 +1727,12 @@ export function filterAnalytics(report, filter) {
             return { view: 'coordination', coordination: report.coordination };
         case 'campaign':
             return { view: 'campaign', campaign: report.campaign };
+        case 'delivery':
+            // P110: top-срез из фильтра, остальные блоки целиком (JSON-сериализуемые)
+            return {
+                view: 'delivery',
+                delivery: { ...report.delivery, topDelivered: report.delivery.topDelivered.slice(0, top) },
+            };
         case 'acceptance':
             // report.acceptance = AcceptanceStats & AcceptanceView — JSON несёт и D4-поля
             return { view: 'acceptance', acceptance: report.acceptance };