@kikedealba/recap 0.0.0-stage → 0.9.0

package/dist/live/origin.js

@@ -0,0 +1,91 @@
+import { trimmed } from "../core/text.js";
+import { PARAGRAPH_GAP_MS, PARAGRAPH_SPAN_MS, orderSegments } from "../pipeline/transcript.js";
+import { questionSimilarity } from "./dedupe.js";
+export function clockMilliseconds(value) {
+    if (typeof value !== 'string')
+        return null;
+    let body = trimmed(value);
+    if (body.length === 0)
+        return null;
+    if (body.startsWith('[') && body.endsWith(']'))
+        body = body.slice(1, -1);
+    const parts = body.split(':');
+    if (parts.length !== 2 && parts.length !== 3)
+        return null;
+    if (!parts.every((part) => /^[0-9]{1,2}$/.test(part)))
+        return null;
+    const numbers = parts.map(Number);
+    const [hours, minutes, seconds] = numbers.length === 3 ? numbers : [0, numbers[0] ?? 0, numbers[1] ?? 0];
+    if (minutes >= 60 || seconds >= 60)
+        return null;
+    return ((hours * 60 + minutes) * 60 + seconds) * 1000;
+}
+function best(indices, ordered, question) {
+    const text = question ? trimmed(question) : '';
+    if (text.length === 0)
+        return null;
+    let winner = null;
+    for (const index of indices) {
+        const segment = ordered[index];
+        if (!segment)
+            continue;
+        const score = questionSimilarity(text, segment.text);
+        if (score > (winner?.score ?? 0))
+            winner = { index, score };
+    }
+    return winner?.index ?? null;
+}
+function anchor(atMs, ordered, question) {
+    if (ordered.length === 0)
+        return null;
+    const second = Math.trunc(atMs / 1000);
+    const indices = ordered.map((_, index) => index);
+    const exact = indices.filter((index) => Math.trunc((ordered[index]?.startMs ?? 0) / 1000) === second);
+    if (exact.length > 0)
+        return best(exact, ordered, question) ?? exact[0] ?? null;
+    const until = second * 1000 + 999;
+    const covering = indices.filter((index) => (ordered[index]?.startMs ?? 0) <= until && (ordered[index]?.endMs ?? 0) >= atMs).pop();
+    if (covering !== undefined)
+        return covering;
+    const before = indices.filter((index) => (ordered[index]?.startMs ?? 0) <= until).pop();
+    if (before !== undefined)
+        return before;
+    let closest = 0;
+    for (const index of indices) {
+        if (Math.abs((ordered[index]?.startMs ?? 0) - atMs) < Math.abs((ordered[closest]?.startMs ?? 0) - atMs))
+            closest = index;
+    }
+    return closest;
+}
+function paragraphFrom(index, ordered) {
+    const first = ordered[index];
+    if (!first)
+        return [];
+    const members = [first];
+    let lastEnd = first.endMs;
+    for (const segment of ordered.slice(index + 1)) {
+        if (segment.channel !== first.channel || segment.startMs - lastEnd > PARAGRAPH_GAP_MS || segment.startMs - first.startMs >= PARAGRAPH_SPAN_MS)
+            break;
+        members.push(segment);
+        lastEnd = Math.max(lastEnd, segment.endMs);
+    }
+    return members;
+}
+export function resolveOrigin(atMs, segments, question) {
+    const ordered = orderSegments(segments.filter((segment) => trimmed(segment.text).length > 0));
+    const index = anchor(atMs, ordered, question);
+    if (index === null)
+        return null;
+    const members = paragraphFrom(index, ordered);
+    let chosen = ordered[index];
+    if (members.length > 1) {
+        const refined = best(members.map((_, i) => i), members, question);
+        if (refined !== null)
+            chosen = members[refined];
+    }
+    return chosen ? { questionMs: chosen.startMs, channel: chosen.channel } : null;
+}
+export function resolveOriginClock(value, segments, question) {
+    const atMs = clockMilliseconds(value);
+    return atMs === null ? null : resolveOrigin(atMs, segments, question);
+}

package/dist/live/stream.js

@@ -0,0 +1,390 @@
+import { asIntLoose, isRecord, parseJsonSafe } from "../core/json.js";
+import { home } from "../core/paths.js";
+import { fold, replaceAll, suffix, trimmed } from "../core/text.js";
+import { RecapError } from "../errors.js";
+import { clockMilliseconds, resolveOrigin } from "./origin.js";
+export function parseStreamLine(line) {
+    const object = parseJsonSafe(line);
+    if (!isRecord(object) || typeof object['type'] !== 'string')
+        return [];
+    switch (object['type']) {
+        case 'stream_event': {
+            const event = object['event'];
+            if (!isRecord(event) || event['type'] !== 'content_block_delta')
+                return [];
+            const delta = event['delta'];
+            if (!isRecord(delta) || delta['type'] !== 'text_delta' || typeof delta['text'] !== 'string' || delta['text'].length === 0)
+                return [];
+            return [{ type: 'text', text: delta['text'] }];
+        }
+        case 'assistant': {
+            const message = object['message'];
+            const content = isRecord(message) && Array.isArray(message['content']) ? message['content'] : [];
+            const events = [];
+            for (const block of content) {
+                if (!isRecord(block) || block['type'] !== 'tool_use' || typeof block['name'] !== 'string')
+                    continue;
+                const input = {};
+                if (isRecord(block['input'])) {
+                    for (const [key, value] of Object.entries(block['input'])) {
+                        if (typeof value === 'string')
+                            input[key] = value;
+                        else if (typeof value === 'number')
+                            input[key] = String(value);
+                        else if (typeof value === 'boolean')
+                            input[key] = value ? '1' : '0';
+                    }
+                }
+                events.push({ type: 'tool', name: block['name'], input });
+            }
+            return events;
+        }
+        case 'result': {
+            const isError = typeof object['is_error'] === 'boolean' ? object['is_error'] : object['subtype'] !== 'success';
+            return [{ type: 'result', text: typeof object['result'] === 'string' ? object['result'] : null, isError }];
+        }
+        default:
+            return [];
+    }
+}
+export class ProgressDescriber {
+    roots;
+    constructor(docsRoot, repos) {
+        const roots = repos.map((repo) => ({ prefix: repo.path, label: repo.slug }));
+        if (docsRoot)
+            roots.push({ prefix: docsRoot, label: 'docs' });
+        this.roots = roots.sort((left, right) => right.prefix.length - left.prefix.length);
+    }
+    describe(name, input) {
+        switch (name) {
+            case 'Read':
+                return `Leyendo ${this.short(input['file_path'] ?? input['path'] ?? '')}`;
+            case 'Grep': {
+                const scope = input['path'] !== undefined ? ` en ${this.short(input['path'])}` : '';
+                return `Buscando «${input['pattern'] ?? ''}»${scope}`;
+            }
+            case 'Glob': {
+                const scope = input['path'] !== undefined ? ` en ${this.short(input['path'])}` : '';
+                return `Listando ${input['pattern'] ?? ''}${scope}`;
+            }
+            case 'Bash': {
+                let command = input['command'];
+                if (command === undefined)
+                    return 'Ejecutando un comando';
+                for (const root of this.roots)
+                    command = replaceAll(command, root.prefix, root.label);
+                return `Ejecutando ${command}`;
+            }
+            default:
+                return name;
+        }
+    }
+    short(file) {
+        for (const root of this.roots) {
+            if (file === root.prefix || file.startsWith(`${root.prefix}/`))
+                return root.label + file.slice(root.prefix.length);
+        }
+        const base = home();
+        if (file.startsWith(`${base}/`))
+            return `~${file.slice(base.length)}`;
+        return file;
+    }
+}
+export const SOURCES_MARKER = '```fuentes';
+export const QUESTION_PREFIX = 'PREGUNTA:';
+function headerQuestion(text) {
+    const clean = trimmed(text);
+    if (!clean.toUpperCase().startsWith(QUESTION_PREFIX))
+        return null;
+    const question = trimmed(clean.slice(QUESTION_PREFIX.length));
+    return question.length === 0 ? null : question;
+}
+export function markerPrefixLength(text) {
+    for (let length = Math.min(SOURCES_MARKER.length - 1, text.length); length >= 1; length -= 1) {
+        if (text.endsWith(SOURCES_MARKER.slice(0, length)))
+            return length;
+    }
+    return 0;
+}
+export class AnswerAssembler {
+    question = null;
+    emitted = '';
+    sourcesText = '';
+    pending = '';
+    headerDone = false;
+    inSources = false;
+    feed(delta) {
+        if (this.inSources) {
+            this.sourcesText += delta;
+            return '';
+        }
+        this.pending += delta;
+        if (!this.headerDone && !this.resolveHeader())
+            return '';
+        return this.drain(false);
+    }
+    finish() {
+        if (!this.headerDone) {
+            this.headerDone = true;
+            const parsed = headerQuestion(this.pending);
+            if (parsed !== null) {
+                this.question = parsed;
+                this.pending = '';
+            }
+        }
+        return this.drain(true);
+    }
+    resolveHeader() {
+        const stripped = this.pending.replace(/^\s+/, '');
+        if (stripped.length === 0)
+            return false;
+        const head = stripped.slice(0, QUESTION_PREFIX.length).toUpperCase();
+        if (QUESTION_PREFIX.startsWith(head) && head.length < QUESTION_PREFIX.length)
+            return false;
+        if (head !== QUESTION_PREFIX) {
+            this.headerDone = true;
+            return true;
+        }
+        const newline = stripped.indexOf('\n');
+        if (newline === -1)
+            return false;
+        this.question = headerQuestion(stripped.slice(0, newline));
+        this.pending = stripped.slice(newline + 1).replace(/^\s*\n/, '');
+        this.headerDone = true;
+        return true;
+    }
+    drain(final) {
+        const marker = this.pending.indexOf(SOURCES_MARKER);
+        if (marker !== -1) {
+            const before = this.pending.slice(0, marker);
+            this.sourcesText += this.pending.slice(marker + SOURCES_MARKER.length);
+            this.pending = '';
+            this.inSources = true;
+            this.emitted += before;
+            return before;
+        }
+        let out = this.pending;
+        if (!final) {
+            const hold = markerPrefixLength(this.pending);
+            out = this.pending.slice(0, this.pending.length - hold);
+            this.pending = this.pending.slice(this.pending.length - hold);
+        }
+        else {
+            this.pending = '';
+        }
+        this.emitted += out;
+        return out;
+    }
+    get answer() {
+        return trimmed(this.emitted);
+    }
+}
+export function encodeSource(source) {
+    return { kind: source.kind, label: source.label, pageId: source.pageId, path: source.path, line: source.line, repo: source.repo, sha: source.sha };
+}
+export function encodeAnswer(answer) {
+    return {
+        id: answer.id,
+        askedAt: answer.askedAt,
+        question: answer.question,
+        answer: answer.answer,
+        found: answer.found,
+        sources: answer.sources.map(encodeSource),
+        auto: answer.auto,
+        answeredAt: answer.answeredAt,
+        questionMs: answer.questionMs,
+        channel: answer.channel,
+        askId: answer.askId,
+    };
+}
+function cleanOptional(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const text = trimmed(value);
+    return text.length === 0 ? undefined : text;
+}
+function decodeSourceLoose(item) {
+    if (!isRecord(item) || typeof item['kind'] !== 'string')
+        return null;
+    const kind = item['kind'].toLowerCase();
+    if (!['page', 'file', 'commit'].includes(kind))
+        return null;
+    const pageId = asIntLoose(item['pageId']);
+    const line = asIntLoose(item['line']);
+    const sourcePath = cleanOptional(item['path']);
+    const repo = cleanOptional(item['repo']);
+    const sha = cleanOptional(item['sha']);
+    if (kind === 'page' && pageId === undefined && sourcePath === undefined)
+        return null;
+    if (kind === 'file' && sourcePath === undefined)
+        return null;
+    if (kind === 'commit' && sha === undefined)
+        return null;
+    let label = typeof item['label'] === 'string' ? trimmed(item['label']) : '';
+    if (label.length === 0) {
+        if (kind === 'page')
+            label = pageId !== undefined ? `Página #${pageId}` : (sourcePath ?? '');
+        else if (kind === 'file')
+            label = [sourcePath ?? '', line !== undefined ? String(line) : ''].filter((part) => part.length > 0).join(':');
+        else
+            label = (sha ?? '').slice(0, 10);
+    }
+    return { kind, label, pageId, path: sourcePath, line, repo, sha };
+}
+export function decodeAnswer(value) {
+    if (!isRecord(value))
+        return null;
+    const { id, askedAt, question, answer, found } = value;
+    if (typeof id !== 'string' || typeof askedAt !== 'string' || typeof question !== 'string' || typeof answer !== 'string' || typeof found !== 'boolean')
+        return null;
+    if (!Array.isArray(value['sources']))
+        return null;
+    const sources = [];
+    for (const item of value['sources']) {
+        if (!isRecord(item) || typeof item['kind'] !== 'string' || typeof item['label'] !== 'string')
+            return null;
+        sources.push({
+            kind: item['kind'],
+            label: item['label'],
+            pageId: typeof item['pageId'] === 'number' ? item['pageId'] : undefined,
+            path: typeof item['path'] === 'string' ? item['path'] : undefined,
+            line: typeof item['line'] === 'number' ? item['line'] : undefined,
+            repo: typeof item['repo'] === 'string' ? item['repo'] : undefined,
+            sha: typeof item['sha'] === 'string' ? item['sha'] : undefined,
+        });
+    }
+    return {
+        id,
+        askedAt,
+        question,
+        answer,
+        found,
+        sources,
+        auto: typeof value['auto'] === 'boolean' ? value['auto'] : undefined,
+        answeredAt: typeof value['answeredAt'] === 'string' ? value['answeredAt'] : undefined,
+        questionMs: typeof value['questionMs'] === 'number' ? value['questionMs'] : undefined,
+        channel: value['channel'] === 'mic' || value['channel'] === 'system' ? value['channel'] : undefined,
+        askId: typeof value['askId'] === 'string' ? value['askId'] : undefined,
+    };
+}
+export function parseSourcesBlock(text) {
+    let body = text;
+    const close = body.indexOf('```');
+    if (close !== -1)
+        body = body.slice(0, close);
+    const start = body.indexOf('{');
+    const end = body.lastIndexOf('}');
+    if (start === -1 || end === -1 || start >= end)
+        return null;
+    const object = parseJsonSafe(body.slice(start, end + 1));
+    if (!isRecord(object))
+        return null;
+    const items = Array.isArray(object['sources']) ? object['sources'] : [];
+    const question = typeof object['question'] === 'string' ? trimmed(object['question']) : null;
+    return {
+        question: question && question.length > 0 ? question : null,
+        found: typeof object['found'] === 'boolean' ? object['found'] : null,
+        sources: items.map(decodeSourceLoose).filter((source) => source !== null),
+        atMs: clockMilliseconds(object['at']),
+    };
+}
+export const NOT_DOCUMENTED = 'no esta documentado';
+export function buildAnswer(id, askedAt, explicitQuestion, assembler, segments = []) {
+    const block = parseSourcesBlock(assembler.sourcesText);
+    const text = assembler.answer;
+    const sources = block?.sources ?? [];
+    const missing = fold(text).includes(NOT_DOCUMENTED);
+    const found = !missing && (block?.found ?? sources.length > 0);
+    const question = explicitQuestion ?? assembler.question ?? block?.question ?? '';
+    const answer = { id, askedAt, question, answer: text, found, sources };
+    if (explicitQuestion === null && block?.atMs !== null && block?.atMs !== undefined) {
+        const origin = resolveOrigin(block.atMs, segments, question);
+        if (origin) {
+            answer.questionMs = origin.questionMs;
+            answer.channel = origin.channel;
+        }
+    }
+    return answer;
+}
+export function encodeAskEvent(event) {
+    switch (event.type) {
+        case 'source':
+            return { type: 'source', source: encodeSource(event.source) };
+        case 'done':
+            return { type: 'done', answer: encodeAnswer(event.answer) };
+        case 'error':
+            return { type: 'error', code: event.code, message: event.message };
+        default:
+            return { type: event.type, text: event.text };
+    }
+}
+export class AskStreamReducer {
+    explicitQuestion;
+    assembler = new AnswerAssembler();
+    questionSent;
+    deltaSent = false;
+    resultText = null;
+    resultError = false;
+    constructor(explicitQuestion) {
+        this.explicitQuestion = explicitQuestion;
+        this.questionSent = explicitQuestion !== null;
+    }
+    consume(line, describer) {
+        const events = [];
+        for (const event of parseStreamLine(line)) {
+            if (event.type === 'text') {
+                const out = this.assembler.feed(event.text);
+                events.push(...this.questionEvent());
+                if (out.length > 0) {
+                    this.deltaSent = true;
+                    events.push({ type: 'delta', text: out });
+                }
+            }
+            else if (event.type === 'tool') {
+                events.push({ type: 'progress', text: describer.describe(event.name, event.input) });
+            }
+            else {
+                this.resultText = event.text;
+                this.resultError = event.isError;
+            }
+        }
+        return events;
+    }
+    questionEvent() {
+        if (this.questionSent || this.assembler.question === null)
+            return [];
+        this.questionSent = true;
+        return [{ type: 'question', text: this.assembler.question }];
+    }
+    finish(status, stderr, id, askedAt, segments = []) {
+        const events = [];
+        const tail = this.assembler.finish();
+        events.push(...this.questionEvent());
+        if (tail.length > 0) {
+            this.deltaSent = true;
+            events.push({ type: 'delta', text: tail });
+        }
+        if (this.resultError || (status !== 0 && this.resultText === null)) {
+            const detail = this.resultText ?? trimmed(stderr);
+            throw new RecapError('CLAUDE_FAILED', detail.length === 0 ? `claude exited with status ${status}` : suffix(detail, 500));
+        }
+        let canonical = this.assembler;
+        if (this.resultText !== null && trimmed(this.resultText).length > 0) {
+            const fresh = new AnswerAssembler();
+            fresh.feed(this.resultText);
+            fresh.finish();
+            canonical = fresh;
+        }
+        const answer = buildAnswer(id, askedAt, this.explicitQuestion, canonical, segments);
+        if (answer.answer.length === 0)
+            throw new RecapError('CLAUDE_FAILED', 'claude returned an empty answer');
+        if (!this.deltaSent)
+            events.push({ type: 'delta', text: answer.answer });
+        if (!this.questionSent && answer.question.length > 0) {
+            this.questionSent = true;
+            events.push({ type: 'question', text: answer.question });
+        }
+        events.push(...answer.sources.map((source) => ({ type: 'source', source })));
+        return { events, answer };
+    }
+}

package/dist/live/worker.js

@@ -0,0 +1,191 @@
+import { existsSync, mkdirSync, rmSync } from 'node:fs';
+import path from 'node:path';
+import { settingsOf, whisperModelPath } from "../core/config.js";
+import { readText, writeAtomic } from "../core/fsutil.js";
+import { isRecord } from "../core/json.js";
+import { ProcessLock } from "../core/lock.js";
+import { isActiveStatus, loadMeeting, reconcile } from "../core/meeting.js";
+import { exec, sleep } from "../core/proc.js";
+import { selfCommand } from "../core/self.js";
+import { suffix, trimmed } from "../core/text.js";
+import { requireTool } from "../core/tools.js";
+import { RecapError, errorMessage } from "../errors.js";
+import { docsClient, meetingTarget } from "../bita/client.js";
+import { resultText, runClaude } from "../pipeline/claude.js";
+import { whisperArguments } from "../pipeline/pipeline.js";
+import { parseWhisper } from "../pipeline/transcript.js";
+import { pruneBoard } from "./asking.js";
+import { loadProjectContext, meetingProject } from "./context.js";
+import { AutoAskProcess, AutoAskQueue, QuestionDetector } from "./detector.js";
+import { appendLines, liveFiles, readLines } from "./files.js";
+import { LiveMerger } from "./merger.js";
+export const LIVE_THREADS = 4;
+export const PROMPT_CHARACTERS = 220;
+export const PRUNE_SECONDS = 5;
+export function decodeChunk(value) {
+    if (!isRecord(value))
+        return null;
+    const { channel, seq, startMs, endMs, file } = value;
+    if (channel !== 'mic' && channel !== 'system')
+        return null;
+    if (typeof seq !== 'number' || typeof startMs !== 'number' || typeof endMs !== 'number')
+        return null;
+    if (file !== undefined && file !== null && typeof file !== 'string')
+        return null;
+    return { file: typeof file === 'string' ? file : undefined, channel, seq, startMs, endMs };
+}
+export function liveWhisperArguments(config, model, outputBase, wav, previous) {
+    return whisperArguments(config, model, outputBase, wav, LIVE_THREADS, previous);
+}
+export class LiveWorker {
+    dir;
+    config;
+    log;
+    pollSeconds;
+    detectorFactory;
+    previousText = {};
+    constructor(dir, config, log, options = {}) {
+        this.dir = dir;
+        this.config = config;
+        this.log = log;
+        this.pollSeconds = options.pollSeconds ?? 1;
+        this.detectorFactory = options.detectorFactory ?? null;
+    }
+    loadState() {
+        const text = readText(liveFiles.workerState(this.dir));
+        if (text === null)
+            return 0;
+        try {
+            const value = JSON.parse(text);
+            return isRecord(value) && typeof value['processed'] === 'number' ? value['processed'] : 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+    isRecording() {
+        try {
+            return isActiveStatus(reconcile(loadMeeting(this.dir), this.dir).status);
+        }
+        catch {
+            return false;
+        }
+    }
+    async run() {
+        mkdirSync(liveFiles.dir(this.dir), { recursive: true });
+        const lock = new ProcessLock(liveFiles.workerLock(this.dir));
+        let detector = null;
+        try {
+            const meeting = loadMeeting(this.dir);
+            const whisper = await requireTool('whisper-cli', this.config);
+            const model = whisperModelPath(this.config);
+            if (!existsSync(model))
+                throw new RecapError('MODEL_MISSING', `Whisper model not found at ${model}. Run \`recap setup\`.`);
+            const settings = settingsOf(this.config);
+            const merger = new LiveMerger(meeting.mode === 'remote', settings.maxChunkSeconds + 10);
+            let processed = this.loadState();
+            this.log(`live worker started at chunk ${processed}`);
+            detector = this.detectorFactory?.(this.dir, meeting) ?? null;
+            if (detector) {
+                this.log(`question detector on (model ${settings.autoAskModel}, every ${settings.autoAskMinSeconds} s at most, ${settings.autoAskConcurrency} answers at a time)`);
+            }
+            pruneBoard(this.dir);
+            let lastPrune = Date.now();
+            let finalPass = false;
+            for (;;) {
+                detector?.tick();
+                if ((Date.now() - lastPrune) / 1000 >= PRUNE_SECONDS) {
+                    pruneBoard(this.dir);
+                    lastPrune = Date.now();
+                }
+                const entries = readLines(liveFiles.chunkIndex(this.dir), decodeChunk);
+                if (entries.length > processed) {
+                    for (const entry of entries.slice(processed)) {
+                        const segments = await this.transcribe(entry, whisper, model);
+                        const ready = entry.file === undefined ? merger.advance(entry.channel, entry.endMs, Date.now()) : merger.add(segments, entry.channel, entry.endMs, Date.now());
+                        appendLines(ready, liveFiles.transcript(this.dir));
+                        if (ready.length > 0)
+                            detector?.transcriptGrew();
+                        processed += 1;
+                        writeAtomic(liveFiles.workerState(this.dir), JSON.stringify({ processed }));
+                        detector?.tick();
+                    }
+                    finalPass = false;
+                    continue;
+                }
+                const released = merger.release(Date.now(), false);
+                appendLines(released, liveFiles.transcript(this.dir));
+                if (released.length > 0)
+                    detector?.transcriptGrew();
+                if (!this.isRecording()) {
+                    if (finalPass)
+                        break;
+                    finalPass = true;
+                    continue;
+                }
+                await sleep(this.pollSeconds * 1000);
+            }
+            appendLines(merger.release(Date.now(), true), liveFiles.transcript(this.dir));
+            this.log(`live worker finished after ${processed} chunks`);
+        }
+        finally {
+            await detector?.stop();
+            lock.release();
+        }
+    }
+    async transcribe(entry, whisper, model) {
+        if (entry.file === undefined)
+            return [];
+        const wav = path.join(liveFiles.chunks(this.dir), entry.file);
+        if (!existsSync(wav))
+            return [];
+        const base = wav.replace(/\.[^./\\]+$/, '');
+        const json = `${base}.json`;
+        try {
+            const result = await exec(whisper, liveWhisperArguments(this.config, model, base, wav, this.previousText[entry.channel]));
+            if (result.status !== 0) {
+                this.log(`whisper failed on ${entry.file}: ${suffix(trimmed(result.stderr), 300)}`);
+                return [];
+            }
+            const text = readText(json);
+            if (text === null)
+                throw new Error(`${json} was not written`);
+            const segments = parseWhisper(text, entry.channel).map((segment) => ({
+                ...segment,
+                startMs: segment.startMs + entry.startMs,
+                endMs: Math.min(segment.endMs + entry.startMs, Math.max(entry.endMs, segment.startMs + entry.startMs)),
+            }));
+            if (segments.length > 0) {
+                const joined = trimmed(`${this.previousText[entry.channel] ?? ''} ${segments.map((segment) => segment.text).join(' ')}`);
+                this.previousText[entry.channel] = suffix(joined, PROMPT_CHARACTERS);
+            }
+            return segments;
+        }
+        catch (error) {
+            this.log(`whisper failed on ${entry.file}: ${errorMessage(error)}`);
+            return [];
+        }
+        finally {
+            rmSync(json, { force: true });
+        }
+    }
+}
+export function makeLiveDetector(dir, meeting, config, log) {
+    const settings = settingsOf(config);
+    if (!settings.autoAsk)
+        return null;
+    const runner = new AutoAskProcess(dir, selfCommand());
+    const asks = new AutoAskQueue({ dir, concurrency: settings.autoAskConcurrency, run: (job) => runner.run(job), cancelRunning: () => runner.cancel(), log });
+    return new QuestionDetector(dir, meeting, settings.autoAskMinSeconds, {
+        context: async () => {
+            const docs = await docsClient(config, meetingTarget(meeting));
+            return loadProjectContext(await meetingProject(meeting, docs), meeting.bitaDocsRoot, docs);
+        },
+        complete: async (prompt) => resultText(await runClaude({ prompt, cwd: dir, config, tools: [], addDirs: [], model: settings.autoAskModel, restrictTools: [] })),
+        enqueue: (question, origin) => {
+            asks.enqueue(question, origin);
+        },
+        cancelAsks: () => asks.cancelAll(),
+        log,
+    });
+}