claude-inspect 0.1.0

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

@@ -0,0 +1,170 @@
+/**
+ * Autostart for claude-inspect (runs the compiled build with plain node).
+ *
+ *   claude-inspect service install [--port 47717]   install + start (login autostart, restart on crash)
+ *   claude-inspect service uninstall                  stop + remove
+ *   claude-inspect service status                     show state and URL
+ *
+ * macOS: LaunchAgent in ~/Library/LaunchAgents, log in ~/Library/Logs/claude-inspect.log
+ * Linux: systemd user unit in ~/.config/systemd/user, log via `journalctl --user -u claude-inspect`
+ *
+ * The service runs without access token (--no-auth): it only listens on 127.0.0.1 and
+ * rejects requests with a foreign Host header, so a plain bookmark to http://localhost:<port> works.
+ */
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir, userInfo } from 'node:os';
+import { dirname, join, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const HERE = dirname(fileURLToPath(import.meta.url));
+/**
+ * The service always runs the compiled cli.js: next to this file in a build/npm install
+ * (…/dist/app/server/cli), or the project's dist when started from the sources via tsx.
+ */
+const FROM_SOURCES = HERE.split(sep).slice(-3).join('/') === 'src/server/cli';
+const ROOT = FROM_SOURCES ? resolve(HERE, '..', '..', '..') : resolve(HERE, '..', '..', '..', '..');
+const ENTRY = FROM_SOURCES ? join(ROOT, 'dist', 'app', 'server', 'cli.js') : resolve(HERE, '..', 'cli.js');
+const WEB = FROM_SOURCES ? join(ROOT, 'dist', 'web') : resolve(HERE, '..', '..', '..', 'web');
+const LABEL = 'com.github.claude-inspect';
+let port = 47717;
+let URL = `http://localhost:${port}/`;
+function run(bin, args, quiet = false) {
+    try {
+        return execFileSync(bin, args, { stdio: ['ignore', 'pipe', quiet ? 'ignore' : 'inherit'] }).toString();
+    }
+    catch (e) {
+        if (quiet)
+            return '';
+        throw e;
+    }
+}
+/** Stable node path (e.g. /opt/homebrew/bin/node instead of a versioned Cellar path). */
+function nodePath() {
+    const found = run('sh', ['-c', 'command -v node'], true).trim();
+    return found || process.execPath;
+}
+function requireBuild() {
+    if (!existsSync(ENTRY) || !existsSync(join(WEB, 'index.html'))) {
+        console.error(`No build found at ${ENTRY} – run \`npm run build\` first.`);
+        process.exit(1);
+    }
+}
+// ---------------------------------------------------------------------------
+// macOS (launchd)
+const plistPath = join(homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
+const logPath = join(homedir(), 'Library', 'Logs', 'claude-inspect.log');
+const domain = `gui/${userInfo().uid}`;
+function macInstall() {
+    const esc = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;');
+    const args = [nodePath(), ENTRY, '--port', String(port), '--no-auth'];
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args.map((a) => `    <string>${esc(a)}</string>`).join('\n')}
+  </array>
+  <key>WorkingDirectory</key><string>${esc(ROOT)}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key><string>/usr/bin:/bin:/usr/sbin:/sbin</string>
+  </dict>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>ThrottleInterval</key><integer>10</integer>
+  <key>ProcessType</key><string>Background</string>
+  <key>StandardOutPath</key><string>${esc(logPath)}</string>
+  <key>StandardErrorPath</key><string>${esc(logPath)}</string>
+</dict>
+</plist>
+`;
+    mkdirSync(dirname(plistPath), { recursive: true });
+    mkdirSync(dirname(logPath), { recursive: true });
+    run('launchctl', ['bootout', `${domain}/${LABEL}`], true); // replace an older install
+    writeFileSync(plistPath, plist);
+    // bootout finishes asynchronously; bootstrap fails with "Input/output error" until it has.
+    for (let attempt = 1;; attempt++) {
+        try {
+            execFileSync('launchctl', ['bootstrap', domain, plistPath], { stdio: 'pipe' });
+            break;
+        }
+        catch (e) {
+            if (attempt >= 10)
+                throw e;
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 500);
+        }
+    }
+    console.log(`Installed LaunchAgent ${plistPath}\nLog: ${logPath}`);
+}
+function macUninstall() {
+    run('launchctl', ['bootout', `${domain}/${LABEL}`], true);
+    rmSync(plistPath, { force: true });
+    console.log('LaunchAgent removed.');
+}
+function macStatus() {
+    const out = run('launchctl', ['print', `${domain}/${LABEL}`], true);
+    if (!out)
+        return console.log('Not installed.');
+    const state = /state = (\w+)/.exec(out)?.[1] ?? '?';
+    const pid = /pid = (\d+)/.exec(out)?.[1];
+    console.log(`State: ${state}${pid ? ` (pid ${pid})` : ''}\nPlist: ${plistPath}\nLog:   ${logPath}`);
+}
+// ---------------------------------------------------------------------------
+// Linux (systemd --user)
+const unitPath = join(homedir(), '.config', 'systemd', 'user', 'claude-inspect.service');
+function linuxInstall() {
+    mkdirSync(dirname(unitPath), { recursive: true });
+    writeFileSync(unitPath, `[Unit]
+Description=claude-inspect – live dashboard for Claude Code agents
+
+[Service]
+ExecStart=${nodePath()} ${ENTRY} --port ${port} --no-auth
+WorkingDirectory=${ROOT}
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=default.target
+`);
+    run('systemctl', ['--user', 'daemon-reload']);
+    run('systemctl', ['--user', 'enable', '--now', 'claude-inspect.service']);
+    console.log(`Installed ${unitPath}\nLog: journalctl --user -u claude-inspect`);
+}
+function linuxUninstall() {
+    run('systemctl', ['--user', 'disable', '--now', 'claude-inspect.service'], true);
+    rmSync(unitPath, { force: true });
+    run('systemctl', ['--user', 'daemon-reload'], true);
+    console.log('Service removed.');
+}
+function linuxStatus() {
+    console.log(run('systemctl', ['--user', 'status', 'claude-inspect.service', '--no-pager'], true) || 'Not installed.');
+}
+// ---------------------------------------------------------------------------
+export function service(cmd, servicePort) {
+    port = servicePort;
+    URL = `http://localhost:${port}/`;
+    const mac = process.platform === 'darwin';
+    if (!mac && process.platform !== 'linux') {
+        console.error('Autostart is only supported on macOS and Linux.');
+        process.exit(1);
+    }
+    switch (cmd) {
+        case 'install':
+            requireBuild();
+            (mac ? macInstall : linuxInstall)();
+            console.log(`\nDashboard: ${URL}  (bookmark it – no token needed)`);
+            break;
+        case 'uninstall':
+            (mac ? macUninstall : linuxUninstall)();
+            break;
+        case 'status':
+            (mac ? macStatus : linuxStatus)();
+            console.log(`URL:   ${URL}`);
+            break;
+        default:
+            console.error('Usage: claude-inspect service install|uninstall|status [--port 47717]');
+            process.exit(1);
+    }
+}

package/dist/app/server/cli-snapshot.js

@@ -0,0 +1,34 @@
+// Terminal-Ausgabe "laufende Agenten + letzte Aktion" – nützlich zum Testen der Parser.
+import { Inspector } from './inspector.js';
+const inspector = new Inspector();
+await inspector.start();
+// Komplettscan nach claude-Aufrufen abwarten
+await inspector.spawns.refresh(inspector.index.list(), (await inspector.getDashboard()).processes.map((p) => p.process), true);
+const d = await inspector.getDashboard();
+inspector.stop();
+const ago = (iso) => (iso ? `${Math.round((Date.now() - Date.parse(iso)) / 1000)}s` : '?');
+for (const dp of d.processes) {
+    const { process: p, job, session: s } = dp;
+    const mark = p.alive ? (p.status === 'idle' ? '○' : '●') : '✕';
+    console.log(`${mark} ${p.name ?? s?.title ?? p.sessionId.slice(0, 8)}  [${p.kind ?? '?'}/${p.status ?? '?'}]  pid ${p.pid}  ${p.cwd ?? ''}  v${p.version ?? '?'}`);
+    if (dp.spawnedBy)
+        console.log(`    ⇠ started by ${dp.spawnedBy.parentTitle ?? dp.spawnedBy.parentSessionId.slice(0, 8)} [${dp.spawnedBy.confidence}: ${dp.spawnedBy.evidence.join(', ')}]`);
+    if (job)
+        console.log(`    job ${job.short}: ${job.state} – ${job.detail ?? ''}`);
+    if (s) {
+        console.log(`    ${s.model ?? '?'} · ctx ${s.contextTokens ?? '?'} · ${s.toolCalls} tools · ${s.current?.kind}: ${s.current?.label ?? ''} (${ago(s.current?.since)} ago)`);
+        for (const t of s.pendingTools)
+            console.log(`    ⏳ ${t.name}: ${t.summary}`);
+        for (const c of s.spawned)
+            console.log(`    ⇢ claude ${c.agent ?? ''} ${c.childSessionId.slice(0, 8)} ${c.status} [${c.confidence}: ${c.evidence.join(', ')}]`);
+        for (const a of s.subagents)
+            console.log(`    ↳ ${a.agentType ?? 'agent'} "${a.description ?? ''}" ${a.status}${a.current ? ' – ' + a.current.label : ''}`);
+    }
+}
+if (d.orphanJobs.length)
+    console.log(`\n${d.orphanJobs.length} jobs without a process`);
+const { decoders, drift } = inspector.formats();
+console.log(`\nDecoder hits: ${decoders.filter((x) => x.hits).map((x) => `${x.id}=${x.hits}`).join(', ')}`);
+console.log(`Drift entries: ${drift.length}`);
+for (const x of drift.slice(0, 15))
+    console.log(`  ${x.source}/${x.recordType}.${x.field} ×${x.count} (${x.firstVersion ?? '?'}–${x.lastVersion ?? '?'})`);

package/dist/app/server/cli.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+/**
+ * claude-inspect command line.
+ *
+ *   claude-inspect [--port 7717] [--open] [--token T | --no-auth]   start the dashboard
+ *   claude-inspect service install|uninstall|status [--port 47717]   autostart (macOS/Linux)
+ *   claude-inspect demo [--port 7718] [--out DIR]                    run on fictional demo data
+ *
+ * Everything is imported lazily: the demo must set CLAUDE_CONFIG_DIR before config.ts is loaded.
+ */
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseArgs } from 'node:util';
+const env = process.env;
+function version() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    for (const p of [join(here, '..', '..', 'package.json'), join(here, '..', '..', '..', 'package.json')]) {
+        try {
+            const pkg = JSON.parse(readFileSync(p, 'utf8'));
+            if (pkg.name === 'claude-inspect')
+                return pkg.version;
+        }
+        catch {
+            /* next candidate */
+        }
+    }
+    return '?';
+}
+const HELP = `claude-inspect ${version()} – live dashboard & history viewer for Claude Code agents
+
+Usage:
+  claude-inspect [options]                 start the dashboard (reads ~/.claude)
+  claude-inspect service install           start automatically at login (port 47717, no token)
+  claude-inspect service uninstall|status
+  claude-inspect demo                      try it on fictional demo data
+
+Options:
+  --port <n>       port (default 7717; service 47717; demo 7718)   env: CLAUDE_INSPECT_PORT
+  --open           open the browser
+  --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
+  --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`;
+const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+        port: { type: 'string' },
+        open: { type: 'boolean', default: false },
+        dev: { type: 'boolean', default: false },
+        token: { type: 'string', default: env.CLAUDE_INSPECT_TOKEN },
+        'no-auth': { type: 'boolean', default: env.CLAUDE_INSPECT_NO_AUTH === '1' },
+        out: { type: 'string' },
+        help: { type: 'boolean', short: 'h', default: false },
+        version: { type: 'boolean', short: 'v', default: false },
+    },
+});
+const [cmd, sub] = positionals;
+const port = (fallback) => Number(values.port ?? env.CLAUDE_INSPECT_PORT ?? fallback);
+if (values.help) {
+    console.log(HELP);
+}
+else if (values.version) {
+    console.log(version());
+}
+else if (cmd === 'service') {
+    const { service } = await import('./cli/service.js');
+    service(sub ?? 'status', Number(values.port ?? 47717));
+}
+else if (cmd === 'demo') {
+    const { runDemo } = await import('./cli/demo.js');
+    await runDemo({ out: values.out, port: port(7718), open: values.open });
+}
+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 });
+}
+else {
+    console.error(`Unknown command "${cmd}".\n\n${HELP}`);
+    process.exit(1);
+}

package/dist/app/server/config.js

@@ -0,0 +1,41 @@
+import { homedir } from 'node:os';
+import { join, relative, sep } from 'node:path';
+export const CLAUDE_DIR = process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude');
+export const paths = {
+    projects: join(CLAUDE_DIR, 'projects'),
+    sessions: join(CLAUDE_DIR, 'sessions'),
+    jobs: join(CLAUDE_DIR, 'jobs'),
+    daemonRoster: join(CLAUDE_DIR, 'daemon', 'roster.json'),
+    tasks: join(CLAUDE_DIR, 'tasks'),
+    history: join(CLAUDE_DIR, 'history.jsonl'),
+};
+/**
+ * Dateien mit Zugangsdaten. Werden nie gelesen – auch nicht über die Rohansicht.
+ * Pfade relativ zu CLAUDE_DIR, mit "/" als Trenner.
+ */
+const DENY = [
+    /\.key$/,
+    /^daemon\/(control\.key|auth\/)/,
+    /^ide\//,
+    /credentials/i,
+    /^session-env\//,
+    /^shell-snapshots\//,
+];
+export function relToClaude(abs) {
+    return relative(CLAUDE_DIR, abs).split(sep).join('/');
+}
+export function isDenied(abs) {
+    const rel = relToClaude(abs);
+    if (rel.startsWith('..'))
+        return true;
+    return DENY.some((r) => r.test(rel));
+}
+/** Limits für die Datenmenge, die ans Frontend geht. */
+export const LIMITS = {
+    /** Maximale Länge eines Strings in Einträgen, bevor gekürzt wird. */
+    maxString: 24_000,
+    /** Arbeitsspeicher-Budget für geladene Transcripts (Bytes der Quelldateien). */
+    transcriptCacheBytes: 400 * 1024 * 1024,
+    /** Rohansicht einer Zeile. */
+    maxRawLine: 4 * 1024 * 1024,
+};

package/dist/app/server/formats/history/prompt.js

@@ -0,0 +1,17 @@
+import { num, str } from '../util.js';
+/** ~/.claude/history.jsonl – jede Nutzereingabe über alle Projekte. */
+export const historyPromptDecoder = {
+    id: 'history.prompt@1',
+    source: 'history',
+    description: 'prompt history (prompt, project, session, time)',
+    match: (raw) => (typeof raw.display === 'string' ? 10 : 0),
+    decode: (raw) => ({ display: str(raw.display) ?? '', timestamp: num(raw.timestamp), project: str(raw.project), sessionId: str(raw.sessionId) }),
+    knownFields: () => ['display', 'timestamp', 'project', 'sessionId', 'pastedContents'],
+};
+export const historyFallback = {
+    id: 'history.fallback',
+    source: 'history',
+    description: 'unknown history entry',
+    match: () => 1,
+    decode: (raw) => ({ display: JSON.stringify(raw).slice(0, 200) }),
+};

package/dist/app/server/formats/index.js

@@ -0,0 +1,35 @@
+import { jobStateDecoder, jobStateFallback, jobTimelineDecoder, jobTimelineFallback, rosterDecoder, rosterFallback } from './job/job.js';
+import { processDecoderV1, processDecoderV2, processFallback } from './process/session-file.js';
+import { FormatRegistry } from './registry.js';
+import { historyFallback, historyPromptDecoder } from './history/prompt.js';
+import { subagentMetaDecoder, subagentMetaFallback } from './subagent/meta.js';
+import { taskDecoder, taskFallback } from './task/task.js';
+import { messageDecoder } from './transcript/message.js';
+import { attachmentDecoder, metaDecoder, systemDecoder, transcriptFallback } from './transcript/other.js';
+/** Zentrale Registry. Neue Decoder hier eintragen. */
+export const registry = new FormatRegistry()
+    // Transcripts
+    .register(messageDecoder)
+    .register(systemDecoder)
+    .register(attachmentDecoder)
+    .register(metaDecoder)
+    .register(transcriptFallback)
+    // Prozesse
+    .register(processDecoderV2)
+    .register(processDecoderV1)
+    .register(processFallback)
+    // Jobs & Daemon
+    .register(jobStateDecoder)
+    .register(jobStateFallback)
+    .register(jobTimelineDecoder)
+    .register(jobTimelineFallback)
+    .register(rosterDecoder)
+    .register(rosterFallback)
+    // Subagenten
+    .register(subagentMetaDecoder)
+    .register(subagentMetaFallback)
+    // Tasks & Eingabe-Historie
+    .register(taskDecoder)
+    .register(taskFallback)
+    .register(historyPromptDecoder)
+    .register(historyFallback);

package/dist/app/server/formats/job/job.js

@@ -0,0 +1,132 @@
+import { sanitize } from '../../util/sanitize.js';
+import { arr, extraFields, isObj, num, obj, str } from '../util.js';
+const STATE_FIELDS = [
+    'state',
+    'detail',
+    'tempo',
+    'inFlight',
+    'fan',
+    'tokens',
+    'output',
+    'children',
+    'linkScanOffset',
+    'linkScanPath',
+    'template',
+    'respawnFlags',
+    'intent',
+    'name',
+    'nameSource',
+    'sessionId',
+    'resumeSessionId',
+    'daemonShort',
+    'cliVersion',
+    'cwd',
+    'bridgeSessionId',
+    'bridgeOutboundOnly',
+    'bridgeOwnerAccountUuid',
+    'bridgeOwnerOrganizationUuid',
+    'bgIsolation',
+    'providerEnv',
+    'interactiveLineage',
+    'backend',
+    'createdAt',
+    'updatedAt',
+    'firstTerminalAt',
+    'lastTerminalAt',
+    'deadEpochReapedAt',
+    'bridgeSessionSeq',
+    'forkSourceAlive',
+    'forkBoundaryAt',
+    'forkSessionId',
+    'forkParentSessionId',
+];
+export const jobStateDecoder = {
+    id: 'job-state@1',
+    source: 'job-state',
+    description: 'background job: state, current step, running shells/monitors (fan)',
+    versions: '>=2.1.200',
+    match: (raw) => (typeof raw.state === 'string' && 'sessionId' in raw ? 10 : 0),
+    decode(raw) {
+        const fan = arr(raw.fan)
+            .filter(isObj)
+            .map((f) => ({ id: str(f.id) ?? '', kind: str(f.kind) ?? '?', label: str(f.label) ?? '', startedAt: num(f.startedAt) }));
+        const extra = extraFields(raw, STATE_FIELDS);
+        return {
+            state: str(raw.state),
+            detail: str(raw.detail),
+            tempo: str(raw.tempo),
+            fan,
+            tokens: num(raw.tokens),
+            intent: str(raw.intent),
+            name: str(raw.name),
+            sessionId: str(raw.sessionId),
+            resumeSessionId: str(raw.resumeSessionId),
+            cwd: str(raw.cwd),
+            cliVersion: str(raw.cliVersion),
+            createdAt: str(raw.createdAt),
+            updatedAt: str(raw.updatedAt),
+            inFlight: obj(raw.inFlight),
+            fork: raw.forkParentSessionId || raw.forkSessionId
+                ? {
+                    parentSessionId: str(raw.forkParentSessionId),
+                    sessionId: str(raw.forkSessionId),
+                    boundaryAt: str(raw.forkBoundaryAt),
+                    sourceAlive: typeof raw.forkSourceAlive === 'boolean' ? raw.forkSourceAlive : undefined,
+                }
+                : undefined,
+            extra: extra ? sanitize(extra) : undefined,
+        };
+    },
+    knownFields: () => STATE_FIELDS,
+};
+export const jobStateFallback = {
+    id: 'job-state.fallback',
+    source: 'job-state',
+    description: 'unknown job state',
+    match: () => 1,
+    decode: (raw) => ({ fan: [], extra: sanitize(raw) }),
+};
+export const jobTimelineDecoder = {
+    id: 'job-timeline@1',
+    source: 'job-timeline',
+    description: 'job status changes',
+    match: (raw) => (typeof raw.at === 'string' ? 10 : 0),
+    decode: (raw) => ({ at: str(raw.at), state: str(raw.state), detail: str(raw.detail), text: str(raw.text) }),
+    knownFields: () => ['at', 'state', 'detail', 'text'],
+};
+export const jobTimelineFallback = {
+    id: 'job-timeline.fallback',
+    source: 'job-timeline',
+    description: 'unknown timeline entry',
+    match: () => 1,
+    decode: (raw) => ({ at: str(raw.at) ?? '', text: JSON.stringify(sanitize(raw)) }),
+};
+export const rosterDecoder = {
+    id: 'daemon-roster@1',
+    source: 'daemon-roster',
+    description: 'daemon workers with launch info (resume/fork, source session)',
+    match: (raw) => (isObj(raw.workers) ? 10 : 0),
+    decode(raw) {
+        const out = {};
+        for (const [short, w] of Object.entries(obj(raw.workers) ?? {})) {
+            const dispatch = obj(obj(w)?.dispatch);
+            const launch = obj(dispatch?.launch);
+            const from = str(launch?.sessionId);
+            out[short] = {
+                mode: str(launch?.mode),
+                fork: launch?.fork === true,
+                source: str(dispatch?.source),
+                // sessionId ist hier teils ein Pfad zur .jsonl-Datei
+                fromSessionId: from?.replace(/^.*\//, '').replace(/\.jsonl$/, ''),
+            };
+        }
+        return out;
+    },
+};
+export const rosterFallback = {
+    id: 'daemon-roster.fallback',
+    source: 'daemon-roster',
+    description: 'unknown roster format',
+    match: () => 1,
+    decode: () => ({}),
+};

package/dist/app/server/formats/process/session-file.js

@@ -0,0 +1,77 @@
+import { sanitize } from '../../util/sanitize.js';
+import { arr, extraFields, num, str } from '../util.js';
+const FIELDS = [
+    'pid',
+    'sessionId',
+    'cwd',
+    'startedAt',
+    'procStart',
+    'version',
+    'kind',
+    'entrypoint',
+    'name',
+    'nameSource',
+    'nameSince',
+    'status',
+    'statusUpdatedAt',
+    'updatedAt',
+    'bridgeSessionId',
+    'jobId',
+    'parkedJobId',
+    'peerProtocol',
+    'peerFeatures',
+    'pidDomain',
+    'messagingSocketPath',
+    'agent',
+];
+function decode(raw) {
+    const extra = extraFields(raw, FIELDS);
+    return {
+        pid: num(raw.pid) ?? -1,
+        sessionId: str(raw.sessionId) ?? '',
+        cwd: str(raw.cwd),
+        name: str(raw.name),
+        nameSource: str(raw.nameSource),
+        kind: str(raw.kind),
+        entrypoint: str(raw.entrypoint),
+        version: str(raw.version),
+        status: str(raw.status),
+        statusUpdatedAt: num(raw.statusUpdatedAt),
+        startedAt: num(raw.startedAt),
+        updatedAt: num(raw.updatedAt),
+        bridgeSessionId: raw.bridgeSessionId === null ? null : str(raw.bridgeSessionId),
+        jobId: str(raw.jobId),
+        parkedJobId: str(raw.parkedJobId),
+        peerFeatures: arr(raw.peerFeatures).filter((x) => typeof x === 'string'),
+        agent: str(raw.agent),
+        procStart: str(raw.procStart),
+        extra: extra ? sanitize(extra) : undefined,
+    };
+}
+/** sessions/<pid>.json ab ca. 2.1.2xx: mit Status, Namen und Peer-Messaging. */
+export const processDecoderV2 = {
+    id: 'process.session-file@2',
+    source: 'process',
+    description: 'running process with status (busy/idle), name, job and bridge link',
+    versions: '>=2.1.200',
+    match: (raw) => (typeof raw.pid === 'number' && typeof raw.sessionId === 'string' && 'status' in raw ? 15 : 0),
+    decode,
+    knownFields: () => FIELDS,
+};
+/** Ältere, schlanke Variante (z. B. 2.1.114): nur pid, sessionId, cwd, startedAt, version, kind. */
+export const processDecoderV1 = {
+    id: 'process.session-file@1',
+    source: 'process',
+    description: 'running process, older variant without status',
+    versions: '<2.1.200',
+    match: (raw) => (typeof raw.pid === 'number' && typeof raw.sessionId === 'string' ? 10 : 0),
+    decode,
+    knownFields: () => FIELDS,
+};
+export const processFallback = {
+    id: 'process.fallback',
+    source: 'process',
+    description: 'unknown process file',
+    match: () => 1,
+    decode: (raw) => ({ pid: num(raw.pid) ?? -1, sessionId: str(raw.sessionId) ?? '', extra: sanitize(raw) }),
+};