wendkeep 0.32.0 → 0.33.0

package/CHANGELOG.md

@@ -4,6 +4,25 @@ 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

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

@@ -167,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) {
@@ -232,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.32.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,
@@ -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'); }

package/src/skills-seed.mjs

@@ -29,8 +29,9 @@ 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]\`.
@@ -53,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:
@@ -248,8 +251,9 @@ 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.
@@ -263,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.
 `;