@xerktech/claude-hud 0.1.0

package/dist/_broker/sessions.js

@@ -0,0 +1,792 @@
+import { LineSplitter, defaultSpawnClaude, encodeUserTurn, extractAssistantText, parseStreamJsonLine, } from "./claude.js";
+import { JsonlTailer } from "./jsonl-tail.js";
+const DEFAULT_IDLE_ARCHIVE_MS = 30 * 60 * 1000;
+const DEFAULT_SIGKILL_GRACE_MS = 2_000;
+export class SessionManager {
+    sessions = new Map();
+    focusedId;
+    bus;
+    spawn;
+    now;
+    defaultCwd;
+    idleArchiveMs;
+    sigkillGraceMs;
+    setTimer;
+    clearTimer;
+    onTerminate;
+    getHookEnv;
+    attachedHub;
+    tailerFactory;
+    nextNumericId = 1;
+    idleInterval;
+    constructor(opts) {
+        this.bus = opts.bus;
+        this.spawn = opts.spawn ?? defaultSpawnClaude;
+        this.now = opts.now ?? (() => Date.now());
+        this.defaultCwd = opts.defaultCwd ?? process.cwd();
+        this.idleArchiveMs = opts.idleArchiveMs ?? DEFAULT_IDLE_ARCHIVE_MS;
+        this.sigkillGraceMs = opts.sigkillGraceMs ?? DEFAULT_SIGKILL_GRACE_MS;
+        this.setTimer = opts.setTimer ?? ((cb, d) => setTimeout(cb, d));
+        this.clearTimer = opts.clearTimer ?? (t => clearTimeout(t));
+        this.onTerminate = opts.onTerminate;
+        this.getHookEnv = opts.getHookEnv;
+        this.attachedHub = opts.attachedHub;
+        this.tailerFactory =
+            opts.tailerFactory ??
+                (factoryOpts => new JsonlTailer({
+                    filePath: factoryOpts.filePath,
+                    onEvent: factoryOpts.onEvent,
+                    onError: factoryOpts.onError,
+                }));
+    }
+    /** Late-binding setter so `startServer` can wire the hub after construction. */
+    setAttachedHub(hub) {
+        this.attachedHub = hub;
+    }
+    /**
+     * Update the lazy hook-env lookup. Called by `startServer` once the
+     * listener is bound and the URL is known. Without this, every spawn would
+     * either need to wait on the listener or ship without the env vars.
+     */
+    setHookEnv(getHookEnv) {
+        this.getHookEnv = getHookEnv;
+    }
+    /**
+     * Construct the env-var bundle for one session's spawned `claude`. The
+     * bundled `broker/scripts/claude-hook.mjs` reads these to call back into
+     * the broker for permission decisions.
+     */
+    buildHookEnv(sessionId) {
+        const cfg = this.getHookEnv?.();
+        if (!cfg)
+            return undefined;
+        const env = {
+            BROKER_HOOKS_URL: cfg.url,
+            BROKER_HOOKS_TOKEN: cfg.token,
+            BROKER_SESSION_ID: sessionId,
+        };
+        if (cfg.insecure)
+            env.BROKER_HOOKS_INSECURE = '1';
+        return env;
+    }
+    list() {
+        return [...this.sessions.values()].map(toPublic);
+    }
+    active() {
+        return this.list().filter(s => s.status !== 'archived' && s.status !== 'exited' && s.status !== 'error');
+    }
+    get(id) {
+        const s = this.sessions.get(id);
+        return s ? toPublic(s) : undefined;
+    }
+    /**
+     * Find the most recently active non-archived/exited session for a given
+     * project. Used by the voice intent dispatcher to resolve `focus <project>`
+     * and `end session in <project>` to a concrete session id.
+     */
+    findActiveByProject(projectId) {
+        const active = [...this.sessions.values()]
+            .filter(s => s.projectId === projectId &&
+            s.status !== 'archived' &&
+            s.status !== 'exited' &&
+            s.status !== 'error')
+            .sort((a, b) => b.lastActivityAt - a.lastActivityAt);
+        return active[0] ? toPublic(active[0]) : undefined;
+    }
+    getFocusedId() {
+        return this.focusedId;
+    }
+    getFocused() {
+        return this.focusedId ? this.get(this.focusedId) : undefined;
+    }
+    /**
+     * Create a new session. M5 requires `projectId` + `cwd`; older callers (M3-era
+     * tests) pass neither and get sensible defaults so the existing single-session
+     * smoke path keeps working.
+     */
+    create(opts = {}) {
+        const id = opts.id ?? `s${this.nextNumericId++}`;
+        if (this.sessions.has(id)) {
+            throw new Error(`session ${id} already exists`);
+        }
+        const cwd = opts.cwd ?? this.defaultCwd;
+        const projectId = opts.projectId ?? '__default__';
+        const label = opts.label ?? id;
+        const now = this.now();
+        const process = this.spawn({
+            cwd,
+            resumeId: opts.resumeClaudeSessionId,
+            model: opts.model,
+            env: this.buildHookEnv(id),
+        });
+        const splitter = new LineSplitter();
+        const internal = {
+            id,
+            projectId,
+            cwd,
+            label,
+            status: 'starting',
+            kind: 'spawned',
+            claudeSessionId: opts.resumeClaudeSessionId,
+            createdAt: now,
+            lastActivityAt: now,
+            lastEventId: 0,
+            unreadBadges: 0,
+            process,
+            splitter,
+            disposers: [],
+        };
+        const onData = process.onData(chunk => this.handleChunk(internal, chunk));
+        const onExit = process.onExit(info => this.handleExit(internal, info));
+        internal.disposers.push(onData, onExit);
+        this.sessions.set(id, internal);
+        this.emit(internal, 'session.created', {
+            sessionId: id,
+            projectId,
+            cwd,
+            label,
+            createdAt: now,
+        });
+        if (opts.initialPrompt && opts.initialPrompt.length > 0) {
+            // Defer one tick so the SSE bus has a chance to deliver session.created
+            // before the user_input event lands on the same channel.
+            this.setTimer(() => {
+                if (this.sessions.has(id))
+                    this.writeInput(id, opts.initialPrompt);
+            }, 0);
+        }
+        return toPublic(internal);
+    }
+    /**
+     * Register an attached session — one whose `claude` process is owned by the
+     * `claude-hud` wrapper running in the user's terminal, not by us. We tail
+     * the on-disk `.jsonl` file Claude Code writes and emit the same
+     * `assistant_text` / `system_init` / `turn_end` events the spawned path
+     * does, so the glasses-side router doesn't need to care about the kind.
+     */
+    attach(input) {
+        if (this.sessions.has(input.id)) {
+            const existing = this.sessions.get(input.id);
+            if (existing)
+                return toPublic(existing);
+            throw new Error(`session ${input.id} already exists`);
+        }
+        const now = this.now();
+        const label = input.label ?? input.id;
+        const splitter = new LineSplitter();
+        const internal = {
+            id: input.id,
+            projectId: input.projectId,
+            cwd: input.cwd,
+            label,
+            status: 'idle',
+            kind: 'attached',
+            claudeSessionId: input.id,
+            wrapperPid: input.wrapperPid,
+            createdAt: now,
+            lastActivityAt: now,
+            lastEventId: 0,
+            unreadBadges: 0,
+            splitter,
+            disposers: [],
+            seenAssistantIds: new Set(),
+        };
+        this.sessions.set(input.id, internal);
+        const tailer = this.tailerFactory({
+            filePath: input.jsonlPath,
+            onEvent: ev => this.handleAttachedEvent(internal, ev),
+            onError: err => {
+                console.warn(`[sessions] attached=${internal.id} jsonl: ${err.message}`);
+            },
+        });
+        internal.tailer = tailer;
+        void tailer.start().catch(err => {
+            console.warn(`[sessions] attached=${internal.id} tailer.start failed: ${err.message}`);
+        });
+        this.emit(internal, 'session.created', {
+            sessionId: internal.id,
+            projectId: internal.projectId,
+            cwd: internal.cwd,
+            label,
+            createdAt: now,
+            kind: 'attached',
+        });
+        return toPublic(internal);
+    }
+    /**
+     * The wrapper reported its `claude` process has exited (or got disconnected).
+     * Mark the session ended and tear down the tailer.
+     */
+    async detach(id, opts = {}) {
+        const s = this.sessions.get(id);
+        if (!s)
+            return false;
+        if (s.kind !== 'attached')
+            return false;
+        if (s.status === 'exited' || s.status === 'error' || s.status === 'archived')
+            return false;
+        s.status = 'exited';
+        s.exitCode = opts.exitCode;
+        s.lastActivityAt = this.now();
+        if (s.tailer) {
+            try {
+                await s.tailer.stop();
+            }
+            catch {
+                // ignore
+            }
+            s.tailer = undefined;
+        }
+        this.attachedHub?.unregister(id);
+        this.emit(s, 'session.ended', {
+            sessionId: id,
+            exitCode: opts.exitCode,
+        });
+        this.onTerminate?.(id, 'exited');
+        if (this.focusedId === id)
+            this.refocusAfterDrop(id);
+        return true;
+    }
+    handleAttachedEvent(s, ev) {
+        s.lastActivityAt = this.now();
+        this.bumpBadge(s);
+        const type = typeof ev.type === 'string' ? ev.type : '';
+        // Claude Code's session jsonl uses different field names than the spawned
+        // stream-json transport. The cases we care about for the glasses:
+        //   - `{ type: 'summary', summary }` — emit as system_init equivalent
+        //   - `{ type: 'user', message: {...} }` — user echo (already shown locally)
+        //   - `{ type: 'assistant', message: { id, content: [...] } }` — text out
+        if (type === 'assistant') {
+            const message = (ev.message ?? {});
+            const msgId = typeof message.id === 'string' ? message.id : undefined;
+            if (msgId) {
+                if (s.seenAssistantIds?.has(msgId))
+                    return;
+                s.seenAssistantIds?.add(msgId);
+            }
+            const text = extractAssistantTextFromContent(message.content);
+            if (text !== null) {
+                s.status = 'thinking';
+                this.emit(s, 'assistant_text', { text });
+            }
+            else {
+                // Tool-use blocks etc. — pass raw so the plugin can render glyphs.
+                this.emit(s, 'stream_raw', ev);
+            }
+            return;
+        }
+        if (type === 'user') {
+            const message = (ev.message ?? {});
+            const content = message.content;
+            if (typeof content === 'string') {
+                this.emit(s, 'user_input', { text: content });
+            }
+            else if (Array.isArray(content)) {
+                // user blocks include tool_result; filter to plain text only.
+                const text = content
+                    .filter(b => b?.type === 'text' && typeof b.text === 'string')
+                    .map(b => b.text)
+                    .join('');
+                if (text)
+                    this.emit(s, 'user_input', { text });
+            }
+            return;
+        }
+        if (type === 'summary' || type === 'system') {
+            // Treat the first system/summary line as the equivalent of system_init.
+            this.emit(s, 'system_init', { claudeSessionId: s.claudeSessionId, model: ev.model });
+            return;
+        }
+        // Anything else — pass through as raw for transparency / debug.
+        this.emit(s, 'stream_raw', ev);
+    }
+    writeInput(id, text) {
+        const s = this.sessions.get(id);
+        if (!s)
+            return false;
+        if (s.status === 'exited' || s.status === 'error' || s.status === 'archived')
+            return false;
+        if (s.kind === 'attached') {
+            // Attached sessions: the wrapper owns the pty. Push the text through the
+            // wrapper's inject WS instead of writing stream-json. If the wrapper has
+            // disconnected (broker survived but the user's terminal closed), drop
+            // the input — the caller can resurface a `[wrapper offline]` toast.
+            const delivered = this.attachedHub?.send(id, text) ?? false;
+            if (!delivered)
+                return false;
+            s.lastActivityAt = this.now();
+            s.status = 'thinking';
+            this.emit(s, 'user_input', { text });
+            return true;
+        }
+        if (!s.process)
+            return false;
+        s.process.write(encodeUserTurn(text));
+        s.lastActivityAt = this.now();
+        s.status = 'thinking';
+        this.emit(s, 'user_input', { text });
+        return true;
+    }
+    /**
+     * Record a user intent (M4: only `approve` so far). Does not touch the pty —
+     * intents are bookkeeping events for the SSE bus. M7 wires `approve` into the
+     * Claude Code permission / AskUserQuestion hook responses.
+     */
+    /**
+     * Flip a session's status to/from `awaiting_permission` / `awaiting_question`.
+     * Wired from `HookManager.onPendingChange`: when a session has any pending
+     * hook, status is `awaiting_*`; when the last one resolves, status returns
+     * to whatever it was (defaults to `thinking` since hooks land mid-turn).
+     * Idempotent and a no-op for ended sessions.
+     */
+    setHookStatus(id, kind) {
+        const s = this.sessions.get(id);
+        if (!s)
+            return false;
+        if (s.status === 'exited' || s.status === 'error' || s.status === 'archived')
+            return false;
+        if (kind === 'permission')
+            s.status = 'awaiting_permission';
+        else if (kind === 'question')
+            s.status = 'awaiting_question';
+        else
+            s.status = 'thinking';
+        s.lastActivityAt = this.now();
+        return true;
+    }
+    recordIntent(id, intent, source) {
+        const s = this.sessions.get(id);
+        if (!s)
+            return false;
+        if (s.status === 'exited' || s.status === 'error' || s.status === 'archived')
+            return false;
+        s.lastActivityAt = this.now();
+        this.emit(s, 'user_intent', { intent, source: source ?? 'unknown' });
+        return true;
+    }
+    /**
+     * Focus a session. No-op if it's already focused or doesn't exist. Resets the
+     * unread-badge counter and emits `focus.changed` on the focused session's bus
+     * channel (so clients subscribed to that channel see the focus event).
+     */
+    focus(id) {
+        if (id === this.focusedId)
+            return false;
+        if (id !== undefined && !this.sessions.has(id))
+            return false;
+        const previousId = this.focusedId;
+        this.focusedId = id;
+        if (id !== undefined) {
+            const s = this.sessions.get(id);
+            if (s) {
+                s.unreadBadges = 0;
+                this.emit(s, 'focus.changed', { focusedId: id, previousId });
+            }
+        }
+        else if (previousId !== undefined) {
+            const prev = this.sessions.get(previousId);
+            if (prev)
+                this.emit(prev, 'focus.changed', { focusedId: null, previousId });
+        }
+        return true;
+    }
+    /**
+     * Initiate graceful shutdown. Sends SIGTERM, waits `sigkillGraceMs`, then
+     * SIGKILL if the process is still alive. `handleExit` does the final cleanup
+     * + emits `session.ended`.
+     *
+     * For attached sessions the broker doesn't own the `claude` process — the
+     * wrapper in the user's terminal does. We can't kill it, but we can
+     * synthesise a detach so the glasses reflect that this session is gone.
+     */
+    end(id) {
+        const s = this.sessions.get(id);
+        if (!s)
+            return false;
+        if (s.status === 'exited' || s.status === 'error' || s.status === 'archived')
+            return false;
+        if (s.kind === 'attached') {
+            void this.detach(id);
+            return true;
+        }
+        if (!s.process)
+            return false;
+        try {
+            s.process.kill('SIGTERM');
+        }
+        catch {
+            // pty already gone — onExit will fire (or has fired).
+        }
+        s.sigkillTimer = this.setTimer(() => {
+            const alive = this.sessions.get(id);
+            if (!alive || !alive.process)
+                return;
+            if (alive.status === 'exited' || alive.status === 'error' || alive.status === 'archived')
+                return;
+            try {
+                alive.process.kill('SIGKILL');
+            }
+            catch {
+                // ignore
+            }
+        }, this.sigkillGraceMs);
+        return true;
+    }
+    /**
+     * Archive an idle session. Kills the pty, marks status `archived`, leaves the
+     * registry entry in place so it can be resumed later (M5 stretch).
+     */
+    archive(id) {
+        const s = this.sessions.get(id);
+        if (!s)
+            return false;
+        if (s.status === 'archived')
+            return false;
+        if (s.process) {
+            try {
+                s.process.kill('SIGTERM');
+            }
+            catch {
+                // ignore
+            }
+        }
+        if (s.tailer) {
+            // Best-effort — let the tailer close async; we don't wait.
+            void s.tailer.stop().catch(() => undefined);
+            s.tailer = undefined;
+        }
+        this.attachedHub?.unregister(id);
+        if (s.sigkillTimer)
+            this.clearTimer(s.sigkillTimer);
+        s.status = 'archived';
+        s.lastActivityAt = this.now();
+        for (const d of s.disposers) {
+            try {
+                d();
+            }
+            catch {
+                // ignore
+            }
+        }
+        s.disposers = [];
+        s.process = undefined;
+        this.emit(s, 'session.archived', { sessionId: id });
+        this.onTerminate?.(id, 'archived');
+        if (this.focusedId === id)
+            this.refocusAfterDrop(id);
+        return true;
+    }
+    /**
+     * Sweep idle sessions older than `idleArchiveMs`. Returns the number archived.
+     * Sessions in `thinking`, `starting`, or any awaiting state are never touched.
+     */
+    archiveIdle() {
+        const cutoff = this.now() - this.idleArchiveMs;
+        let count = 0;
+        for (const s of [...this.sessions.values()]) {
+            if (s.status !== 'idle')
+                continue;
+            if (s.lastActivityAt >= cutoff)
+                continue;
+            if (this.archive(s.id))
+                count += 1;
+        }
+        return count;
+    }
+    startIdleArchiver(intervalMs = 60_000) {
+        if (this.idleInterval)
+            return;
+        this.idleInterval = setInterval(() => this.archiveIdle(), intervalMs);
+    }
+    stopIdleArchiver() {
+        if (this.idleInterval) {
+            clearInterval(this.idleInterval);
+            this.idleInterval = undefined;
+        }
+    }
+    async closeAll() {
+        this.stopIdleArchiver();
+        for (const s of [...this.sessions.values()]) {
+            if (s.sigkillTimer)
+                this.clearTimer(s.sigkillTimer);
+            if (s.process) {
+                try {
+                    s.process.kill('SIGTERM');
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    /** Persist the registry to a portable snapshot. */
+    snapshot() {
+        return {
+            version: 1,
+            sessions: [...this.sessions.values()].map(snapshotSession),
+            focusedId: this.focusedId,
+        };
+    }
+    /**
+     * Re-attach to active sessions on broker restart. Each session whose status
+     * was not `archived`/`exited`/`error` is respawned with `claude --resume`.
+     * Sessions that have no `claudeSessionId` (never got past `starting`) are
+     * dropped — there's nothing to resume.
+     */
+    hydrate(file) {
+        for (const snap of file.sessions) {
+            if (this.sessions.has(snap.id))
+                continue;
+            // Attached sessions can't be hydrated: the wrapper owns the `claude`
+            // process and the wrapper is no longer running. The user will re-attach
+            // by running `claude-hud` again. We keep the entry in `archived` so the
+            // glasses can show it as dormant rather than dropping it entirely.
+            if ((snap.kind ?? 'spawned') === 'attached') {
+                const splitter = new LineSplitter();
+                this.sessions.set(snap.id, {
+                    ...snap,
+                    kind: 'attached',
+                    status: 'archived',
+                    lastEventId: 0,
+                    splitter,
+                    disposers: [],
+                });
+                continue;
+            }
+            if (snap.status === 'archived' || snap.status === 'exited' || snap.status === 'error') {
+                // Dormant — keep the metadata so the user can revive it later.
+                const splitter = new LineSplitter();
+                this.sessions.set(snap.id, {
+                    ...snap,
+                    kind: 'spawned',
+                    lastEventId: 0,
+                    splitter,
+                    disposers: [],
+                });
+                continue;
+            }
+            if (!snap.claudeSessionId)
+                continue;
+            const process = this.spawn({
+                cwd: snap.cwd,
+                resumeId: snap.claudeSessionId,
+                env: this.buildHookEnv(snap.id),
+            });
+            const splitter = new LineSplitter();
+            const internal = {
+                ...snap,
+                kind: 'spawned',
+                status: 'starting',
+                lastEventId: 0,
+                process,
+                splitter,
+                disposers: [],
+            };
+            const onData = process.onData(chunk => this.handleChunk(internal, chunk));
+            const onExit = process.onExit(info => this.handleExit(internal, info));
+            internal.disposers.push(onData, onExit);
+            this.sessions.set(snap.id, internal);
+            this.emit(internal, 'session.created', {
+                sessionId: snap.id,
+                projectId: snap.projectId,
+                cwd: snap.cwd,
+                label: snap.label,
+                resumed: true,
+            });
+        }
+        if (file.focusedId && this.sessions.has(file.focusedId)) {
+            this.focusedId = file.focusedId;
+        }
+    }
+    handleChunk(s, chunk) {
+        const lines = s.splitter.push(chunk);
+        for (const line of lines) {
+            const ev = parseStreamJsonLine(line);
+            if (!ev)
+                continue;
+            this.handleStreamEvent(s, ev);
+        }
+    }
+    handleStreamEvent(s, ev) {
+        s.lastActivityAt = this.now();
+        this.bumpBadge(s);
+        if (ev.type === 'system' && ev.subtype === 'init') {
+            if (typeof ev.session_id === 'string') {
+                s.claudeSessionId = ev.session_id;
+            }
+            s.status = 'idle';
+            this.emit(s, 'system_init', {
+                claudeSessionId: ev.session_id,
+                model: ev.model,
+            });
+            return;
+        }
+        if (ev.type === 'assistant') {
+            const text = extractAssistantText(ev);
+            if (text !== null) {
+                s.status = 'thinking';
+                this.emit(s, 'assistant_text', { text });
+            }
+            return;
+        }
+        if (ev.type === 'result') {
+            s.status = 'idle';
+            this.emit(s, 'turn_end', {
+                durationMs: ev.duration_ms,
+                costUsd: ev.total_cost_usd,
+                isError: ev.is_error ?? false,
+                result: ev.result,
+            });
+            return;
+        }
+        if (ev.type === 'error') {
+            s.status = 'error';
+            this.emit(s, 'session_error', { message: ev.message ?? 'unknown error' });
+            return;
+        }
+        // Anything else (user echo, tool_use, etc.) — emit as raw for transparency.
+        this.emit(s, 'stream_raw', ev);
+    }
+    handleExit(s, info) {
+        if (s.sigkillTimer) {
+            this.clearTimer(s.sigkillTimer);
+            s.sigkillTimer = undefined;
+        }
+        // If we'd already archived, the archive path emitted `session.archived` —
+        // exit is the natural follow-on, no need for a duplicate `session.ended`.
+        if (s.status === 'archived') {
+            for (const d of s.disposers) {
+                try {
+                    d();
+                }
+                catch {
+                    // ignore
+                }
+            }
+            s.disposers = [];
+            s.process = undefined;
+            return;
+        }
+        const wasError = s.status === 'error';
+        s.status = wasError ? 'error' : 'exited';
+        s.exitCode = info.exitCode;
+        s.lastActivityAt = this.now();
+        for (const d of s.disposers) {
+            try {
+                d();
+            }
+            catch {
+                // ignore
+            }
+        }
+        s.disposers = [];
+        s.process = undefined;
+        this.emit(s, 'session.ended', {
+            sessionId: s.id,
+            exitCode: info.exitCode,
+            signal: info.signal,
+        });
+        this.onTerminate?.(s.id, wasError ? 'error' : 'exited');
+        if (this.focusedId === s.id)
+            this.refocusAfterDrop(s.id);
+    }
+    /**
+     * CLAUDE.md §8.7 — when the focused session ends/archives, jump to the
+     * most-recent other active session, or clear focus if there is none.
+     */
+    refocusAfterDrop(droppedId) {
+        const candidates = [...this.sessions.values()]
+            .filter(s => s.id !== droppedId &&
+            s.status !== 'archived' &&
+            s.status !== 'exited' &&
+            s.status !== 'error')
+            .sort((a, b) => b.lastActivityAt - a.lastActivityAt);
+        const next = candidates[0]?.id;
+        this.focusedId = next;
+        if (next) {
+            const s = this.sessions.get(next);
+            if (s) {
+                s.unreadBadges = 0;
+                this.emit(s, 'focus.changed', {
+                    focusedId: next,
+                    previousId: droppedId,
+                    reason: 'fallback',
+                });
+            }
+        }
+        else {
+            // No surviving sessions to focus — emit `focus.changed` on the dropped
+            // channel so clients watching that channel can route to the empty switcher.
+            const prev = this.sessions.get(droppedId);
+            if (prev)
+                this.emit(prev, 'focus.changed', {
+                    focusedId: null,
+                    previousId: droppedId,
+                    reason: 'fallback',
+                });
+        }
+    }
+    bumpBadge(s) {
+        if (this.focusedId === s.id)
+            return;
+        s.unreadBadges += 1;
+    }
+    emit(s, event, data) {
+        const published = this.bus.publish(channelName(s.id), event, data);
+        s.lastEventId = published.id;
+        // Mirror lifecycle-shaped events onto the global channel so the plugin
+        // (or any future client) can observe every session's lifecycle without
+        // pre-subscribing to each per-session channel. Without this mirror, a
+        // voice-spawned session emits `session.created` + `focus.changed` on a
+        // channel nobody is yet listening to.
+        if (LIFECYCLE_EVENTS.has(event)) {
+            this.bus.publish(LIFECYCLE_CHANNEL, event, { sessionId: s.id, ...data });
+        }
+    }
+}
+export const LIFECYCLE_CHANNEL = 'broker:lifecycle';
+const LIFECYCLE_EVENTS = new Set([
+    'session.created',
+    'session.ended',
+    'session.archived',
+    'focus.changed',
+]);
+export function channelName(sessionId) {
+    return `session:${sessionId}`;
+}
+function toPublic(s) {
+    const { process: _p, splitter: _sp, disposers: _d, sigkillTimer: _t, tailer: _tailer, seenAssistantIds: _seen, ...pub } = s;
+    return pub;
+}
+function snapshotSession(s) {
+    return {
+        id: s.id,
+        projectId: s.projectId,
+        cwd: s.cwd,
+        label: s.label,
+        status: s.status,
+        kind: s.kind,
+        claudeSessionId: s.claudeSessionId,
+        createdAt: s.createdAt,
+        lastActivityAt: s.lastActivityAt,
+        unreadBadges: s.unreadBadges,
+    };
+}
+/**
+ * Pull plain assistant text out of the jsonl's `content` field. The shape is
+ * the same as the spawned stream-json's `message.content`: an array of typed
+ * blocks. We keep tool_use / tool_result blocks for future glyph rendering
+ * (they fall out through `stream_raw`).
+ */
+function extractAssistantTextFromContent(content) {
+    if (typeof content === 'string')
+        return content.length > 0 ? content : null;
+    if (!Array.isArray(content))
+        return null;
+    const text = content
+        .filter(b => b?.type === 'text' && typeof b.text === 'string')
+        .map(b => b.text)
+        .join('');
+    return text.length > 0 ? text : null;
+}
+//# sourceMappingURL=sessions.js.map