wendkeep 0.36.0 → 0.38.0

package/CHANGELOG.md

@@ -4,6 +4,35 @@ 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
+
+- Observabilidade consolidada em `## Agentes, tokens e custos`: Stop, SubagentStop, importação e rebuild usam um único writer atômico para main + subagents.
+- Ledger por modelo/origem com reasoning tokens e effort, sem alterar a regra de preço do modelo.
+- Novo `wendkeep cost rebuild`, dry-run por padrão; `--apply` reconstrói sessões antigas via `SESSION_REGISTRY` e grava `.brain/COST_REBUILD.json`.
+- Preços API-equivalentes de GPT-5.6 Sol, Terra e Luna.
+
+### Fixed
+
+- Custos de subagents são atribuídos ao modelo que realmente os executou, em vez do modelo principal.
+- Migração remove os headings legados sem perder reaberturas ou iterações mal posicionadas.
+- Totais combinados de tokens/custo são atualizados também no `SubagentStop` e persistidos em campos compatíveis com os dashboards existentes.
+
 ## [0.35.0] — 2026-07-11
 
 ### Fixed
@@ -870,9 +899,3 @@ Initial release — the capture engine, extracted from a system in daily product
 [0.2.7]: https://www.npmjs.com/package/wendkeep/v/0.2.7
 [0.2.0]: https://www.npmjs.com/package/wendkeep/v/0.2.0
 [0.1.0]: https://www.npmjs.com/package/wendkeep/v/0.1.0
-# 0.36.0 — 2026-07-11
-
-- Custos de subagents agora são atribuídos ao modelo que realmente os executou por meio de um ledger por sessão; campos legados continuam compatíveis.
-- Novo `wendkeep cost rebuild`, dry-run por padrão, reconstrói sessões antigas via `SESSION_REGISTRY` e, com `--apply`, grava um manifesto auditável em `.brain/COST_REBUILD.json`.
-- Totais combinados de tokens/custo passam a ser persistidos explicitamente nas notas.
-- Preços API-equivalentes de GPT-5.6 Sol, Terra e Luna adicionados à tabela editável e ao fallback interno.

package/README.md

@@ -119,6 +119,10 @@ 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). |
 | `wendkeep sync-defs` | Copy `.brain/agents\|skills` into `.codex/agents`, `.claude/skills`, `.agents/skills`; `--check` detects drift. |
 | `wendkeep validate-memory [path]` | Validate `.brain/CORE.md` (cap 25, 3 sections, no secrets/PII). |

package/README.pt-BR.md

@@ -116,6 +116,10 @@ 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`). |
 | `wendkeep import [opts]` | **Memória retroativa** — importa sessões passadas de **Claude + Codex** pro cofre (dedup por `session_id`). `--source all\|claude\|codex` / `--from <dir>` / `--codex-from <dir>` / `--stamp-ids` / `--since d` / `--limit n` / `--dry-run` / `--json`. |
 | `wendkeep dashboard [--force]` | (Re)gera os Bases filtrados por pasta + o MOC `00-Dashboard`. |

package/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/import-sessions.mjs

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

package/hooks/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,