@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/meetings/live-transcription.d.ts

@@ -0,0 +1,57 @@
+import type { Readable } from "node:stream";
+import type { SherpaOfflineRecognizerEngine } from "../speech/providers/local/sherpa/sherpa-offline-recognizer.js";
+import { type SherpaSileroVadSessionConfig } from "../speech/providers/local/sherpa/silero-vad-session.js";
+export interface LiveTranscriptionHeader {
+    sampleRate: number;
+    channels: number;
+    format: "f32le";
+    track: string;
+}
+export type LiveTranscriptEvent = {
+    type: "partial";
+    segmentId: string;
+    text: string;
+    atSeconds: number;
+} | {
+    type: "final";
+    segmentId: string;
+    text: string;
+    atSeconds: number;
+} | {
+    type: "error";
+    error: Error;
+};
+interface DebugLogger {
+    debug: (...args: unknown[]) => void;
+}
+export interface CreateLiveTranscriptionParams {
+    /** Readable carrying the framed f32le protocol (header line + length-prefixed blocks). */
+    stream: Readable;
+    /** Shared 16000-Hz offline recognizer the realtime session decodes against. */
+    engine: SherpaOfflineRecognizerEngine;
+    /** Injected event sink - a plain function, no WebSocket/orchestrator here. */
+    sink: (event: LiveTranscriptEvent) => void;
+    logger?: DebugLogger;
+    /** Realtime decode throttle; defaults to 350ms (preserved from the realtime session default). */
+    minDecodeIntervalMs?: number;
+    vadConfig?: SherpaSileroVadSessionConfig;
+    maxQueuedFrames?: number;
+}
+export interface LiveTranscriptionHandle {
+    /** The parsed header - resolves once the header line has been read off the stream. */
+    readonly header: Promise<LiveTranscriptionHeader>;
+    /** Force a final on the realtime session (orchestrator stop hook). Does not tear down. */
+    commit: () => void;
+    /** Flush + force a final + tear down both sessions. Idempotent. */
+    close: () => Promise<void>;
+    /** Resolves when the stream ends (or errors) and the final has been flushed. */
+    readonly done: Promise<void>;
+}
+/**
+ * Wire a live f32le capture stream into the on-device realtime STT stack and forward
+ * partial/final transcript events to `sink`. Returns a handle exposing the header, a `commit()`
+ * stop hook, `close()`, and a `done` promise that settles when the stream ends.
+ */
+export declare function createLiveTranscription(params: CreateLiveTranscriptionParams): Promise<LiveTranscriptionHandle>;
+export {};
+//# sourceMappingURL=live-transcription.d.ts.map

package/dist/server/server/meetings/live-transcription.js

@@ -0,0 +1,280 @@
+// LIVE-TRANSCRIPT INGEST SEAM (Story 2.1, ported from the earlier Story 3.1). Turns a live f32le
+// capture stream (from `meetcap capture --emit pcm`) into realtime partial/final transcript
+// events, without any WebSocket, orchestrator, or persistence - those live in the orchestrator +
+// capture-stream WS. The seam is a plain function with an injected sink; its `commit()`/`close()`
+// are exposed hooks for the orchestrator to force a final on stop.
+//
+// Conversion chain (explicit, one direction):
+//   f32le @ header.sampleRate  -> float32ToPcm16le -> pcm16le
+//   -> Pcm16MonoResampler(->16000)  ONLY when header.sampleRate !== 16000, else passthrough
+//   -> SherpaSileroVadSession.appendPcm16 (VAD gate; tracks in-speech)
+//   -> SherpaParakeetRealtimeTranscriptionSession.appendPcm16  ONLY while in-speech.
+// Both the realtime and VAD sessions run at 16000 mono; the realtime session is built against a
+// caller-supplied shared SherpaOfflineRecognizerEngine (sampleRate === 16000).
+//
+// Wire protocol consumed (matches the native emitter): one single-line UTF-8 JSON header
+// terminated by `\n` - {"sampleRate","channels","format":"f32le","track"} - then repeated
+// `[uint32 LE byteLength][byteLength bytes of f32le]` blocks. Explicit lengths mean a partial
+// socket read never desyncs f32le sample boundaries; the reader buffers across chunks until a
+// whole length-prefixed block is available.
+import { once } from "node:events";
+import { Pcm16MonoResampler } from "../agent/pcm16-resampler.js";
+import { float32ToPcm16le } from "../speech/audio.js";
+import { SherpaParakeetRealtimeTranscriptionSession } from "../speech/providers/local/sherpa/sherpa-parakeet-realtime-session.js";
+import { SherpaSileroVadSession, } from "../speech/providers/local/sherpa/silero-vad-session.js";
+const TARGET_SAMPLE_RATE = 16000;
+const DEFAULT_MIN_DECODE_INTERVAL_MS = 350;
+// Drop-oldest ring bound. The decode path is synchronous per frame and the realtime decode is
+// throttled + async, so this never fills in practice - it is a guard so a slow consumer can
+// never apply pipe backpressure that would stall the stdout reader (and thus `meetcap`).
+const DEFAULT_MAX_QUEUED_FRAMES = 512;
+// Safety cap on how long `finalize()` waits for the forced-final decode to land. The realtime
+// session emits `committed` right after its decode resolves, so this is only insurance against a
+// wedged native decode - not a timing dependency the happy path relies on.
+const FINALIZE_TIMEOUT_MS = 5000;
+function toError(value) {
+    return value instanceof Error ? value : new Error(String(value));
+}
+function parseHeaderLine(line) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        throw new Error(`live-transcription: malformed header line: ${JSON.stringify(line)}`);
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+        throw new Error("live-transcription: header is not a JSON object");
+    }
+    const header = parsed;
+    if (header.format !== "f32le") {
+        throw new Error(`live-transcription: unsupported format ${String(header.format)} (want f32le)`);
+    }
+    const { sampleRate, channels } = header;
+    if (typeof sampleRate !== "number" || !Number.isInteger(sampleRate) || sampleRate <= 0) {
+        throw new Error(`live-transcription: invalid sampleRate ${String(sampleRate)}`);
+    }
+    if (typeof channels !== "number" || !Number.isInteger(channels) || channels <= 0) {
+        throw new Error(`live-transcription: invalid channels ${String(channels)}`);
+    }
+    return {
+        sampleRate,
+        channels,
+        format: "f32le",
+        track: typeof header.track === "string" ? header.track : "near",
+    };
+}
+/** Copy f32le bytes -> Float32Array. `readFloatLE` sidesteps Buffer byteOffset alignment. */
+function f32leToFloat32(block) {
+    if (block.length % 4 !== 0) {
+        throw new Error(`live-transcription: f32le block byteLength must be a multiple of 4, got ${block.length}`);
+    }
+    const out = new Float32Array(block.length / 4);
+    for (let i = 0; i < out.length; i += 1) {
+        out[i] = block.readFloatLE(i * 4);
+    }
+    return out;
+}
+/**
+ * Wire a live f32le capture stream into the on-device realtime STT stack and forward
+ * partial/final transcript events to `sink`. Returns a handle exposing the header, a `commit()`
+ * stop hook, `close()`, and a `done` promise that settles when the stream ends.
+ */
+export async function createLiveTranscription(params) {
+    const { stream, engine, sink } = params;
+    const logger = params.logger ?? { debug: () => { } };
+    const minDecodeIntervalMs = params.minDecodeIntervalMs ?? DEFAULT_MIN_DECODE_INTERVAL_MS;
+    const maxQueuedFrames = params.maxQueuedFrames ?? DEFAULT_MAX_QUEUED_FRAMES;
+    const vad = new SherpaSileroVadSession({ logger, config: params.vadConfig });
+    const realtime = new SherpaParakeetRealtimeTranscriptionSession({ engine, minDecodeIntervalMs });
+    await vad.connect();
+    await realtime.connect();
+    // atSeconds is the cumulative resampled-audio clock (all frames, in-speech or not) / 16000.
+    let totalResampledSamples = 0;
+    const atSeconds = () => totalResampledSamples / TARGET_SAMPLE_RATE;
+    let inSpeech = false;
+    vad.on("speech_started", () => {
+        inSpeech = true;
+    });
+    vad.on("speech_stopped", () => {
+        inSpeech = false;
+    });
+    vad.on("error", (err) => sink({ type: "error", error: toError(err) }));
+    realtime.on("transcript", (payload) => {
+        sink({
+            type: payload.isFinal ? "final" : "partial",
+            segmentId: payload.segmentId,
+            text: payload.transcript,
+            atSeconds: atSeconds(),
+        });
+    });
+    // `committed` is the final-boundary signal; the `transcript` (isFinal) emitted right after it
+    // carries the text, so the sink is driven from `transcript` above. Hook kept explicit per spec.
+    realtime.on("committed", () => { });
+    realtime.on("error", (err) => sink({ type: "error", error: toError(err) }));
+    let header = null;
+    let resampler = null;
+    let residual = Buffer.alloc(0);
+    let headerResolve;
+    let headerReject;
+    const headerPromise = new Promise((resolve, reject) => {
+        headerResolve = resolve;
+        headerReject = reject;
+    });
+    // Suppress unhandled-rejection noise when a caller never awaits `.header` (e.g. a malformed
+    // header settles via the sink `error` + `done` instead). Awaiters still observe the rejection.
+    void headerPromise.catch(() => { });
+    // Bounded drop-oldest ring of decoded 16k pcm16 frames, drained off the data-handler stack so
+    // the stream reader never awaits decode work (AC 7).
+    const ring = [];
+    let droppedFrames = 0;
+    let drainScheduled = false;
+    function drain() {
+        drainScheduled = false;
+        while (ring.length > 0) {
+            const frame = ring.shift();
+            totalResampledSamples += frame.length / 2;
+            vad.appendPcm16(frame); // may flip `inSpeech` synchronously via its events
+            if (inSpeech) {
+                realtime.appendPcm16(frame);
+            }
+        }
+    }
+    function enqueue(frame16k) {
+        if (frame16k.length === 0) {
+            return;
+        }
+        if (ring.length >= maxQueuedFrames) {
+            ring.shift();
+            droppedFrames += 1;
+        }
+        ring.push(frame16k);
+        if (!drainScheduled) {
+            drainScheduled = true;
+            queueMicrotask(drain);
+        }
+    }
+    function handleBlock(block) {
+        const floats = f32leToFloat32(block);
+        const pcm16 = float32ToPcm16le(floats);
+        const frame16k = resampler ? resampler.processChunk(pcm16) : pcm16;
+        enqueue(frame16k);
+    }
+    function extractFrames() {
+        if (!header) {
+            const newline = residual.indexOf(0x0a);
+            if (newline < 0) {
+                return; // header line not fully received yet
+            }
+            const line = residual.subarray(0, newline).toString("utf8");
+            header = parseHeaderLine(line);
+            resampler =
+                header.sampleRate !== TARGET_SAMPLE_RATE
+                    ? new Pcm16MonoResampler({ inputRate: header.sampleRate, outputRate: TARGET_SAMPLE_RATE })
+                    : null;
+            residual = residual.subarray(newline + 1);
+            logger.debug({ header, resampling: resampler !== null }, "[live-transcription] header parsed");
+            headerResolve(header);
+        }
+        for (;;) {
+            if (residual.length < 4) {
+                return;
+            }
+            const byteLength = residual.readUInt32LE(0);
+            if (residual.length < 4 + byteLength) {
+                return; // whole block not yet available - buffer across reads
+            }
+            const block = residual.subarray(4, 4 + byteLength);
+            residual = residual.subarray(4 + byteLength);
+            handleBlock(block);
+        }
+    }
+    let doneResolve;
+    const done = new Promise((resolve) => {
+        doneResolve = resolve;
+    });
+    let finalized = false;
+    let failure = null;
+    async function finalize() {
+        if (finalized) {
+            await done;
+            return;
+        }
+        finalized = true;
+        drain(); // flush any queued frames before closing the turn
+        try {
+            vad.flush(); // force-closes a trailing in-speech span (payload-less speech_stopped)
+        }
+        catch (err) {
+            sink({ type: "error", error: toError(err) });
+        }
+        // Wait for the forced-final decode to land - the realtime session emits `committed` right
+        // after it - with a safety timeout so a wedged native decode can't hang the stream forever.
+        const abort = new AbortController();
+        const committed = once(realtime, "committed", { signal: abort.signal });
+        const timer = setTimeout(() => abort.abort(), FINALIZE_TIMEOUT_MS);
+        realtime.commit();
+        try {
+            await committed;
+        }
+        catch {
+            // aborted by the safety timeout - proceed to teardown regardless
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        try {
+            vad.close();
+        }
+        catch {
+            // ignore native cleanup failures
+        }
+        try {
+            realtime.close();
+        }
+        catch {
+            // ignore native cleanup failures
+        }
+        if (droppedFrames > 0) {
+            logger.debug({ droppedFrames }, "[live-transcription] dropped frames under backpressure");
+        }
+        doneResolve();
+    }
+    function fail(err) {
+        if (failure) {
+            return;
+        }
+        failure = err;
+        sink({ type: "error", error: err });
+        if (!header) {
+            headerReject(err);
+        }
+        stream.destroy(err);
+        void finalize();
+    }
+    stream.on("data", (chunk) => {
+        if (finalized) {
+            return;
+        }
+        try {
+            residual = residual.length === 0 ? chunk : Buffer.concat([residual, chunk]);
+            extractFrames();
+        }
+        catch (err) {
+            fail(toError(err));
+        }
+    });
+    stream.on("end", () => {
+        void finalize();
+    });
+    stream.on("error", (err) => {
+        fail(toError(err));
+    });
+    return {
+        header: headerPromise,
+        commit: () => realtime.commit(),
+        close: () => finalize(),
+        done,
+    };
+}
+//# sourceMappingURL=live-transcription.js.map

package/dist/server/server/meetings/meetings-http.d.ts

@@ -0,0 +1,42 @@
+import type { Express } from "express";
+export declare function ensureWorkdir(meetingId: string): string;
+export declare function deriveStatus(unidentified: number, turnCount: number): string;
+export interface IngestedParticipant {
+    id: string;
+    displayName: string;
+    voiceLabel: string;
+    email: string;
+    identified: boolean;
+    talkSeconds: number;
+    sampleClips: string[];
+}
+export interface IngestedMeeting {
+    id: string;
+    title: string;
+    startedAt: string;
+    status: string;
+    source: string;
+    participants: IngestedParticipant[];
+    transcript: {
+        speaker: string;
+        atSeconds: number;
+        text: string;
+    }[];
+    actionItems: unknown[];
+    decisions: unknown[];
+    openQuestions: {
+        id: string;
+        text: string;
+        kind: string;
+    }[];
+    stats: {
+        participantCount: number;
+        unidentifiedCount: number;
+        turnCount: number;
+    };
+    workdir?: string;
+}
+/** Prepend a fully-built meeting to the ingested store (used by the capture orchestrator). */
+export declare function appendIngestedMeeting(meeting: IngestedMeeting): void;
+export declare function registerMeetingsRoutes(app: Express): void;
+//# sourceMappingURL=meetings-http.d.ts.map

package/dist/server/server/meetings/meetings-http.js

@@ -0,0 +1,266 @@
+// MEETINGS BACKEND (B) — serves real meeting data over HTTP. Two sources:
+//   1. the engine corpus (meetings.db) read via Node's built-in node:sqlite, and
+//   2. an ingested JSON store of transcript-only meetings (JSON, no sqlite needed).
+// node:sqlite is loaded LAZILY + GUARDED (see getDatabaseSyncCtor) so a runtime that
+// lacks it (Node <24 without --experimental-sqlite) does NOT crash the daemon at import:
+// the corpus meetings simply degrade out while the ingested meetings keep working.
+// Endpoints:
+//   GET  /api/meetings                         → { meetings: Meeting[] }
+//   GET  /api/meetings/clip/:vsid/:idx         → streams the voice-sample mp3 (corpus only)
+//   POST /api/meetings/:id/participants/:pid   → { displayName, email } (ingest→JSON, corpus→DB)
+import { createRequire } from "node:module";
+import { createReadStream, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+let cachedDbCtor;
+function getDatabaseSyncCtor() {
+    if (cachedDbCtor !== undefined)
+        return cachedDbCtor;
+    try {
+        const req = createRequire(import.meta.url);
+        cachedDbCtor = req("node:sqlite").DatabaseSync;
+    }
+    catch {
+        cachedDbCtor = null;
+    }
+    return cachedDbCtor;
+}
+const DB_PATH = process.env.MEETINGS_DB_PATH ??
+    "/Users/claudinho/super-repo/docs/research/krisp-speaker-assigner/data/meetings.db";
+// voice_clips.path is stored relative to the corpus root (the dir containing data/)
+const CORPUS_ROOT = path.dirname(path.dirname(DB_PATH));
+const PASEO_HOME = process.env.PASEO_HOME ?? path.join(os.homedir(), ".paseo");
+// Ingested meetings (transcript-only, dropped in by the ingest pipeline) live in a JSON
+// store, kept entirely separate from the read-only corpus DB. Their participant edits
+// (naming a Krisp "Speaker N" voice) persist here, not in the corpus.
+const INGESTED_PATH = process.env.INGESTED_MEETINGS_PATH ?? path.join(PASEO_HOME, "meetings-ingested.json");
+export function ensureWorkdir(meetingId) {
+    const dir = path.join(PASEO_HOME, "meetings", meetingId);
+    try {
+        mkdirSync(dir, { recursive: true });
+    }
+    catch {
+        /* best-effort */
+    }
+    return dir;
+}
+const MAX_MEETINGS = 30;
+const MAX_TURNS = 48;
+const MAX_TEXT = 360;
+const MAX_CLIPS = 2;
+const str = (v) => (typeof v === "string" ? v.trim() : "");
+const num = (v) => (typeof v === "number" ? v : Number(v) || 0);
+export function deriveStatus(unidentified, turnCount) {
+    if (unidentified > 0)
+        return "needs-attention";
+    if (turnCount > 0)
+        return "ready";
+    return "processing";
+}
+function buildMeetings() {
+    const DatabaseSync = getDatabaseSyncCtor();
+    if (!DatabaseSync)
+        return []; // node:sqlite unavailable — corpus meetings degrade out
+    if (!existsSync(DB_PATH))
+        return []; // corpus DB not present on this host
+    const db = new DatabaseSync(DB_PATH, { readOnly: true });
+    try {
+        const meetings = db
+            .prepare("select id,title,started_at from meetings where started_at is not null order by started_at desc limit ?")
+            .all(MAX_MEETINGS);
+        return meetings.map((m, idx) => {
+            const mid = m.id;
+            const vspeakers = db
+                .prepare("select id,label,assigned_name,assigned_email,total_seconds from voice_speakers where meeting_id=? order by total_seconds desc")
+                .all(mid);
+            let unidentified = 0;
+            const participants = vspeakers.map((vs) => {
+                const name = str(vs.assigned_name);
+                const label = str(vs.label) || "Unknown voice";
+                const identified = name !== "";
+                if (!identified)
+                    unidentified++;
+                const clips = db
+                    .prepare("select idx from voice_clips where voice_speaker_id=? order by idx limit ?")
+                    .all(vs.id, MAX_CLIPS);
+                return {
+                    id: `vs-${vs.id}`,
+                    displayName: name || label,
+                    voiceLabel: label,
+                    email: str(vs.assigned_email),
+                    identified,
+                    talkSeconds: Math.round(num(vs.total_seconds) * 10) / 10,
+                    sampleClips: clips.map((c) => `/api/meetings/clip/${vs.id}/${c.idx}`),
+                };
+            });
+            const turns = db
+                .prepare("select t.start_seconds s,t.text,sp.assigned_name an,sp.label lb from turns t join speakers sp on sp.id=t.speaker_id where t.meeting_id=? order by t.start_seconds asc limit ?")
+                .all(mid, MAX_TURNS);
+            const transcript = turns
+                .map((t) => ({
+                speaker: str(t.an) || str(t.lb) || "Speaker",
+                atSeconds: Math.round(num(t.s) * 10) / 10,
+                text: str(t.text).slice(0, MAX_TEXT),
+            }))
+                .filter((t) => t.text !== "");
+            const openQuestions = participants
+                .filter((p) => !p.identified)
+                .map((p) => ({
+                id: `id-${p.id}`,
+                text: `Identify speaker “${p.voiceLabel || p.displayName}”`,
+                kind: "identify",
+            }));
+            let status = deriveStatus(unidentified, transcript.length);
+            if (idx < 2)
+                status = "scheduled";
+            else if (idx < 4)
+                status = "processing";
+            return {
+                id: mid,
+                title: str(m.title) || "Untitled meeting",
+                startedAt: m.started_at,
+                status,
+                source: "daemon",
+                workdir: ensureWorkdir(mid),
+                participants,
+                transcript,
+                actionItems: [],
+                decisions: [],
+                openQuestions,
+                stats: {
+                    participantCount: participants.length,
+                    unidentifiedCount: unidentified,
+                    turnCount: transcript.length,
+                },
+            };
+        });
+    }
+    finally {
+        db.close();
+    }
+}
+function readIngestedFile() {
+    if (!existsSync(INGESTED_PATH))
+        return [];
+    try {
+        const raw = JSON.parse(readFileSync(INGESTED_PATH, "utf8"));
+        return Array.isArray(raw) ? raw : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Prepend a fully-built meeting to the ingested store (used by the capture orchestrator). */
+export function appendIngestedMeeting(meeting) {
+    const all = readIngestedFile();
+    all.unshift(meeting);
+    writeFileSync(INGESTED_PATH, JSON.stringify(all, null, 1));
+}
+// Recompute the derived fields (unidentified count, open questions, status) after a
+// participant rename, so naming the last "Speaker N" moves the card to Ready.
+function recomputeIngested(m) {
+    const unidentified = m.participants.filter((p) => !p.identified).length;
+    m.stats.unidentifiedCount = unidentified;
+    m.openQuestions = m.participants
+        .filter((p) => !p.identified)
+        .map((p) => ({
+        id: `id-${p.id}`,
+        text: `Identify speaker “${p.voiceLabel || p.displayName}”`,
+        kind: "identify",
+    }));
+    m.status = deriveStatus(unidentified, m.transcript.length);
+}
+function loadIngested() {
+    const meetings = readIngestedFile();
+    for (const m of meetings)
+        m.workdir = ensureWorkdir(m.id);
+    return meetings;
+}
+function updateIngestedParticipant(meetingId, pid, displayName, email) {
+    const all = readIngestedFile();
+    const m = all.find((x) => x.id === meetingId);
+    if (!m)
+        return false;
+    const p = m.participants.find((x) => x.id === pid);
+    if (!p)
+        return false;
+    if (displayName !== undefined) {
+        p.displayName = displayName;
+        p.identified = displayName.trim() !== "";
+    }
+    if (email !== undefined)
+        p.email = email;
+    recomputeIngested(m);
+    writeFileSync(INGESTED_PATH, JSON.stringify(all, null, 1));
+    return true;
+}
+export function registerMeetingsRoutes(app) {
+    app.get("/api/meetings", (_req, res) => {
+        // Ingested (fresh, transcript-only) meetings first; they never depend on sqlite.
+        const ingested = loadIngested();
+        // Corpus meetings are best-effort: a missing DB or missing node:sqlite must not
+        // take down the whole endpoint — degrade to ingested-only instead of 500ing.
+        let corpus = [];
+        try {
+            corpus = buildMeetings();
+        }
+        catch (e) {
+            console.error("[meetings] corpus DB unavailable, serving ingested only:", e);
+        }
+        res.json({ meetings: [...ingested, ...corpus] });
+    });
+    app.get("/api/meetings/clip/:vsid/:idx", (req, res) => {
+        try {
+            const DatabaseSync = getDatabaseSyncCtor();
+            if (!DatabaseSync) {
+                res.status(503).json({ error: "node:sqlite unavailable on this runtime" });
+                return;
+            }
+            const db = new DatabaseSync(DB_PATH, { readOnly: true });
+            const row = db
+                .prepare("select path from voice_clips where voice_speaker_id=? and idx=?")
+                .get(Number(req.params.vsid), Number(req.params.idx));
+            db.close();
+            const rel = row ? str(row.path) : "";
+            if (!rel) {
+                res.status(404).end();
+                return;
+            }
+            const fp = path.join(CORPUS_ROOT, rel);
+            if (!existsSync(fp)) {
+                res.status(404).end();
+                return;
+            }
+            res.setHeader("Content-Type", "audio/mpeg");
+            createReadStream(fp).pipe(res);
+        }
+        catch (e) {
+            res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+    app.post("/api/meetings/:id/participants/:pid", (req, res) => {
+        try {
+            const body = (req.body ?? {});
+            // Ingested meetings persist to the JSON store (corpus DB stays untouched).
+            if (String(req.params.id).startsWith("ingest-")) {
+                const ok = updateIngestedParticipant(req.params.id, req.params.pid, body.displayName, body.email);
+                res.status(ok ? 200 : 404).json({ ok });
+                return;
+            }
+            const DatabaseSync = getDatabaseSyncCtor();
+            if (!DatabaseSync) {
+                res.status(503).json({ error: "node:sqlite unavailable on this runtime" });
+                return;
+            }
+            const vsid = Number(String(req.params.pid).replace(/^vs-/, ""));
+            const db = new DatabaseSync(DB_PATH, { readOnly: false });
+            db.prepare("update voice_speakers set assigned_name=?, assigned_email=? where id=?").run(body.displayName ?? null, body.email ?? null, vsid);
+            db.close();
+            res.json({ ok: true });
+        }
+        catch (e) {
+            res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+}
+//# sourceMappingURL=meetings-http.js.map

package/dist/server/server/messages.d.ts

@@ -0,0 +1,9 @@
+import type { ManagedAgent } from "./agent/agent-manager.js";
+import type { AgentStreamEvent } from "./agent/agent-sdk-types.js";
+import type { AgentSnapshotPayload, AgentStreamEventPayload } from "@hyperdrive.bot/fleet-protocol/messages";
+export * from "@hyperdrive.bot/fleet-protocol/messages";
+export declare function serializeAgentSnapshot(agent: ManagedAgent, options?: {
+    title?: string | null;
+}): AgentSnapshotPayload;
+export declare function serializeAgentStreamEvent(event: AgentStreamEvent): AgentStreamEventPayload | null;
+//# sourceMappingURL=messages.d.ts.map

package/dist/server/server/messages.js

@@ -0,0 +1,29 @@
+import { toAgentPayload } from "./agent/agent-projections.js";
+import { AgentStreamEventPayloadSchema as AgentStreamEventPayloadRuntimeSchema } from "@hyperdrive.bot/fleet-protocol/messages";
+export * from "@hyperdrive.bot/fleet-protocol/messages";
+function validateStreamEventPayload(payload) {
+    const parsed = AgentStreamEventPayloadRuntimeSchema.safeParse(payload);
+    if (!parsed.success) {
+        return null;
+    }
+    return parsed.data;
+}
+export function serializeAgentSnapshot(agent, options) {
+    return toAgentPayload(agent, options);
+}
+export function serializeAgentStreamEvent(event) {
+    if (event.type === "attention_required") {
+        // Providers may emit attention_required without per-client notification context.
+        // The websocket server emits attention_required with shouldNotify computed per client.
+        // Normalize provider events so they satisfy the shared schema.
+        return validateStreamEventPayload({
+            type: "attention_required",
+            provider: event.provider,
+            reason: event.reason,
+            timestamp: event.timestamp,
+            shouldNotify: false,
+        });
+    }
+    return validateStreamEventPayload(event);
+}
+//# sourceMappingURL=messages.js.map