wendkeep 0.32.0 → 0.34.0

package/CHANGELOG.md

@@ -4,6 +4,57 @@ 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.34.0] — 2026-07-11
+
+### Added
+
+- **Spec efetiva por change**: `wendkeep spec effective --change <slug> [--json]` combina o
+  contrato consolidado com somente o delta selecionado, incluindo origem e operação por requisito.
+- `change use <slug>` troca o ponteiro global; `change continue <arquivada> <novo-slug>` cria
+  continuação com backlink sem reabrir arquivo nem herdar evidência/verdict.
+- `sync-defs --check`, metadata de versão/hash e entrega idêntica de skills em `.claude/skills`
+  e `.agents/skills`.
+- `SPECS_STATE.json`, baseline por change e `spec migrate/rebase` para detectar edição direta e
+  conflitos concorrentes no mesmo requisito.
+
+### Changed
+
+- `08-Mudanças/<slug>/specs/` é o único local de autoria. `07-Specs` permanece como contrato
+  consolidado gerado/read-only, preservando ADRs e links históricos.
+- `verify --deep` agora grava requisitos completos em `verificacao.json` e sela o pacote com
+  `effectiveSpecHash`; `wk-verify` não relê `07-Specs`.
+- `doctor` valida todas as changes abertas e avisa quando skills precisam de reseed + reinício.
+
+### Fixed
+
+- Requisitos `ADDED` ainda não arquivados deixam de ficar invisíveis ao verificador independente.
+- Archives concorrentes bloqueiam somente quando outra change alterou o mesmo requisito; mudanças
+  não relacionadas na mesma capability podem prosseguir.
+
+### Migration
+
+- Rode `wendkeep spec migrate --vault <vault>` uma vez para adotar os contratos consolidados atuais.
+- Rode `wendkeep sync-defs --reseed --vault <vault> --project .` e reinicie Claude Code/Codex.
+
+## [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

@@ -71,7 +71,7 @@ npx wendkeep init
    Control with `--companions <csv>` or `--no-companions`. The Claude Code plugin layer (`extraKnownMarketplaces` + `enabledPlugins`) is wired as a bonus where the companion has one.
 5. Install a **color system** into the vault's `.obsidian/`: a CSS snippet that accents notes by type (session/decision/bug/learning, via the `cssclasses` the hooks emit) plus graph color groups by folder. Non-destructive merge into `appearance.json`/`graph.json`; skip with `--no-colors`.
 6. Seed the **curated memory layer**: `.brain/CORE.md` (the hand-curated hot layer, with the 3 required sections) and `.brain/COMPACTION_PROTOCOL.md` (the protocol guide). The auto layers (`DIGEST.md`, `index.jsonl`) are generated by the hooks. Validate the curated layer with `wendkeep validate-memory` (cap 25 lines, 3 sections, no secrets/PII).
-7. Seed the **definitions + skills layer**: `.brain/agents/` + `.brain/skills/` (versioned source of truth), including the native process skills `wk-workflow` / `wk-tdd` / `wk-debugging` / `wk-brainstorming` / `wk-planning` / `wk-verify` (some ship bundled templates, e.g. `wk-verify`'s `verdict-template.json` + reviewer prompt). `init` runs `wendkeep sync-defs` for you, delivering them to `.codex/agents/` + `.claude/skills/` (re‑run `sync-defs` after editing `.brain`).
+7. Seed the **definitions + skills layer**: `.brain/agents/` + `.brain/skills/` (versioned source of truth), including the native process skills `wk-workflow` / `wk-tdd` / `wk-debugging` / `wk-brainstorming` / `wk-planning` / `wk-verify`. `init` delivers them to `.codex/agents/`, `.claude/skills/`, and `.agents/skills/`; `sync-defs --check` detects stale copies.
 8. Seed the **change/spec lifecycle**: the `07-Specs/` + `08-Mudanças/` folders and a native `wendkeep.sensors.json` (a `validate-memory` sensor plus one per detected `package.json` script). Drives `wendkeep change` / `wendkeep verify` — see **Change lifecycle** below.
 
 ```bash
@@ -112,14 +112,14 @@ 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 spec <sub>` | `list` / `show` generated contracts; `effective --change <slug>`; `migrate`; `rebase`. |
 | `wendkeep sensors <sub>` | `list` / `add <id> "<command>"` — view/edit `wendkeep.sensors.json` (JSON Schema shipped). |
 | `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 lesson add "t" "l"` | Record a project-local lesson (injected at the next SessionStart). |
-| `wendkeep sync-defs` | Copy `.brain/agents\|skills` into the project (`.codex/agents`, `.claude/skills`). |
+| `wendkeep sync-defs` | Copy `.brain/agents\|skills` into `.codex/agents`, `.claude/skills`, `.agents/skills`; `--check` detects drift. |
 | `wendkeep validate-memory [path]` | Validate `.brain/CORE.md` (cap 25, 3 sections, no secrets/PII). |
 | `wendkeep doctor [--vault P]` | Run a vault health check (integrity of sessions, registry, links). |
 | `wendkeep --version` / `--help` | Version / usage. |
@@ -148,14 +148,14 @@ 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; `change use <slug>` changes focus and `change continue <archived> <new>` creates an auditable continuation.
 - **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.
+- **Verify** — `wendkeep verify` records sensor evidence. `verify --deep` builds a self-contained package with complete effective requirements (living contract + this change's delta), so the independent verifier never needs to reconstruct unarchived requirements from `07-Specs`.
 - **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/`.
 
 > The gate blocks unless the scaffold is filled, no task is open, evidence is fresh, and every declared requirement is covered. **`--force` is the human's call — never the agent's.**
 
-`wendkeep init` also seeds **native process skills** (`wk-workflow`, `wk-tdd`, `wk-debugging`, `wk-brainstorming`, `wk-planning`, `wk-verify`) into `.brain/skills` and delivers them to `.claude/skills` — the *how* layer, zero‑dep. Optional companions (`context-mode`, `dotcontext`, `understand-anything`, `caveman`) remain an opt‑in extra layer.
+`wendkeep init` seeds process skills into `.brain/skills` and delivers identical copies to Claude Code and Codex. Every skill carries source hash/version metadata; `doctor` warns when reseed + agent restart is required.
 
 ### The loop in five minutes
 
@@ -170,11 +170,14 @@ Edit `tarefas.md` — tag proof and requirement per task:
 - [ ] 1.1 toggle persists across sessions [req:UI-1] [sensor:tests]
 ```
 
-Declare the capability in `proposta.md` (`specs: [ui]`) and author its delta in
-`specs/ui/spec.md` (`## ADDED Requirements` → `### Requisito: UI-1 — dark mode toggle`). Then:
+Declare the capability in `proposta.md` (`specs: [ui]`) and author its delta only in
+`08-Mudanças/<slug>/specs/ui/spec.md`. `07-Specs` is generated/read-only. Then:
 
 ```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 spec effective --change dark-mode # living contract + this change's delta
 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
@@ -183,7 +186,7 @@ npx wendkeep change diff                       # preview what will land in 07-Sp
 npx wendkeep change archive dark-mode          # gate: sensors + verdict + no open tasks
 ```
 
-The archive promotes the delta into the living `07-Specs/ui.md`, mints an ADR, and the
+The archive promotes the delta into generated `07-Specs/ui.md`, mints an ADR, and the
 Obsidian graph now links *session ↔ change ↔ requirement ↔ decision*. A change that names
 no `[req:]` skips the independent verdict — the sensor gate is its proof.
 
@@ -194,7 +197,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/bin/wendkeep.mjs

@@ -43,10 +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] | list | show | status |
-                           done <id> | undone <id> | diff | archive [--force] | abandon [slug].
+  wendkeep change <sub>        Change lifecycle: new [--simple] | use | continue | list | show |
+                           status | done <id> | undone <id> | diff | archive [--force] | abandon.
                            archive exige verdict (rode verify --deep); abandon descarta sem ADR.
-  wendkeep spec <sub>          Living specs: list | show <capability>.
+  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.
                            --since <date> · --top [N] (priciest) · --trend [day|week|month]
@@ -70,9 +70,10 @@ Usage:
                            --vault <path> or OBSIDIAN_VAULT_PATH if no path given.
   wendkeep sync-defs [opts]    Copy versioned defs from the vault's .brain into the
                            project: .brain/agents/*.toml -> .codex/agents,
-                           .brain/skills/<name> -> .claude/skills. --vault P --project P.
+                           .brain/skills/<name> -> .claude/skills + .agents/skills. --vault P --project P.
                            --reseed re-semeia as skills wk-* com os seeds da versão instalada
                            (sobrescreve edições manuais nas wk-*) antes de copiar.
+                           --check detecta drift sem modificar arquivos.
   wendkeep --version           Print version.
   wendkeep --help              Show this help.
 `;

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

@@ -4,7 +4,7 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { ensureDir, wikilinkFromRel, monthFolderRelFromDateStr } from './obsidian-common.mjs';
-import { parseSpecsList, promoteSpecs, discoverSpecDeltas, tasksHashOf } from './spec-core.mjs';
+import { parseSpecsList, promoteSpecs, discoverSpecDeltas, tasksHashOf, captureSpecBaseline } from './spec-core.mjs';
 import { getLocale } from './locale.mjs';
 
 export const ARCHIVE_DIR = '_arquivo';
@@ -119,10 +119,44 @@ export function newChange(vaultBase, slug, { sessionRel = '', dateStr, simple =
       writeFileSync(exampleDelta, files.specDelta, 'utf8');
     }
   }
+  if (!existed) captureSpecBaseline(vaultBase, dir);
   setActiveChange(vaultBase, slug);
   return { rel: changeDirRel(slug, vaultBase), created: !existed };
 }
 
+export function useChange(vaultBase, slug) {
+  const dir = join(vaultBase, getLocale(vaultBase).folders.changes, slug);
+  if (!existsSync(join(dir, 'proposta.md'))) return { ok: false, error: `change aberta não encontrada: ${slug}` };
+  setActiveChange(vaultBase, slug);
+  return { ok: true, rel: changeDirRel(slug, vaultBase) };
+}
+
+export function continueChange(vaultBase, archivedSlug, newSlug, options = {}) {
+  const loc = getLocale(vaultBase);
+  const archiveDir = join(vaultBase, loc.folders.changes, ARCHIVE_DIR);
+  let names = [];
+  try { names = readdirSync(archiveDir).filter((name) => statSync(join(archiveDir, name)).isDirectory()); } catch { /* no archive */ }
+  const matches = names.filter((name) => name === archivedSlug || name.endsWith(`-${archivedSlug}`));
+  if (!matches.length) return { ok: false, error: `change arquivada não encontrada: ${archivedSlug}` };
+  if (matches.length > 1) return { ok: false, error: `change arquivada ambígua: ${archivedSlug} (${matches.join(', ')})` };
+  if (existsSync(join(vaultBase, loc.folders.changes, newSlug, 'proposta.md'))) {
+    return { ok: false, error: `change de continuação já existe: ${newSlug}` };
+  }
+  const archivedName = matches[0];
+  const archivedProposal = join(loc.folders.changes, ARCHIVE_DIR, archivedName, 'proposta');
+  const result = newChange(vaultBase, newSlug, options);
+  const proposalPath = join(vaultBase, loc.folders.changes, newSlug, 'proposta.md');
+  let proposal = readFileSync(proposalPath, 'utf8');
+  proposal = proposal.replace(/^specs:/m, `continues: "${wikilinkFromRel(archivedProposal)}"\nspecs:`);
+  const heading = loc.id === 'en' ? '## Continuation' : '## Continuação';
+  const note = loc.id === 'en'
+    ? `Continues ${wikilinkFromRel(archivedProposal)}. Archived evidence and verdict are not inherited.`
+    : `Continua ${wikilinkFromRel(archivedProposal)}. Evidências e verdict da change arquivada não são herdados.`;
+  proposal = `${proposal.trimEnd()}\n\n${heading}\n\n${note}\n`;
+  writeFileSync(proposalPath, proposal, 'utf8');
+  return { ok: true, ...result, archived: archivedName };
+}
+
 export function parseTasks(md) {
   const tasks = [];
   const re = /^-\s+\[( |x)\]\s+(\S+)\s+(.*)$/gm;
@@ -167,22 +201,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 use <slug>` 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 +311,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/hooks/harness-doctor.mjs

@@ -3,13 +3,12 @@
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { activeChange, parseTasks } from './change-core.mjs';
-import { parseRequirements, parseSpecsList, parseDelta, evaluateVerdict, validateSpecImpact } from './spec-core.mjs';
+import { buildEffectiveRequirementPackage, checkSpecsState, evaluateVerdict, tasksHashOf, validateSpecImpact } from './spec-core.mjs';
 import { getLocale } from './locale.mjs';
 
 export function checkHarness(vaultBase, projectRoot) {
   const loc = getLocale(vaultBase);
   const CHANGES_DIR = loc.folders.changes;
-  const SPECS_DIR = loc.folders.specs;
   const errors = [];
   const warnings = [];
 
@@ -23,16 +22,9 @@ export function checkHarness(vaultBase, projectRoot) {
     } catch { errors.push('wendkeep.sensors.json: JSON inválido'); }
   }
 
-  // Known requirement ids across the living specs (+ spec-without-source warning).
-  const knownReqs = new Set();
-  try {
-    for (const f of readdirSync(join(vaultBase, SPECS_DIR))) {
-      if (!f.endsWith('.md') || f === 'README.md') continue;
-      const md = readFileSync(join(vaultBase, SPECS_DIR, f), 'utf8');
-      for (const r of parseRequirements(md)) if (r.id) knownReqs.add(r.id);
-      if (!/^>\s+Atualizado por/m.test(md)) warnings.push(`spec sem origem: ${SPECS_DIR}/${f}`);
-    }
-  } catch { /* sem 07-Specs */ }
+  const specState = checkSpecsState(vaultBase);
+  if (specState.missing) warnings.push('SPECS_STATE ausente — rode `wendkeep spec migrate`; 07-Specs deve ser gerado/read-only');
+  else if (!specState.ok) errors.push(`07-Specs alterado fora do WendKeep: ${specState.changed.join(', ')} — mova a alteração para 08-Mudanças/<change>/specs`);
 
   // 2/3. Changes: malformed dirs; the active change's deltas add to knownReqs.
   const active = activeChange(vaultBase);
@@ -46,15 +38,18 @@ export function checkHarness(vaultBase, projectRoot) {
     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'))) {
-          try {
-            const d = parseDelta(readFileSync(join(dir, 'specs', cap, 'spec.md'), 'utf8'));
-            for (const r of [...d.added, ...d.modified]) if (r.id) knownReqs.add(r.id);
-          } catch { /* sem delta pra essa cap */ }
-        }
-      } catch { /* proposta ilegível */ }
+    let tasks = [];
+    let tarefasMd = '';
+    try { tarefasMd = readFileSync(join(dir, 'tarefas.md'), 'utf8'); tasks = parseTasks(tarefasMd); } catch { /* sem tarefas */ }
+    const reqIds = [...new Set(tasks.map((t) => t.req).filter(Boolean))];
+    const effective = buildEffectiveRequirementPackage(vaultBase, dir, reqIds);
+    errors.push(...effective.errors.map((e) => `${name}: spec efetiva inválida: ${e}`));
+    if (effective.missing.length) errors.push(`req órfão em ${name}: ${effective.missing.map((id) => `[req:${id}]`).join(', ')} não existe na spec efetiva`);
+    let verdict = null;
+    try { verdict = JSON.parse(readFileSync(join(dir, 'verdict.json'), 'utf8')); } catch { /* sem verdict */ }
+    if (verdict && reqIds.length) {
+      const v = evaluateVerdict(verdict, reqIds, { tasksHash: tasksHashOf(tarefasMd), effectiveSpecHash: effective.hash });
+      if (!v.ok) warnings.push(`verdict stale/incompleto em ${name}${v.missing.length ? `: falta cobrir ${v.missing.join(', ')}` : ''}`);
     }
   }
 
@@ -63,17 +58,6 @@ export function checkHarness(vaultBase, projectRoot) {
     const dir = join(vaultBase, CHANGES_DIR, active);
     if (!existsSync(join(dir, 'proposta.md'))) {
       errors.push(`ponteiro CURRENT_CHANGE aponta pra change inexistente: ${active}`);
-    } else {
-      let tasks = [];
-      try { tasks = parseTasks(readFileSync(join(dir, 'tarefas.md'), 'utf8')); } catch { /* sem tarefas */ }
-      const reqIds = [...new Set(tasks.map((t) => t.req).filter(Boolean))];
-      for (const rid of reqIds) if (!knownReqs.has(rid)) errors.push(`req órfão em ${active}: [req:${rid}] não existe em 07-Specs nem no delta`);
-      let verdict = null;
-      try { verdict = JSON.parse(readFileSync(join(dir, 'verdict.json'), 'utf8')); } catch { /* sem verdict */ }
-      if (verdict && reqIds.length) {
-        const v = evaluateVerdict(verdict, reqIds);
-        if (!v.ok) warnings.push(`verdict stale em ${active}: falta cobrir ${v.missing.join(', ')}`);
-      }
     }
   }