wendkeep 0.36.0 → 0.38.0

package/hooks/session-identity.mjs

@@ -0,0 +1,75 @@
+import { existsSync, readFileSync } from 'fs';
+import { basename } from 'path';
+import { detectProvider, readSessionRegistry, transcriptsMatch } from './obsidian-common.mjs';
+
+function parseLines(path) {
+  if (!path || !existsSync(path)) return [];
+  return readFileSync(path, 'utf-8').split('\n').filter(Boolean).map((line) => {
+    try { return JSON.parse(line); } catch { return null; }
+  }).filter(Boolean);
+}
+
+export function inspectTranscriptIdentity(transcriptPath) {
+  const lines = parseLines(transcriptPath);
+  const codexMeta = lines.find((event) => event.type === 'session_meta')?.payload;
+  if (codexMeta) {
+    return {
+      transcriptProvider: 'openai',
+      provider: 'codex',
+      canonicalConversationId: codexMeta.session_id || codexMeta.id || '',
+      transcriptId: codexMeta.id || basename(transcriptPath, '.jsonl'),
+      parentConversationId: codexMeta.parent_thread_id || codexMeta.forked_from_id || '',
+    };
+  }
+  const claudeEvent = lines.find((event) => event.sessionId);
+  if (claudeEvent) {
+    return {
+      transcriptProvider: 'anthropic',
+      provider: 'claude',
+      canonicalConversationId: claudeEvent.sessionId,
+      transcriptId: basename(transcriptPath, '.jsonl'),
+      parentConversationId: '',
+    };
+  }
+  return { transcriptProvider: 'unknown', provider: 'unknown', canonicalConversationId: '', transcriptId: '', parentConversationId: '' };
+}
+
+function compatible(provider, transcriptProvider) {
+  return (provider === 'codex' && transcriptProvider === 'openai')
+    || (provider === 'claude' && transcriptProvider === 'anthropic');
+}
+
+export function resolveSessionIdentity(vaultBase, input = {}, provider = detectProvider()) {
+  const transcriptPath = input.transcript_path || input.transcriptPath || '';
+  const inspected = inspectTranscriptIdentity(transcriptPath);
+  const hookId = input.session_id || input.sessionId || '';
+  if (!transcriptPath || !inspected.canonicalConversationId) {
+    return { state: 'deferred', provider, transcriptPath, diagnostics: ['transcript ausente ou sem identidade canônica'] };
+  }
+  if (!compatible(provider, inspected.transcriptProvider)) {
+    return { state: 'deferred', provider, transcriptPath, diagnostics: [`provider ${provider} incompatível com transcript ${inspected.transcriptProvider}`] };
+  }
+
+  const registry = readSessionRegistry(vaultBase);
+  const byTranscript = Object.entries(registry.sessions || {}).find(([, entry]) => {
+    const paths = [...(Array.isArray(entry?.transcript_paths) ? entry.transcript_paths : []), entry?.transcript_path].filter(Boolean);
+    return paths.some((path) => transcriptsMatch(path, transcriptPath));
+  });
+  const canonicalConversationId = byTranscript?.[0] || inspected.canonicalConversationId;
+  return {
+    state: 'resolved',
+    provider,
+    canonicalConversationId,
+    hookSessionId: hookId,
+    transcriptPath,
+    transcriptId: inspected.transcriptId,
+    parentConversationId: inspected.parentConversationId,
+    diagnostics: [],
+  };
+}
+
+export function resolveSessionEntry(vaultBase, input = {}, provider = detectProvider()) {
+  const identity = resolveSessionIdentity(vaultBase, input, provider);
+  if (identity.state !== 'resolved') return { identity, entry: null };
+  return { identity, entry: readSessionRegistry(vaultBase).sessions?.[identity.canonicalConversationId] || null };
+}

package/hooks/session-observability.mjs

@@ -0,0 +1,176 @@
+// 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';
+import { inspectTranscriptIdentity } from './session-identity.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, caller = 'unknown', canonicalConversationId = '' }) {
+  if (!sessionPath || !existsSync(sessionPath)) return null;
+  const sessionContent = readFileSync(sessionPath, 'utf8');
+  const noteProvider = sessionContent.match(/^provider:\s*"?([^"\n]+)"?/m)?.[1]?.trim() || 'unknown';
+  const identity = inspectTranscriptIdentity(transcriptPath);
+  if ((noteProvider === 'codex' && identity.transcriptProvider !== 'openai')
+    || (noteProvider === 'claude' && identity.transcriptProvider !== 'anthropic')) {
+    throw new Error(`observability provider mismatch: note=${noteProvider}, transcript=${identity.transcriptProvider}`);
+  }
+  let annotated = setFrontmatterField(sessionContent, 'observability_caller', `"${caller}"`);
+  annotated = setFrontmatterField(annotated, 'observability_session_id', `"${canonicalConversationId || identity.canonicalConversationId || ''}"`);
+  annotated = setFrontmatterField(annotated, 'observability_transcript_id', `"${identity.transcriptId || ''}"`);
+  if (!/^observability_updated_at:/m.test(annotated)) {
+    annotated = setFrontmatterField(annotated, 'observability_updated_at', `"${new Date().toISOString()}"`);
+  }
+  const result = buildSessionObservability({ sessionContent: annotated, transcriptPath });
+  if (!result) return null;
+  writeFileSync(sessionPath, result.content, 'utf8');
+  return result.snapshot;
+}

package/hooks/session-start.mjs

@@ -29,7 +29,8 @@ import {
   writeControl,
   writeHookOutput,
   yamlQuote,
-} from './obsidian-common.mjs';
+} from './obsidian-common.mjs';
+import { resolveSessionIdentity } from './session-identity.mjs';
 
 export function buildSessionContent({ relPath, now, summary = 'session', provider: providerId, sessionId = '' }) {
   const date = formatDate(now);
@@ -150,16 +151,29 @@ function buildAdditionalContext({ relPath, startedAt, vaultBase }) {
 
 function main() {
   const input = readHookInput();
-  const vaultBase = getVaultBase(input);
-  warnIfDefaultVault(input);
-  const now = new Date();
-  const sessionId = input.session_id || input.sessionId || '';
-  const control = readControl(vaultBase);
+  const vaultBase = getVaultBase(input);
+  warnIfDefaultVault(input);
+  const now = new Date();
+  const provider = providerMeta();
+  const identity = resolveSessionIdentity(vaultBase, input, provider.id);
+  if (identity.state !== 'resolved') {
+    writeHookOutput({
+      hookSpecificOutput: {
+        hookEventName: 'SessionStart',
+        additionalContext: `<obsidian_session_deferred>Memória global disponível, mas nenhuma escrita de sessão foi feita: ${identity.diagnostics.join('; ')}.</obsidian_session_deferred>`,
+      },
+      systemMessage: `[wendkeep] Identidade de sessão adiada: ${identity.diagnostics.join('; ')}`,
+    });
+    return;
+  }
+  const sessionId = identity.canonicalConversationId;
+  const transcriptPath = identity.transcriptPath;
+  const control = readControl(vaultBase);
 
   // Fecha sessões `active` órfãs (sem evento de fim — janela fechada/crash) antes
   // de seguir. Preserva a deste transcript: pode ser reaproveitada logo abaixo.
   try {
-    sweepStaleSessionsFile(vaultBase, now, undefined, input.transcript_path || input.transcriptPath || '');
+    sweepStaleSessionsFile(vaultBase, now, undefined, transcriptPath);
   } catch (error) {
     process.stderr.write(`[wendkeep] sweep de sessões falhou: ${error.message}\n`);
   }
@@ -172,12 +186,15 @@ function main() {
   if (control.status === 'active' && control.session_file && control.session_id === sessionId) {
     const activePath = join(vaultBase, control.session_file);
     if (existsSync(activePath)) {
-      upsertSessionRegistry(vaultBase, sessionId, {
+      upsertSessionRegistry(vaultBase, sessionId, {
         session_file: control.session_file,
         status: 'active',
         started_at: control.started_at,
-        ended_at: '',
-      });
+        ended_at: '',
+        provider: provider.id,
+        transcript_path: transcriptPath,
+        transcript_id: identity.transcriptId,
+      });
       writeHookOutput({
         hookSpecificOutput: {
           hookEventName: 'SessionStart',
@@ -220,7 +237,9 @@ function main() {
         status: 'active',
         started_at: startedAt,
         ended_at: '',
-        transcript_path: input.transcript_path || input.transcriptPath || known.transcript_path || '',
+        transcript_path: transcriptPath || known.transcript_path || '',
+        transcript_id: identity.transcriptId,
+        provider: provider.id,
       });
       writeHookOutput({
         hookSpecificOutput: {
@@ -235,8 +254,7 @@ function main() {
   // Re-init da conversa (compactação/resume) traz um session_id novo e cai fora
   // da janela de reuso; o transcript continua o mesmo. Reaproveita a sessão ativa
   // desse transcript em vez de criar um placeholder `HH-MM-codex`.
-  const transcriptPath = input.transcript_path || input.transcriptPath || '';
-  if (transcriptPath) {
+  if (transcriptPath) {
     const match = findActiveSessionByTranscript(vaultBase, transcriptPath);
     if (match) {
       // fail-safe: a nota do registro pode ter sumido do disco (git stash/checkout/
@@ -262,7 +280,9 @@ function main() {
         status: 'active',
         started_at: startedAt,
         ended_at: '',
-        transcript_path: transcriptPath,
+        transcript_path: transcriptPath,
+        transcript_id: identity.transcriptId,
+        provider: provider.id,
       });
       writeHookOutput({
         hookSpecificOutput: {
@@ -277,7 +297,7 @@ function main() {
   const summary = sessionSummaryFromInput(input);
   const { absPath, relPath } = allocateSessionPath(vaultBase, now, summary);
   const startedAt = formatLocalIso(now);
-  writeFileSync(absPath, buildSessionContent({ relPath, now, summary, sessionId }), 'utf-8');
+  writeFileSync(absPath, buildSessionContent({ relPath, now, summary, sessionId, provider: provider.id }), 'utf-8');
   writeControl(vaultBase, {
     status: 'active',
     session_file: relPath,
@@ -289,8 +309,11 @@ function main() {
     session_file: relPath,
     status: 'active',
     started_at: startedAt,
-    ended_at: '',
-  });
+    ended_at: '',
+    provider: provider.id,
+    transcript_path: transcriptPath,
+    transcript_id: identity.transcriptId,
+  });
 
   writeHookOutput({
     hookSpecificOutput: {
@@ -298,7 +321,7 @@ function main() {
       additionalContext: buildAdditionalContext({ relPath, startedAt, vaultBase }),
     },
     systemMessage: [
-      `Sessão ${providerMeta().label} criada em ${relPath}.`,
+      `Sessão ${provider.label} criada em ${relPath}.`,
       `${basename(controlPath(vaultBase))} atualizado.`,
       'Iterações devem ser anexadas, nunca sobrescritas.',
     ].join(' '),

package/hooks/session-stop.mjs

@@ -4,11 +4,12 @@ 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 { resolveSessionEntry } from './session-identity.mjs';
 import {
   ensureDir,
   findActiveSessionByTranscript,
@@ -704,8 +705,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 +857,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## ');
@@ -1021,15 +1023,20 @@ function main() {
 
   const vaultBase = getVaultBase(input);
   warnIfDefaultVault(input);
-  const control = readControl(vaultBase);
-  const transcriptPath = input.transcript_path || input.transcriptPath || '';
+  const control = readControl(vaultBase);
+  const transcriptPath = input.transcript_path || input.transcriptPath || '';
+  const { identity, entry } = resolveSessionEntry(vaultBase, input);
+  if (identity.state !== 'resolved' || !entry?.session_file) {
+    process.stderr.write(`[wendkeep] Stop sem identidade segura: ${identity.diagnostics?.join('; ') || 'sessão não registrada'}\n`);
+    writeHookOutput({});
+    return;
+  }
 
   // Roteia o turn pela sessão DO PRÓPRIO transcript (registry), não pelo
   // CURRENT_SESSION global — que sessões concorrentes sobrescrevem, fazendo
   // o turn cair na nota de outra conversa. Sem match por transcript NÃO caímos
   // no global (contaminaria nota alheia): pulamos e o backfill recupera depois.
-  const matched = transcriptPath ? findActiveSessionByTranscript(vaultBase, transcriptPath) : null;
-  const sessionRel = matched?.session_file || '';
+  const sessionRel = entry.session_file;
   if (!sessionRel) {
     writeHookOutput({});
     return;
@@ -1043,7 +1050,7 @@ function main() {
 
   const tx = parseTranscript(input.transcript_path || input.transcriptPath);
   const turnId = input.turn_id || tx.latestTurnId || String(Date.now());
-  const sessionId = matched?.sessionId || control.session_id || tx.sessionId;
+  const sessionId = identity.canonicalConversationId;
   const logged = insertIteration(sessionPath, buildIterationBlock(tx, input), turnId, tx);
 
   try {
@@ -1053,24 +1060,11 @@ function main() {
   }
 
   try {
-    updateSessionUsage({
-      vaultBase,
-      sessionRel,
-      sessionPath,
-      transcriptPath,
-    });
+    updateSessionObservability({ sessionPath, transcriptPath, caller: 'stop', canonicalConversationId: sessionId });
   } 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,
@@ -1088,7 +1082,9 @@ function main() {
       // started_at de sessões concorrentes que sobrescrevem o ponteiro global.
       ended_at: '',
       last_turn_id: logged ? turnId : control.last_logged_turn_id,
-      transcript_path: transcriptPath,
+      transcript_path: transcriptPath,
+      transcript_id: identity.transcriptId,
+      provider: identity.provider,
     });
     pingObsidianVault(input.obsidian_api_key);
     writeHookOutput({});
@@ -1107,7 +1103,9 @@ function main() {
   // grafo quando a change fechava antes do turno seguinte. Aqui sobrevive ao reopen e acumula toda
   // change que passou pela sessão (upsertListSection deduplica). Fail-quiet: nunca derruba o Stop.
   try {
-    const chgLink = activeChangeLink(vaultBase);
+    const chgLink = entry.change_slug
+      ? `Change ativa: [[${getLocale(vaultBase).folders.changes}/${entry.change_slug}/proposta]]`
+      : activeChangeLink(vaultBase);
     const wl = (chgLink.match(/\[\[[^\]]+\]\]/) || [])[0];
     if (wl) {
       let cur = readFileSync(sessionPath, 'utf8');
@@ -1131,7 +1129,9 @@ function main() {
     // started_at omitido: preserva o da própria entry (ver branch acima).
     ended_at: endedAt,
     last_turn_id: turnId,
-    transcript_path: transcriptPath,
+    transcript_path: transcriptPath,
+    transcript_id: identity.transcriptId,
+    provider: identity.provider,
   });
 
   // Reconstrói índice (camada fria) + digest (camada quente) ao finalizar. Nunca derruba o Stop.

package/hooks/subagent-stop.mjs

@@ -1,25 +1,26 @@
 #!/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.
 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 { readHookInput, writeHookOutput, getVaultBase } from './obsidian-common.mjs';
+import { updateSessionObservability } from './session-observability.mjs';
+import { resolveSessionEntry } from './session-identity.mjs';
 
 export function refreshSubagents(vaultBase, input) {
-  const transcriptPath = input.transcript_path || input.transcriptPath || '';
-  const matched = transcriptPath ? findActiveSessionByTranscript(vaultBase, transcriptPath) : null;
-  const sessionRel = matched?.session_file || readControl(vaultBase).session_file || '';
+  const { identity, entry } = resolveSessionEntry(vaultBase, input);
+  if (identity.state !== 'resolved') return false;
+  const transcriptPath = identity.transcriptPath;
+  const sessionRel = entry?.session_file || '';
   if (!sessionRel) return false;
   const sessionPath = join(vaultBase, sessionRel);
   if (!existsSync(sessionPath)) return false;
-  upsertSubagentUsage(sessionPath, transcriptPath);
+  updateSessionObservability({ sessionPath, transcriptPath, caller: 'subagent-stop', canonicalConversationId: identity.canonicalConversationId });
   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/task-log.mjs

@@ -8,8 +8,9 @@
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { pathToFileURL } from 'url';
-import { readHookInput, writeHookOutput, getVaultBase, findActiveSessionByTranscript, readControl, formatHourMinute } from './obsidian-common.mjs';
+import { readHookInput, writeHookOutput, getVaultBase, formatHourMinute } from './obsidian-common.mjs';
 import { getLocale } from './locale.mjs';
+import { resolveSessionEntry } from './session-identity.mjs';
 
 // Pull the task's human text from whatever field the payload carries.
 export function taskText(input) {
@@ -41,9 +42,9 @@ export function appendProgress(content, line, heading) {
 export function logTask(vaultBase, input) {
   const text = taskText(input);
   if (!text) return false;
-  const transcriptPath = input.transcript_path || input.transcriptPath || '';
-  const matched = transcriptPath ? findActiveSessionByTranscript(vaultBase, transcriptPath) : null;
-  const sessionRel = matched?.session_file || readControl(vaultBase).session_file || '';
+  const { identity, entry } = resolveSessionEntry(vaultBase, input);
+  if (identity.state !== 'resolved') return false;
+  const sessionRel = entry?.session_file || '';
   if (!sessionRel) return false;
   const sessionPath = join(vaultBase, sessionRel);
   if (!existsSync(sessionPath)) return false;