claude-inspect 0.1.0

package/dist/app/server/inspector.js

@@ -0,0 +1,468 @@
+import { EventEmitter } from 'node:events';
+import { watch } from 'node:fs';
+import { stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { CLAUDE_DIR, relToClaude } from './config.js';
+import { registry } from './formats/index.js';
+import { HistoryIndex } from './history/aggregator.js';
+import { search } from './history/search.js';
+import { analyze } from './model/analyze.js';
+import { laneData } from './model/flow.js';
+import { readTasks } from './sources/tasks.js';
+import { readJobs } from './sources/jobs.js';
+import { readProcesses } from './sources/processes.js';
+import { ProjectIndex } from './sources/projects.js';
+import { SpawnIndex } from './sources/spawns.js';
+import { agentCallIds, listSubagents } from './sources/subagents.js';
+import { TranscriptStore } from './sources/transcripts.js';
+/** Subagenten, deren Datei so lange unverändert ist, gelten ohne Abschluss als "stale". */
+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;
+export class Inspector extends EventEmitter {
+    index = new ProjectIndex();
+    store = new TranscriptStore();
+    /** Verknüpfung per Bash gestarteter claude-Sitzungen mit ihrem Aufrufer. */
+    spawns = new SpawnIndex();
+    spawnsReady = false;
+    /** Aggregierte History (Tokens, Kosten, Tool-Aufrufe, Dateien) – nur im Speicher. */
+    history = new HistoryIndex();
+    historyReady = false;
+    historyReadyResolve;
+    /** Erfüllt, sobald der erste History-Scan durch ist (API-Aufrufe warten darauf). */
+    historyLoaded = new Promise((r) => (this.historyReadyResolve = r));
+    processes = [];
+    jobs = [];
+    dashboard;
+    dashboardJson = '';
+    watcher;
+    dirty = { processes: true, jobs: true, index: false, dashboard: true };
+    timer;
+    poller;
+    building;
+    async start() {
+        await this.index.scan();
+        await this.rebuild();
+        // Erster Komplettscan nach claude-Aufrufen läuft im Hintergrund, damit der Start schnell bleibt.
+        void this.spawns
+            .refresh(this.index.list(), this.processes, true)
+            .then(() => {
+            this.spawnsReady = true;
+            this.schedule(0);
+            return this.history.refresh(this.index.list(), this.projectOf, true);
+        })
+            .then(() => {
+            this.historyReady = true;
+            this.historyReadyResolve();
+        });
+        try {
+            // macOS/Windows: rekursives Watching nativ. Linux (Node ≥ 20): ebenfalls unterstützt.
+            this.watcher = watch(CLAUDE_DIR, { recursive: true }, (_ev, filename) => {
+                if (filename)
+                    this.onFsEvent(join(CLAUDE_DIR, filename.toString()));
+            });
+            this.watcher.on('error', () => undefined);
+        }
+        catch {
+            /* Fallback: nur Polling */
+        }
+        // Polling als Netz: Prozess-Liveness (kein Datei-Event beim Absturz) und verpasste Events.
+        this.poller = setInterval(() => void this.poll(), 3000);
+    }
+    stop() {
+        this.watcher?.close();
+        clearInterval(this.poller);
+        clearTimeout(this.timer);
+    }
+    onFsEvent(abs) {
+        const rel = relToClaude(abs);
+        if (rel.startsWith('sessions/'))
+            this.dirty.processes = true;
+        else if (rel.startsWith('jobs/') || rel.startsWith('daemon/'))
+            this.dirty.jobs = true;
+        else if (rel.startsWith('projects/')) {
+            if (rel.endsWith('.jsonl')) {
+                void this.onTranscriptChanged(abs);
+                if (!rel.includes('/subagents/'))
+                    void this.index.touch(abs);
+            }
+            this.dirty.dashboard = true;
+        }
+        else
+            return;
+        this.schedule();
+    }
+    async onTranscriptChanged(path) {
+        const r = await this.store.refreshIfLoaded(path);
+        if (r)
+            this.emitTranscript(r.transcript);
+    }
+    emitTranscript(t) {
+        this.emit('event', { type: 'transcript', data: { sessionId: t.sessionId, agentId: t.agentId, total: t.entries.length } });
+    }
+    async poll() {
+        for (const t of this.store.all()) {
+            try {
+                const st = await stat(t.path);
+                if (st.size !== t.bytes)
+                    await this.onTranscriptChanged(t.path);
+            }
+            catch {
+                /* gelöscht */
+            }
+        }
+        this.dirty.processes = true;
+        this.dirty.jobs = true;
+        this.schedule(0);
+    }
+    schedule(delay = 250) {
+        clearTimeout(this.timer);
+        this.timer = setTimeout(() => void this.rebuild(), delay);
+    }
+    async rebuild() {
+        if (this.building) {
+            this.schedule();
+            return;
+        }
+        this.building = (async () => {
+            if (this.dirty.processes) {
+                this.dirty.processes = false;
+                this.processes = await readProcesses();
+            }
+            if (this.dirty.jobs) {
+                this.dirty.jobs = false;
+                this.jobs = await readJobs();
+            }
+            if (this.spawnsReady)
+                await this.spawns.refresh(this.index.list(), this.processes, false);
+            if (this.historyReady)
+                await this.history.refresh(this.index.list(), this.projectOf, false);
+            this.dirty.dashboard = false;
+            const d = await this.buildDashboard();
+            const { generatedAt: _g, ...cmp } = d;
+            const json = JSON.stringify(cmp);
+            this.dashboard = d;
+            if (json !== this.dashboardJson) {
+                this.dashboardJson = json;
+                this.emit('event', { type: 'dashboard', data: d });
+            }
+        })().finally(() => (this.building = undefined));
+        await this.building;
+    }
+    async getDashboard() {
+        if (!this.dashboard)
+            await this.rebuild();
+        return this.dashboard;
+    }
+    // -------------------------------------------------------------------------
+    jobFor(p) {
+        return this.jobs.find((j) => j.short === p.jobId) ?? this.jobs.find((j) => j.short === p.parkedJobId);
+    }
+    async buildDashboard() {
+        const procs = [...this.processes].sort((a, b) => Number(b.alive) - Number(a.alive) || (b.updatedAt ?? b.startedAt ?? 0) - (a.updatedAt ?? a.startedAt ?? 0));
+        const processes = [];
+        for (const p of procs) {
+            const dp = { process: p, job: this.jobFor(p), spawnedBy: await this.spawnParent(p.sessionId) };
+            if (p.alive) {
+                try {
+                    dp.session = await this.sessionLive(p.sessionId, p);
+                }
+                catch {
+                    /* Transcript nicht lesbar */
+                }
+            }
+            processes.push(dp);
+        }
+        const usedJobs = new Set(processes.flatMap((p) => [p.process.jobId, p.process.parkedJobId]).filter(Boolean));
+        const orphanJobs = this.jobs.filter((j) => !usedJobs.has(j.short)).sort((a, b) => (b.updatedAt ?? '').localeCompare(a.updatedAt ?? ''));
+        const liveIds = new Set(processes.filter((p) => p.process.alive).map((p) => p.process.sessionId));
+        const recentSessions = [];
+        for (const f of this.index.list().slice(0, 25)) {
+            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, processes, orphanJobs, recentSessions };
+    }
+    async sessionLive(sessionId, p) {
+        const f = this.index.get(sessionId);
+        if (!f)
+            return undefined;
+        const t = await this.store.get(f.path, sessionId);
+        const a = analyze(t.entries);
+        const busy = p.status !== 'idle';
+        const subFiles = await listSubagents(f.path);
+        const recent = subFiles.filter((s) => Date.now() - s.mtime < SUBAGENT_DASHBOARD_MS);
+        const subagents = await this.resolveSubagents(f.path, recent, true);
+        let current = a.current;
+        if (!busy && current && current.kind !== 'error')
+            current = { kind: 'idle', label: current.kind === 'idle' ? current.label : 'waiting for input', since: current.since };
+        return {
+            sessionId,
+            title: a.title,
+            model: a.model,
+            effort: a.effort,
+            permissionMode: a.permissionMode,
+            gitBranch: (await this.index.summary(f)).gitBranch,
+            lastActivityAt: a.lastActivityAt,
+            contextTokens: a.contextTokens,
+            outputTokens: a.outputTokens,
+            toolCalls: a.toolCalls,
+            current,
+            pendingTools: busy ? a.pendingTools : [],
+            subagents,
+            subagentTotal: subFiles.length,
+            costUSD: a.costUSD,
+            lastPrompt: a.lastPrompt,
+            spawned: await this.spawnedSessions(sessionId),
+        };
+    }
+    async spawnParent(sessionId) {
+        const link = this.spawns.parentOf(sessionId);
+        if (!link)
+            return undefined;
+        const pf = this.index.get(link.parentSessionId);
+        const proc = this.processes.find((p) => p.alive && p.sessionId === link.parentSessionId);
+        return { ...link, parentTitle: proc?.name ?? (pf ? (await this.index.summary(pf)).title : undefined) };
+    }
+    /** Von einer Session per `claude`-Aufruf gestartete Sitzungen mit Status. */
+    async spawnedSessions(parentSessionId) {
+        const out = [];
+        for (const link of this.spawns.childrenOf(parentSessionId)) {
+            const f = this.index.get(link.childSessionId);
+            if (!f)
+                continue;
+            const proc = this.processes.find((p) => p.alive && p.sessionId === link.childSessionId);
+            const child = this.spawns.childInfo(link.childSessionId);
+            const s = {
+                ...link,
+                agent: proc?.agent ?? child?.agentSetting,
+                pid: proc?.pid,
+                status: proc ? (proc.status === 'idle' ? 'idle' : 'running') : 'done',
+            };
+            if (proc) {
+                const a = analyze((await this.store.get(f.path, link.childSessionId)).entries);
+                Object.assign(s, { title: a.title, model: a.model, lastActivityAt: a.lastActivityAt, current: a.current });
+                if (a.finished && proc.status === 'idle')
+                    s.status = 'idle';
+            }
+            else {
+                const sum = await this.index.summary(f);
+                Object.assign(s, { title: sum.title, model: sum.model, lastActivityAt: sum.lastTimestamp });
+            }
+            // Ohne Titel (z. B. `claude -p "/usage"`): erste Zeile des Auftrags anzeigen
+            s.title ??= child?.prompt?.split('\n', 1)[0].slice(0, 120);
+            out.push(s);
+        }
+        return out.sort((a, b) => (a.lastActivityAt ?? '').localeCompare(b.lastActivityAt ?? ''));
+    }
+    /**
+     * Baut SubagentInfo inkl. Eltern-Zuordnung. `load` = Transcripts laden, um
+     * Status und aktuelle Aktivität zu bestimmen (für Dashboard und Detailansicht).
+     */
+    async resolveSubagents(sessionPath, files, load) {
+        const sessionId = sessionPath.replace(/^.*\//, '').replace(/\.jsonl$/, '');
+        const out = [];
+        for (const sf of files) {
+            const info = {
+                agentId: sf.agentId,
+                ...sf.meta,
+                status: 'stale',
+                lastActivityAt: new Date(sf.mtime).toISOString(),
+            };
+            if (load) {
+                const t = await this.store.get(sf.path, sessionId, sf.agentId);
+                const a = analyze(t.entries);
+                const fresh = Date.now() - sf.mtime < SUBAGENT_STALE_MS;
+                info.status = a.errored ? 'error' : a.finished ? 'done' : fresh ? 'running' : 'stale';
+                info.model = a.model;
+                info.current = info.status === 'running' ? a.current : null;
+                info.toolCalls = a.toolCalls;
+                info.outputTokens = a.outputTokens;
+                info.lastActivityAt = a.lastActivityAt ?? info.lastActivityAt;
+                if (!info.description)
+                    info.description = a.title;
+            }
+            out.push(info);
+        }
+        // Eltern: Tiefe 1 → Hauptagent. Tiefer: der Subagent, dessen Datei den Agent-Aufruf enthält.
+        const all = files.length && out.some((s) => (s.spawnDepth ?? 1) > 1) ? await listSubagents(sessionPath) : [];
+        for (const s of out) {
+            if ((s.spawnDepth ?? 1) <= 1 || !s.toolUseId)
+                continue;
+            for (const cand of all) {
+                if (cand.agentId === s.agentId)
+                    continue;
+                if ((await agentCallIds(cand.path, cand.size)).has(s.toolUseId)) {
+                    s.parentAgentId = cand.agentId;
+                    break;
+                }
+            }
+        }
+        return out.sort((a, b) => (a.lastActivityAt ?? '').localeCompare(b.lastActivityAt ?? ''));
+    }
+    // -------------------------------------------------------------------------
+    // API
+    async sessions(offset, limit, q) {
+        let files = this.index.list();
+        const liveIds = new Set(this.processes.filter((p) => p.alive).map((p) => p.sessionId));
+        if (q) {
+            const needle = q.toLowerCase();
+            const matches = [];
+            for (const f of files) {
+                const s = await this.index.summary(f);
+                if ([s.project, s.title, s.lastPrompt, s.sessionId, s.cwd].some((x) => x?.toLowerCase().includes(needle)))
+                    matches.push(s);
+            }
+            return {
+                total: matches.length,
+                items: matches.slice(offset, offset + limit).map((s) => ({ ...s, live: liveIds.has(s.sessionId), spawnedBy: this.spawns.parentOf(s.sessionId)?.parentSessionId })),
+            };
+        }
+        const total = files.length;
+        files = files.slice(offset, offset + limit);
+        const items = await Promise.all(files.map(async (f) => ({ ...(await this.index.summary(f)), live: liveIds.has(f.sessionId), spawnedBy: this.spawns.parentOf(f.sessionId)?.parentSessionId })));
+        return { total, items };
+    }
+    async sessionDetail(sessionId) {
+        const f = this.index.get(sessionId);
+        if (!f)
+            return undefined;
+        const summary = await this.index.summary(f);
+        const files = await listSubagents(f.path);
+        // Status aller Subagenten braucht deren Inhalt; kleine Dateien, daher vertretbar.
+        const subagents = await this.resolveSubagents(f.path, files, true);
+        const process = this.processes.find((p) => p.sessionId === sessionId && p.alive) ?? this.processes.find((p) => p.sessionId === sessionId);
+        const job = process ? this.jobFor(process) : this.jobs.find((j) => j.sessionId === sessionId || j.resumeSessionId === sessionId);
+        return {
+            summary: { ...summary, live: !!process?.alive },
+            subagents,
+            spawned: await this.spawnedSessions(sessionId),
+            spawnedBy: await this.spawnParent(sessionId),
+            tasks: await readTasks(sessionId),
+            process,
+            job,
+        };
+    }
+    async transcriptFor(sessionId, agentId) {
+        const f = this.index.get(sessionId);
+        if (!f)
+            return undefined;
+        if (!agentId)
+            return this.store.get(f.path, sessionId);
+        const sub = (await listSubagents(f.path)).find((s) => s.agentId === agentId);
+        return sub ? this.store.get(sub.path, sessionId, agentId) : undefined;
+    }
+    async transcript(sessionId, agentId, from) {
+        const t = await this.transcriptFor(sessionId, agentId);
+        if (!t)
+            return undefined;
+        return { sessionId, agentId, entries: t.entries.slice(from), total: t.entries.length, from };
+    }
+    async rawLine(sessionId, agentId, line) {
+        const t = await this.transcriptFor(sessionId, agentId);
+        return t?.rawLine(line);
+    }
+    projectOf = async (f) => (await this.index.summary(f)).project;
+    async historyStats(filter) {
+        await this.historyLoaded;
+        return this.history.stats(filter);
+    }
+    async toolCalls(q) {
+        await this.historyLoaded;
+        return this.history.toolCalls(q);
+    }
+    async fileStats(filter) {
+        await this.historyLoaded;
+        return this.history.fileStats(filter);
+    }
+    async historyProjects() {
+        await this.historyLoaded;
+        return this.history.projects();
+    }
+    async search(q) {
+        const files = [];
+        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 });
+            }
+        }
+        return search(q, files, new Set(this.index.list().map((f) => f.sessionId)));
+    }
+    /**
+     * Ablauf einer Session für Zeitleiste und Graph: Hauptagent, Subagenten
+     * (verschachtelt) und per claude-Aufruf gestartete Sitzungen (rekursiv).
+     */
+    async flow(rootSessionId) {
+        const rootFile = this.index.get(rootSessionId);
+        if (!rootFile)
+            return undefined;
+        const lanes = [];
+        const visited = new Set();
+        const addSession = async (f, kind, depth, parent) => {
+            if (visited.has(f.sessionId) || depth > 6)
+                return;
+            visited.add(f.sessionId);
+            const t = await this.store.get(f.path, f.sessionId);
+            const a = analyze(t.entries);
+            const sum = await this.index.summary(f);
+            const proc = this.processes.find((p) => p.alive && p.sessionId === f.sessionId);
+            const mainId = f.sessionId;
+            lanes.push({
+                id: mainId,
+                sessionId: f.sessionId,
+                kind,
+                label: proc?.name ?? sum.title ?? this.spawns.childInfo(f.sessionId)?.prompt?.split('\n', 1)[0].slice(0, 80) ?? f.sessionId.slice(0, 8),
+                sublabel: kind === 'spawn' ? (this.spawns.childInfo(f.sessionId)?.agentSetting ?? 'claude') : sum.project,
+                parentId: parent?.id,
+                viaToolUseId: parent?.via,
+                confidence: parent?.confidence,
+                depth,
+                status: proc ? (proc.status === 'idle' ? 'idle' : 'running') : a.errored ? 'error' : 'done',
+                ...laneData(t.entries),
+            });
+            const subFiles = await listSubagents(f.path);
+            const subs = await this.resolveSubagents(f.path, subFiles, true);
+            const subIds = new Set(subs.map((x) => x.agentId));
+            const depthOf = (x) => (x.spawnDepth ?? 1);
+            for (const sub of [...subs].sort((x, y) => depthOf(x) - depthOf(y))) {
+                const sf = subFiles.find((x) => x.agentId === sub.agentId);
+                const st = await this.store.get(sf.path, f.sessionId, sub.agentId);
+                lanes.push({
+                    id: `${f.sessionId}/${sub.agentId}`,
+                    sessionId: f.sessionId,
+                    agentId: sub.agentId,
+                    kind: 'subagent',
+                    label: sub.agentType ?? 'agent',
+                    sublabel: sub.description,
+                    parentId: sub.parentAgentId && subIds.has(sub.parentAgentId) ? `${f.sessionId}/${sub.parentAgentId}` : mainId,
+                    viaToolUseId: sub.toolUseId,
+                    depth: depth + depthOf(sub),
+                    status: sub.status,
+                    ...laneData(st.entries),
+                });
+            }
+            for (const link of this.spawns.childrenOf(f.sessionId)) {
+                const cf = this.index.get(link.childSessionId);
+                if (!cf)
+                    continue;
+                const parentId = link.parentAgentId && subIds.has(link.parentAgentId) ? `${f.sessionId}/${link.parentAgentId}` : mainId;
+                const parentDepth = lanes.find((l) => l.id === parentId)?.depth ?? depth;
+                await addSession(cf, 'spawn', parentDepth + 1, { id: parentId, via: link.toolUseId, confidence: link.confidence });
+            }
+        };
+        await addSession(rootFile, 'main', 0);
+        let origin;
+        const job = this.jobs.find((j) => j.sessionId === rootSessionId || j.resumeSessionId === rootSessionId);
+        const from = job?.fork?.parentSessionId ?? job?.launch?.fromSessionId;
+        if (from && from !== rootSessionId) {
+            const of = this.index.get(from);
+            origin = { kind: job?.fork || job?.launch?.fork ? 'fork' : 'resume', sessionId: from, title: of ? (await this.index.summary(of)).title : undefined };
+        }
+        return { rootSessionId, lanes, origin };
+    }
+    formats() {
+        return registry.report();
+    }
+}

package/dist/app/server/main.js

@@ -0,0 +1,2 @@
+// Kept for `tsx src/server/main.ts` (npm run dev) – the actual entry point is cli.ts.
+import './cli.js';

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

@@ -0,0 +1,112 @@
+import { toolSummary } from '../../shared/tools.js';
+import { num, str } from '../formats/util.js';
+const SIGNIFICANT = new Set(['user-text', 'assistant-text', 'thinking', 'tool-use', 'tool-result']);
+function short(s, max = 140) {
+    const one = s
+        .replace(/```[\s\S]*?```/g, ' ')
+        .replace(/\*\*|__|`|^#+\s*/gm, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return one.length > max ? one.slice(0, max - 1) + '…' : one;
+}
+export function analyze(entries) {
+    const a = { outputTokens: 0, toolCalls: 0, pendingTools: [], current: null, finished: false, errored: false };
+    const open = new Map();
+    const outputByMessage = new Map();
+    const titles = {};
+    for (const e of entries) {
+        if (e.timestamp && (!a.lastActivityAt || e.timestamp > a.lastActivityAt))
+            a.lastActivityAt = e.timestamp;
+        switch (e.kind) {
+            case 'tool-use':
+                a.toolCalls++;
+                open.set(e.toolUseId, e);
+                break;
+            case 'tool-result':
+                open.delete(e.toolUseId);
+                break;
+            case 'user-text':
+                if (e.permissionMode)
+                    a.permissionMode = e.permissionMode;
+                if (!e.isMeta && e.text && !e.text.startsWith('<'))
+                    a.lastPrompt = e.text;
+                break;
+            case 'meta': {
+                const d = e.data;
+                if (e.metaType === 'permission-mode' && str(d.permissionMode))
+                    a.permissionMode = str(d.permissionMode);
+                if (e.metaType === 'custom-title' && str(d.customTitle))
+                    titles.custom = str(d.customTitle);
+                if (e.metaType === 'agent-name' && str(d.agentName))
+                    titles.agent = str(d.agentName);
+                if (e.metaType === 'ai-title' && str(d.aiTitle))
+                    titles.ai = str(d.aiTitle);
+                if (e.metaType === 'last-prompt' && str(d.lastPrompt))
+                    a.lastPrompt = str(d.lastPrompt);
+                if (e.metaType === 'cost-state' && num(d.totalCostUSD) !== undefined)
+                    a.costUSD = num(d.totalCostUSD);
+                break;
+            }
+        }
+        if ((e.kind === 'assistant-text' || e.kind === 'thinking' || e.kind === 'tool-use') && e.usage) {
+            if (e.model && e.model !== '<synthetic>')
+                a.model = e.model;
+            if (e.effort)
+                a.effort = e.effort;
+            const u = e.usage;
+            a.contextTokens = (u.input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0);
+            if (e.messageId)
+                outputByMessage.set(e.messageId, u.output_tokens ?? 0);
+        }
+    }
+    for (const v of outputByMessage.values())
+        a.outputTokens += v;
+    a.title = titles.custom ?? titles.agent ?? titles.ai;
+    a.pendingTools = [...open.values()].map((t) => ({
+        toolUseId: t.toolUseId,
+        name: t.name,
+        summary: toolSummary(t.name, t.input),
+        since: t.timestamp,
+    }));
+    // Aktuelle Aktivität aus dem letzten bedeutsamen Eintrag
+    let last;
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const e = entries[i];
+        if (e.kind === 'system' && e.subtype === 'api_error') {
+            a.current = { kind: 'error', label: short(e.text ?? String(e.data.error?.message ?? 'API error')), since: e.timestamp };
+            a.errored = true;
+            return a;
+        }
+        if (SIGNIFICANT.has(e.kind) && !e.isMeta) {
+            last = e;
+            break;
+        }
+    }
+    const pending = a.pendingTools.at(-1);
+    if (pending) {
+        a.current = { kind: 'tool', label: pending.summary, toolName: pending.name, since: pending.since };
+    }
+    else if (last) {
+        switch (last.kind) {
+            case 'assistant-text':
+                if (last.stopReason === 'end_turn' || last.stopReason === 'stop_sequence') {
+                    a.finished = true;
+                    a.current = { kind: 'idle', label: short(last.text), since: last.timestamp };
+                }
+                else {
+                    a.current = { kind: 'text', label: short(last.text), since: last.timestamp };
+                }
+                break;
+            case 'thinking':
+                a.current = { kind: 'thinking', label: short(last.text) || 'thinking', since: last.timestamp };
+                break;
+            case 'tool-result':
+                a.current = { kind: 'waiting', label: 'model working (after tool result)', since: last.timestamp };
+                break;
+            case 'user-text':
+                a.current = { kind: 'waiting', label: 'new input: ' + short(last.text, 100), since: last.timestamp };
+                break;
+        }
+    }
+    return a;
+}

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

@@ -0,0 +1,47 @@
+import { toolSummary } from '../../shared/tools.js';
+/** Tool-Spannen, Antwortzeitpunkte und Zeitraum eines Transcripts. */
+export function laneData(entries) {
+    const spans = [];
+    const byId = new Map();
+    const turns = [];
+    const outByMsg = new Map();
+    let start;
+    let end;
+    let model;
+    for (const e of entries) {
+        const ts = e.timestamp ? Date.parse(e.timestamp) : NaN;
+        if (Number.isNaN(ts))
+            continue;
+        if (e.kind === 'meta' || e.kind === 'attachment')
+            continue;
+        start = start === undefined ? ts : Math.min(start, ts);
+        end = end === undefined ? ts : Math.max(end, ts);
+        if (e.kind === 'tool-use') {
+            // Fortgesetzte/geforkte Sessions enthalten Records teils doppelt
+            if (byId.has(e.toolUseId))
+                continue;
+            const s = { toolUseId: e.toolUseId, name: e.name, summary: toolSummary(e.name, e.input).slice(0, 160), start: ts };
+            spans.push(s);
+            byId.set(e.toolUseId, s);
+        }
+        else if (e.kind === 'tool-result') {
+            const s = byId.get(e.toolUseId);
+            if (s) {
+                s.end = Math.max(ts, s.start);
+                if (e.isError || e.denied)
+                    s.isError = true;
+            }
+        }
+        if ((e.kind === 'assistant-text' || e.kind === 'tool-use' || e.kind === 'thinking') && e.messageId) {
+            if (!outByMsg.has(e.messageId))
+                turns.push(ts);
+            outByMsg.set(e.messageId, e.usage?.output_tokens ?? 0);
+            if (e.model && e.model !== '<synthetic>')
+                model = e.model;
+        }
+    }
+    let outputTokens = 0;
+    for (const v of outByMsg.values())
+        outputTokens += v;
+    return { spans, turns, start, end, toolCalls: spans.length, outputTokens, model };
+}

package/dist/app/server/run.js

@@ -0,0 +1,37 @@
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { CLAUDE_DIR } from './config.js';
+import { startServer } from './http.js';
+import { Inspector } from './inspector.js';
+/** Locates the built web UI – works from src/server (tsx), dist/app/server and an installed npm package. */
+function findWebRoot() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [join(here, '..', '..', 'dist', 'web'), join(here, '..', '..', 'web')];
+    return candidates.find((d) => existsSync(join(d, 'index.html'))) ?? candidates[0];
+}
+export async function runServer(opts) {
+    const inspector = new Inspector();
+    const t0 = Date.now();
+    await inspector.start();
+    const noAuth = !!(opts.dev || opts.noAuth);
+    const { server, token } = startServer(inspector, { port: opts.port, host: '127.0.0.1', webRoot: findWebRoot(), noAuth, token: opts.token });
+    server.on('error', (e) => {
+        console.error(e.code === 'EADDRINUSE' ? `Port ${opts.port} is already in use – choose another one with --port.` : String(e));
+        process.exit(1);
+    });
+    const url = noAuth ? `http://localhost:${opts.port}/` : `http://localhost:${opts.port}/?t=${token}`;
+    console.log(`claude-inspect is reading ${CLAUDE_DIR} (started in ${Date.now() - t0} ms)`);
+    console.log(opts.dev ? `API (dev, no token): ${url}  –  UI: npm run dev:web` : `Dashboard: ${url}`);
+    if (opts.open && process.platform === 'darwin')
+        execFile('open', [url]);
+    else if (opts.open && process.platform === 'linux')
+        execFile('xdg-open', [url]);
+    const shutdown = () => {
+        inspector.stop();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}