@kikedealba/recap 0.0.0-stage → 0.9.0

package/dist/media/media.js

@@ -0,0 +1,83 @@
+import { lstatSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import { exists } from "../core/fsutil.js";
+import { recordingPath } from "../core/meeting.js";
+import { LIVE_DIR, liveFiles } from "../live/files.js";
+export const VIDEO_FILE = 'recording.mov';
+export const AUDIO_FILE = 'recording.m4a';
+export const INTERMEDIATE_FILES = ['mic.wav', 'system.wav', 'transcript-mic.json', 'transcript-system.json'];
+export const FRAMES_DIR = 'frames';
+export function hasVideo(dir, mode) {
+    const file = recordingPath(dir, mode);
+    return path.basename(file) === VIDEO_FILE && exists(file);
+}
+export function pathSize(file) {
+    let info;
+    try {
+        info = lstatSync(file);
+    }
+    catch {
+        return 0;
+    }
+    if (info.isSymbolicLink())
+        return 0;
+    if (!info.isDirectory())
+        return info.size;
+    let total = 0;
+    let children = [];
+    try {
+        children = readdirSync(file);
+    }
+    catch {
+        return 0;
+    }
+    for (const child of children)
+        total += pathSize(path.join(file, child));
+    return total;
+}
+export function measureStorage(dir, mode) {
+    const storage = { recordingBytes: 0, intermediateBytes: 0, framesBytes: 0, otherBytes: 0, totalBytes: 0 };
+    const recording = path.basename(recordingPath(dir, mode));
+    let entries = [];
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return storage;
+    }
+    for (const name of entries) {
+        const bytes = pathSize(path.join(dir, name));
+        storage.totalBytes += bytes;
+        if (name === recording)
+            storage.recordingBytes += bytes;
+        else if (INTERMEDIATE_FILES.includes(name))
+            storage.intermediateBytes += bytes;
+        else if (name === FRAMES_DIR)
+            storage.framesBytes += bytes;
+        else if (name === LIVE_DIR) {
+            const chunks = pathSize(liveFiles.chunks(dir));
+            storage.intermediateBytes += chunks;
+            storage.otherBytes += bytes - chunks;
+        }
+        else
+            storage.otherBytes += bytes;
+    }
+    return storage;
+}
+export const VIDEO_PRESETS = ['light', 'medium', 'max'];
+const PRESETS = {
+    light: { width: 1280, frameRate: '2', videoBitrate: '250k' },
+    medium: { width: 960, frameRate: '1', videoBitrate: '140k' },
+    max: { width: 720, frameRate: '0.5', videoBitrate: '70k' },
+};
+export function presetParameters(preset) {
+    const base = PRESETS[preset];
+    return { ...base, durationTolerance: 1 + 1 / (Number(base.frameRate) || 1) };
+}
+export function hevcEncoder(platform = process.platform) {
+    return platform === 'darwin' ? ['-c:v', 'hevc_videotoolbox'] : ['-c:v', 'libx265', '-preset', 'medium'];
+}
+export function presetVideoArguments(preset, platform = process.platform) {
+    const p = PRESETS[preset];
+    return [...hevcEncoder(platform), '-tag:v', 'hvc1', '-vf', `fps=${p.frameRate},scale='min(${p.width},iw)':-2`, '-b:v', p.videoBitrate];
+}

package/dist/media/operations.js

@@ -0,0 +1,131 @@
+import { renameSync, rmSync } from 'node:fs';
+import path from 'node:path';
+import { isoNow } from "../core/dates.js";
+import { ProcessLock, lockOwner } from "../core/lock.js";
+import { isActiveStatus, loadMeeting, updateMeeting } from "../core/meeting.js";
+import { exec, isAlive } from "../core/proc.js";
+import { formatBytes, suffix, trimmed } from "../core/text.js";
+import { requireTool } from "../core/tools.js";
+import { RecapError } from "../errors.js";
+import { liveFiles } from "../live/files.js";
+import { AUDIO_FILE, INTERMEDIATE_FILES, VIDEO_FILE, hasVideo, pathSize, presetParameters, presetVideoArguments } from "./media.js";
+import { inspectMedia, verifyMedia } from "./probe.js";
+export function requireIdle(meeting) {
+    if (isActiveStatus(meeting.status))
+        throw new RecapError('MEETING_ACTIVE', `"${meeting.title}" is still being recorded`);
+}
+export function removeIntermediates(dir) {
+    for (const name of INTERMEDIATE_FILES)
+        rmSync(path.join(dir, name), { force: true });
+    rmSync(liveFiles.chunks(dir), { recursive: true, force: true });
+}
+export function enableAudio(info) {
+    return Array.from({ length: info.audioTracks }, (_, index) => [`-disposition:a:${index}`, 'default']).flat();
+}
+function requireVideo(meeting, dir) {
+    if (meeting.mode !== 'remote')
+        throw new RecapError('NOT_REMOTE', `"${meeting.title}" is an in-person meeting and has no video`);
+    requireIdle(meeting);
+    if (!hasVideo(dir, meeting.mode))
+        throw new RecapError('NO_VIDEO', `"${meeting.title}" has no ${VIDEO_FILE}`);
+}
+function replace(temporary, target) {
+    try {
+        renameSync(temporary, target);
+    }
+    catch (error) {
+        rmSync(temporary, { force: true });
+        throw new RecapError('RENAME_FAILED', `Cannot move ${path.basename(temporary)} to ${path.basename(target)}: ${error.message}`);
+    }
+}
+async function transcode(config, source, temporary, original, expectVideo, tolerance, args) {
+    const ffmpeg = await requireTool('ffmpeg', config);
+    rmSync(temporary, { force: true });
+    try {
+        const result = await exec(ffmpeg, ['-hide_banner', '-loglevel', 'error', '-nostdin', '-y', '-i', source, ...args, '-movflags', '+faststart', temporary]);
+        if (result.status !== 0)
+            throw new RecapError('FFMPEG_FAILED', suffix(trimmed(result.stderr), 500));
+        verifyMedia(original, await inspectMedia(temporary, config), expectVideo, tolerance);
+    }
+    catch (error) {
+        rmSync(temporary, { force: true });
+        throw error;
+    }
+}
+export async function stripVideo(config, meeting, dir, pruneIntermediates) {
+    requireVideo(meeting, dir);
+    const lock = new ProcessLock(path.join(dir, 'process.lock'));
+    try {
+        const source = path.join(dir, VIDEO_FILE);
+        const target = path.join(dir, AUDIO_FILE);
+        const temporary = path.join(dir, '.recording-strip.m4a');
+        const original = await inspectMedia(source, config);
+        await transcode(config, source, temporary, original, false, 1, ['-map', '0:a', '-c', 'copy', ...enableAudio(original), '-f', 'mp4']);
+        replace(temporary, target);
+        rmSync(source, { force: true });
+        if (pruneIntermediates)
+            removeIntermediates(dir);
+        return updateMeeting(dir, (current) => {
+            current.videoRemovedAt = isoNow();
+        });
+    }
+    finally {
+        lock.release();
+    }
+}
+export async function compressVideo(config, meeting, dir, preset, pruneIntermediates) {
+    requireVideo(meeting, dir);
+    const lock = new ProcessLock(path.join(dir, 'process.lock'));
+    try {
+        const source = path.join(dir, VIDEO_FILE);
+        const temporary = path.join(dir, '.recording-compress.mov');
+        const original = await inspectMedia(source, config);
+        const originalBytes = pathSize(source);
+        await transcode(config, source, temporary, original, true, presetParameters(preset).durationTolerance, [
+            '-map',
+            '0:v:0',
+            '-map',
+            '0:a',
+            ...presetVideoArguments(preset),
+            '-c:a',
+            'copy',
+            ...enableAudio(original),
+            '-f',
+            'mov',
+        ]);
+        const compressedBytes = pathSize(temporary);
+        if (compressedBytes >= originalBytes) {
+            rmSync(temporary, { force: true });
+            throw new RecapError('NOT_SMALLER', `The ${preset} preset produced ${formatBytes(compressedBytes)}, not smaller than ${formatBytes(originalBytes)}; the original was kept`);
+        }
+        replace(temporary, source);
+        if (pruneIntermediates)
+            removeIntermediates(dir);
+        return updateMeeting(dir, (current) => {
+            current.video = { compressedAt: isoNow(), preset, originalBytes: current.video?.originalBytes ?? originalBytes };
+        });
+    }
+    finally {
+        lock.release();
+    }
+}
+export function pruneMeeting(meeting, dir) {
+    requireIdle(meeting);
+    const lock = new ProcessLock(path.join(dir, 'process.lock'));
+    try {
+        removeIntermediates(dir);
+        return loadMeeting(dir);
+    }
+    finally {
+        lock.release();
+    }
+}
+export function deleteMeeting(meeting, dir) {
+    requireIdle(meeting);
+    const pid = lockOwner(path.join(dir, 'process.lock'));
+    if (pid !== null && pid !== process.pid && isAlive(pid))
+        throw new RecapError('MEETING_ACTIVE', `"${meeting.title}" is being processed (pid ${pid})`);
+    const freed = pathSize(dir);
+    rmSync(dir, { recursive: true, force: true });
+    return { id: meeting.id, dir, freedBytes: freed };
+}

package/dist/media/probe.js

@@ -0,0 +1,50 @@
+import path from 'node:path';
+import { isRecord, parseJsonSafe } from "../core/json.js";
+import { exec } from "../core/proc.js";
+import { requireTool } from "../core/tools.js";
+import { RecapError } from "../errors.js";
+export function parseProbe(text) {
+    const value = parseJsonSafe(text);
+    if (!isRecord(value))
+        throw new Error('ffprobe returned no JSON');
+    const streams = Array.isArray(value['streams']) ? value['streams'].filter(isRecord) : [];
+    const format = isRecord(value['format']) ? value['format'] : {};
+    const audio = streams.filter((stream) => stream['codec_type'] === 'audio');
+    const video = streams.filter((stream) => stream['codec_type'] === 'video' && !(isRecord(stream['disposition']) && stream['disposition']['attached_pic'] === 1));
+    const enabled = audio.filter((stream) => !isRecord(stream['disposition']) || stream['disposition']['default'] !== 0).length;
+    const tags = isRecord(format['tags']) ? format['tags'] : {};
+    const creation = typeof tags['creation_time'] === 'string' ? tags['creation_time'] : undefined;
+    return {
+        duration: Number(format['duration'] ?? Number.NaN),
+        audioTracks: audio.length,
+        enabledAudioTracks: enabled,
+        videoTracks: video.length,
+        creationTime: creation,
+    };
+}
+export async function inspectMedia(file, config) {
+    const ffprobe = await requireTool('ffprobe', config);
+    const result = await exec(ffprobe, ['-v', 'error', '-print_format', 'json', '-show_format', '-show_streams', file]);
+    if (result.status !== 0)
+        throw new RecapError('MEDIA_UNREADABLE', `Cannot read ${path.basename(file)}: ${result.stderr.trim()}`);
+    try {
+        return parseProbe(result.stdout);
+    }
+    catch (error) {
+        throw new RecapError('MEDIA_UNREADABLE', `Cannot read ${path.basename(file)}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function verifyMedia(original, output, expectVideo, tolerance = 1) {
+    if (!Number.isFinite(output.duration) || Math.abs(output.duration - original.duration) > tolerance) {
+        throw new RecapError('VERIFY_FAILED', `The new file lasts ${output.duration.toFixed(1)}s instead of ${original.duration.toFixed(1)}s`);
+    }
+    if (output.audioTracks !== original.audioTracks) {
+        throw new RecapError('VERIFY_FAILED', `The new file has ${output.audioTracks} audio tracks instead of ${original.audioTracks}`);
+    }
+    if (output.enabledAudioTracks !== output.audioTracks) {
+        throw new RecapError('VERIFY_FAILED', `Only ${output.enabledAudioTracks} of ${output.audioTracks} audio tracks are enabled in the new file`);
+    }
+    if (output.videoTracks > 0 !== expectVideo) {
+        throw new RecapError('VERIFY_FAILED', expectVideo ? 'The new file has no video track' : 'The new file still has a video track');
+    }
+}

package/dist/pipeline/claude.js

@@ -0,0 +1,73 @@
+import { isRecord, parseJsonSafe } from "../core/json.js";
+import { exec } from "../core/proc.js";
+import { prefix, trimmed } from "../core/text.js";
+import { requireTool, toolEnvironment } from "../core/tools.js";
+import { RecapError } from "../errors.js";
+export const ISOLATION = ['--setting-sources', 'project', '--strict-mcp-config', '--no-session-persistence', '--disable-slash-commands'];
+export function claudeOptions(tools, addDirs, model, restrictTools) {
+    const args = [...ISOLATION];
+    if (restrictTools)
+        args.push('--tools', restrictTools.join(','));
+    const allowed = trimmed(tools.join(' '));
+    if (allowed.length > 0)
+        args.push('--allowedTools', allowed);
+    const seen = new Set();
+    for (const dir of addDirs) {
+        if (seen.has(dir))
+            continue;
+        seen.add(dir);
+        args.push('--add-dir', dir);
+    }
+    if (model)
+        args.push('--model', model);
+    return args;
+}
+export function streamArguments(tools, addDirs, model, restrictTools) {
+    return ['-p', '--output-format', 'stream-json', '--verbose', '--include-partial-messages', ...claudeOptions(tools, addDirs, model, restrictTools)];
+}
+export async function runClaude(call) {
+    const claude = await requireTool('claude', call.config);
+    const args = ['-p', '--output-format', 'json', ...claudeOptions(call.tools, call.addDirs, call.model, call.restrictTools)];
+    const result = await exec(claude, args, { input: call.prompt, env: toolEnvironment(claude, call.config), cwd: call.cwd });
+    if (result.status !== 0)
+        throw new RecapError('CLAUDE_FAILED', trimmed(result.stderr.length === 0 ? result.stdout : result.stderr));
+    return result.stdout;
+}
+export function runSummaryClaude(prompt, dir, config) {
+    return runClaude({ prompt, cwd: dir, config, tools: ['Read'], addDirs: [dir], model: config.summaryModel });
+}
+export async function streamClaude(prompt, cwd, config, args, onLine, onSpawn) {
+    const claude = await requireTool('claude', config);
+    let buffer = '';
+    const result = await exec(claude, args, {
+        input: prompt,
+        env: toolEnvironment(claude, config),
+        cwd,
+        detached: process.platform !== 'win32',
+        ...(onSpawn ? { onSpawn } : {}),
+        onStdout: (chunk) => {
+            buffer += chunk;
+            let newline = buffer.indexOf('\n');
+            while (newline !== -1) {
+                const line = buffer.slice(0, newline);
+                buffer = buffer.slice(newline + 1);
+                if (line.length > 0)
+                    onLine(line);
+                newline = buffer.indexOf('\n');
+            }
+        },
+    });
+    if (buffer.length > 0)
+        onLine(buffer);
+    return result;
+}
+export function resultText(output) {
+    const parsed = parseJsonSafe(output);
+    if (!isRecord(parsed))
+        throw new RecapError('CLAUDE_OUTPUT', `Unexpected output from claude: ${prefix(output, 300)}`);
+    const result = typeof parsed['result'] === 'string' ? parsed['result'] : undefined;
+    if (parsed['is_error'] === true || result === undefined || trimmed(result).length === 0) {
+        throw new RecapError('CLAUDE_FAILED', result ?? 'claude returned an empty answer');
+    }
+    return result;
+}

package/dist/pipeline/pipeline.js

@@ -0,0 +1,275 @@
+import { existsSync, mkdirSync, readdirSync, renameSync, rmSync } from 'node:fs';
+import { cpus } from 'node:os';
+import path from 'node:path';
+import { settingsOf, transcriptionLanguage, vadModelPath, whisperModelPath } from "../core/config.js";
+import { clock, isoNow } from "../core/dates.js";
+import { readText, writeAtomic } from "../core/fsutil.js";
+import { encodeJson, swiftDefault } from "../core/json.js";
+import { ProcessLock } from "../core/lock.js";
+import { isActiveStatus, loadMeeting, recordingPath, updateMeeting } from "../core/meeting.js";
+import { exec } from "../core/proc.js";
+import { suffix, trimmed } from "../core/text.js";
+import { requireTool } from "../core/tools.js";
+import { RecapError, errorMessage } from "../errors.js";
+import { docsClient, meetingTarget, requireBita } from "../bita/client.js";
+import { ProposalGenerator } from "../bita/proposals.js";
+import { runWrapup } from "../bita/wrapup.js";
+import { runSummaryClaude } from "./claude.js";
+import { STAGES, allStagesSatisfied, stageApplies, stageComplete, stageIsOptional, stageSkipped } from "./stages.js";
+import { extractSummary, saveSummary, summaryPromptFor } from "./summary.js";
+import { mergeTranscripts, orderedSegment, parseWhisper, transcriptMarkdown } from "./transcript.js";
+export const MAX_FRAMES = 40;
+export function whisperThreads() {
+    return Math.max(2, Math.min(8, cpus().length - 2));
+}
+export function showinfoTimes(log) {
+    const times = [];
+    for (const line of log.split('\n')) {
+        if (!line.includes('Parsed_showinfo'))
+            continue;
+        const index = line.indexOf('pts_time:');
+        if (index === -1)
+            continue;
+        const value = Number(line.slice(index + 'pts_time:'.length).split(/\s/)[0]);
+        if (Number.isFinite(value))
+            times.push(value);
+    }
+    return times;
+}
+export function evenlySpaced(count, limit) {
+    if (count <= limit || limit <= 1)
+        return Array.from({ length: count }, (_, index) => index);
+    return Array.from({ length: limit }, (_, index) => Math.round((index * (count - 1)) / (limit - 1)));
+}
+export function channelsOf(meeting) {
+    return meeting.mode === 'remote'
+        ? [
+            ['mic', 0],
+            ['system', 1],
+        ]
+        : [['mic', 0]];
+}
+export function whisperArguments(config, model, outputBase, wav, threads, previous) {
+    const args = ['-m', model, '-l', transcriptionLanguage(config), '-t', String(threads), '-oj', '-of', outputBase, '-np', '-sns'];
+    const prompt = [];
+    if (config.vocabulary && config.vocabulary.length > 0)
+        prompt.push(`Glosario: ${config.vocabulary.join(', ')}.`);
+    if (previous && trimmed(previous).length > 0)
+        prompt.push(trimmed(previous));
+    if (prompt.length > 0)
+        args.push('--prompt', prompt.join(' '));
+    if (existsSync(vadModelPath()))
+        args.push('--vad', '-vm', vadModelPath());
+    args.push(wav);
+    return args;
+}
+export class Pipeline {
+    dir;
+    config;
+    log;
+    constructor(dir, config, log) {
+        this.dir = dir;
+        this.config = config;
+        this.log = log;
+    }
+    file(name) {
+        return path.join(this.dir, name);
+    }
+    recording(meeting) {
+        return recordingPath(this.dir, meeting.mode);
+    }
+    setStage(stage, status, error, extra) {
+        return updateMeeting(this.dir, (current) => {
+            current.stages[stage] = { status, updatedAt: isoNow(), ...(error !== undefined ? { error } : {}) };
+            extra?.(current);
+        });
+    }
+    async run(from, only) {
+        let meeting = loadMeeting(this.dir);
+        if (isActiveStatus(meeting.status))
+            throw new RecapError('STILL_RECORDING', `"${meeting.title}" is still being recorded`);
+        if (!existsSync(this.recording(meeting)))
+            throw new RecapError('NO_RECORDING', `"${meeting.title}" has no recording`);
+        const lock = new ProcessLock(this.file('process.lock'));
+        try {
+            meeting = updateMeeting(this.dir, (current) => {
+                current.status = 'processing';
+            });
+            let forced = false;
+            for (const stage of STAGES) {
+                if (!stageApplies(stage, meeting))
+                    continue;
+                if (only !== undefined && stage !== only)
+                    continue;
+                if (stage === from)
+                    forced = true;
+                if (stage === 'proposals' && !settingsOf(this.config).proposals) {
+                    meeting = this.setStage(stage, 'skipped');
+                    this.log(`${stage}: skipped, live.proposals is off`);
+                    continue;
+                }
+                if (stageSkipped(stage, meeting, this.dir)) {
+                    if (stageComplete(meeting.stages[stage])) {
+                        this.log(`${stage}: already done`);
+                        continue;
+                    }
+                    meeting = this.setStage(stage, 'skipped');
+                    this.log(`${stage}: skipped, the recording has no video`);
+                    continue;
+                }
+                const done = meeting.stages[stage]?.status === 'done';
+                if (done && !forced && only === undefined) {
+                    this.log(`${stage}: already done`);
+                    continue;
+                }
+                this.log(`${stage}: running`);
+                const began = Date.now();
+                try {
+                    await this.execute(stage, meeting);
+                    meeting = this.setStage(stage, 'done');
+                    this.log(`${stage}: done in ${Math.trunc((Date.now() - began) / 1000)}s`);
+                }
+                catch (error) {
+                    const message = error instanceof RecapError ? error.message : errorMessage(error);
+                    if (stageIsOptional(stage)) {
+                        meeting = this.setStage(stage, 'failed', message);
+                        this.log(`${stage}: failed, continuing: ${message}`);
+                        continue;
+                    }
+                    meeting = this.setStage(stage, 'failed', message, (current) => {
+                        current.status = 'recorded';
+                    });
+                    this.log(`${stage}: failed: ${message}`);
+                    throw new RecapError('STAGE_FAILED', `${stage} failed: ${message}`);
+                }
+            }
+            const complete = allStagesSatisfied(meeting);
+            return updateMeeting(this.dir, (current) => {
+                current.status = complete ? 'processed' : 'recorded';
+            });
+        }
+        finally {
+            lock.release();
+        }
+    }
+    async execute(stage, meeting) {
+        switch (stage) {
+            case 'audio':
+                return this.extractAudio(meeting);
+            case 'transcribe':
+                return this.transcribe(meeting);
+            case 'frames':
+                return this.extractFrames(meeting);
+            case 'summarize':
+                return this.summarize(meeting);
+            case 'proposals':
+                return this.proposals(meeting);
+            case 'wrapup':
+                return runWrapup(meeting, this.dir, this.config);
+        }
+    }
+    async extractAudio(meeting) {
+        const ffmpeg = await requireTool('ffmpeg', this.config);
+        for (const [channel, index] of channelsOf(meeting)) {
+            const result = await exec(ffmpeg, [
+                '-hide_banner',
+                '-loglevel',
+                'error',
+                '-y',
+                '-i',
+                this.recording(meeting),
+                '-map',
+                `0:a:${index}`,
+                '-ac',
+                '1',
+                '-ar',
+                '16000',
+                '-c:a',
+                'pcm_s16le',
+                this.file(`${channel}.wav`),
+            ]);
+            if (result.status !== 0)
+                throw new RecapError('FFMPEG_FAILED', trimmed(result.stderr));
+        }
+    }
+    async transcribe(meeting) {
+        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\`.`);
+        if (channelsOf(meeting).some(([channel]) => !existsSync(this.file(`${channel}.wav`))))
+            await this.extractAudio(meeting);
+        const byChannel = {};
+        for (const [channel] of channelsOf(meeting)) {
+            const base = this.file(`transcript-${channel}`);
+            const result = await exec(whisper, whisperArguments(this.config, model, base, this.file(`${channel}.wav`), whisperThreads()));
+            if (result.status !== 0)
+                throw new RecapError('WHISPER_FAILED', trimmed(result.stderr));
+            const text = readText(`${base}.json`);
+            if (text === null)
+                throw new RecapError('WHISPER_FAILED', `whisper-cli did not write ${base}.json`);
+            try {
+                byChannel[channel] = parseWhisper(text, channel);
+            }
+            catch (error) {
+                throw new RecapError('WHISPER_FAILED', `Cannot read ${base}.json: ${errorMessage(error)}`);
+            }
+        }
+        const segments = mergeTranscripts(byChannel.mic ?? [], byChannel.system ?? []);
+        writeAtomic(this.file('transcript.json'), encodeJson(segments.map(orderedSegment), { pretty: true }));
+        writeAtomic(this.file('transcript.md'), transcriptMarkdown(meeting, segments));
+    }
+    async extractFrames(meeting) {
+        const ffmpeg = await requireTool('ffmpeg', this.config);
+        const framesDir = this.file('frames');
+        rmSync(framesDir, { recursive: true, force: true });
+        mkdirSync(framesDir, { recursive: true });
+        const select = "select='isnan(prev_selected_t)+gt(scene\\,0.15)*gte(t-prev_selected_t\\,20)+gte(t-prev_selected_t\\,300)',showinfo";
+        const result = await exec(ffmpeg, [
+            '-hide_banner',
+            '-y',
+            '-i',
+            this.recording(meeting),
+            '-map',
+            '0:v:0',
+            '-vf',
+            select,
+            '-fps_mode',
+            'vfr',
+            '-q:v',
+            '4',
+            path.join(framesDir, 'raw-%04d.jpg'),
+        ]);
+        if (result.status !== 0)
+            throw new RecapError('FFMPEG_FAILED', suffix(trimmed(result.stderr), 500));
+        const times = showinfoTimes(result.stderr);
+        const raw = readdirSync(framesDir)
+            .filter((name) => name.startsWith('raw-'))
+            .sort();
+        const keep = new Set(evenlySpaced(raw.length, MAX_FRAMES));
+        const frames = [];
+        raw.forEach((name, index) => {
+            const source = path.join(framesDir, name);
+            const time = times[index];
+            if (!keep.has(index) || time === undefined) {
+                rmSync(source, { force: true });
+                return;
+            }
+            const target = `${clock(Math.trunc(time * 1000)).replace(/:/g, '-')}.jpg`;
+            rmSync(path.join(framesDir, target), { force: true });
+            renameSync(source, path.join(framesDir, target));
+            frames.push({ file: `frames/${target}`, timeSeconds: time });
+        });
+        writeAtomic(this.file('frames.json'), swiftDefault(frames.map((frame) => ({ file: frame.file, timeSeconds: frame.timeSeconds }))));
+    }
+    async summarize(meeting) {
+        const prompt = summaryPromptFor(meeting, this.dir);
+        const output = await runSummaryClaude(prompt, this.dir, this.config);
+        saveSummary(extractSummary(output), meeting, this.dir);
+    }
+    async proposals(meeting) {
+        const target = meetingTarget(meeting);
+        const docs = (await docsClient(this.config, target)) ?? (await requireBita(this.config, target));
+        await new ProposalGenerator(this.config, docs, this.log).run(meeting, this.dir);
+    }
+}

package/dist/pipeline/resources.js

@@ -0,0 +1,16 @@
+import path from 'node:path';
+import { readText } from "../core/fsutil.js";
+import { configDir } from "../core/paths.js";
+import { RecapError } from "../errors.js";
+import { PACKAGE_ROOT } from "../version.js";
+export function resourcePath(name) {
+    return path.join(PACKAGE_ROOT, 'Resources', name);
+}
+export function loadResource(name) {
+    for (const candidate of [path.join(configDir(), name), resourcePath(name)]) {
+        const text = readText(candidate);
+        if (text !== null)
+            return text;
+    }
+    throw new RecapError('PROMPT_MISSING', `${name} not found; reinstall recap`);
+}

package/dist/pipeline/stages.js

@@ -0,0 +1,27 @@
+import { hasVideo } from "../media/media.js";
+export const STAGES = ['audio', 'transcribe', 'frames', 'summarize', 'proposals', 'wrapup'];
+export function isStage(value) {
+    return STAGES.includes(value);
+}
+export function stageApplies(stage, meeting) {
+    if (stage === 'frames')
+        return meeting.mode === 'remote';
+    if (stage === 'wrapup' || stage === 'proposals')
+        return meeting.bitaEntryId !== undefined;
+    return true;
+}
+export function stageSkipped(stage, meeting, dir) {
+    return stage === 'frames' && !hasVideo(dir, meeting.mode);
+}
+export function stageIsOptional(stage) {
+    return stage === 'proposals';
+}
+export function stageComplete(state) {
+    return state?.status === 'done' || state?.status === 'skipped';
+}
+export function stageSatisfied(stage, state) {
+    return stageComplete(state) || (stageIsOptional(stage) && state?.status === 'failed');
+}
+export function allStagesSatisfied(meeting) {
+    return STAGES.filter((stage) => stageApplies(stage, meeting)).every((stage) => stageSatisfied(stage, meeting.stages[stage]));
+}