wendkeep 0.50.0 → 0.52.0

package/CHANGELOG.md

@@ -4,6 +4,46 @@ All notable changes to **wendkeep** are documented here. Format based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this project follows
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.52.0] — 2026-07-25
+
+### Fixed
+
+- **`claude-opus-5` e `claude-mythos-5` deixam de custar $0.** Modelo ausente de
+  `hooks/pricing.json` faz `priceForModel` devolver `null` e a parcela dele do custo virar
+  zero — sem erro, sem aviso, sem nada no `doctor`. Num vault real:
+  `claude-opus-5  $0.0000` no `wendkeep cost`, enquanto Opus 4.8 e Fable 5 somavam $462.
+  Adicionados com os preços de API: Opus 5 a $5 input / $0,50 cache read / $25 output
+  (mesmo tier do Opus 4.8) e Mythos 5 a $10 / $1 / $50 (mesmo tier do Fable 5), com os
+  aliases das variantes de id. Notas já fechadas com custo zerado se corrigem com
+  `wendkeep cost rebuild`.
+
+### Added
+
+- **`wendkeep doctor` surfaça modelos sem preço.** Nova seção `[preços]`: lista os modelos
+  que aparecem nas notas de sessão com uso registrado mas sem entrada na tabela, e aponta
+  `hooks/pricing.json`. Cada modelo citado é consultado direto em `priceForModel` — **não**
+  se infere pelo sintoma "custo zerado", que não funciona: na nota que motivou a correção,
+  `modelo: "claude-opus-4.8 + claude-fable-5 + claude-opus-5"` fecha com **$415** porque os
+  dois primeiros têm preço, e só a fatia do Opus 5 está zerada. Um detector por custo zero
+  passaria batido justamente no caso real. Capability `session-observability` (OBS-9, OBS-10).
+
+## [0.51.0] — 2026-07-25
+
+### Added
+
+- **`wendkeep note repair-frontmatter [--apply]` — conserta as notas de sessão empilhadas.**
+  A 0.50.0 fechou a causa (lock + escrita atômica) e ensinou o `doctor` a **apontar** as
+  notas danificadas, mas não havia comando para consertá-las — a única checagem do doctor
+  sem conserto ao lado. O reparo funde os blocos num só sem perder nada: as chaves-base vêm
+  do bloco original (o de baixo, o único que as tem) e os valores gerenciados do bloco mais
+  recente (o do topo, último prepend). O merge opera sobre o texto bruto de cada chave, sem
+  reserializar YAML, então listas aninhadas atravessam byte-a-byte. Dry-run por padrão como
+  o `note relink`; `--apply` grava pelo mesmo lock dos hooks. Antes de gravar valida que o
+  resultado tem um bloco só, que nenhuma chave sumiu e que o corpo sobreviveu — falhando
+  qualquer uma, pula e reporta. O `doctor` agora imprime
+  `→ wendkeep note repair-frontmatter --apply` quando a contagem é > 0. Capability
+  `session-observability` (OBS-7, OBS-8) e `vault-doctor` (DIAG-5).
+
 ## [0.50.0] — 2026-07-23
 
 ### Fixed

package/bin/wendkeep.mjs

@@ -80,6 +80,10 @@ Usage:
   wendkeep note relink [--apply]  Backfill orphan derived notes (BUG/APR without a source session),
                            linking each to the modal source session of its type/month cohort. Dry-run
                            by default; --apply writes; skips notes with no sibling to infer from.
+  wendkeep note repair-frontmatter [--apply]  Merge stacked frontmatter blocks in session notes
+                           (damage from pre-lock concurrent writes) into a single block: base keys
+                           from the original block, values from the newest. Dry-run by default;
+                           --apply writes under the same lock as the hooks · --json.
   wendkeep lesson add "t" "l"   Record a project-local lesson (injected at SessionStart).
   wendkeep validate-memory [path]  Validate .brain/CORE.md against the compaction
                            protocol (cap 25, 3 sections, no secrets/PII). Uses

package/hooks/frontmatter-repair.mjs

@@ -0,0 +1,135 @@
+// Reparo das notas de sessão que ficaram com frontmatter empilhado.
+//
+// O dano vem das versões anteriores à session-note-atomic-write: sem lock, um hook lia a
+// nota já truncada por outro e prependava um frontmatter novo. Como o prepend entra pelo
+// TOPO, o bloco de baixo é o original (o único com type/date/provider/source) e o de cima
+// é a gravação mais recente. Ficar com um só perde metade da informação; a fusão é que é a
+// resposta.
+//
+// A causa já está fechada — isto aqui limpa o que ficou para trás.
+import { readFileSync } from 'node:fs';
+import { relative } from 'node:path';
+import { checkStackedFrontmatter } from './harness-doctor.mjs';
+import { mutateSessionNote } from './session-note-io.mjs';
+
+// Separa os blocos de frontmatter empilhados no topo do corpo da nota.
+//
+// A regra de "empilhado" é a MESMA de `checkStackedFrontmatter`: só conta como bloco o que
+// reabre com `---` logo após o fechamento do anterior. Detector e reparador precisam
+// concordar — se divergissem, o doctor acusaria uma nota que o reparo não conserta (ou
+// pior, o reparo comeria corpo que o doctor considera são). Um `---` no meio do texto
+// (regra horizontal, tabela) fica no corpo, onde deve ficar.
+export function splitStackedFrontmatter(content) {
+  const blocks = [];
+  let rest = typeof content === 'string' ? content : '';
+
+  while (/^---\n/.test(rest)) {
+    const close = rest.indexOf('\n---', 4);
+    if (close < 0) break;
+    blocks.push(rest.slice(0, close + 4));
+    rest = rest.slice(close + 4).replace(/^[\r\n]+/, '');
+  }
+
+  return { blocks, body: rest };
+}
+
+// Quebra o miolo de um frontmatter em entradas top-level, preservando as linhas literais.
+// Uma linha `^chave:` abre a entrada; o que vier indentado/em branco pertence a ela. Nada é
+// reinterpretado — listas YAML aninhadas atravessam byte-a-byte, sem reserializar aspas,
+// recuo ou ordem (o que geraria um diff gigante numa nota de 228 KB).
+function parseEntries(block) {
+  const inner = block.replace(/^---\n/, '').replace(/\n---$/, '');
+  const entries = new Map();
+  let current = null;
+
+  for (const line of inner.split('\n')) {
+    const root = line.match(/^([A-Za-z0-9_-]+):/);
+    if (root) {
+      current = root[1];
+      entries.set(current, [line]);
+      continue;
+    }
+    if (current) entries.get(current).push(line);
+  }
+
+  // Linha em branco no fim de uma entrada é layout, não valor.
+  for (const lines of entries.values()) {
+    while (lines.length > 1 && lines[lines.length - 1].trim() === '') lines.pop();
+  }
+  return entries;
+}
+
+// Funde os blocos empilhados num só. Devolve `null` quando não há nada a fundir.
+export function mergeStackedFrontmatter(content) {
+  const { blocks, body } = splitStackedFrontmatter(content);
+  if (blocks.length < 2) return null;
+
+  // A base é o bloco de BAIXO: é o original, o único com as chaves-base, e define a ordem
+  // das chaves. Depois aplica de baixo para cima, então o bloco do topo — a gravação mais
+  // recente — é o último a escrever e vence. Chave que só existe num bloco de cima entra no
+  // fim, nunca é descartada.
+  const merged = parseEntries(blocks[blocks.length - 1]);
+  for (let i = blocks.length - 2; i >= 0; i -= 1) {
+    for (const [key, lines] of parseEntries(blocks[i])) merged.set(key, lines);
+  }
+
+  return `---\n${[...merged.values()].flat().join('\n')}\n---\n\n${body}`;
+}
+
+// Um reparo que perde dado é pior que o dano que ele conserta: só grava o que passar aqui.
+function validateMerge(original, merged) {
+  const after = splitStackedFrontmatter(merged);
+  if (after.blocks.length !== 1) return 'resultado não ficou com um bloco só';
+
+  const kept = new Set(parseEntries(after.blocks[0]).keys());
+  const before = splitStackedFrontmatter(original);
+  for (const block of before.blocks) {
+    for (const key of parseEntries(block).keys()) {
+      if (!kept.has(key)) return `chave perdida no merge: ${key}`;
+    }
+  }
+  if (before.body && !merged.endsWith(before.body)) return 'corpo da nota não sobreviveu ao merge';
+  return null;
+}
+
+// Varre as notas de sessão empilhadas e as funde. Dry-run por padrão.
+export function repairStackedFrontmatter(vaultBase, { apply = false, lockTimeoutMs } = {}) {
+  const repaired = [];
+  const skipped = [];
+
+  for (const abs of checkStackedFrontmatter(vaultBase).notes) {
+    const rel = relative(vaultBase, abs).replaceAll('\\', '/');
+    let original;
+    try {
+      original = readFileSync(abs, 'utf-8');
+    } catch {
+      skipped.push({ file: rel, reason: 'leitura falhou' });
+      continue;
+    }
+
+    const merged = mergeStackedFrontmatter(original);
+    if (merged === null) continue; // detector e merge concordam: nada a fundir
+
+    const problem = validateMerge(original, merged);
+    if (problem) {
+      skipped.push({ file: rel, reason: problem });
+      continue;
+    }
+
+    const blocks = splitStackedFrontmatter(original).blocks.length;
+    if (!apply) {
+      repaired.push({ file: rel, blocks });
+      continue;
+    }
+
+    // Sob o mesmo lock dos hooks: reparar enquanto um subagente escreve seria repetir o bug.
+    const outcome = mutateSessionNote(abs, () => merged, lockTimeoutMs ? { timeoutMs: lockTimeoutMs } : {});
+    if (!outcome.written) {
+      skipped.push({ file: rel, reason: `gravação não ocorreu (${outcome.reason})` });
+      continue;
+    }
+    repaired.push({ file: rel, blocks });
+  }
+
+  return { applied: apply, repaired, skipped };
+}

package/hooks/harness-doctor.mjs

@@ -6,6 +6,7 @@ import { activeChange, parseTasks, backfillArtifactLinks } from './change-core.m
 import { relinkDerivedNotes } from './linked-notes.mjs';
 import { buildEffectiveRequirementPackage, checkSpecsState, evaluateVerdict, tasksHashOf, validateSpecImpact } from './spec-core.mjs';
 import { getLocale } from './locale.mjs';
+import { priceForModel } from './token-usage.mjs';
 import { readControl } from './obsidian-common.mjs';
 
 export function checkHarness(vaultBase, projectRoot) {
@@ -122,11 +123,69 @@ export function checkStackedFrontmatter(vaultBase) {
   return { count: notes.length, notes };
 }
 
+// Um modelo fora de `pricing.json` faz `priceForModel` devolver null e a parcela dele do custo
+// virar zero — sem erro, sem aviso. Modelo novo (claude-opus-5, claude-mythos-5) cai nisso por
+// default. A checagem é sobre o vault, não sobre o caminho de cálculo: o cálculo roda em hook a
+// cada turno, onde avisar viraria ruído e lançar derrubaria a captura da sessão.
+//
+// Cada modelo citado na nota é consultado direto em `priceForModel` — NÃO se infere pelo
+// sintoma "custo zerado". Numa sessão multi-modelo (`modelo: "claude-opus-4.8 + claude-opus-5"`)
+// os modelos precificados mantêm o total acima de zero e escondem o que falta: no vault que
+// motivou esta change, a nota fecha com $415 e a fatia do Opus 5 é a única zerada.
+export function checkUnpricedModels(vaultBase) {
+  const counts = new Map();
+
+  const modelsOf = (frontmatter) => {
+    // `modelos:` é a lista canônica; `modelo:` é o rótulo agregado (junta com " + ").
+    const list = frontmatter.match(/^modelos:\n((?:\s+- .*\n?)+)/m);
+    if (list) return list[1].split('\n').map((l) => l.replace(/^\s*-\s*/, '')).filter(Boolean);
+    const label = (frontmatter.match(/^modelo:\s*(.+)$/m) || [])[1] || '';
+    return label.split('+');
+  };
+
+  const walk = (dir) => {
+    let entries = [];
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const entry of entries) {
+      const abs = join(dir, entry.name);
+      if (entry.isDirectory()) { walk(abs); continue; }
+      if (!entry.name.endsWith('.md')) continue;
+      let content;
+      try { content = readFileSync(abs, 'utf-8'); } catch { continue; }
+      const fm = content.match(/^---\n([\s\S]*?)\n---/);
+      if (!fm) continue;
+      // Sessão sem uso registrado não é sintoma de nada — custo zero ali é correto.
+      if (!(Number((fm[1].match(/^tokens_total:\s*(.+)$/m) || [])[1]) > 0)) continue;
+      for (const raw of modelsOf(fm[1])) {
+        const model = raw.trim().replace(/^["']|["']$/g, '');
+        if (!model || model === 'unknown') continue;
+        if (priceForModel(model)) continue;
+        counts.set(model, (counts.get(model) || 0) + 1);
+      }
+    }
+  };
+
+  walk(join(vaultBase, '02-Sessões'));
+  return { models: [...counts].map(([model, notes]) => ({ model, notes })) };
+}
+
+export function renderUnpricedModelLines(unpriced) {
+  const lines = [`[preços] ${unpriced.models.length} modelo(s) sem preço na tabela`];
+  for (const { model, notes } of unpriced.models) {
+    lines.push(`  ✗ ${model} (${notes} nota(s) com custo zerado)`);
+  }
+  if (unpriced.models.length) lines.push('  → adicione o modelo em hooks/pricing.json');
+  else lines.push('  tabela de preços completa ✓');
+  return lines;
+}
+
 // Formatador puro pra que a saída do doctor seja testável sem process.exit.
 export function renderStackedFrontmatterLines(vaultBase, stacked) {
   const lines = [`[notas] ${stacked.count} sessão(ões) com frontmatter empilhado`];
   for (const abs of stacked.notes) lines.push(`  ✗ ${relative(vaultBase, abs)}`);
-  if (!stacked.count) lines.push('  frontmatter íntegro ✓');
+  // Como as demais checagens do doctor: nunca apontar um problema sem oferecer o conserto.
+  if (stacked.count) lines.push('  → wendkeep note repair-frontmatter --apply');
+  else lines.push('  frontmatter íntegro ✓');
   return lines;
 }
 

package/hooks/pricing.json

@@ -26,6 +26,13 @@
       "cachedInput": 0.5,
       "output": 25
     },
+    "claude-opus-5": {
+      "label": "Claude Opus 5 API",
+      "provider": "anthropic",
+      "input": 5,
+      "cachedInput": 0.5,
+      "output": 25
+    },
     "claude-sonnet-4.6": {
       "label": "Claude Sonnet 4.6 API",
       "provider": "anthropic",
@@ -53,6 +60,13 @@
       "input": 10,
       "cachedInput": 1,
       "output": 50
+    },
+    "claude-mythos-5": {
+      "label": "Claude Mythos 5 API",
+      "provider": "anthropic",
+      "input": 10,
+      "cachedInput": 1,
+      "output": 50
     }
   }
 }

package/hooks/token-usage.mjs

@@ -117,6 +117,9 @@ const MODEL_ALIASES = {
   'claude-opus-4-8': 'claude-opus-4.8',
   'anthropic/claude-opus-4.8': 'claude-opus-4.8',
   'anthropic/claude-opus-4-8': 'claude-opus-4.8',
+  'claude-opus-5': 'claude-opus-5',
+  'claude-opus-5-0': 'claude-opus-5',
+  'anthropic/claude-opus-5': 'claude-opus-5',
   'claude-sonnet-4.6': 'claude-sonnet-4.6',
   'claude-sonnet-4-6': 'claude-sonnet-4.6',
   'anthropic/claude-sonnet-4.6': 'claude-sonnet-4.6',
@@ -132,6 +135,8 @@ const MODEL_ALIASES = {
   'claude-fable-5': 'claude-fable-5',
   'claude-fable-5[1m]': 'claude-fable-5',
   'anthropic/claude-fable-5': 'claude-fable-5',
+  'claude-mythos-5': 'claude-mythos-5',
+  'anthropic/claude-mythos-5': 'claude-mythos-5',
 };
 
 const MANAGED_FRONTMATTER_KEYS = new Set([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.50.0",
+  "version": "0.52.0",
   "description": "A persistent-memory harness for AI coding agents on your Obsidian vault: turn-by-turn session capture plus a native, zero-dependency spec→change→verify→archive loop (sensor-gated, independent verdict, mutation discrimination). Local-first, agent-agnostic (Claude Code, Codex, Cursor…).",
   "type": "module",
   "bin": {

package/src/doctor.mjs

@@ -4,7 +4,7 @@ import { spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { checkHarness, checkVaultLinks, checkSessionActivity, checkStackedFrontmatter, renderStackedFrontmatterLines } from '../hooks/harness-doctor.mjs';
+import { checkHarness, checkVaultLinks, checkSessionActivity, checkStackedFrontmatter, renderStackedFrontmatterLines, checkUnpricedModels, renderUnpricedModelLines } from '../hooks/harness-doctor.mjs';
 import { checkSyncDefs } from './sync-defs.mjs';
 import { resolveProjectVault } from './project-vault.mjs';
 
@@ -73,6 +73,9 @@ export function runDoctor(argv) {
   const stacked = checkStackedFrontmatter(vaultBase);
   process.stdout.write(`\n${renderStackedFrontmatterLines(vaultBase, stacked).join('\n')}\n`);
 
+  // 3c. Modelo fora de pricing.json fecha a sessão com custo zero, sem erro — só aparece aqui.
+  process.stdout.write(`\n${renderUnpricedModelLines(checkUnpricedModels(vaultBase)).join('\n')}\n`);
+
   // 4. Sessão: não mente "inativa" quando há atividade recente (workflow/subagente em background).
   const act = checkSessionActivity(vaultBase);
   if (act.lastSession) {

package/src/note.mjs

@@ -15,6 +15,7 @@ import {
 } from '../hooks/obsidian-common.mjs';
 import { getLocale } from '../hooks/locale.mjs';
 import { buildManualBugNote, buildManualLearningNote, relinkDerivedNotes } from '../hooks/linked-notes.mjs';
+import { repairStackedFrontmatter } from '../hooks/frontmatter-repair.mjs';
 
 const TYPES = {
   bug: { folderKey: 'bugs', prefix: 'BUG', build: buildManualBugNote },
@@ -45,8 +46,22 @@ export function runNote(argv) {
     process.exit(0);
   }
 
+  if (sub === 'repair-frontmatter') {
+    const vaultRaw = opt(rest, '--vault') || process.env.OBSIDIAN_VAULT_PATH;
+    if (!vaultRaw) { process.stderr.write('wendkeep note repair-frontmatter: no vault (--vault or OBSIDIAN_VAULT_PATH).\n'); process.exit(2); }
+    const vaultBase = isAbsolute(vaultRaw) ? vaultRaw : resolve(process.cwd(), vaultRaw);
+    if (!existsSync(vaultBase)) { process.stderr.write(`wendkeep note repair-frontmatter: vault not found: ${vaultBase}\n`); process.exit(2); }
+    const r = repairStackedFrontmatter(vaultBase, { apply: rest.includes('--apply') });
+    if (rest.includes('--json')) { process.stdout.write(`${JSON.stringify(r, null, 2)}\n`); process.exit(0); }
+    process.stdout.write(`${r.repaired.length} nota(s) com frontmatter empilhado${r.applied ? ' reparada(s)' : ' seriam reparada(s)'}\n`);
+    for (const n of r.repaired) process.stdout.write(`  ${n.file} (${n.blocks} blocos -> 1)\n`);
+    for (const s of r.skipped) process.stdout.write(`  pulado: ${s.file} (${s.reason})\n`);
+    if (!r.applied && r.repaired.length) process.stdout.write('\ndry-run — nada escrito. Rode com --apply para fundir os blocos.\n');
+    process.exit(0);
+  }
+
   if (sub !== 'new') {
-    process.stderr.write('wendkeep note: subcomando desconhecido (use `note new --type bug|learning "<título>"` ou `note relink [--apply]`).\n');
+    process.stderr.write('wendkeep note: subcomando desconhecido (use `note new --type bug|learning "<título>"`, `note relink [--apply]` ou `note repair-frontmatter [--apply]`).\n');
     process.exit(2);
   }