wendkeep 0.36.0 → 0.38.0

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',
@@ -357,7 +366,7 @@ function parseCodexLines(lines, result) {
     const payload = event.payload || {};
 
     if (event.type === 'session_meta') {
-      result.sessionId = payload.id || result.sessionId;
+      result.sessionId = payload.session_id || payload.id || result.sessionId;
       currentProvider = normalizeProvider(payload.model_provider || currentProvider);
       currentModel = normalizeModelName(payload.model || currentModel);
       result.provider = currentProvider;
@@ -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,18 +110,19 @@ 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];
-  if (control.session_id && !registryEntry) {
-    failures.push(`SESSION_REGISTRY não possui session_id ativo: ${control.session_id}`);
-  } else if (registryEntry) {
-    if (registryEntry.session_file !== sessionRel) {
-      failures.push('SESSION_REGISTRY diverge do CURRENT_SESSION.md para a sessão ativa.');
-    }
+  const registryPair = Object.entries(registry.sessions || {}).find(([, entry]) => entry?.session_file === sessionRel);
+  const registryEntry = registryPair?.[1];
+  if (!registryEntry) {
+    failures.push(`SESSION_REGISTRY não possui a sessão: ${sessionRel}`);
+  } else {
     if (!registryEntry.transcript_path) {
       warnings.push('SESSION_REGISTRY não possui transcript_path para a sessão ativa.');
     } else if (!existsSync(registryEntry.transcript_path)) {
@@ -161,10 +164,15 @@ export function runVaultHealth({ vaultBase, session = '' }) {
   failures.push(...sessionResult.failures);
   warnings.push(...sessionResult.warnings);
 
-  const staleDone = Object.values(registry.sessions || {})
+  const staleDone = Object.values(registry.sessions || {})
     .filter((item) => item.status === 'active' && item.ended_at)
     .length;
-  if (staleDone) warnings.push(`${staleDone} entradas active com ended_at no SESSION_REGISTRY.`);
+  if (staleDone) warnings.push(`${staleDone} entradas active com ended_at no SESSION_REGISTRY.`);
+  const activeEntries = Object.values(registry.sessions || {}).filter((item) => item?.status === 'active');
+  for (const entry of activeEntries) {
+    if (!entry.session_file) failures.push('SESSION_REGISTRY possui sessão ativa sem session_file.');
+    if (!entry.transcript_path) warnings.push(`Sessão ativa sem transcript_path: ${entry.session_file || '(sem arquivo)'}`);
+  }
 
   const locF = getLocale(vaultBase).folders;
   const derivedFolders = [locF.decisions, locF.bugs, locF.learnings];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.36.0",
+  "version": "0.38.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

@@ -18,7 +18,7 @@ import {
 } from '../hooks/change-core.mjs';
 import { evaluateGate, requiredSensors } from '../hooks/sensors-core.mjs';
 import { buildEffectiveRequirementPackage, evaluateVerdict, tasksHashOf, parseSpecsList, parseDelta, parseRequirements, applyDelta, validateSpecImpact } from '../hooks/spec-core.mjs';
-import { getNextAdrNumber, readControl } from '../hooks/obsidian-common.mjs';
+import { getNextAdrNumber, readControl, readSessionRegistry, upsertSessionRegistry } from '../hooks/obsidian-common.mjs';
 import { getLocale } from '../hooks/locale.mjs';
 
 function resolveVault(argv) {
@@ -51,7 +51,7 @@ function today() {
 export function runChange(argv) {
   const [sub, ...rest] = argv;
   const vaultBase = resolveVault(rest);
-  const VALUE_FLAGS = new Set(['--vault', '--change', '--project']);
+  const VALUE_FLAGS = new Set(['--vault', '--change', '--project', '--session']);
   const slugArg = () => rest.find((a, i) => !a.startsWith('-') && !VALUE_FLAGS.has(rest[i - 1]));
 
   if (sub === 'new') {
@@ -74,6 +74,18 @@ export function runChange(argv) {
     process.exit(0);
   }
 
+  if (sub === 'bind') {
+    const slug = slugArg();
+    const sessionId = opt(rest, '--session');
+    if (!slug || !sessionId) { process.stderr.write('wendkeep change bind: use <slug> --session <id>\n'); process.exit(2); }
+    const state = allChangesState(vaultBase);
+    if (!state.changes.some((item) => item.slug === slug)) { process.stderr.write(`wendkeep change bind: open change not found: ${slug}\n`); process.exit(2); }
+    if (!readSessionRegistry(vaultBase).sessions?.[sessionId]) { process.stderr.write(`wendkeep change bind: session not found: ${sessionId}\n`); process.exit(2); }
+    upsertSessionRegistry(vaultBase, sessionId, { change_slug: slug });
+    process.stdout.write(`session ${sessionId} -> change ${slug}\n`);
+    process.exit(0);
+  }
+
   if (sub === 'continue') {
     const positionals = rest.filter((a, i) => !a.startsWith('-') && !VALUE_FLAGS.has(rest[i - 1]));
     const [archivedSlug, newSlug] = positionals;

package/src/rebuild-costs.mjs

@@ -3,27 +3,25 @@
 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);
   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) => e.session_file)
     .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) });
+    if (!entry.transcript_path || !existsSync(note) || !existsSync(entry.transcript_path)) {
+      report.missing.push({ sessionId: entry.sessionId, session: entry.session_file, note: existsSync(note), transcript: !!entry.transcript_path && existsSync(entry.transcript_path), transcriptPath: 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);
+      updateSessionObservability({ sessionPath: note, transcriptPath: entry.transcript_path, caller: 'cost-rebuild', canonicalConversationId: entry.sessionId });
       const after = readFileSync(note, 'utf8');
       const changed = before !== after;
       if (changed) report.changed += 1; else report.unchanged += 1;
@@ -34,7 +32,7 @@ export function rebuildSessionCosts(vaultBase, { apply = false, session = '', li
       report.errors.push({ sessionId: entry.sessionId, session: entry.session_file, error: error.message });
     }
   }
-  report.ok = report.errors.length === 0;
+  report.ok = report.errors.length === 0 && report.missing.length === 0;
   if (apply) writeFileSync(join(vaultBase, '.brain', 'COST_REBUILD.json'), `${JSON.stringify(report, null, 2)}\n`, 'utf8');
   return report;
 }

package/src/session.mjs

@@ -0,0 +1,37 @@
+import { isAbsolute, resolve } from 'node:path';
+import { readControl, readSessionRegistry, writeControl } from '../hooks/obsidian-common.mjs';
+
+function vaultOf(argv) {
+  const i = argv.indexOf('--vault');
+  const raw = i >= 0 ? argv[i + 1] : argv.find((a) => a.startsWith('--vault='))?.slice(8) || process.env.OBSIDIAN_VAULT_PATH;
+  if (!raw) throw new Error('pass --vault <path> or set OBSIDIAN_VAULT_PATH');
+  return isAbsolute(raw) ? raw : resolve(process.cwd(), raw);
+}
+
+function positionals(argv) {
+  return argv.filter((arg, index) => !arg.startsWith('-') && argv[index - 1] !== '--vault');
+}
+
+export function runSession(argv) {
+  const vault = vaultOf(argv);
+  const [sub, id] = positionals(argv);
+  const registry = readSessionRegistry(vault);
+  const rows = Object.entries(registry.sessions || {}).sort((a, b) => String(b[1].last_seen || '').localeCompare(String(a[1].last_seen || '')));
+  if (sub === 'list') {
+    for (const [sessionId, item] of rows) process.stdout.write(`${sessionId}\t${item.status || 'unknown'}\t${item.provider || 'unknown'}\t${item.change_slug || '-'}\t${item.session_file || '-'}\n`);
+    return;
+  }
+  const entry = registry.sessions?.[id];
+  if (!entry) throw new Error(`session not found: ${id || '(missing id)'}`);
+  if (sub === 'show') {
+    process.stdout.write(`${JSON.stringify({ session_id: id, ...entry }, null, 2)}\n`);
+    return;
+  }
+  if (sub === 'use') {
+    const control = readControl(vault);
+    writeControl(vault, { ...control, status: entry.status || 'active', session_id: id, session_file: entry.session_file || '', started_at: entry.started_at || '' });
+    process.stdout.write(`session focus: ${id}\n`);
+    return;
+  }
+  throw new Error('use: wendkeep session list | show <id> | use <id>');
+}