@kikedealba/recap 0.9.1 → 0.11.0

package/README.md

@@ -37,9 +37,14 @@ Requisitos: Node 24 o superior, ffmpeg, whisper.cpp (`whisper-cli`) y
   `start`, `stop`, `cancel` y `amend` de las entradas `remote-meeting` e
   `in-person-meeting`. Reemplaza al viejo `bita hooks add` y quita ese hook si
   lo encuentra, para que no se dispare dos veces;
-- instala la skill y los comandos en los agentes que encuentre: Claude Code,
-  opencode, Codex y Gemini CLI (`--agents codex,gemini`, `--agents all` o
-  `--agents none`). Si el plugin de Claude Code ya está instalado, no lo duplica.
+- en Claude Code agrega o actualiza el marketplace `KikeDeAlba/recap` e instala
+  o actualiza el plugin `recap@recap` (`claude plugin marketplace add|update` y
+  `claude plugin install|update --scope user`), así el plugin queda en la misma
+  versión que la CLI; también quita los archivos sueltos que versiones viejas
+  dejaron en `~/.claude`;
+- en opencode, Codex y Gemini CLI instala la skill y las skills de usuario en el
+  formato de cada uno (`--agents codex,gemini`, `--agents all` o
+  `--agents none`).
 
 En Windows y Linux `recap start` falla con `CAPTURE_UNAVAILABLE`: graba con la
 app que quieras y procesa el archivo con
@@ -51,9 +56,11 @@ recap import llamada.mov --remote                         # video con dos pistas
 
 Los archivos en disco, los comandos, las opciones y el sobre `--json` son los
 mismos que los del `recap` en Swift, así que las dos versiones leen las mismas
-reuniones. Cuando [inkwell](https://github.com/KikeDeAlba/inkwell) está
-instalado y ya migró los documentos de bita, las páginas, las propuestas y el
-backlog se escriben con inkwell; si no, con `bita docs` y `bita backlog`.
+reuniones. bita solo lleva el tiempo: las páginas, las propuestas, el backlog
+y la nota de cada entrada viven en [inkwell](https://github.com/KikeDeAlba/inkwell),
+y el volcado del tiempo a Jira lo hace [tally](https://github.com/KikeDeAlba/tally).
+Sin inkwell la reunión se procesa igual: las etapas `proposals` y `wrapup` se
+saltan con un aviso y la minuta se queda en la carpeta de la reunión.
 
 Para trabajar en el paquete: `pnpm install`, `pnpm test`, `pnpm typecheck` y
 `node src/bin/recap.ts <comando>`.
@@ -131,26 +138,47 @@ recap prompt <meeting>                 # print the summary prompt with transcrip
 recap save-summary <meeting> file.md   # store minutes written elsewhere
 ```
 
-## Claude Code plugin
+## Plugin de Claude Code
 
-The repository is also a Claude Code plugin marketplace:
+El repositorio también es un marketplace de plugins de Claude Code. `recap setup`
+lo instala y lo mantiene al día; a mano sería:
 
 ```
-/plugin marketplace add KikeDeAlba/recap
-/plugin install recap@recap
+claude plugin marketplace add KikeDeAlba/recap
+claude plugin install recap@recap --scope user
+claude plugin marketplace update recap && claude plugin update recap@recap   # al actualizar la CLI
 ```
 
-| Command | What it does |
-|---|---|
-| `/recap-start [remota\|presencial] [título]` | Starts a recording; infers the mode from the arguments or the conversation and asks when it cannot |
-| `/recap-stop [--wait]` | Stops the recording; with `--wait` it processes in the foreground and shows agreements and action items |
-| `/recap-status` | Shows whether a recording is running and how far processing got |
-| `/recap-list [meeting]` | Lists meetings or shows one meeting's minutes |
-| `/recap-summarize [meeting] [instructions]` | Rewrites the minutes inside the session, following extra instructions, and stores them with `recap save-summary` |
-| `/recap-ask [question]` | Answers the last question of the meeting being recorded, or the one given, from the bita pages and the project repositories |
-| `/recap-proposals [meeting]` | Reviews the documentation changes proposed by a meeting and accepts, edits or rejects them |
-
-The `recap` skill lets Claude answer questions such as "¿qué acordamos en la reunión de ayer?" from the stored minutes and transcripts. The commands call `recap`, so it must be on the `PATH` of the shell Claude Code runs.
+Trae tres cosas:
+
+- **La skill `recap`**, que Claude carga sola cuando la conversación trata de
+  reuniones ("¿qué acordamos en la reunión de ayer?"). Es la única fuente del
+  flujo de una reunión; bita y tally enlazan a ella. Lo largo (cierre con bita e
+  inkwell, en vivo, propuestas, espacio) vive en archivos aparte que se leen
+  solo cuando hacen falta.
+- **Skills de usuario** con `disable-model-invocation: true`: no ocupan contexto
+  y solo corren cuando las escribes.
+
+  | Skill | Qué hace |
+  |---|---|
+  | `/recap:recap-start [remota\|presencial] [título]` | Empieza a grabar; saca el modo de los argumentos o de la conversación y pregunta si no puede |
+  | `/recap:recap-stop [--no-wait]` | Para la grabación (por bita si la sigue un cronómetro), espera el procesamiento y muestra el resultado |
+  | `/recap:recap-status` | Dice si se está grabando y en qué va el procesamiento |
+  | `/recap:recap-list [reunión]` | Lista las reuniones o muestra la minuta de una |
+  | `/recap:recap-summarize [reunión] [indicaciones]` | Rehace la minuta dentro de la sesión y la guarda con `recap save-summary` |
+  | `/recap:recap-ask [pregunta]` | Responde la última pregunta de la reunión en curso, o la que le pases, con las páginas de inkwell y los repos del proyecto |
+  | `/recap:recap-proposals [reunión]` | Revisa los cambios a la documentación que propuso una reunión |
+
+- **Un monitor** (`monitors/monitors.json`) que corre `recap watch` en segundo
+  plano en cada sesión interactiva. Revisa las carpetas de reuniones cada 5 s,
+  sin llamar al modelo, y escribe una sola línea cuando una reunión termina de
+  procesarse o falla; esa línea le llega a Claude como notificación. No corre
+  con `claude -p`. Si `recap` no está en el `PATH`, no hace nada. Para apagarlo,
+  define `RECAP_MONITOR=off` en el entorno de Claude Code (por ejemplo en
+  `"env"` de `~/.claude/settings.json`).
+
+Las skills llaman a `recap`, así que tiene que estar en el `PATH` del shell que
+usa Claude Code.
 
 ## Live assistant
 
@@ -160,7 +188,7 @@ While a meeting is being recorded, recap also transcribes it live:
 - A detached `recap live-worker` transcribes each chunk with `whisper-cli` (same model and VAD as the pipeline, 4 threads, the previous text as prompt), drops hallucinations and microphone echo, and appends `{startMs, endMs, channel, text}` lines to `live/transcript.jsonl`, with offsets from the start of the recording. It exits once the recording stops and the queue is empty.
 - The transcript after `stop` is still the source of truth; the live one is for answering during the meeting.
 
-`recap ask` answers a question with Claude Code (headless, streaming), reading only the bita pages and the repositories registered for the entry's project (`bita project repo ls`, bita 0.16 or later):
+`recap ask` answers a question with Claude Code (headless, streaming), reading only the inkwell pages of the project (`inkwell page ls --project`) and the repositories registered for it in bita (`bita project repo ls`). Without inkwell it answers from the repositories alone:
 
 ```sh
 recap ask --active                                      # the last question in the live transcript
@@ -191,9 +219,9 @@ With `live.autoAsk` on (the default), the live worker also looks for questions o
 
 ### Proposed documentation changes
 
-For meetings linked to a bita entry, the `proposals` stage (before `wrapup`) asks Claude Code (`Resources/proposals-prompt.md`) for the explicit, firm changes said about existing pages: the project pages and the pages linked to the entry, never the meeting's own page. Ideas, doubts and statements corrected later are left out, and the text follows bita's writing rule: nothing that reveals the conversation.
+For meetings linked to a bita entry, when inkwell is installed, the `proposals` stage (before `wrapup`) asks Claude Code (`Resources/proposals-prompt.md`) for the explicit, firm changes said about existing pages: the project pages and the pages linked to the entry in inkwell (`inkwell page ls --entry`), never the meeting's own page. Ideas, doubts and statements corrected later are left out, and the text follows the documentation writing rule: nothing that reveals the conversation.
 
-Each change becomes a commit on the docs branch `proposal/meeting-<entry>` through `bita docs propose`, and is listed in `proposals.json` (its markdown in `proposals/<n>.md`). Nothing reaches `main`, or Confluence, until it is accepted:
+Each change becomes a commit on the docs branch `proposal/meeting-<entry>` through `inkwell git propose`, and is listed in `proposals.json` (its markdown in `proposals/<n>.md`). Nothing reaches `main`, or Confluence, until it is accepted:
 
 ```sh
 recap proposals ls <meeting> --json          # or --bita-entry <id>
@@ -202,41 +230,44 @@ recap proposals accept <meeting> <n> [--md edited.md]
 recap proposals reject <meeting> <n>
 ```
 
-`accept` runs `bita docs branch apply`; with `--md` it first proposes the edited text again. If the page changed since the proposal, the merge conflicts and the proposal turns `stale` (the command still succeeds). When no proposal is pending, the branch is dropped. A failure in this stage is recorded in `stages.proposals` and never stops the wrap-up. Turn it off with `recap config set live.proposals false`.
+`accept` runs `inkwell branch apply` (and needs inkwell); with `--md` it first proposes the edited text again. If the page changed since the proposal, the merge conflicts and the proposal turns `stale` (the command still succeeds). When no proposal is pending, the branch is dropped. A failure in this stage is recorded in `stages.proposals` and never stops the wrap-up; without inkwell the stage is `skipped` with the reason in `stages.proposals.reason`. Turn it off with `recap config set live.proposals false`.
 
 ## bita integration
 
-With [bita](https://github.com/KikeDeAlba/bita-cli) 0.12 or later, a meeting timer records the meeting while it runs:
+With [bita](https://github.com/KikeDeAlba/bita-cli), a meeting timer records the meeting while it runs:
 
 ```sh
 bita start "Planeación sprint 42" --kind remote-meeting     # recap starts recording the screen, system audio and mic
 bita start "1:1 con Ana" --kind in-person-meeting           # recap records the mic only
-bita stop                                                   # recap stops, processes, and writes the minutes into the entry
+bita stop                                                   # recap stops, processes, and writes the minutes into the entry note in inkwell
 ```
 
-`recap setup` registers the hook in bita (`bita hooks add --on start,stop,cancel,amend --kind in-person-meeting,remote-meeting -- …/recap bita-hook`). It works the same whether the timer is started from the terminal, from Claude Code or from bita-desktop.
+`recap setup` subscribes `recap bita-hook` to bita's `start`, `stop`, `cancel` and `amend` events through the kit registry. It works the same whether the timer is started from the terminal, from Claude Code or from bita-desktop.
 
 | bita event | recap |
 |---|---|
 | `start` of a meeting kind | starts recording in the matching mode, linked to the entry |
-| `stop` | stops, processes in the background and wraps the meeting up in bita (see below) |
+| `stop` | stops, processes in the background and wraps the meeting up (see below) |
 | `cancel` | discards the recording |
 | `amend --kind <meeting kind>` on a running entry | starts recording |
 | `amend --kind none` while recording | stops without processing; the recording is kept |
+| `amend` of the title or project only | updates the meeting's title and entry data; the recording is not touched |
 
 ### Wrap-up
 
-After the summary, the `wrapup` stage asks Claude Code (headless, `Resources/wrapup-prompt.md`) for a title, a project, a documentation page and backlog items, and applies them through the bita CLI:
+After the summary, the `wrapup` stage asks Claude Code (headless, `Resources/wrapup-prompt.md`) for a title, a project, a documentation page and backlog items, and applies them: title and project through `bita amend`, everything else through inkwell (found in the kit registry by its capabilities):
 
 - the timer gets the meeting's real topic as its title when the current one is generic ("Reunión presencial", "Junta", …);
-- if the timer has no project, it gets one only when the conversation makes it clear and the name exists in `bita projects`; otherwise `wrapup.projectResolved` is false and `/bita-stop` asks;
-- a page is created with `bita docs page new --from-entry` in that project and written as formal documentation (no pending sections); if the timer already had a page, a `## Reunión <date>` section is added to it instead;
-- action items and open questions become `bita backlog` items on that page;
-- the minutes still land in the `## Reunión` section of the entry document.
+- if the timer has no project, it gets one only when the conversation makes it clear and the name exists in `bita projects`; otherwise `wrapup.projectResolved` is false and `/recap-stop` asks;
+- a page is created with `inkwell page new --from-entry` in that project and written as formal documentation (no pending sections); if the entry already has a page in inkwell (`inkwell page ls --entry`), a `## Reunión <date>` section is added to it instead;
+- action items and findings become `inkwell backlog add` items on that page;
+- the minutes land in the `Reunión` section of the entry note (`inkwell note save <entry> --section Reunión --md …`, capability `docs.entry-notes`).
+
+Without inkwell the stage is `skipped` (reason and hint `npm i -g @kikedealba/inkwell && inkwell setup` in `stages.wrapup`) and the meeting is still `processed`; the minutes stay in `summary.md`. With an inkwell lacking `docs.entry-notes` the page and backlog are written and `process.log` notes that the minutes were not saved. Run `recap process <id> --from proposals` after installing it. Time goes to Jira later through tally, never from recap.
 
 `recap wait --bita-entry <id>` blocks until all of that is done and prints the result (`data.wrapup` with `--json`).
 
-The hook output goes to `hooks.log` beside the bita database. Minutes regenerated with `/recap-summarize` or `recap save-summary` are sent to bita again.
+The hook output goes to `hooks.log` beside the bita database. Minutes regenerated with `/recap-summarize` or `recap save-summary` are saved in the entry note again when inkwell is installed.
 
 ## Pipeline
 
@@ -246,8 +277,8 @@ The hook output goes to `hooks.log` beside the bita database. Minutes regenerate
 | `transcribe` | per channel, then merged | mic | `transcript.json`, `transcript.md` |
 | `frames` | scene changes, at least 20 s apart, at most 40 | skipped | `frames/hh-mm-ss.jpg`, `frames.json` |
 | `summarize` | `claude -p` with transcript and frames | `claude -p` with transcript | `summary.md` |
-| `proposals` | only when linked to a bita entry and `live.proposals` is on | same | `proposals.json`, `proposals/<n>.md` and the docs branch `proposal/meeting-<entry>` |
-| `wrapup` | only when linked to a bita entry | same | entry title and project, a bita page, backlog items and the `## Reunión` section of the entry document |
+| `proposals` | only when linked to a bita entry and `live.proposals` is on; skipped without inkwell | same | `proposals.json`, `proposals/<n>.md` and the docs branch `proposal/meeting-<entry>` |
+| `wrapup` | only when linked to a bita entry; skipped without inkwell | same | entry title and project (bita), an inkwell page, backlog items and the `Reunión` section of the entry note |
 
 - Transcription runs locally with `whisper-cli`, `large-v3-turbo` and Silero VAD. Known whisper hallucinations on silence are dropped.
 - In remote meetings the microphone is labelled **Sala** and the call audio **Remotos**. When the microphone picks up the speakers, segments that repeat the call audio within a few seconds are removed as echo; headphones avoid the problem entirely.

package/Resources/ask-prompt.md

@@ -10,7 +10,7 @@ Estás acompañando en vivo una reunión. Quien te consulta necesita una respues
 
 Responde solo con lo que encuentres en estas fuentes. Puedes leerlas con Read, Grep y Glob. Para el historial de un repositorio usa solo `git -C <ruta del repo> log`, `git -C <ruta del repo> show` o `git -C <ruta del repo> diff`, con la ruta exacta de la lista: un comando por llamada, sin `cd`, sin `&&` y sin tuberías; cualquier otra forma se rechaza.
 
-- Raíz de la documentación de bita: {{docsRoot}}
+- Raíz de la documentación (inkwell): {{docsRoot}}
 - Páginas del proyecto (ruta relativa a la raíz):
 {{pages}}
 - Repositorios del proyecto:

package/Resources/wrapup-prompt.md

@@ -1,4 +1,4 @@
-Vas a cerrar en bita el registro de una reunión ya transcrita y resumida. Con la minuta y la transcripción de abajo, decide cómo queda documentada.
+Vas a cerrar el registro de una reunión ya transcrita y resumida. Con la minuta y la transcripción de abajo, decide cómo queda documentada.
 
 - Título actual del contador: «{{currentTitle}}»
 - Proyecto actual del contador: {{currentProject}}

package/dist/bita/client.js

@@ -53,8 +53,6 @@ export class BitaClient {
         const args = [];
         if (this.target.databasePath)
             args.push('--db-path', this.target.databasePath);
-        if (this.target.docsRoot)
-            args.push('--docs-dir', this.target.docsRoot);
         return args;
     }
     async run(args) {
@@ -69,36 +67,49 @@ export class BitaClient {
         return parseResponse(result.stdout, result.stderr, result.status);
     }
 }
-export function inkwellArguments(args) {
-    if (args[0] === 'backlog')
-        return [...args];
-    if (args[0] !== 'docs')
-        return null;
-    if (args[1] === 'propose')
-        return ['git', 'propose', ...args.slice(2)];
-    return args.slice(1);
-}
-let inkwellCache = null;
-export function resetInkwellCache() {
-    inkwellCache = null;
-}
-async function discoverInkwell() {
+export const INKWELL_HINT = 'npm i -g @kikedealba/inkwell && inkwell setup';
+export const INKWELL_CAPABILITIES = {
+    pages: ['docs.page.read'],
+    wrapup: ['docs.page.read', 'docs.page.write', 'docs.backlog'],
+    proposals: ['docs.page.read', 'docs.propose'],
+    notes: ['docs.entry-notes'],
+};
+export async function lookupInkwell(capabilities = []) {
     if (process.env['RECAP_NO_INKWELL'] === '1')
-        return null;
-    const tool = await findTool('inkwell', { capability: 'docs.page.write' }).catch(() => null);
+        return { client: null, reason: 'inkwell is turned off (RECAP_NO_INKWELL=1)' };
+    const tool = await findTool('inkwell').catch(() => null);
     if (!tool)
-        return null;
-    try {
-        const { envelope } = await invokeTool(tool, ['migrate', 'status'], { env: { ...process.env, ...QUIET_ENV }, timeoutMs: 20_000 });
-        return envelope.ok && envelope.data?.migrated === true ? tool : null;
-    }
-    catch {
-        return null;
+        return { client: null, reason: 'inkwell is not installed' };
+    const missing = capabilities.filter((capability) => !tool.manifest.capabilities.includes(capability));
+    if (missing.length > 0)
+        return { client: null, reason: `inkwell ${tool.manifest.version} lacks ${missing.join(', ')}` };
+    return { client: new InkwellClient(tool) };
+}
+export async function findInkwell(capabilities = []) {
+    return (await lookupInkwell(capabilities)).client;
+}
+export async function requireInkwell(capabilities, purpose) {
+    const found = await lookupInkwell(capabilities);
+    if (found.client)
+        return found.client;
+    throw new RecapError('DEPENDENCY_MISSING', `${purpose} needs inkwell: ${found.reason}`, { hint: INKWELL_HINT });
+}
+export class StageSkipped extends RecapError {
+    constructor(message, hint) {
+        super('STAGE_SKIPPED', message, hint === undefined ? {} : { hint });
     }
 }
-export function findInkwell() {
-    inkwellCache ??= discoverInkwell();
-    return inkwellCache;
+export async function inkwellForStage(capabilities) {
+    const found = await lookupInkwell(capabilities);
+    if (found.client)
+        return found.client;
+    throw new StageSkipped(found.reason, INKWELL_HINT);
+}
+export async function callInkwell(inkwell, args) {
+    const response = await inkwell.invoke(args);
+    if (!response.ok)
+        throw new RecapError('INKWELL_FAILED', `inkwell ${args.slice(0, 2).join(' ')} failed: ${response.errorMessage ?? 'no reason given'}`);
+    return response.data;
 }
 export class InkwellClient {
     tool;
@@ -121,32 +132,9 @@ export class InkwellClient {
         }
     }
 }
-export class DocsRouter {
-    bita;
-    inkwell;
-    constructor(bita, inkwell) {
-        this.bita = bita;
-        this.inkwell = inkwell;
-    }
-    async invoke(args) {
-        const mapped = this.inkwell ? inkwellArguments(args) : null;
-        if (mapped && this.inkwell)
-            return this.inkwell.invoke(mapped);
-        if (this.bita)
-            return this.bita.invoke(args);
-        return { ok: false, errorCode: 'DEPENDENCY_MISSING', errorMessage: 'bita not found' };
-    }
-}
 export function meetingTarget(meeting) {
     return { databasePath: meeting.bitaDatabasePath, docsRoot: meeting.bitaDocsRoot };
 }
-export async function docsClient(config, target) {
-    const bita = await BitaClient.create(config, target);
-    const inkwell = await findInkwell();
-    if (!bita && !inkwell)
-        return null;
-    return new DocsRouter(bita, inkwell ? new InkwellClient(inkwell) : null);
-}
 export async function requireBita(config, target) {
     const client = await BitaClient.create(config, target);
     if (!client)

package/dist/bita/hook.js

@@ -14,6 +14,8 @@ export function decodeHookEvent(text) {
     const entry = value['entry'];
     if (typeof entry['id'] !== 'number' || !Number.isInteger(entry['id']) || typeof entry['description'] !== 'string')
         throw new Error('the entry has no id or description');
+    const reportsEveryChange = 'previousTitle' in value || 'previousProjectId' in value;
+    const kindChanged = !reportsEveryChange || (optionalString(value['previousKind']) ?? null) !== (optionalString(entry['kind']) ?? null);
     const pageIds = Array.isArray(value['pageIds']) ? value['pageIds'].filter((id) => typeof id === 'number' && Number.isInteger(id)) : undefined;
     return {
         event: value['event'],
@@ -25,9 +27,11 @@ export function decodeHookEvent(text) {
             projectName: optionalString(entry['projectName']),
         },
         previousKind: optionalString(value['previousKind']),
+        previousTitle: optionalString(value['previousTitle']),
         databasePath: optionalString(value['databasePath']),
         docsRoot: optionalString(value['docsRoot']),
         pageIds,
+        kindChanged,
     };
 }
 export function eventSnapshot(event) {
@@ -65,6 +69,8 @@ export function planHook(event, activeEntryId) {
         case 'cancel':
             return { type: 'discard' };
         case 'amend': {
+            if (!event.kindChanged)
+                return { type: 'refresh' };
             const previous = previousMode(event);
             if (mode && previous === undefined) {
                 if (event.entry.running === false)

package/dist/bita/proposals.js

@@ -7,10 +7,10 @@ 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 { entryPages, 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 { callInkwell } from "./client.js";
 import { meetingDay } from "./wrapup.js";
 export const REVEALING_PHRASES = [
     'se acordo',
@@ -190,45 +190,42 @@ export function saveProposals(file, dir) {
         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];
+export async function propose(inkwell, branch, pageId, section, file, reason, entryId) {
+    const args = ['git', '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 data = await callInkwell(inkwell, 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');
+        throw new RecapError('INKWELL_FAILED', 'inkwell git propose did not return the commit sha');
     return sha;
 }
-export function ownPageId(meeting) {
-    return meeting.wrapup?.pageId ?? meeting.bitaEntry?.pageIds[0];
+export function ownPageId(meeting, linked) {
+    return meeting.wrapup?.pageId ?? linked[0]?.pageId;
 }
 export class ProposalGenerator {
     config;
-    bita;
+    inkwell;
     log;
     claude;
-    constructor(config, bita, log, claude) {
+    constructor(config, inkwell, log, claude) {
         this.config = config;
-        this.bita = bita;
+        this.inkwell = inkwell;
         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);
+    candidates(meeting, context, linked) {
+        const own = ownPageId(meeting, linked);
         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)
+        for (const page of linked) {
+            if (known.has(page.pageId) || page.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);
+            pages.push({ ...page, depth: 0 });
+            known.add(page.pageId);
         }
         return pages.filter((page) => page.pageId !== own);
     }
@@ -244,10 +241,11 @@ export class ProposalGenerator {
                 return existing;
             }
             if (existing.proposals.length > 0)
-                await this.bita.invoke(['docs', 'branch', 'drop', branch]).catch(() => null);
+                await this.inkwell.invoke(['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 linked = await entryPages(this.inkwell, entryId);
+        const context = await loadProjectContext(await meetingProject(meeting, this.inkwell, linked), { inkwell: this.inkwell, bita: null });
+        const pages = this.candidates(meeting, context, linked);
         const file = { entryId, branch, generatedAt: isoNow(), branchDropped: false, proposals: [], discarded: [] };
         if (pages.length === 0 || context.docsRoot === null) {
             this.log('proposals: no candidate pages');
@@ -276,7 +274,7 @@ export class ProposalGenerator {
             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);
+                const sha = await propose(this.inkwell, branch, draft.pageId, draft.section, markdownFile, draft.title, entryId);
                 file.proposals.push({
                     n,
                     pageId: draft.pageId,
@@ -323,10 +321,10 @@ export class ProposalGenerator {
 }
 export class ProposalReview {
     dir;
-    bita;
-    constructor(dir, bita) {
+    inkwell;
+    constructor(dir, inkwell) {
         this.dir = dir;
-        this.bita = bita;
+        this.inkwell = inkwell;
     }
     list() {
         return loadProposals(this.dir)?.proposals ?? [];
@@ -341,7 +339,7 @@ export class ProposalReview {
         return found;
     }
     async diff(proposal) {
-        const response = await this.bita.invoke(['docs', 'branch', 'diff', proposal.branch, '--commit', proposal.sha]).catch(() => null);
+        const response = await this.inkwell.invoke(['branch', 'diff', proposal.branch, '--commit', proposal.sha]).catch(() => null);
         return response?.ok ? response.data : null;
     }
     load() {
@@ -361,7 +359,7 @@ export class ProposalReview {
         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);
+            const response = await this.inkwell.invoke(['branch', 'drop', file.branch]).catch(() => null);
             file.branchDropped = response?.ok === true;
         }
         saveProposals(file, this.dir);
@@ -384,10 +382,10 @@ export class ProposalReview {
                     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);
+                proposal.sha = await propose(this.inkwell, 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]);
+            const response = await this.inkwell.invoke(['branch', 'apply', proposal.branch, '--commit', proposal.sha]);
             if (response.ok) {
                 proposal.status = 'accepted';
                 const data = isRecord(response.data) ? response.data : {};
@@ -397,7 +395,7 @@ export class ProposalReview {
                 proposal.status = 'stale';
             }
             else {
-                throw new RecapError('BITA_FAILED', `bita docs branch apply failed: ${response.errorMessage ?? 'no reason given'}`);
+                throw new RecapError('INKWELL_FAILED', `inkwell branch apply failed: ${response.errorMessage ?? 'no reason given'}`);
             }
             proposal.updatedAt = isoNow();
             await this.store(proposal, file);