wendkeep 0.37.0 → 0.38.1

package/hooks/session-identity.mjs

@@ -0,0 +1,97 @@
+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 || '';
+
+  // Claude: input.session_id já é o id canônico e estável da conversa — idêntico
+  // ao sessionId que cada linha do transcript grava. Numa sessão nova o arquivo
+  // ainda não materializou em disco quando o hook roda, então inspectTranscriptIdentity
+  // volta vazio e o gate abaixo adiaria o 1º turno inteiro (SessionStart + 1º prompt
+  // sem nota; sessão curta nunca registrada). Não adiar: usar o hookId direto.
+  // Codex NÃO entra aqui de propósito — lá o id do hook no resume é efêmero e ≠ do
+  // thread canônico, então seguimos exigindo rollout/registry (incidente 2026-07-11,
+  // contaminação cross-provider de sessão).
+  if (provider === 'claude' && hookId && !inspected.canonicalConversationId) {
+    return {
+      state: 'resolved',
+      provider,
+      canonicalConversationId: hookId,
+      hookSessionId: hookId,
+      transcriptPath,
+      transcriptId: transcriptPath ? basename(transcriptPath, '.jsonl') : hookId,
+      parentConversationId: '',
+      diagnostics: [],
+    };
+  }
+
+  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

@@ -2,6 +2,7 @@
 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'];
@@ -153,9 +154,22 @@ export function buildSessionObservability({ sessionContent, transcriptPath }) {
   return { snapshot, content: upsertObservabilitySection(content, renderSessionObservability(snapshot)) };
 }
 
-export function updateSessionObservability({ sessionPath, transcriptPath }) {
+export function updateSessionObservability({ sessionPath, transcriptPath, caller = 'unknown', canonicalConversationId = '' }) {
   if (!sessionPath || !existsSync(sessionPath)) return null;
-  const result = buildSessionObservability({ sessionContent: readFileSync(sessionPath, 'utf8'), transcriptPath });
+  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;