wendkeep 0.31.0 → 0.33.0

package/CHANGELOG.md

@@ -4,6 +4,69 @@ 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.33.0] — 2026-07-11
+
+### Added
+
+- **Visão global de changes abertas**: `SessionStart`, `UserPromptSubmit`, `wendkeep change list`
+  e `wendkeep change status` sem slug mostram todas as pendências, inclusive as iniciadas por
+  outro agente.
+- Ações de takeover explícitas no contexto: Claude, Codex ou outro agente podem retomar uma
+  change existente sem perder o restante do backlog.
+
+### Changed
+
+- `.brain/CURRENT_CHANGE.md` continua como ponteiro global único, agora marcado como change
+  **atual**. Comandos implícitos (`done`, `verify`, `archive`, `abandon`) continuam restritos a ela.
+- Mudanças em qualquer `tarefas.md` invalidam o hash do hook de contexto e reinjetam a lista global
+  na sessão afetada.
+- `change-nag` permanece local à change atual; pendências de outra frente não bloqueiam o agente
+  em foco.
+
+## [0.32.0] — 2026-07-09
+
+### Added
+
+- **Contrato explícito `spec_impact`** para changes novas: `pending`, `required` ou `none`.
+  Changes materiais (`required`) precisam listar a capability e manter um delta real em
+  `specs/<capability>/spec.md`; `none` exige justificativa em `spec_impact_reason`.
+- **Snapshots imutáveis de planos aprovados** em `planos/<sha256-12>.md`, deduplicados por
+  conteúdo. `plano-aprovado.md` passa a ser o índice dos snapshots, sem sobrescrever planos
+  anteriores da mesma change.
+- Diagnósticos de `spec_impact` no `wendkeep doctor`, incluindo estado pendente, delta ausente e
+  divergência entre `specs:` e o conteúdo real no disco.
+
+### Changed
+
+- Hooks Claude de alta frequência usam `node` com caminho ancorado em
+  `${CLAUDE_PROJECT_DIR}`. O `init` migra automaticamente os comandos relativos de 0.31.0 sem
+  duplicar grupos, inclusive quando o agente muda o `cwd` para um subprojeto.
+- `wk-workflow`, `wk-brainstorming`, `wk-planning` e o roteador de SessionStart agora exigem a
+  classificação do impacto, o delta da capability e a rastreabilidade `[req:ID]` antes do archive.
+- O archive passa a ser **fail-closed** para specs: placeholder, arquivo ausente ou falha de
+  promoção bloqueiam o move e a criação do ADR.
+- Ao arquivar, links da sessão para a change ativa são reescritos para o caminho em `_arquivo`.
+  Decisões capturadas também entram imediatamente na seção de decisões da sessão ativa.
+
+### Fixed
+
+- **Planos aprovados descartados no Claude Code atual**: `plan-capture` agora lê
+  `tool_response.plan` no payload estruturado de `PostToolUse:ExitPlanMode`, mantendo os formatos
+  textuais legados e rejeições como no-op.
+- **52 falhas `MODULE_NOT_FOUND` observadas em produção** quando `change-warn`/`change-guard`
+  rodavam a partir de `mobile-app` ou `backend-core`.
+- A criação automática de change por plano aprovado agora preserva o backlink da sessão resolvido
+  pelo `transcript_path`/registry.
+- `vault-health` não exige `## Encerramento` de uma sessão ainda ativa; continua validando a ordem
+  completa quando a sessão está finalizada.
+
+### Migration
+
+- Rode `wendkeep init --force` para migrar hooks relativos instalados pela 0.31.0.
+- Rode `wendkeep sync-defs --reseed` para atualizar as skills wk-* em vaults existentes.
+- Changes antigas sem `spec_impact` continuam legíveis e são diagnosticadas como legadas; antes do
+  próximo archive, classifique-as explicitamente como `required` ou `none`.
+
 ## [0.31.0] — 2026-07-09
 
 ### Added — enforcement do loop a2 (o loop deixa de ser opcional na prática)

package/README.md

@@ -112,7 +112,7 @@ No re‑copying, no snapshot to re‑sync — the package is the single source o
 |---|---|
 | `wendkeep init` | Set up wendkeep in a project (vault taxonomy + settings + MCP + skills). |
 | `wendkeep hook <name>` | Run a session hook; invoked by `settings.json` (reads agent JSON on stdin). |
-| `wendkeep change <sub>` | Change lifecycle: `new [--simple]` / `list` / `show` / `status` / `done <id>` / `undone <id>` / `diff` / `archive [--force]`. |
+| `wendkeep change <sub>` | Change lifecycle: `new [--simple]` / `list` (global backlog) / `show` / `status [slug]` / `done <id> [--change slug]` / `undone <id> [--change slug]` / `diff` / `archive [--force]`. |
 | `wendkeep verify [--deep]` | Run the change's task sensors; `--deep` assembles the independent-verification package. |
 | `wendkeep spec <sub>` | Living specs: `list` / `show <capability>`. |
 | `wendkeep sensors <sub>` | `list` / `add <id> "<command>"` — view/edit `wendkeep.sensors.json` (JSON Schema shipped). |
@@ -148,7 +148,7 @@ Beyond capturing sessions, wendkeep is a **harness**: a native, zero‑dependenc
 explore → propose → apply (TDD) → verify → archive
 ```
 
-- **Propose** — `wendkeep change new <slug>` scaffolds `08-Mudanças/<slug>/` (`proposta.md`, `design.md`, `tarefas.md`, and a `specs/` delta). The change becomes *active* and is injected at the next `SessionStart`, so the agent resumes work‑in‑progress.
+- **Propose** — `wendkeep change new <slug>` scaffolds `08-Mudanças/<slug>/` (`proposta.md`, `design.md`, `tarefas.md`, and a `specs/` delta). It becomes the global *current* change. Multiple changes may remain open: hooks and `change list/status` expose every pending task, while commands without `--change` use only the current one.
 - **Apply** — implement each `tarefas.md` task. Tag a task that needs machine proof with `[sensor:<id>]`.
 - **Verify** — `wendkeep verify` runs the sensors your tasks declared (from `wendkeep.sensors.json` at the project root) and records `evidencia.json`. A critical red fails the gate; a `warning` red is advisory.
 - **Archive** — `wendkeep change archive <slug>` **gates** on the evidence (blocks unless every declared critical sensor is green), promotes each capability's spec delta (`ADDED`/`MODIFIED`/`REMOVED`) into the living `07-Specs/<capability>.md`, moves the change to `_arquivo/`, and mints an ADR in `04-Decisões/`.
@@ -175,6 +175,8 @@ Declare the capability in `proposta.md` (`specs: [ui]`) and author its delta in
 
 ```bash
 npx wendkeep change status                     # one screen: tasks / sensors / verdict
+npx wendkeep change list                       # all open changes + pending tasks
+npx wendkeep change status dark-mode           # one change in detail
 npx wendkeep change done 1.1                   # tick a task from the CLI
 npx wendkeep verify                            # run the declared sensors -> evidencia.json
 npx wendkeep verify --deep                     # assemble the verification package
@@ -194,7 +196,7 @@ agent session ──hooks──▶ wendkeep ──▶ Markdown in vault ──
    (Claude/Codex)        (Node)      (02-Sessões/…)        (CORE+DIGEST, backlinks)
 ```
 
-The agent's settings.json points each hook at `npx wendkeep hook …`. On `Stop`, wendkeep parses the session transcript, appends the turn, updates the token/cost table, and (idempotently) emits any decision/bug/learning notes. On every `SessionStart`, `brain-inject` injects back the curated memory (CORE + DIGEST), the active change, project lessons, and a `<wk_process>` router that routes any non‑trivial task through the a2 loop (plan → `change new` + fill the scaffold → TDD → verify → archive).
+The agent's settings.json points each hook at `npx wendkeep hook …`. On `Stop`, wendkeep parses the session transcript, appends the turn, updates the token/cost table, and (idempotently) emits any decision/bug/learning notes. On every `SessionStart`, `brain-inject` injects back curated memory (CORE + DIGEST), every open change with its pending tasks, the global current-change marker, project lessons, and a `<wk_process>` router. Claude, Codex, or another agent can therefore resume work started elsewhere without hiding the rest of the backlog.
 
 The archive **gate** blocks unless: the change scaffold is filled (G0), no task is open (G1), every declared critical sensor is green (with fresh evidence), and — when the change declares `[req:]` — an independent `verdict.json` covers them. `--force` is the human escape hatch; the agent is instructed never to use it on its own.
 

package/README.pt-BR.md

@@ -110,7 +110,7 @@ Sem recopiar, sem snapshot pra re‑sincronizar — o pacote é a única fonte d
 |---|---|
 | `wendkeep init` | Configura o wendkeep num projeto (taxonomia do cofre + settings + MCP + skills). |
 | `wendkeep hook <name>` | Roda um hook de sessão; invocado pelo `settings.json` (lê o JSON do agente no stdin). |
-| `wendkeep change <sub>` | Ciclo de mudança: `new [--simple]` / `list` / `show` / `status` / `done <id>` / `undone <id>` / `diff` / `archive [--force]`. |
+| `wendkeep change <sub>` | Ciclo de mudança: `new [--simple]` / `list` (backlog global) / `show` / `status [slug]` / `done <id> [--change slug]` / `undone <id> [--change slug]` / `diff` / `archive [--force]`. |
 | `wendkeep verify [--deep]` | Roda os sensores das tarefas da change; `--deep` monta o pacote de verificação independente. |
 | `wendkeep spec <sub>` | Specs vivos: `list` / `show <capability>`. |
 | `wendkeep sensors <sub>` | `list` / `add <id> "<comando>"` — vê/edita `wendkeep.sensors.json` (JSON Schema incluso). |
@@ -147,7 +147,7 @@ Além de capturar sessões, o wendkeep é um **harness**: um loop nativo e sem d
 explore → propose → apply (TDD) → verify → archive
 ```
 
-- **Propose** — `wendkeep change new <slug>` faz o scaffold de `08-Mudanças/<slug>/` (`proposta.md`, `design.md`, `tarefas.md` e um delta `specs/`). A change vira *ativa* e é injetada no próximo `SessionStart`, então o agente retoma o trabalho em curso.
+- **Propose** — `wendkeep change new <slug>` faz o scaffold de `08-Mudanças/<slug>/` (`proposta.md`, `design.md`, `tarefas.md` e um delta `specs/`). A change vira a *atual* global. Várias changes podem ficar abertas: hooks e `change list/status` mostram todas as pendências, enquanto comandos sem `--change` usam somente a atual.
 - **Apply** — implemente cada tarefa de `tarefas.md`. Taggeie a tarefa que precisa de prova de máquina com `[sensor:<id>]`.
 - **Verify** — `wendkeep verify` roda os sensores que suas tarefas declararam (do `wendkeep.sensors.json` na raiz do projeto) e grava `evidencia.json`. Um vermelho crítico falha o gate; um vermelho `warning` é aviso.
 - **Archive** — `wendkeep change archive <slug>` faz **gate** na evidência (bloqueia a não ser que todo sensor crítico declarado esteja verde), promove o delta de cada capability (`ADDED`/`MODIFIED`/`REMOVED`) pro `07-Specs/<capability>.md` vivo, move a change pro `_arquivo/` e cunha um ADR em `04-Decisões/`.
@@ -163,7 +163,7 @@ sessão do agente ──hooks──▶ wendkeep ──▶ Markdown no cofre ─
    (Claude/Codex)           (Node)      (02-Sessões/…)         (CORE+DIGEST, backlinks)
 ```
 
-O settings.json do agente aponta cada hook pra `npx wendkeep hook …`. No `Stop`, o wendkeep parseia o transcript, anexa o turno, atualiza a tabela de tokens/custo e (idempotentemente) emite qualquer nota de decisão/bug/aprendizado. Em todo `SessionStart`, o `brain-inject` injeta de volta a memória curada (CORE + DIGEST), a change ativa, as lições do projeto e um roteador `<wk_process>` que roteia qualquer tarefa não‑trivial pelo loop a2 (planejar → `change new` + preencher o scaffold → TDD → verify → archive).
+O settings.json do agente aponta cada hook pra `npx wendkeep hook …`. No `Stop`, o wendkeep parseia o transcript, anexa o turno, atualiza a tabela de tokens/custo e (idempotentemente) emite qualquer nota de decisão/bug/aprendizado. Em todo `SessionStart`, o `brain-inject` injeta a memória curada (CORE + DIGEST), todas as changes abertas com suas pendências, o marcador global da change atual, as lições do projeto e o roteador `<wk_process>`. Claude, Codex ou outro agente podem assim retomar trabalho iniciado em outro lugar sem ocultar o restante do backlog.
 
 O **gate** do archive bloqueia a não ser que: o scaffold da change esteja preenchido (G0), nenhuma tarefa esteja aberta (G1), todo sensor crítico declarado esteja verde (com evidência fresca) e — quando a change declara `[req:]` — um `verdict.json` independente cubra eles. O `--force` é a saída de emergência humana; o agente é instruído a nunca usar por conta própria.
 

package/hooks/brain-inject.mjs

@@ -1,6 +1,6 @@
 // .agent/hooks/brain-inject.mjs
 // Injeção da camada quente no SessionStart (Claude/Codex/Copilot): CORE curado +
-// DIGEST auto + 1-linha pointer do recall. Budget-capada. Nunca derruba o hook.
+// 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';
@@ -21,7 +21,7 @@ function processRouter(localeId) {
       '<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 08-Changes/<slug>/ — proposta.md (why/what), design.md (the approved approach), tarefas.md (the plan\'s tasks, `- [ ] N.N` with [req:ID]/[sensor:id]). Never leave the scaffold placeholders.',
+      '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`.',
@@ -32,7 +32,7 @@ function processRouter(localeId) {
     '<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 08-Mudanças/<slug>/ — proposta.md (porquê/o quê), design.md (a abordagem aprovada), tarefas.md (as tarefas do plano, `- [ ] N.N` com [req:ID]/[sensor:id]). Nunca deixe os placeholders do scaffold.',
+    '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`.',
@@ -72,8 +72,8 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
         additionalContext: buildInjection(vaultBase),
       },
     });
-    // Sentinela do change-context: a change ativa acabou de ser injetada aqui, então o hook de
-    // UserPromptSubmit não precisa re-pingar no 1º prompt. Bônus — nunca derruba a injeção.
+    // 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);

package/hooks/change-context.mjs

@@ -1,14 +1,13 @@
 #!/usr/bin/env node
 // UserPromptSubmit hook. Dois papéis, ambos quiet-by-default (a maioria dos prompts não injeta nada):
-//   1. Com change ativa: re-injeta <active_change_ping> (slug + tarefas abertas) SÓ quando o
-//      estado mudou desde a última injeção (hash em sentinela por sessão) — o nudge do
-//      SessionStart dilui/compacta; este devolve o loop ao contexto no momento certo.
-//   2. Sem change ativa: prompt com cara de tarefa ganha <wk_skill_gate> mandando invocar a
+//   1. Com changes abertas: re-injeta <open_changes_ping> (backlog completo) SÓ quando o estado
+//      mudou desde a última injeção (hash em sentinela por sessão).
+//   2. Sem changes abertas: prompt com cara de tarefa ganha <wk_skill_gate> mandando invocar a
 //      Skill wk-workflow ANTES de editar — 1x por sessão. É o empurrão de ativação da skill.
 // Fail-open; brain-inject grava a sentinela ctx no SessionStart para não duplicar no 1º prompt.
 import { pathToFileURL } from 'node:url';
 import { getVaultBase, readHookInput, writeHookOutput } from './obsidian-common.mjs';
-import { changeCtxState, readSentinel, writeSentinel } from './change-core.mjs';
+import { changeCtxState, readSentinel, renderOpenChanges, writeSentinel } from './change-core.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.
@@ -25,17 +24,9 @@ export function buildChangePing(vaultBase, sessionId, prompt = '') {
   if (st) {
     if (readSentinel(vaultBase, 'ctx', sessionId) === st.hash) return null;
     writeSentinel(vaultBase, 'ctx', sessionId, st.hash);
-    const lines = st.openTasks.map((t) => `- [ ] ${t.id} ${t.text}`);
-    const context = [
-      '<active_change_ping>',
-      `Mudança ativa: ${st.slug}${st.openTasks.length ? ` — tarefa(s) aberta(s):` : ' — sem tarefas abertas.'}`,
-      ...lines,
-      'Ao concluir uma tarefa: `wendkeep change done <id>`. Antes de arquivar: `wendkeep verify`.',
-      '</active_change_ping>',
-    ].join('\n');
-    return { context, hash: st.hash };
+    return { context: renderOpenChanges(st, { tag: 'open_changes_ping' }), hash: st.hash };
   }
-  // Sem change ativa: gate de skill para prompt-tarefa, 1x por sessão.
+  // Sem changes abertas: gate de skill para prompt-tarefa, 1x por sessão.
   if (!looksLikeTask(prompt)) return null;
   if (readSentinel(vaultBase, 'gate', sessionId)) return null;
   writeSentinel(vaultBase, 'gate', sessionId);

package/hooks/change-core.mjs

@@ -14,9 +14,13 @@ export function changeDirRel(slug, vaultBase) {
   return join(getLocale(vaultBase).folders.changes, slug);
 }
 
-export function renderChangeScaffold({ slug, sessionRel, dateStr, locale = 'pt-BR' }) {
+export function renderChangeScaffold({ slug, sessionRel, dateStr, locale = 'pt-BR', simple = false }) {
   const en = locale === 'en';
   const source = sessionRel ? `\n  - "${wikilinkFromRel(sessionRel)}"` : ' []';
+  const impact = simple ? 'none' : 'pending';
+  const impactReason = simple
+    ? (en ? 'Simple change with no product-contract impact.' : 'Mudança simples sem impacto no contrato do produto.')
+    : '';
   const proposta = `---
 type: change
 status: active
@@ -26,6 +30,8 @@ cssclasses:
 tags:
   - mudanca
 source:${source}
+spec_impact: ${impact}
+spec_impact_reason: ${JSON.stringify(impactReason)}
 specs: []
 ---
 
@@ -96,13 +102,14 @@ export function newChange(vaultBase, slug, { sessionRel = '', dateStr, simple =
   const dir = join(vaultBase, loc.folders.changes, slug);
   const existed = existsSync(join(dir, 'proposta.md'));
   mkdirSync(dir, { recursive: true });
-  const files = renderChangeScaffold({ slug, sessionRel, dateStr, locale: loc.id });
+  const files = renderChangeScaffold({ slug, sessionRel, dateStr, locale: loc.id, simple });
   const write = (name, content) => {
     const f = join(dir, name);
     if (!existsSync(f)) writeFileSync(f, content, 'utf8');
   };
   write('proposta.md', files.proposta);
   write('tarefas.md', files.tarefas);
+  if (!existed) write('.spec-impact-v1', '1\n');
   // Auto-sizing (Wave B): a --simple change skips the design + spec-delta scaffold.
   if (!simple) {
     write('design.md', files.design);
@@ -160,22 +167,67 @@ export function listChanges(vaultBase) {
   try {
     archived = readdirSync(join(base, ARCHIVE_DIR)).filter((n) => !n.startsWith('.'));
   } catch { /* none */ }
-  return { active, archived };
+  return { active: active.sort(), archived: archived.sort() };
 }
 
-export function buildActiveChangeInjection(vaultBase, { maxTasks = 8 } = {}) {
-  const slug = activeChange(vaultBase);
-  if (!slug) return '';
+// Visão derivada de TODAS as changes abertas. CURRENT_CHANGE continua sendo o único foco para
+// comandos implícitos; provider/session nunca filtram a fila, para que outro agente possa assumir
+// o trabalho. O hash leva o conteúdo inteiro de cada tarefas.md — não apenas as contagens — pois
+// ele controla a reinjeção por sessão dos hooks.
+export function allChangesState(vaultBase) {
+  const current = activeChange(vaultBase);
+  const { active } = listChanges(vaultBase);
   const chDir = getLocale(vaultBase).folders.changes;
-  let md = '';
-  try { md = readFileSync(join(vaultBase, chDir, slug, 'tarefas.md'), 'utf8'); } catch { return ''; }
-  const open = parseTasks(md).filter((t) => !t.done).slice(0, maxTasks);
-  const lines = open.map((t) => `- [ ] ${t.id} ${t.text}`);
-  const more = open.length === maxTasks ? '\n*…mais tarefas em tarefas.md*' : '';
-  return `<active_change>
-Mudança ativa: ${slug} — [[${chDir}/${slug}/proposta]]. Tarefas abertas:
-${lines.join('\n')}${more}
-</active_change>`;
+  const fingerprint = [`current:${current}`];
+  const changes = active.map((slug) => {
+    let md = '';
+    let warning = '';
+    try { md = readFileSync(join(vaultBase, chDir, slug, 'tarefas.md'), 'utf8'); }
+    catch { warning = 'tarefas.md ausente ou ilegível'; }
+    const tasks = parseTasks(md);
+    const openTasks = tasks.filter((t) => !t.done);
+    fingerprint.push(`slug:${slug}`, `tasks:${md}`, `warning:${warning}`);
+    return {
+      slug,
+      current: slug === current,
+      openTasks,
+      openCount: openTasks.length,
+      doneCount: tasks.length - openTasks.length,
+      warning,
+    };
+  });
+  changes.sort((a, b) => Number(b.current) - Number(a.current) || a.slug.localeCompare(b.slug));
+  const pointerWarning = current && !changes.some((change) => change.current)
+    ? `CURRENT_CHANGE aponta para change inexistente: ${current}`
+    : '';
+  if (pointerWarning) fingerprint.push(`pointer-warning:${pointerWarning}`);
+  return { current, changes, pointerWarning, hash: tasksHashOf(fingerprint.join('\n')) };
+}
+
+export function renderOpenChanges(state, { tag = 'open_changes' } = {}) {
+  if (!state?.changes?.length && !state?.pointerWarning) return '';
+  const lines = [];
+  if (tag) lines.push(`<${tag}>`);
+  if (state.current) lines.push(`Change atual (comandos sem --change): ${state.current}.`);
+  else lines.push('Nenhuma change atual selecionada; comandos sem --change continuam recusados.');
+  if (state.pointerWarning) lines.push(`Aviso: ${state.pointerWarning}.`);
+  for (const change of state.changes || []) {
+    const label = change.current ? 'ATUAL' : 'ABERTA';
+    lines.push(`### ${label} — ${change.slug} (${change.openCount} aberta(s), ${change.doneCount} concluída(s))`);
+    if (change.warning) lines.push(`- Aviso: ${change.warning}.`);
+    else if (!change.openTasks.length) lines.push('- Nenhuma tarefa aberta.');
+    else for (const task of change.openTasks) lines.push(`- [ ] ${task.id} ${task.text}`);
+  }
+  if (state.current) lines.push('Para change atual: `wendkeep change done <id>`; antes de archive: `wendkeep verify`.');
+  lines.push('Qualquer agente pode assumir uma change: selecione-a com `wendkeep change new <slug-existente>` ou use `--change <slug>` quando disponível.');
+  if (tag) lines.push(`</${tag}>`);
+  return lines.join('\n');
+}
+
+// Mantém o nome exportado para consumidores internos existentes, mas agora injeta o backlog
+// completo em vez de ocultar changes não selecionadas.
+export function buildActiveChangeInjection(vaultBase) {
+  return renderOpenChanges(allChangesState(vaultBase));
 }
 
 export function activeChangeLink(vaultBase) {
@@ -225,14 +277,18 @@ export function writeSentinel(vaultBase, kind, sid, value = '1') {
   } catch { /* fail-open: pior caso = aviso repetido */ }
 }
 
-// Estado da change ativa para o ping do change-context: hash inclui o slug para que trocar de
-// change com tarefas idênticas ainda re-pingue.
-export function changeCtxState(vaultBase, { maxTasks = 5 } = {}) {
-  const slug = activeChange(vaultBase);
-  if (!slug) return null;
-  let md = '';
-  try { md = readFileSync(join(vaultBase, getLocale(vaultBase).folders.changes, slug, 'tarefas.md'), 'utf8'); } catch { /* sem tarefas */ }
-  return { slug, hash: tasksHashOf(`${slug}\n${md}`), openTasks: parseTasks(md).filter((t) => !t.done).slice(0, maxTasks) };
+// Estado global usado pelo change-context: hash cobre qualquer tarefa aberta, inclusive de uma
+// change que não esteja no ponteiro. As propriedades slug/openTasks preservam compatibilidade com
+// consumidores antigos e descrevem somente a atual.
+export function changeCtxState(vaultBase) {
+  const state = allChangesState(vaultBase);
+  if (!state.changes.length && !state.pointerWarning) return null;
+  const selected = state.changes.find((change) => change.current);
+  return {
+    ...state,
+    slug: state.current,
+    openTasks: selected?.openTasks || [],
+  };
 }
 
 // GC das sentinelas (>7 dias) — seleção pura separada da execução (testável sem depender de
@@ -291,6 +347,12 @@ export function archiveChange(vaultBase, slug, { gate = gateGreen, dateStr, adrN
   const loc = getLocale(vaultBase);
   const chDir = loc.folders.changes;
   const src = join(vaultBase, chDir, slug);
+  let sourceSessionRel = '';
+  try {
+    const proposal = readFileSync(join(src, 'proposta.md'), 'utf8');
+    const m = proposal.match(/\[\[((?:02-Sessões|02-Sessions)\/[^\]|]+?)(?:\|[^\]]+)?\]\]/);
+    if (m) sourceSessionRel = m[1].endsWith('.md') ? m[1] : `${m[1]}.md`;
+  } catch { /* sem source */ }
   const verdict = gate(src);
   if (!verdict.ok) return { ok: false, failing: verdict.failing || [] };
 
@@ -324,7 +386,9 @@ export function archiveChange(vaultBase, slug, { gate = gateGreen, dateStr, adrN
         ...res.warnings,
       ];
     }
-  } catch { /* promoção falhou — segue só com ADR */ }
+  } catch (error) {
+    return { ok: false, failing: [`falha ao promover specs: ${error.message}`] };
+  }
 
   let reqIds = [];
   try { reqIds = [...new Set(parseTasks(readFileSync(join(src, 'tarefas.md'), 'utf8')).map((t) => t.req).filter(Boolean))]; } catch { /* sem tarefas */ }
@@ -343,6 +407,17 @@ export function archiveChange(vaultBase, slug, { gate = gateGreen, dateStr, adrN
     writeFileSync(pp, c, 'utf8');
   } catch { /* proposta ilegível — segue */ }
 
+  // A sessão guardava o link da change ativa; após o move, reescreva para o caminho arquivado.
+  if (sourceSessionRel) {
+    try {
+      const sessionPath = join(vaultBase, sourceSessionRel);
+      const oldLink = wikilinkFromRel(join(chDir, slug, 'proposta'));
+      const archivedLink = wikilinkFromRel(join(destRel, 'proposta'));
+      const current = readFileSync(sessionPath, 'utf8');
+      if (current.includes(oldLink)) writeFileSync(sessionPath, current.replaceAll(oldLink, archivedLink), 'utf8');
+    } catch { /* backlink é reparo auxiliar; archive já está íntegro */ }
+  }
+
   // ADR goes in the same dated month folder as session-derived decisions (04-Decisões/ano/MM-MMM/)
   // — not the year root — so all ADRs sit together in the vault's convention.
   const adrDirRel = monthFolderRelFromDateStr(loc.folders.decisions, dateStr, vaultBase);

package/hooks/decision-capture.mjs

@@ -33,9 +33,20 @@ export function decisionKeyExists(dir, key) {
   return false;
 }
 
-// The AskUserQuestion tool_output reads: `... "Question"="chosen labels"  "Q2"="..."`.
+// Claude Code >= 2.1 returns `{ answers: { Question: choice } }` in tool_response.
+// Older releases expose a text tool_output: `... "Question"="chosen labels"  "Q2"="..."`.
 export function parseAnswers(output) {
   const map = {};
+  if (output && typeof output === 'object') {
+    const answers = output.answers && typeof output.answers === 'object'
+      ? output.answers
+      : output;
+    for (const [question, answer] of Object.entries(answers)) {
+      if (typeof answer === 'string') map[clean(question)] = clean(answer);
+      else if (Array.isArray(answer)) map[clean(question)] = answer.map(clean).filter(Boolean).join(',');
+    }
+    if (Object.keys(map).length) return map;
+  }
   const re = /"([^"]+)"\s*=\s*"([^"]*)"/g;
   let m;
   while ((m = re.exec(String(output || '')))) map[m[1].trim()] = m[2].trim();
@@ -172,7 +183,35 @@ export function captureDecision(vaultBase, input) {
   writeFileSync(filePath, buildDecisionCaptureNote({
     questions, answers, dateStr, startedAt: formatLocalIso(now), sessionRel, provider, localeId: loc.id, adrNum, contentKey,
   }), 'utf-8');
-  return { rel: toVaultRelative(vaultBase, filePath), skipped: false };
+  const rel = toVaultRelative(vaultBase, filePath);
+  if (sessionRel) {
+    try {
+      const sessionPath = join(vaultBase, sessionRel);
+      let session = readFileSync(sessionPath, 'utf8');
+      const wikilink = wikilinkFromRel(rel);
+      const link = `- ${wikilink}`;
+      if (!session.includes(wikilink)) {
+        const heading = '\n## Decisões geradas nesta sessão\n';
+        const at = session.indexOf(heading);
+        if (at !== -1) {
+          const bodyStart = at + heading.length;
+          const nextRel = session.slice(bodyStart).search(/\n## /);
+          const bodyEnd = nextRel === -1 ? session.length : bodyStart + nextRel;
+          const body = session.slice(bodyStart, bodyEnd)
+            .replace(/\n?Nenhuma decisão registrada ainda\.\s*/i, '\n')
+            .trim();
+          const merged = [body, link].filter(Boolean).join('\n');
+          session = `${session.slice(0, bodyStart)}\n${merged}\n\n${session.slice(bodyEnd).replace(/^\n+/, '')}`;
+        } else {
+          const anchor = session.indexOf('\n## Encerramento');
+          const section = `\n## Decisões geradas nesta sessão\n\n${link}\n`;
+          session = anchor === -1 ? `${session.trimEnd()}${section}` : `${session.slice(0, anchor).trimEnd()}${section}${session.slice(anchor)}`;
+        }
+        writeFileSync(sessionPath, session, 'utf8');
+      }
+    } catch { /* backlink auxiliar nunca derruba a captura */ }
+  }
+  return { rel, skipped: false };
 }
 
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {

package/hooks/harness-doctor.mjs

@@ -3,7 +3,7 @@
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { activeChange, parseTasks } from './change-core.mjs';
-import { parseRequirements, parseSpecsList, parseDelta, evaluateVerdict } from './spec-core.mjs';
+import { parseRequirements, parseSpecsList, parseDelta, evaluateVerdict, validateSpecImpact } from './spec-core.mjs';
 import { getLocale } from './locale.mjs';
 
 export function checkHarness(vaultBase, projectRoot) {
@@ -43,6 +43,9 @@ export function checkHarness(vaultBase, projectRoot) {
     let entries;
     try { entries = readdirSync(dir); } catch { continue; } // a file, not a change dir
     if (!entries.includes('proposta.md')) { errors.push(`change sem proposta.md: ${name}`); continue; }
+    const impact = validateSpecImpact(dir);
+    errors.push(...impact.errors.map((e) => `${name}: ${e}`));
+    warnings.push(...impact.warnings.map((w) => `${name}: ${w}`));
     if (name === active) {
       try {
         for (const cap of parseSpecsList(readFileSync(join(dir, 'proposta.md'), 'utf8'))) {

package/hooks/plan-capture.mjs

@@ -3,10 +3,20 @@
 // Code e o vault: quando o usuário APROVA um plano, o plano vira registro — anexado à change
 // ativa, ou uma change nova criada e preenchida a partir dele (proposta do Contexto, design do
 // corpo, tarefas dos checkboxes). Não depende de a LLM lembrar do processo. Rejeição = no-op.
-import { readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { formatDate, getVaultBase, readHookInput, slugify, writeHookOutput } from './obsidian-common.mjs';
+import {
+  findActiveSessionByTranscript,
+  formatDate,
+  getVaultBase,
+  readControl,
+  readHookInput,
+  slugify,
+  wikilinkFromRel,
+  writeHookOutput,
+} from './obsidian-common.mjs';
 import { activeChange, newChange } from './change-core.mjs';
 import { getLocale } from './locale.mjs';
 
@@ -17,8 +27,18 @@ export function extractPlan(input) {
   const tr = input?.tool_response ?? input?.toolResponse ?? '';
   const resp = typeof tr === 'string' ? tr : JSON.stringify(tr || '');
   if (/doesn'?t want to proceed|user rejected|rejected the plan/i.test(resp)) return null;
-  if (!/approved (your |the )?plan|Approved Plan/i.test(resp)) return null;
   const direct = input?.tool_input?.plan ?? input?.toolInput?.plan;
+  // Claude Code atual entrega o plano aprovado como objeto estruturado no PostToolUse.
+  // Esse evento só ocorre após sucesso; flags negativas explícitas continuam no-op.
+  if (tr && typeof tr === 'object') {
+    if (tr.approved === false || tr.rejected === true || tr.cancelled === true) return null;
+    const structured = tr.plan ?? direct;
+    if (structured && String(structured).trim()) return String(structured);
+    const structuredPath = tr.filePath ?? tr.planFilePath;
+    if (structuredPath) { try { return readFileSync(String(structuredPath), 'utf8'); } catch { /* inacessível */ } }
+    return null;
+  }
+  if (!/approved (your |the )?plan|Approved Plan/i.test(resp)) return null;
   if (direct && String(direct).trim()) return String(direct);
   const marker = resp.match(/## Approved Plan[^\n]*:\s*\n([\s\S]+)$/);
   if (marker && marker[1].trim()) return marker[1].trim();
@@ -27,6 +47,27 @@ export function extractPlan(input) {
   return null;
 }
 
+function planIndex(slug) {
+  return `---\ntype: plan-index\ntags:\n  - plano\n---\n\n# ${slug} — planos aprovados\n`;
+}
+
+export function persistApprovedPlan(dir, slug, rawNote, plan, dateStr) {
+  const hash = createHash('sha256').update(String(plan)).digest('hex').slice(0, 12);
+  const snapshotsDir = join(dir, 'planos');
+  mkdirSync(snapshotsDir, { recursive: true });
+  const snapshot = join(snapshotsDir, `${hash}.md`);
+  if (!existsSync(snapshot)) writeFileSync(snapshot, rawNote, 'utf8');
+
+  const indexPath = join(dir, 'plano-aprovado.md');
+  let index = existsSync(indexPath) ? readFileSync(indexPath, 'utf8') : planIndex(slug);
+  const entry = `- [[planos/${hash}|${dateStr} — ${hash}]]`;
+  if (!index.includes(`[[planos/${hash}|`)) {
+    index = `${index.trimEnd()}\n\n${entry}\n`;
+    writeFileSync(indexPath, index, 'utf8');
+  }
+  return { hash, snapshot };
+}
+
 export function planSlug(plan) {
   const h1 = String(plan || '').match(/^#\s+(.+)$/m);
   return h1 ? slugify(h1[1], 'plano-aprovado', 60) : 'plano-aprovado';
@@ -53,11 +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 active = activeChange(vaultBase);
   if (active) {
     const dir = join(vaultBase, loc.folders.changes, active);
-    writeFileSync(join(dir, 'plano-aprovado.md'), rawNote, 'utf8');
+    persistApprovedPlan(dir, active, rawNote, plan, dateStr);
     return {
       slug: active, created: false,
       context: `<plan_captured>\n${en
@@ -67,9 +112,10 @@ export function capturePlan(vaultBase, input) {
   }
 
   const slug = planSlug(plan);
-  newChange(vaultBase, slug, { dateStr });
+  newChange(vaultBase, slug, { dateStr, sessionRel });
   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)}"` : ' []';
   writeFileSync(join(dir, 'proposta.md'), `---
 type: change
 status: active
@@ -78,7 +124,9 @@ cssclasses:
   - topic-change
 tags:
   - mudanca
-source: []
+source:${source}
+spec_impact: pending
+spec_impact_reason: ""
 specs: []
 ---
 
@@ -95,7 +143,7 @@ ${en ? 'See design.md and plano-aprovado.md (captured from the approved plan-mod
   writeFileSync(join(dir, 'design.md'), `# ${slug} — design\n\n${plan.trim()}\n`, 'utf8');
   const tasks = planTasks(plan);
   if (tasks.length) writeFileSync(join(dir, 'tarefas.md'), `# ${slug} — ${en ? 'tasks' : 'tarefas'}\n\n${tasks.join('\n')}\n`, 'utf8');
-  writeFileSync(join(dir, 'plano-aprovado.md'), rawNote, 'utf8');
+  persistApprovedPlan(dir, slug, rawNote, plan, dateStr);
   return {
     slug, created: true,
     context: `<plan_captured>\n${en
@@ -110,7 +158,11 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
     const r = capturePlan(getVaultBase(input), input);
     if (!r) { writeHookOutput({}); }
     else writeHookOutput({ hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: r.context } });
-  } catch {
-    writeHookOutput({});
+  } catch (error) {
+    process.stderr.write(`[wendkeep] plan-capture falhou: ${error.message}\n`);
+    writeHookOutput({ hookSpecificOutput: {
+      hookEventName: 'PostToolUse',
+      additionalContext: `<plan_capture_error>O plano aprovado não foi persistido: ${error.message}</plan_capture_error>`,
+    } });
   }
 }

package/hooks/spec-core.mjs

@@ -1,7 +1,7 @@
 // hooks/spec-core.mjs — living spec (07-Specs) + change delta merge (OpenSpec native).
 // Pure parsing/merge + promoteSpecs (fs). No import from change-core (avoids a cycle).
 import { createHash } from 'node:crypto';
-import { readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ensureDir } from './obsidian-common.mjs';
 import { getLocale } from './locale.mjs';
@@ -87,6 +87,49 @@ export function parseSpecsList(propostaMd) {
   return [];
 }
 
+function yamlScalar(text, key) {
+  const m = String(text).match(new RegExp(`^${key}:\\s*(.*)$`, 'm'));
+  return m ? m[1].trim().replace(/^['"]|['"]$/g, '') : '';
+}
+
+export function parseSpecImpact(propostaMd) {
+  const text = String(propostaMd || '');
+  const status = yamlScalar(text, 'spec_impact') || yamlScalar(text, 'spec-impact');
+  const reason = yamlScalar(text, 'spec_impact_reason') || yamlScalar(text, 'spec-impact-reason');
+  return { status, reason };
+}
+
+export function validateSpecImpact(changeDir) {
+  let proposta = '';
+  try { proposta = readFileSync(join(changeDir, 'proposta.md'), 'utf8'); }
+  catch { return { ok: false, errors: ['proposta.md ausente'], warnings: [], status: '', listed: [], onDisk: [] }; }
+
+  const { status, reason } = parseSpecImpact(proposta);
+  const listed = parseSpecsList(proposta);
+  const onDisk = discoverSpecDeltas(changeDir);
+  const enforced = existsSync(join(changeDir, '.spec-impact-v1'));
+  const errors = [];
+  const warnings = [];
+
+  if (!status) {
+    if (enforced) errors.push('spec_impact ausente — classifique como required ou none');
+    else warnings.push('change legada sem spec_impact — migre para required ou none antes do próximo ciclo');
+    return { ok: errors.length === 0, errors, warnings, status: '', listed, onDisk, legacy: !enforced };
+  }
+  if (!['pending', 'required', 'none'].includes(status)) errors.push(`spec_impact inválido: ${status}`);
+  if (status === 'pending') errors.push('spec_impact pending — classifique o impacto antes de arquivar');
+  if (status === 'none') {
+    if (!reason) errors.push('spec_impact none exige justificativa em spec_impact_reason');
+    if (listed.length || onDisk.length) errors.push('spec_impact none contradiz specs/deltas declarados');
+  }
+  if (status === 'required') {
+    if (!listed.length) errors.push('spec_impact required exige ao menos uma capability em specs');
+    for (const cap of listed) if (!onDisk.includes(cap)) errors.push(`delta real ausente para capability ${cap}`);
+    for (const cap of onDisk) if (!listed.includes(cap)) errors.push(`delta ${cap} existe no disco mas não está listado em specs`);
+  }
+  return { ok: errors.length === 0, errors, warnings, status, reason, listed, onDisk, legacy: false };
+}
+
 // Um delta ainda no estado do scaffold (só o requisito "(nome)"/"(name)", nada removido) não é
 // contrato — a promoção o filtra. Um delta com REMOVED é sempre intenção real.
 export function isPlaceholderDelta(md) {
@@ -118,9 +161,11 @@ export function promoteSpecs(vaultBase, changeDir, specs, { changeWikilink, date
   const promoted = [];
   const warnings = [];
   for (const cap of specs) {
-    let delta;
-    try { delta = parseDelta(readFileSync(join(changeDir, 'specs', cap, 'spec.md'), 'utf8')); }
-    catch { warnings.push(`sem delta para ${cap}`); continue; }
+    let deltaMd;
+    try { deltaMd = readFileSync(join(changeDir, 'specs', cap, 'spec.md'), 'utf8'); }
+    catch { throw new Error(`delta ausente para ${cap}`); }
+    if (isPlaceholderDelta(deltaMd)) throw new Error(`delta placeholder para ${cap}`);
+    const delta = parseDelta(deltaMd);
     const livePath = join(vaultBase, specsDir, `${cap}.md`);
     let current = [];
     try { current = parseRequirements(readFileSync(livePath, 'utf8')); } catch { /* nova capability */ }

package/hooks/vault-health.mjs

@@ -71,14 +71,14 @@ function hasDefaultPending(content) {
     .some((line) => DEFAULT_PENDING_PATTERNS.some((pattern) => pattern.test(line.trim())));
 }
 
-function usageSectionIsPlaced(content) {
+function usageSectionIsPlaced(content, { active = false } = {}) {
   const usage = content.indexOf('\n## Uso de tokens e custos');
   if (usage === -1) return true;
   const changed = content.indexOf('\n## Arquivos criados ou alterados');
   const pending = content.indexOf('\n## Pendências');
   const closing = content.indexOf('\n## Encerramento');
-  if (pending === -1 || closing === -1) return false;
-  return usage < pending && usage < closing && (changed === -1 || usage > changed);
+  if (pending === -1 || (!active && closing === -1)) return false;
+  return usage < pending && (active || usage < closing) && (changed === -1 || usage > changed);
 }
 
 function linkedNotesFromSession(content) {
@@ -102,14 +102,15 @@ function checkSession({ vaultBase, sessionRel, control, registry }) {
     return { failures, warnings, metrics };
   }
 
-  const content = readFileSync(sessionPath, 'utf-8');
+  const content = readFileSync(sessionPath, 'utf-8');
+  const activeSession = control.status === 'active' && control.session_file === sessionRel;
   const duplicates = findDuplicateTurnMarkers(content);
   metrics.turnMarkers = (content.match(/<!-- (?:wk-turn|codex-turn):/g) || []).length;
   metrics.duplicateTurnMarkers = duplicates.length;
 
   if (duplicates.length) failures.push(`Marcadores de turno duplicados: ${duplicates.join(', ')}`);
   if (hasHeadingAfterClosing(content)) failures.push('Há headings/iterações após ## Encerramento.');
-  if (!usageSectionIsPlaced(content)) failures.push('## Uso de tokens e custos está fora da posição esperada.');
+  if (!usageSectionIsPlaced(content, { active: activeSession })) failures.push('## Uso de tokens e custos está fora da posição esperada.');
   if (hasDefaultPending(content)) warnings.push('Pendências ainda contém placeholders padrão.');
 
   const registryEntry = registry.sessions?.[control.session_id];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.31.0",
+  "version": "0.33.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

@@ -4,7 +4,9 @@ import { isAbsolute, join, resolve } from 'node:path';
 import {
   newChange,
   activeChange,
+  allChangesState,
   listChanges,
+  renderOpenChanges,
   parseTasks,
   setTaskDone,
   archiveChange,
@@ -12,7 +14,7 @@ import {
   scaffoldPlaceholders,
 } from '../hooks/change-core.mjs';
 import { evaluateGate, requiredSensors } from '../hooks/sensors-core.mjs';
-import { evaluateVerdict, tasksHashOf, parseSpecsList, parseDelta, parseRequirements, applyDelta } from '../hooks/spec-core.mjs';
+import { evaluateVerdict, tasksHashOf, parseSpecsList, parseDelta, parseRequirements, applyDelta, validateSpecImpact } from '../hooks/spec-core.mjs';
 import { getNextAdrNumber, readControl } from '../hooks/obsidian-common.mjs';
 import { getLocale } from '../hooks/locale.mjs';
 
@@ -61,9 +63,9 @@ export function runChange(argv) {
   }
 
   if (sub === 'list') {
-    const { active, archived } = listChanges(vaultBase);
-    const cur = activeChange(vaultBase);
-    process.stdout.write(`active: ${active.map((s) => (s === cur ? `*${s}` : s)).join(', ') || '(none)'}\n`);
+    const state = allChangesState(vaultBase);
+    const { archived } = listChanges(vaultBase);
+    process.stdout.write(`${renderOpenChanges(state, { tag: '' }) || 'open changes: (none)'}\n`);
     process.stdout.write(`archived: ${archived.join(', ') || '(none)'}\n`);
     process.exit(0);
   }
@@ -82,8 +84,16 @@ export function runChange(argv) {
   }
 
   if (sub === 'status') {
-    const slug = slugArg() || activeChange(vaultBase);
-    if (!slug) { process.stderr.write('wendkeep change status: no change (arg or active)\n'); process.exit(2); }
+    const slug = slugArg();
+    if (!slug) {
+      const state = allChangesState(vaultBase);
+      if (!state.changes.length && !state.pointerWarning) {
+        process.stderr.write('wendkeep change status: no open changes\n');
+        process.exit(2);
+      }
+      process.stdout.write(`${renderOpenChanges(state, { tag: '' })}\n`);
+      process.exit(0);
+    }
     const dir = join(vaultBase, getLocale(vaultBase).folders.changes, slug);
     let tarefasMd;
     try { tarefasMd = readFileSync(join(dir, 'tarefas.md'), 'utf8'); }
@@ -163,6 +173,9 @@ export function runChange(argv) {
       if (placeholders.length) {
         return { ok: false, failing: [`scaffold não preenchido (${placeholders.join('; ')}) — preencha proposta/design/tarefas antes de arquivar, ou \`wendkeep change abandon ${slug}\` se a change não vai adiante (--force não pula este check)`] };
       }
+      const impact = validateSpecImpact(dir);
+      for (const warning of impact.warnings) process.stderr.write(`aviso spec: ${warning}\n`);
+      if (!impact.ok) return { ok: false, failing: impact.errors };
       let tarefasMd = '';
       try { tarefasMd = readFileSync(join(dir, 'tarefas.md'), 'utf8'); } catch { /* no tasks */ }
       const tasks = parseTasks(tarefasMd);

package/src/init.mjs

@@ -15,6 +15,7 @@ import {
   mcpServerEntry,
   hookCommand,
   hookCommandLocal,
+  hookCommandLocalLegacy,
   deriveVaultDirName,
   selectableCompanions,
   resolveCompanions,
@@ -105,6 +106,16 @@ export function hookCommandFor(name, projectPath) {
   return hookCommand(name);
 }
 
+function localHookAvailable(name, projectPath) {
+  try {
+    return !!projectPath && existsSync(join(projectPath, 'node_modules', 'wendkeep', 'hooks', `${name}.mjs`));
+  } catch { return false; }
+}
+
+function localHookArg(name) {
+  return `${'${CLAUDE_PROJECT_DIR}'}/node_modules/wendkeep/hooks/${name}.mjs`;
+}
+
 export function mergeSettings(existing, { vaultPath, withMcp, force, companions = [], skipMcp = [], dotcontextHookLevel = 'full', projectPath = '' }) {
   const s = existing && typeof existing === 'object' ? { ...existing } : {};
   s.hooks = { ...(s.hooks || {}) };
@@ -120,19 +131,26 @@ export function mergeSettings(existing, { vaultPath, withMcp, force, companions
     ...companionHookSpecs(companions, { dotcontextHookLevel }),
   ].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
   for (const h of allSpecs) {
-    const command = h.command ?? (h.preferLocal ? hookCommandFor(h.name, projectPath) : hookCommand(h.name));
+    const useLocal = !h.command && h.preferLocal && localHookAvailable(h.name, projectPath);
+    const command = h.command ?? (useLocal ? 'node' : hookCommand(h.name));
+    const args = useLocal ? [localHookArg(h.name)] : undefined;
     // Dual-recognition: um hook nomeado é reconhecido tanto na forma npx quanto na node-direta,
     // para que trocar a forma preferida (ou re-initar noutra máquina) nunca duplique o grupo.
-    const candidates = h.command ? [h.command] : [hookCommand(h.name), hookCommandLocal(h.name)];
+    const candidates = h.command ? [h.command] : [hookCommand(h.name), hookCommandLocal(h.name), hookCommandLocalLegacy(h.name)];
+    const ownsHook = (x) => candidates.includes(x.command)
+      || (x.command === 'node' && Array.isArray(x.args) && x.args[0] === localHookArg(h.name));
     const groups = Array.isArray(s.hooks[h.event]) ? [...s.hooks[h.event]] : [];
-    const owning = groups.find((g) => (g.hooks || []).some((x) => candidates.includes(x.command)));
+    const owning = groups.find((g) => (g.hooks || []).some(ownsHook));
     if (owning) {
       // Already wired: never add a duplicate group (the old `if (present && !force)` fell through
       // under --force and appended a second identical group). Under --force, refresh the managed
       // entry's fields in place — without disturbing any sibling hooks the user grouped with it.
-      if (force) {
-        const hk = owning.hooks.find((x) => candidates.includes(x.command));
+      const hk = owning.hooks.find(ownsHook);
+      const brokenRelative = hk?.command === hookCommandLocalLegacy(h.name);
+      if (force || brokenRelative) {
         hk.command = command;
+        if (args) hk.args = args;
+        else delete hk.args;
         hk.timeout = h.timeout;
         if (h.statusMessage) hk.statusMessage = h.statusMessage;
         if (h.matcher && (owning.hooks || []).length === 1) owning.matcher = h.matcher;
@@ -141,6 +159,7 @@ export function mergeSettings(existing, { vaultPath, withMcp, force, companions
       continue;
     }
     const entry = { type: 'command', command, timeout: h.timeout, statusMessage: h.statusMessage };
+    if (args) entry.args = args;
     const group = h.matcher ? { matcher: h.matcher, hooks: [entry] } : { hooks: [entry] };
     groups.push(group);
     s.hooks[h.event] = groups;
@@ -530,6 +549,8 @@ export async function runInit(argv) {
     log(M.mcpSkipped);
   }
 
+  log('  [!] ignore runtime do wendkeep no Git quando o vault for versionado: .brain/.change-*');
+
   // 4. Vault color system (.obsidian) -----------------------------------------
   if (args.noColors) {
     log(M.colorsSkipped);

package/src/skills-seed.mjs

@@ -29,8 +29,14 @@ vault cego. Exceção única: mudança trivial (typo, 1 linha).
    - \`proposta.md\` — *por quê* e *o que muda* (o WHAT).
    - \`design.md\` — a abordagem técnica.
    - \`tarefas.md\` — a lista de tarefas \`- [ ] N.N descrição\`.
-   A mudança vira a *ativa* (ponteiro \`.brain/CURRENT_CHANGE.md\`) e é injetada no
-   próximo SessionStart, então você retoma o trabalho em curso automaticamente.
+   A mudança vira a *atual* (ponteiro global \`.brain/CURRENT_CHANGE.md\`). Podem existir
+   várias changes abertas: hooks e \`change list/status\` mostram todas as pendências; comandos
+   sem \`--change\` usam somente a atual.
+   Antes de implementar, resolva \`spec_impact\` na proposta:
+   - \`required\`: liste a capability em \`specs:\` e preencha
+     \`specs/<capability>/spec.md\` com ADDED/MODIFIED/REMOVED; ligue tarefas com \`[req:ID]\`.
+   - \`none\`: registre uma justificativa real em \`spec_impact_reason\`.
+   \`pending\` nunca é estado pronto para implementação ou archive.
 3. **Apply** — implemente cada tarefa de \`tarefas.md\` com disciplina **wk-tdd**
    (teste vermelho antes do código). Marque \`- [x]\` ao concluir. Declare nas tarefas:
    - \`[sensor:<id>]\` — a prova automatizada (roda no verify).
@@ -48,7 +54,9 @@ vault cego. Exceção única: mudança trivial (typo, 1 linha).
 
 ## Regras
 
-- Uma mudança ativa por vez. Termine (archive) antes de abrir outra.
+- Várias changes podem ficar abertas. \`CURRENT_CHANGE.md\` marca uma atual, sem esconder as
+  outras pendências. Claude, Codex ou outro agente podem assumir uma change existente com
+  \`wendkeep change new <slug-existente>\` ou \`--change <slug>\` quando disponível.
 - Se uma tarefa não precisa de prova automatizada, não declare sensor — o gate só exige
   o que você declarou. Sem \`[sensor:]\`, o archive não trava.
 - A proposta linka a sessão de origem; a sessão linka a mudança ativa. É de propósito:
@@ -139,6 +147,7 @@ qualquer código.
 Antes de fechar o design, resolva cada zona cinza: decide com o usuário, ou registra como
 **assumption assinada** ("assumo X porque Y — corrija se errado"). Cinza declinado pelo
 usuário é *registrado*, não descartado no silêncio. Nada sai do design silenciosamente ambíguo.
+Declare também a capability e se o design tem \`spec_impact: required\` ou \`none\`.
 
 ## Tabela out-of-scope
 
@@ -170,6 +179,10 @@ Mapeie os arquivos: quais criar/modificar e a responsabilidade de cada um. Arqui
 mudam juntos ficam juntos; um arquivo, uma responsabilidade. É aqui que a decomposição
 trava.
 
+Resolva o contrato antes de decompor: \`spec_impact: required\` exige capability + delta real em
+\`specs/<capability>/spec.md\`; \`spec_impact: none\` exige justificativa. Cada comportamento do
+delta recebe ID e as tarefas correspondentes usam \`[req:ID]\`.
+
 ## Tarefas bite-sized (TDD)
 
 Cada tarefa termina num entregável testável de forma independente. Cada passo é uma ação
@@ -238,8 +251,12 @@ leaves the vault blind. Single exception: a trivial change (typo, one line).
 
 1. **Explore** — understand the problem before proposing.
 2. **Propose** — \`wendkeep change new <slug>\` scaffolds \`08-Changes/<slug>/\`
-   (proposta/design/tarefas + a \`specs/\` delta). The change becomes *active* and is
-   injected at the next SessionStart.
+   (proposta/design/tarefas + a \`specs/\` delta). The change becomes *current* through global
+   \`.brain/CURRENT_CHANGE.md\`. Multiple changes may stay open; hooks and \`change list/status\`
+   show every pending task, while commands without \`--change\` use only the current change.
+   Before implementation, resolve \`spec_impact\`: \`required\` needs the capability listed in
+   \`specs:\` plus a real \`specs/<capability>/spec.md\` delta and \`[req:ID]\` links; \`none\`
+   needs a real \`spec_impact_reason\`. \`pending\` is never ready for implementation/archive.
 3. **Apply** — implement each task in tarefas.md with **wk-tdd** (red test first). Tag tasks:
    \`[sensor:<id>]\` (automated proof) and \`[req:<ID>]\` (the spec requirement it satisfies).
 4. **Verify** — \`wendkeep verify\` runs the sensors; then \`wendkeep verify --deep\` builds
@@ -250,7 +267,9 @@ leaves the vault blind. Single exception: a trivial change (typo, one line).
    verdict AND no open tasks. It promotes the delta into \`07-Specs\` and mints an ADR.
 
 ## Rules
-- One active change at a time. Finish (archive) before starting another.
+- Multiple changes may stay open. \`CURRENT_CHANGE.md\` marks one current change without hiding
+  other pending tasks. Any agent may take over an existing change with
+  \`wendkeep change new <existing-slug>\` or \`--change <slug>\` where available.
 - No \`[sensor:]\` on a task = no automated gate for it. No \`[req:]\` = no independent verdict.
 - The graph links session ↔ change ↔ requirement ↔ decision. That is the point.
 `;
@@ -310,6 +329,7 @@ Use it when the idea is still vague. Turn it into an approved design BEFORE writ
 ## Closure gate — no dangling ambiguity
 Resolve every gray area: decide with the user, or log a **signed-off assumption** ("assuming X
 because Y — correct me if wrong"). A declined gray area is recorded, not silently dropped.
+Also declare the capability and whether the design has \`spec_impact: required\` or \`none\`.
 
 ## Out-of-scope table
 List explicitly what the change does **not** do. Undeclared scope becomes creep.
@@ -331,6 +351,10 @@ Use it after an approved design. Produce a plan an engineer with no project cont
 Map the files: what to create/modify and each one's responsibility. Files that change together
 live together; one file, one responsibility.
 
+Resolve the contract first: \`spec_impact: required\` needs a capability and a real delta at
+\`specs/<capability>/spec.md\`; \`spec_impact: none\` needs a reason. Give each behaviour an ID
+and link the corresponding tasks with \`[req:ID]\`.
+
 ## Bite-sized tasks (TDD)
 Each task ends in an independently testable deliverable. Each step is a 2–5 min action:
 write the failing test (show code) → run and see it fail (exact command + expected) → minimal
@@ -434,6 +458,10 @@ comes from the package (freshness seal; edit a task later and the gate rejects i
 
 const PLAN_TEMPLATE_PT = `# Template — plano de tarefas (TDD, bite-sized)
 
+## Impacto em specs
+- \`spec_impact\`: \`required\` | \`none\`
+- Capability/delta: \`specs/<capability>/spec.md\` ou justificativa de \`none\`
+
 ## Arquivos
 - Criar: \`caminho/exato.mjs\`
 - Modificar: \`caminho/existente.mjs:120-140\`
@@ -457,6 +485,10 @@ tarefas (uma função é \`x()\` em toda parte). Cada tarefa termina num entreg
 
 const PLAN_TEMPLATE_EN = `# Template — task plan (TDD, bite-sized)
 
+## Spec impact
+- \`spec_impact\`: \`required\` | \`none\`
+- Capability/delta: \`specs/<capability>/spec.md\` or the \`none\` rationale
+
 ## Files
 - Create: \`exact/path.mjs\`
 - Modify: \`exact/existing.mjs:120-140\`

package/src/taxonomy.mjs

@@ -121,6 +121,10 @@ export function hookCommand(name) {
 // de segundos no Windows). Usada pelos hooks de ALTA FREQUÊNCIA (por prompt / por tool-call)
 // quando o projeto tem wendkeep instalado localmente; o init decide (hookCommandFor).
 export function hookCommandLocal(name) {
+  return `node "${'${CLAUDE_PROJECT_DIR}'}/node_modules/wendkeep/hooks/${name}.mjs"`;
+}
+
+export function hookCommandLocalLegacy(name) {
   return `node node_modules/wendkeep/hooks/${name}.mjs`;
 }