claude-inspect 0.6.0 → 0.8.0

package/dist/app/server/inspector.js

@@ -1,8 +1,11 @@
 import { EventEmitter } from 'node:events';
 import { watch } from 'node:fs';
 import { stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
-import { CLAUDE_DIR, relToClaude } from './config.js';
+import { CLAUDE_DIR, DATA_DIR, relToClaude } from './config.js';
+import { buildDigest } from './review/digest.js';
+import { findClaude, Reviewer } from './review/runner.js';
 import { CpuMonitor } from './cpu-monitor.js';
 import { registry } from './formats/index.js';
 import { HistoryIndex } from './history/aggregator.js';
@@ -33,6 +36,9 @@ function idleIdeProcess(p) {
 const SUBAGENT_STALE_MS = 10 * 60_000;
 /** Subagenten erscheinen auf dem Dashboard, wenn sie so kürzlich aktiv waren. */
 const SUBAGENT_DASHBOARD_MS = 30 * 60_000;
+/** Sparbetrieb ohne offenen Tab: Prozessliste alle 30 s, Komplettaktualisierung alle 2 min */
+const IDLE_POLL_MS = 30_000;
+const IDLE_REBUILD_MS = 120_000;
 export class Inspector extends EventEmitter {
     index = new ProjectIndex();
     store = new TranscriptStore();
@@ -42,6 +48,13 @@ export class Inspector extends EventEmitter {
     /** Aggregierte History (Tokens, Kosten, Tool-Aufrufe, Dateien) – nur im Speicher. */
     history = new HistoryIndex();
     historyReady = false;
+    historyRefreshedAt = 0;
+    /**
+     * Offene, sichtbare Browser-Tabs (Live-Verbindungen). Ohne Zuschauer läuft nur ein
+     * Sparbetrieb: Prozessliste alle 30 s (für die CPU-Messung), alles andere alle 2 min.
+     */
+    viewers = 0;
+    builtAt = 0;
     historyReadyResolve;
     /** Erfüllt, sobald der erste History-Scan durch ist (API-Aufrufe warten darauf). */
     historyLoaded = new Promise((r) => (this.historyReadyResolve = r));
@@ -56,8 +69,12 @@ export class Inspector extends EventEmitter {
     building;
     /** CPU-Auslastung je Claude-Prozess samt Unterprozessen */
     cpu;
+    /** "Analyze with Claude": startet auf Knopfdruck `claude -p` (abschaltbar mit --no-analyze) */
+    reviewer;
     constructor(opts = {}) {
         super();
+        if (opts.analyze !== false)
+            this.reviewer = new Reviewer(join(DATA_DIR, 'reviews'), (data) => this.emit('event', { type: 'review', data }));
         this.cpu = new CpuMonitor({
             log: opts.cpuLog ?? false,
             roots: () => new Map(this.processes.filter((p) => p.alive && p.pid > 0).map((p) => [p.pid, p.sessionId])),
@@ -91,7 +108,7 @@ export class Inspector extends EventEmitter {
             /* Fallback: nur Polling */
         }
         // Polling als Netz: Prozess-Liveness (kein Datei-Event beim Absturz) und verpasste Events.
-        this.poller = setInterval(() => void this.poll(), 3000);
+        this.startPoller();
         this.cpu.start();
     }
     stop() {
@@ -100,6 +117,28 @@ export class Inspector extends EventEmitter {
         clearInterval(this.poller);
         clearTimeout(this.timer);
     }
+    get active() {
+        return this.viewers > 0;
+    }
+    startPoller() {
+        clearInterval(this.poller);
+        this.poller = setInterval(() => void this.poll(), this.active ? 5000 : IDLE_POLL_MS);
+        this.cpu.setIdle(!this.active);
+    }
+    /** Anzahl offener Live-Verbindungen (sichtbare Tabs); schaltet zwischen Live- und Sparbetrieb. */
+    setViewers(n) {
+        const was = this.active;
+        this.viewers = n;
+        if (was === this.active)
+            return;
+        this.startPoller();
+        if (this.active) {
+            // Zuschauer zurück: sofort alles auf Stand bringen
+            this.dirty.processes = this.dirty.jobs = this.dirty.dashboard = true;
+            this.historyRefreshedAt = 0;
+            void this.poll();
+        }
+    }
     onFsEvent(abs) {
         const rel = relToClaude(abs);
         if (rel.startsWith('sessions/'))
@@ -108,7 +147,8 @@ export class Inspector extends EventEmitter {
             this.dirty.jobs = true;
         else if (rel.startsWith('projects/')) {
             if (rel.endsWith('.jsonl')) {
-                void this.onTranscriptChanged(abs);
+                if (this.active)
+                    void this.onTranscriptChanged(abs);
                 if (!rel.includes('/subagents/'))
                     void this.index.touch(abs);
             }
@@ -116,7 +156,9 @@ export class Inspector extends EventEmitter {
         }
         else
             return;
-        this.schedule();
+        // ohne Zuschauer nur vormerken; der nächste Sparlauf holt es nach
+        if (this.active)
+            this.schedule();
     }
     async onTranscriptChanged(path) {
         const r = await this.store.refreshIfLoaded(path);
@@ -127,6 +169,20 @@ export class Inspector extends EventEmitter {
         this.emit('event', { type: 'transcript', data: { sessionId: t.sessionId, agentId: t.agentId, total: t.entries.length } });
     }
     async poll() {
+        if (!this.active) {
+            // Sparbetrieb: Prozessliste aktuell halten (CPU-Messung braucht die Claude-Prozesse),
+            // den Rest nur alle 2 Minuten
+            if (Date.now() - this.builtAt < IDLE_REBUILD_MS) {
+                if (!this.building) {
+                    this.processes = await readProcesses();
+                }
+                return;
+            }
+            this.dirty.processes = true;
+            this.dirty.jobs = true;
+            this.schedule(0);
+            return;
+        }
         for (const t of this.store.all()) {
             try {
                 const st = await stat(t.path);
@@ -161,9 +217,13 @@ export class Inspector extends EventEmitter {
             }
             if (this.spawnsReady)
                 await this.spawns.refresh(this.index.list(), this.processes, false);
-            if (this.historyReady)
+            // Statistik muss nicht im Sekundentakt nachziehen; laufende Agenten schreiben ständig
+            if (this.historyReady && (!this.active || Date.now() - this.historyRefreshedAt > 5000)) {
+                this.historyRefreshedAt = Date.now();
                 await this.history.refresh(this.index.list(), this.projectOf, false);
+            }
             this.dirty.dashboard = false;
+            this.builtAt = Date.now();
             const d = await this.buildDashboard();
             const { generatedAt: _g, ...cmp } = d;
             const json = JSON.stringify(cmp);
@@ -185,8 +245,11 @@ export class Inspector extends EventEmitter {
         return this.cpu.logging ? this.cpu.dir : undefined;
     }
     async getDashboard() {
-        if (!this.dashboard)
+        // Abruf ohne Live-Verbindung (z. B. API) im Sparbetrieb: nicht älter als 5 s ausliefern
+        if (!this.dashboard || (!this.active && Date.now() - this.builtAt > 5000)) {
+            this.dirty.processes = this.dirty.jobs = true;
             await this.rebuild();
+        }
         return this.dashboard;
     }
     // -------------------------------------------------------------------------
@@ -421,14 +484,62 @@ export class Inspector extends EventEmitter {
     }
     async search(q) {
         const files = [];
+        const subMeta = new Map();
         for (const f of this.index.list()) {
             const sum = await this.index.summary(f);
             files.push({ path: f.path, sessionId: f.sessionId, project: sum.project, title: sum.title });
             for (const sf of await listSubagents(f.path)) {
                 files.push({ path: sf.path, sessionId: f.sessionId, agentId: sf.agentId, project: sum.project, title: sf.meta.description ?? sum.title });
+                subMeta.set(`${f.sessionId}/${sf.agentId}`, { type: sf.meta.agentType, description: sf.meta.description, path: sf.path });
             }
         }
-        return search(q, files, new Set(this.index.list().map((f) => f.sessionId)));
+        const res = await search(q, files, new Set(this.index.list().map((f) => f.sessionId)));
+        // Agenten der Treffer samt Vorfahren (Hauptagent, per claude -p aufrufender Agent) für die Baumansicht
+        const agents = {};
+        const home = homedir();
+        const tilde = (p) => (home && p.startsWith(home) ? '~' + p.slice(home.length) : p);
+        const add = async (sessionId, agentId, depth = 0) => {
+            const key = agentId ? `${sessionId}/${agentId}` : sessionId;
+            if (agents[key])
+                return key;
+            const f = this.index.get(sessionId);
+            if (!f || depth > 8)
+                return undefined;
+            const sum = await this.index.summary(f);
+            if (agentId) {
+                const m = subMeta.get(key);
+                agents[key] = {
+                    key,
+                    sessionId,
+                    agentId,
+                    kind: 'subagent',
+                    label: m?.type ?? 'subagent',
+                    sublabel: m?.description,
+                    project: sum.project,
+                    parentKey: await add(sessionId, undefined, depth + 1),
+                    file: tilde(m?.path ?? f.path),
+                };
+                return key;
+            }
+            const link = this.spawns.parentOf(sessionId);
+            const proc = this.processes.find((p) => p.sessionId === sessionId);
+            agents[key] = {
+                key,
+                sessionId,
+                kind: link ? 'spawn' : 'main',
+                label: proc?.name ?? sum.title ?? sessionId.slice(0, 8),
+                sublabel: link ? (this.spawns.childInfo(sessionId)?.agentSetting ?? 'claude -p') : undefined,
+                project: sum.project,
+                file: tilde(f.path),
+            };
+            if (link)
+                agents[key].parentKey = await add(link.parentSessionId, link.parentAgentId, depth + 1);
+            return key;
+        };
+        for (const h of res.hits)
+            if (h.kind !== 'history-prompt')
+                await add(h.sessionId, h.agentId);
+        return { ...res, agents };
     }
     /**
      * Ablauf einer Session für Zeitleiste und Graph: Hauptagent, Subagenten
@@ -576,6 +687,38 @@ export class Inspector extends EventEmitter {
     formats() {
         return registry.report();
     }
+    /** Kompakter Bericht über die Session samt Subagenten und gestarteten Sitzungen (Grundlage der Analyse). */
+    async reviewDigest(sessionId) {
+        const [flow, cost] = [await this.flow(sessionId), await this.sessionCost(sessionId)];
+        const f = this.index.get(sessionId);
+        if (!flow || !f)
+            return undefined;
+        const sum = await this.index.summary(f);
+        const costOf = new Map(cost?.rows.map((r) => [r.id, r.costUSD]));
+        const lanes = [];
+        for (const lane of flow.lanes) {
+            const t = await this.transcriptFor(lane.sessionId, lane.agentId);
+            if (t)
+                lanes.push({ lane, entries: t.entries, costUSD: costOf.get(lane.id) ?? 0 });
+        }
+        return buildDigest({ title: sum.title, project: sum.project, cwd: sum.cwd, gitBranch: sum.gitBranch, costUSD: cost?.costUSD ?? 0, lanes });
+    }
+    async reviewState(sessionId) {
+        if (!this.index.get(sessionId))
+            return undefined;
+        if (!this.reviewer)
+            return { available: false, disabled: true, runs: [] };
+        const claudePath = await findClaude();
+        return { available: !!claudePath, claudePath, disabled: false, digest: (await this.reviewDigest(sessionId))?.stats, runs: await this.reviewer.list(sessionId) };
+    }
+    async startReview(sessionId, req) {
+        if (!this.reviewer)
+            throw new Error('Analysis is turned off (--no-analyze).');
+        const digest = await this.reviewDigest(sessionId);
+        if (!digest)
+            throw new Error('unknown session');
+        return this.reviewer.start(sessionId, digest, req);
+    }
 }
 const MIN = 60_000;
 const BUCKET_SIZES = [1, 2, 5, 10, 15, 30, 60, 120, 180, 360, 720, 1440].map((m) => m * MIN);

package/dist/app/server/model/cpu.js

@@ -87,7 +87,7 @@ export function cpuHistory(samples, opts) {
     for (let i = 0; i < samples.length; i++) {
         const s = samples[i];
         // Anteil dieser Messung an der Zeit: Abstand zur vorigen, höchstens zwei Messabstände
-        const dt = Math.min(i > 0 ? s.t - samples[i - 1].t : opts.intervalMs, 2 * opts.intervalMs) / 1000;
+        const dt = Math.min(i > 0 ? s.t - samples[i - 1].t : opts.intervalMs, opts.maxStepMs ?? 2 * opts.intervalMs) / 1000;
         const byComm = new Map();
         for (const p of s.procs) {
             byComm.set(p.comm, (byComm.get(p.comm) ?? 0) + p.pct);

package/dist/app/server/review/digest.js

@@ -0,0 +1,362 @@
+import { homedir } from 'node:os';
+import { addUsage, emptyTotals, estimateCost } from '../../shared/pricing.js';
+/** ~70k Tokens – genug für lange Sessions, ohne das Limit unnötig zu belasten */
+const MAX_CHARS = 240_000;
+const LEVELS = [
+    { prompt: 4000, text: 1200, err: 600, ok: 160, cmd: 400 },
+    { prompt: 2000, text: 500, err: 300, ok: 0, cmd: 240 },
+    { prompt: 1000, text: 200, err: 160, ok: 0, cmd: 160 },
+];
+// --- Geheimnisse ---------------------------------------------------------------
+const SECRET_PATTERNS = [
+    [/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|$)/g, '[REDACTED:private-key]'],
+    [/\bsk-ant-[A-Za-z0-9_-]{10,}/g, '[REDACTED:anthropic-key]'],
+    [/\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}/g, '[REDACTED:api-key]'],
+    [/\bgithub_pat_[A-Za-z0-9_]{20,}/g, '[REDACTED:github-token]'],
+    [/\bgh[pousr]_[A-Za-z0-9]{20,}/g, '[REDACTED:github-token]'],
+    [/\bxox[abprs]-[A-Za-z0-9-]{10,}/g, '[REDACTED:slack-token]'],
+    [/\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g, '[REDACTED:aws-key]'],
+    [/\bAIza[0-9A-Za-z_-]{35}\b/g, '[REDACTED:google-key]'],
+    [/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g, '[REDACTED:jwt]'],
+    [/\b(Bearer|Basic)\s+[A-Za-z0-9._~+/-]{16,}=*/g, (_m, kind) => `${kind} [REDACTED:credential]`],
+    [/(:\/\/[^\s:/@]+:)[^\s@/]{3,}@/g, (_m, pre) => `${pre}[REDACTED:password]@`],
+    [
+        /\b((?:password|passwd|pwd|secret|token|api[_-]?key|access[_-]?key|client[_-]?secret|auth)["']?\s*[:=]\s*["']?)([^\s"',;]{6,})/gi,
+        (_m, pre) => `${pre}[REDACTED:secret]`,
+    ],
+];
+export function redact(s, count) {
+    let out = s;
+    for (const [re, rep] of SECRET_PATTERNS) {
+        out = out.replace(re, (...args) => {
+            count.n++;
+            return typeof rep === 'string' ? rep : rep(...args);
+        });
+    }
+    return out;
+}
+// --- Hilfen ------------------------------------------------------------------
+const home = homedir();
+const tildify = (p) => (home && p.startsWith(home) ? '~' + p.slice(home.length) : p);
+function oneLine(s, max) {
+    const t = s.replace(/\r/g, '').replace(/\n+/g, ' ⏎ ').replace(/\s+/g, ' ').trim();
+    return t.length > max ? t.slice(0, max) + ` …[+${t.length - max}]` : t;
+}
+function block(s, max) {
+    const t = s.replace(/\r/g, '').trim();
+    return t.length > max ? t.slice(0, max) + `\n…[${t.length - max} more characters]` : t;
+}
+const time = (ts) => (ts ? new Date(ts).toLocaleTimeString('en-GB', { hour12: false }) : '--:--:--');
+const usd = (n) => (n >= 1 ? `$${n.toFixed(2)}` : `$${n.toFixed(3)}`);
+const kTok = (n) => (n >= 1000 ? `${Math.round(n / 1000)}k` : String(n));
+function dur(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60_000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    if (ms < 3600_000)
+        return `${Math.floor(ms / 60_000)}m${Math.round((ms % 60_000) / 1000)}s`;
+    if (ms < 86_400_000)
+        return `${Math.floor(ms / 3600_000)}h${Math.round((ms % 3600_000) / 60_000)}m`;
+    return `${Math.floor(ms / 86_400_000)}d${Math.round((ms % 86_400_000) / 3600_000)}h`;
+}
+function resultText(r) {
+    return r.parts.map((p) => (p.type === 'text' ? p.text : p.type === 'image' ? '[image]' : '')).join('\n');
+}
+const s = (v) => (typeof v === 'string' ? v : '');
+function toolDetail(e, lv) {
+    const i = e.input ?? {};
+    switch (e.name) {
+        case 'Bash':
+            return `${oneLine(s(i.command), lv.cmd)}${i.run_in_background ? ' (background)' : ''}`;
+        case 'Read':
+        case 'Write':
+        case 'Edit':
+        case 'MultiEdit':
+        case 'NotebookEdit': {
+            const p = tildify(s(i.file_path) || s(i.notebook_path));
+            if (e.name === 'Write')
+                return `${p} (${s(i.content).split('\n').length} lines)`;
+            if (e.name === 'Edit')
+                return `${p} (−${s(i.old_string).split('\n').length}/+${s(i.new_string).split('\n').length} lines)`;
+            if (e.name === 'Read' && (i.offset || i.limit))
+                return `${p} (from ${i.offset ?? 0}, ${i.limit ?? 'all'} lines)`;
+            return p;
+        }
+        case 'Grep':
+        case 'Glob':
+            return `${oneLine(s(i.pattern), 160)}${i.path ? ` in ${tildify(s(i.path))}` : ''}`;
+        case 'Agent':
+        case 'Task':
+            return `${s(i.subagent_type) || 'agent'}: ${oneLine(s(i.description), 120)} – prompt: ${oneLine(s(i.prompt), lv.cmd)}`;
+        case 'WebFetch':
+            return `${s(i.url)}${i.prompt ? ` – ${oneLine(s(i.prompt), 120)}` : ''}`;
+        case 'WebSearch':
+            return oneLine(s(i.query), 200);
+    }
+    return oneLine(JSON.stringify(i), lv.cmd);
+}
+// --- Automatische Befunde ------------------------------------------------------
+const SENSITIVE_PATH = /(^|[/\\\s"'])(\.env(\.[\w-]+)?|id_rsa|id_ed25519|id_ecdsa|[\w-]+\.pem|[\w-]+\.key|\.netrc|\.npmrc|\.pypirc|credentials(\.json)?|\.aws[/\\]|\.ssh[/\\]|\.kube[/\\]config|\.docker[/\\]config\.json|secrets?\.(json|ya?ml|env))(\b|$)/i;
+// Aufrufe an localhost zählen nicht als Netzwerkverkehr nach außen
+const NETWORK = /\b(scp|rsync|sftp|ssh|ncat|telnet|ftp)\b|https?:\/\/(?!localhost\b|127\.0\.0\.1\b|\[::1\])|\b(curl|wget)\b(?![^\n|;&]*\b(localhost|127\.0\.0\.1)\b)/;
+const UPLOAD = /\bcurl\b(?![^\n|;&]*\b(localhost|127\.0\.0\.1)\b)[^|]*(\s-d\b|--data|\s-F\b|--form|\s-T\b|--upload-file|-X\s*(POST|PUT|PATCH))|\bscp\b|\brsync\b.*:|\bgit\s+push\b/;
+const RISKY = [
+    [/\brm\s+-[a-zA-Z]*r[a-zA-Z]*f|\brm\s+-[a-zA-Z]*f[a-zA-Z]*r/, 'rm -rf'],
+    [/\bgit\s+push\b[^\n]*(--force\b|-f\b|--force-with-lease)/, 'force push'],
+    [/\bgit\s+reset\s+--hard/, 'git reset --hard'],
+    [/\bgit\s+clean\s+-[a-zA-Z]*f/, 'git clean -f'],
+    [/\bgit\s+(checkout|restore)\s+(--\s+)?\.(\s|$)/, 'discard all changes'],
+    [/--no-verify\b/, '--no-verify'],
+    [/\bsudo\b/, 'sudo'],
+    [/\bchmod\s+(-R\s+)?777\b/, 'chmod 777'],
+    [/\b(curl|wget)\b[^|\n]*\|\s*(sudo\s+)?(ba|z)?sh\b/, 'pipe download to shell'],
+    [/\b(DROP\s+(TABLE|DATABASE)|TRUNCATE\s+TABLE|DELETE\s+FROM\s+\w+\s*;?\s*$)/i, 'destructive SQL'],
+    [/--dangerously|bypassPermissions/, 'permission bypass'],
+];
+class Findings {
+    toolCalls = 0;
+    errors = 0;
+    denied = 0;
+    failing = new Map();
+    reads = new Map();
+    sensitive = new Map();
+    network = [];
+    uploads = [];
+    risky = new Map();
+    webFetches = 0;
+    maxContext = 0;
+    cacheRead = 0;
+    inputAll = 0;
+    compactions = 0;
+    tool(lane, e, r, count) {
+        this.toolCalls++;
+        const i = e.input ?? {};
+        const cmd = e.name === 'Bash' ? s(i.command) : '';
+        const path = s(i.file_path) || s(i.notebook_path) || s(i.path);
+        if (r?.isError) {
+            this.errors++;
+            const key = `${lane}: ${e.name} ${oneLine(redact(cmd || path || JSON.stringify(i), count), 140)}`;
+            this.failing.set(key, (this.failing.get(key) ?? 0) + 1);
+        }
+        if (r?.denied)
+            this.denied++;
+        if (e.name === 'Read' && path)
+            this.reads.set(`${lane}: ${tildify(path)}`, (this.reads.get(`${lane}: ${tildify(path)}`) ?? 0) + 1);
+        for (const c of [path, cmd]) {
+            const m = c && SENSITIVE_PATH.exec(c);
+            if (m) {
+                const k = `${e.name} ${oneLine(tildify(c), 140)}`;
+                this.sensitive.set(redact(k, count), (this.sensitive.get(k) ?? 0) + 1);
+                break;
+            }
+        }
+        if (e.name === 'WebFetch' || e.name === 'WebSearch')
+            this.webFetches++;
+        if (cmd) {
+            const short = oneLine(redact(cmd, count), 160);
+            if (UPLOAD.test(cmd))
+                this.uploads.push(`${time(e.timestamp)} ${lane}: ${short}`);
+            else if (NETWORK.test(cmd))
+                this.network.push(`${time(e.timestamp)} ${lane}: ${short}`);
+            for (const [re, label] of RISKY) {
+                if (re.test(cmd)) {
+                    const l = this.risky.get(label) ?? [];
+                    l.push(`${time(e.timestamp)} ${lane}: ${short}`);
+                    this.risky.set(label, l);
+                }
+            }
+        }
+    }
+    render(redactions) {
+        const out = [];
+        const top = (m, n, f) => [...m.entries()].slice(0, n).map(([k, v]) => f(k, v));
+        out.push(`- Tool calls: ${this.toolCalls}, failed: ${this.errors}, permission denied: ${this.denied}`);
+        const repeatedFails = new Map([...this.failing].filter(([, n]) => n >= 2).sort((a, b) => b[1] - a[1]));
+        if (repeatedFails.size)
+            out.push('- Same call failed repeatedly:', ...top(repeatedFails, 8, (k, n) => `  - ${n}× ${k}`));
+        const repeatedReads = new Map([...this.reads].filter(([, n]) => n >= 3).sort((a, b) => b[1] - a[1]));
+        if (repeatedReads.size)
+            out.push('- Same file read 3+ times:', ...top(repeatedReads, 8, (k, n) => `  - ${n}× ${k}`));
+        if (this.inputAll)
+            out.push(`- Prompt cache: ${Math.round((this.cacheRead / this.inputAll) * 100)}% of input tokens read from cache; largest context ${kTok(this.maxContext)} tokens; context compactions: ${this.compactions}`);
+        if (this.sensitive.size)
+            out.push('- Access to possibly sensitive files:', ...top(this.sensitive, 10, (k, n) => `  - ${n > 1 ? `${n}× ` : ''}${k}`));
+        if (redactions)
+            out.push(`- ${redactions} secret-looking values were found in the session and replaced with [REDACTED:…] in this digest`);
+        if (this.uploads.length)
+            out.push('- Commands that send data out (upload/POST/push/copy to remote):', ...this.uploads.slice(0, 10).map((l) => `  - ${l}`));
+        if (this.network.length)
+            out.push(`- Other network commands: ${this.network.length}`, ...this.network.slice(0, 6).map((l) => `  - ${l}`));
+        if (this.webFetches)
+            out.push(`- WebFetch/WebSearch calls: ${this.webFetches}`);
+        for (const [label, list] of this.risky)
+            out.push(`- Risky pattern "${label}": ${list.length}×`, ...list.slice(0, 5).map((l) => `  - ${l}`));
+        return out.join('\n');
+    }
+}
+const SHOWN = new Set(['user-text', 'assistant-text', 'tool-use']);
+function renderLane(dl, lv, childOf, f, count) {
+    const { lane, entries } = dl;
+    const results = new Map();
+    for (const e of entries)
+        if (e.kind === 'tool-result')
+            results.set(e.toolUseId, e);
+    const seenMsg = new Set();
+    const lines = [];
+    const R = (t) => redact(t, count);
+    const name = lane.kind === 'main' ? 'main agent' : lane.kind === 'subagent' ? `subagent ${lane.label}` : `spawned claude session ${lane.label}`;
+    let day = '';
+    for (const e of entries) {
+        const d = e.timestamp ? new Date(e.timestamp).toDateString() : '';
+        if (d && d !== day && SHOWN.has(e.kind)) {
+            day = d;
+            lines.push(`--- ${new Date(e.timestamp).toLocaleDateString('en-GB', { weekday: 'short', day: '2-digit', month: 'short', year: 'numeric' })} ---`);
+        }
+        // Kosten und Kontextgröße je Modellantwort (einmal pro Message)
+        let turn = '';
+        if ((e.kind === 'assistant-text' || e.kind === 'thinking' || e.kind === 'tool-use') && e.usage && e.messageId && !seenMsg.has(e.messageId) && e.model !== '<synthetic>') {
+            seenMsg.add(e.messageId);
+            const t = emptyTotals();
+            addUsage(t, e.usage);
+            const ctx = t.input + t.cacheRead + t.cacheWrite5m + t.cacheWrite1h;
+            if (f) {
+                f.maxContext = Math.max(f.maxContext, ctx);
+                f.cacheRead += t.cacheRead;
+                f.inputAll += ctx;
+            }
+            const c = estimateCost(e.model, t) ?? 0;
+            if (c >= 0.02)
+                turn = ` {${usd(c)}, ctx ${kTok(ctx)}}`;
+        }
+        const at = `[${time(e.timestamp)}]`;
+        switch (e.kind) {
+            case 'user-text': {
+                if (e.isMeta || !e.text)
+                    break;
+                if (e.isCompactSummary) {
+                    lines.push(`${at} [context was compacted – earlier conversation summarized]`);
+                    if (f)
+                        f.compactions++;
+                    break;
+                }
+                if (e.text.startsWith('<')) {
+                    const cmd = /<command-name>([^<]+)<\/command-name>/.exec(e.text);
+                    if (cmd)
+                        lines.push(`${at} USER ran ${cmd[1]}`);
+                    break;
+                }
+                lines.push(`${at} USER:\n${R(block(e.text, lv.prompt))}`);
+                break;
+            }
+            case 'assistant-text':
+                if (e.isApiError)
+                    lines.push(`${at} API ERROR: ${R(oneLine(e.text, 300))}`);
+                else if (e.text.trim())
+                    lines.push(`${at} ASSISTANT${turn}: ${R(block(e.text, lv.text))}`);
+                else if (turn)
+                    lines.push(`${at} ASSISTANT${turn}`);
+                break;
+            case 'thinking':
+                if (turn)
+                    lines.push(`${at} (thinking)${turn}`);
+                break;
+            case 'tool-use': {
+                const r = results.get(e.toolUseId);
+                f?.tool(lane.kind === 'main' ? 'main' : lane.label, e, r, count);
+                let status = 'no result';
+                if (r) {
+                    const took = r.timestamp && e.timestamp ? ` ${dur(Date.parse(r.timestamp) - Date.parse(e.timestamp))}` : '';
+                    const text = resultText(r);
+                    if (r.denied)
+                        status = `DENIED${took}: ${R(oneLine(r.denied, lv.err))}`;
+                    else if (r.isError)
+                        status = `ERROR${took}: ${R(oneLine(text, lv.err))}`;
+                    else
+                        status = `ok${took}${text.length > 200 ? `, ${text.length} chars` : ''}${lv.ok ? `: ${R(oneLine(text, lv.ok))}` : ''}`;
+                }
+                const child = childOf.get(e.toolUseId);
+                lines.push(`${at} TOOL ${e.name}${turn}: ${R(toolDetail(e, lv))} → ${status}${child ? ` ⇒ started ${child}` : ''}`);
+                break;
+            }
+            case 'system':
+                if (e.subtype === 'compact_boundary') {
+                    lines.push(`${at} [context compacted]`);
+                    if (f)
+                        f.compactions++;
+                }
+                break;
+        }
+    }
+    const span = lane.start && lane.end ? `, ${dur(lane.end - lane.start)}` : '';
+    const head = `## Agent: ${name}${lane.sublabel ? ` – ${R(oneLine(lane.sublabel, 160))}` : ''}\n(${lane.model ?? 'unknown model'}, ${lane.toolCalls} tool calls, ${kTok(lane.outputTokens)} output tokens, est. ${usd(dl.costUSD)}${span}, status ${lane.status})`;
+    return { head, lines };
+}
+export function buildDigest(input) {
+    const childOf = new Map();
+    const labelOf = new Map(input.lanes.map((l) => [l.lane.id, l.lane.kind === 'main' ? 'main agent' : `${l.lane.kind === 'spawn' ? 'claude session' : 'subagent'} "${l.lane.label}"`]));
+    for (const { lane } of input.lanes)
+        if (lane.viaToolUseId)
+            childOf.set(lane.viaToolUseId, labelOf.get(lane.id));
+    const tree = input.lanes
+        .map(({ lane, costUSD }) => `${'  '.repeat(lane.depth)}- ${labelOf.get(lane.id)}${lane.sublabel ? ` (${oneLine(lane.sublabel, 80)})` : ''}: ${lane.model ?? '?'}, ${lane.toolCalls} tool calls, est. ${usd(costUSD)}, ${lane.status}`)
+        .join('\n');
+    const starts = input.lanes.map((l) => l.lane.start).filter((x) => !!x);
+    const ends = input.lanes.map((l) => l.lane.end).filter((x) => !!x);
+    const from = starts.length ? Math.min(...starts) : undefined;
+    const to = ends.length ? Math.max(...ends) : undefined;
+    let truncated = false;
+    let result;
+    for (let li = 0; li < LEVELS.length; li++) {
+        const count = { n: 0 };
+        const f = new Findings();
+        const lanes = input.lanes.map((l) => renderLane(l, LEVELS[li], childOf, f, count));
+        let body = lanes.map((l) => `${l.head}\n\n${l.lines.join('\n')}`).join('\n\n');
+        const last = li === LEVELS.length - 1;
+        if (body.length > MAX_CHARS && !last) {
+            truncated = true;
+            continue;
+        }
+        if (body.length > MAX_CHARS) {
+            // Notfalls die Mitte langer Lanes auslassen: Anfang und Ende sind meist am aufschlussreichsten
+            const total = lanes.reduce((a, l) => a + l.lines.length, 0);
+            const avg = body.length / Math.max(1, total);
+            const keep = Math.floor(MAX_CHARS / avg);
+            body = lanes
+                .map((l) => {
+                const k = Math.max(20, Math.floor((keep * l.lines.length) / total));
+                if (l.lines.length <= k)
+                    return `${l.head}\n\n${l.lines.join('\n')}`;
+                const head = Math.ceil(k * 0.4);
+                const tail = k - head;
+                return `${l.head}\n\n${[...l.lines.slice(0, head), `… [${l.lines.length - k} entries omitted for length] …`, ...l.lines.slice(-tail)].join('\n')}`;
+            })
+                .join('\n\n');
+        }
+        const meta = [
+            `# Claude Code session digest`,
+            '',
+            `- Title: ${redact(input.title ?? '(untitled)', count)}`,
+            `- Project: ${input.project}${input.cwd ? ` (${tildify(input.cwd)})` : ''}${input.gitBranch ? `, branch ${input.gitBranch}` : ''}`,
+            from ? `- Time: ${new Date(from).toLocaleString('en-GB')} – ${to ? new Date(to).toLocaleString('en-GB') : 'now'}${to ? ` (${dur(to - from)})` : ''}` : undefined,
+            `- Estimated cost of the whole tree (API list prices): ${usd(input.costUSD)}`,
+            `- Format: one line per event. [hh:mm:ss] USER / ASSISTANT / TOOL <name>: <input> → <result status, duration>. {$cost, ctx N} = cost and context size of that model response (shown from $0.02). Texts and outputs are shortened${truncated ? ' strongly, because the session is long' : ''}.`,
+            '',
+            '## Agent tree',
+            tree,
+            '',
+            '## Automatic observations (computed, not judged)',
+            f.render(count.n),
+            '',
+        ]
+            .filter((x) => x !== undefined)
+            .join('\n');
+        const text = `${meta}\n\n${body}\n`;
+        result = {
+            text,
+            stats: { chars: text.length, tokens: Math.round(text.length / 3.5), agents: input.lanes.length, toolCalls: f.toolCalls, redactions: count.n, truncated: truncated || text.includes('entries omitted for length') },
+        };
+        break;
+    }
+    return result;
+}