claude-inspect 0.1.0

package/dist/app/server/sources/jobs.js

@@ -0,0 +1,59 @@
+import { readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { paths } from '../config.js';
+import { registry } from '../formats/index.js';
+import { readHeadTail, readJson } from '../util/jsonl.js';
+async function readRoster() {
+    try {
+        return registry.decode('daemon-roster', await readJson(paths.daemonRoster), paths.daemonRoster).out;
+    }
+    catch {
+        return {};
+    }
+}
+async function readTimeline(file) {
+    try {
+        const { tail } = await readHeadTail(file, 0, 32 * 1024);
+        return tail.slice(-30).map((raw) => registry.decode('job-timeline', raw, file).out);
+    }
+    catch {
+        return [];
+    }
+}
+/** Zuletzt gelesener Zustand je Job – neu dekodiert wird nur bei geänderter Datei. */
+const cache = new Map();
+export async function readJobs() {
+    let names = [];
+    try {
+        names = await readdir(paths.jobs);
+    }
+    catch {
+        return [];
+    }
+    const roster = await readRoster();
+    const jobs = [];
+    for (const short of names) {
+        const dir = join(paths.jobs, short);
+        try {
+            if (!(await stat(dir)).isDirectory())
+                continue;
+            const file = join(dir, 'state.json');
+            const tl = join(dir, 'timeline.jsonl');
+            const [st, tst] = await Promise.all([stat(file), stat(tl).catch(() => undefined)]);
+            const key = `${st.mtimeMs}:${st.size}:${tst?.mtimeMs ?? 0}:${JSON.stringify(roster[short] ?? null)}`;
+            const hit = cache.get(short);
+            if (hit && hit.key === key) {
+                jobs.push(hit.job);
+                continue;
+            }
+            const { out, decoder } = registry.decode('job-state', await readJson(file), file);
+            const job = { ...out, short, decoder, launch: roster[short], timeline: await readTimeline(tl) };
+            cache.set(short, { key, job });
+            jobs.push(job);
+        }
+        catch {
+            /* Job ohne state.json */
+        }
+    }
+    return jobs;
+}

package/dist/app/server/sources/processes.js

@@ -0,0 +1,99 @@
+import { execFile } from 'node:child_process';
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { paths } from '../config.js';
+import { registry } from '../formats/index.js';
+import { readJson } from '../util/jsonl.js';
+/**
+ * Startzeiten laufender Prozesse per `ps` (rein lesend).
+ * TZ=UTC, weil Claude Code `procStart` in UTC schreibt.
+ */
+function procStarts(pids) {
+    return new Promise((resolve) => {
+        if (pids.length === 0 || process.platform === 'win32')
+            return resolve(new Map());
+        execFile('ps', ['-o', 'pid=,lstart=', '-p', pids.join(',')], { env: { ...process.env, TZ: 'UTC', LC_ALL: 'C' }, timeout: 5000 }, (_err, stdout) => {
+            // ps endet mit Code 1, wenn einzelne PIDs fehlen – die Ausgabe ist trotzdem gültig.
+            const out = new Map();
+            for (const line of String(stdout ?? '').split('\n')) {
+                const m = /^\s*(\d+)\s+(.+?)\s*$/.exec(line);
+                if (m)
+                    out.set(Number(m[1]), m[2]);
+            }
+            resolve(out);
+        });
+    });
+}
+/** Eltern-PID und Programmname aller Prozesse (`ps -A`), für die Zuordnung per Prozessbaum. */
+function processTable() {
+    return new Promise((resolve) => {
+        if (process.platform === 'win32')
+            return resolve(new Map());
+        execFile('ps', ['-A', '-o', 'pid=,ppid=,comm='], { timeout: 5000, maxBuffer: 8 * 1024 * 1024 }, (_err, stdout) => {
+            const out = new Map();
+            for (const line of String(stdout ?? '').split('\n')) {
+                const m = /^\s*(\d+)\s+(\d+)\s+(.*)$/.exec(line);
+                if (m)
+                    out.set(Number(m[1]), { ppid: Number(m[2]), comm: m[3].trim().split('/').pop() ?? '' });
+            }
+            resolve(out);
+        });
+    });
+}
+/**
+ * Programme, die zwischen aufrufendem Agenten und gestartetem claude liegen dürfen
+ * (Bash-Tool → Shell → evtl. Wrapper → claude). Alles andere – etwa der Daemon,
+ * der Hintergrund-Jobs forkt – ist keine Aufrufbeziehung.
+ */
+const LAUNCH_INTERMEDIATES = new Set(['sh', 'zsh', 'bash', 'dash', 'fish', '-zsh', '-bash', 'env', 'caffeinate', 'timeout', 'gtimeout', 'nohup', 'time', 'script', 'xargs', 'stdbuf', 'nice', 'sudo']);
+const norm = (s) => s.replace(/\s+/g, ' ').trim();
+export async function readProcesses() {
+    let names = [];
+    try {
+        names = await readdir(paths.sessions);
+    }
+    catch {
+        return [];
+    }
+    const decoded = [];
+    const procStart = new Map();
+    for (const name of names) {
+        // <pid>.json – die <pid>.<hash>.key-Dateien enthalten Tokens und werden nie gelesen.
+        if (!/^\d+\.json$/.test(name))
+            continue;
+        const file = join(paths.sessions, name);
+        try {
+            const { out, decoder } = registry.decode('process', await readJson(file), file);
+            const { procStart: ps, ...rest } = out;
+            procStart.set(rest.pid, ps);
+            decoded.push({ ...rest, alive: false, file, decoder });
+        }
+        catch {
+            /* halb geschrieben oder gelöscht */
+        }
+    }
+    const [running, table] = await Promise.all([procStarts(decoded.map((p) => p.pid).filter((p) => p > 0)), processTable()]);
+    for (const p of decoded) {
+        const actual = running.get(p.pid);
+        const expected = procStart.get(p.pid);
+        p.alive = actual !== undefined && (!expected || norm(actual) === norm(expected));
+    }
+    // Prozessbaum hochlaufen (claude → zsh → claude …) bis zum nächsten bekannten Claude-Prozess.
+    const alivePids = new Set(decoded.filter((p) => p.alive).map((p) => p.pid));
+    for (const p of decoded) {
+        if (!p.alive || p.kind === 'bg')
+            continue;
+        let cur = table.get(p.pid)?.ppid;
+        for (let depth = 0; cur && cur > 1 && depth < 8; depth++) {
+            if (alivePids.has(cur)) {
+                p.parentPid = cur;
+                break;
+            }
+            const row = table.get(cur);
+            if (!row || !LAUNCH_INTERMEDIATES.has(row.comm))
+                break;
+            cur = row.ppid;
+        }
+    }
+    return decoded;
+}

package/dist/app/server/sources/projects.js

@@ -0,0 +1,165 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { paths } from '../config.js';
+import { registry } from '../formats/index.js';
+import { isObj, num, str } from '../formats/util.js';
+import { readHeadTail } from '../util/jsonl.js';
+import { compareVersions } from '../util/semver.js';
+export function projectName(cwd, projectDir) {
+    if (cwd)
+        return cwd.replace(/\/+$/, '').split('/').pop() || cwd;
+    return projectDir.replace(/^-Users-[^-]+-/, '');
+}
+/**
+ * Index über alle Session-Transcripts unter ~/.claude/projects.
+ * Hält nur Dateinamen, Größe und mtime; Zusammenfassungen werden lazy
+ * aus Anfang und Ende der Datei gebildet und nach (size, mtime) gecacht.
+ */
+export class ProjectIndex {
+    files = new Map();
+    summaries = new Map();
+    async scan() {
+        const next = new Map();
+        let dirs = [];
+        try {
+            dirs = await readdir(paths.projects);
+        }
+        catch {
+            /* noch keine Projekte */
+        }
+        await Promise.all(dirs.map(async (projectDir) => {
+            const dir = join(paths.projects, projectDir);
+            let names;
+            try {
+                names = await readdir(dir);
+            }
+            catch {
+                return;
+            }
+            for (const name of names) {
+                if (!name.endsWith('.jsonl'))
+                    continue;
+                const path = join(dir, name);
+                try {
+                    const st = await stat(path);
+                    const sessionId = name.slice(0, -'.jsonl'.length);
+                    next.set(sessionId, { sessionId, projectDir, path, size: st.size, mtime: st.mtimeMs });
+                }
+                catch {
+                    /* gerade gelöscht */
+                }
+            }
+        }));
+        this.files = next;
+    }
+    /** Aktualisiert einen einzelnen Eintrag nach einem Watch-Event. */
+    async touch(path) {
+        const m = /\/projects\/([^/]+)\/([^/]+)\.jsonl$/.exec(path);
+        if (!m)
+            return;
+        try {
+            const st = await stat(path);
+            this.files.set(m[2], { sessionId: m[2], projectDir: m[1], path, size: st.size, mtime: st.mtimeMs });
+        }
+        catch {
+            this.files.delete(m[2]);
+        }
+    }
+    get(sessionId) {
+        return this.files.get(sessionId);
+    }
+    list() {
+        return [...this.files.values()].sort((a, b) => b.mtime - a.mtime);
+    }
+    async summary(f) {
+        const cached = this.summaries.get(f.path);
+        if (cached && cached.size === f.size && cached.mtime === f.mtime)
+            return cached.summary;
+        const summary = await summarize(f);
+        this.summaries.set(f.path, { size: f.size, mtime: f.mtime, summary });
+        return summary;
+    }
+}
+async function countSubagents(sessionDir) {
+    try {
+        return (await readdir(join(sessionDir, 'subagents'))).filter((n) => n.endsWith('.jsonl')).length;
+    }
+    catch {
+        return 0;
+    }
+}
+async function summarize(f) {
+    const s = {
+        sessionId: f.sessionId,
+        projectDir: f.projectDir,
+        project: projectName(undefined, f.projectDir),
+        size: f.size,
+        mtime: f.mtime,
+        versions: [],
+        subagentCount: 0,
+    };
+    const sessionDir = f.path.slice(0, -'.jsonl'.length);
+    s.subagentCount = await countSubagents(sessionDir);
+    let head = [];
+    let tail = [];
+    try {
+        ({ head, tail } = await readHeadTail(f.path, 32 * 1024, 256 * 1024));
+    }
+    catch {
+        return s;
+    }
+    const versions = new Set();
+    const titles = {};
+    const fold = (raws) => {
+        for (const raw of raws) {
+            if (!isObj(raw))
+                continue;
+            const { out } = registry.decode('transcript', raw, f.path, 0, { silent: true });
+            const v = str(raw.version);
+            if (v)
+                versions.add(v);
+            if (str(raw.cwd))
+                s.cwd = str(raw.cwd);
+            if (str(raw.gitBranch))
+                s.gitBranch = str(raw.gitBranch);
+            for (const e of out) {
+                if (e.timestamp) {
+                    if (!s.firstTimestamp || e.timestamp < s.firstTimestamp)
+                        s.firstTimestamp = e.timestamp;
+                    if (!s.lastTimestamp || e.timestamp > s.lastTimestamp)
+                        s.lastTimestamp = e.timestamp;
+                }
+                if (e.kind === 'meta') {
+                    const d = e.data;
+                    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))
+                        s.lastPrompt = str(d.lastPrompt);
+                    if (e.metaType === 'cost-state' && num(d.totalCostUSD) !== undefined)
+                        s.costUSD = num(d.totalCostUSD);
+                }
+                if ((e.kind === 'assistant-text' || e.kind === 'tool-use' || e.kind === 'thinking') && e.model && e.model !== '<synthetic>') {
+                    s.model = e.model;
+                }
+            }
+        }
+    };
+    fold(head);
+    fold(tail);
+    try {
+        const ct = JSON.parse(await readFile(join(sessionDir, 'custom-title.json'), 'utf8'));
+        if (isObj(ct) && str(ct.customTitle))
+            titles.custom ??= str(ct.customTitle);
+    }
+    catch {
+        /* optional */
+    }
+    s.title = titles.custom ?? titles.agent ?? titles.ai;
+    s.versions = [...versions].sort(compareVersions);
+    s.project = projectName(s.cwd, f.projectDir);
+    return s;
+}

package/dist/app/server/sources/spawns.js

@@ -0,0 +1,297 @@
+import { readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { isObj, obj, str } from '../formats/util.js';
+import { JsonlTail, readHeadTail } from '../util/jsonl.js';
+import { subagentDir } from './subagents.js';
+/** `claude` als eigenständiges Kommando (auch mit Pfad), nicht z. B. "claude-inspect" oder ".claude/". */
+const CLAUDE_CMD = /(?:^|[\s;&|(`]|\$\()(?:[\w./~-]*\/)?claude(?=\s|$)/m;
+/** Aufrufe, die keine Sitzung erzeugen. */
+const NO_SESSION = /^\s*(?:which|type|command -v)\b|claude\s+(?:--version|-v|update|doctor|mcp|config|install)\b/;
+const NOT_A_CALL_BEFORE = /(?:\bwhich|\btype|command\s+-v|\bpgrep(?:\s+-\w+)*|\bpkill(?:\s+-\w+)*|\bkillall|\bman)\s+["']?[\w./~-]*$/;
+const UUID = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/;
+export function normalize(s) {
+    return s
+        .replace(/\\\n/g, ' ')
+        .replace(/\\(["'$`\\])/g, '$1')
+        .replace(/\\012|\\n/g, ' ')
+        .replace(/["'`]/g, '')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
+function words(s) {
+    return normalize(s)
+        .split(/[^\p{L}\p{N}_./-]+/u)
+        .filter((w) => w.length >= 3);
+}
+/** Zerlegt einen Shell-Befehl in die einzelnen claude-Aufrufe (bei `a && claude …; claude …`). */
+export function claudeInvocations(command) {
+    const out = [];
+    let pos = 0;
+    for (let i = 0; i < 20; i++) {
+        const m = CLAUDE_CMD.exec(command.slice(pos));
+        if (!m)
+            break;
+        const abs = pos + m.index;
+        const start = abs + m[0].length;
+        const next = CLAUDE_CMD.exec(command.slice(start));
+        const end = next ? start + next.index : command.length;
+        // `which claude`, `pgrep -f claude` … nennen claude nur als Argument
+        const before = command.slice(Math.max(0, abs - 24), abs + m[0].indexOf('claude'));
+        if (!NOT_A_CALL_BEFORE.test(before))
+            out.push(command.slice(abs, end));
+        pos = end;
+    }
+    return out;
+}
+export function parseCall(raw, block, sessionId, agentId) {
+    const input = obj(block.input);
+    const command = str(input?.command);
+    const ts = Date.parse(str(raw.timestamp) ?? '');
+    if (!command || Number.isNaN(ts) || !CLAUDE_CMD.test(command))
+        return [];
+    const out = [];
+    for (const inv of claudeInvocations(command)) {
+        if (NO_SESSION.test(inv))
+            continue;
+        const agentFlag = /--agent[=\s]+["']?([\w.-]+)/.exec(inv)?.[1];
+        const sessionFlags = [...inv.matchAll(new RegExp(`--(?:session-id|resume|fork-session)[=\\s]+["']?(${UUID.source})`, 'g'))].map((m) => m[1]);
+        out.push({
+            sessionId,
+            agentId,
+            toolUseId: str(block.id) ?? '',
+            ts,
+            command,
+            normCommand: normalize(inv),
+            words: new Set(words(inv)),
+            cwd: /(?:^|[\s;&(])cd\s+["']?([^\s"';&]+)/.exec(command)?.[1] ?? str(raw.cwd),
+            agentFlag,
+            sessionFlags,
+        });
+    }
+    return out;
+}
+/** Bewertet, wie gut ein claude-Aufruf zu einer Kind-Sitzung passt (höher = besser). */
+export function scoreSpawn(child, call) {
+    const evidence = [];
+    let score = 0;
+    if (call.sessionFlags.includes(child.sessionId))
+        return { score: 1000, evidence: ['session id in command'] };
+    if (child.prompt) {
+        const np = normalize(child.prompt);
+        const prefix = np.slice(0, 160);
+        if (prefix.length >= 20 && call.normCommand.includes(prefix)) {
+            score += 60;
+            evidence.push('prompt');
+        }
+        else if (prefix.length > 0 && prefix.length < 20 && new RegExp(`(?:^|\\s)-p ${prefix.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&')}(?:\\s|$)`).test(call.normCommand)) {
+            // kurze Prompts wie "/usage": nur als exaktes -p-Argument werten
+            score += 40;
+            evidence.push('prompt');
+        }
+        else {
+            const pw = words(child.prompt).slice(0, 80);
+            if (pw.length >= 5) {
+                const ratio = pw.filter((w) => call.words.has(w)).length / pw.length;
+                if (ratio >= 0.5) {
+                    score += Math.round(ratio * 45);
+                    evidence.push(`prompt ~${Math.round(ratio * 100)}%`);
+                }
+            }
+        }
+    }
+    if (call.agentFlag || child.agentSetting) {
+        if (call.agentFlag && call.agentFlag === child.agentSetting) {
+            score += 15;
+            evidence.push('agent');
+        }
+        else {
+            score -= 25;
+        }
+    }
+    if (child.startTs !== undefined) {
+        const dt = (child.startTs - call.ts) / 1000;
+        if (dt >= -2 && dt <= 30) {
+            score += 15;
+            evidence.push('time');
+        }
+        else if (dt > 30 && dt <= 180) {
+            score += 5;
+            evidence.push('time (rough)');
+        }
+    }
+    if (child.cwd && call.cwd && child.cwd.replace(/\/$/, '') === call.cwd.replace(/\/$/, '')) {
+        score += 5;
+        evidence.push('directory');
+    }
+    return { score, evidence };
+}
+export class SpawnIndex {
+    files = new Map();
+    children = new Map();
+    links = new Map();
+    /** Neue Zeilen aller Transcripts nach claude-Aufrufen durchsuchen (inkrementell). */
+    async refresh(transcripts, processes, full) {
+        for (const f of transcripts) {
+            await this.scanFile(f.path, f.size, f.sessionId);
+            // Subagenten können ebenfalls claude-Aufrufe machen. Nach dem ersten
+            // Durchlauf nur noch bei kürzlich aktiven Sessions nachsehen.
+            if (!full && Date.now() - f.mtime > 3600_000)
+                continue;
+            const dir = subagentDir(f.path);
+            let names = [];
+            try {
+                names = await readdir(dir);
+            }
+            catch {
+                /* keine Subagenten */
+            }
+            for (const n of names) {
+                const m = /^agent-(.+)\.jsonl$/.exec(n);
+                if (!m)
+                    continue;
+                const path = join(dir, n);
+                try {
+                    await this.scanFile(path, (await stat(path)).size, f.sessionId, m[1]);
+                }
+                catch {
+                    /* gelöscht */
+                }
+            }
+        }
+        for (const f of transcripts)
+            await this.readChild(f);
+        this.link(processes);
+    }
+    async scanFile(path, size, sessionId, agentId) {
+        let st = this.files.get(path);
+        if (st && st.size === size)
+            return;
+        if (!st || size < st.size) {
+            st = { size: 0, tail: new JsonlTail(path), calls: [] };
+            this.files.set(path, st);
+        }
+        st.size = size;
+        try {
+            const { lines, reset } = await st.tail.readNew((t) => t.includes('"Bash"') && t.includes('claude'));
+            if (reset)
+                st.calls = [];
+            for (const l of lines) {
+                const raw = l.value;
+                if (!isObj(raw) || raw.type !== 'assistant')
+                    continue;
+                const content = obj(raw.message)?.content;
+                if (!Array.isArray(content))
+                    continue;
+                for (const b of content) {
+                    if (isObj(b) && b.type === 'tool_use' && b.name === 'Bash')
+                        st.calls.push(...parseCall(raw, b, sessionId, agentId));
+                }
+            }
+        }
+        catch {
+            /* gelöscht */
+        }
+    }
+    /** Kopf eines Transcripts: Einstiegspunkt, erster Prompt, Startzeit, Agent. */
+    async readChild(f) {
+        const cached = this.children.get(f.sessionId);
+        if (cached && cached.info.prompt !== undefined && cached.size <= f.size)
+            return;
+        const info = { sessionId: f.sessionId };
+        try {
+            const { head } = await readHeadTail(f.path, 96 * 1024, 0);
+            for (const raw of head) {
+                if (!isObj(raw))
+                    continue;
+                if (raw.type === 'agent-setting')
+                    info.agentSetting ??= str(raw.agentSetting);
+                const ts = Date.parse(str(raw.timestamp) ?? '');
+                if (!Number.isNaN(ts) && (info.startTs === undefined || ts < info.startTs))
+                    info.startTs = ts;
+                if (raw.type === 'queue-operation' && raw.operation === 'enqueue' && info.prompt === undefined)
+                    info.prompt = str(raw.content);
+                if (raw.type === 'user' && !raw.isMeta) {
+                    info.entrypoint ??= str(raw.entrypoint);
+                    info.promptSource ??= str(raw.promptSource);
+                    info.cwd ??= str(raw.cwd);
+                    const c = obj(raw.message)?.content;
+                    const text = typeof c === 'string' ? c : Array.isArray(c) ? c.map((b) => (isObj(b) && b.type === 'text' ? str(b.text) : '')).join('\n') : '';
+                    if (text && !text.startsWith('<') && (info.prompt === undefined || info.promptSource === 'sdk'))
+                        info.prompt = text;
+                    if (info.entrypoint)
+                        break;
+                }
+            }
+        }
+        catch {
+            /* gelöscht */
+        }
+        this.children.set(f.sessionId, { size: f.size, info });
+    }
+    link(processes) {
+        const allCalls = [...this.files.values()].flatMap((f) => f.calls);
+        const byPid = new Map(processes.filter((p) => p.alive).map((p) => [p.pid, p]));
+        const links = new Map();
+        for (const { info: child } of this.children.values()) {
+            // Nur Sitzungen, die nicht interaktiv gestartet wurden, kommen als Kind in Frage.
+            const proc = processes.find((p) => p.alive && p.sessionId === child.sessionId);
+            const parentProc = proc?.parentPid ? byPid.get(proc.parentPid) : undefined;
+            const isSdk = child.promptSource === 'sdk' || child.entrypoint?.startsWith('sdk');
+            if (!isSdk && !parentProc)
+                continue;
+            let candidates = allCalls.filter((c) => c.sessionId !== child.sessionId);
+            if (parentProc) {
+                const own = candidates.filter((c) => c.sessionId === parentProc.sessionId);
+                if (own.length)
+                    candidates = own;
+            }
+            else if (child.startTs !== undefined) {
+                // ohne Prozessbaum: nur Aufrufe, die zeitlich passen
+                candidates = candidates.filter((c) => child.startTs - c.ts >= -2000 && child.startTs - c.ts <= 600_000);
+            }
+            let best;
+            for (const call of candidates) {
+                const r = scoreSpawn(child, call);
+                if (!best || r.score > best.score || (r.score === best.score && call.ts > best.call.ts))
+                    best = { call, ...r };
+            }
+            if (parentProc) {
+                // Die Eltern-Session steht fest; der Tool-Aufruf ist das beste Indiz innerhalb dieser Session.
+                const call = best && best.call.sessionId === parentProc.sessionId && best.score > 0 ? best : undefined;
+                links.set(child.sessionId, {
+                    childSessionId: child.sessionId,
+                    parentSessionId: parentProc.sessionId,
+                    parentAgentId: call?.call.agentId,
+                    toolUseId: call?.call.toolUseId,
+                    confidence: 'exact',
+                    evidence: ['process tree', ...(call?.evidence ?? [])],
+                    score: 1000 + (call?.score ?? 0),
+                });
+                continue;
+            }
+            if (!best || best.score < 40)
+                continue;
+            const confidence = best.score >= 1000 ? 'exact' : best.score >= 70 ? 'high' : 'likely';
+            links.set(child.sessionId, {
+                childSessionId: child.sessionId,
+                parentSessionId: best.call.sessionId,
+                parentAgentId: best.call.agentId,
+                toolUseId: best.call.toolUseId,
+                confidence,
+                evidence: best.evidence,
+                score: best.score,
+            });
+        }
+        this.links = links;
+    }
+    parentOf(sessionId) {
+        return this.links.get(sessionId);
+    }
+    childrenOf(sessionId) {
+        return [...this.links.values()].filter((l) => l.parentSessionId === sessionId);
+    }
+    childInfo(sessionId) {
+        return this.children.get(sessionId)?.info;
+    }
+}

package/dist/app/server/sources/subagents.js

@@ -0,0 +1,62 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { registry } from '../formats/index.js';
+import { readJson } from '../util/jsonl.js';
+export function subagentDir(sessionPath) {
+    return join(sessionPath.slice(0, -'.jsonl'.length), 'subagents');
+}
+export async function listSubagents(sessionPath) {
+    const dir = subagentDir(sessionPath);
+    let names;
+    try {
+        names = await readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of names) {
+        const m = /^agent-(.+)\.jsonl$/.exec(name);
+        if (!m)
+            continue;
+        const path = join(dir, name);
+        const metaPath = join(dir, `agent-${m[1]}.meta.json`);
+        let meta = {};
+        try {
+            meta = registry.decode('subagent-meta', await readJson(metaPath), metaPath).out;
+        }
+        catch {
+            /* ältere Versionen ohne meta.json */
+        }
+        try {
+            const st = await stat(path);
+            out.push({ agentId: m[1], path, mtime: st.mtimeMs, size: st.size, meta });
+        }
+        catch {
+            /* gelöscht */
+        }
+    }
+    return out;
+}
+/**
+ * Welche Agent-Tool-Aufrufe (tool_use ids) stecken in einer Datei?
+ * Schneller Textscan statt vollständigem Parsen; gecacht nach Dateigröße.
+ */
+const agentCallCache = new Map();
+const AGENT_CALL = /"id":"([^"]+)","name":"(?:Agent|Task)"/g;
+export async function agentCallIds(path, size) {
+    const c = agentCallCache.get(path);
+    if (c && c.size === size)
+        return c.ids;
+    const ids = new Set();
+    try {
+        const text = await readFile(path, 'utf8');
+        for (const m of text.matchAll(AGENT_CALL))
+            ids.add(m[1]);
+    }
+    catch {
+        /* gelöscht */
+    }
+    agentCallCache.set(path, { size, ids });
+    return ids;
+}