claude-inspect 0.5.1 → 0.7.1

package/README.de.md

@@ -41,7 +41,8 @@ beim Login und nach Abstürzen neu und läuft ohne Token (nur von localhost erre
 Manuell gestartet gibt `claude-inspect` eine URL mit Zufallstoken (`?t=…`) aus; der Browser merkt
 es sich als Cookie. `--token` für einen festen Token, `--no-auth` für keinen, `--port` für einen
 anderen Port, `CLAUDE_CONFIG_DIR=/pfad` für ein anderes Datenverzeichnis, `--no-cpu-log` ohne
-CPU-Protokoll, `CLAUDE_INSPECT_DATA_DIR=/pfad` für einen anderen Ablageort des CPU-Protokolls.
+CPU-Protokoll, `--no-analyze` ohne *Analyze with Claude*, `CLAUDE_INSPECT_DATA_DIR=/pfad` für einen
+anderen Ablageort von CPU-Protokoll und Analysen.
 
 Aus den Quellen: `git clone …`, `npm install`, `npm run build`, `npm start`
 (`npm run dev` + `npm run dev:web` für die Entwicklung mit Hot-Reload).
@@ -73,6 +74,25 @@ Aus den Quellen: `git clone …`, `npm install`, `npm run build`, `npm start`
   Windows `%LOCALAPPDATA%\claude-inspect\cpu`), damit der Verlauf nach Sessionende abrufbar bleibt.
   Dateien älter als 30 Tage werden gelöscht. Gemessen wird nur, solange claude-inspect läuft;
   Prozesse, die kürzer als 3 s leben, fehlen. Abschalten mit `--no-cpu-log`.
+- **Analyze with Claude**: Knopf auf jeder Session. Im Pop-up wählt man, worauf geachtet wird
+  (Auftrag erfüllt, Effizienz & Kosten, Fehler & Umwege, Datenschutz, Sicherheit & riskante
+  Aktionen, Agenten & Delegation, Setup-Verbesserungen), dazu optional eine eigene Frage, Modell
+  und Antwortsprache. claude-inspect baut einen kompakten Bericht über die Session samt Subagenten
+  und gestarteten Sitzungen (Anfragen, Antworten, jeder Tool-Aufruf mit Status, Dauer und Kosten,
+  dazu automatische Befunde wie wiederholte Fehler, mehrfach gelesene Dateien, Zugriffe auf
+  sensible Dateien, Uploads, riskante Befehle), maskiert Geheimnisse und lässt ihn vom lokalen
+  `claude -p` auswerten – ohne Tools, MCP-Server und Einstellungen, nicht als Session gespeichert.
+  Die Antwort erscheint live im Tab *Analysis* und wird im Datenverzeichnis (`reviews/`) abgelegt.
+  Läuft über die eigene Claude-Code-Anmeldung und zählt zum Abo-Verbrauch; *View what is sent*
+  zeigt den genauen Bericht. Das ist die einzige Funktion, die Daten verschickt, und nur auf Klick.
+  `--no-analyze` blendet den Knopf aus.
+- **Abo-Budget**: Kosten als geschätzter Anteil am Wochenlimit und am 5-Stunden-Fenster des Tarifs
+  (Max 20x, Max 5x, Pro). Der Tarif wird aus `~/.claude.json` erkannt (gelesen wird nur das
+  Rate-Limit-Tier) und lässt sich im Browser umstellen. Anthropic nennt keine Dollar- oder
+  Token-Grenzen; die Werte sind aus echten `/usage`-Messwerten gegen den im selben Zeitraum
+  angefallenen API-Gegenwert kalibriert. Max 5x/20x sind gemessen, Pro ist hochgerechnet.
+  Nachkalibrieren mit eigenen Daten (z. B. zusammen mit einer Kopie des `~/.claude` eines Servers):
+  siehe [Calibrating the plan budgets](https://github.com/brokoskokoli/claude_inspect/blob/main/CONTRIBUTING.md#calibrating-the-plan-budgets)
 - **Statistics**: API-Gegenwert (Schätzung nach Listenpreisen), Tokens je Modell/Tag/Projekt,
   Cache-Anteil, Aktivitäts-Heatmap, Tool-Statistik mit Fehlern und Dauer (p95)
 - **Tools**: alle Tool-Aufrufe aller Sessions, filterbar; Klick springt an die Stelle im Verlauf
@@ -114,7 +134,13 @@ Neue Dateiformate: siehe [docs/FORMATS.md](https://github.com/brokoskokoli/claud
 
 ## Speicher & Leistung
 
-Außer dem CPU-Log im eigenen Datenverzeichnis wird nichts auf Platte geschrieben. Beim Start liest der Server nur Prozess-, Job- und
+Außer CPU-Log und Analysen im eigenen Datenverzeichnis wird nichts auf Platte geschrieben. Beim Start liest der Server nur Prozess-, Job- und
 Kopfdaten (unter 1 s); die komplette History (hier ~600 MB) wird im Hintergrund in
 2–3 s aggregiert und danach nur noch inkrementell nachgeführt. Vollständige Verläufe
 werden erst beim Öffnen geladen und mit einer Obergrenze im Speicher gehalten.
+
+Solange ein Dashboard-Tab sichtbar ist, aktualisiert sich alles live (CPU alle 3 s). Ist kein Tab
+sichtbar (geschlossen oder 15 s im Hintergrund), wechselt der Server in einen Sparbetrieb:
+Prozessliste alle 30 s, CPU alle 15 s, alles andere alle 2 Minuten – etwa 1 % eines Kerns
+(gemessen mit ~1.600 Transcripts und mehreren laufenden Agenten). Beim Zurückwechseln wird sofort
+nachgeladen.

package/README.md

@@ -23,7 +23,8 @@ No Claude Code data at hand? `npx claude-inspect demo --open` starts it with a f
 Permanent install with autostart: see [Installation](#installation).
 
 It is **read-only and passive** towards `~/.claude`: no hooks, no settings changes, no proxy, no data leaves
-your machine. The only thing it writes is a CPU log in its own data directory (see *CPU usage*).
+your machine. The only things it writes go to its own data directory: a CPU log (see *CPU usage*) and the
+results of *Analyze with Claude* – the one feature that sends data, and only when you click it.
 
 > Website: [brokoskokoli.github.io/claude_inspect](https://brokoskokoli.github.io/claude_inspect/) · Deutsch: [README.de.md](https://github.com/brokoskokoli/claude_inspect/blob/main/README.de.md) · Design notes (German): [KONZEPT.md](https://github.com/brokoskokoli/claude_inspect/blob/main/KONZEPT.md) · [Contributing](https://github.com/brokoskokoli/claude_inspect/blob/main/CONTRIBUTING.md)
 
@@ -51,6 +52,8 @@ becomes hard to tell *who is doing what*. claude-inspect answers:
 | **Timeline** | One lane per agent, tool calls as bars, spawn links between lanes, idle gaps > 10 min collapsed, zoom. Click a bar to jump to the call. |
 | **Spawn linking** | Links sessions started by `claude -p …` to the calling tool use via the process tree (exact), `--session-id`, prompt text, `--agent`, time window and working directory – with a confidence label. |
 | **Cost per agent tree** | Cost tab per session: API list-price estimate for the main agent plus all its subagents and spawned `claude` sessions, per agent and per model with input, output and cache tokens, plus a cost timeline with the most expensive moments. |
+| **Plan budget** | Cost as an estimated share of your plan's weekly limit and 5-hour window (Max 20x, Max 5x, Pro). The plan is detected from `~/.claude.json` (only the rate-limit tier is read) and can be changed in the browser. Anthropic publishes no dollar or token limits; the values are calibrated from real `/usage` readings against the API equivalent spent in the same time – to recalibrate with your own data (e.g. including a server's copy of `~/.claude`), see [Calibrating the plan budgets](https://github.com/brokoskokoli/claude_inspect/blob/main/CONTRIBUTING.md#calibrating-the-plan-budgets). Max 5x/20x are measured, Pro is extrapolated. |
+| **Analyze with Claude** | Button on every session: pick what to check – task outcome, efficiency & cost, errors & dead ends, privacy & data protection, security & risky actions, agents & delegation, setup improvements – plus an optional own question, model and answer language. claude-inspect builds a condensed digest of the session and all its subagents and spawned sessions (requests, answers, every tool call with status, duration and cost, plus computed observations such as repeated failures, repeated reads, access to sensitive files, uploads and risky commands), masks secrets, and runs your local `claude -p` on it – no tools, no MCP servers, no settings, not saved as a session. The answer streams into the *Analysis* tab and is stored in the data directory (`reviews/`). It runs on your own Claude Code login and counts towards your plan usage; *View what is sent* shows the exact digest. `--no-analyze` removes the button. |
 | **Statistics** | API list-price estimate, tokens per model/day/project, cache share, activity heatmap, tool statistics with error rate and p95 duration. |
 | **CPU usage** | CPU of each Claude Code process plus all its subprocesses (shells, builds, test runners, MCP servers …), measured every 3 s from the process table. Sparkline on the dashboard card, a *CPU* tab per session with a stacked chart by process name and the processes that used the most CPU time. Recorded as one CSV per session in the app data directory (`~/Library/Application Support/claude-inspect/cpu` on macOS, `~/.local/share/claude-inspect/cpu` on Linux, `%LOCALAPPDATA%\claude-inspect\cpu` on Windows), so it stays available after the session ended; files older than 30 days are deleted. Only measured while claude-inspect runs; processes that live less than 3 s are missed. `--no-cpu-log` turns recording off. |
 | **Tool explorer & files** | Every tool call across all sessions, filterable; which files agents read, edited or wrote. |
@@ -105,7 +108,7 @@ After `npm install -g claude-inspect@latest`, run `claude-inspect service instal
 Started manually, `claude-inspect` prints a URL with a random access token (`?t=…`) that the browser
 keeps as a cookie. Use `--token <t>` for a fixed token or `--no-auth` for none, `--port` for another port,
 `CLAUDE_CONFIG_DIR=/path/to/.claude` for another data directory, `--no-cpu-log` to not record CPU usage,
-`CLAUDE_INSPECT_DATA_DIR=/path` for another place for the CPU log. `claude-inspect --help` lists everything.
+`--no-analyze` to hide *Analyze with Claude*, `CLAUDE_INSPECT_DATA_DIR=/path` for another place for the CPU log and analyses. `claude-inspect --help` lists everything.
 
 ### Try it without your own data
 
@@ -142,6 +145,7 @@ FormatRegistry → versioned decoders → normalized model → REST + SSE → Sv
 
 - **Per-record format detection:** every decoder scores a record (`type`, version range, structure); the best one wins, a fallback keeps unknown records. Adding support for a new Claude Code version = adding a decoder file. See [docs/FORMATS.md](https://github.com/brokoskokoli/claude_inspect/blob/main/docs/FORMATS.md).
 - **In memory only:** startup reads process/job data and file heads (< 1 s); the full history (hundreds of MB) is aggregated in the background in a few seconds and then followed incrementally.
+- **Light in the background:** while a dashboard tab is visible, it updates live (CPU every 3 s). With no visible tab (closed or in the background for 15 s) it switches to a saving mode – process list every 30 s, CPU every 15 s, everything else every 2 minutes – and uses about 1 % of one core (measured with ~1,600 transcripts and several agents running). Switching back to the tab catches up immediately.
 - **Privacy & security:** listens on `127.0.0.1` only (never reachable from the network), rejects requests whose `Host` header isn't `localhost`/`127.0.0.1` (DNS rebinding), sends no CORS headers (other websites in your browser can't read the API), is read-only towards `~/.claude` (the CPU log goes to its own data directory and contains only timestamps, PIDs, program names and CPU percentages – no command lines), never reads credential files (`*.key`, `daemon/auth`, `ide/*.lock`, …) and masks token/secret fields in the raw view. The access token is an extra layer against *other local processes or users* on the same machine; on a single-user machine `--no-auth` (used by the autostart service) is a reasonable trade-off. Cost figures are estimates from public API list prices – with a subscription you do not pay these amounts directly.
 
 ## Development

package/dist/app/server/cli/demo.js

@@ -360,6 +360,8 @@ export async function runDemo(opts) {
     sessionFile(docsProc.pid, { sessionId: s.docsId, cwd: s.DOCS, startedAt: s.docs.o.start, kind: 'interactive', entrypoint: 'cli', name: 'docs', nameSource: 'user', status: 'idle' });
     console.log(`Demo data in ${ROOT}`);
     // config.ts reads CLAUDE_CONFIG_DIR on import – set it before loading the server
+    // "Analyze with Claude" starts the real claude – it needs the user's own config dir (login)
+    process.env.CLAUDE_INSPECT_CLAUDE_CONFIG_DIR = process.env.CLAUDE_CONFIG_DIR ?? '';
     process.env.CLAUDE_CONFIG_DIR = ROOT;
     process.env.CLAUDE_INSPECT_DATA_DIR = `${ROOT}-data`;
     demoCpu(`${ROOT}-data`, s);

package/dist/app/server/cli.js

@@ -41,12 +41,14 @@ Options:
   --token <t>      fixed access token instead of a random one      env: CLAUDE_INSPECT_TOKEN
   --no-auth        no token (still only reachable from localhost)  env: CLAUDE_INSPECT_NO_AUTH=1
   --no-cpu-log     don't record CPU usage to the data directory     env: CLAUDE_INSPECT_NO_CPU_LOG=1
+  --no-analyze     hide "Analyze with Claude" (never runs claude)   env: CLAUDE_INSPECT_NO_ANALYZE=1
   --out <dir>      demo: only write the demo data to <dir>
   -v, --version    print the version
   -h, --help       show this help
 
 Data directory: $CLAUDE_CONFIG_DIR or ~/.claude (read only)
-CPU log:        $CLAUDE_INSPECT_DATA_DIR/cpu (default: the platform's app data directory)`;
+CPU log:        $CLAUDE_INSPECT_DATA_DIR/cpu (default: the platform's app data directory)
+Analyses:       $CLAUDE_INSPECT_DATA_DIR/reviews`;
 const { values, positionals } = parseArgs({
     allowPositionals: true,
     options: {
@@ -56,6 +58,7 @@ const { values, positionals } = parseArgs({
         token: { type: 'string', default: env.CLAUDE_INSPECT_TOKEN },
         'no-auth': { type: 'boolean', default: env.CLAUDE_INSPECT_NO_AUTH === '1' },
         'no-cpu-log': { type: 'boolean', default: env.CLAUDE_INSPECT_NO_CPU_LOG === '1' },
+        'no-analyze': { type: 'boolean', default: env.CLAUDE_INSPECT_NO_ANALYZE === '1' },
         out: { type: 'string' },
         help: { type: 'boolean', short: 'h', default: false },
         version: { type: 'boolean', short: 'v', default: false },
@@ -79,7 +82,7 @@ else if (cmd === 'demo') {
 }
 else if (cmd === undefined) {
     const { runServer } = await import('./run.js');
-    await runServer({ port: port(7717), open: values.open, dev: values.dev, noAuth: values['no-auth'], token: values.token, noCpuLog: values['no-cpu-log'] });
+    await runServer({ port: port(7717), open: values.open, dev: values.dev, noAuth: values['no-auth'], token: values.token, noCpuLog: values['no-cpu-log'], noAnalyze: values['no-analyze'] });
 }
 else {
     console.error(`Unknown command "${cmd}".\n\n${HELP}`);

package/dist/app/server/config.js

@@ -14,6 +14,8 @@ function defaultDataDir() {
  * (CPU-Messwerte). ~/.claude wird nie verändert.
  */
 export const DATA_DIR = process.env.CLAUDE_INSPECT_DATA_DIR || defaultDataDir();
+/** Globale Claude-Code-Konfiguration (Konto, Tarif). Liegt neben, nicht in ~/.claude. */
+export const CLAUDE_JSON = process.env.CLAUDE_CONFIG_DIR ? join(process.env.CLAUDE_CONFIG_DIR, '.claude.json') : join(homedir(), '.claude.json');
 export const paths = {
     projects: join(CLAUDE_DIR, 'projects'),
     sessions: join(CLAUDE_DIR, 'sessions'),

package/dist/app/server/cpu-monitor.js

@@ -14,13 +14,20 @@ const MIN_PCT = 1;
 const IDLE_WRITE_MS = 30_000;
 /** Dateien, die so lange nicht mehr geschrieben wurden, werden gelöscht (wie Claude Codes eigene Aufräumfrist). */
 const RETENTION_MS = 30 * 24 * 3600_000;
+/**
+ * Messabstand im Sparbetrieb (kein Tab offen). Gemessen wird verbrauchte CPU-Zeit, längere
+ * Abstände liefern also korrekte Mittelwerte – nur gröber. Spart vor allem die ps-Aufrufe.
+ */
+const IDLE_INTERVAL_MS = 15_000;
 /**
  * Misst in festen Abständen die CPU-Auslastung jedes Claude-Prozesses samt Unterprozessen.
  * Liest die Prozesstabelle (ps bzw. /proc), schreibt nur ins eigene Datenverzeichnis.
  */
 export class CpuMonitor {
     opts;
+    /** Messabstand bei offenem Tab */
     intervalMs = process.platform === 'win32' ? 10_000 : 3_000;
+    currentMs = Math.max(IDLE_INTERVAL_MS, this.intervalMs);
     dir = join(DATA_DIR, 'cpu');
     cores = availableParallelism();
     prev;
@@ -40,13 +47,26 @@ export class CpuMonitor {
     }
     start() {
         void this.tick();
-        this.timer = setInterval(() => void this.tick(), this.intervalMs);
+        this.timer = setInterval(() => void this.tick(), this.currentMs);
         if (this.opts.log) {
             void this.cleanup();
             this.cleanupTimer = setInterval(() => void this.cleanup(), 6 * 3600_000);
             this.cleanupTimer.unref();
         }
     }
+    /** Sparbetrieb ein/aus (kein Tab offen → seltener messen) */
+    setIdle(idle) {
+        const ms = idle ? Math.max(IDLE_INTERVAL_MS, this.intervalMs) : this.intervalMs;
+        if (ms === this.currentMs)
+            return;
+        this.currentMs = ms;
+        if (!this.timer)
+            return;
+        clearInterval(this.timer);
+        if (!idle)
+            void this.tick();
+        this.timer = setInterval(() => void this.tick(), ms);
+    }
     stop() {
         clearInterval(this.timer);
         clearInterval(this.cleanupTimer);
@@ -137,7 +157,7 @@ export class CpuMonitor {
                 continue;
             sessions[id] = { pct: sampleTotal(last), spark: b.samples.slice(-SPARK_POINTS).map(sampleTotal) };
         }
-        return { t: this.lastT, intervalMs: this.intervalMs, cores: this.cores, sessions };
+        return { t: this.lastT, intervalMs: this.currentMs, cores: this.cores, sessions };
     }
     async history(sessionId) {
         let samples = [];
@@ -153,7 +173,7 @@ export class CpuMonitor {
         // Messungen, die (noch) nicht in der Datei stehen, aus dem Speicher ergänzen
         const lastT = samples[samples.length - 1]?.t ?? 0;
         samples.push(...(this.buffers.get(sessionId)?.samples.filter((s) => s.t > lastT) ?? []));
-        const h = cpuHistory(samples, { intervalMs: this.intervalMs, gapMs: IDLE_WRITE_MS + 5 * this.intervalMs });
+        const h = cpuHistory(samples, { intervalMs: this.intervalMs, gapMs: IDLE_WRITE_MS + 5 * this.intervalMs, maxStepMs: 2 * IDLE_INTERVAL_MS });
         return { sessionId, logging: this.opts.log, file: samples.length ? file : undefined, cores: this.cores, ...h };
     }
 }

package/dist/app/server/history/aggregator.js

@@ -32,18 +32,22 @@ export class HistoryIndex {
      */
     async refresh(transcripts, projectOf, full) {
         const seen = new Set();
+        // Sessions ohne Änderung in der letzten Stunde: Subagenten nicht neu einlesen, nur behalten
+        const untouched = new Set();
         for (const f of transcripts) {
             const project = await projectOf(f);
             seen.add(f.path);
             await this.scan(f.path, f.size, f.sessionId, undefined, project);
             if (!full && Date.now() - f.mtime > 3600_000) {
-                for (const p of this.files.keys())
-                    if (p.startsWith(subagentDir(f.path)))
-                        seen.add(p);
+                untouched.add(f.sessionId);
                 continue;
             }
             await this.scanSubagents(f, project, seen);
         }
+        // ein Durchgang statt Sessions × Dateien (war bei ~1.500 Sessions der größte CPU-Verbraucher)
+        for (const [p, a] of this.files)
+            if (a.agentId && untouched.has(a.sessionId))
+                seen.add(p);
         // Von Claude Code aufgeräumte Dateien vergessen
         for (const p of [...this.files.keys()])
             if (!seen.has(p))

package/dist/app/server/http.js

@@ -66,6 +66,43 @@ export function startServer(inspector, opts) {
         res.writeHead(200, { 'content-type': MIME[extname(file)] ?? 'application/octet-stream' });
         createReadStream(file).pipe(res);
     }
+    /**
+     * Die einzigen schreibenden Aufrufe: Analyse starten/abbrechen. Nur mit JSON-Body (erzwingt bei
+     * fremden Seiten einen CORS-Preflight, den der Server nie erlaubt) und lokalem Origin.
+     */
+    async function post(req, res, p) {
+        const origin = req.headers.origin;
+        if (origin && !/^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d+)?$/.test(origin))
+            return json(res, 403, { error: 'origin not allowed' });
+        if (!(req.headers['content-type'] ?? '').startsWith('application/json'))
+            return json(res, 415, { error: 'JSON expected' });
+        let raw = '';
+        for await (const c of req) {
+            raw += c;
+            if (raw.length > 100_000)
+                return json(res, 413, { error: 'too large' });
+        }
+        let body;
+        try {
+            body = JSON.parse(raw || '{}');
+        }
+        catch {
+            return json(res, 400, { error: 'invalid JSON' });
+        }
+        let m = /^\/api\/review\/([\w-]+)$/.exec(p);
+        if (m) {
+            try {
+                return json(res, 200, await inspector.startReview(m[1], body));
+            }
+            catch (e) {
+                return json(res, 400, { error: e.message });
+            }
+        }
+        m = /^\/api\/review-cancel\/([\w-]+)$/.exec(p);
+        if (m)
+            return json(res, 200, { cancelled: inspector.reviewer?.cancel(m[1]) ?? false });
+        return json(res, 405, { error: 'read-only' });
+    }
     const server = createServer(async (req, res) => {
         try {
             const url = new URL(req.url ?? '/', 'http://localhost');
@@ -81,6 +118,8 @@ export function startServer(inspector, opts) {
                 res.setHeader('set-cookie', `${COOKIE}=${token}; HttpOnly; SameSite=Strict; Path=/; Max-Age=31536000`);
             }
             const p = url.pathname;
+            if (req.method === 'POST')
+                return await post(req, res, p);
             if (req.method !== 'GET')
                 return json(res, 405, { error: 'read-only' });
             if (p === '/api/dashboard')
@@ -90,7 +129,11 @@ export function startServer(inspector, opts) {
                 res.write(`event: dashboard\ndata: ${JSON.stringify(await inspector.getDashboard())}\n\n`);
                 res.write(`event: cpu\ndata: ${JSON.stringify(inspector.cpuSnapshot())}\n\n`);
                 sseClients.add(res);
-                req.on('close', () => sseClients.delete(res));
+                inspector.setViewers(sseClients.size);
+                req.on('close', () => {
+                    sseClients.delete(res);
+                    inspector.setViewers(sseClients.size);
+                });
                 return;
             }
             if (p === '/api/sessions') {
@@ -160,6 +203,19 @@ export function startServer(inspector, opts) {
                 const cost = await inspector.sessionCost(m[1]);
                 return cost ? json(res, 200, cost) : json(res, 404, { error: 'unknown session' });
             }
+            m = /^\/api\/review\/([\w-]+)$/.exec(p);
+            if (m) {
+                const st = await inspector.reviewState(m[1]);
+                return st ? json(res, 200, st) : json(res, 404, { error: 'unknown session' });
+            }
+            m = /^\/api\/review\/([\w-]+)\/digest$/.exec(p);
+            if (m) {
+                const d = await inspector.reviewDigest(m[1]);
+                if (!d)
+                    return json(res, 404, { error: 'unknown session' });
+                res.writeHead(200, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' });
+                return res.end(d.text);
+            }
             m = /^\/api\/flow\/([\w-]+)$/.exec(p);
             if (m) {
                 const flow = await inspector.flow(m[1]);

package/dist/app/server/inspector.js

@@ -2,7 +2,9 @@ import { EventEmitter } from 'node:events';
 import { watch } from 'node:fs';
 import { stat } from 'node:fs/promises';
 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';
@@ -10,6 +12,7 @@ import { emptyTotals, estimateCost, mergeTotals } from '../shared/pricing.js';
 import { search } from './history/search.js';
 import { analyze } from './model/analyze.js';
 import { laneData } from './model/flow.js';
+import { readPlan } from './sources/plan.js';
 import { readTasks } from './sources/tasks.js';
 import { readJobs } from './sources/jobs.js';
 import { readProcesses } from './sources/processes.js';
@@ -32,6 +35,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();
@@ -41,6 +47,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));
@@ -55,8 +68,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])),
@@ -90,7 +107,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() {
@@ -99,6 +116,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/'))
@@ -107,7 +146,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);
             }
@@ -115,7 +155,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);
@@ -126,6 +168,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);
@@ -160,9 +216,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);
@@ -184,8 +244,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;
     }
     // -------------------------------------------------------------------------
@@ -219,7 +282,7 @@ export class Inspector extends EventEmitter {
             const s = await this.index.summary(f);
             recentSessions.push({ ...s, live: liveIds.has(s.sessionId), spawnedBy: this.spawns.parentOf(s.sessionId)?.parentSessionId });
         }
-        return { generatedAt: Date.now(), claudeDir: CLAUDE_DIR, platform: process.platform, processes, orphanJobs, recentSessions };
+        return { generatedAt: Date.now(), claudeDir: CLAUDE_DIR, platform: process.platform, processes, orphanJobs, recentSessions, plan: await readPlan() };
     }
     async sessionLive(sessionId, p) {
         const f = this.index.get(sessionId);
@@ -575,6 +638,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);