@kikedealba/recap 0.9.0 → 0.10.0

package/README.md

@@ -51,9 +51,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>`.
@@ -147,7 +149,7 @@ The repository is also a Claude Code plugin marketplace:
 | `/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-ask [question]` | Answers the last question of the meeting being recorded, or the one given, from the inkwell 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.
@@ -160,7 +162,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 +193,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 +204,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 +251,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/commands/recap-proposals.md

@@ -5,8 +5,10 @@ allowed-tools: Bash(recap proposals:*), Bash(recap show:*), Read, Write
 ---
 
 Al cerrar una reunión ligada a bita, recap deja los cambios explícitos a
-páginas existentes como propuestas en la rama `proposal/meeting-<entrada>` de
-los docs. Nada llega a `main` sin aceptarse.
+páginas existentes de inkwell como propuestas en la rama
+`proposal/meeting-<entrada>` de sus docs. Nada llega a `main` sin aceptarse.
+Aceptar o rechazar necesita inkwell instalado (`npm i -g @kikedealba/inkwell &&
+inkwell setup`).
 
 1. La reunión es `$ARGUMENTS`, o `last` si viene vacío. Lista sus propuestas:
 

package/commands/recap-stop.md

@@ -1,7 +1,7 @@
 ---
 description: Termina la grabación y deja la reunión documentada
 argument-hint: [--no-wait para no esperar el resultado]
-allowed-tools: Bash(recap stop:*), Bash(recap status:*), Bash(recap wait:*), Bash(recap show:*), Bash(bita stop:*), Bash(bita ls:*), Bash(bita amend:*), Bash(bita docs page move:*), Bash(bita backlog edit:*), Bash(inkwell page move:*), Bash(inkwell backlog edit:*)
+allowed-tools: Bash(recap stop:*), Bash(recap status:*), Bash(recap wait:*), Bash(recap show:*), Bash(bita stop:*), Bash(bita ls:*), Bash(bita amend:*), Bash(inkwell page move:*), Bash(inkwell backlog edit:*)
 ---
 
 Detén la grabación activa y deja la reunión documentada.
@@ -12,23 +12,28 @@ Grabación actual:
 
 Si no hay grabación activa (`NOT_RECORDING`), dilo en una línea y termina.
 
-## Si la grabación sigue a un contador de bita
+## Si la grabación sigue a un cronómetro de bita
 
-Cuando `data.active.bitaEntryId` trae un id, para **el contador**, no recap. Sin
-`--did` y sin escribir la página:
+Cuando `data.active.bitaEntryId` trae un id, para **el cronómetro**, no recap,
+sin escribir la página:
 
 ```
 bita stop <id> --json
 recap wait --bita-entry <id> --json
 ```
 
-El hook de bita detiene la grabación y recap hace lo demás:
+El evento de bita detiene la grabación y recap hace lo demás:
 
 - transcribe y escribe la minuta;
-- le pone al contador un título real y, si no tenía, su proyecto;
-- crea o completa la página;
-- pasa los pendientes al backlog;
-- deja la minuta en la sección «Reunión» de la entrada.
+- le pone al cronómetro un título real y, si no tenía, su proyecto (`bita amend`);
+- crea o completa la página en inkwell;
+- pasa los pendientes y hallazgos al backlog de inkwell;
+- deja la minuta en la sección «Reunión» de la nota de la entrada (`inkwell note save`).
+
+Sin inkwell, las etapas `proposals` y `wrapup` quedan en `skipped` con su
+motivo (`stages.wrapup.reason`) y la minuta se queda en la carpeta de la
+reunión; sugiere `npm i -g @kikedealba/inkwell && inkwell setup` y después
+`recap process <id> --from proposals`.
 
 `recap wait` tarda de uno a cinco minutos en una reunión de una hora: córrelo con
 un timeout amplio (15 min). Si después de un minuto `recap status` sigue
@@ -46,9 +51,9 @@ recap wait --json
 Con el resultado de `recap wait` responde:
 
 - título y duración;
-- con bita: el proyecto, la página (`wrapup.pageId`) y cuántos pendientes y
-  hallazgos quedaron en el backlog;
-- sin bita: los **Acuerdos** y **Pendientes** de la minuta, tal cual.
+- con bita e inkwell: el proyecto, la página (`wrapup.pageId`) y cuántos
+  pendientes y hallazgos quedaron en el backlog;
+- sin bita o sin inkwell: los **Acuerdos** y **Pendientes** de la minuta, tal cual.
 
 Si una etapa falló, muestra su error y sugiere `recap process <id>`: retoma
 desde la etapa que falló.
@@ -58,12 +63,11 @@ y, con la respuesta:
 
 ```
 bita amend <entryId> --project <X>
-bita docs page move <pageId> --project <X>
-bita backlog edit <CLAVE> --project <X>      # una por cada valor de wrapup.backlogKeys
+inkwell page move <pageId> --project <X>
+inkwell backlog edit <CLAVE> --project <X>   # una por cada valor de wrapup.backlogKeys
 ```
 
-Si inkwell está instalado, usa `inkwell page move <pageId> --project <X>` e
-`inkwell backlog edit <CLAVE> --project <X>` en lugar de los dos últimos.
+El tiempo de la reunión se vuelca a Jira después con tally, no desde aquí.
 
 Con `--no-wait` en `$ARGUMENTS`, solo para y responde en una línea que el
 procesamiento sigue en segundo plano.

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);

package/dist/bita/wrapup.js

@@ -3,11 +3,12 @@ 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 { fold, formatDuration, prefix, replaceAll, 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";
+import { INKWELL_CAPABILITIES, INKWELL_HINT, StageSkipped, callBita, callInkwell, lookupInkwell, meetingTarget, requireBita } from "./client.js";
+import { entryPages } from "../live/context.js";
 export const FORBIDDEN_SECTIONS = ['pendiente', 'proximos pasos', 'hallazgo', 'preguntas abiertas', 'lo que falta'];
 export function stripForbiddenSections(markdown) {
     const kept = [];
@@ -127,20 +128,30 @@ export function noteBody(summary, meeting, dir) {
     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) {
+export async function saveMinutes(meeting, dir, notes, log) {
     const entryId = meeting.bitaEntryId;
     if (entryId === undefined)
-        return;
-    const bita = client ?? (await requireBita(config, meetingTarget(meeting)));
+        return { saved: false, reason: 'the meeting has no bita entry' };
     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');
+        throw new RecapError('NO_SUMMARY', `"${meeting.title}" has no summary to save in the entry note`);
+    const note = path.join(dir, 'entry-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)}`);
+    let client = notes;
+    let reason = 'no inkwell with docs.entry-notes was given';
+    if (client === undefined) {
+        const found = await lookupInkwell(INKWELL_CAPABILITIES.notes);
+        client = found.client;
+        if (found.reason !== undefined)
+            reason = found.reason;
+    }
+    if (!client) {
+        log?.(`minutes: not saved in the note of entry #${entryId}, ${reason}; they stay in ${dir} (${INKWELL_HINT})`);
+        return { saved: false, reason };
     }
+    await callInkwell(client, ['note', 'save', String(entryId), '--section', NOTE_SECTION, '--md', note]);
+    log?.(`minutes: saved in the note of entry #${entryId}`);
+    return { saved: true };
 }
 export function meetingDay(meeting) {
     return dayString(parseDate(meeting.startedAt) ?? parseDate(meeting.createdAt) ?? new Date());
@@ -155,7 +166,7 @@ export function encodeWrapupPlan(plan) {
     });
 }
 async function pageText(docs, pageId) {
-    const page = await callBita(docs, ['docs', 'page', 'show', String(pageId)]);
+    const page = await callInkwell(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;
@@ -182,8 +193,16 @@ export async function runWrapup(meeting, dir, config, dependencies) {
     const entryId = meeting.bitaEntryId;
     if (entryId === undefined)
         return;
+    let docs = dependencies?.docs;
+    if (!docs) {
+        const found = await lookupInkwell(INKWELL_CAPABILITIES.wrapup);
+        if (!found.client) {
+            await saveMinutes(meeting, dir, undefined, dependencies?.log).catch((error) => dependencies?.log?.(`minutes: ${String(error)}`));
+            throw new StageSkipped(found.reason, INKWELL_HINT);
+        }
+        docs = found.client;
+    }
     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 ?? {}) };
@@ -192,7 +211,7 @@ export async function runWrapup(meeting, dir, config, dependencies) {
         .filter(isRecord)
         .filter((project) => project['active'] !== false)
         .flatMap((project) => (typeof project['name'] === 'string' ? [project['name']] : []));
-    const existingPageId = wrapup.pageId ?? snapshot.pageIds[0];
+    const existingPageId = wrapup.pageId ?? (await entryPages(docs, entryId, true))[0]?.pageId;
     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));
@@ -209,23 +228,23 @@ export async function runWrapup(meeting, dir, config, dependencies) {
         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');
+    const pageFile = path.join(dir, 'wrapup-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)}`]);
+        await callInkwell(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)];
+        const args = ['page', 'new', plan.pageTitle, '--from-entry', String(entryId)];
         if (wrapup.project)
             args.push('--project', wrapup.project);
-        const created = await callBita(docs, args);
+        const created = await callInkwell(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]);
+            throw new RecapError('INKWELL_FAILED', 'inkwell page new did not return the page id');
+        await callInkwell(docs, ['page', 'write', String(pageId), '--md', pageFile]);
         wrapup.pageId = pageId;
         wrapup.pageCreated = true;
     }
@@ -237,17 +256,17 @@ export async function runWrapup(meeting, dir, config, dependencies) {
             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');
+            const bodyFile = path.join(dir, 'wrapup-backlog-item.md');
             writeAtomic(bodyFile, item.body);
             args.push('--md', bodyFile);
         }
-        const added = await callBita(docs, args);
+        const added = await callInkwell(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);
+    await saveMinutes(meeting, dir, dependencies?.notes, dependencies?.log);
     updateMeeting(dir, (current) => {
         current.wrapup = { ...wrapup, backlogKeys: { ...wrapup.backlogKeys } };
     });

package/dist/capture/capture.js

@@ -6,7 +6,7 @@ import { exists, readText } from "../core/fsutil.js";
 import { isRecord } from "../core/json.js";
 import { home } from "../core/paths.js";
 import { exec, spawnDetached } from "../core/proc.js";
-import { selfCommand } from "../core/self.js";
+import { selfCommand, stableCommand } from "../core/self.js";
 import { trimmed } from "../core/text.js";
 import { RecapError } from "../errors.js";
 import { parseEnvelope } from '@kikedealba/kit/envelope';
@@ -35,16 +35,24 @@ export function captureUnavailable() {
         : 'Recording is only available on macOS for now. Record with any app and process the file with `recap import <file>`.';
     return new RecapError('CAPTURE_UNAVAILABLE', 'The recorder (recap-capture) is not available on this machine', { hint });
 }
-export function liveWorkerCommand() {
-    return JSON.stringify([...selfCommand(), 'live-worker']);
+export async function liveWorkerCommand(ctx) {
+    return [...(await stableCommand(ctx)), 'live-worker'];
+}
+export function workerPath(command, env = process.env) {
+    if (command[0] === selfCommand()[0])
+        return null;
+    return [path.dirname(process.execPath), ...(env['PATH'] ?? '').split(path.delimiter)].filter((dir, index, all) => dir.length > 0 && all.indexOf(dir) === index).join(path.delimiter);
 }
 export function hasCaptureBinary(app) {
     return exists(path.join(app, 'Contents', 'MacOS', 'recap-capture'));
 }
-export function launchArguments(app, dir, log, modern = hasCaptureBinary(app)) {
+export async function launchArguments(app, dir, log, modern = hasCaptureBinary(app), ctx) {
     if (!modern)
         return ['-g', '-n', '-a', app, '--stdout', log, '--stderr', log, '--args', 'record', dir];
-    return ['-g', '-n', '-a', app, '--env', `RECAP_LIVE_WORKER=${liveWorkerCommand()}`, '--stdout', log, '--stderr', log, '--args', 'capture', 'record', dir];
+    const worker = await liveWorkerCommand(ctx);
+    const searchPath = workerPath(worker, ctx?.env);
+    const env = ['--env', `RECAP_LIVE_WORKER=${JSON.stringify(worker)}`, ...(searchPath === null ? [] : ['--env', `PATH=${searchPath}`])];
+    return ['-g', '-n', '-a', app, ...env, '--stdout', log, '--stderr', log, '--args', 'capture', 'record', dir];
 }
 export async function launchRecorder(dir) {
     const launcher = await findCapture();
@@ -52,12 +60,12 @@ export async function launchRecorder(dir) {
         throw captureUnavailable();
     const log = path.join(dir, 'recorder.log');
     if (launcher.kind === 'app') {
-        const result = await exec('/usr/bin/open', launchArguments(launcher.app, dir, log));
+        const result = await exec('/usr/bin/open', await launchArguments(launcher.app, dir, log));
         if (result.status !== 0)
             throw new RecapError('LAUNCH_FAILED', `Cannot launch ${path.basename(launcher.app)}: ${trimmed(result.stderr)}`);
         return;
     }
-    spawnDetached(launcher.binary, ['record', dir, '--live-worker', liveWorkerCommand()], log);
+    spawnDetached(launcher.binary, ['record', dir, '--live-worker', JSON.stringify(await liveWorkerCommand())], log);
 }
 function readReport(text) {
     if (text === null)

package/dist/cli/commands/ask.js

@@ -5,10 +5,9 @@ import { MeetingStore, loadMeeting, resolveTarget } from "../../core/meeting.js"
 import { signalNumber, signalTree } from "../../core/proc.js";
 import { trimmed } from "../../core/text.js";
 import { RecapError, asRecapError, usageError } from "../../errors.js";
-import { BitaClient, docsClient, meetingTarget } from "../../bita/client.js";
 import { runAsk } from "../../live/ask.js";
 import { isValidAskId, makeAskId, performAsk, removeBoard } from "../../live/asking.js";
-import { loadProjectContext, meetingProject, meetingProjectName } from "../../live/context.js";
+import { contextSources, loadProjectContext, meetingContext, meetingProjectName } from "../../live/context.js";
 import { jsonLine } from "../../live/files.js";
 import { encodeAnswer, encodeAskEvent } from "../../live/stream.js";
 import { parseArgs } from "../args.js";
@@ -77,8 +76,7 @@ async function answer(args, emit) {
     let childPid = null;
     installCleanup(found.dir, id, () => childPid);
     return performAsk({ dir: found.dir, id, question, auto: args.has('auto'), now, questionMs, channel }, async () => {
-        const docs = await docsClient(config, meetingTarget(found.meeting));
-        const context = await loadProjectContext(await meetingProject(found.meeting, docs), found.meeting.bitaDocsRoot, docs);
+        const context = await meetingContext(found.meeting, config);
         return runAsk(config, { meeting: found.meeting, dir: found.dir, question, windowSeconds: args.int('window') ?? 180, now, auto: args.has('auto'), questionMs, channel, askId: id }, context, emit, (pid) => {
             childPid = pid;
         });
@@ -105,9 +103,9 @@ export async function askCommand(argv) {
         if (args.has('sources')) {
             const config = loadConfig();
             const found = args.has('active') || args.value('meeting') !== undefined || args.value('bita-entry') !== undefined ? target(args, config) : null;
-            const docs = found ? await docsClient(config, meetingTarget(found.meeting)) : await docsClient(config, {});
+            const sources = await contextSources(config, found?.meeting ?? null);
             const name = args.value('project') ?? (found ? meetingProjectName(found.meeting) : null);
-            const context = await loadProjectContext(name, found?.meeting.bitaDocsRoot, docs ?? (await BitaClient.create(config, {})));
+            const context = await loadProjectContext(name, sources);
             const lines = [`Project: ${context.project ?? '(none)'}`, `Docs: ${context.docsRoot ?? '(unknown)'}`, ...context.repos.map((repo) => `Repo: ${repo.slug} ${repo.path}${repo.exists ? '' : ' (missing)'}`)];
             return { data: { project: context.project ?? undefined, docsRoot: context.docsRoot ?? undefined, repos: context.repos }, text: lines.join('\n') };
         }

package/dist/cli/commands/hook.js

@@ -62,6 +62,21 @@ export async function handleHookEvent(event) {
                 log(`discarded ${record.dir}`);
                 break;
             }
+            case 'refresh': {
+                const found = new MeetingStore(loadConfig()).find(event.entry.id);
+                if (!found) {
+                    log(`nothing to do: no meeting for entry #${event.entry.id}`);
+                    break;
+                }
+                updateMeeting(found.dir, (meeting) => {
+                    meeting.bitaEntry = { ...eventSnapshot(event), pageIds: meeting.bitaEntry?.pageIds ?? [] };
+                    const renamed = event.previousTitle !== undefined && event.previousTitle !== event.entry.description;
+                    if (renamed && event.entry.description.trim().length > 0)
+                        meeting.title = event.entry.description;
+                });
+                log(`updated ${found.dir}`);
+                break;
+            }
             case 'ignore':
                 log(`nothing to do: ${action.reason}`);
                 break;

package/dist/cli/commands/proposals.js

@@ -3,7 +3,7 @@ import { expandTilde } from "../../core/paths.js";
 import { readText } from "../../core/fsutil.js";
 import { MeetingStore, resolveTarget } from "../../core/meeting.js";
 import { RecapError, usageError } from "../../errors.js";
-import { docsClient, meetingTarget } from "../../bita/client.js";
+import { INKWELL_CAPABILITIES, INKWELL_HINT, findInkwell, requireInkwell } from "../../bita/client.js";
 import { ProposalReview, loadProposals, proposalJson } from "../../bita/proposals.js";
 import { parseArgs } from "../args.js";
 import { output } from "../output.js";
@@ -21,13 +21,11 @@ function number(args) {
         throw new RecapError('PROPOSAL_REQUIRED', 'Pass the proposal number');
     return Number(raw);
 }
-const noBita = { invoke: async () => ({ ok: false, errorCode: 'DEPENDENCY_MISSING', errorMessage: 'bita not found' }) };
+const noInkwell = { invoke: async () => ({ ok: false, errorCode: 'DEPENDENCY_MISSING', errorMessage: `inkwell not found (${INKWELL_HINT})` }) };
 async function review(args, config, required) {
     const found = meeting(args, config);
-    const docs = await docsClient(config, meetingTarget(found.meeting));
-    if (!docs && required)
-        throw new RecapError('DEPENDENCY_MISSING', 'bita not found. Install it with `npm install -g @kikedealba/bita`');
-    return new ProposalReview(found.dir, docs ?? noBita);
+    const inkwell = required ? await requireInkwell(INKWELL_CAPABILITIES.proposals, 'Reviewing proposals') : await findInkwell(INKWELL_CAPABILITIES.proposals);
+    return new ProposalReview(found.dir, inkwell ?? noInkwell);
 }
 export async function proposalsCommand(argv) {
     const [sub, ...rest] = argv;

package/dist/cli/commands/query.js

@@ -10,6 +10,7 @@ import { processInBackground } from "../../core/self.js";
 import { formatDuration, padEnd } from "../../core/text.js";
 import { RecapError, usageError } from "../../errors.js";
 import { saveMinutes } from "../../bita/wrapup.js";
+import { INKWELL_HINT } from "../../bita/client.js";
 import { Pipeline } from "../../pipeline/pipeline.js";
 import { STAGES, allStagesSatisfied, isStage } from "../../pipeline/stages.js";
 import { saveSummary, summaryPromptFor } from "../../pipeline/summary.js";
@@ -106,14 +107,17 @@ export async function saveSummaryCommand(argv) {
             throw new RecapError('FILE_UNREADABLE', `Cannot read ${file}: ${error.message}`);
         }
         saveSummary(body, meeting, dir);
-        if (meeting.bitaEntryId !== undefined)
-            await saveMinutes(meeting, dir, config);
+        let minutes = null;
+        if (meeting.bitaEntryId !== undefined) {
+            const result = await saveMinutes(meeting, dir);
+            minutes = result.saved ? `Minutes saved in the note of entry #${meeting.bitaEntryId}` : `Minutes not saved in the entry note: ${result.reason ?? 'no reason given'} (${INKWELL_HINT})`;
+        }
         const updated = updateMeeting(dir, (current) => {
             current.stages['summarize'] = { status: 'done', updatedAt: isoNow() };
             if (allStagesSatisfied({ ...meeting, stages: current.stages }))
                 current.status = 'processed';
         });
-        return { data: meetingRecord(updated, dir), text: path.join(dir, 'summary.md') };
+        return { data: meetingRecord(updated, dir), text: minutes === null ? path.join(dir, 'summary.md') : `${path.join(dir, 'summary.md')}\n${minutes}` };
     });
 }
 export function failedStage(meeting) {
@@ -131,6 +135,10 @@ export function describeWait(meeting, dir) {
     const failed = failedStage(meeting);
     if (failed)
         lines.push(`Failed at ${failed[0]}: ${failed[1].error ?? 'no reason given'}`);
+    for (const [stage, state] of Object.entries(meeting.stages)) {
+        if (state.status === 'skipped' && state.reason !== undefined)
+            lines.push(`Skipped ${stage}: ${state.reason}${state.hint !== undefined ? ` (${state.hint})` : ''}`);
+    }
     const wrapup = meeting.wrapup;
     if (wrapup) {
         lines.push(`Title   : ${wrapup.title ?? meeting.title}`);

package/dist/core/self.js

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
-import { PACKAGE_ROOT } from "../version.js";
+import { stableBin } from '@kikedealba/kit/registry';
+import { PACKAGE_ROOT, VERSION } from "../version.js";
 import { spawnDetached } from "./proc.js";
 export function binEntry() {
     const built = path.join(PACKAGE_ROOT, 'dist', 'bin', 'recap.js');
@@ -9,6 +10,9 @@ export function binEntry() {
 export function selfCommand() {
     return [process.execPath, binEntry()];
 }
+export function stableCommand(ctx) {
+    return stableBin('recap', VERSION, selfCommand(), ctx);
+}
 export function spawnSelf(args, logPath) {
     const [node, entry] = selfCommand();
     return spawnDetached(node ?? process.execPath, [entry ?? binEntry(), ...args], logPath);

package/dist/live/context.js

@@ -2,6 +2,8 @@ import path from 'node:path';
 import { isDirectory } from "../core/fsutil.js";
 import { isRecord } from "../core/json.js";
 import { trimmed } from "../core/text.js";
+import { BitaClient, INKWELL_CAPABILITIES, findInkwell, meetingTarget } from "../bita/client.js";
+import { RecapError } from "../errors.js";
 export function emptyContext(overrides = {}) {
     return { project: null, docsRoot: null, pages: [], repos: [], ...overrides };
 }
@@ -24,6 +26,7 @@ export function parsePages(data) {
                 title,
                 relPath: typeof item['relPath'] === 'string' ? item['relPath'] : '',
                 depth: typeof item['depth'] === 'number' && Number.isInteger(item['depth']) ? item['depth'] : depth,
+                ...(typeof item['projectName'] === 'string' ? { projectName: item['projectName'] } : {}),
             });
             if (Array.isArray(item['children']))
                 walk(item['children'], depth + 1);
@@ -52,39 +55,63 @@ export function parseRepos(data) {
 function metaRoot(meta) {
     return typeof meta?.['root'] === 'string' ? meta['root'] : null;
 }
-export async function loadProjectContext(project, docsRoot, bita) {
-    const context = emptyContext({ project: project && trimmed(project).length > 0 ? project : null, docsRoot: docsRoot ?? null });
-    if (!bita)
-        return context;
+export async function loadProjectContext(project, sources) {
+    const context = emptyContext({ project: project && trimmed(project).length > 0 ? project : null });
+    const { inkwell, bita } = sources;
     if (context.project) {
-        const pages = await bita.invoke(['docs', 'page', 'ls', '--project', context.project]).catch(() => null);
-        if (pages?.ok) {
-            context.pages = parsePages(pages.data);
-            context.docsRoot ??= metaRoot(pages.meta);
+        if (inkwell) {
+            const pages = await inkwell.invoke(['page', 'ls', '--project', context.project]).catch(() => null);
+            if (pages?.ok) {
+                context.pages = parsePages(pages.data);
+                context.docsRoot = metaRoot(pages.meta);
+            }
+        }
+        if (bita) {
+            const repos = await bita.invoke(['project', 'repo', 'ls', '--project', context.project]).catch(() => null);
+            if (repos?.ok)
+                context.repos = parseRepos(repos.data);
         }
-        const repos = await bita.invoke(['project', 'repo', 'ls', '--project', context.project]).catch(() => null);
-        if (repos?.ok)
-            context.repos = parseRepos(repos.data);
     }
-    if (context.docsRoot === null) {
-        const tree = await bita.invoke(['docs', 'tree']).catch(() => null);
+    if (context.docsRoot === null && inkwell) {
+        const tree = await inkwell.invoke(['tree']).catch(() => null);
         if (tree?.ok)
             context.docsRoot = metaRoot(tree.meta);
     }
     return context;
 }
+export async function entryPages(inkwell, entryId, strict = false) {
+    if (!inkwell || entryId === undefined)
+        return [];
+    const response = await inkwell.invoke(['page', 'ls', '--entry', String(entryId)]).catch(() => null);
+    if (response?.ok)
+        return parsePages(response.data);
+    if (strict)
+        throw new RecapError('INKWELL_FAILED', `inkwell page ls --entry ${entryId} failed: ${response?.errorMessage ?? 'no reason given'}`);
+    return [];
+}
 export function meetingProjectName(meeting) {
     return meeting.bitaEntry?.projectName ?? meeting.wrapup?.project ?? null;
 }
-export async function meetingProject(meeting, bita) {
+export async function meetingProject(meeting, inkwell, linked) {
     const name = meetingProjectName(meeting);
     if (name && trimmed(name).length > 0)
         return name;
-    const pageId = meeting.wrapup?.pageId ?? meeting.bitaEntry?.pageIds[0];
-    if (!bita || pageId === undefined)
-        return null;
-    const response = await bita.invoke(['docs', 'page', 'show', String(pageId), '--no-markdown']).catch(() => null);
-    if (!response?.ok || !isRecord(response.data))
+    if (!inkwell)
         return null;
-    return typeof response.data['projectName'] === 'string' ? response.data['projectName'] : null;
+    const pageId = meeting.wrapup?.pageId;
+    if (pageId !== undefined) {
+        const response = await inkwell.invoke(['page', 'show', String(pageId), '--no-markdown']).catch(() => null);
+        if (response?.ok && isRecord(response.data) && typeof response.data['projectName'] === 'string')
+            return response.data['projectName'];
+    }
+    const pages = linked ?? (await entryPages(inkwell, meeting.bitaEntryId));
+    return pages.find((page) => page.projectName !== undefined)?.projectName ?? null;
+}
+export async function contextSources(config, meeting) {
+    const [inkwell, bita] = await Promise.all([findInkwell(INKWELL_CAPABILITIES.pages), BitaClient.create(config, meeting ? meetingTarget(meeting) : {})]);
+    return { inkwell, bita };
+}
+export async function meetingContext(meeting, config) {
+    const sources = await contextSources(config, meeting);
+    return loadProjectContext(await meetingProject(meeting, sources.inkwell), sources);
 }

package/dist/live/worker.js

@@ -10,12 +10,11 @@ import { selfCommand } from "../core/self.js";
 import { suffix, trimmed } from "../core/text.js";
 import { requireTool } from "../core/tools.js";
 import { RecapError, errorMessage } from "../errors.js";
-import { docsClient, meetingTarget } from "../bita/client.js";
 import { resultText, runClaude } from "../pipeline/claude.js";
 import { whisperArguments } from "../pipeline/pipeline.js";
 import { parseWhisper } from "../pipeline/transcript.js";
 import { pruneBoard } from "./asking.js";
-import { loadProjectContext, meetingProject } from "./context.js";
+import { meetingContext } from "./context.js";
 import { AutoAskProcess, AutoAskQueue, QuestionDetector } from "./detector.js";
 import { appendLines, liveFiles, readLines } from "./files.js";
 import { LiveMerger } from "./merger.js";
@@ -177,10 +176,7 @@ export function makeLiveDetector(dir, meeting, config, log) {
     const runner = new AutoAskProcess(dir, selfCommand());
     const asks = new AutoAskQueue({ dir, concurrency: settings.autoAskConcurrency, run: (job) => runner.run(job), cancelRunning: () => runner.cancel(), log });
     return new QuestionDetector(dir, meeting, settings.autoAskMinSeconds, {
-        context: async () => {
-            const docs = await docsClient(config, meetingTarget(meeting));
-            return loadProjectContext(await meetingProject(meeting, docs), meeting.bitaDocsRoot, docs);
-        },
+        context: () => meetingContext(meeting, config),
         complete: async (prompt) => resultText(await runClaude({ prompt, cwd: dir, config, tools: [], addDirs: [], model: settings.autoAskModel, restrictTools: [] })),
         enqueue: (question, origin) => {
             asks.enqueue(question, origin);

package/dist/pipeline/pipeline.js

@@ -11,7 +11,7 @@ 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 { INKWELL_CAPABILITIES, StageSkipped, inkwellForStage } from "../bita/client.js";
 import { ProposalGenerator } from "../bita/proposals.js";
 import { runWrapup } from "../bita/wrapup.js";
 import { runSummaryClaude } from "./claude.js";
@@ -78,9 +78,9 @@ export class Pipeline {
     recording(meeting) {
         return recordingPath(this.dir, meeting.mode);
     }
-    setStage(stage, status, error, extra) {
+    setStage(stage, status, error, extra, details = {}) {
         return updateMeeting(this.dir, (current) => {
-            current.stages[stage] = { status, updatedAt: isoNow(), ...(error !== undefined ? { error } : {}) };
+            current.stages[stage] = { status, updatedAt: isoNow(), ...(error !== undefined ? { error } : {}), ...details };
             extra?.(current);
         });
     }
@@ -131,6 +131,11 @@ export class Pipeline {
                 }
                 catch (error) {
                     const message = error instanceof RecapError ? error.message : errorMessage(error);
+                    if (error instanceof StageSkipped) {
+                        meeting = this.setStage(stage, 'skipped', undefined, undefined, { reason: message, ...(error.hint !== undefined ? { hint: error.hint } : {}) });
+                        this.log(`${stage}: skipped, ${message}${error.hint !== undefined ? ` (${error.hint})` : ''}`);
+                        continue;
+                    }
                     if (stageIsOptional(stage)) {
                         meeting = this.setStage(stage, 'failed', message);
                         this.log(`${stage}: failed, continuing: ${message}`);
@@ -165,7 +170,7 @@ export class Pipeline {
             case 'proposals':
                 return this.proposals(meeting);
             case 'wrapup':
-                return runWrapup(meeting, this.dir, this.config);
+                return runWrapup(meeting, this.dir, this.config, { log: this.log });
         }
     }
     async extractAudio(meeting) {
@@ -268,8 +273,7 @@ export class Pipeline {
         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);
+        const inkwell = await inkwellForStage(INKWELL_CAPABILITIES.proposals);
+        await new ProposalGenerator(this.config, inkwell, this.log).run(meeting, this.dir);
     }
 }

package/dist/setup/integration.js

@@ -6,7 +6,7 @@ import { bitaCommand } from "../bita/client.js";
 import { readText } from "../core/fsutil.js";
 import { isRecord } from "../core/json.js";
 import { home } from "../core/paths.js";
-import { selfCommand } from "../core/self.js";
+import { stableCommand } from "../core/self.js";
 import { HOOK_EVENTS, MEETING_KINDS } from "../bita/hook.js";
 import { PACKAGE_ROOT, VERSION } from "../version.js";
 export const INSTALL_HINT = 'npm install -g @kikedealba/recap && recap setup';
@@ -14,28 +14,32 @@ export const BASE_CAPABILITIES = ['meeting.process', 'meeting.import', 'meeting.
 export function capabilities(captureAvailable) {
     return captureAvailable ? ['meeting.record', ...BASE_CAPABILITIES] : [...BASE_CAPABILITIES];
 }
-export function bitaSubscription() {
+function subscription(bin) {
     return {
         tool: 'bita',
         events: [...HOOK_EVENTS],
         filter: { kind: Object.keys(MEETING_KINDS).sort() },
-        command: [...selfCommand(), 'bita-hook'],
+        command: [...bin, 'bita-hook'],
     };
 }
-export function manifest(captureAvailable, subscribe = captureAvailable) {
+export async function bitaSubscription(ctx) {
+    return subscription(await stableCommand(ctx));
+}
+export async function manifest(captureAvailable, subscribe = captureAvailable, ctx) {
+    const bin = await stableCommand(ctx);
     return defineManifest({
         name: 'recap',
         version: VERSION,
         description: 'Meeting recorder: local transcription, minutes, live answers',
-        bin: selfCommand(),
+        bin,
         capabilities: capabilities(captureAvailable),
-        subscribes: subscribe ? [bitaSubscription()] : [],
+        subscribes: subscribe ? [subscription(bin)] : [],
         homepage: 'https://github.com/KikeDeAlba/recap',
         install: INSTALL_HINT,
     });
 }
-export function register(captureAvailable, subscribe = captureAvailable) {
-    return registerTool(manifest(captureAvailable, subscribe));
+export async function register(captureAvailable, subscribe = captureAvailable) {
+    return registerTool(await manifest(captureAvailable, subscribe));
 }
 export async function bitaLinked(config) {
     const own = await readManifest('recap').catch(() => null);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kikedealba/recap",
-  "version": "0.9.0",
-  "description": "Meeting recorder CLI: local transcription with whisper.cpp, minutes written by Claude Code, live answers and bita integration.",
+  "version": "0.10.0",
+  "description": "Meeting recorder CLI: local transcription with whisper.cpp, minutes written by Claude Code, live answers, bita timers and inkwell docs.",
   "license": "MIT",
   "author": "Jesus Enrique De Alba Gaytan",
   "homepage": "https://github.com/KikeDeAlba/recap#readme",
@@ -50,7 +50,7 @@
     "recap": "node src/bin/recap.ts"
   },
   "dependencies": {
-    "@kikedealba/kit": "^0.1.1"
+    "@kikedealba/kit": "^0.2.0"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/skills/recap/SKILL.md

@@ -74,37 +74,57 @@ Errores típicos y qué hacer:
 | `DEPENDENCY_MISSING`, `MODEL_MISSING` | Falta ffmpeg, whisper-cli, claude o el modelo | `recap setup --install-deps` |
 | `CAPTURE_UNAVAILABLE` | No hay grabador en este equipo (Windows, Linux, o falta Recap.app) | Graba con otra app y usa `recap import <archivo>`; en mac, `recap setup` |
 
-## Con bita
+## Con bita e inkwell
+
+Cada herramienta hace una sola cosa:
+
+- **bita** lleva el tiempo (cronómetros). recap solo le pide `projects`,
+  `project repo ls`, `entries get` y `amend` (título y proyecto).
+- **inkwell** guarda la documentación: páginas, backlog, propuestas, historial
+  y la nota de cada entrada de bita (`inkwell note …`).
+- **tally** vuelca a Jira el tiempo de bita (`tally summary --pending`); recap
+  no toca Jira.
 
 Si `recap status --json` trae `data.bitaLinked: true` (recap está suscrito a
 los eventos de bita desde `recap setup`), **arranca y para las reuniones desde
 bita**, no desde recap: así el tiempo queda medido y la grabación sigue al
-contador.
+cronómetro.
 
 ```sh
 bita start "<título>" --kind remote-meeting
 bita start "<título>" --kind in-person-meeting
-bita stop <id> --json                 # sin --did y sin escribir la página
+bita stop <id> --json                 # sin escribir la página: eso lo hace recap
 recap wait --bita-entry <id> --json   # espera a que todo quede listo
 ```
 
+Cambiar el título o el proyecto del cronómetro mientras se graba (`bita amend`)
+no corta ni duplica la grabación: recap solo actualiza los datos de la reunión.
+Solo un cambio de tipo (`--kind`) que cruce la línea de reunión la arranca o la
+detiene.
+
 Al parar, recap hace todo lo demás sin que nadie lo pida:
 
 - transcribe y escribe la minuta;
-- le pone al contador un título real, si el que tenía era genérico;
-- le asigna el proyecto si no tenía y la conversación lo deja claro;
-- crea la página en ese proyecto, o agrega una sección a la que ya tenía, y la escribe;
-- pasa pendientes y preguntas abiertas al backlog;
-- deja la minuta en la sección «Reunión» de la entrada.
+- le pone al cronómetro un título real, si el que tenía era genérico (`bita amend`);
+- le asigna el proyecto si no tenía y la conversación lo deja claro (`bita amend`);
+- crea la página en inkwell, ligada a la entrada (`inkwell page new --from-entry`),
+  o agrega una sección a la que ya tenía (`inkwell page ls --entry`), y la escribe;
+- pasa pendientes y hallazgos al backlog de inkwell (`inkwell backlog add`);
+- deja la minuta en la sección «Reunión» de la nota de la entrada
+  (`inkwell note save <entrada> --section Reunión --md …`).
 
 El resultado está en `data.wrapup` de `recap wait`. Si `wrapup.projectResolved`
-es false, pregunta el proyecto y aplícalo con `bita amend`, y mueve la página y
-el backlog con inkwell si está instalado (`inkwell page move --project`,
-`inkwell backlog edit --project`) o, si no, con `bita docs page move --project`
-y `bita backlog edit --project`.
-
-Las páginas, las propuestas y el backlog se escriben con inkwell cuando está
-instalado y ya migró los documentos de bita; si no, con `bita docs`/`bita backlog`.
+es false, pregunta el proyecto, aplícalo con `bita amend <id> --project …` y
+mueve la página y el backlog con `inkwell page move --project` e
+`inkwell backlog edit --project`.
+
+**Sin inkwell** la reunión igual queda procesada: las etapas `proposals` y
+`wrapup` quedan en `skipped` con el motivo en `stages.<etapa>.reason` y la pista
+`npm i -g @kikedealba/inkwell && inkwell setup`; la minuta se queda en
+`summary.md` de la carpeta de la reunión. Si inkwell es viejo y no tiene la
+capacidad `docs.entry-notes`, se escribe la página y el backlog pero la minuta
+no pasa a la nota (queda anotado en `process.log`). Después de instalar o
+actualizar inkwell, `recap process <id> --from proposals` lo completa.
 
 ## En vivo
 
@@ -113,8 +133,9 @@ Mientras se graba, recap transcribe por tramos de 5 a 20 s en
 Sala y `system` Remotos). Es aproximada: la transcripción de después del stop
 (`transcript.md`) sigue siendo la fuente de verdad.
 
-Para responder una pregunta que hicieron en la reunión, con las páginas de bita
-y los repos del proyecto (`bita project repo ls`):
+Para responder una pregunta que hicieron en la reunión, con las páginas de
+inkwell y los repos del proyecto (`bita project repo ls`); sin inkwell responde
+solo con los repos:
 
 ```sh
 recap ask --active --json                              # la última pregunta de la transcripción
@@ -138,9 +159,10 @@ solo corre una respuesta a la vez y una manual detiene a la automática.
 
 ## Cambios propuestos a la documentación
 
-Si la reunión está ligada a bita, la etapa `proposals` (antes de `wrapup`)
-detecta los cambios explícitos y firmes a páginas que ya existen y los deja en
-la rama `proposal/meeting-<entrada>` de los docs, sin tocar `main`. Ideas,
+Si la reunión está ligada a bita e inkwell está instalado, la etapa `proposals`
+(antes de `wrapup`) detecta los cambios explícitos y firmes a páginas de inkwell
+que ya existen y los deja en la rama `proposal/meeting-<entrada>` de sus docs
+(`inkwell git propose`), sin tocar `main`. Ideas,
 dudas y lo que se corrigió después no entran.
 
 ```sh