wendkeep 0.34.1 → 0.36.0

package/CHANGELOG.md

@@ -4,6 +4,24 @@ 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.35.0] — 2026-07-11
+
+### Fixed
+
+- **Wikilinks para changes arquivadas não quebram mais.** `archive` e `abandon` movem a pasta
+  para `_arquivo/<data>-<slug>/` — e todo wikilink gravado ANTES do move (sessões fechadas,
+  decisões, outras changes) morria, aparecendo cinza no grafo (visto em produção). Agora o move
+  **reescreve os wikilinks no vault inteiro** (`[[08-Mudanças/<slug>/…]]` →
+  `[[08-Mudanças/_arquivo/<data>-<slug>/…]]`, full-path com e sem alias; nunca por basename —
+  `proposta`/`design` existem em toda change). Fail-quiet: a reescrita nunca derruba o archive.
+
+### Added
+
+- **`wendkeep change relink [--apply] [--json]`** — cura retroativa para vaults com links já
+  mortos (changes arquivadas antes da 0.35.0): mapeia cada slug morto para o dir datado em
+  `_arquivo/` e reescreve. Dry-run por default; slug ambíguo (arquivado 2×) é reportado e pulado
+  — nunca chuta; sem archive correspondente vira aviso.
+
 ## [0.34.1] — 2026-07-11
 
 ### Fixed
@@ -852,3 +870,9 @@ Initial release — the capture engine, extracted from a system in daily product
 [0.2.7]: https://www.npmjs.com/package/wendkeep/v/0.2.7
 [0.2.0]: https://www.npmjs.com/package/wendkeep/v/0.2.0
 [0.1.0]: https://www.npmjs.com/package/wendkeep/v/0.1.0
+# 0.36.0 — 2026-07-11
+
+- Custos de subagents agora são atribuídos ao modelo que realmente os executou por meio de um ledger por sessão; campos legados continuam compatíveis.
+- Novo `wendkeep cost rebuild`, dry-run por padrão, reconstrói sessões antigas via `SESSION_REGISTRY` e, com `--apply`, grava um manifesto auditável em `.brain/COST_REBUILD.json`.
+- Totais combinados de tokens/custo passam a ser persistidos explicitamente nas notas.
+- Preços API-equivalentes de GPT-5.6 Sol, Terra e Luna adicionados à tabela editável e ao fallback interno.

package/README.md

@@ -118,6 +118,7 @@ No re‑copying, no snapshot to re‑sync — the package is the single source o
 | `wendkeep sensors <sub>` | `list` / `add <id> "<command>"` — view/edit `wendkeep.sensors.json` (JSON Schema shipped). |
 | `wendkeep cost [--since d]` | Aggregate AI-coding spend across the vault's sessions — total, by model, by day (`--json`). |
 | `wendkeep import [opts]` | **Retroactive memory** — backfill past **Claude + Codex** sessions into the vault (deduped by `session_id`). `--source all\|claude\|codex` / `--from <dir>` / `--codex-from <dir>` / `--since d` / `--limit n` / `--dry-run` / `--json`. |
+| `wendkeep cost rebuild [opts]` | Recalcula custos históricos do transcript principal e subagents usando `SESSION_REGISTRY`. Dry-run por padrão; `--apply` atualiza notas e grava `.brain/COST_REBUILD.json`. Aceita `--session`, `--limit` e `--json`. |
 | `wendkeep lesson add "t" "l"` | Record a project-local lesson (injected at the next SessionStart). |
 | `wendkeep sync-defs` | Copy `.brain/agents\|skills` into `.codex/agents`, `.claude/skills`, `.agents/skills`; `--check` detects drift. |
 | `wendkeep validate-memory [path]` | Validate `.brain/CORE.md` (cap 25, 3 sections, no secrets/PII). |

package/README.pt-BR.md

@@ -115,6 +115,7 @@ Sem recopiar, sem snapshot pra re‑sincronizar — o pacote é a única fonte d
 | `wendkeep spec <sub>` | Specs vivos: `list` / `show <capability>`. |
 | `wendkeep sensors <sub>` | `list` / `add <id> "<comando>"` — vê/edita `wendkeep.sensors.json` (JSON Schema incluso). |
 | `wendkeep cost [opts]` | Agrega o gasto de IA nas sessões do cofre — total, por modelo, por dia · `--top [N]` · `--trend [day\|week\|month]` (+ projeção) · `--write` (gera `00-Custo.md`) · `--json`. |
+| `wendkeep cost rebuild [opts]` | Reconstrói custos históricos do transcript principal e subagents via `SESSION_REGISTRY`. Dry-run por padrão; `--apply` grava notas e `.brain/COST_REBUILD.json`. |
 | `wendkeep stats [--vault P]` | Uma linha compartilhável: sessões · prompts · gasto · período · modelos (`--json`). |
 | `wendkeep import [opts]` | **Memória retroativa** — importa sessões passadas de **Claude + Codex** pro cofre (dedup por `session_id`). `--source all\|claude\|codex` / `--from <dir>` / `--codex-from <dir>` / `--stamp-ids` / `--since d` / `--limit n` / `--dry-run` / `--json`. |
 | `wendkeep dashboard [--force]` | (Re)gera os Bases filtrados por pasta + o MOC `00-Dashboard`. |

package/bin/wendkeep.mjs

@@ -51,6 +51,9 @@ Usage:
   wendkeep cost [opts]         Aggregate AI-coding spend across the vault's sessions.
                            --since <date> · --top [N] (priciest) · --trend [day|week|month]
                            (+ run-rate projection) · --write (generate 00-Custo.md) · --json.
+  wendkeep cost rebuild        Recalculate historical parent + subagent costs from SESSION_REGISTRY.
+                           Dry-run by default · --apply writes notes + .brain/COST_REBUILD.json
+                           · --session <id|file> · --limit N · --json.
   wendkeep stats [--vault P]   One shareable line: sessions · prompts · spend · span · models (--json).
   wendkeep import [opts]       Backfill: import this project's past Claude + Codex sessions into
                            the vault (deduped by session_id). --source all|claude|codex (default

package/hooks/change-core.mjs

@@ -381,12 +381,6 @@ export function archiveChange(vaultBase, slug, { gate = gateGreen, dateStr, adrN
   const loc = getLocale(vaultBase);
   const chDir = loc.folders.changes;
   const src = join(vaultBase, chDir, slug);
-  let sourceSessionRel = '';
-  try {
-    const proposal = readFileSync(join(src, 'proposta.md'), 'utf8');
-    const m = proposal.match(/\[\[((?:02-Sessões|02-Sessions)\/[^\]|]+?)(?:\|[^\]]+)?\]\]/);
-    if (m) sourceSessionRel = m[1].endsWith('.md') ? m[1] : `${m[1]}.md`;
-  } catch { /* sem source */ }
   const verdict = gate(src);
   if (!verdict.ok) return { ok: false, failing: verdict.failing || [] };
 
@@ -441,16 +435,10 @@ export function archiveChange(vaultBase, slug, { gate = gateGreen, dateStr, adrN
     writeFileSync(pp, c, 'utf8');
   } catch { /* proposta ilegível — segue */ }
 
-  // A sessão guardava o link da change ativa; após o move, reescreva para o caminho arquivado.
-  if (sourceSessionRel) {
-    try {
-      const sessionPath = join(vaultBase, sourceSessionRel);
-      const oldLink = wikilinkFromRel(join(chDir, slug, 'proposta'));
-      const archivedLink = wikilinkFromRel(join(destRel, 'proposta'));
-      const current = readFileSync(sessionPath, 'utf8');
-      if (current.includes(oldLink)) writeFileSync(sessionPath, current.replaceAll(oldLink, archivedLink), 'utf8');
-    } catch { /* backlink é reparo auxiliar; archive já está íntegro */ }
-  }
+  // O move quebrava TODO wikilink gravado antes (sessões fechadas, decisões, outras changes —
+  // links cinza no grafo, visto em produção). Reescreve vault-wide; fail-quiet.
+  let linksRewritten = 0;
+  try { linksRewritten = rewriteChangeLinks(vaultBase, `${chDir}/${slug}`, destRel.replaceAll('\\', '/')); } catch { /* archive já íntegro */ }
 
   // ADR goes in the same dated month folder as session-derived decisions (04-Decisões/ano/MM-MMM/)
   // — not the year root — so all ADRs sit together in the vault's convention.
@@ -485,7 +473,88 @@ Mudança ${changeWikilink} concluída e arquivada.${capLine}${reqLine}${forcedNo
   // Only clear the pointer when the archived change IS the active one — archiving some other
   // slug explicitly must not blank the pointer of a different, still-active change.
   if (activeChange(vaultBase) === slug) clearActiveChange(vaultBase);
-  return { ok: true, failing: [], archivedRel: destRel, adrRel, promoted, specWarnings };
+  return { ok: true, failing: [], archivedRel: destRel, adrRel, promoted, specWarnings, linksRewritten };
+}
+
+// --- reescrita de wikilinks pós-move (0.35.0) ----------------------------------
+// Todo .md do vault (inclui .brain e _arquivo — uma change arquivada pode linkar outra).
+function allVaultMarkdown(vaultBase) {
+  const out = [];
+  const skip = new Set(['.git', '.obsidian', 'node_modules']);
+  const walk = (dir) => {
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (skip.has(e.name)) continue;
+      if (e.name.startsWith('.') && e.name !== '.brain') continue;
+      const abs = join(dir, e.name);
+      if (e.isDirectory()) walk(abs);
+      else if (e.name.endsWith('.md')) out.push(abs);
+    }
+  };
+  walk(vaultBase);
+  return out;
+}
+
+// Reescreve `[[fromRel/...]]`, `[[fromRel]]` e `[[fromRel|alias]]` em todo o vault.
+// NUNCA por basename: `proposta`/`design` existem em toda change — só full-path é seguro.
+function rewriteChangeLinks(vaultBase, fromRel, toRel) {
+  let touched = 0;
+  for (const abs of allVaultMarkdown(vaultBase)) {
+    let content;
+    try { content = readFileSync(abs, 'utf8'); } catch { continue; }
+    const next = content
+      .split(`[[${fromRel}/`).join(`[[${toRel}/`)
+      .split(`[[${fromRel}]]`).join(`[[${toRel}]]`)
+      .split(`[[${fromRel}|`).join(`[[${toRel}|`);
+    if (next !== content) {
+      try { writeFileSync(abs, next, 'utf8'); touched += 1; } catch { /* nota readonly — segue */ }
+    }
+  }
+  return touched;
+}
+
+// Cura retroativa (vaults pré-0.35): wikilinks para changes que já moveram sem reescrita.
+// Dry-run por default; match por slug no nome datado do archive (`<data>-<slug>[-abandonada]`);
+// ambíguo (mesmo slug arquivado 2×) é reportado e pulado — nunca chuta.
+export function relinkChanges(vaultBase, { apply = false } = {}) {
+  const chDir = getLocale(vaultBase).folders.changes;
+  const archiveAbs = join(vaultBase, chDir, ARCHIVE_DIR);
+  let archived = [];
+  try { archived = readdirSync(archiveAbs, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name); } catch { /* sem arquivo */ }
+  const slugOf = (name) => name.replace(/^\d{4}-\d{2}-\d{2}-/, '').replace(/-abandonada$/, '');
+
+  // Slugs mortos referenciados em algum .md: [[<chDir>/<seg>/...]] | [[<chDir>/<seg>]] | [[...|
+  const linkRe = new RegExp(`\\[\\[${chDir.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\$&')}/([^/\\]|]+)(?=[/\\]|])`, 'g');
+  const files = allVaultMarkdown(vaultBase);
+  const dead = new Set();
+  for (const abs of files) {
+    let content;
+    try { content = readFileSync(abs, 'utf8'); } catch { continue; }
+    for (const m of content.matchAll(linkRe)) {
+      const seg = m[1];
+      if (seg === ARCHIVE_DIR) continue;
+      if (!existsSync(join(vaultBase, chDir, seg, 'proposta.md'))) dead.add(seg);
+    }
+  }
+
+  const rewritten = [];
+  const ambiguous = [];
+  const orphans = [];
+  const renames = [];
+  for (const seg of dead) {
+    const matches = archived.filter((name) => slugOf(name) === seg);
+    if (matches.length === 1) renames.push({ from: `${chDir}/${seg}`, to: `${chDir}/${ARCHIVE_DIR}/${matches[0]}` });
+    else if (matches.length > 1) ambiguous.push(`${seg} → ${matches.join(', ')}`);
+    else orphans.push(seg);
+  }
+
+  let filesTouched = 0;
+  if (apply) {
+    for (const r of renames) filesTouched += rewriteChangeLinks(vaultBase, r.from, r.to);
+  }
+  rewritten.push(...renames);
+  return { applied: apply, scanned: files.length, filesTouched, rewritten, ambiguous, orphans };
 }
 
 // Abandono (0.31.0): a saída legítima para uma change que não vai adiante — o que antes só o
@@ -504,6 +573,8 @@ export function abandonChange(vaultBase, slug, { dateStr }) {
     const pp = join(destAbs, 'proposta.md');
     writeFileSync(pp, readFileSync(pp, 'utf8').replace(/^status:\s*active\s*$/m, 'status: abandoned'), 'utf8');
   } catch { /* proposta sem frontmatter — segue */ }
+  let linksRewritten = 0;
+  try { linksRewritten = rewriteChangeLinks(vaultBase, `${chDir}/${slug}`, destRel.replaceAll('\\', '/')); } catch { /* abandono já íntegro */ }
   if (activeChange(vaultBase) === slug) clearActiveChange(vaultBase);
-  return { ok: true, failing: [], archivedRel: destRel };
+  return { ok: true, failing: [], archivedRel: destRel, linksRewritten };
 }

package/hooks/pricing.json

@@ -1,7 +1,10 @@
 {
   "_nota": "Preços API por milhão de tokens. cachedInput = cache read. Cache write aplica multiplicador no código: 5m = 1.25x input, 1h = 2x input. Editar aqui quando o provedor mudar preços (sem mexer no .mjs). Se o arquivo sumir ou ficar inválido, o hook usa a tabela embutida em token-usage.mjs.",
-  "_fonte": "Anthropic https://www.anthropic.com/pricing — conferido 2026-06-13 (Opus 4.8: $5 input / $25 output; cache read 0.1x; cache write 1.25x 5m / 2x 1h)",
-  "models": {
+  "_fonte": "OpenAI https://openai.com/index/gpt-5-6/ e https://help.openai.com/en/articles/20001325-a-preview-of-gpt-56-sol-terra-and-luna; Anthropic https://www.anthropic.com/pricing — conferido 2026-07-11",
+  "models": {
+    "gpt-5.6-sol": { "label": "GPT-5.6 Sol API", "provider": "openai", "input": 5, "cachedInput": 0.5, "output": 30 },
+    "gpt-5.6-terra": { "label": "GPT-5.6 Terra API", "provider": "openai", "input": 2.5, "cachedInput": 0.25, "output": 15 },
+    "gpt-5.6-luna": { "label": "GPT-5.6 Luna API", "provider": "openai", "input": 1, "cachedInput": 0.1, "output": 6 },
     "gpt-5.5": {
       "label": "GPT-5.5 API",
       "provider": "openai",

package/hooks/subagent-usage.mjs

@@ -91,6 +91,7 @@ export function collectSubagentUsage(sessionDir) {
   let count = 0;
   let calls = 0;
   let cost = 0;
+  const modelMap = new Map();
 
   for (const f of files) {
     const summary = summarizeTokenUsage(parseTokenUsageFromTranscript(f));
@@ -112,8 +113,18 @@ export function collectSubagentUsage(sessionDir) {
       calls: summary.calls,
       tokens,
       cost: round4(summary.costs.model),
+      modelRows: summary.modelRows,
     });
 
+    for (const row of summary.modelRows || []) {
+      const key = `${row.provider || '?'}\u0000${row.model || '?'}`;
+      const current = modelMap.get(key) || { provider: row.provider || '?', model: row.model || '?', calls: 0, tokens: 0, cost: 0 };
+      current.calls += row.calls || 0;
+      current.tokens += tokensTotal(row.usage);
+      current.cost += row.costs?.model || 0;
+      modelMap.set(key, current);
+    }
+
     count += 1;
     calls += summary.calls;
     cost += summary.costs.model;
@@ -151,7 +162,9 @@ export function collectSubagentUsage(sessionDir) {
   return {
     subagents,
     workflows,
-    aggregate: { count, calls, tokens: tokensTotal(usageAgg), cost: round4(cost), wasted, usage: usageAgg, tools: [...allTools] },
+    aggregate: { count, calls, tokens: tokensTotal(usageAgg), cost: round4(cost), wasted, usage: usageAgg, tools: [...allTools],
+      modelRows: [...modelMap.values()].map((r) => ({ ...r, cost: round4(r.cost), source: 'subagent' })),
+    },
   };
 }
 
@@ -173,19 +186,22 @@ export function renderSubagentSection(c) {
     .map((s) => `| ${s.id} | ${s.agentType || '-'} | ${s.workflow || '-'} | ${s.model} | ${s.tools} | ${fmt(s.tokens)} | ${usd(s.cost)} |`)
     .join('\n');
   const wasteLine = a.wasted ? `\n- **Desperdiçado (runs killed/failed):** ${usd(a.wasted)}` : '';
+  const combinedLine = c.combined ? `\n- **Sessão completa (main + subagents):** ${fmt(c.combined.tokens)} tokens · ${usd(c.combined.cost)}` : '';
+  const modelRows = c.combined?.models?.map((m) => `| ${m.model} | ${m.source} | ${fmt(m.tokens)} | ${usd(m.cost)} |`).join('\n') || '';
+  const models = modelRows ? `\n\n### Por modelo (sessão completa)\n\n| Modelo | Origem | Tokens | Custo |\n|---|---|---:|---:|\n${modelRows}` : '';
   return `## Subagents & Workflows
 
-> Custo de subagents/workflows desta sessão — NÃO incluído no total principal acima.
+> Custo de subagents/workflows desta sessão, seguido do total combinado e da atribuição por modelo.
 
 - **Subagents:** ${a.count} · ${a.calls} chamadas · ${fmt(a.tokens)} tokens · ${usd(a.cost)}
 - **Workflows:** ${wf}
-- **Tools (subagents):** ${tools}${wasteLine}
+- **Tools (subagents):** ${tools}${wasteLine}${combinedLine}
 
 ### Por subagent (${a.count})
 
 | Agent | Tipo | Workflow | Modelo | Tools | Tokens | Custo |
 |---|---|---|---|---:|---:|---:|
-${rows}`;
+${rows}${models}`;
 }
 
 function setFrontmatterField(content, key, value) {
@@ -228,6 +244,26 @@ export function upsertSubagentUsage(sessionPath, transcriptPath) {
   content = setFrontmatterField(content, 'subagents_tools', `"${(a.tools || []).join(', ')}"`);
   content = setFrontmatterField(content, 'subagents_wasted_usd', a.wasted || 0);
   content = setFrontmatterField(content, 'tokens_total_incl_subagents', frontmatterNumber(content, 'tokens_total') + a.tokens);
+  content = setFrontmatterField(content, 'custo_total_incl_subagents_usd', round4(frontmatterNumber(content, 'custo_modelo_usd') + a.cost));
+  let mainRows = [];
+  try {
+    const main = summarizeTokenUsage(parseTokenUsageFromTranscript(transcriptPath));
+    mainRows = (main.modelRows || []).map((r) => ({
+      provider: r.provider || '?', model: r.model || '?', source: 'main', calls: r.calls || 0,
+      tokens: tokensTotal(r.usage), cost: round4(r.costs?.model || 0),
+    }));
+  } catch { /* preserve legacy aggregate fallback */ }
+  if (!mainRows.length) {
+    const mainModel = (content.match(/^custo_modelo_label:\s*["']?([^"'\r\n]+)["']?\s*$/m) || [])[1] || '?';
+    mainRows = [{ model: mainModel, source: 'main', cost: round4(frontmatterNumber(content, 'custo_modelo_usd')), tokens: frontmatterNumber(content, 'tokens_total') }];
+  }
+  const ledger = [...mainRows, ...(a.modelRows || [])];
+  collected.combined = {
+    tokens: frontmatterNumber(content, 'tokens_total') + a.tokens,
+    cost: round4(frontmatterNumber(content, 'custo_modelo_usd') + a.cost),
+    models: ledger,
+  };
+  content = setFrontmatterField(content, 'custo_por_modelo_json', `'${JSON.stringify(ledger).replaceAll("'", "''")}'`);
   content = upsertSection(content, '## Subagents & Workflows', renderSubagentSection(collected));
   writeFileSync(sessionPath, content, 'utf8');
   return true;

package/hooks/token-usage.mjs

@@ -12,7 +12,10 @@ import {
 // Cache write: 5m = 1.25x input, 1h = 2x input (multiplicadores em calculateCost).
 // Tabela editável em pricing.json (mesma pasta); esta é o fallback embutido
 // usado quando o JSON some ou fica inválido — o hook nunca deve quebrar por isso.
-const DEFAULT_PRICE_REFERENCE = {
+const DEFAULT_PRICE_REFERENCE = {
+  'gpt-5.6-sol': { label: 'GPT-5.6 Sol API', provider: 'openai', input: 5, cachedInput: 0.5, output: 30 },
+  'gpt-5.6-terra': { label: 'GPT-5.6 Terra API', provider: 'openai', input: 2.5, cachedInput: 0.25, output: 15 },
+  'gpt-5.6-luna': { label: 'GPT-5.6 Luna API', provider: 'openai', input: 1, cachedInput: 0.1, output: 6 },
   'gpt-5.5': {
     label: 'GPT-5.5 API',
     provider: 'openai',
@@ -82,7 +85,18 @@ export function loadPriceReference(file = PRICING_FILE) {
 
 const PRICE_REFERENCE = loadPriceReference();
 
-const MODEL_ALIASES = {
+const MODEL_ALIASES = {
+  'gpt-5.6': 'gpt-5.6-sol',
+  'gpt-5.6-sol': 'gpt-5.6-sol',
+  'gpt-5-6-sol': 'gpt-5.6-sol',
+  'openai/gpt-5.6': 'gpt-5.6-sol',
+  'openai/gpt-5.6-sol': 'gpt-5.6-sol',
+  'gpt-5.6-terra': 'gpt-5.6-terra',
+  'gpt-5-6-terra': 'gpt-5.6-terra',
+  'openai/gpt-5.6-terra': 'gpt-5.6-terra',
+  'gpt-5.6-luna': 'gpt-5.6-luna',
+  'gpt-5-6-luna': 'gpt-5.6-luna',
+  'openai/gpt-5.6-luna': 'gpt-5.6-luna',
   'gpt-5.5': 'gpt-5.5',
   'gpt-5_5': 'gpt-5.5',
   'openai/gpt-5.5': 'gpt-5.5',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.34.1",
+  "version": "0.36.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/change.mjs

@@ -13,6 +13,7 @@ import {
   setTaskDone,
   archiveChange,
   abandonChange,
+  relinkChanges,
   scaffoldPlaceholders,
 } from '../hooks/change-core.mjs';
 import { evaluateGate, requiredSensors } from '../hooks/sensors-core.mjs';
@@ -284,6 +285,17 @@ export function runChange(argv) {
     process.exit(0);
   }
 
+  if (sub === 'relink') {
+    const r = relinkChanges(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.rewritten.length} slug(s) morto(s) mapeado(s)${r.applied ? ` · ${r.filesTouched} arquivo(s) reescritos` : ''}\n`);
+    for (const m of r.rewritten) process.stdout.write(`  ${m.from} → ${m.to}\n`);
+    for (const a of r.ambiguous) process.stdout.write(`  ambíguo (pulado): ${a}\n`);
+    for (const o of r.orphans) process.stdout.write(`  sem archive correspondente: ${o}\n`);
+    if (!r.applied) process.stdout.write('\ndry-run — nada foi escrito. Rode com --apply para reescrever os wikilinks.\n');
+    process.exit(0);
+  }
+
   if (sub === 'abandon') {
     const slug = slugArg() || activeChange(vaultBase);
     if (!slug) { process.stderr.write('wendkeep change abandon: missing <slug> and no active change\n'); process.exit(2); }
@@ -293,6 +305,6 @@ export function runChange(argv) {
     process.exit(0);
   }
 
-  process.stderr.write(`wendkeep change: unknown subcommand "${sub}". Known: new, use, continue, list, show, status, done, undone, diff, archive, abandon.\n`);
+  process.stderr.write(`wendkeep change: unknown subcommand "${sub}". Known: new, use, continue, list, show, status, done, undone, diff, archive, abandon, relink.\n`);
   process.exit(2);
 }

package/src/cost.mjs

@@ -4,6 +4,7 @@
 import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join, resolve } from 'node:path';
 import { getLocale } from '../hooks/locale.mjs';
+import { rebuildSessionCosts } from './rebuild-costs.mjs';
 
 const round4 = (n) => Math.round((Number(n) || 0) * 10000) / 10000;
 const usd = (n) => `$${(Number(n) || 0).toFixed(4)}`;
@@ -20,6 +21,11 @@ function fmValue(content, key) {
 // Parse the cost-relevant frontmatter of one note; null if it is not a session note.
 export function parseSessionCost(content) {
   if (!/^type:\s*session\s*$/m.test(content)) return null;
+  let ledger = [];
+  try {
+    const raw = fmValue(content, 'custo_por_modelo_json').replaceAll("''", "'");
+    if (raw) ledger = JSON.parse(raw);
+  } catch { /* legacy/malformed note: use safe fallback below */ }
   return {
     date: (fmValue(content, 'date') || '').slice(0, 10),
     model: fmValue(content, 'custo_modelo_label') || fmValue(content, 'modelo') || '?',
@@ -29,6 +35,7 @@ export function parseSessionCost(content) {
     tokens: Number(fmValue(content, 'tokens_total')) || 0,
     subTokens: Number(fmValue(content, 'subagents_tokens_total')) || 0,
     prompts: Number(fmValue(content, 'prompts')) || 0,
+    ledger,
   };
 }
 
@@ -46,8 +53,16 @@ export function aggregateCosts(entries) {
     const d = e.date || '?';
     (byDay[d] = byDay[d] || { cost: 0, count: 0 }).cost += e.mainCost + e.subCost;
     byDay[d].count += 1;
-    (byModel[e.model] = byModel[e.model] || { cost: 0, count: 0 }).cost += e.mainCost + e.subCost;
-    byModel[e.model].count += 1;
+    const rows = e.ledger?.length ? e.ledger : [
+      { model: e.model, cost: e.mainCost },
+      ...(e.subCost ? [{ model: 'subagents (legado, modelo desconhecido)', cost: e.subCost }] : []),
+    ];
+    const seen = new Set();
+    for (const row of rows) {
+      const model = row.model || '?';
+      (byModel[model] = byModel[model] || { cost: 0, count: 0 }).cost += Number(row.cost) || 0;
+      if (!seen.has(model)) { byModel[model].count += 1; seen.add(model); }
+    }
   }
   const total = main + sub;
   return {
@@ -186,6 +201,16 @@ export function runCost(argv) {
   if (!vaultRaw) { process.stderr.write('wendkeep cost: 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 cost: vault not found: ${vaultBase}\n`); process.exit(2); }
+  if (argv[0] === 'rebuild') {
+    const report = rebuildSessionCosts(vaultBase, {
+      apply: argv.includes('--apply'),
+      session: opt(argv, '--session') || '',
+      limit: Number(opt(argv, '--limit')) || 0,
+    });
+    if (argv.includes('--json')) process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    else process.stdout.write(`cost rebuild (${report.mode}): ${report.scanned} lidas · ${report.changed} alteradas · ${report.unchanged} iguais · ${report.missing.length} sem fonte · ${report.errors.length} erros\n${report.mode === 'apply' ? 'Relatório: .brain/COST_REBUILD.json\n' : 'Nenhum arquivo foi alterado; use --apply para gravar.\n'}`);
+    process.exit(report.ok ? 0 : 1);
+  }
   const agg = collectVaultCost(vaultBase, { since: opt(argv, '--since') });
 
   if (argv.includes('--json')) { process.stdout.write(`${JSON.stringify(agg, null, 2)}\n`); process.exit(0); }

package/src/rebuild-costs.mjs

@@ -0,0 +1,40 @@
+// Deterministic cost reconstruction for historical sessions.
+// Registry is authoritative: session_file <-> transcript_path. Dry-run restores every note.
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { readSessionRegistry } from '../hooks/obsidian-common.mjs';
+import { updateSessionUsage } from '../hooks/token-usage.mjs';
+import { upsertSubagentUsage } from '../hooks/subagent-usage.mjs';
+
+export function rebuildSessionCosts(vaultBase, { apply = false, session = '', limit = 0 } = {}) {
+  const registry = readSessionRegistry(vaultBase);
+  const report = { version: 1, generatedAt: new Date().toISOString(), mode: apply ? 'apply' : 'dry-run', scanned: 0, changed: 0, unchanged: 0, missing: [], errors: [], sessions: [] };
+  const entries = Object.entries(registry.sessions || {}).map(([sessionId, value]) => ({ sessionId, ...value }))
+    .filter((e) => e.session_file && e.transcript_path)
+    .filter((e) => !session || e.sessionId === session || e.session_file === session);
+  for (const entry of entries) {
+    if (limit && report.scanned >= limit) break;
+    report.scanned += 1;
+    const note = join(vaultBase, entry.session_file);
+    if (!existsSync(note) || !existsSync(entry.transcript_path)) {
+      report.missing.push({ sessionId: entry.sessionId, session: entry.session_file, note: existsSync(note), transcript: existsSync(entry.transcript_path) });
+      continue;
+    }
+    const before = readFileSync(note, 'utf8');
+    try {
+      updateSessionUsage({ vaultBase, sessionRel: entry.session_file, sessionPath: note, transcriptPath: entry.transcript_path });
+      upsertSubagentUsage(note, entry.transcript_path);
+      const after = readFileSync(note, 'utf8');
+      const changed = before !== after;
+      if (changed) report.changed += 1; else report.unchanged += 1;
+      report.sessions.push({ sessionId: entry.sessionId, session: entry.session_file, transcript: entry.transcript_path, changed });
+      if (!apply && changed) writeFileSync(note, before, 'utf8');
+    } catch (error) {
+      if (!apply) writeFileSync(note, before, 'utf8');
+      report.errors.push({ sessionId: entry.sessionId, session: entry.session_file, error: error.message });
+    }
+  }
+  report.ok = report.errors.length === 0;
+  if (apply) writeFileSync(join(vaultBase, '.brain', 'COST_REBUILD.json'), `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+  return report;
+}

package/src/stats.mjs

@@ -14,7 +14,7 @@ export function statsFrom(agg) {
     sessions: agg.count,
     prompts: agg.prompts || 0,
     cost: agg.total,
-    models: (agg.byModel || []).length,
+    models: (agg.byModel || []).filter((m) => m.model !== 'subagents (legado, modelo desconhecido)').length,
     firstDay: days[0] || '',
     lastDay: days[days.length - 1] || '',
     spanDays: days.length,