@kikedealba/recap 0.0.0-stage → 0.9.0

package/dist/bita/proposals.js

@@ -0,0 +1,419 @@
+import { mkdirSync, rmSync } from 'node:fs';
+import path from 'node:path';
+import { isoNow } from "../core/dates.js";
+import { readText, writeAtomic } from "../core/fsutil.js";
+import { asIntLoose, extractBetween, isRecord, swiftPretty } from "../core/json.js";
+import { withDirectoryLockAsync } from "../core/lock.js";
+import { home } from "../core/paths.js";
+import { fold, prefix, replaceAll, trimmed } from "../core/text.js";
+import { RecapError, errorMessage } from "../errors.js";
+import { loadProjectContext, meetingProject } from "../live/context.js";
+import { resultText, runClaude } from "../pipeline/claude.js";
+import { loadResource } from "../pipeline/resources.js";
+import { callBita } from "./client.js";
+import { meetingDay } from "./wrapup.js";
+export const REVEALING_PHRASES = [
+    'se acordo',
+    'acordamos',
+    'decidimos',
+    'se decidio',
+    'por decision de',
+    'en la reunion',
+    'en la junta',
+    'segun lo hablado',
+    'como se comento',
+    'como se menciono',
+    'quedamos en',
+    'se platico',
+    'la grabacion',
+    'la transcripcion',
+];
+export function revealing(markdown) {
+    const folded = fold(markdown);
+    return REVEALING_PHRASES.find((phrase) => folded.includes(phrase)) ?? null;
+}
+export function cleanHeading(heading) {
+    return trimmed(trimmed(heading).replace(/^#+/, ''));
+}
+export function stripLeadingHeading(markdown, section) {
+    if (section === null)
+        return markdown;
+    const lines = markdown.split('\n');
+    const first = lines[0];
+    if (first === undefined || !first.startsWith('#') || fold(cleanHeading(first)) !== fold(section))
+        return markdown;
+    return trimmed(lines.slice(1).join('\n'));
+}
+function quoteOf(item) {
+    if (!isRecord(item) || typeof item['text'] !== 'string')
+        return null;
+    const text = trimmed(item['text']);
+    if (text.length === 0)
+        return null;
+    const raw = item['startMs'];
+    const startMs = typeof raw === 'number' && Number.isFinite(raw) ? Math.trunc(raw) : 0;
+    const channel = fold(typeof item['channel'] === 'string' ? item['channel'] : 'mic');
+    return { startMs: Math.max(0, startMs), channel: ['system', 'remotos', 'remoto'].includes(channel) ? 'system' : 'mic', text };
+}
+export function parseProposalPlan(text, candidates) {
+    const object = extractBetween(text, '{', '}');
+    if (!isRecord(object) || !Array.isArray(object['proposals'])) {
+        throw new RecapError('PROPOSALS_OUTPUT', `The proposals answer has no {"proposals": [...]} object: ${prefix(text, 200)}`);
+    }
+    const drafts = [];
+    const discarded = [];
+    const seen = new Set();
+    object['proposals'].forEach((raw, index) => {
+        if (!isRecord(raw)) {
+            discarded.push({ index, reason: 'not an object' });
+            return;
+        }
+        const pageId = asIntLoose(raw['pageId']);
+        const discard = (reason) => discarded.push({ index, pageId, reason });
+        if (pageId === undefined)
+            return discard('missing pageId');
+        if (!candidates.has(pageId))
+            return discard(`page ${pageId} is not a candidate`);
+        const rawSection = typeof raw['section'] === 'string' ? cleanHeading(raw['section']) : '';
+        const section = rawSection.length > 0 ? rawSection : null;
+        const markdown = trimmed(typeof raw['markdown'] === 'string' ? raw['markdown'] : '');
+        const title = prefix(trimmed(typeof raw['title'] === 'string' ? raw['title'] : ''), 160);
+        const rationale = trimmed(typeof raw['rationale'] === 'string' ? raw['rationale'] : '');
+        if (markdown.length === 0)
+            return discard('empty markdown');
+        if (title.length === 0)
+            return discard('empty title');
+        const phrase = revealing(markdown);
+        if (phrase)
+            return discard(`the markdown reveals the conversation (${phrase})`);
+        const quotes = (Array.isArray(raw['quotes']) ? raw['quotes'] : []).map(quoteOf).filter((quote) => quote !== null);
+        if (quotes.length === 0)
+            return discard('no quotes from the transcript');
+        const key = `${pageId}|${fold(section ?? '')}`;
+        if (seen.has(key))
+            return discard('duplicate change to the same section');
+        seen.add(key);
+        drafts.push({ pageId, section, markdown: stripLeadingHeading(markdown, section), title, rationale, quotes: quotes.slice(0, 3) });
+        return undefined;
+    });
+    return { drafts, discarded };
+}
+export const proposalStore = {
+    file: (dir) => path.join(dir, 'proposals.json'),
+    markdownDir: (dir) => path.join(dir, 'proposals'),
+    markdownFile: (dir, n) => path.join(dir, 'proposals', `${n}.md`),
+    branch: (entryId) => `proposal/meeting-${entryId}`,
+};
+function decodeProposal(value) {
+    if (!isRecord(value))
+        return null;
+    const { n, pageId, pageTitle, title, rationale, branch, sha, status, file } = value;
+    if (typeof n !== 'number' || typeof pageId !== 'number' || typeof pageTitle !== 'string' || typeof title !== 'string')
+        return null;
+    if (typeof rationale !== 'string' || typeof branch !== 'string' || typeof sha !== 'string' || typeof file !== 'string')
+        return null;
+    if (status !== 'pending' && status !== 'accepted' && status !== 'rejected' && status !== 'stale')
+        return null;
+    const quotes = Array.isArray(value['quotes']) ? value['quotes'].map(quoteOf).filter((quote) => quote !== null) : [];
+    return {
+        n,
+        pageId,
+        pageTitle,
+        section: typeof value['section'] === 'string' ? value['section'] : null,
+        title,
+        rationale,
+        quotes,
+        branch,
+        sha,
+        status,
+        appliedSha: typeof value['appliedSha'] === 'string' ? value['appliedSha'] : undefined,
+        file,
+        updatedAt: typeof value['updatedAt'] === 'string' ? value['updatedAt'] : undefined,
+    };
+}
+export function loadProposals(dir) {
+    const text = readText(proposalStore.file(dir));
+    if (text === null)
+        return null;
+    try {
+        const value = JSON.parse(text);
+        if (!isRecord(value) || typeof value['entryId'] !== 'number' || typeof value['branch'] !== 'string' || typeof value['generatedAt'] !== 'string')
+            return null;
+        if (!Array.isArray(value['proposals']))
+            return null;
+        const proposals = value['proposals'].map(decodeProposal);
+        if (proposals.some((proposal) => proposal === null))
+            return null;
+        const discarded = Array.isArray(value['discarded'])
+            ? value['discarded'].filter(isRecord).map((item) => ({ index: Number(item['index']), pageId: typeof item['pageId'] === 'number' ? item['pageId'] : undefined, reason: String(item['reason'] ?? '') }))
+            : [];
+        return {
+            entryId: value['entryId'],
+            branch: value['branch'],
+            generatedAt: value['generatedAt'],
+            branchDropped: value['branchDropped'] === true,
+            proposals: proposals,
+            discarded,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function encodeProposal(proposal) {
+    return {
+        n: proposal.n,
+        pageId: proposal.pageId,
+        pageTitle: proposal.pageTitle,
+        section: proposal.section,
+        title: proposal.title,
+        rationale: proposal.rationale,
+        quotes: proposal.quotes.map((quote) => ({ startMs: quote.startMs, channel: quote.channel, text: quote.text })),
+        branch: proposal.branch,
+        sha: proposal.sha,
+        status: proposal.status,
+        appliedSha: proposal.appliedSha,
+        file: proposal.file,
+        updatedAt: proposal.updatedAt,
+    };
+}
+export function proposalJson(proposal) {
+    return encodeProposal(proposal);
+}
+export function saveProposals(file, dir) {
+    writeAtomic(proposalStore.file(dir), swiftPretty({
+        entryId: file.entryId,
+        branch: file.branch,
+        generatedAt: file.generatedAt,
+        branchDropped: file.branchDropped,
+        proposals: file.proposals.map(encodeProposal),
+        discarded: file.discarded.map((item) => ({ index: item.index, pageId: item.pageId, reason: item.reason })),
+    }));
+}
+export async function propose(bita, branch, pageId, section, file, reason, entryId) {
+    const args = ['docs', 'propose', '--branch', branch, String(pageId), '--md', file];
+    if (section !== null)
+        args.push('--section', section);
+    args.push('--reason', reason, '--source', `meeting:${entryId}`);
+    const data = await callBita(bita, args);
+    const sha = isRecord(data) && typeof data['sha'] === 'string' ? data['sha'] : '';
+    if (sha.length === 0)
+        throw new RecapError('BITA_FAILED', 'bita docs propose did not return the commit sha');
+    return sha;
+}
+export function ownPageId(meeting) {
+    return meeting.wrapup?.pageId ?? meeting.bitaEntry?.pageIds[0];
+}
+export class ProposalGenerator {
+    config;
+    bita;
+    log;
+    claude;
+    constructor(config, bita, log, claude) {
+        this.config = config;
+        this.bita = bita;
+        this.log = log;
+        this.claude =
+            claude ??
+                (async (prompt, dirs) => resultText(await runClaude({ prompt, cwd: dirs[dirs.length - 1] ?? home(), config, tools: ['Read Grep Glob'], addDirs: dirs, model: config.summaryModel })));
+    }
+    async candidates(meeting, context) {
+        const own = ownPageId(meeting);
+        const pages = [...context.pages];
+        const known = new Set(pages.map((page) => page.pageId));
+        for (const pageId of meeting.bitaEntry?.pageIds ?? []) {
+            if (known.has(pageId) || pageId === own)
+                continue;
+            const response = await this.bita.invoke(['docs', 'page', 'show', String(pageId), '--no-markdown']).catch(() => null);
+            if (!response?.ok || !isRecord(response.data) || typeof response.data['title'] !== 'string')
+                continue;
+            pages.push({ pageId, title: response.data['title'], relPath: typeof response.data['relPath'] === 'string' ? response.data['relPath'] : '', depth: 0 });
+            known.add(pageId);
+        }
+        return pages.filter((page) => page.pageId !== own);
+    }
+    async run(meeting, dir) {
+        const entryId = meeting.bitaEntryId;
+        if (entryId === undefined)
+            return null;
+        const branch = proposalStore.branch(entryId);
+        const existing = loadProposals(dir);
+        if (existing) {
+            if (existing.proposals.some((proposal) => proposal.status !== 'pending')) {
+                this.log(`proposals: already reviewed, keeping ${existing.proposals.length}`);
+                return existing;
+            }
+            if (existing.proposals.length > 0)
+                await this.bita.invoke(['docs', 'branch', 'drop', branch]).catch(() => null);
+        }
+        const context = await loadProjectContext(await meetingProject(meeting, this.bita), meeting.bitaDocsRoot, this.bita);
+        const pages = await this.candidates(meeting, context);
+        const file = { entryId, branch, generatedAt: isoNow(), branchDropped: false, proposals: [], discarded: [] };
+        if (pages.length === 0 || context.docsRoot === null) {
+            this.log('proposals: no candidate pages');
+            saveProposals(file, dir);
+            return file;
+        }
+        const transcript = readText(path.join(dir, 'transcript.md'));
+        if (transcript === null)
+            throw new RecapError('NO_TRANSCRIPT', `"${meeting.title}" has no transcript yet`);
+        const prompt = this.render(meeting, context.docsRoot, pages, transcript);
+        const answer = await this.claude(prompt, [context.docsRoot, dir]);
+        const parsed = parseProposalPlan(answer, new Set(pages.map((page) => page.pageId)));
+        file.discarded = parsed.discarded;
+        for (const item of parsed.discarded)
+            this.log(`proposals: discarded #${item.index}: ${item.reason}`);
+        rmSync(proposalStore.markdownDir(dir), { recursive: true, force: true });
+        if (parsed.drafts.length > 0)
+            mkdirSync(proposalStore.markdownDir(dir), { recursive: true });
+        const titles = new Map();
+        for (const page of pages)
+            if (!titles.has(page.pageId))
+                titles.set(page.pageId, page.title);
+        const failures = [];
+        for (const draft of parsed.drafts) {
+            const n = file.proposals.length + 1;
+            const markdownFile = proposalStore.markdownFile(dir, n);
+            writeAtomic(markdownFile, `${draft.markdown}\n`);
+            try {
+                const sha = await propose(this.bita, branch, draft.pageId, draft.section, markdownFile, draft.title, entryId);
+                file.proposals.push({
+                    n,
+                    pageId: draft.pageId,
+                    pageTitle: titles.get(draft.pageId) ?? `#${draft.pageId}`,
+                    section: draft.section,
+                    title: draft.title,
+                    rationale: draft.rationale,
+                    quotes: draft.quotes,
+                    branch,
+                    sha,
+                    status: 'pending',
+                    file: markdownFile,
+                    updatedAt: isoNow(),
+                });
+            }
+            catch (error) {
+                rmSync(markdownFile, { force: true });
+                const message = errorMessage(error);
+                failures.push(message);
+                this.log(`proposals: page #${draft.pageId} failed: ${message}`);
+            }
+        }
+        saveProposals(file, dir);
+        this.log(`proposals: ${file.proposals.length} on ${branch}`);
+        if (file.proposals.length === 0 && failures[0])
+            throw new RecapError('PROPOSALS_FAILED', failures[0]);
+        return file;
+    }
+    render(meeting, docsRoot, pages, transcript) {
+        const list = pages.map((page) => `  - #${page.pageId} «${page.title}» — ${path.join(docsRoot, page.relPath)}`).join('\n');
+        const speakers = meeting.mode === 'remote'
+            ? 'Hablantes: «Sala» es el micrófono local; «Remotos» es el audio de la llamada.'
+            : 'Hablantes: un solo micrófono en la sala, sin separación por persona.';
+        let text = loadResource('proposals-prompt.md');
+        text = replaceAll(text, '{{title}}', meeting.bitaEntry?.title ?? meeting.title);
+        text = replaceAll(text, '{{date}}', meetingDay(meeting));
+        text = replaceAll(text, '{{mode}}', meeting.mode === 'remote' ? 'remota' : 'presencial');
+        text = replaceAll(text, '{{speakers}}', speakers);
+        text = replaceAll(text, '{{docsRoot}}', docsRoot);
+        text = replaceAll(text, '{{pages}}', list);
+        text = replaceAll(text, '{{transcript}}', transcript);
+        return text;
+    }
+}
+export class ProposalReview {
+    dir;
+    bita;
+    constructor(dir, bita) {
+        this.dir = dir;
+        this.bita = bita;
+    }
+    list() {
+        return loadProposals(this.dir)?.proposals ?? [];
+    }
+    proposal(n) {
+        const file = loadProposals(this.dir);
+        if (!file)
+            throw new RecapError('NO_PROPOSALS', 'The meeting has no proposals');
+        const found = file.proposals.find((item) => item.n === n);
+        if (!found)
+            throw new RecapError('PROPOSAL_NOT_FOUND', `There is no proposal ${n}`);
+        return found;
+    }
+    async diff(proposal) {
+        const response = await this.bita.invoke(['docs', 'branch', 'diff', proposal.branch, '--commit', proposal.sha]).catch(() => null);
+        return response?.ok ? response.data : null;
+    }
+    load() {
+        const file = loadProposals(this.dir);
+        if (!file)
+            throw new RecapError('NO_PROPOSALS', 'The meeting has no proposals');
+        return file;
+    }
+    find(n, file) {
+        const found = file.proposals.find((item) => item.n === n);
+        if (!found)
+            throw new RecapError('PROPOSAL_NOT_FOUND', `There is no proposal ${n}`);
+        return { ...found };
+    }
+    async store(proposal, file) {
+        const index = file.proposals.findIndex((item) => item.n === proposal.n);
+        if (index !== -1)
+            file.proposals[index] = proposal;
+        if (!file.branchDropped && !file.proposals.some((item) => item.status === 'pending')) {
+            const response = await this.bita.invoke(['docs', 'branch', 'drop', file.branch]).catch(() => null);
+            file.branchDropped = response?.ok === true;
+        }
+        saveProposals(file, this.dir);
+    }
+    accept(n, editedMarkdown) {
+        return withDirectoryLockAsync(path.join(this.dir, '.proposals.lockdir'), async () => {
+            const file = this.load();
+            const proposal = this.find(n, file);
+            if (proposal.status !== 'pending' && proposal.status !== 'stale')
+                throw new RecapError('PROPOSAL_CLOSED', `Proposal ${n} is already ${proposal.status}`);
+            const target = proposal.file;
+            if (editedMarkdown !== undefined) {
+                const text = readText(editedMarkdown);
+                if (text === null)
+                    throw new RecapError('FILE_UNREADABLE', `Cannot read ${editedMarkdown}`);
+                if (trimmed(text).length === 0)
+                    throw new RecapError('EMPTY_MARKDOWN', `${editedMarkdown} is empty`);
+                mkdirSync(path.dirname(target), { recursive: true });
+                if (path.resolve(editedMarkdown) !== path.resolve(target))
+                    writeAtomic(target, text);
+            }
+            if (editedMarkdown !== undefined || file.branchDropped) {
+                proposal.sha = await propose(this.bita, proposal.branch, proposal.pageId, proposal.section, target, proposal.title, file.entryId);
+                file.branchDropped = false;
+            }
+            const response = await this.bita.invoke(['docs', 'branch', 'apply', proposal.branch, '--commit', proposal.sha]);
+            if (response.ok) {
+                proposal.status = 'accepted';
+                const data = isRecord(response.data) ? response.data : {};
+                proposal.appliedSha = typeof data['appliedSha'] === 'string' ? data['appliedSha'] : typeof data['sha'] === 'string' ? data['sha'] : undefined;
+            }
+            else if (response.errorCode === 'MERGE_CONFLICT') {
+                proposal.status = 'stale';
+            }
+            else {
+                throw new RecapError('BITA_FAILED', `bita docs branch apply failed: ${response.errorMessage ?? 'no reason given'}`);
+            }
+            proposal.updatedAt = isoNow();
+            await this.store(proposal, file);
+            return proposal;
+        });
+    }
+    reject(n) {
+        return withDirectoryLockAsync(path.join(this.dir, '.proposals.lockdir'), async () => {
+            const file = this.load();
+            const proposal = this.find(n, file);
+            if (proposal.status !== 'pending' && proposal.status !== 'stale')
+                throw new RecapError('PROPOSAL_CLOSED', `Proposal ${n} is already ${proposal.status}`);
+            proposal.status = 'rejected';
+            proposal.updatedAt = isoNow();
+            await this.store(proposal, file);
+            return proposal;
+        });
+    }
+}

package/dist/bita/wrapup.js

@@ -0,0 +1,254 @@
+import path from 'node:path';
+import { dayString, parseDate } from "../core/dates.js";
+import { readText, writeAtomic } from "../core/fsutil.js";
+import { extractBetween, isRecord, swiftDefault } from "../core/json.js";
+import { durationSeconds, emptyWrapup, updateMeeting } from "../core/meeting.js";
+import { fold, formatDuration, prefix, replaceAll, suffix, trimmed } from "../core/text.js";
+import { RecapError } from "../errors.js";
+import { resultText, runSummaryClaude } from "../pipeline/claude.js";
+import { loadResource } from "../pipeline/resources.js";
+import { callBita, docsClient, meetingTarget, requireBita } from "./client.js";
+export const FORBIDDEN_SECTIONS = ['pendiente', 'proximos pasos', 'hallazgo', 'preguntas abiertas', 'lo que falta'];
+export function stripForbiddenSections(markdown) {
+    const kept = [];
+    let skipping = false;
+    let inFence = false;
+    for (const line of markdown.split('\n')) {
+        if (line.startsWith('```'))
+            inFence = !inFence;
+        if (!inFence && line.startsWith('## ')) {
+            const heading = fold(line.slice(3));
+            skipping = FORBIDDEN_SECTIONS.some((section) => heading.startsWith(section));
+        }
+        if (!skipping)
+            kept.push(line);
+    }
+    return kept.join('\n');
+}
+export function demoteHeadings(markdown) {
+    let inFence = false;
+    return markdown
+        .split('\n')
+        .map((line) => {
+        if (line.startsWith('```'))
+            inFence = !inFence;
+        return !inFence && line.startsWith('#') ? `#${line}` : line;
+    })
+        .join('\n');
+}
+export function parseWrapup(text) {
+    const start = text.indexOf('{');
+    const end = text.lastIndexOf('}');
+    if (start === -1 || end === -1 || start >= end)
+        throw new RecapError('WRAPUP_OUTPUT', `The wrap-up answer has no JSON object: ${prefix(text, 200)}`);
+    const raw = extractBetween(text, '{', '}');
+    const incomplete = (reason) => new RecapError('WRAPUP_OUTPUT', `The wrap-up JSON is incomplete: ${reason}`);
+    if (!isRecord(raw))
+        throw incomplete('the JSON object cannot be parsed');
+    if (typeof raw['title'] !== 'string')
+        throw incomplete('title is missing');
+    if (typeof raw['pageTitle'] !== 'string')
+        throw incomplete('pageTitle is missing');
+    if (typeof raw['pageMarkdown'] !== 'string')
+        throw incomplete('pageMarkdown is missing');
+    if (!Array.isArray(raw['backlog']))
+        throw incomplete('backlog is missing');
+    if (raw['project'] !== undefined && raw['project'] !== null && typeof raw['project'] !== 'string')
+        throw incomplete('project must be a string');
+    const items = [];
+    for (const item of raw['backlog']) {
+        if (!isRecord(item) || typeof item['kind'] !== 'string' || typeof item['title'] !== 'string')
+            throw incomplete('a backlog item is invalid');
+        if (item['body'] !== undefined && item['body'] !== null && typeof item['body'] !== 'string')
+            throw incomplete('a backlog body is invalid');
+        items.push({ kind: item['kind'], title: item['title'], body: typeof item['body'] === 'string' ? item['body'] : undefined });
+    }
+    const title = prefix(trimmed(raw['title']), 120);
+    const pageTitle = trimmed(raw['pageTitle']).length === 0 ? title : trimmed(raw['pageTitle']);
+    const page = trimmed(stripForbiddenSections(raw['pageMarkdown']));
+    if (title.length === 0 || page.length === 0)
+        throw new RecapError('WRAPUP_OUTPUT', 'The wrap-up answer has an empty title or page');
+    const project = typeof raw['project'] === 'string' ? trimmed(raw['project']) : undefined;
+    const backlog = items
+        .filter((item) => ['pending', 'finding'].includes(item.kind) && trimmed(item.title).length > 0)
+        .map((item) => ({ kind: item.kind, title: prefix(trimmed(item.title), 200), body: item.body === undefined ? undefined : trimmed(item.body) }));
+    return { title, project: project && project.length > 0 ? project : undefined, pageTitle, pageMarkdown: page, backlog };
+}
+export const GENERIC_TITLES = new Set([
+    '',
+    'reunion',
+    'reunion presencial',
+    'reunion remota',
+    'junta',
+    'junta presencial',
+    'junta remota',
+    'meet',
+    'meeting',
+    'llamada',
+    'videollamada',
+    'remote meeting',
+    'in-person meeting',
+    'in person meeting',
+    'reunion en sala',
+    'sesion',
+]);
+export function isGenericTitle(title) {
+    const folded = fold(title)
+        .split(/[^\p{L}\p{M}\p{N}-]+/u)
+        .filter((part) => part.length > 0)
+        .join(' ');
+    return GENERIC_TITLES.has(folded);
+}
+export function chooseProject(current, proposed, available) {
+    if (current && trimmed(current).length > 0)
+        return { apply: null, resolved: true };
+    if (!proposed)
+        return { apply: null, resolved: false };
+    const wanted = fold(proposed);
+    const match = available.find((name) => fold(name) === wanted);
+    return match ? { apply: match, resolved: true } : { apply: null, resolved: false };
+}
+export const NOTE_SECTION = 'Reunión';
+export function noteBody(summary, meeting, dir) {
+    let body = summary;
+    const start = body.indexOf('## Resumen');
+    if (start !== -1)
+        body = body.slice(start);
+    const mode = meeting.mode === 'remote' ? 'remota' : 'presencial';
+    const lines = [`Minuta de la reunión ${mode} (${formatDuration(durationSeconds(meeting))}), generada por recap a partir de la grabación.`, ''];
+    let inFence = false;
+    for (const line of body.split('\n')) {
+        if (line.startsWith('```'))
+            inFence = !inFence;
+        lines.push(!inFence && line.startsWith('#') ? `#${line}` : line);
+    }
+    while (lines.length > 0 && trimmed(lines[lines.length - 1] ?? '').length === 0)
+        lines.pop();
+    lines.push('', `Archivos de la reunión: \`${dir}\` (\`summary.md\`, \`transcript.md\`${meeting.mode === 'remote' ? ', `frames/`' : ''}).`);
+    return `${lines.join('\n')}\n`;
+}
+export async function saveMinutes(meeting, dir, config, client) {
+    const entryId = meeting.bitaEntryId;
+    if (entryId === undefined)
+        return;
+    const bita = client ?? (await requireBita(config, meetingTarget(meeting)));
+    const summary = readText(path.join(dir, 'summary.md'));
+    if (summary === null)
+        throw new RecapError('NO_SUMMARY', `"${meeting.title}" has no summary to send to bita`);
+    const note = path.join(dir, 'bita-note.md');
+    writeAtomic(note, noteBody(summary, meeting, dir));
+    const result = await bita.run(['note', 'save', String(entryId), '--note-md', note, '--section', NOTE_SECTION, '--json', ...bita.targetArgs()]);
+    if (result.status !== 0) {
+        throw new RecapError('BITA_FAILED', `bita note save ${entryId} failed: ${suffix(trimmed(result.stdout + result.stderr), 400)}`);
+    }
+}
+export function meetingDay(meeting) {
+    return dayString(parseDate(meeting.startedAt) ?? parseDate(meeting.createdAt) ?? new Date());
+}
+export function encodeWrapupPlan(plan) {
+    return swiftDefault({
+        title: plan.title,
+        project: plan.project,
+        pageTitle: plan.pageTitle,
+        pageMarkdown: plan.pageMarkdown,
+        backlog: plan.backlog.map((item) => ({ kind: item.kind, title: item.title, body: item.body })),
+    });
+}
+async function pageText(docs, pageId) {
+    const page = await callBita(docs, ['docs', 'page', 'show', String(pageId)]);
+    const doc = isRecord(page) && isRecord(page['doc']) ? page['doc'] : undefined;
+    const file = typeof doc?.['path'] === 'string' ? doc['path'] : undefined;
+    return file ? readText(file) : null;
+}
+export async function planWrapup(meeting, dir, snapshot, projects, existingPage, claude) {
+    const summary = readText(path.join(dir, 'summary.md')) ?? '';
+    const transcript = readText(path.join(dir, 'transcript.md')) ?? '';
+    const pageNote = existingPage === null
+        ? ''
+        : `- Esta reunión ya tiene página. \`pageMarkdown\` se agregará como una sección nueva de esa página; no repitas lo que ya dice:\n<pagina_actual>\n${prefix(existingPage, 20_000)}\n</pagina_actual>`;
+    let prompt = loadResource('wrapup-prompt.md');
+    prompt = replaceAll(prompt, '{{currentTitle}}', snapshot.title);
+    prompt = replaceAll(prompt, '{{currentProject}}', snapshot.projectName ?? 'ninguno');
+    prompt = replaceAll(prompt, '{{date}}', meetingDay(meeting));
+    prompt = replaceAll(prompt, '{{duration}}', formatDuration(durationSeconds(meeting)));
+    prompt = replaceAll(prompt, '{{mode}}', meeting.mode === 'remote' ? 'remota' : 'presencial');
+    prompt = replaceAll(prompt, '{{projects}}', projects.map((name) => `  - ${name}`).join('\n'));
+    prompt = replaceAll(prompt, '{{existingPage}}', pageNote);
+    prompt = replaceAll(prompt, '{{summary}}', summary);
+    prompt = replaceAll(prompt, '{{transcript}}', transcript);
+    return parseWrapup(await claude(prompt));
+}
+export async function runWrapup(meeting, dir, config, dependencies) {
+    const entryId = meeting.bitaEntryId;
+    if (entryId === undefined)
+        return;
+    const bita = dependencies?.bita ?? (await requireBita(config, meetingTarget(meeting)));
+    const docs = dependencies?.docs ?? (await docsClient(config, meetingTarget(meeting))) ?? bita;
+    const claude = dependencies?.claude ?? (async (prompt) => resultText(await runSummaryClaude(prompt, dir, config)));
+    const snapshot = meeting.bitaEntry ?? { title: meeting.title, pageIds: [] };
+    const wrapup = { ...emptyWrapup(), ...(meeting.wrapup ?? {}) };
+    const listed = await callBita(bita, ['projects']);
+    const projects = (Array.isArray(listed) ? listed : [])
+        .filter(isRecord)
+        .filter((project) => project['active'] !== false)
+        .flatMap((project) => (typeof project['name'] === 'string' ? [project['name']] : []));
+    const existingPageId = wrapup.pageId ?? snapshot.pageIds[0];
+    const existingPage = existingPageId === undefined ? null : await pageText(docs, existingPageId);
+    const plan = await planWrapup(meeting, dir, snapshot, projects, existingPage, claude);
+    writeAtomic(path.join(dir, 'wrapup.json'), encodeWrapupPlan(plan));
+    if (isGenericTitle(snapshot.title)) {
+        await callBita(bita, ['amend', String(entryId), '--title', plan.title]);
+        wrapup.title = plan.title;
+        wrapup.titleChanged = true;
+    }
+    else {
+        wrapup.title = snapshot.title;
+    }
+    const choice = chooseProject(snapshot.projectName, plan.project, projects);
+    if (choice.apply)
+        await callBita(bita, ['amend', String(entryId), '--project', choice.apply]);
+    wrapup.project = choice.apply ?? snapshot.projectName;
+    wrapup.projectResolved = choice.resolved;
+    const pageFile = path.join(dir, 'bita-page.md');
+    if (existingPageId !== undefined) {
+        writeAtomic(pageFile, demoteHeadings(plan.pageMarkdown));
+        await callBita(docs, ['docs', 'page', 'write', String(existingPageId), '--md', pageFile, '--section', `Reunión ${meetingDay(meeting)}`]);
+        wrapup.pageId = existingPageId;
+    }
+    else {
+        writeAtomic(pageFile, plan.pageMarkdown);
+        const args = ['docs', 'page', 'new', plan.pageTitle, '--from-entry', String(entryId)];
+        if (wrapup.project)
+            args.push('--project', wrapup.project);
+        const created = await callBita(docs, args);
+        const page = isRecord(created) && isRecord(created['page']) ? created['page'] : undefined;
+        const pageId = typeof page?.['pageId'] === 'number' ? page['pageId'] : undefined;
+        if (pageId === undefined)
+            throw new RecapError('BITA_FAILED', 'bita docs page new did not return the page id');
+        await callBita(docs, ['docs', 'page', 'write', String(pageId), '--md', pageFile]);
+        wrapup.pageId = pageId;
+        wrapup.pageCreated = true;
+    }
+    updateMeeting(dir, (current) => {
+        current.wrapup = { ...wrapup, backlogKeys: { ...wrapup.backlogKeys } };
+    });
+    for (const item of plan.backlog) {
+        if (wrapup.backlogKeys[item.title] !== undefined)
+            continue;
+        const args = ['backlog', 'add', '--kind', item.kind, '--title', item.title, '--page', String(wrapup.pageId ?? 0)];
+        if (item.body) {
+            const bodyFile = path.join(dir, 'bita-backlog-item.md');
+            writeAtomic(bodyFile, item.body);
+            args.push('--md', bodyFile);
+        }
+        const added = await callBita(docs, args);
+        wrapup.backlogKeys[item.title] = isRecord(added) && typeof added['key'] === 'string' ? added['key'] : '?';
+        updateMeeting(dir, (current) => {
+            current.wrapup = { ...wrapup, backlogKeys: { ...wrapup.backlogKeys } };
+        });
+    }
+    await saveMinutes(meeting, dir, config, bita);
+    updateMeeting(dir, (current) => {
+        current.wrapup = { ...wrapup, backlogKeys: { ...wrapup.backlogKeys } };
+    });
+}