botmux 3.10.0 → 3.23.1

package/dist/services/insight/report.js

@@ -1,1247 +0,0 @@
-import { existsSync, statSync } from 'node:fs';
-import { basename, isAbsolute, relative } from 'node:path';
-import { resolveSessionTranscriptPath } from '../transcript-resolver.js';
-import { isReadPhase, isWritePhase, isInteractiveWaitTool } from './classify.js';
-import { buildSubagentLanes } from './subagent-reader.js';
-import { parseAntigravityInsight } from './antigravity-span-reader.js';
-import { parseClaudeInsight } from './claude-span-reader.js';
-import { parseCodexInsight } from './codex-span-reader.js';
-import { safeErrorMessage, toSafeSpan } from './redact.js';
-import { INSIGHT_PHASES } from './types.js';
-const DEFAULT_MAX_SPANS = 500;
-const DEFAULT_OVERVIEW_LIMIT = 200;
-const MAX_OVERVIEW_LIMIT = 500;
-const DEFAULT_SLOW_THRESHOLD_MS = 60_000;
-const DIAGNOSTIC_TARGET_CAP = 100;
-const SEVERITY_ORDER = { bad: 0, warn: 1, info: 2 };
-const SUPPORTED_CLI_IDS = new Set(['claude-code', 'seed', 'relay', 'aiden', 'codex', 'traex', 'antigravity']);
-// Sized above MAX_OVERVIEW_LIMIT so a single overview pass doesn't evict its own
-// earlier sessions (FIFO thrash), defeating the parse-cache amortization.
-const PARSE_CACHE_MAX = 600;
-const parseCache = new Map();
-export function __resetInsightReportCacheForTest() {
-    parseCache.clear();
-}
-function emptyPhase() {
-    return {
-        research: { count: 0, ms: 0 },
-        edit: { count: 0, ms: 0 },
-        run: { count: 0, ms: 0 },
-        delegate: { count: 0, ms: 0 },
-        discuss: { count: 0, ms: 0 },
-    };
-}
-function emptyAgg() {
-    return {
-        totalSpans: 0,
-        failedSpans: 0,
-        slowSpans: 0,
-        failByTool: {},
-        phase: emptyPhase(),
-        readWriteRatio: null,
-        compactions: 0,
-        subagentCostShare: null,
-    };
-}
-function baseReport(q, detail, parsedAt) {
-    return {
-        sessionId: q.sessionId,
-        cliId: q.cliId ?? 'unknown',
-        status: 'ok',
-        meta: { parsedAt, partial: false, detail },
-        agg: emptyAgg(),
-        suggestions: [],
-        diagnostics: [],
-        recommendations: [],
-        turnDiagnostics: [],
-        turnTimeline: [],
-    };
-}
-function unsupported(q, detail, parsedAt, code) {
-    return {
-        ...baseReport(q, detail, parsedAt),
-        status: code,
-        error: { code, message: safeErrorMessage(code) },
-    };
-}
-function promptUnavailable(q, turnIndex, offset, limit, code) {
-    return {
-        sessionId: q.sessionId,
-        cliId: q.cliId ?? 'unknown',
-        status: code,
-        turnIndex,
-        offset,
-        limit,
-        total: 0,
-        hasMore: false,
-        error: { code, message: safeErrorMessage(code) },
-    };
-}
-function conversationUnavailable(q, offset, limit, code) {
-    return {
-        sessionId: q.sessionId,
-        cliId: q.cliId ?? 'unknown',
-        status: code,
-        offset,
-        limit,
-        total: 0,
-        hasMore: false,
-        messages: [],
-        error: { code, message: safeErrorMessage(code) },
-    };
-}
-function parseForKind(kind, path, opts = {}) {
-    if (kind === 'claude')
-        return parseClaudeInsight(path, opts);
-    if (kind === 'codex' || kind === 'traex')
-        return parseCodexInsight(path, opts);
-    if (kind === 'antigravity')
-        return parseAntigravityInsight(path, opts);
-    return null;
-}
-function isSupportedTranscriptKind(kind) {
-    return kind === 'claude' || kind === 'codex' || kind === 'traex' || kind === 'antigravity';
-}
-function cachedParseForKind(kind, path) {
-    let key;
-    try {
-        const st = statSync(path);
-        key = `${kind}:${path}:${st.mtimeMs}:${st.size}`;
-    }
-    catch {
-        key = `${kind}:${path}:missing`;
-    }
-    const hit = parseCache.get(key);
-    if (hit)
-        return hit;
-    const parsed = parseForKind(kind, path);
-    if (!parsed)
-        return null;
-    if (parseCache.size >= PARSE_CACHE_MAX && !parseCache.has(key)) {
-        const oldest = parseCache.keys().next().value;
-        if (oldest !== undefined)
-            parseCache.delete(oldest);
-    }
-    parseCache.set(key, parsed);
-    return parsed;
-}
-// A span is "slow" only if it actually spent that time working — tools that block
-// on a human reply (ask-question / plan approval) are excluded everywhere slowness
-// is judged, since their duration is mostly user idle, not a slow operation.
-function isSlowSpan(span, slowThresholdMs) {
-    return (span.durationMs ?? 0) >= slowThresholdMs && !isInteractiveWaitTool(span.tool);
-}
-function aggregate(spans, compactions, slowThresholdMs) {
-    const agg = emptyAgg();
-    agg.totalSpans = spans.length;
-    agg.compactions = compactions;
-    let reads = 0;
-    let writes = 0;
-    for (const s of spans) {
-        const phase = INSIGHT_PHASES.includes(s.phase) ? s.phase : 'discuss';
-        // User-blocking tools (ask-question / plan approval) spend their wall-clock
-        // waiting on a human, not working — count the action but not its duration,
-        // and never flag it as a slow span.
-        const waits = isInteractiveWaitTool(s.tool);
-        agg.phase[phase].count++;
-        if (s.durationMs !== undefined && !waits)
-            agg.phase[phase].ms += Math.max(0, Math.round(s.durationMs));
-        if (s.status === 'error') {
-            agg.failedSpans++;
-            agg.failByTool[s.tool] = (agg.failByTool[s.tool] ?? 0) + 1;
-        }
-        if (isSlowSpan(s, slowThresholdMs))
-            agg.slowSpans++;
-        if (isReadPhase(phase))
-            reads++;
-        if (isWritePhase(phase))
-            writes++;
-    }
-    agg.readWriteRatio = writes > 0 ? Math.round((reads / writes) * 100) / 100 : null;
-    return agg;
-}
-function topEntry(input) {
-    return Object.entries(input).sort((a, b) => b[1] - a[1])[0];
-}
-function suggestionsFor(agg, spans, slowThresholdMs) {
-    const out = [];
-    const topFail = topEntry(agg.failByTool);
-    if (agg.failedSpans >= 3) {
-        out.push({
-            id: 'high_tool_failure',
-            title: 'Tool failures are concentrated',
-            severity: 'bad',
-            evidence: [
-                `${agg.failedSpans} failed spans`,
-                topFail ? `${topFail[0]} failed ${topFail[1]} times` : 'multiple tools failed',
-            ],
-            action: 'Check the repeated failing tool first, then add preflight checks or clearer execution constraints.',
-        });
-    }
-    else if (agg.failedSpans > 0) {
-        out.push({
-            id: 'tool_failure_present',
-            title: 'Some tool calls failed',
-            severity: 'warn',
-            evidence: [`${agg.failedSpans} failed spans`],
-            action: 'Review the failed spans before repeating the workflow.',
-        });
-    }
-    const slowest = spans
-        .filter(s => s.durationMs !== undefined && !isInteractiveWaitTool(s.tool))
-        .sort((a, b) => (b.durationMs ?? 0) - (a.durationMs ?? 0))[0];
-    if (slowest && (slowest.durationMs ?? 0) >= slowThresholdMs) {
-        out.push({
-            id: 'slow_span',
-            title: 'A slow span dominates the session',
-            severity: (slowest.durationMs ?? 0) >= 180_000 ? 'bad' : 'warn',
-            evidence: [`${slowest.tool} ran for ${Math.round((slowest.durationMs ?? 0) / 1000)}s`],
-            action: 'Split or bound the slow operation, and surface timeout or progress feedback earlier.',
-        });
-    }
-    if (agg.readWriteRatio !== null && agg.readWriteRatio < 1) {
-        out.push({
-            id: 'low_read_write_ratio',
-            title: 'Edits outpaced reads',
-            severity: 'warn',
-            evidence: [`read/write ratio ${agg.readWriteRatio}`],
-            action: 'Add a read/search pass before edits when changing unfamiliar files.',
-        });
-    }
-    if (agg.compactions > 0) {
-        out.push({
-            id: 'context_compaction',
-            title: 'Context compaction happened',
-            severity: 'info',
-            evidence: [`compactions ${agg.compactions}`],
-            action: 'For long tasks, preserve decisions and checkpoints in durable notes or smaller subtasks.',
-        });
-    }
-    if (out.length === 0) {
-        out.push({
-            id: 'no_major_friction',
-            title: 'No major trace friction detected',
-            severity: 'info',
-            evidence: [`${agg.totalSpans} spans analyzed`],
-            action: 'Use the span timeline for spot checks or compare against slower sessions.',
-        });
-    }
-    return out.sort((a, b) => SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity]);
-}
-function uniqueNumbers(values, cap = DIAGNOSTIC_TARGET_CAP) {
-    return [...new Set(values)].slice(0, cap);
-}
-function diagnosticForSuggestion(s, agg, spans, visibleSpans, slowThresholdMs) {
-    const detail = visibleSpans !== undefined;
-    const visibleRaw = visibleSpans ?? [];
-    const target = (predicate) => {
-        const allMatches = spans
-            .map((span, index) => ({ span, index }))
-            .filter(x => predicate(x.span));
-        const visibleMatches = visibleRaw
-            .map((span, index) => ({ span, index }))
-            .filter(x => predicate(x.span))
-            .slice(0, DIAGNOSTIC_TARGET_CAP);
-        return {
-            spanIndexes: detail ? visibleMatches.map(x => x.index) : undefined,
-            turnIndexes: detail ? uniqueNumbers(visibleMatches.map(x => x.span.turnIndex)) : undefined,
-            matchedSpans: allMatches.length,
-            returnedSpans: visibleMatches.length,
-        };
-    };
-    const targetTools = (matches, cap = 5) => [...new Set(matches.map(x => x.tool))].slice(0, cap);
-    const base = (kind, reason, targets, stats) => ({
-        id: s.id,
-        suggestionId: s.id,
-        kind,
-        severity: s.severity,
-        title: s.title,
-        reason,
-        targets,
-        stats,
-    });
-    if (s.id === 'high_tool_failure' || s.id === 'tool_failure_present') {
-        const allErrorSpans = spans.filter(span => span.status === 'error');
-        const t = target(span => span.status === 'error');
-        const topFail = topEntry(agg.failByTool);
-        const tools = targetTools(allErrorSpans);
-        return base('tool_failure', topFail ? `${agg.failedSpans} failed spans; ${topFail[0]} failed ${topFail[1]} times.` : `${agg.failedSpans} failed spans.`, { spanIndexes: t.spanIndexes, turnIndexes: t.turnIndexes, tools }, {
-            failedSpans: agg.failedSpans,
-            matchedSpans: t.matchedSpans,
-            returnedSpans: t.returnedSpans,
-            topTool: topFail?.[0] ?? '',
-            topToolFailures: topFail?.[1] ?? 0,
-        });
-    }
-    if (s.id === 'slow_span') {
-        const slowSpans = spans
-            .filter(span => isSlowSpan(span, slowThresholdMs))
-            .sort((a, b) => (b.durationMs ?? 0) - (a.durationMs ?? 0));
-        const slowSet = new Set(slowSpans);
-        const t = target(span => slowSet.has(span));
-        const slowest = slowSpans[0];
-        const tools = targetTools(slowSpans);
-        return base('slow_span', slowest ? `${slowSpans.length} slow spans; slowest ${slowest.tool} ran ${Math.round((slowest.durationMs ?? 0) / 1000)}s.` : 'No slow spans matched.', { spanIndexes: t.spanIndexes, turnIndexes: t.turnIndexes, tools }, {
-            slowSpansTotal: slowSpans.length,
-            matchedSpans: t.matchedSpans,
-            returnedSpans: t.returnedSpans,
-            slowThresholdMs,
-            slowestTool: slowest?.tool ?? '',
-            slowestDurationMs: slowest?.durationMs ?? 0,
-        });
-    }
-    if (s.id === 'low_read_write_ratio') {
-        const reads = spans.filter(span => isReadPhase(span.phase));
-        const writes = spans.filter(span => isWritePhase(span.phase));
-        const t = target(span => isWritePhase(span.phase) || span.phase === 'run');
-        const targetSpans = spans.filter(span => isWritePhase(span.phase) || span.phase === 'run');
-        return base('read_write_imbalance', `Read/write ratio ${agg.readWriteRatio}; ${reads.length} read spans and ${writes.length} write spans.`, { spanIndexes: t.spanIndexes, turnIndexes: t.turnIndexes, tools: targetTools(targetSpans) }, {
-            readWriteRatio: agg.readWriteRatio ?? '',
-            readSpans: reads.length,
-            writeSpans: writes.length,
-            matchedSpans: t.matchedSpans,
-            returnedSpans: t.returnedSpans,
-        });
-    }
-    if (s.id === 'context_compaction') {
-        return base('compaction', `${agg.compactions} context compactions happened in this session.`, {}, { compactions: agg.compactions });
-    }
-    return base('none', `${agg.totalSpans} spans analyzed; no major trace friction detected.`, {}, { totalSpans: agg.totalSpans });
-}
-function diagnosticsFor(suggestions, agg, spans, visibleSpans, slowThresholdMs) {
-    return suggestions.map(s => diagnosticForSuggestion(s, agg, spans, visibleSpans, slowThresholdMs));
-}
-function selectVisibleSpans(spans, maxSpans, slowThresholdMs) {
-    const limit = Math.max(0, Math.floor(maxSpans));
-    if (spans.length <= limit)
-        return spans;
-    if (limit <= 0)
-        return [];
-    const selected = new Set();
-    const addWhere = (predicate) => {
-        for (let i = 0; i < spans.length && selected.size < limit; i++) {
-            if (predicate(spans[i]))
-                selected.add(i);
-        }
-    };
-    addWhere(span => span.status === 'error');
-    addWhere(span => isSlowSpan(span, slowThresholdMs));
-    addWhere(() => true);
-    return [...selected].sort((a, b) => a - b).map(i => spans[i]);
-}
-function safeFilePathLabel(path, cwd) {
-    const raw = path.trim();
-    if (!raw)
-        return 'unknown';
-    let label = raw;
-    if (cwd && isAbsolute(raw)) {
-        const rel = relative(cwd, raw);
-        if (rel && !rel.startsWith('..') && !isAbsolute(rel))
-            label = rel;
-    }
-    if (isAbsolute(label))
-        label = basename(label) || 'file';
-    label = label.replace(/\\/g, '/').replace(/\s+/g, ' ').trim();
-    if (!label || label === '.' || label === '..')
-        return 'file';
-    return label.length > 120 ? `.../${basename(label) || label.slice(-80)}` : label;
-}
-function patchLineCounts(patch) {
-    if (!patch)
-        return undefined;
-    let added = 0;
-    let removed = 0;
-    for (const line of patch.split('\n')) {
-        if (line.startsWith('+++') || line.startsWith('---'))
-            continue;
-        if (line.startsWith('+'))
-            added++;
-        else if (line.startsWith('-'))
-            removed++;
-    }
-    return added > 0 || removed > 0 ? { added, removed } : undefined;
-}
-function uniqueSortedNumbers(values, cap = DIAGNOSTIC_TARGET_CAP) {
-    return [...new Set(values)].sort((a, b) => a - b).slice(0, cap);
-}
-function buildWorkSummary(spans, safeSpans, cwd) {
-    const fileMap = new Map();
-    for (let i = 0; i < spans.length; i++) {
-        const span = spans[i];
-        for (const rawPath of span.filePaths ?? []) {
-            const label = safeFilePathLabel(rawPath, cwd);
-            const cur = fileMap.get(label) ?? {
-                path: label,
-                reads: 0,
-                edits: 0,
-                added: 0,
-                removed: 0,
-                hasLineCounts: false,
-                turnIndexes: [],
-                spanIndexes: [],
-            };
-            if (isReadPhase(span.phase))
-                cur.reads++;
-            if (isWritePhase(span.phase))
-                cur.edits++;
-            const counts = isWritePhase(span.phase) ? (span.lineCounts ?? patchLineCounts(span.patchText)) : undefined;
-            if (counts) {
-                cur.added += counts.added;
-                cur.removed += counts.removed;
-                cur.hasLineCounts = true;
-            }
-            cur.turnIndexes.push(span.turnIndex);
-            cur.spanIndexes.push(i);
-            fileMap.set(label, cur);
-        }
-    }
-    const fileChanges = [...fileMap.values()]
-        .map(row => ({
-        path: row.path,
-        reads: row.reads,
-        edits: row.edits,
-        ...(row.hasLineCounts ? { added: row.added, removed: row.removed } : {}),
-        turnIndexes: uniqueSortedNumbers(row.turnIndexes),
-        spanIndexes: uniqueSortedNumbers(row.spanIndexes),
-    }))
-        .sort((a, b) => ((b.added ?? 0) + (b.removed ?? 0)) - ((a.added ?? 0) + (a.removed ?? 0))
-        || b.edits - a.edits
-        || b.reads - a.reads
-        || a.path.localeCompare(b.path))
-        .slice(0, 100);
-    const commandMap = new Map();
-    for (let i = 0; i < (safeSpans?.length ?? 0); i++) {
-        const span = safeSpans[i];
-        const command = span.evidence?.command;
-        if (!command)
-            continue;
-        const key = command.text;
-        const cur = commandMap.get(key) ?? {
-            command,
-            count: 0,
-            failures: 0,
-            totalDurationMs: 0,
-            maxDurationMs: undefined,
-            lastStatus: span.status,
-            turnIndexes: [],
-            spanIndexes: [],
-        };
-        cur.count++;
-        if (span.status === 'error')
-            cur.failures++;
-        if (span.durationMs !== undefined) {
-            cur.totalDurationMs += span.durationMs;
-            cur.maxDurationMs = cur.maxDurationMs === undefined ? span.durationMs : Math.max(cur.maxDurationMs, span.durationMs);
-        }
-        cur.lastStatus = span.status;
-        cur.turnIndexes.push(span.turnIndex);
-        cur.spanIndexes.push(i);
-        commandMap.set(key, cur);
-    }
-    const commandsRun = [...commandMap.values()]
-        .map(row => ({
-        command: row.command,
-        count: row.count,
-        failures: row.failures,
-        totalDurationMs: row.totalDurationMs,
-        ...(row.maxDurationMs !== undefined ? { maxDurationMs: row.maxDurationMs } : {}),
-        lastStatus: row.lastStatus,
-        turnIndexes: uniqueSortedNumbers(row.turnIndexes),
-        spanIndexes: uniqueSortedNumbers(row.spanIndexes),
-    }))
-        .sort((a, b) => b.failures - a.failures
-        || b.count - a.count
-        || b.totalDurationMs - a.totalDurationMs
-        || a.command.text.localeCompare(b.command.text))
-        .slice(0, 100);
-    return { fileChanges, commandsRun };
-}
-// Compact per-session rollup for cross-session recurrence hotspots. Computed from raw
-// spans alone (filePaths→safe label, evidence.command already a scrubbed preview, tool +
-// result enum), so it's cheap enough to include in summary mode. Top-N capped.
-function buildSessionHot(spans, cwd) {
-    const files = new Map();
-    const cmds = new Map();
-    const errs = new Map();
-    for (const span of spans) {
-        for (const rawPath of span.filePaths ?? []) {
-            const label = safeFilePathLabel(rawPath, cwd);
-            const f = files.get(label) ?? { path: label, reads: 0, edits: 0, added: 0, removed: 0 };
-            if (isReadPhase(span.phase))
-                f.reads++;
-            if (isWritePhase(span.phase)) {
-                f.edits++;
-                const c = span.lineCounts ?? patchLineCounts(span.patchText);
-                if (c) {
-                    f.added += c.added;
-                    f.removed += c.removed;
-                }
-            }
-            files.set(label, f);
-        }
-        // Command recurrence keyed by the SAFE intent (kind + safe subject) — never the
-        // raw command text, which must not cross into the summary/overview (redaction
-        // invariant: command previews live only in per-session detail).
-        if (span.phase === 'run' && span.intent && span.intent.kind !== 'unknown') {
-            const subj = span.intent.subject;
-            const label = subj ? (subj.startsWith(span.intent.kind) ? subj : `${span.intent.kind} ${subj}`) : span.intent.kind;
-            if (label) {
-                const c = cmds.get(label) ?? { cmd: label, runs: 0, fails: 0 };
-                c.runs++;
-                if (span.status === 'error')
-                    c.fails++;
-                cmds.set(label, c);
-            }
-        }
-        if (span.status === 'error') {
-            const result = span.result?.category ?? 'tool_error';
-            const key = `${span.tool}\u0000${result}`;
-            const e = errs.get(key) ?? { tool: span.tool, result, count: 0 };
-            e.count++;
-            errs.set(key, e);
-        }
-    }
-    return {
-        files: [...files.values()]
-            .map(f => ({ path: f.path, reads: f.reads, edits: f.edits, ...(f.added || f.removed ? { added: f.added, removed: f.removed } : {}) }))
-            .sort((a, b) => (b.edits + b.reads) - (a.edits + a.reads) || ((b.added ?? 0) + (b.removed ?? 0)) - ((a.added ?? 0) + (a.removed ?? 0)))
-            .slice(0, 12),
-        cmds: [...cmds.values()].sort((a, b) => b.fails - a.fails || b.runs - a.runs).slice(0, 12),
-        errs: [...errs.values()].sort((a, b) => b.count - a.count).slice(0, 8),
-    };
-}
-function spanKey(span) {
-    const intent = span.intent;
-    return `${intent?.kind ?? 'unknown'}:${intent?.subject ?? ''}:${intent?.detail ?? ''}`;
-}
-function tagsForVisibleSpans(spans, slowThresholdMs) {
-    const counts = new Map();
-    for (const span of spans) {
-        const key = spanKey(span);
-        if (!key.startsWith('unknown:'))
-            counts.set(key, (counts.get(key) ?? 0) + 1);
-    }
-    const turnCounts = new Map();
-    for (const span of spans) {
-        const cur = turnCounts.get(span.turnIndex) ?? { reads: 0, writes: 0, runs: 0 };
-        if (isReadPhase(span.phase))
-            cur.reads++;
-        if (isWritePhase(span.phase))
-            cur.writes++;
-        if (span.phase === 'run')
-            cur.runs++;
-        turnCounts.set(span.turnIndex, cur);
-    }
-    return spans.map(span => {
-        const tags = new Set();
-        if (span.status === 'error')
-            tags.add('failure');
-        if (isSlowSpan(span, slowThresholdMs))
-            tags.add('slow');
-        const key = spanKey(span);
-        if (!key.startsWith('unknown:') && (counts.get(key) ?? 0) > 1)
-            tags.add('retry');
-        const tc = turnCounts.get(span.turnIndex);
-        if (tc && tc.reads === 0 && (tc.writes > 0 || tc.runs > 0))
-            tags.add('read_write_imbalance');
-        if (tags.size > 0)
-            tags.add('diagnostic');
-        else
-            tags.add('normal');
-        return [...tags];
-    });
-}
-function buildTurnDiagnostics(visibleSpans, slowThresholdMs) {
-    if (!visibleSpans)
-        return [];
-    const spanTags = tagsForVisibleSpans(visibleSpans, slowThresholdMs);
-    const byTurn = new Map();
-    for (let i = 0; i < visibleSpans.length; i++) {
-        const span = visibleSpans[i];
-        const acc = byTurn.get(span.turnIndex) ?? {
-            reads: 0,
-            edits: 0,
-            runs: 0,
-            failures: 0,
-            durationMs: 0,
-            spanIndexes: [],
-            tags: new Set(),
-        };
-        if (isReadPhase(span.phase))
-            acc.reads++;
-        if (isWritePhase(span.phase))
-            acc.edits++;
-        if (span.phase === 'run')
-            acc.runs++;
-        if (span.status === 'error')
-            acc.failures++;
-        if (span.durationMs !== undefined && !isInteractiveWaitTool(span.tool))
-            acc.durationMs += Math.max(0, Math.round(span.durationMs));
-        acc.spanIndexes.push(i);
-        for (const tag of spanTags[i] ?? []) {
-            if (tag !== 'normal')
-                acc.tags.add(tag);
-        }
-        byTurn.set(span.turnIndex, acc);
-    }
-    return [...byTurn.entries()]
-        .map(([turnIndex, acc]) => {
-        let severity = 'info';
-        let id = 'turn_normal';
-        const params = {
-            reads: acc.reads,
-            edits: acc.edits,
-            runs: acc.runs,
-            failures: acc.failures,
-            durationMs: acc.durationMs,
-        };
-        if (acc.failures > 0) {
-            severity = 'bad';
-            id = 'turn_has_failures';
-        }
-        else if (acc.tags.has('slow') || acc.durationMs >= slowThresholdMs) {
-            severity = 'warn';
-            id = 'turn_has_slow_spans';
-        }
-        else if (acc.tags.has('retry')) {
-            severity = 'warn';
-            id = 'turn_has_retries';
-        }
-        return {
-            turnIndex,
-            severity,
-            headline: { id, params },
-            metrics: {
-                reads: acc.reads,
-                edits: acc.edits,
-                runs: acc.runs,
-                failures: acc.failures,
-                durationMs: acc.durationMs,
-            },
-            spanIndexes: acc.spanIndexes.slice(0, DIAGNOSTIC_TARGET_CAP),
-            tags: acc.tags.size ? [...acc.tags] : ['normal'],
-        };
-    })
-        .filter(d => d.severity !== 'info')
-        .sort((a, b) => a.turnIndex - b.turnIndex);
-}
-function recordFromStats(stats) {
-    const out = {};
-    for (const [key, value] of Object.entries(stats ?? {})) {
-        out[key] = value;
-    }
-    return out;
-}
-function recommendationsForDiagnostics(diagnostics) {
-    return diagnostics
-        .filter(d => d.kind !== 'none')
-        .map(d => {
-        const stats = recordFromStats(d.stats);
-        const base = (id, impactId, whyId, actionIds) => ({
-            id,
-            diagnosticId: d.id,
-            severity: d.severity,
-            impact: { id: impactId, params: stats },
-            why: { id: whyId, params: stats },
-            nextActions: actionIds.map(actionId => ({ id: actionId, params: stats })),
-            evidence: {
-                spanIndexes: d.targets.spanIndexes,
-                turnIndexes: d.targets.turnIndexes,
-                counts: stats,
-            },
-        });
-        if (d.kind === 'tool_failure') {
-            return base('fix_repeated_tool_failures', 'impact_failed_spans', 'why_tool_failure_concentrated', ['inspect_failed_span_details', 'add_preflight_or_timeout']);
-        }
-        if (d.kind === 'slow_span') {
-            return base('split_slow_operation', 'impact_slow_spans', 'why_slow_span_dominates', ['narrow_or_split_slow_operation', 'surface_timeout_or_progress']);
-        }
-        if (d.kind === 'read_write_imbalance') {
-            return base('add_read_pass_before_edit', 'impact_low_read_write_ratio', 'why_edits_outpaced_reads', ['read_or_search_before_editing', 'verify_assumptions_before_running']);
-        }
-        return base('preserve_context_checkpoints', 'impact_context_compaction', 'why_context_compaction_happened', ['write_checkpoints_for_long_tasks']);
-    });
-}
-function spanDetailHeadline(span) {
-    return {
-        id: span.status === 'error'
-            ? 'span_failed'
-            : span.tags?.includes('slow')
-                ? 'span_slow'
-                : 'span_completed',
-        params: {
-            tool: span.tool,
-            intentKind: span.intent?.kind ?? 'unknown',
-            subject: span.intent?.subject ?? '',
-            resultCategory: span.result?.category ?? 'unknown',
-            durationMs: span.durationMs ?? 0,
-        },
-    };
-}
-function attachSpanDetails(spans) {
-    if (!spans)
-        return undefined;
-    return spans.map((span, index) => ({
-        ...span,
-        detail: {
-            headline: spanDetailHeadline(span),
-            phase: span.phase,
-            status: span.status,
-            ...(span.durationMs !== undefined ? { durationMs: span.durationMs } : {}),
-            turnIndex: span.turnIndex,
-            tags: span.tags ?? ['normal'],
-            ...(span.intent ? { intent: span.intent } : {}),
-            ...(span.result ? { result: span.result } : {}),
-            ...(span.evidence ? { evidence: span.evidence } : {}),
-            context: {
-                ...(spans[index - 1]?.intent ? { previousIntent: spans[index - 1].intent } : {}),
-                ...(spans[index + 1]?.intent ? { nextIntent: spans[index + 1].intent } : {}),
-            },
-        },
-    }));
-}
-function timelineKindForSpan(span) {
-    if (span.phase === 'research')
-        return 'read';
-    if (span.phase === 'edit')
-        return 'edit';
-    if (span.phase === 'run')
-        return span.status === 'error' ? 'result' : 'run';
-    if (span.phase === 'delegate')
-        return 'delegate';
-    return 'discuss';
-}
-function timelineLabelForSpan(span) {
-    return {
-        id: span.status === 'error' ? 'timeline_span_failed' : 'timeline_span_completed',
-        params: {
-            tool: span.tool,
-            intentKind: span.intent?.kind ?? 'unknown',
-            subject: span.intent?.subject ?? '',
-            resultCategory: span.result?.category ?? 'unknown',
-            durationMs: span.durationMs ?? 0,
-        },
-    };
-}
-function metricsForTimeline(spans) {
-    return spans.reduce((acc, span) => {
-        if (isReadPhase(span.phase))
-            acc.reads++;
-        if (isWritePhase(span.phase))
-            acc.edits++;
-        if (span.phase === 'run')
-            acc.runs++;
-        if (span.status === 'error')
-            acc.failures++;
-        // Exclude interactive-wait tools (ask-question / plan approval): their
-        // duration is user idle, not work — must match aggregate / buildTurnDiagnostics
-        // so the timeline turn metric doesn't show 119s of "waiting for the user".
-        if (span.durationMs !== undefined && !isInteractiveWaitTool(span.tool))
-            acc.durationMs += span.durationMs;
-        return acc;
-    }, { reads: 0, edits: 0, runs: 0, failures: 0, durationMs: 0 });
-}
-function buildTurnTimeline(spans, turnDiagnostics, turnPrompts, turnContext, turnAgentSay, allSpanTurnIndexes) {
-    if (!spans)
-        return [];
-    const diagByTurn = new Map(turnDiagnostics.map(d => [d.turnIndex, d]));
-    const grouped = new Map();
-    spans.forEach((span, index) => {
-        const row = grouped.get(span.turnIndex) ?? [];
-        row.push({ span, index });
-        grouped.set(span.turnIndex, row);
-    });
-    // A fully tool-less turn (pure Q&A / clarification / text-only reply) has no
-    // span, so keying turns off `grouped` alone would drop it from the timeline and
-    // the conversation replay. Union in turn indices that carry a prompt / context /
-    // narration — but ONLY when the turn is genuinely span-less (absent from
-    // `allSpanTurnIndexes`, the full un-capped span set). A turn whose spans exist
-    // but were trimmed by the maxSpans cap must NOT be re-added as an events:[] turn:
-    // that would misrepresent a capped turn as a 0-op turn and leak its prompt/say
-    // preview past the cap. When `allSpanTurnIndexes` is omitted (uncapped paths)
-    // every real-span turn is already in `grouped`, so the guard is a no-op.
-    // Detail==='summary' passes the prompt/context/say arrays undefined, so summary
-    // reports stay span-only.
-    const turnIndexes = new Set(grouped.keys());
-    const consider = (i) => {
-        if (grouped.has(i) || !allSpanTurnIndexes?.has(i))
-            turnIndexes.add(i);
-    };
-    turnPrompts?.forEach((p, i) => { if (p)
-        consider(i); });
-    turnContext?.forEach((c, i) => { if (c)
-        consider(i); });
-    turnAgentSay?.forEach((s, i) => { if (s?.text)
-        consider(i); });
-    return [...turnIndexes]
-        .sort((a, b) => a - b)
-        .map(turnIndex => {
-        const rows = grouped.get(turnIndex) ?? [];
-        const rowSpans = rows.map(r => r.span);
-        const diag = diagByTurn.get(turnIndex);
-        const tags = [...new Set(rowSpans.flatMap(s => s.tags ?? ['normal']))];
-        const metrics = diag?.metrics ?? metricsForTimeline(rowSpans);
-        return {
-            turnIndex,
-            severity: diag?.severity ?? 'info',
-            ...(turnPrompts?.[turnIndex] ? { prompt: turnPrompts[turnIndex] } : {}),
-            ...(turnAgentSay?.[turnIndex]?.text ? { agentSay: turnAgentSay[turnIndex] } : {}),
-            ...(turnContext?.[turnIndex] ? { context: turnContext[turnIndex] } : {}),
-            headline: diag?.headline ?? { id: 'turn_normal', params: metrics },
-            metrics,
-            tags,
-            events: rows.map(({ span, index }) => ({
-                kind: timelineKindForSpan(span),
-                spanIndex: index,
-                label: timelineLabelForSpan(span),
-                phase: span.phase,
-                status: span.status,
-                ...(span.durationMs !== undefined ? { durationMs: span.durationMs } : {}),
-                ...(span.intent ? { intent: span.intent } : {}),
-                ...(span.result ? { result: span.result } : {}),
-                ...(span.tags ? { tags: span.tags } : {}),
-                ...(span.evidence ? { evidence: span.evidence } : {}),
-            })),
-        };
-    })
-        .sort((a, b) => {
-        const sev = SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity];
-        return sev || a.turnIndex - b.turnIndex;
-    });
-}
-function roleForPromptSource(source) {
-    if (source?.kind === 'a2a_agent')
-        return 'a2a_agent';
-    if (source?.kind === 'system')
-        return 'system';
-    return 'user';
-}
-function authorForPromptSource(source) {
-    if (source?.kind === 'a2a_agent')
-        return source.agentName ?? source.senderName;
-    if (source?.kind === 'system')
-        return source.senderName ?? 'system';
-    return source?.senderName;
-}
-function buildConversationProjection(turns) {
-    const messages = [];
-    for (const turn of turns.slice().sort((a, b) => a.turnIndex - b.turnIndex)) {
-        if (turn.prompt) {
-            messages.push({
-                id: `turn-${turn.turnIndex}-prompt`,
-                turnIndex: turn.turnIndex,
-                role: roleForPromptSource(turn.prompt.source),
-                severity: turn.severity,
-                tags: turn.tags,
-                ...(authorForPromptSource(turn.prompt.source) ? { author: authorForPromptSource(turn.prompt.source) } : {}),
-                text: turn.prompt.text,
-                truncated: turn.prompt.truncated,
-                ...(turn.prompt.source ? { source: turn.prompt.source } : {}),
-            });
-        }
-        if (turn.agentSay?.text) {
-            // Agent narration as a 'say' message (role 'agent', text but no event) — sits
-            // before the turn's operations so the replay reads 你说 → agent 说 → agent 做.
-            messages.push({
-                id: `turn-${turn.turnIndex}-say`,
-                turnIndex: turn.turnIndex,
-                role: 'agent',
-                severity: turn.severity,
-                tags: turn.tags,
-                author: 'agent',
-                text: turn.agentSay.text,
-                truncated: turn.agentSay.truncated,
-            });
-        }
-        for (let i = 0; i < turn.events.length; i++) {
-            const event = turn.events[i];
-            const tags = event.tags ?? ['normal'];
-            messages.push({
-                id: `turn-${turn.turnIndex}-event-${event.spanIndex}-${i}`,
-                turnIndex: turn.turnIndex,
-                role: 'agent',
-                severity: event.status === 'error' ? 'bad' : tags.includes('slow') ? 'warn' : turn.severity,
-                tags,
-                author: 'agent',
-                event,
-            });
-        }
-    }
-    return messages;
-}
-function conversationSearchText(message) {
-    const parts = [
-        message.author,
-        message.text,
-        message.role,
-        message.severity,
-        ...(message.tags ?? []),
-        message.source?.senderName,
-        message.source?.agentName,
-        message.event?.intent?.kind,
-        message.event?.intent?.subject,
-        message.event?.intent?.detail,
-        message.event?.result?.category,
-        message.event?.evidence?.command?.text,
-        message.event?.evidence?.output?.text,
-    ];
-    return parts.filter(Boolean).join('\n').toLowerCase();
-}
-function filterConversationMessages(messages, opts) {
-    const q = opts.q?.trim().toLowerCase();
-    const turns = opts.turnIndexes?.length ? new Set(opts.turnIndexes.map(x => Math.max(0, Math.floor(x)))) : undefined;
-    return messages.filter(message => {
-        if (turns && !turns.has(message.turnIndex))
-            return false;
-        if (opts.role && message.role !== opts.role)
-            return false;
-        if (opts.severity && message.severity !== opts.severity)
-            return false;
-        if (opts.tag && !(message.tags ?? []).includes(opts.tag))
-            return false;
-        if (q && !conversationSearchText(message).includes(q))
-            return false;
-        return true;
-    });
-}
-function buildDetailTimelineFromParsed(parsed, slowThresholdMs) {
-    const tags = tagsForVisibleSpans(parsed.spans, slowThresholdMs);
-    const safeSpans = attachSpanDetails(parsed.spans.map((span, index) => toSafeSpan(span, parsed.firstEventMs, tags[index]))) ?? [];
-    const turnDiagnostics = buildTurnDiagnostics(parsed.spans, slowThresholdMs);
-    return buildTurnTimeline(safeSpans, turnDiagnostics, parsed.turnPrompts, parsed.turnContext, parsed.turnAgentSay);
-}
-function resolveAndParseForPrompt(q, promptMax) {
-    if (q.cliId && !SUPPORTED_CLI_IDS.has(q.cliId))
-        return { error: 'unsupported_cli' };
-    const resolved = resolveSessionTranscriptPath(q);
-    if (!resolved)
-        return { error: 'transcript_missing' };
-    if (!isSupportedTranscriptKind(resolved.kind))
-        return { error: 'unsupported_cli' };
-    if (!existsSync(resolved.path))
-        return { error: 'transcript_missing' };
-    try {
-        const parsed = parseForKind(resolved.kind, resolved.path, { promptMax });
-        if (!parsed)
-            return { error: 'unsupported_cli' };
-        return { parsed, kind: resolved.kind };
-    }
-    catch {
-        return { error: 'parse_error' };
-    }
-}
-export function buildSafeInsightTurnDetail(q, turnIndexInput, opts = {}) {
-    const turnIndex = Math.max(0, Math.floor(turnIndexInput));
-    const offset = Math.max(0, Math.floor(opts.offset ?? 0));
-    const limit = Math.min(Math.max(Math.floor(opts.limit ?? 4000) || 4000, 1), 20_000);
-    const resolved = resolveAndParseForPrompt(q, Number.MAX_SAFE_INTEGER);
-    if ('error' in resolved)
-        return promptUnavailable(q, turnIndex, offset, limit, resolved.error);
-    const parsed = resolved.parsed;
-    const prompt = parsed.turnPrompts?.[turnIndex];
-    const total = prompt?.text.length ?? 0;
-    const text = prompt ? prompt.text.slice(offset, offset + limit) : '';
-    const nextOffset = offset + text.length;
-    const hasMore = nextOffset < total;
-    const turnTimeline = buildDetailTimelineFromParsed(parsed, DEFAULT_SLOW_THRESHOLD_MS);
-    const messages = buildConversationProjection(turnTimeline).filter(m => m.turnIndex === turnIndex && m.role === 'agent');
-    return {
-        sessionId: q.sessionId,
-        cliId: q.cliId ?? 'unknown',
-        status: 'ok',
-        turnIndex,
-        offset,
-        limit,
-        total,
-        ...(hasMore ? { nextOffset } : {}),
-        hasMore,
-        ...(prompt ? {
-            prompt: {
-                text,
-                truncated: hasMore,
-                ...(prompt.source ? { source: prompt.source } : {}),
-            },
-        } : {}),
-        messages,
-    };
-}
-export function buildSafeInsightConversation(q, opts = {}) {
-    const offset = Math.max(0, Math.floor(opts.offset ?? 0));
-    const limit = Math.min(Math.max(Math.floor(opts.limit ?? 50) || 50, 1), 200);
-    const resolved = resolveAndParseForPrompt(q, 400);
-    if ('error' in resolved)
-        return conversationUnavailable(q, offset, limit, resolved.error);
-    const turnTimeline = buildDetailTimelineFromParsed(resolved.parsed, DEFAULT_SLOW_THRESHOLD_MS);
-    const all = filterConversationMessages(buildConversationProjection(turnTimeline), opts);
-    const messages = all.slice(offset, offset + limit);
-    const nextOffset = offset + messages.length;
-    const hasMore = nextOffset < all.length;
-    return {
-        sessionId: q.sessionId,
-        cliId: q.cliId ?? 'unknown',
-        status: 'ok',
-        offset,
-        limit,
-        total: all.length,
-        ...(hasMore ? { nextOffset } : {}),
-        hasMore,
-        messages,
-    };
-}
-export function buildSafeInsightReport(q, opts = {}) {
-    const detail = opts.detail ?? 'summary';
-    const parsedAt = (opts.now?.() ?? new Date()).toISOString();
-    if (q.cliId && !SUPPORTED_CLI_IDS.has(q.cliId))
-        return unsupported(q, detail, parsedAt, 'unsupported_cli');
-    const resolved = resolveSessionTranscriptPath(q);
-    if (!resolved)
-        return unsupported(q, detail, parsedAt, 'transcript_missing');
-    if (!isSupportedTranscriptKind(resolved.kind))
-        return unsupported(q, detail, parsedAt, 'unsupported_cli');
-    if (!existsSync(resolved.path))
-        return unsupported(q, detail, parsedAt, 'transcript_missing');
-    let parsed;
-    try {
-        const maybe = cachedParseForKind(resolved.kind, resolved.path);
-        if (!maybe)
-            return unsupported(q, detail, parsedAt, 'unsupported_cli');
-        parsed = maybe;
-    }
-    catch {
-        return unsupported(q, detail, parsedAt, 'parse_error');
-    }
-    const slowThresholdMs = opts.slowThresholdMs ?? DEFAULT_SLOW_THRESHOLD_MS;
-    const maxSpans = opts.maxSpans ?? DEFAULT_MAX_SPANS;
-    const agg = aggregate(parsed.spans, parsed.compactions, slowThresholdMs);
-    const suggestions = suggestionsFor(agg, parsed.spans, slowThresholdMs);
-    const visibleRaw = detail === 'spans'
-        ? selectVisibleSpans(parsed.spans, maxSpans, slowThresholdMs)
-        : undefined;
-    const visibleTags = visibleRaw ? tagsForVisibleSpans(visibleRaw, slowThresholdMs) : undefined;
-    const visible = attachSpanDetails(visibleRaw?.map((s, index) => toSafeSpan(s, parsed.firstEventMs, visibleTags?.[index])));
-    const diagnostics = diagnosticsFor(suggestions, agg, parsed.spans, visibleRaw, slowThresholdMs);
-    const turnDiagnostics = buildTurnDiagnostics(visibleRaw, slowThresholdMs);
-    // `visible` is capped to maxSpans; pass the FULL span turn set so a turn whose
-    // spans were trimmed by the cap isn't re-synthesized as an events:[] turn (only
-    // genuinely tool-less turns get unioned in). See buildTurnTimeline.
-    const allSpanTurnIndexes = detail === 'spans' ? new Set(parsed.spans.map(s => s.turnIndex)) : undefined;
-    const turnTimeline = buildTurnTimeline(visible, turnDiagnostics, detail === 'spans' ? parsed.turnPrompts : undefined, detail === 'spans' ? parsed.turnContext : undefined, detail === 'spans' ? parsed.turnAgentSay : undefined, allSpanTurnIndexes);
-    const report = {
-        sessionId: q.sessionId,
-        cliId: q.cliId ?? 'unknown',
-        status: 'ok',
-        meta: {
-            parsedAt,
-            asOf: parsed.asOf,
-            partial: parsed.partial,
-            detail,
-            spansTotal: parsed.spans.length,
-        },
-        agg,
-        suggestions,
-        diagnostics,
-        recommendations: recommendationsForDiagnostics(diagnostics),
-        turnDiagnostics,
-        turnTimeline,
-    };
-    // Compact recurrence rollup — included in BOTH modes so the overview (summary mode)
-    // can aggregate file/command/error hotspots cross-session without heavy detail.
-    report.hot = buildSessionHot(parsed.spans, q.cwd);
-    if (detail === 'spans' && visible) {
-        report.spans = visible;
-        report.meta.spansReturned = visible.length;
-        report.meta.capped = parsed.spans.length > visible.length;
-        report.workSummary = buildWorkSummary(visibleRaw ?? [], visible, q.cwd);
-        // Delegated sub-agents (Claude only) — one extra file parse each, so detail-mode only.
-        // Route through the shared parse cache so repeated detail fetches don't re-read
-        // unchanged sub-agent transcripts.
-        if (resolved.kind === 'claude') {
-            const lanes = buildSubagentLanes(resolved.path, p => cachedParseForKind('claude', p));
-            if (lanes.length)
-                report.subagents = lanes;
-        }
-    }
-    return report;
-}
-function mergeAgg(into, agg) {
-    // Defensive: in the cross-daemon merge, `agg` comes from a peer daemon's HTTP
-    // response, so don't assume its shape — a malformed chunk must not throw and
-    // 500 the whole aggregated overview (it should just contribute nothing).
-    if (!agg || typeof agg !== 'object')
-        return;
-    into.totalSpans += agg.totalSpans ?? 0;
-    into.failedSpans += agg.failedSpans ?? 0;
-    into.slowSpans += agg.slowSpans ?? 0;
-    into.compactions += agg.compactions ?? 0;
-    for (const [tool, count] of Object.entries(agg.failByTool ?? {})) {
-        into.failByTool[tool] = (into.failByTool[tool] ?? 0) + (count ?? 0);
-    }
-    for (const phase of INSIGHT_PHASES) {
-        into.phase[phase].count += agg.phase?.[phase]?.count ?? 0;
-        into.phase[phase].ms += agg.phase?.[phase]?.ms ?? 0;
-    }
-}
-function overviewSuggestions(reports) {
-    const byId = new Map();
-    for (const report of reports) {
-        if (report.status !== 'ok')
-            continue;
-        for (const s of report.suggestions) {
-            const cur = byId.get(s.id);
-            if (cur) {
-                cur.count += 1;
-                for (const e of s.evidence) {
-                    if (cur.evidence.length >= 4)
-                        break;
-                    if (!cur.evidence.includes(e))
-                        cur.evidence.push(e);
-                }
-            }
-            else {
-                byId.set(s.id, {
-                    id: s.id,
-                    title: s.title,
-                    severity: s.severity,
-                    count: 1,
-                    evidence: s.evidence.slice(0, 4),
-                    action: s.action,
-                });
-            }
-        }
-    }
-    return [...byId.values()]
-        .sort((a, b) => SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity] || b.count - a.count || a.id.localeCompare(b.id))
-        .slice(0, 12);
-}
-/** Yield to the event loop so a large overview (up to MAX_OVERVIEW_LIMIT sessions,
- *  each a synchronous transcript read+parse) can't monopolize the single-threaded
- *  daemon — Lark dispatch / PTY IO get a slot between batches. */
-const OVERVIEW_YIELD_EVERY = 16;
-function yieldToEventLoop() {
-    return new Promise(resolve => setImmediate(resolve));
-}
-export async function buildSafeInsightOverview(sessions, opts = {}) {
-    const parsedAt = (opts.now?.() ?? new Date()).toISOString();
-    const requestedLimit = opts.limit ?? DEFAULT_OVERVIEW_LIMIT;
-    const limit = Math.min(Math.max(Math.floor(requestedLimit) || DEFAULT_OVERVIEW_LIMIT, 1), MAX_OVERVIEW_LIMIT);
-    const input = sessions
-        .slice()
-        .sort((a, b) => Number(b.lastMessageAt ?? 0) - Number(a.lastMessageAt ?? 0));
-    const selected = input.slice(0, limit);
-    const rows = [];
-    for (let i = 0; i < selected.length; i++) {
-        const s = selected[i];
-        rows.push({
-            sessionId: s.sessionId,
-            cliId: s.cliId ?? 'unknown',
-            cliSessionId: s.cliSessionId,
-            title: s.title,
-            botName: s.botName,
-            larkAppId: s.larkAppId,
-            workingDir: s.workingDir ?? s.cwd,
-            status: s.status,
-            lastMessageAt: s.lastMessageAt,
-            report: buildSafeInsightReport(s, { ...opts, detail: 'summary', now: () => new Date(parsedAt) }),
-        });
-        if ((i + 1) % OVERVIEW_YIELD_EVERY === 0 && i + 1 < selected.length)
-            await yieldToEventLoop();
-    }
-    const reports = rows.map(r => r.report);
-    const okReports = reports.filter(r => r.status === 'ok');
-    const agg = emptyAgg();
-    for (const report of okReports) {
-        mergeAgg(agg, report.agg);
-    }
-    // Pooled read/write ratio (Σresearch ÷ Σedit), matching the dashboard's
-    // client-side aggregate. Averaging per-session ratios would let a tiny
-    // 2-read/1-write session weigh the same as a 300-read/100-write one and
-    // skew the headline, so pool the totals instead.
-    agg.readWriteRatio = agg.phase.edit.count > 0
-        ? Math.round((agg.phase.research.count / agg.phase.edit.count) * 100) / 100
-        : null;
-    return {
-        generatedAt: parsedAt,
-        meta: {
-            totalSessions: input.length,
-            returnedSessions: rows.length,
-            analyzedSessions: okReports.length,
-            unsupportedSessions: reports.filter(r => r.status === 'unsupported_cli').length,
-            missingTranscriptSessions: reports.filter(r => r.status === 'transcript_missing').length,
-            parseErrorSessions: reports.filter(r => r.status === 'parse_error').length,
-            capped: input.length > selected.length,
-            limit,
-        },
-        agg,
-        suggestions: overviewSuggestions(reports),
-        topFailedTools: Object.entries(agg.failByTool)
-            .map(([tool, count]) => ({ tool, count }))
-            .sort((a, b) => b.count - a.count || a.tool.localeCompare(b.tool))
-            .slice(0, 12),
-        topSlowSessions: rows
-            .filter(r => r.report.status === 'ok' && r.report.agg.slowSpans > 0)
-            .map(r => ({
-            sessionId: r.sessionId,
-            title: r.title,
-            cliId: r.cliId,
-            slowSpans: r.report.agg.slowSpans,
-            totalSpans: r.report.agg.totalSpans,
-        }))
-            .sort((a, b) => b.slowSpans - a.slowSpans || b.totalSpans - a.totalSpans)
-            .slice(0, 12),
-        sessions: rows,
-    };
-}
-export function mergeSafeInsightOverviews(overviews, opts = {}) {
-    const generatedAt = opts.generatedAt ?? new Date().toISOString();
-    const requestedLimit = opts.limit ?? DEFAULT_OVERVIEW_LIMIT;
-    const limit = Math.min(Math.max(Math.floor(requestedLimit) || DEFAULT_OVERVIEW_LIMIT, 1), MAX_OVERVIEW_LIMIT);
-    const allRows = overviews
-        .flatMap(o => o.sessions)
-        .sort((a, b) => Number(b.lastMessageAt ?? 0) - Number(a.lastMessageAt ?? 0));
-    const rows = allRows.slice(0, limit);
-    const reports = rows.map(r => r.report);
-    const okReports = reports.filter(r => r.status === 'ok');
-    const agg = emptyAgg();
-    for (const report of okReports) {
-        mergeAgg(agg, report.agg);
-    }
-    // Pooled read/write ratio (Σresearch ÷ Σedit), matching the dashboard's
-    // client-side aggregate. Averaging per-session ratios would let a tiny
-    // 2-read/1-write session weigh the same as a 300-read/100-write one and
-    // skew the headline, so pool the totals instead.
-    agg.readWriteRatio = agg.phase.edit.count > 0
-        ? Math.round((agg.phase.research.count / agg.phase.edit.count) * 100) / 100
-        : null;
-    return {
-        generatedAt,
-        meta: {
-            totalSessions: overviews.reduce((sum, o) => sum + o.meta.totalSessions, 0),
-            returnedSessions: rows.length,
-            analyzedSessions: okReports.length,
-            unsupportedSessions: reports.filter(r => r.status === 'unsupported_cli').length,
-            missingTranscriptSessions: reports.filter(r => r.status === 'transcript_missing').length,
-            parseErrorSessions: reports.filter(r => r.status === 'parse_error').length,
-            capped: allRows.length > rows.length || overviews.some(o => o.meta.capped),
-            limit,
-        },
-        agg,
-        suggestions: overviewSuggestions(reports),
-        topFailedTools: Object.entries(agg.failByTool)
-            .map(([tool, count]) => ({ tool, count }))
-            .sort((a, b) => b.count - a.count || a.tool.localeCompare(b.tool))
-            .slice(0, 12),
-        topSlowSessions: rows
-            .filter((r) => r.report.status === 'ok' && r.report.agg.slowSpans > 0)
-            .map(r => ({
-            sessionId: r.sessionId,
-            title: r.title,
-            cliId: r.cliId,
-            slowSpans: r.report.agg.slowSpans,
-            totalSpans: r.report.agg.totalSpans,
-        }))
-            .sort((a, b) => b.slowSpans - a.slowSpans || b.totalSpans - a.totalSpans)
-            .slice(0, 12),
-        sessions: rows,
-    };
-}
-//# sourceMappingURL=report.js.map