wendkeep 0.37.0 → 0.38.0

package/CHANGELOG.md

@@ -4,6 +4,20 @@ 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.38.0] — 2026-07-12
+
+### Added
+
+- Registry multi-sessão v2: `SESSION_REGISTRY.json` passa a ser a autoridade por conversa, enquanto `CURRENT_SESSION.md` vira um dashboard compatível com todas as sessões ativas.
+- `wendkeep session list|show|use` e `wendkeep change bind <slug> --session <id>` permitem inspecionar sessões concorrentes e transferir explicitamente o vínculo de uma change.
+- Metadados de auditoria da observabilidade registram caller, conversa canônica, transcript e instante da atualização.
+
+### Fixed
+
+- Roteamento cross-provider agora é fail-closed: Codex usa `session_meta.payload.session_id`, Claude usa o `sessionId` do transcript, e writers não recorrem ao foco global quando a identidade é ambígua.
+- Atualizações concorrentes do registry usam lock, releitura e rename atômico; patches vazios não apagam transcript ou metadados válidos.
+- `cost rebuild` reporta entradas órfãs, ausentes ou incompatíveis como estado não verde em vez de omiti-las silenciosamente.
+
 ## [0.37.0] — 2026-07-11
 
 ### Added

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`. |
+| `wendkeep session list\|show\|use` | Lista o registry multi-sessão, mostra uma conversa ou muda somente o foco humano de `CURRENT_SESSION.md`. |
+| `wendkeep change bind <slug> --session <id>` | Vincula ou transfere uma change para uma conversa canônica sem esconder as demais pendências. |
 
 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). |

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`. |
+| `wendkeep session list\|show\|use` | Lista o registry multi-sessão, mostra uma conversa ou muda somente o foco humano de `CURRENT_SESSION.md`. |
+| `wendkeep change bind <slug> --session <id>` | Vincula ou transfere uma change para uma conversa canônica sem esconder as demais pendências. |
 
 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`). |

package/bin/wendkeep.mjs

@@ -43,9 +43,10 @@ Usage:
                            agent's JSON on stdin. Names: ${RUNNABLE_HOOKS.join(', ')}.
 
   wendkeep doctor [--vault P]  Run a vault health check.
-  wendkeep change <sub>        Change lifecycle: new [--simple] | use | continue | list | show |
+  wendkeep change <sub>        Change lifecycle: new [--simple] | use | bind <slug> --session <id> | continue | list | show |
                            status | done <id> | undone <id> | diff | archive [--force] | abandon.
                            archive exige verdict (rode verify --deep); abandon descarta sem ADR.
+  wendkeep session <sub>       Session registry: list | show <id> | use <id>.
   wendkeep spec <sub>          Specs: list | show | effective [--change] [--json] | migrate | rebase.
   wendkeep sensors <sub>       list | add <id> "<command>" [--severity --type --report].
   wendkeep cost [opts]         Aggregate AI-coding spend across the vault's sessions.
@@ -132,6 +133,11 @@ async function main() {
       runChange(rest);
       break;
     }
+    case 'session': {
+      const { runSession } = await import('../src/session.mjs');
+      runSession(rest);
+      break;
+    }
     case 'verify': {
       const { runVerify } = await import('../src/verify.mjs');
       runVerify(rest);

package/hooks/brain-inject.mjs

@@ -9,7 +9,8 @@ import { getVaultBase, readHookInput, writeHookOutput } from './obsidian-common.
 import { brainDir } from './brain-core.mjs';
 import { buildActiveChangeInjection, changeCtxState, writeSentinel } from './change-core.mjs';
 import { buildLessonsInjection } from './lessons-core.mjs';
-import { getLocale } from './locale.mjs';
+import { getLocale } from './locale.mjs';
+import { resolveSessionEntry } from './session-identity.mjs';
 
 // The process ROUTER — the enforcement layer. The wk-* skills are passive files; without a
 // standing instruction the model plans in chat, leaves the change scaffold raw and forces the
@@ -42,7 +43,7 @@ function processRouter(localeId) {
 
 const MAX_LINES = 45; // CORE ≤25 + DIGEST ≤15 + folga; salvaguarda se o CORE crescer à mão
 
-export function buildInjection(vaultBase) {
+export function buildInjection(vaultBase, input = {}) {
   const dir = brainDir(vaultBase);
   const read = (name) => {
     try { return readFileSync(join(dir, name), 'utf8').trim(); } catch { return ''; }
@@ -58,8 +59,12 @@ export function buildInjection(vaultBase) {
   const brain = ['<brain_memory>', ...lines, pointer, '</brain_memory>'].join('\n');
   const router = processRouter(getLocale(vaultBase).id);
   const change = buildActiveChangeInjection(vaultBase);
-  const lessons = buildLessonsInjection(vaultBase);
-  return [brain, router, change, lessons].filter(Boolean).join('\n');
+  const lessons = buildLessonsInjection(vaultBase);
+  const { identity, entry } = resolveSessionEntry(vaultBase, input);
+  const focus = identity.state === 'resolved' && entry?.change_slug
+    ? `<session_change>Change vinculada a esta sessão: ${entry.change_slug}. Este vínculo prevalece para writes automáticos; todas as pendências continuam visíveis acima.</session_change>`
+    : '';
+  return [brain, router, focus, change, lessons].filter(Boolean).join('\n');
 }
 
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
@@ -69,14 +74,16 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
     writeHookOutput({
       hookSpecificOutput: {
         hookEventName: 'SessionStart',
-        additionalContext: buildInjection(vaultBase),
+        additionalContext: buildInjection(vaultBase, input),
       },
     });
     // Sentinela do change-context: o backlog completo acabou de ser injetado aqui, então o hook
     // UserPromptSubmit não precisa re-pingar no 1º prompt. Bônus — nunca derruba a injeção.
     try {
       const st = changeCtxState(vaultBase);
-      if (st) writeSentinel(vaultBase, 'ctx', input.session_id || input.sessionId || '', st.hash);
+      const { identity } = resolveSessionEntry(vaultBase, input);
+      const sid = identity.state === 'resolved' ? identity.canonicalConversationId : (input.session_id || input.sessionId || '');
+      if (st) writeSentinel(vaultBase, 'ctx', sid, st.hash);
     } catch { /* sentinela é bônus */ }
   } catch (error) {
     process.stderr.write(`[brain] inject falhou: ${error.message}\n`);

package/hooks/change-context.mjs

@@ -8,6 +8,7 @@
 import { pathToFileURL } from 'node:url';
 import { getVaultBase, readHookInput, writeHookOutput } from './obsidian-common.mjs';
 import { changeCtxState, readSentinel, renderOpenChanges, writeSentinel } from './change-core.mjs';
+import { resolveSessionEntry } from './session-identity.mjs';
 
 // Conservador de propósito: verbos de tarefa comuns (pt+en) + tamanho mínimo. Falso-negativo
 // custa só o nudge; falso-positivo em pergunta curta viraria ruído.
@@ -19,12 +20,13 @@ export function looksLikeTask(prompt) {
 }
 
 // Retorna { context, hash? } quando há algo a injetar; null = silêncio.
-export function buildChangePing(vaultBase, sessionId, prompt = '') {
+export function buildChangePing(vaultBase, sessionId, prompt = '', changeSlug = '') {
   const st = changeCtxState(vaultBase);
   if (st) {
     if (readSentinel(vaultBase, 'ctx', sessionId) === st.hash) return null;
     writeSentinel(vaultBase, 'ctx', sessionId, st.hash);
-    return { context: renderOpenChanges(st, { tag: 'open_changes_ping' }), hash: st.hash };
+    const focus = changeSlug ? `\n<session_change>Change vinculada a esta sessão: ${changeSlug}.</session_change>` : '';
+    return { context: `${renderOpenChanges(st, { tag: 'open_changes_ping' })}${focus}`, hash: st.hash };
   }
   // Sem changes abertas: gate de skill para prompt-tarefa, 1x por sessão.
   if (!looksLikeTask(prompt)) return null;
@@ -42,8 +44,10 @@ export function buildChangePing(vaultBase, sessionId, prompt = '') {
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   try {
     const input = readHookInput();
-    const sid = input.session_id || input.sessionId || '';
-    const ping = buildChangePing(getVaultBase(input), sid, input.prompt || '');
+    const vaultBase = getVaultBase(input);
+    const { identity, entry } = resolveSessionEntry(vaultBase, input);
+    const sid = identity.state === 'resolved' ? identity.canonicalConversationId : (input.session_id || input.sessionId || '');
+    const ping = buildChangePing(vaultBase, sid, input.prompt || '', entry?.change_slug || '');
     if (!ping) { writeHookOutput({}); }
     else writeHookOutput({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: ping.context } });
   } catch {

package/hooks/decision-capture.mjs

@@ -12,6 +12,7 @@ import {
   wikilinkFromRel, readControl, toVaultRelative, getNextAdrNumber, derivedContentKey,
 } from './obsidian-common.mjs';
 import { getLocale } from './locale.mjs';
+import { resolveSessionEntry } from './session-identity.mjs';
 
 // Decision notes follow the ADR naming convention: ADR-NNNN-<slug>, NNNN a 4-digit sequential
 // number assigned in the order decisions are made (getNextAdrNumber scans the whole 04-Decisões).
@@ -168,8 +169,9 @@ export function captureDecision(vaultBase, input) {
   const dateStr = formatDate(now);
   const provider = providerMeta(input.provider);
 
-  const matched = input.transcript_path ? findActiveSessionByTranscript(vaultBase, input.transcript_path) : null;
-  const sessionRel = matched?.session_file || readControl(vaultBase).session_file || '';
+  const { identity, entry } = resolveSessionEntry(vaultBase, input, provider.id);
+  if (identity.state !== 'resolved') return null;
+  const sessionRel = entry?.session_file || '';
 
   const dir = join(vaultBase, monthFolderRelFromDateStr(loc.folders.decisions, dateStr, vaultBase));
   ensureDir(dir);

package/hooks/obsidian-common.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'fs';
 import { basename, dirname, join, relative } from 'path';
 import { getLocale } from './locale.mjs';
 
@@ -189,7 +189,7 @@ export function readControl(vaultBase) {
   return data;
 }
 
-export function writeControl(vaultBase, data) {
+export function writeControl(vaultBase, data) {
   const path = controlPath(vaultBase);
   ensureDir(dirname(path));
 
@@ -201,8 +201,16 @@ export function writeControl(vaultBase, data) {
   const sessionId = data.session_id || '';
   const lastLoggedTurnId = data.last_logged_turn_id || '';
 
-  const content = `---
-status: "${status}"
+  const registry = readSessionRegistry(vaultBase);
+  const active = Object.entries(registry.sessions || {})
+    .filter(([, item]) => item?.status === 'active' && item.session_file)
+    .sort((a, b) => String(b[1].last_seen || b[1].updated_at || '').localeCompare(String(a[1].last_seen || a[1].updated_at || '')));
+  const activeRows = active.length
+    ? active.map(([id, item]) => `| ${id} | ${item.provider || 'unknown'} | ${item.session_file} | ${item.change_slug || '-'} | ${item.last_seen || item.updated_at || '-'} |`).join('\n')
+    : '| - | - | nenhuma | - | - |';
+
+  const content = `---
+status: "${status}"
 session_file: "${sessionFile}"
 last_session_file: "${lastSessionFile}"
 started_at: "${startedAt}"
@@ -211,13 +219,21 @@ session_id: "${sessionId}"
 last_logged_turn_id: "${lastLoggedTurnId}"
 ---
 
-# CURRENT_SESSION
+# CURRENT_SESSION
+
+> Visão gerada pelo WendKeep. A autoridade de roteamento é .brain/SESSION_REGISTRY.json; hooks não usam este foco como fallback de escrita.
 
 - **Status:** ${status}
 - **Sessão ativa:** ${sessionFile || 'nenhuma'}
 - **Última sessão encerrada:** ${lastSessionFile || 'nenhuma'}
 - **Início:** ${startedAt || 'n/a'}
-- **Fim:** ${endedAt || 'n/a'}
+- **Fim:** ${endedAt || 'n/a'}
+
+## Sessões ativas (${active.length})
+
+| Conversa | Provider | Sessão | Change vinculada | Último sinal |
+|---|---|---|---|---|
+${activeRows}
 
 Regra crítica: sempre anexar conteúdo à sessão ativa. Nunca sobrescrever o histórico de iterações.
 `;
@@ -225,22 +241,22 @@ Regra crítica: sempre anexar conteúdo à sessão ativa. Nunca sobrescrever o h
   writeFileSync(path, content, 'utf-8');
 }
 
-export function readSessionRegistry(vaultBase) {
+export function readSessionRegistry(vaultBase) {
   const path = registryPath(vaultBase);
-  if (!existsSync(path)) return { version: 1, sessions: {} };
+  if (!existsSync(path)) return { version: 2, sessions: {} };
 
   try {
     const parsed = JSON.parse(readFileSync(path, 'utf-8'));
     return {
-      version: parsed.version || 1,
+      version: Math.max(2, parsed.version || 1),
       sessions: parsed.sessions && typeof parsed.sessions === 'object' ? parsed.sessions : {},
     };
   } catch {
-    return { version: 1, sessions: {} };
+    return { version: 2, sessions: {} };
   }
 }
 
-export function writeSessionRegistry(vaultBase, registry) {
+export function writeSessionRegistry(vaultBase, registry) {
   const path = registryPath(vaultBase);
   ensureDir(dirname(path));
   // Escrita atômica: grava em tmp e renomeia (rename é atômico no mesmo volume),
@@ -248,22 +264,86 @@ export function writeSessionRegistry(vaultBase, registry) {
   const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
   writeFileSync(tmp, `${JSON.stringify(registry, null, 2)}\n`, 'utf-8');
   renameSync(tmp, path);
-}
-
-export function upsertSessionRegistry(vaultBase, sessionId, patch) {
-  if (!sessionId) return null;
-
-  const registry = readSessionRegistry(vaultBase);
-  const current = registry.sessions[sessionId] || {};
-  const next = {
-    ...current,
-    ...patch,
-    updated_at: patch.updated_at || formatLocalIso(new Date()),
-  };
-  registry.sessions[sessionId] = next;
-  writeSessionRegistry(vaultBase, registry);
-  return next;
-}
+}
+
+function registryLockPath(vaultBase) {
+  return `${registryPath(vaultBase)}.lock`;
+}
+
+function waitBriefly(ms) {
+  const signal = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(signal, 0, 0, ms);
+}
+
+export function mutateSessionRegistry(vaultBase, mutator, { timeoutMs = 2000 } = {}) {
+  const lock = registryLockPath(vaultBase);
+  ensureDir(dirname(lock));
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    try {
+      mkdirSync(lock);
+      break;
+    } catch (error) {
+      if (error?.code === 'EEXIST') {
+        try {
+          if (Date.now() - statSync(lock).mtimeMs > 10_000) {
+            rmSync(lock, { recursive: true, force: true });
+            continue;
+          }
+        } catch { /* outro processo pode ter liberado o lock */ }
+      }
+      if (error?.code !== 'EEXIST' || Date.now() >= deadline) {
+        throw new Error(`SESSION_REGISTRY lock indisponível: ${error.message}`);
+      }
+      waitBriefly(10);
+    }
+  }
+
+  try {
+    const registry = readSessionRegistry(vaultBase);
+    registry.version = 2;
+    const result = mutator(registry);
+    writeSessionRegistry(vaultBase, registry);
+    return result;
+  } finally {
+    rmSync(lock, { recursive: true, force: true });
+  }
+}
+
+function meaningfulPatch(patch = {}) {
+  const protectedNonEmpty = new Set(['session_file', 'transcript_path', 'transcript_id', 'provider', 'started_at', 'change_slug']);
+  return Object.fromEntries(Object.entries(patch).filter(([key, value]) => {
+    if (value === undefined || value === null) return false;
+    if (value === '' && protectedNonEmpty.has(key)) return false;
+    return true;
+  }));
+}
+
+export function upsertSessionRegistry(vaultBase, sessionId, patch) {
+  if (!sessionId) return null;
+  const clean = meaningfulPatch(patch);
+  const next = mutateSessionRegistry(vaultBase, (registry) => {
+    const current = registry.sessions[sessionId] || {};
+    const transcriptPaths = [...new Set([
+      ...(Array.isArray(current.transcript_paths) ? current.transcript_paths : []),
+      current.transcript_path,
+      ...(Array.isArray(clean.transcript_paths) ? clean.transcript_paths : []),
+      clean.transcript_path,
+    ].filter(Boolean))];
+    const value = {
+      ...current,
+      ...clean,
+      ...(transcriptPaths.length ? { transcript_paths: transcriptPaths, transcript_path: clean.transcript_path || current.transcript_path || transcriptPaths.at(-1) } : {}),
+      last_seen: clean.last_seen || clean.updated_at || formatLocalIso(new Date()),
+      updated_at: clean.updated_at || formatLocalIso(new Date()),
+    };
+    registry.sessions[sessionId] = value;
+    return value;
+  });
+  const focus = readControl(vaultBase);
+  writeControl(vaultBase, focus);
+  return next;
+}
 
 // Sessões sem evento de fim (janela fechada, crash, agente sem SessionEnd) ficam
 // `active` para sempre. Após este limite ocioso, considera-se a sessão encerrada.
@@ -316,11 +396,12 @@ export function pruneRegistry(registry, nowMs, { keepDone = REGISTRY_KEEP_DONE,
 
 // Wrapper de IO: varre as ociosas, poda o registry, grava e fecha a NOTA `.md` de cada
 // sessão encerrada (mantém vault e registry alinhados). Devolve quantas fechou.
-export function sweepStaleSessionsFile(vaultBase, now = new Date(), maxIdleMs = SESSION_IDLE_CLOSE_MS, excludeTranscriptPath = '') {
-  const registry = readSessionRegistry(vaultBase);
-  const closed = sweepStaleSessions(registry, now.getTime(), maxIdleMs, excludeTranscriptPath);
-  const pruned = pruneRegistry(registry, now.getTime());
-  if (closed.length || pruned) writeSessionRegistry(vaultBase, registry);
+export function sweepStaleSessionsFile(vaultBase, now = new Date(), maxIdleMs = SESSION_IDLE_CLOSE_MS, excludeTranscriptPath = '') {
+  const closed = mutateSessionRegistry(vaultBase, (registry) => {
+    const result = sweepStaleSessions(registry, now.getTime(), maxIdleMs, excludeTranscriptPath);
+    pruneRegistry(registry, now.getTime());
+    return result;
+  });
   for (const { session_file, ended_at } of closed) {
     try { closeSessionNoteFile(vaultBase, session_file, ended_at); } catch { /* nunca derruba o sweep */ }
   }
@@ -512,13 +593,14 @@ export function transcriptsMatch(a, b) {
 // O `transcript_path` é estável dentro de uma conversa mesmo quando o
 // SessionStart re-dispara (compactação/resume) com `session_id` novo. Achar a
 // sessão ativa do mesmo transcript evita criar placeholders `HH-MM-codex`.
-export function findActiveSessionByTranscript(vaultBase, transcriptPath) {
+export function findActiveSessionByTranscript(vaultBase, transcriptPath) {
   if (!transcriptPath) return null;
   const registry = readSessionRegistry(vaultBase);
   let best = null;
   for (const [sessionId, item] of Object.entries(registry.sessions || {})) {
     if (!item || item.status !== 'active' || !item.session_file) continue;
-    if (!transcriptsMatch(item.transcript_path, transcriptPath)) continue;
+    const paths = [...(Array.isArray(item.transcript_paths) ? item.transcript_paths : []), item.transcript_path].filter(Boolean);
+    if (!paths.some((path) => transcriptsMatch(path, transcriptPath))) continue;
     if (!best || String(item.started_at || '') > String(best.started_at || '')) {
       best = { sessionId, session_file: item.session_file, started_at: item.started_at || '' };
     }

package/hooks/plan-capture.mjs

@@ -8,17 +8,17 @@ import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import {
-  findActiveSessionByTranscript,
   formatDate,
   getVaultBase,
-  readControl,
   readHookInput,
   slugify,
+  upsertSessionRegistry,
   wikilinkFromRel,
   writeHookOutput,
 } from './obsidian-common.mjs';
 import { activeChange, newChange } from './change-core.mjs';
 import { getLocale } from './locale.mjs';
+import { resolveSessionEntry } from './session-identity.mjs';
 
 // O plano aprovado chega por um de três canais, conforme a versão do Claude Code:
 // tool_input.plan (legado), o bloco "## Approved Plan" do tool_response, ou o arquivo de plano
@@ -94,15 +94,15 @@ export function capturePlan(vaultBase, input) {
   const en = loc.id === 'en';
   const dateStr = formatDate(new Date());
   const rawNote = `---\ntype: plan\ndate: ${dateStr}\ntags:\n  - plano\n---\n\n${plan.trim()}\n`;
-  const transcriptPath = input?.transcript_path ?? input?.transcriptPath ?? '';
-  const sessionRel = findActiveSessionByTranscript(vaultBase, transcriptPath)?.session_file
-    || readControl(vaultBase).session_file
-    || '';
+  const { identity, entry } = resolveSessionEntry(vaultBase, input, 'claude');
+  if (identity.state !== 'resolved') return null;
+  const sessionRel = entry?.session_file || '';
 
-  const active = activeChange(vaultBase);
+  const active = entry?.change_slug || activeChange(vaultBase);
   if (active) {
     const dir = join(vaultBase, loc.folders.changes, active);
     persistApprovedPlan(dir, active, rawNote, plan, dateStr);
+    upsertSessionRegistry(vaultBase, identity.canonicalConversationId, { change_slug: active });
     return {
       slug: active, created: false,
       context: `<plan_captured>\n${en
@@ -113,6 +113,7 @@ export function capturePlan(vaultBase, input) {
 
   const slug = planSlug(plan);
   newChange(vaultBase, slug, { dateStr, sessionRel });
+  upsertSessionRegistry(vaultBase, identity.canonicalConversationId, { change_slug: slug });
   const dir = join(vaultBase, loc.folders.changes, slug);
   const ctx = sectionBody(plan, ['Contexto', 'Context']) || plan.trim().split('\n').slice(0, 6).join('\n');
   const source = sessionRel ? `\n  - "${wikilinkFromRel(sessionRel)}"` : ' []';

package/hooks/session-ensure.mjs

@@ -29,7 +29,8 @@ import {
   writeControl,
   writeHookOutput,
   yamlQuote,
-} from './obsidian-common.mjs';
+} from './obsidian-common.mjs';
+import { resolveSessionIdentity } from './session-identity.mjs';
 
 function sessionIdFromInput(input) {
   return input.session_id || input.sessionId || input.codex_session_id || '';
@@ -239,7 +240,7 @@ function findSessionForInput(vaultBase, input, control) {
   return { sessionId, relPath: '', startedAt: '', fromRegistry: false };
 }
 
-function activateExistingSession({ vaultBase, relPath, startedAt, sessionId, input, now }) {
+function activateExistingSession({ vaultBase, relPath, startedAt, sessionId, input, now, identity }) {
   const sessionPath = join(vaultBase, relPath);
   if (!existsSync(sessionPath)) return false;
 
@@ -259,12 +260,14 @@ function activateExistingSession({ vaultBase, relPath, startedAt, sessionId, inp
     status: 'active',
     started_at: nextStartedAt,
     ended_at: '',
-    transcript_path: input.transcript_path || input.transcriptPath || '',
+    transcript_path: identity.transcriptPath,
+    transcript_id: identity.transcriptId,
+    provider: identity.provider,
   });
   return true;
 }
 
-function createSession({ vaultBase, sessionId, input, now }) {
+function createSession({ vaultBase, sessionId, input, now, identity }) {
   const summary = sessionSummaryFromInput(input);
   const { absPath, relPath } = allocateSessionPath(vaultBase, now, summary);
   const startedAt = formatLocalIso(now);
@@ -283,7 +286,9 @@ function createSession({ vaultBase, sessionId, input, now }) {
     status: 'active',
     started_at: startedAt,
     ended_at: '',
-    transcript_path: input.transcript_path || input.transcriptPath || '',
+    transcript_path: identity.transcriptPath,
+    transcript_id: identity.transcriptId,
+    provider: identity.provider,
   });
   return { relPath, startedAt };
 }
@@ -303,7 +308,18 @@ function main() {
   const vaultBase = getVaultBase(input);
   warnIfDefaultVault(input);
   const now = new Date();
-  const sessionId = sessionIdFromInput(input);
+  const identity = resolveSessionIdentity(vaultBase, input, providerMeta().id);
+  if (identity.state !== 'resolved') {
+    writeHookOutput({
+      hookSpecificOutput: {
+        hookEventName: 'UserPromptSubmit',
+        additionalContext: `<obsidian_session_deferred>Memória global disponível, sem escrita vinculada: ${identity.diagnostics.join('; ')}.</obsidian_session_deferred>`,
+      },
+      systemMessage: `[wendkeep] Identidade de sessão adiada: ${identity.diagnostics.join('; ')}`,
+    });
+    return;
+  }
+  const sessionId = identity.canonicalConversationId;
 
   // Fast path: skip all writes if control file touched < 5 min ago and session matches
   try {
@@ -316,7 +332,7 @@ function main() {
         ctrl.session_file &&
         !isPlaceholderSessionFile(ctrl.session_file) &&
         existsSync(join(vaultBase, ctrl.session_file)) &&
-        (!sessionId || ctrl.session_id === sessionId)
+        ctrl.session_id === sessionId
       ) {
         writeHookOutput({});
         return;
@@ -333,7 +349,7 @@ function main() {
     // Sem reuso-por-janela: só reaproveita a nota do control quando não há
     // identidade pra checar (!sessionId) ou quando é a MESMA conversa. Conversa
     // concorrente recente NÃO pode herdar a nota ativa do ponteiro global.
-    if (existsSync(activePath) && (!sessionId || control.session_id === sessionId)) {
+    if (existsSync(activePath) && control.session_id === sessionId) {
       const titled = maybeRetitleSession({
         vaultBase,
         relPath: control.session_file,
@@ -357,25 +373,30 @@ function main() {
         status: 'active',
         started_at: control.started_at,
         ended_at: '',
-        transcript_path: input.transcript_path || input.transcriptPath || '',
+        transcript_path: identity.transcriptPath,
+        transcript_id: identity.transcriptId,
+        provider: identity.provider,
       });
       writeHookOutput({});
       return;
     }
   }
 
-  const target = findSessionForInput(vaultBase, input, control);
-  if (target.relPath && activateExistingSession({ vaultBase, relPath: target.relPath, startedAt: target.startedAt, sessionId: target.sessionId, input, now })) {
+  const registered = readSessionRegistry(vaultBase).sessions?.[sessionId];
+  const resolvedTarget = registered?.session_file
+    ? { sessionId, relPath: registered.session_file, startedAt: registered.started_at || '' }
+    : { sessionId, relPath: '', startedAt: '' };
+  if (resolvedTarget.relPath && activateExistingSession({ vaultBase, relPath: resolvedTarget.relPath, startedAt: resolvedTarget.startedAt, sessionId, input, now, identity })) {
     outputActiveContext({
-      relPath: target.relPath,
-      startedAt: target.startedAt || formatLocalIso(now),
+      relPath: resolvedTarget.relPath,
+      startedAt: resolvedTarget.startedAt || formatLocalIso(now),
       vaultBase,
-      message: `Sessão Obsidian reaberta em ${target.relPath}. ${basename(controlPath(vaultBase))} atualizado.`,
+      message: `Sessão Obsidian reaberta em ${resolvedTarget.relPath}. ${basename(controlPath(vaultBase))} atualizado.`,
     });
     return;
   }
 
-  const created = createSession({ vaultBase, sessionId, input, now });
+  const created = createSession({ vaultBase, sessionId, input, now, identity });
   outputActiveContext({
     relPath: created.relPath,
     startedAt: created.startedAt,

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

@@ -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;

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

@@ -9,6 +9,7 @@ import { buildBrainDigest, buildBrainIndex } from './brain-core.mjs';
 import { activeChangeLink, pruneChangeSentinels } from './change-core.mjs';
 import { getLocale } from './locale.mjs';
 import { updateSessionObservability } from './session-observability.mjs';
+import { resolveSessionEntry } from './session-identity.mjs';
 import {
   ensureDir,
   findActiveSessionByTranscript,
@@ -1022,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;
@@ -1044,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 {
@@ -1054,7 +1060,7 @@ function main() {
   }
 
   try {
-    updateSessionObservability({ sessionPath, transcriptPath });
+    updateSessionObservability({ sessionPath, transcriptPath, caller: 'stop', canonicalConversationId: sessionId });
   } catch (error) {
     process.stderr.write(`[wendkeep] Token usage falhou: ${error.message}\n`);
   }
@@ -1076,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({});
@@ -1095,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');
@@ -1119,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

@@ -8,17 +8,19 @@
 import { existsSync } from 'fs';
 import { join } from 'path';
 import { pathToFileURL } from 'url';
-import { readHookInput, writeHookOutput, getVaultBase, findActiveSessionByTranscript, readControl } from './obsidian-common.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;
-  updateSessionObservability({ sessionPath, transcriptPath });
+  updateSessionObservability({ sessionPath, transcriptPath, caller: 'subagent-stop', canonicalConversationId: identity.canonicalConversationId });
   return true;
 }
 

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;

package/hooks/token-usage.mjs

@@ -366,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;

package/hooks/vault-health.mjs

@@ -118,13 +118,11 @@ function checkSession({ vaultBase, sessionRel, control, registry }) {
   }
   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)) {
@@ -166,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.37.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

@@ -9,19 +9,19 @@ export function rebuildSessionCosts(vaultBase, { apply = false, session = '', li
   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 {
-      updateSessionObservability({ sessionPath: note, transcriptPath: 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;
@@ -32,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>');
+}