wendkeep 0.37.0 → 0.38.1

package/CHANGELOG.md

@@ -4,6 +4,27 @@ 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.1] — 2026-07-12
+
+### Fixed
+
+- Sessão Claude nova não perde mais o 1º turno: `resolveSessionIdentity` usa o `session_id` do hook como identidade canônica quando o transcript ainda não materializou em disco, em vez de adiar a criação da nota. Codex mantém a exigência de rollout/registry — a barreira anti-contaminação do 0.38.0 segue intacta.
+- `task-log` e `subagent-stop` passam a honrar `input.provider` ao resolver a sessão (paridade com `decision-capture`), evitando deferimento falso quando o provider do ambiente diverge do transcript.
+
+## [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

@@ -1,85 +1,92 @@
-// .agent/hooks/brain-inject.mjs
-// Injeção da camada quente no SessionStart (Claude/Codex/Copilot): CORE curado +
+// .agent/hooks/brain-inject.mjs
+// Injeção da camada quente no SessionStart (Claude/Codex/Copilot): CORE curado +
 // DIGEST auto + 1-linha pointer do recall + backlog completo de changes. Nunca derruba o hook.
-// Uso (hook): node .agent/hooks/brain-inject.mjs   (input JSON via stdin)
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { getVaultBase, readHookInput, writeHookOutput } from './obsidian-common.mjs';
-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';
-
-// 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
-// gate (seen in production: change archived with `(primeira tarefa)` open, via --force). This
-// block is injected EVERY session so planning always routes through the a2 loop.
-function processRouter(localeId) {
-  if (localeId === 'en') {
-    return [
-      '<wk_process>',
-      'Spec-driven process (mandatory for any non-trivial task): INVOKE the wk-workflow Skill BEFORE editing any file.',
-      '1. Plan: invoke the wk-brainstorming Skill (approved design) → wk-planning (task plan).',
+// Uso (hook): node .agent/hooks/brain-inject.mjs   (input JSON via stdin)
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { getVaultBase, readHookInput, writeHookOutput } from './obsidian-common.mjs';
+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 { 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
+// gate (seen in production: change archived with `(primeira tarefa)` open, via --force). This
+// block is injected EVERY session so planning always routes through the a2 loop.
+function processRouter(localeId) {
+  if (localeId === 'en') {
+    return [
+      '<wk_process>',
+      'Spec-driven process (mandatory for any non-trivial task): INVOKE the wk-workflow Skill BEFORE editing any file.',
+      '1. Plan: invoke the wk-brainstorming Skill (approved design) → wk-planning (task plan).',
       '2. Record: `wendkeep change new <slug>` and FILL proposta/design/tasks. Resolve `spec_impact`: `required` needs `specs/<capability>/spec.md` + [req:ID]; `none` needs a reason. Never leave pending/placeholders.',
-      '3. Implement: wk-tdd per task; tick `- [x]` as you finish. Something broke? wk-debugging.',
-      '4. Close: `wendkeep verify` (+ `--deep` + the wk-verify Skill) → `wendkeep change archive`.',
-      'NEVER `archive --force` on your own — a red gate means pending work; --force is the user\'s call, not yours. Dead end? `wendkeep change abandon`.',
-      '</wk_process>',
-    ].join('\n');
-  }
-  return [
-    '<wk_process>',
-    'Processo spec-driven (obrigatório em tarefa não-trivial): INVOQUE a Skill wk-workflow ANTES de editar qualquer arquivo.',
-    '1. Planejar: invoque a Skill wk-brainstorming (design aprovado) → wk-planning (plano de tarefas).',
+      '3. Implement: wk-tdd per task; tick `- [x]` as you finish. Something broke? wk-debugging.',
+      '4. Close: `wendkeep verify` (+ `--deep` + the wk-verify Skill) → `wendkeep change archive`.',
+      'NEVER `archive --force` on your own — a red gate means pending work; --force is the user\'s call, not yours. Dead end? `wendkeep change abandon`.',
+      '</wk_process>',
+    ].join('\n');
+  }
+  return [
+    '<wk_process>',
+    'Processo spec-driven (obrigatório em tarefa não-trivial): INVOQUE a Skill wk-workflow ANTES de editar qualquer arquivo.',
+    '1. Planejar: invoque a Skill wk-brainstorming (design aprovado) → wk-planning (plano de tarefas).',
     '2. Registrar: `wendkeep change new <slug>` e PREENCHA proposta/design/tarefas. Resolva `spec_impact`: `required` exige `specs/<capability>/spec.md` + [req:ID]; `none` exige justificativa. Nunca deixe pending/placeholders.',
-    '3. Implementar: wk-tdd por tarefa; marque `- [x]` ao concluir. Quebrou algo? wk-debugging.',
-    '4. Fechar: `wendkeep verify` (+ `--deep` + Skill wk-verify) → `wendkeep change archive`.',
-    'PROIBIDO `archive --force` por conta própria — gate vermelho significa trabalho pendente; --force é decisão do usuário, não sua. Beco sem saída? `wendkeep change abandon`.',
-    '</wk_process>',
-  ].join('\n');
-}
-
-const MAX_LINES = 45; // CORE ≤25 + DIGEST ≤15 + folga; salvaguarda se o CORE crescer à mão
-
-export function buildInjection(vaultBase) {
-  const dir = brainDir(vaultBase);
-  const read = (name) => {
-    try { return readFileSync(join(dir, name), 'utf8').trim(); } catch { return ''; }
-  };
-  const pointer = 'Memória profunda sob demanda: /brain-recall <tópico> (índice .brain/index.jsonl).';
-  // Quando CORE e DIGEST não existem, ''.split('\n') vira [''] — o filter derruba essa
-  // linha vazia para o caso "só pointer" ficar com exatamente 3 linhas.
-  let lines = [read('CORE.md'), read('DIGEST.md')].filter(Boolean).join('\n\n').split('\n').filter((l, i, a) => a.length > 1 || l);
-  if (lines.length > MAX_LINES) {
-    lines = lines.slice(0, MAX_LINES);
-    lines.push('*…truncado pelo budget — fonte completa: .brain/CORE.md + .brain/DIGEST.md*');
-  }
-  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');
-}
-
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
-  try {
-    const input = readHookInput();
-    const vaultBase = getVaultBase(input);
-    writeHookOutput({
-      hookSpecificOutput: {
-        hookEventName: 'SessionStart',
-        additionalContext: buildInjection(vaultBase),
-      },
-    });
+    '3. Implementar: wk-tdd por tarefa; marque `- [x]` ao concluir. Quebrou algo? wk-debugging.',
+    '4. Fechar: `wendkeep verify` (+ `--deep` + Skill wk-verify) → `wendkeep change archive`.',
+    'PROIBIDO `archive --force` por conta própria — gate vermelho significa trabalho pendente; --force é decisão do usuário, não sua. Beco sem saída? `wendkeep change abandon`.',
+    '</wk_process>',
+  ].join('\n');
+}
+
+const MAX_LINES = 45; // CORE ≤25 + DIGEST ≤15 + folga; salvaguarda se o CORE crescer à mão
+
+export function buildInjection(vaultBase, input = {}) {
+  const dir = brainDir(vaultBase);
+  const read = (name) => {
+    try { return readFileSync(join(dir, name), 'utf8').trim(); } catch { return ''; }
+  };
+  const pointer = 'Memória profunda sob demanda: /brain-recall <tópico> (índice .brain/index.jsonl).';
+  // Quando CORE e DIGEST não existem, ''.split('\n') vira [''] — o filter derruba essa
+  // linha vazia para o caso "só pointer" ficar com exatamente 3 linhas.
+  let lines = [read('CORE.md'), read('DIGEST.md')].filter(Boolean).join('\n\n').split('\n').filter((l, i, a) => a.length > 1 || l);
+  if (lines.length > MAX_LINES) {
+    lines = lines.slice(0, MAX_LINES);
+    lines.push('*…truncado pelo budget — fonte completa: .brain/CORE.md + .brain/DIGEST.md*');
+  }
+  const brain = ['<brain_memory>', ...lines, pointer, '</brain_memory>'].join('\n');
+  const router = processRouter(getLocale(vaultBase).id);
+  const change = buildActiveChangeInjection(vaultBase);
+  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) {
+  try {
+    const input = readHookInput();
+    const vaultBase = getVaultBase(input);
+    writeHookOutput({
+      hookSpecificOutput: {
+        hookEventName: 'SessionStart',
+        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);
-    } catch { /* sentinela é bônus */ }
-  } catch (error) {
-    process.stderr.write(`[brain] inject falhou: ${error.message}\n`);
-    writeHookOutput({});
-  }
-}
+    try {
+      const st = changeCtxState(vaultBase);
+      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`);
+    writeHookOutput({});
+  }
+}

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