wendkeep 0.36.0 → 0.37.0

package/CHANGELOG.md

@@ -4,6 +4,21 @@ 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.37.0] — 2026-07-11
+
+### Added
+
+- Observabilidade consolidada em `## Agentes, tokens e custos`: Stop, SubagentStop, importação e rebuild usam um único writer atômico para main + subagents.
+- Ledger por modelo/origem com reasoning tokens e effort, sem alterar a regra de preço do modelo.
+- Novo `wendkeep cost rebuild`, dry-run por padrão; `--apply` reconstrói sessões antigas via `SESSION_REGISTRY` e grava `.brain/COST_REBUILD.json`.
+- Preços API-equivalentes de GPT-5.6 Sol, Terra e Luna.
+
+### Fixed
+
+- Custos de subagents são atribuídos ao modelo que realmente os executou, em vez do modelo principal.
+- Migração remove os headings legados sem perder reaberturas ou iterações mal posicionadas.
+- Totais combinados de tokens/custo são atualizados também no `SubagentStop` e persistidos em campos compatíveis com os dashboards existentes.
+
 ## [0.35.0] — 2026-07-11
 
 ### Fixed
@@ -870,9 +885,3 @@ 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

@@ -119,6 +119,8 @@ No re‑copying, no snapshot to re‑sync — the package is the single source o
 | `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`. |
+
+Session notes use one live `## Agentes, tokens e custos` snapshot. Main-agent and subagent hooks recompose it atomically, with costs, token dimensions, reasoning tokens and effort per model/source.
 | `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

@@ -116,6 +116,8 @@ Sem recopiar, sem snapshot pra re‑sincronizar — o pacote é a única fonte d
 | `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`. |
+
+As notas de sessão usam um único snapshot vivo `## Agentes, tokens e custos`. Os hooks do agente principal e dos subagents recompõem o bloco atomicamente, incluindo custo, dimensões de tokens, reasoning e effort por modelo/origem.
 | `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/hooks/import-sessions.mjs

@@ -16,8 +16,7 @@ import {
 } from './session-stop.mjs';
 import { buildSessionContent, allocateSessionPath } from './session-start.mjs';
 import { createLinkedNotes } from './linked-notes.mjs';
-import { updateSessionUsage } from './token-usage.mjs';
-import { upsertSubagentUsage } from './subagent-usage.mjs';
+import { updateSessionObservability } from './session-observability.mjs';
 import { readSessionRegistry, upsertSessionRegistry, formatLocalIso, formatDate, providerMeta } from './obsidian-common.mjs';
 import { getLocale } from './locale.mjs';
 import { captureProseDecisions } from './decision-capture.mjs';
@@ -211,11 +210,8 @@ export function importSession(vaultBase, txPath, opts = {}) {
 
   // Cost + subagent telemetry, exactly like the live Stop hook. Fail-open.
   try {
-    updateSessionUsage({ vaultBase, sessionRel: relPath, sessionPath: absPath, transcriptPath: txPath });
-  } catch { /* usage is best-effort */ }
-  try {
-    upsertSubagentUsage(absPath, txPath);
-  } catch { /* subagent telemetry is best-effort */ }
+    updateSessionObservability({ sessionPath: absPath, transcriptPath: txPath });
+  } catch { /* observability is best-effort */ }
 
   // Finalize: derived notes + closing section + ended_at from the last turn.
   const endedAt = formatLocalIso(endDate);

package/hooks/session-observability.mjs

@@ -0,0 +1,162 @@
+// Single atomic writer for session usage, models, reasoning/effort and subagents.
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { collectSessionUsage } from './token-usage.mjs';
+import { collectSubagentUsage, sessionDirFromTranscript } from './subagent-usage.mjs';
+
+const HEADING = '## Agentes, tokens e custos';
+const LEGACY_HEADINGS = ['## Uso de tokens e custos', '## Subagents & Workflows'];
+const fmt = (n) => Math.trunc(Number(n) || 0).toString().replace(/\B(?=(\d{3})+(?!\d))/g, '.');
+const usd = (n) => `$${(Number(n) || 0).toFixed(4)}`;
+const round4 = (n) => Math.round((Number(n) || 0) * 10000) / 10000;
+const effort = (value) => {
+  const normalized = String(value || '').trim().toLowerCase();
+  return ['none', 'low', 'medium', 'high', 'xhigh'].includes(normalized) ? normalized : (normalized || 'unknown');
+};
+const usageTotal = (u = {}) => Number(u.total || 0) || (Number(u.input || 0) + Number(u.cached || 0) + Number(u.cacheWrite || 0) + Number(u.output || 0));
+
+function setFrontmatterField(content, key, value) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return content;
+  const re = new RegExp(`^${key}:.*$`, 'm');
+  const line = `${key}: ${value}`;
+  const body = re.test(match[1]) ? match[1].replace(re, line) : `${match[1]}\n${line}`;
+  return content.replace(match[0], `---\n${body}\n---`);
+}
+
+function removeSection(content, heading, { preserveOrphanIterations = false } = {}) {
+  const start = content.indexOf(`\n${heading}`);
+  if (start < 0) return content;
+  const next = content.indexOf('\n## ', start + heading.length + 1);
+  const body = next < 0 ? content.slice(start) : content.slice(start, next);
+  const orphanAt = preserveOrphanIterations ? body.search(/\n### \d{2}:\d{2} - /) : -1;
+  const preserved = orphanAt >= 0 ? body.slice(orphanAt).trim() : '';
+  const rest = next < 0 ? '' : content.slice(next + 1).trimStart();
+  return [content.slice(0, start).trimEnd(), preserved, rest].filter(Boolean).join('\n\n').trimEnd() + '\n';
+}
+
+export function upsertObservabilitySection(content, section) {
+  let base = content;
+  base = removeSection(base, HEADING);
+  base = removeSection(base, LEGACY_HEADINGS[0], { preserveOrphanIterations: true });
+  base = removeSection(base, LEGACY_HEADINGS[1]);
+  const anchors = ['\n## Pendências', '\n## Issues Linear', '\n## Encerramento'];
+  const indexes = anchors.map((a) => base.indexOf(a)).filter((i) => i >= 0).sort((a, b) => a - b);
+  if (!indexes.length) return `${base.trimEnd()}\n\n${section.trimEnd()}\n`;
+  const at = indexes[0];
+  return `${base.slice(0, at).trimEnd()}\n\n${section.trimEnd()}\n\n${base.slice(at).trimStart()}`;
+}
+
+function mainLedger(main) {
+  return (main.summary.modelRows || []).map((row) => ({
+    provider: row.provider || 'unknown', model: row.model || 'unknown', source: 'main',
+    effort: effort(main.summary.pensamento), calls: row.calls || 0,
+    input: row.usage.input || 0, cacheWrite: row.usage.cacheWrite || 0, cached: row.usage.cached || 0,
+    output: row.usage.output || 0, reasoning: row.usage.reasoning || 0, total: usageTotal(row.usage),
+    cost: round4(row.costs?.model || 0),
+  }));
+}
+
+function subagentLedger(collected) {
+  return (collected?.aggregate.modelRows || []).map((row) => ({
+    provider: row.provider || 'unknown', model: row.model || 'unknown', source: 'subagent',
+    effort: effort(row.effort), calls: row.calls || 0,
+    input: row.usage?.input || 0, cacheWrite: row.usage?.cacheWrite || 0, cached: row.usage?.cached || 0,
+    output: row.usage?.output || 0, reasoning: row.usage?.reasoning || 0, total: usageTotal(row.usage || row),
+    cost: round4(row.cost || 0),
+  }));
+}
+
+function renderLedger(rows) {
+  if (!rows.length) return 'Nenhum modelo registrado.';
+  return ['| Modelo | Provider | Origem | Effort | Chamadas | Input | Cache W | Cache R | Output | Reasoning | Total | Custo |',
+    '|---|---|---|---|---:|---:|---:|---:|---:|---:|---:|---:|',
+    ...rows.map((r) => `| ${r.model} | ${r.provider} | ${r.source} | ${r.effort} | ${fmt(r.calls)} | ${fmt(r.input)} | ${fmt(r.cacheWrite)} | ${fmt(r.cached)} | ${fmt(r.output)} | ${fmt(r.reasoning)} | ${fmt(r.total)} | ${usd(r.cost)} |`),
+  ].join('\n');
+}
+
+function renderHistory(entries) {
+  if (!entries.length) return 'Nenhuma reabertura registrada.';
+  return ['| Transcript | Modelo(s) | Effort | Input | Cache W | Cache R | Output | Reasoning | Total | Custo | Atualizado |',
+    '|---|---|---|---:|---:|---:|---:|---:|---:|---:|---|',
+    ...entries.map((e) => `| ${String(e.transcript_id).slice(0, 12)}… | ${(e.modelos || []).join(' + ')} | ${effort(e.pensamento)} | ${fmt(e.input)} | ${fmt(e.cache_write)} | ${fmt(e.cache_read)} | ${fmt(e.output)} | ${fmt(e.reasoning)} | ${fmt(e.total)} | ${usd(e.custo_usd)} | ${e.atualizado_em || ''} |`),
+  ].join('\n');
+}
+
+function renderSubagents(collected) {
+  if (!collected) return '### Subagents e workflows\n\nNenhum subagent registrado.';
+  const a = collected.aggregate;
+  const workflows = collected.workflows.length
+    ? collected.workflows.map((w) => `${w.name} (${w.runId}${w.status ? ` · ${w.status}` : ''} · ${w.agents} agentes · ${usd(w.cost)})`).join('; ')
+    : '(nenhum)';
+  const rows = collected.subagents.map((s) => `| ${s.id} | ${s.agentType || '-'} | ${s.workflow || '-'} | ${s.model} | ${effort(s.effort)} | ${s.tools} | ${fmt(s.tokens)} | ${usd(s.cost)} |`).join('\n');
+  return `### Subagents e workflows
+
+- **Subagents:** ${a.count} · ${a.calls} chamadas · ${fmt(a.tokens)} tokens · ${usd(a.cost)}
+- **Workflows:** ${workflows}
+- **Tools:** ${(a.tools || []).join(', ') || '(nenhuma)'}${a.wasted ? `\n- **Desperdiçado:** ${usd(a.wasted)}` : ''}
+
+#### Por subagent (${a.count})
+
+| Agent | Tipo | Workflow | Modelo | Effort | Tools | Tokens | Custo |
+|---|---|---|---|---|---:|---:|---:|
+${rows}`;
+}
+
+export function renderSessionObservability(snapshot) {
+  const { main, subagents, ledger } = snapshot;
+  const sub = subagents?.aggregate || { count: 0, tokens: 0, cost: 0 };
+  const combinedTokens = main.aggregate.total + sub.tokens;
+  const combinedCost = round4(main.aggregate.custo + sub.cost);
+  return `${HEADING}
+
+> Estimativa API-equivalente baseada nos transcripts locais. Reasoning e effort são observacionais e não acrescentam tarifa separada.
+
+| Métrica | Principal | Subagents | Total |
+|---|---:|---:|---:|
+| Chamadas com uso | ${fmt(main.aggregate.calls)} | ${fmt(sub.calls)} | ${fmt(main.aggregate.calls + (sub.calls || 0))} |
+| Input tokens | ${fmt(main.aggregate.input)} | ${fmt(sub.usage?.input)} | ${fmt(main.aggregate.input + (sub.usage?.input || 0))} |
+| Cache write | ${fmt(main.aggregate.cacheWrite)} | ${fmt(sub.usage?.cacheWrite)} | ${fmt(main.aggregate.cacheWrite + (sub.usage?.cacheWrite || 0))} |
+| Cache read | ${fmt(main.aggregate.cached)} | ${fmt(sub.usage?.cached)} | ${fmt(main.aggregate.cached + (sub.usage?.cached || 0))} |
+| Output tokens | ${fmt(main.aggregate.output)} | ${fmt(sub.usage?.output)} | ${fmt(main.aggregate.output + (sub.usage?.output || 0))} |
+| Reasoning tokens | ${fmt(main.aggregate.reasoning)} | ${fmt(sub.usage?.reasoning)} | ${fmt(main.aggregate.reasoning + (sub.usage?.reasoning || 0))} |
+| Total tokens | ${fmt(main.aggregate.total)} | ${fmt(sub.tokens)} | ${fmt(combinedTokens)} |
+| Custo estimado | ${usd(main.aggregate.custo)} | ${usd(sub.cost)} | ${usd(combinedCost)} |
+
+### Por modelo e origem
+
+${renderLedger(ledger)}
+
+### Por reabertura
+
+${renderHistory(main.entries)}
+
+${renderSubagents(subagents)}`;
+}
+
+export function buildSessionObservability({ sessionContent, transcriptPath }) {
+  const main = collectSessionUsage({ sessionContent, transcriptPath });
+  if (!main) return null;
+  const subagents = collectSubagentUsage(sessionDirFromTranscript(transcriptPath));
+  const ledger = [...mainLedger(main), ...subagentLedger(subagents)];
+  const sub = subagents?.aggregate || { count: 0, tokens: 0, cost: 0, wasted: 0, tools: [] };
+  let content = main.content;
+  content = setFrontmatterField(content, 'subagents_count', sub.count || 0);
+  content = setFrontmatterField(content, 'subagents_tokens_total', sub.tokens || 0);
+  content = setFrontmatterField(content, 'subagents_custo_usd', sub.cost || 0);
+  content = setFrontmatterField(content, 'subagents_tools', `"${(sub.tools || []).join(', ')}"`);
+  content = setFrontmatterField(content, 'subagents_wasted_usd', sub.wasted || 0);
+  content = setFrontmatterField(content, 'tokens_total_incl_subagents', main.aggregate.total + (sub.tokens || 0));
+  content = setFrontmatterField(content, 'custo_total_incl_subagents_usd', round4(main.aggregate.custo + (sub.cost || 0)));
+  content = setFrontmatterField(content, 'observability_schema', 1);
+  content = setFrontmatterField(content, 'custo_por_modelo_json', `'${JSON.stringify(ledger).replaceAll("'", "''")}'`);
+  const snapshot = { version: 1, main, subagents, ledger };
+  return { snapshot, content: upsertObservabilitySection(content, renderSessionObservability(snapshot)) };
+}
+
+export function updateSessionObservability({ sessionPath, transcriptPath }) {
+  if (!sessionPath || !existsSync(sessionPath)) return null;
+  const result = buildSessionObservability({ sessionContent: readFileSync(sessionPath, 'utf8'), transcriptPath });
+  if (!result) return null;
+  writeFileSync(sessionPath, result.content, 'utf8');
+  return result.snapshot;
+}

package/hooks/session-stop.mjs

@@ -4,11 +4,11 @@ import { join } from 'path';
 import { request } from 'http';
 import { pathToFileURL } from 'url';
 import { createLinkedNotes } from './linked-notes.mjs';
-import { addUsage, costBreakdown, emptyTokenUsage, normalizeClaudeUsage, normalizeCodexUsage, priceForModel, updateSessionUsage } from './token-usage.mjs';
+import { addUsage, costBreakdown, emptyTokenUsage, normalizeClaudeUsage, normalizeCodexUsage, priceForModel } from './token-usage.mjs';
 import { buildBrainDigest, buildBrainIndex } from './brain-core.mjs';
 import { activeChangeLink, pruneChangeSentinels } from './change-core.mjs';
 import { getLocale } from './locale.mjs';
-import { upsertSubagentUsage } from './subagent-usage.mjs';
+import { updateSessionObservability } from './session-observability.mjs';
 import {
   ensureDir,
   findActiveSessionByTranscript,
@@ -704,8 +704,9 @@ function applyDedicatedSections(content, tx) {
 function insertIntoIteracoes(content, block) {
   const iter = content.indexOf('\n## Iterações');
   if (iter !== -1) {
-    const anchors = [
-      '\n## Uso de tokens e custos',
+    const anchors = [
+      '\n## Agentes, tokens e custos',
+      '\n## Uso de tokens e custos',
       '\n## Decisões geradas nesta sessão',
       '\n## Bugs gerados nesta sessão',
       '\n## Aprendizados gerados nesta sessão',
@@ -855,7 +856,7 @@ function replacePendingSection(content, pending) {
   const end = content.indexOf(closingMarker, start + marker.length);
   if (end === -1) return content;
 
-  // Preserva seções que outros writers inseriram dentro do span (## Subagents & Workflows,
+  // Preserva seções que outros writers inseriram dentro do span (observabilidade,
   // ## Progresso do plano, ## Mudanças…) — só o texto das Pendências em si é regenerado.
   const span = content.slice(start + marker.length, end);
   const innerIdx = span.indexOf('\n## ');
@@ -1053,24 +1054,11 @@ function main() {
   }
 
   try {
-    updateSessionUsage({
-      vaultBase,
-      sessionRel,
-      sessionPath,
-      transcriptPath,
-    });
+    updateSessionObservability({ sessionPath, transcriptPath });
   } catch (error) {
     process.stderr.write(`[wendkeep] Token usage falhou: ${error.message}\n`);
   }
 
-  // Subagent/workflow telemetry (0.10.0): fold sibling subagent transcripts into the note.
-  // Provider-gated by structure + fail-open — never derruba o Stop.
-  try {
-    upsertSubagentUsage(sessionPath, transcriptPath);
-  } catch (error) {
-    process.stderr.write(`[wendkeep] Subagent usage falhou: ${error.message}\n`);
-  }
-
   if (!shouldFinalizeSession()) {
     writeControl(vaultBase, {
       ...control,

package/hooks/subagent-stop.mjs

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 // SubagentStop hook: refresh this session's subagent/workflow telemetry the MOMENT a subagent
-// finishes — not only at the main Stop. Resilience: a session that never reaches Stop (crash,
-// window closed) still gets its subagent cost notes. Reuses the same upsertSubagentUsage the Stop
-// hook runs, so the output is identical; it just runs earlier + incrementally. Fail-open.
+// finishes — not only at the main Stop. It recomposes the complete main + subagent snapshot
+// through the same atomic writer used by Stop/import/rebuild. Fail-open.
 //
 // Model choice for subagents stays the harness's job (agent frontmatter `model:` / the Task/
 // workflow `model` param). wendkeep OBSERVES (this telemetry) rather than dictating a routing rule.
@@ -10,7 +9,7 @@ import { existsSync } from 'fs';
 import { join } from 'path';
 import { pathToFileURL } from 'url';
 import { readHookInput, writeHookOutput, getVaultBase, findActiveSessionByTranscript, readControl } from './obsidian-common.mjs';
-import { upsertSubagentUsage } from './subagent-usage.mjs';
+import { updateSessionObservability } from './session-observability.mjs';
 
 export function refreshSubagents(vaultBase, input) {
   const transcriptPath = input.transcript_path || input.transcriptPath || '';
@@ -19,7 +18,7 @@ export function refreshSubagents(vaultBase, input) {
   if (!sessionRel) return false;
   const sessionPath = join(vaultBase, sessionRel);
   if (!existsSync(sessionPath)) return false;
-  upsertSubagentUsage(sessionPath, transcriptPath);
+  updateSessionObservability({ sessionPath, transcriptPath });
   return true;
 }
 

package/hooks/subagent-usage.mjs

@@ -69,7 +69,7 @@ function readWorkflowRuns(sessionDir) {
 }
 
 function tokensTotal(t = {}) {
-  return (t.input || 0) + (t.cached || 0) + (t.cacheWrite || 0) + (t.output || 0);
+  return Number(t.total || 0) || ((t.input || 0) + (t.cached || 0) + (t.cacheWrite || 0) + (t.output || 0));
 }
 
 const round4 = (n) => Math.round((Number(n) || 0) * 10000) / 10000;
@@ -87,7 +87,7 @@ export function collectSubagentUsage(sessionDir) {
   const subagents = [];
   const wf = {};
   const allTools = new Set();
-  const usageAgg = { input: 0, cached: 0, cacheWrite: 0, output: 0 };
+  const usageAgg = { input: 0, cached: 0, cacheWrite: 0, output: 0, reasoning: 0, total: 0 };
   let count = 0;
   let calls = 0;
   let cost = 0;
@@ -108,6 +108,7 @@ export function collectSubagentUsage(sessionDir) {
       agentType,
       workflow,
       model: summary.models[0] || '?',
+      effort: summary.pensamento || '',
       tools: summary.tools.length,
       toolNames: summary.tools,
       calls: summary.calls,
@@ -117,11 +118,14 @@ export function collectSubagentUsage(sessionDir) {
     });
 
     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 };
+      const rowEffort = summary.pensamento || '';
+      const key = `${row.provider || '?'}\u0000${row.model || '?'}\u0000${rowEffort}`;
+      const current = modelMap.get(key) || { provider: row.provider || '?', model: row.model || '?', effort: rowEffort, calls: 0, tokens: 0, cost: 0,
+        usage: { input: 0, cached: 0, cacheWrite: 0, output: 0, reasoning: 0, total: 0 } };
       current.calls += row.calls || 0;
       current.tokens += tokensTotal(row.usage);
       current.cost += row.costs?.model || 0;
+      for (const k of Object.keys(current.usage)) current.usage[k] += row.usage?.[k] || 0;
       modelMap.set(key, current);
     }
 

package/hooks/token-usage.mjs

@@ -153,7 +153,16 @@ const MANAGED_FRONTMATTER_KEYS = new Set([
   'custo_modelo_label',
   'custo_modelo_usd',
   'custo_por_modelo',
-  'usage_por_transcript',
+  'usage_por_transcript',
+  'subagents_count',
+  'subagents_tokens_total',
+  'subagents_custo_usd',
+  'subagents_tools',
+  'subagents_wasted_usd',
+  'tokens_total_incl_subagents',
+  'custo_total_incl_subagents_usd',
+  'observability_schema',
+  'custo_por_modelo_json',
   // Legado: chaves antigas removidas ao reprocessar a sessão.
   'custo_estimado_gpt55_usd',
   'custo_estimado_opus47_usd',
@@ -442,8 +451,9 @@ function parseClaudeLines(lines, result) {
   result.provider = 'anthropic';
   const seenUsage = new Set();
   const seenTools = new Set();
-  const seenThinking = new Set();
-  let thinkingChars = 0;
+  const seenThinking = new Set();
+  let thinkingChars = 0;
+  const thinkingCharsByModel = new Map();
   let latestPrompt = '';
 
   for (const line of lines) {
@@ -476,8 +486,9 @@ function parseClaudeLines(lines, result) {
       if (block?.type === 'thinking' && block.thinking) {
         const thinkKey = `${msg.id || ''}:${block.thinking.slice(0, 60)}`;
         if (!seenThinking.has(thinkKey)) {
-          seenThinking.add(thinkKey);
-          thinkingChars += block.thinking.length;
+          seenThinking.add(thinkKey);
+          thinkingChars += block.thinking.length;
+          thinkingCharsByModel.set(model, (thinkingCharsByModel.get(model) || 0) + block.thinking.length);
         }
       }
     }
@@ -502,10 +513,14 @@ function parseClaudeLines(lines, result) {
   // Thinking estimado: ~3,5 chars por token. Distribuído no total como informação à parte
   // (já contido em output_tokens — não somar de novo).
   const thinkingTokens = Math.round(thinkingChars / 3.5);
-  if (thinkingTokens > 0) {
-    result.totals.reasoning = thinkingTokens;
-    result.pensamento = `thinking ~${formatTokensShort(thinkingTokens)}`;
-  }
+  if (thinkingTokens > 0) {
+    result.totals.reasoning = thinkingTokens;
+    result.pensamento = `thinking ~${formatTokensShort(thinkingTokens)}`;
+    for (const [model, chars] of thinkingCharsByModel) {
+      const entry = result.byModel.get(`anthropic:${model}`);
+      if (entry) entry.usage.reasoning = Math.round(chars / 3.5);
+    }
+  }
 
   return result;
 }
@@ -896,40 +911,52 @@ function legacyEntryFromNote(content, summary) {
   };
 }
 
-export function updateSessionUsage({ vaultBase, sessionRel, sessionPath, transcriptPath }) {
-  if (!sessionPath || !existsSync(sessionPath) || !transcriptPath || !existsSync(transcriptPath)) {
-    return null;
-  }
+export function collectSessionUsage({ sessionContent, transcriptPath }) {
+  if (!transcriptPath || !existsSync(transcriptPath)) {
+    return null;
+  }
 
   const parsed = parseTokenUsageFromTranscript(transcriptPath);
   const summary = summarizeTokenUsage(parsed);
   if (!summary.calls) return null;
 
-  const sessionContent = readFileSync(sessionPath, 'utf-8');
-  const fmMatch = sessionContent.match(/^---\n([\s\S]*?)\n---/);
+  const fmMatch = sessionContent.match(/^---\n([\s\S]*?)\n---/);
   const existingEntries = fmMatch ? parseUsageHistory(fmMatch[1]) : [];
 
-  const transcriptId = transcriptIdFromPath(transcriptPath);
-  let entries = existingEntries.filter((e) => e.transcript_id !== transcriptId);
+  const transcriptId = transcriptIdFromPath(transcriptPath);
+  const previous = existingEntries.find((entry) => entry.transcript_id === transcriptId);
+  const current = entryFromSummary(summary, transcriptId);
+  if (previous) {
+    const comparable = (entry) => JSON.stringify({ ...entry, atualizado_em: undefined });
+    if (comparable(previous) === comparable(current)) current.atualizado_em = previous.atualizado_em;
+  }
+  let entries = existingEntries.filter((e) => e.transcript_id !== transcriptId);
 
   if (!existingEntries.length) {
     const legacy = legacyEntryFromNote(sessionContent, summary);
     if (legacy) entries.push(legacy);
   }
 
-  entries.push(entryFromSummary(summary, transcriptId));
-
-  const agg = aggregateEntries(entries);
-  const withFrontmatter = upsertSessionFrontmatter(sessionContent, agg, entries);
-  const withSection = upsertUsageSection(withFrontmatter, buildUsageSection(agg, entries, summary));
-  writeFileSync(sessionPath, withSection, 'utf-8');
-
-  return {
-    summary,
-    aggregate: agg,
-    entries,
-  };
-}
+  entries.push(current);
+
+  const agg = aggregateEntries(entries);
+  const withFrontmatter = upsertSessionFrontmatter(sessionContent, agg, entries);
+  return {
+    summary,
+    aggregate: agg,
+    entries,
+    content: withFrontmatter,
+  };
+}
+
+export function updateSessionUsage({ vaultBase, sessionRel, sessionPath, transcriptPath }) {
+  if (!sessionPath || !existsSync(sessionPath)) return null;
+  const result = collectSessionUsage({ sessionContent: readFileSync(sessionPath, 'utf-8'), transcriptPath });
+  if (!result) return null;
+  const withSection = upsertUsageSection(result.content, buildUsageSection(result.aggregate, result.entries, result.summary));
+  writeFileSync(sessionPath, withSection, 'utf-8');
+  return result;
+}
 
 function parseCliArgs(argv) {
   const args = {};

package/hooks/vault-health.mjs

@@ -72,7 +72,9 @@ function hasDefaultPending(content) {
 }
 
 function usageSectionIsPlaced(content, { active = false } = {}) {
-  const usage = content.indexOf('\n## Uso de tokens e custos');
+  const unified = content.indexOf('\n## Agentes, tokens e custos');
+  const legacy = content.indexOf('\n## Uso de tokens e custos');
+  const usage = unified !== -1 ? unified : legacy;
   if (usage === -1) return true;
   const changed = content.indexOf('\n## Arquivos criados ou alterados');
   const pending = content.indexOf('\n## Pendências');
@@ -108,9 +110,12 @@ function checkSession({ vaultBase, sessionRel, control, registry }) {
   metrics.turnMarkers = (content.match(/<!-- (?:wk-turn|codex-turn):/g) || []).length;
   metrics.duplicateTurnMarkers = duplicates.length;
 
-  if (duplicates.length) failures.push(`Marcadores de turno duplicados: ${duplicates.join(', ')}`);
-  if (hasHeadingAfterClosing(content)) failures.push('Há headings/iterações após ## Encerramento.');
-  if (!usageSectionIsPlaced(content, { active: activeSession })) failures.push('## Uso de tokens e custos está fora da posição esperada.');
+  if (duplicates.length) failures.push(`Marcadores de turno duplicados: ${duplicates.join(', ')}`);
+  if (hasHeadingAfterClosing(content)) failures.push('Há headings/iterações após ## Encerramento.');
+  if (!usageSectionIsPlaced(content, { active: activeSession })) failures.push('A seção de agentes, tokens e custos está fora da posição esperada.');
+  if (content.includes('\n## Agentes, tokens e custos') && (content.includes('\n## Uso de tokens e custos') || content.includes('\n## Subagents & Workflows'))) {
+    failures.push('A sessão mistura observabilidade consolidada e seções legadas.');
+  }
   if (hasDefaultPending(content)) warnings.push('Pendências ainda contém placeholders padrão.');
 
   const registryEntry = registry.sessions?.[control.session_id];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.36.0",
+  "version": "0.37.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/rebuild-costs.mjs

@@ -3,8 +3,7 @@
 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';
+import { updateSessionObservability } from '../hooks/session-observability.mjs';
 
 export function rebuildSessionCosts(vaultBase, { apply = false, session = '', limit = 0 } = {}) {
   const registry = readSessionRegistry(vaultBase);
@@ -22,8 +21,7 @@ export function rebuildSessionCosts(vaultBase, { apply = false, session = '', li
     }
     const before = readFileSync(note, 'utf8');
     try {
-      updateSessionUsage({ vaultBase, sessionRel: entry.session_file, sessionPath: note, transcriptPath: entry.transcript_path });
-      upsertSubagentUsage(note, entry.transcript_path);
+      updateSessionObservability({ sessionPath: note, transcriptPath: entry.transcript_path });
       const after = readFileSync(note, 'utf8');
       const changed = before !== after;
       if (changed) report.changed += 1; else report.unchanged += 1;