wendkeep 0.75.0 → 0.75.2

package/CHANGELOG.md

@@ -4,6 +4,32 @@ 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.75.2] — 2026-08-20
+
+### Fixed
+
+- **Handoffs legados reescopáveis.** `memory rescope` agora separa individualmente eventos
+  `handoff.latest` ambíguos quando a sessão de origem é comprovável. A migração permanece
+  append-only, não escolhe vencedor e conserva ambiguidades reais dentro da mesma work session.
+- **Curadoria proporcional.** `memory curate` mostra conflitos acionáveis por padrão; `--all`
+  inclui handoffs de sessões encerradas com status/change sanitizados e permite `H` para encerrar
+  em lote somente recomendações seguras, sempre com confirmação e releitura entre decisões.
+- **Diagnóstico sem falso bloqueio.** O doctor separa conflitos acionáveis de handoffs históricos
+  reparáveis no mesmo snapshot. Dívida histórica isolada gera atenção e orienta `memory rescope`,
+  sem degradar a memória nem ocultar a contagem restante.
+
+## [0.75.1] — 2026-08-20
+
+### Fixed
+
+- **Coalescência sem perda.** A outbox seleciona o identificador próprio de cada tipo de evento;
+  chamadas, agentes, rollups e transcripts distintos da mesma sessão não disputam mais a mesma chave.
+- **Reconciliação realmente integral.** `observer reconcile --url` e `observer memory import`
+  ignoram o cursor incremental local, consultam as revisões remotas e regeneram documentos,
+  consumo, chamadas e transcripts mesmo após restauração ou troca do Observer.
+- **Leases compatíveis com o transporte.** Locks de batch e publisher permanecem válidos além do
+  timeout máximo de request e só podem ser liberados pelo proprietário que os adquiriu.
+
 ## [0.75.0] — 2026-08-20
 
 ### Added

package/README.en.md

@@ -88,7 +88,7 @@ Decisions, dead ends, the reason you chose X over Y — gone next session. The p
 | **Cost** — what it all cost | Per‑model, cache‑aware token pricing per session — plus `cost --trend` with a run‑rate projection across the whole vault; research previews without a final rate remain unestimated. |
 | **Multi‑agent** — one vault, both agents | `init` wires the session hooks into `.claude/settings.json` *and* `.codex/hooks.json`, and every note is tagged with the agent that wrote it: Claude Code is detected from its environment, anything else is recorded as Codex. One shared graph, whichever agent you are in. |
 | **Local‑first** — no cloud, no account | Everything is plain Markdown on your disk. An optional MCP server (`@bitbonsai/mcpvault`) lets the agent read/write the vault. |
-| **Local Observer** — many projects, one view | `wendkeep observer` keeps documents, FTS5 chunks, sessions, agents, tokens, costs, calls, and transcripts in SQLite. Identities and foreign keys are project-scoped; each event is atomic. Hooks publish only what changed, while `observer reconcile` reserves full scans for explicit recovery. |
+| **Local Observer** — many projects, one view | `wendkeep observer` keeps documents, FTS5 chunks, sessions, agents, tokens, costs, calls, and transcripts in SQLite. Identities and foreign keys are project-scoped; each event is atomic. Hooks publish only what changed; `observer reconcile --url` ignores the incremental cursor to regenerate the complete projection while preserving local/remote revision baselines. |
 
 During historical migration, the Observer preserves differences between frontmatter totals and the
 ledger as explicit reconciliation rows, and disambiguates duplicate `session_id` values per file
@@ -413,10 +413,13 @@ CAS-migrated on both the attempt and `memory_checkpoint` to the correct physical
 backup/audit; divergent mirrors fail closed. A demonstrably superseded
 ambiguity uses `memory reconcile <session> --by-session <successor>
 --reason <reason>` as a dry run and requires `--apply`; the decision is backed up and audited
-without rewriting ledger, CORE, or notes. Run `status --gate` again afterwards. Conflicts require
-explicit, durable curation. Start with `memory curate --vault <vault>`: the menu groups conflicts
-under friendly names, shows sanitized previews, and confirms every write with default `no`. Skip
-or quit and run it again to resume. In a non-TTY environment, use
+without rewriting ledger, CORE, or notes. Run `status --gate` again afterwards. `memory rescope`
+append-only separates legacy handoffs with proven identity even when they already participate in
+candidates; it never selects a winner. Actionable conflicts require explicit, durable curation.
+Start with `memory curate --vault <vault>`: the menu shows actionable conflicts only, groups them
+under friendly names, shows sanitized previews, and confirms every write with default `no`.
+`memory curate --all` includes proven historical handoffs and lets `H` batch-close them after
+confirmation. In a non-TTY environment, use
 `memory candidates --active --vault <vault>` to list only safe IDs and metadata in read-only mode —
 it does not expose memory values or content. After human review,
 `memory promote <id> --event <event-id>` selects one event from the candidate, while

package/README.md

@@ -88,7 +88,7 @@ Decisions, dead ends, the reason you chose X over Y — gone next session. The p
 | **Cost** — what it all cost | Per‑model, cache‑aware token pricing per session — plus `cost --trend` with a run‑rate projection across the whole vault; research previews without a final rate remain unestimated. |
 | **Multi‑agent** — one vault, both agents | `init` wires the session hooks into `.claude/settings.json` *and* `.codex/hooks.json`, and every note is tagged with the agent that wrote it: Claude Code is detected from its environment, anything else is recorded as Codex. One shared graph, whichever agent you are in. |
 | **Local‑first** — no cloud, no account | Everything is plain Markdown on your disk. An optional MCP server (`@bitbonsai/mcpvault`) lets the agent read/write the vault. |
-| **Local Observer** — many projects, one view | `wendkeep observer` keeps documents, FTS5 chunks, sessions, agents, tokens, costs, calls, and transcripts in SQLite. Identities and foreign keys are project-scoped; each event is atomic. Hooks publish only what changed, while `observer reconcile` reserves full scans for explicit recovery. |
+| **Local Observer** — many projects, one view | `wendkeep observer` keeps documents, FTS5 chunks, sessions, agents, tokens, costs, calls, and transcripts in SQLite. Identities and foreign keys are project-scoped; each event is atomic. Hooks publish only what changed; `observer reconcile --url` ignores the incremental cursor to regenerate the complete projection while preserving local/remote revision baselines. |
 
 During historical migration, the Observer preserves differences between frontmatter totals and the
 ledger as explicit reconciliation rows, and disambiguates duplicate `session_id` values per file
@@ -413,10 +413,13 @@ CAS-migrated on both the attempt and `memory_checkpoint` to the correct physical
 backup/audit; divergent mirrors fail closed. A demonstrably superseded
 ambiguity uses `memory reconcile <session> --by-session <successor>
 --reason <reason>` as a dry run and requires `--apply`; the decision is backed up and audited
-without rewriting ledger, CORE, or notes. Run `status --gate` again afterwards. Conflicts require
-explicit, durable curation. Start with `memory curate --vault <vault>`: the menu groups conflicts
-under friendly names, shows sanitized previews, and confirms every write with default `no`. Skip
-or quit and run it again to resume. In a non-TTY environment, use
+without rewriting ledger, CORE, or notes. Run `status --gate` again afterwards. `memory rescope`
+append-only separates legacy handoffs with proven identity even when they already participate in
+candidates; it never selects a winner. Actionable conflicts require explicit, durable curation.
+Start with `memory curate --vault <vault>`: the menu shows actionable conflicts only, groups them
+under friendly names, shows sanitized previews, and confirms every write with default `no`.
+`memory curate --all` includes proven historical handoffs and lets `H` batch-close them after
+confirmation. In a non-TTY environment, use
 `memory candidates --active --vault <vault>` to list only safe IDs and metadata in read-only mode —
 it does not expose memory values or content. After human review,
 `memory promote <id> --event <event-id>` selects one event from the candidate, while

package/docs/en/commands/maintenance-and-diagnostics.md

@@ -104,6 +104,10 @@ dry-run path before any write.
   the evidence, and then use
   `memory promote <candidate-id> --event <event-id> --vault <vault>` to select an event or
   `memory reject <candidate-id> --vault <vault>` to keep the current operational value.
+- Historical handoffs from closed sessions are repairable debt, not actionable conflicts. Run
+  `memory rescope --vault <vault>` first and review the dry run, then apply with `--apply`. If debt
+  remains, `memory curate --all --vault <vault>` shows context and offers `H` to batch-close safe
+  recommendations only, always after confirmation.
 - `legacy`/`degraded`/`stale`/`manifest-unproven` observability: run
   `npx --no-install wendkeep cost rebuild --session <id> --json --vault <vault>`, review diagnostics,
   and only then authorize the second variant with `--apply`.

package/docs/en/commands/memory.md

@@ -28,7 +28,7 @@ Pass the vault explicitly in automation. Preserve backups and evidence before re
 
 ```bash
 npx wendkeep memory status [--gate] --vault <vault>
-npx wendkeep memory curate --vault <vault>
+npx wendkeep memory curate [--all] --vault <vault>
 npx wendkeep memory candidates [--active] --vault <vault>
 npx wendkeep memory rescope [--apply] --vault <vault>
 npx wendkeep memory repair --vault <vault>
@@ -43,12 +43,14 @@ npx wendkeep validate-memory --vault <v2-vault>
 ## Options and exit codes
 
 - `memory status` is read-only; `--gate` exits `1` only for blocking state.
-- `memory curate` is the recommended human path: in an interactive terminal it groups each
-  conflict under a friendly name, shows sanitized previews only, and offers numbered choices,
-  `P` to skip, `R` to reject, `D` for technical details, and `Q` to quit. Every promotion or
-  rejection asks for confirmation with default `no`: Enter or `N` does not write. Skip or quit
-  leaves the remaining work pending; running the command again resumes the active conflicts.
-- The assistant accepts only `--vault`: there is no `--yes`, `--apply`, or batch mode. In a
+- `memory curate` is the recommended human path and shows actionable conflicts only by default.
+  In an interactive terminal it groups conflicts under friendly names, shows sanitized previews
+  and context, and offers numbered choices, `P` to skip, `R` to reject, `D` for technical details,
+  and `Q` to quit. `--all` includes handoffs from proven closed sessions; for those, `H` batch-closes
+  only safe recommendations while reloading authority between decisions. Every write asks for
+  confirmation with default `no`: Enter or `N` does not write. Skip or quit preserves the
+  remaining conflicts so a later run can resume them.
+- The assistant accepts `--vault` and `--all`: there is no `--yes` or `--apply`. In a
   non-TTY environment it exits `2` without changing bytes and recommends the advanced fallback
   `memory candidates --active`.
 - `memory candidates` is read-only and prints deterministic JSON containing only `candidate_id`,
@@ -98,8 +100,10 @@ npx wendkeep validate-memory --vault <v2-vault>
   decision is idempotent.
 - `memory rescope` is a dry run by default and lists only planned IDs, keys, and scopes. With
   `--apply`, it appends explicit project, work-session, change, branch, or worktree events while
-  preserving historic bytes as the ledger prefix. Ambiguous candidates are neither migrated nor
-  assigned a winner; retry returns `unchanged`.
+  preserving historic bytes as the ledger prefix. Legacy `handoff.latest` events inside candidates
+  are also rescoped individually when they carry proven session identity, separating independent
+  workflows without selecting a winner. Ambiguities that remain inside one scope stay under human
+  curation; retry returns `unchanged`.
 - Registers such as `git.local-head`, `handoff.latest`, `quality.latest-*`, and
   `change.<slug>.status` compete only inside the same scope. Automatic resolution still requires
   the same project and causal lineage; incompatible decisions, constraints, and blockers remain

package/docs/en/commands/observer.md

@@ -92,8 +92,13 @@ agent sessions, cost rollups, and calls. Messages and transcripts are only sent
 that explicitly enable them. The container stores everything in
 `/data/observer.sqlite`; it does not mount `C:\GitHub` or any `.WendKeep-vault`. Markdown is only
 the text held in SQL and is recreated as files only by an explicit read-only export.
-`memory import` performs the initial load and returns file/hash parity. During migration, the
-cost/token total recorded in frontmatter is preserved through an explicit reconciliation row when
+`memory import` performs the initial load and returns file/hash parity. The remote recovery
+commands `observer reconcile --url` and `observer memory import` do not use the
+incremental cursor to decide what to omit: they regenerate documents, sessions, usage, calls, and
+transcripts. The cursor still supplies the local revision baseline and the remote tree, when
+available, supplies the highest known baseline; a transient read failure never lowers the locally
+persisted revision. During migration, the cost/token total recorded in frontmatter is preserved
+through an explicit reconciliation row when
 the detailed ledger does not add up; that row does not invent calls. Historical sessions sharing
 one `session_id` receive a canonical per-file identity so one rollup cannot overwrite the other.
 

package/docs/pt-BR/commands/maintenance-and-diagnostics.md

@@ -102,6 +102,10 @@ ou sem manifest comprovado e oferece um caminho dry-run antes de qualquer escrit
   liste os IDs seguros com `memory candidates --active --vault <cofre>`, revise a evidência e use
   `memory promote <candidate-id> --event <event-id> --vault <cofre>` para selecionar um evento ou
   `memory reject <candidate-id> --vault <cofre>` para manter o valor operacional atual.
+- Handoffs históricos de sessões encerradas são dívida reparável, não conflito acionável. Rode
+  primeiro `memory rescope --vault <cofre>` e revise o dry-run; aplique com `--apply`. Se restar
+  dívida, `memory curate --all --vault <cofre>` mostra o contexto e oferece `H` para encerrar em
+  lote somente as recomendações seguras, sempre com confirmação.
 - Observabilidade `legacy`/`degraded`/`stale`/`manifest-unproven`: rode
   `npx --no-install wendkeep cost rebuild --session <id> --json --vault <cofre>`, revise diagnostics
   e só então autorize a segunda variante com `--apply`.

package/docs/pt-BR/commands/memory.md

@@ -28,7 +28,7 @@ Informe o vault explicitamente em automações. Preserve backups e evidências a
 
 ```bash
 npx wendkeep memory status [--gate] --vault <cofre>
-npx wendkeep memory curate --vault <cofre>
+npx wendkeep memory curate [--all] --vault <cofre>
 npx wendkeep memory candidates [--active] --vault <cofre>
 npx wendkeep memory rescope [--apply] --vault <cofre>
 npx wendkeep memory repair --vault <cofre>
@@ -43,12 +43,14 @@ npx wendkeep validate-memory --vault <cofre-v2>
 ## Opções e códigos de saída
 
 - `memory status` é read-only; `--gate` retorna exit `1` apenas para estado bloqueante.
-- `memory curate` é o caminho recomendado para pessoas: em um terminal interativo, agrupa cada
-  conflito por nome amigável, mostra somente previews sanitizados e oferece escolhas numeradas,
-  `P` para pular, `R` para rejeitar, `D` para detalhes técnicos e `Q` para sair. Cada promoção ou
-  rejeição pede confirmação com padrão negativo: Enter ou `N` não grava. Pular ou sair deixa o
-  restante pendente; uma nova execução retoma os conflitos ainda ativos.
-- O assistente aceita somente `--vault`: não há `--yes`, `--apply` ou modo em lote. Em ambiente
+- `memory curate` é o caminho recomendado para pessoas: por padrão mostra somente conflitos
+  acionáveis. Em um terminal interativo, agrupa por nome amigável, mostra previews e contexto
+  sanitizados e oferece escolhas numeradas, `P` para pular, `R` para rejeitar, `D` para detalhes
+  técnicos e `Q` para sair. `--all` inclui handoffs de sessões comprovadamente encerradas; nesses
+  casos, `H` encerra em lote somente as recomendações seguras, relendo a autoridade entre cada
+  decisão. Toda escrita pede confirmação com padrão negativo: Enter ou `N` não grava. Pular ou
+  sair preserva o restante para retomar em outra execução.
+- O assistente aceita `--vault` e `--all`: não há `--yes` nem `--apply`. Em ambiente
   não-TTY/terminal não interativo, ele retorna exit `2` sem alterar bytes e orienta usar o fallback
   avançado `memory candidates --active`.
 - `memory candidates` é read-only e imprime JSON determinístico com somente `candidate_id`,
@@ -98,8 +100,10 @@ npx wendkeep validate-memory --vault <cofre-v2>
   notas, nem consome a outbox. Repetir a mesma decisão aplicada é idempotente.
 - `memory rescope` é dry-run por padrão e lista somente IDs, chaves e escopos planejados. Com
   `--apply`, anexa eventos explícitos de projeto, work session, change, branch ou worktree e mantém
-  os bytes históricos como prefixo do ledger. Candidates ambíguos não são migrados nem recebem
-  vencedor; uma repetição retorna `unchanged`.
+  os bytes históricos como prefixo do ledger. Eventos legados de `handoff.latest` que participam
+  de candidates também são reescopados individualmente quando possuem identidade de sessão
+  comprovável: isso separa workflows independentes sem selecionar vencedor. Ambiguidades que
+  permanecem no mesmo escopo continuam sob curadoria; uma repetição retorna `unchanged`.
 - Registradores como `git.local-head`, `handoff.latest`, `quality.latest-*` e
   `change.<slug>.status` só competem dentro do mesmo escopo. Resolução automática ainda exige o
   mesmo projeto e linhagem causal; decisões, constraints e blockers incompatíveis permanecem sob

package/docs/pt-BR/commands/observer.md

@@ -94,6 +94,11 @@ níveis de captura que os habilitam. O container grava tudo em
 `/data/observer.sqlite`; não monta `C:\GitHub` nem qualquer `.WendKeep-vault`. Markdown é aceito
 somente como conteúdo de uma coluna SQL e volta a existir como arquivo apenas pela exportação
 read-only sob demanda. `memory import` faz a carga inicial e retorna a paridade por arquivo e hash.
+Na recuperação remota, `observer reconcile --url` e `observer memory import` não usam o cursor
+incremental para decidir o que omitir: regeneram documentos, sessões, consumo, chamadas e
+transcripts. O cursor continua fornecendo o baseline local de revisão e a árvore remota, quando
+disponível, fornece o maior baseline conhecido; uma falha temporária nessa leitura nunca reduz a
+revisão persistida localmente.
 Na migração, o total de custo/token registrado no frontmatter é preservado por uma linha de
 reconciliação quando o ledger detalhado não fecha com ele; essa linha não inventa chamadas.
 Sessões históricas com o mesmo `session_id` recebem uma identidade canônica por arquivo para

package/hooks/vault-health.mjs

@@ -18,6 +18,7 @@ import { detectMemoryMode, LEGACY_MEMORY_WARNING } from './memory-mode.mjs';
 import { deriveMemoryProjection } from './memory-store.mjs';
 import { assertVaultPathSafe, assertVaultPathsSafe } from './vault-path-safety.mjs';
 import { validateMemoryBundle } from '../src/validate-memory.mjs';
+import { isHistoricalHandoffCandidate } from '../packages/vault/src/memory-candidate-policy.mjs';
 
 const DEFAULT_PENDING_PATTERNS = [
   /^- \[ \] Revisar resumo da sessão$/i,
@@ -115,6 +116,12 @@ const memoryCandidatesCommand = (vaultBase) => (
 const memoryCurateCommand = (vaultBase) => (
   `${WENDKEEP_COMMAND} memory curate --vault ${quoteCommandArgument(vaultBase)}`
 );
+const memoryCurateAllCommand = (vaultBase) => (
+  `${WENDKEEP_COMMAND} memory curate --all --vault ${quoteCommandArgument(vaultBase)}`
+);
+const memoryRescopeCommand = (vaultBase, { apply = false } = {}) => (
+  `${WENDKEEP_COMMAND} memory rescope${apply ? ' --apply' : ''} --vault ${quoteCommandArgument(vaultBase)}`
+);
 
 const MEMORY_KEY_PURPOSES = new Map([
   ['handoff.latest', 'próximo handoff'],
@@ -231,6 +238,7 @@ function memoryMetrics() {
     pendingOutbox: 0,
     candidates: 0,
     activeConflicts: 0,
+    repairableHandoffs: 0,
     semanticStatus: null,
     semanticCode: null,
     semanticActiveKeys: [],
@@ -497,7 +505,12 @@ export function checkMemoryBundle(vaultBase, { registry } = {}) {
   warnings.push(...lifecycle.warnings);
 
   const unresolved = candidates.items.filter((item) => !['resolved', 'rejected', 'superseded'].includes(item?.status));
-  const activeConflicts = unresolved.filter((item) => item?.reason === 'conflict');
+  const allConflicts = unresolved.filter((item) => item?.reason === 'conflict');
+  const historicalHandoffs = allConflicts.filter(
+    (item) => isHistoricalHandoffCandidate(item, effectiveRegistry),
+  );
+  const historicalIds = new Set(historicalHandoffs.map((item) => item.candidate_id));
+  const activeConflicts = allConflicts.filter((item) => !historicalIds.has(item.candidate_id));
   const ordinaryCandidates = unresolved.filter((item) => item?.reason !== 'conflict');
   if (activeConflicts.length) {
     const label = activeConflicts.length === 1
@@ -506,6 +519,17 @@ export function checkMemoryBundle(vaultBase, { registry } = {}) {
     const purposes = groupConflictPurposes(activeConflicts).join('; ');
     warnings.push(`${label} (${purposes}). Existem versões concorrentes e nenhum dado foi escolhido automaticamente. Conflito semântico degrada somente as chaves afetadas e exige curadoria humana; memory repair não escolhe vencedor. Próximo passo: ${memoryCurateCommand(vaultBase)}. Inventário avançado: ${memoryCandidatesCommand(vaultBase)}.`);
   }
+  if (historicalHandoffs.length) {
+    const label = historicalHandoffs.length === 1
+      ? '1 handoff histórico reparável'
+      : `${historicalHandoffs.length} handoffs históricos reparáveis`;
+    warnings.push(
+      `${label}; sessões de origem estão encerradas e nenhuma versão precisa virar estado atual. `
+      + `Execute primeiro o dry-run: ${memoryRescopeCommand(vaultBase)}. `
+      + `Se a prévia estiver correta: ${memoryRescopeCommand(vaultBase, { apply: true })}. `
+      + `Dívida restante: ${memoryCurateAllCommand(vaultBase)}.`,
+    );
+  }
   if (outbox.count) warnings.push(`${outbox.count} evento(s) pendente(s) na outbox; execute o projector quando seguro.`);
   if (ordinaryCandidates.length) warnings.push(`${ordinaryCandidates.length} candidate(s) aguardando curadoria humana.`);
   for (const warning of bundle.warnings || []) warnings.push(warning);
@@ -526,6 +550,7 @@ export function checkMemoryBundle(vaultBase, { registry } = {}) {
       pendingOutbox: outbox.count,
       candidates: candidates.items.length,
       activeConflicts: activeConflicts.length,
+      repairableHandoffs: historicalHandoffs.length,
       semanticStatus: semantic.status ?? null,
       semanticCode: semantic.code ?? null,
       semanticActiveKeys: semantic.activeKeys || [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.75.0",
+  "version": "0.75.2",
   "description": "Vault-first persistent memory for AI coding agents, with an optional profile-aware governance runtime: OFF, FLOW, GUIDE, GOVERN, or ASSURE. Local-first and agent-agnostic (Claude Code, Codex, Cursor…).",
   "type": "module",
   "workspaces": [
@@ -41,7 +41,7 @@
     "node": ">=18"
   },
   "scripts": {
-    "check": "node --check scripts/release.mjs && node --check scripts/release-plan.mjs && node --check scripts/release-provenance.mjs && node --check scripts/run-scope.mjs && node --check src/release-provenance.mjs && node --check bin/wendkeep.mjs && node --check packages/cli/src/index.mjs && node --check src/init.mjs && node --check src/doctor.mjs && node --check src/project-vault.mjs && node --check src/observer-auth.mjs && node --check src/observer-privacy.mjs && node --check src/observer-snapshot.mjs && node --check src/observer-store.mjs && node --check src/observer-memory.mjs && node --check src/observer-memory-publish.mjs && node --check src/observer-sql-store.mjs && node --check src/observer-sql-migrate.mjs && node --check src/observer-sql-publish.mjs && node --check src/observer-transcript-store.mjs && node --check src/observer-server.mjs && node --check src/observer.mjs && node --check src/observer-publish.mjs && node --check src/operating-profile.mjs && node --check src/profile.mjs && node --check src/flow.mjs && node --check src/work-kind.mjs && node --check src/delivery.mjs && node --check web/observer/app.mjs && node --check hooks/observer-publish.mjs && node --check hooks/evidence-context.mjs && node --check hooks/evidence-recall.mjs && node --check hooks/memory-scope.mjs && node --check hooks/operating-profile-runtime.mjs && node --check hooks/operating-profile-task-store.mjs && node --check hooks/flow-core.mjs && node --check hooks/flow-protected-policy.mjs && node --check hooks/git-snapshot.mjs && node --check hooks/vault-path-safety.mjs && node --check hooks/vault-runtime-store.mjs && node --check packages/harness/src/index.mjs && node --check packages/harness/src/flow-store.mjs && node --check packages/harness/src/operating-profile.mjs && node --check packages/harness/src/sensors-core.mjs && node --check packages/integrations/src/host-hooks.mjs && node --check packages/integrations/src/hook-envelope.mjs && node --check packages/integrations/src/prompt-content.mjs && node --check packages/integrations/src/transcript-usage.mjs && node --check packages/integrations/src/transcripts.mjs && node --check packages/integrations/src/session-identity.mjs && node --check packages/integrations/src/index.mjs && node --check packages/mcp/src/config.mjs && node --check packages/mcp/src/index.mjs && node --check packages/vault/src/index.mjs && node --check packages/vault/src/project-vault.mjs && node --check packages/vault/src/vault-path-safety.mjs && node --check packages/vault/src/locale.mjs && node --check packages/vault/src/memory-schema.mjs && node --check packages/vault/src/memory-mode.mjs && node --check packages/vault/src/memory-scope.mjs && node --check packages/vault/src/evidence-recall.mjs && node --check packages/vault/src/memory-handoff.mjs && node --check packages/vault/src/memory-store.mjs && node --check packages/vault/src/validate-core.mjs && node --check packages/vault/src/validate-memory.mjs",
+    "check": "node --check scripts/release.mjs && node --check scripts/release-plan.mjs && node --check scripts/release-provenance.mjs && node --check scripts/run-scope.mjs && node --check src/release-provenance.mjs && node --check bin/wendkeep.mjs && node --check packages/cli/src/index.mjs && node --check src/init.mjs && node --check src/doctor.mjs && node --check src/project-vault.mjs && node --check src/observer-auth.mjs && node --check src/observer-privacy.mjs && node --check src/observer-snapshot.mjs && node --check src/observer-store.mjs && node --check src/observer-memory.mjs && node --check src/observer-memory-publish.mjs && node --check src/observer-sql-store.mjs && node --check src/observer-sql-migrate.mjs && node --check src/observer-sql-publish.mjs && node --check src/observer-transcript-store.mjs && node --check src/observer-server.mjs && node --check src/observer.mjs && node --check src/observer-publish.mjs && node --check src/operating-profile.mjs && node --check src/profile.mjs && node --check src/flow.mjs && node --check src/work-kind.mjs && node --check src/delivery.mjs && node --check web/observer/app.mjs && node --check hooks/observer-publish.mjs && node --check hooks/evidence-context.mjs && node --check hooks/evidence-recall.mjs && node --check hooks/memory-scope.mjs && node --check hooks/operating-profile-runtime.mjs && node --check hooks/operating-profile-task-store.mjs && node --check hooks/flow-core.mjs && node --check hooks/flow-protected-policy.mjs && node --check hooks/git-snapshot.mjs && node --check hooks/vault-path-safety.mjs && node --check hooks/vault-runtime-store.mjs && node --check packages/harness/src/index.mjs && node --check packages/harness/src/flow-store.mjs && node --check packages/harness/src/operating-profile.mjs && node --check packages/harness/src/sensors-core.mjs && node --check packages/integrations/src/host-hooks.mjs && node --check packages/integrations/src/hook-envelope.mjs && node --check packages/integrations/src/prompt-content.mjs && node --check packages/integrations/src/transcript-usage.mjs && node --check packages/integrations/src/transcripts.mjs && node --check packages/integrations/src/session-identity.mjs && node --check packages/integrations/src/index.mjs && node --check packages/mcp/src/config.mjs && node --check packages/mcp/src/index.mjs && node --check packages/vault/src/index.mjs && node --check packages/vault/src/project-vault.mjs && node --check packages/vault/src/vault-path-safety.mjs && node --check packages/vault/src/locale.mjs && node --check packages/vault/src/memory-schema.mjs && node --check packages/vault/src/memory-mode.mjs && node --check packages/vault/src/memory-scope.mjs && node --check packages/vault/src/memory-candidate-policy.mjs && node --check packages/vault/src/evidence-recall.mjs && node --check packages/vault/src/memory-handoff.mjs && node --check packages/vault/src/memory-store.mjs && node --check packages/vault/src/validate-core.mjs && node --check packages/vault/src/validate-memory.mjs",
     "test": "node --test --test-concurrency=2",
     "test:core": "node scripts/run-scope.mjs core",
     "release": "node scripts/release.mjs",

package/packages/cli/src/index.mjs

@@ -102,8 +102,9 @@ Usage:
                            in session notes from the linked derived notes — the body used to lag
                            behind the closing block. Dry-run by default · --apply · --json.
   wendkeep lesson add "t" "l"   Record a project-local lesson (injected at SessionStart).
-  wendkeep memory curate         Guide one semantic conflict at a time in an interactive terminal.
-                           Every promote/reject requires confirmation; --vault P.
+  wendkeep memory curate         Guide actionable semantic conflicts in an interactive terminal.
+                           --all includes historical handoffs and enables confirmed safe batch close;
+                           every promote/reject requires confirmation. --vault P.
   wendkeep memory <sub>          Shared memory v2: status | candidates [--active] | curate | migrate [--apply] | rescope [--apply] | repair |
                            recover-attempt <session> [--apply] |
                            reconcile <session> --by-session <session> --reason <text> [--apply] |

package/packages/vault/src/memory-candidate-policy.mjs

@@ -0,0 +1,47 @@
+const TERMINAL_SESSION_STATUSES = new Set([
+  'done',
+  'superseded',
+  'completed',
+  'closed',
+  'inactive',
+  'abandoned',
+]);
+
+function sessionEntry(registry, event) {
+  const sessionId = String(event?.canonical_session_id || '').trim();
+  return sessionId ? registry?.sessions?.[sessionId] || null : null;
+}
+
+/** Pure, fail-closed policy shared by doctor and interactive curation. */
+export function classifyMemoryCandidate(candidate, registry = { sessions: {} }) {
+  if (candidate?.reason !== 'conflict' || candidate?.memory_key !== 'handoff.latest') {
+    return { classification: 'actionable' };
+  }
+
+  const events = Array.isArray(candidate.events) ? candidate.events : [];
+  if (!events.length) return { classification: 'unknown' };
+  const entries = events.map((event) => sessionEntry(registry, event));
+  if (entries.some((entry) => !entry)) return { classification: 'unknown' };
+  if (entries.some((entry) => String(entry.status || '').trim() === 'active')) {
+    return { classification: 'actionable' };
+  }
+  if (entries.every((entry) => TERMINAL_SESSION_STATUSES.has(String(entry.status || '').trim()))) {
+    return { classification: 'historical', recommended_action: 'reject' };
+  }
+  return { classification: 'unknown' };
+}
+
+export function candidateSessionContext(event, registry = { sessions: {} }) {
+  const entry = sessionEntry(registry, event);
+  if (!entry) return {};
+  const status = String(entry.status || '').trim();
+  const changeSlug = String(entry.change_slug || entry.changeSlug || '').trim();
+  return {
+    ...(status ? { session_status: status } : {}),
+    ...(changeSlug ? { change_slug: changeSlug } : {}),
+  };
+}
+
+export function isHistoricalHandoffCandidate(candidate, registry) {
+  return classifyMemoryCandidate(candidate, registry).classification === 'historical';
+}

package/src/doctor.mjs

@@ -39,7 +39,8 @@ export function renderVaultHealthLines(result) {
   lines.push(
     `[memória] ${healthStatusLabel(result.memoryStatus)} — schema: ${metricValue(memory.schemaVersion)} · revisão: ${metricValue(memory.revision)} · cursor: ${metricValue(memory.eventCursor)} · hash: ${metricValue(memory.stateHash)}`,
   );
-  lines.push(`  ledger: ${metricValue(memory.ledgerEvents)} evento(s) · outbox: ${metricValue(memory.pendingOutbox)} · candidates: ${metricValue(memory.candidates)} · conflitos: ${metricValue(memory.activeConflicts)}`);
+  const repairableHandoffs = Number(memory.repairableHandoffs || 0);
+  lines.push(`  ledger: ${metricValue(memory.ledgerEvents)} evento(s) · outbox: ${metricValue(memory.pendingOutbox)} · candidates: ${metricValue(memory.candidates)} · conflitos: ${metricValue(memory.activeConflicts)}${repairableHandoffs ? ` · handoffs reparáveis: ${repairableHandoffs}` : ''}`);
   const semanticKeys = memory.semanticActiveKeys || [];
   const semanticProjected = memory.semanticProjectedKeys || [];
   const semanticMissing = memory.semanticMissingKeys || [];

package/src/memory-curate.mjs

@@ -21,10 +21,18 @@ const TEXT = {
     observed: 'registrado em',
     newer: 'mais recente',
     actions: '[1-N] Manter uma versão · [P] Pular · [R] Encerrar sem vencedor · [D] Detalhes · [Q] Sair',
+    historicalAction: '[H] Encerrar todos os handoffs históricos recomendados',
+    terminalContext: 'sessão encerrada',
+    activeContext: 'sessão ativa',
+    changeContext: (slug) => `change: ${slug}`,
+    safeRecommendation: 'Recomendação segura: encerrar sem vencedor; as evidências permanecem no ledger.',
+    historicalOmitted: (count) => `${count} handoff(s) histórico(s) reparável(is) foram omitidos. Use --all para revisar ou encerrar em lote.`,
+    confirmHistorical: (count) => `Encerrar ${count} handoff(s) histórico(s) sem vencedor? Cada decisão será auditada. [s/N] `,
+    historicalClosed: (count) => `${count} handoff(s) histórico(s) encerrado(s) com decisão auditada.`,
     choose: '> ',
     confirmPromote: (number) => `Manter a versão ${number}? Essa decisão será gravada agora. [s/N] `,
     confirmReject: 'Encerrar este conflito sem escolher uma versão? Essa decisão será gravada agora. [s/N] ',
-    invalid: 'Opção inválida. Escolha um número exibido, P, R, D ou Q.',
+    invalid: 'Opção inválida. Escolha um número exibido, P, R, D, H ou Q.',
     declined: 'Decisão não confirmada; nenhum byte foi alterado.',
     promoted: 'Versão promovida e decisão auditada.',
     rejected: 'Conflito encerrado sem promover uma versão.',
@@ -47,10 +55,18 @@ const TEXT = {
     observed: 'recorded at',
     newer: 'newest timestamp',
     actions: '[1-N] Keep one version · [P] Skip · [R] Close without a winner · [D] Details · [Q] Quit',
+    historicalAction: '[H] Close every safely recommended historical handoff',
+    terminalContext: 'closed session',
+    activeContext: 'active session',
+    changeContext: (slug) => `change: ${slug}`,
+    safeRecommendation: 'Safe recommendation: close without a winner; evidence remains in the ledger.',
+    historicalOmitted: (count) => `${count} repairable historical handoff(s) were omitted. Use --all to review or close them in a batch.`,
+    confirmHistorical: (count) => `Close ${count} historical handoff(s) without a winner? Every decision will be audited. [y/N] `,
+    historicalClosed: (count) => `${count} historical handoff(s) closed with audited decisions.`,
     choose: '> ',
     confirmPromote: (number) => `Keep version ${number}? This decision will be written now. [y/N] `,
     confirmReject: 'Close this conflict without choosing a version? This decision will be written now. [y/N] ',
-    invalid: 'Invalid option. Choose a displayed number, P, R, D, or Q.',
+    invalid: 'Invalid option. Choose a displayed number, P, R, D, H, or Q.',
     declined: 'Decision not confirmed; no bytes were changed.',
     promoted: 'Version promoted and decision audited.',
     rejected: 'Conflict closed without promoting a version.',
@@ -125,13 +141,24 @@ export function renderMemoryConflict(candidate, {
     const source = text.sourceKinds[event.source] || text.sourceKinds.unknown;
     lines.push(`[${eventIndex + 1}] ${text.source}: ${source}${recent}`);
     if (event.observed_at) lines.push(`    ${text.observed}: ${event.observed_at}`);
+    const context = [
+      event.session_status === 'active' ? text.activeContext
+        : event.session_status ? text.terminalContext : '',
+      event.change_slug ? text.changeContext(event.change_slug) : '',
+    ].filter(Boolean);
+    if (context.length) lines.push(`    ${context.join(' · ')}`);
     lines.push(`    ${event.preview}`);
   });
+  if (candidate.classification === 'historical'
+      && candidate.recommended_action === 'reject') {
+    lines.push('', text.safeRecommendation);
+  }
   if (details) {
     lines.push('', `${text.details}:`, `  candidate: ${candidate.candidate_id}`);
     candidate.events.forEach((event) => lines.push(`  event: ${event.event_id}`));
   }
   lines.push('', text.actions);
+  if (candidate.classification === 'historical') lines.push(text.historicalAction);
   return `${lines.join('\n')}\n`;
 }
 
@@ -141,6 +168,7 @@ export async function runGuidedMemoryCuration(vault, {
   loadCandidates = listMemoryCandidatesForCuration,
   decide = decideMemoryCandidate,
   locale = 'pt-BR',
+  omittedHistorical = 0,
 } = {}) {
   if (typeof ask !== 'function' || typeof write !== 'function') {
     throw new TypeError('runGuidedMemoryCuration requer ask e write.');
@@ -167,6 +195,7 @@ export async function runGuidedMemoryCuration(vault, {
     if (first) {
       sessionTotal = loaded.length;
       write(`${text.title}\n${text.intro(loaded.length)}\n`);
+      if (omittedHistorical) write(`${text.historicalOmitted(omittedHistorical)}\n`);
       if (loaded.length) write(`${text.categories}\n${groupLines(loaded, id).join('\n')}\n`);
       first = false;
     }
@@ -207,6 +236,56 @@ export async function runGuidedMemoryCuration(vault, {
       }));
       continue;
     }
+    if (answer === 'h') {
+      const historicalCount = loaded.filter((item) => (
+        item.classification === 'historical' && item.recommended_action === 'reject'
+      )).length;
+      if (!historicalCount) {
+        write(`${text.invalid}\n`);
+        continue;
+      }
+      const confirmation = await ask(text.confirmHistorical(historicalCount));
+      if (!isAffirmative(confirmation)) {
+        write(`${text.declined}\n`);
+        continue;
+      }
+      let closed = 0;
+      const batchIds = new Set();
+      while (true) {
+        let refreshed;
+        try {
+          refreshed = loadCandidates(vault);
+        } catch {
+          write(`${text.blocked}\n`);
+          return { status: 'blocked', decisions, skipped };
+        }
+        const next = refreshed.find((item) => (
+          item.classification === 'historical' && item.recommended_action === 'reject'
+        ));
+        if (!next) break;
+        if (batchIds.has(next.candidate_id)) {
+          write(`${text.blocked}\n`);
+          return { status: 'blocked', decisions, skipped };
+        }
+        batchIds.add(next.candidate_id);
+        let batchResult;
+        try {
+          batchResult = decide(vault, { action: 'reject', candidateId: next.candidate_id });
+        } catch {
+          write(`${text.blocked}\n`);
+          return { status: 'blocked', decisions, skipped };
+        }
+        if (batchResult?.status !== 'rejected') {
+          write(`${text.blocked}\n`);
+          return { status: 'blocked', decisions, skipped };
+        }
+        decisions += 1;
+        closed += 1;
+        decidedIds.add(next.candidate_id);
+      }
+      write(`${text.historicalClosed(closed)}\n`);
+      continue;
+    }
 
     let decision;
     let confirmation;
@@ -260,11 +339,18 @@ function usageError(message) {
 export function parseMemoryCurateArgs(argv) {
   let vault = '';
   let seenVault = false;
+  let includeHistorical = false;
   for (let index = 0; index < argv.length; index += 1) {
     const token = argv[index];
     if (!token.startsWith('--')) throw usageError(`argumento posicional inesperado: ${token}.`);
     const equalAt = token.indexOf('=');
     const name = equalAt >= 0 ? token.slice(0, equalAt) : token;
+    if (name === '--all') {
+      if (equalAt >= 0) throw usageError('--all não aceita valor.');
+      if (includeHistorical) throw usageError('--all duplicado.');
+      includeHistorical = true;
+      continue;
+    }
     if (name !== '--vault') throw usageError(`opção desconhecida: ${name}.`);
     if (seenVault) throw usageError('--vault duplicado.');
     const value = equalAt >= 0 ? token.slice(equalAt + 1) : argv[index + 1];
@@ -275,7 +361,7 @@ export function parseMemoryCurateArgs(argv) {
     seenVault = true;
     if (equalAt < 0) index += 1;
   }
-  return { vault };
+  return { vault, ...(includeHistorical ? { includeHistorical: true } : {}) };
 }
 
 export async function runMemoryCurateCli(argv, {
@@ -313,8 +399,16 @@ export async function runMemoryCurateCli(argv, {
 
   const rl = createInterface({ input, output });
   try {
+    const allCandidates = listMemoryCandidatesForCuration(vault, { includeHistorical: true });
+    const omittedHistorical = args.includeHistorical
+      ? 0
+      : allCandidates.filter((item) => item.classification === 'historical').length;
     const result = await runGuidedMemoryCuration(vault, {
       locale: getLocale(vault).id,
+      omittedHistorical,
+      loadCandidates: (base) => listMemoryCandidatesForCuration(base, {
+        includeHistorical: Boolean(args.includeHistorical),
+      }),
       ask: (question) => rl.question(question),
       write: (value) => output.write(String(value)),
     });

package/src/memory.mjs

@@ -21,6 +21,10 @@ import {
 import { validateCore } from './validate-core.mjs';
 import { checkMemoryBundle } from '../hooks/vault-health.mjs';
 import { scopeForMemoryKey } from '../hooks/memory-scope.mjs';
+import {
+  candidateSessionContext,
+  classifyMemoryCandidate,
+} from '../packages/vault/src/memory-candidate-policy.mjs';
 
 const BRAIN = '.brain';
 const LEDGER = 'MEMORY_EVENTS.jsonl';
@@ -241,24 +245,17 @@ export function planScopedMemoryMigration(vault) {
   const projection = deriveMemoryProjection(vault, ledger.events);
   const ambiguous = new Set(projection.candidates.map((candidate) => candidate.record_key || candidate.memory_key));
   const existingIds = new Set(ledger.events.map((event) => event.event_id));
+  const alreadyRescopedSourceIds = new Set(ledger.events.flatMap((event) => [
+    event.rescopes_event_id,
+    ...(Array.isArray(event.rescopes_event_ids) ? event.rescopes_event_ids : []),
+  ]).filter(Boolean));
   const planned = [];
+  const plannedSourceIds = new Set();
 
-  for (const [recordKey, record] of Object.entries(projection.records)) {
-    if (ambiguous.has(recordKey) || record.source?.scope) continue;
-    const source = record.source;
-    const sameLegacyKey = ledger.events.filter((event) => (
-      !event.scope && event.memory_key === source.memory_key && !event.rescopes_event_id
-    ));
-    const scope = scopeForMemoryKey(source.memory_key, {
-      ...source,
-      projectId: source.project_id,
-      workSessionId: source.work_session_id,
-      branch: source.value?.branch || source.value?.branch_name,
-      worktreeId: source.value?.worktree_id,
-      repositoryId: source.value?.repository_id,
-    });
+  const appendRescope = (source, scope, rescopesEventIds = [source.event_id]) => {
     const eventId = rescopeEventId(source.event_id, scope);
-    if (existingIds.has(eventId)) continue;
+    if (existingIds.has(eventId) || alreadyRescopedSourceIds.has(source.event_id)
+        || plannedSourceIds.has(source.event_id)) return false;
     planned.push({
       v: 1,
       event_id: eventId,
@@ -266,7 +263,7 @@ export function planScopedMemoryMigration(vault) {
       memory_key: source.memory_key,
       scope,
       operation: 'assert',
-      value: record.value,
+      value: source.value,
       authority: source.authority,
       canonical_session_id: source.canonical_session_id || 'memory-rescope',
       activation_id: source.activation_id || 'memory-rescope',
@@ -275,9 +272,58 @@ export function planScopedMemoryMigration(vault) {
       source_turn_id: source.source_turn_id || 'memory-rescope',
       observed_at: source.observed_at || new Date(0).toISOString(),
       evidence: [...new Set([...(source.evidence || []), `memory-rescope:${source.event_id}`])],
+      ...(source.work_session_id ? { work_session_id: source.work_session_id } : {}),
       rescopes_event_id: source.event_id,
-      rescopes_event_ids: sameLegacyKey.map((event) => event.event_id).sort(),
+      rescopes_event_ids: [...new Set(rescopesEventIds)].sort(),
     });
+    plannedSourceIds.add(source.event_id);
+    return true;
+  };
+
+  for (const [recordKey, record] of Object.entries(projection.records)) {
+    if (ambiguous.has(recordKey) || record.source?.scope) continue;
+    const source = record.source;
+    const sameLegacyKey = ledger.events.filter((event) => (
+      !event.scope && event.memory_key === source.memory_key && !event.rescopes_event_id
+    ));
+    const scope = scopeForMemoryKey(source.memory_key, {
+      ...source,
+      projectId: source.project_id,
+      workSessionId: source.work_session_id,
+      branch: source.value?.branch || source.value?.branch_name,
+      worktreeId: source.value?.worktree_id,
+      repositoryId: source.value?.repository_id,
+    });
+    const eventId = rescopeEventId(source.event_id, scope);
+    if (existingIds.has(eventId)) continue;
+    appendRescope(
+      { ...source, value: record.value },
+      scope,
+      sameLegacyKey.map((event) => event.event_id),
+    );
+  }
+
+  let rescopableConflicts = 0;
+  for (const candidate of projection.candidates) {
+    if (candidate.reason !== 'conflict' || candidate.memory_key !== 'handoff.latest') continue;
+    const sources = Array.isArray(candidate.events) ? candidate.events : [];
+    if (!sources.length || sources.some((source) => (
+      source.scope || (!source.work_session_id && !source.canonical_session_id)
+    ))) continue;
+
+    const scopedSources = sources.map((source) => ({
+      source,
+      scope: scopeForMemoryKey(source.memory_key, {
+        ...source,
+        projectId: source.project_id,
+        workSessionId: source.work_session_id,
+      }),
+    }));
+    if (scopedSources.some(({ scope }) => scope.type !== 'work_session'
+        || scope.id.startsWith('legacy:'))) continue;
+
+    rescopableConflicts += 1;
+    for (const { source, scope } of scopedSources) appendRescope(source, scope);
   }
 
   return {
@@ -285,6 +331,7 @@ export function planScopedMemoryMigration(vault) {
     ledger_events: ledger.events.length,
     planned: planned.length,
     ambiguous: projection.candidates.length,
+    rescopable_conflicts: rescopableConflicts,
     events: planned,
   };
 }
@@ -298,13 +345,18 @@ export function rescopeMemoryEvents(vault, { apply = false } = {}) {
       ledger_events: plan.ledger_events,
       planned: plan.planned,
       ambiguous: plan.ambiguous,
+      rescopable_conflicts: plan.rescopable_conflicts,
       scopes: plan.events.map((event) => ({
         event_id: event.event_id, memory_key: event.memory_key, scope: event.scope,
       })),
     };
   }
   if (!plan.events.length) {
-    return { status: 'unchanged', migrated: 0, ambiguous: plan.ambiguous };
+    return {
+      status: 'unchanged', migrated: 0, ambiguous: plan.ambiguous,
+      rescopable_conflicts: plan.rescopable_conflicts,
+      remaining_ambiguous: plan.ambiguous,
+    };
   }
   for (const event of plan.events) enqueueMemoryEvent(vault, event);
   const projection = projectMemoryOutbox(vault);
@@ -312,6 +364,10 @@ export function rescopeMemoryEvents(vault, { apply = false } = {}) {
     status: projection.status === 'projected' ? 'migrated' : projection.status,
     migrated: plan.events.length,
     ambiguous: plan.ambiguous,
+    rescopable_conflicts: plan.rescopable_conflicts,
+    remaining_ambiguous: Number.isInteger(projection.candidates)
+      ? projection.candidates
+      : plan.ambiguous,
     checkpoint: projection.checkpoint || null,
   };
 }
@@ -377,7 +433,7 @@ function curationPreview(value) {
     : `${visible.slice(0, CURATION_PREVIEW_CHARS - 1).trimEnd()}…`;
 }
 
-function sanitizedCurationEvent(candidate, eventId, candidateIndex) {
+function sanitizedCurationEvent(candidate, eventId, candidateIndex, registry) {
   const events = Array.isArray(candidate.events) ? candidate.events : [];
   const event = events.find((item) => item?.event_id === eventId);
   if (!event || typeof event !== 'object' || Array.isArray(event)) {
@@ -397,15 +453,24 @@ function sanitizedCurationEvent(candidate, eventId, candidateIndex) {
     observed_at: sanitizeMemoryText(event.observed_at || event.effective_at || ''),
     source: sanitizeMemoryText(source),
     preview: curationPreview(event.value),
+    ...Object.fromEntries(Object.entries(candidateSessionContext(event, registry))
+      .map(([key, value]) => [key, sanitizeMemoryText(value)])),
   };
 }
 
-export function listMemoryCandidatesForCuration(vault) {
+export function listMemoryCandidatesForCuration(vault, { includeHistorical = false } = {}) {
+  const registry = readSessionRegistry(vault);
   return readCandidates(vault)
-    .map((candidate, index) => ({ candidate, index, safe: sanitizedCandidate(candidate, index) }))
+    .map((candidate, index) => ({
+      candidate,
+      index,
+      safe: sanitizedCandidate(candidate, index),
+      policy: classifyMemoryCandidate(candidate, registry),
+    }))
     .filter(({ safe }) => safe.reason === 'conflict'
       && !TERMINAL_CANDIDATE_STATUSES.has(safe.status))
-    .map(({ candidate, index, safe }) => {
+    .filter(({ policy }) => includeHistorical || policy.classification !== 'historical')
+    .map(({ candidate, index, safe, policy }) => {
       if (!safe.event_ids.length) {
         throw new Error(
           `MEMORY_CANDIDATES.jsonl: candidate ${index + 1} sem eventos elegíveis.`,
@@ -416,8 +481,12 @@ export function listMemoryCandidatesForCuration(vault) {
         reason: safe.reason,
         status: safe.status,
         memory_key: safe.memory_key,
+        classification: policy.classification,
+        ...(policy.recommended_action ? { recommended_action: policy.recommended_action } : {}),
         ...(safe.scope ? { scope: safe.scope } : {}),
-        events: safe.event_ids.map((eventId) => sanitizedCurationEvent(candidate, eventId, index)),
+        events: safe.event_ids.map(
+          (eventId) => sanitizedCurationEvent(candidate, eventId, index, registry),
+        ),
       };
     })
     .sort((left, right) => lexicalCompare(left.memory_key, right.memory_key)

package/src/observer-sql-publish.mjs

@@ -26,6 +26,7 @@ export const SQL_EVENT_BATCH_SIZE = 64;
 export const SQL_EVENT_BATCH_BYTES = 8 * 1024 * 1024;
 const REQUEST_TIMEOUT_MS = 15000;
 const MAX_REQUEST_TIMEOUT_MS = 120000;
+export const SQL_LEASE_STALE_MS = MAX_REQUEST_TIMEOUT_MS + 30000;
 const REQUEST_TIMEOUT_BYTES_STEP = 1024 * 1024;
 const CAPTURE_LEVELS = new Set(['metadata', 'messages', 'full-transcript']);
 
@@ -262,7 +263,7 @@ function dedupeEvents(events) {
   });
 }
 
-export function buildObserverSqlEventBatch({ vaultBase, projectId, input = {}, now = new Date(), state = readState(vaultBase), remoteDocuments = {}, captureLevel = process.env.WENDKEEP_OBSERVER_CAPTURE_LEVEL || 'metadata' } = {}) {
+export function buildObserverSqlEventBatch({ vaultBase, projectId, input = {}, now = new Date(), state = readState(vaultBase), remoteDocuments = {}, captureLevel = process.env.WENDKEEP_OBSERVER_CAPTURE_LEVEL || 'metadata', forceFull = false } = {}) {
   if (!vaultBase || !projectId) throw new Error('vaultBase e projectId são obrigatórios.');
   const occurredAt = isoNow(now);
   const resolvedCaptureLevel = normalizeObserverCaptureLevel(captureLevel);
@@ -289,7 +290,7 @@ export function buildObserverSqlEventBatch({ vaultBase, projectId, input = {}, n
     nextState.files[file.logicalPath] = { content_hash: contentHash, revision: revision || 1 };
     const fm = parseFrontmatter(content);
     if (fm.type === 'session') sessionContexts.push({ file, content, fm, contentHash, revision: revision || 1, sessionId: sessionIdentity.get(file.logicalPath) });
-    if (previous?.content_hash === contentHash) continue;
+    if (!forceFull && previous?.content_hash === contentHash) continue;
     changed += 1;
     events.push(documentEvent({ projectId, logicalPath: file.logicalPath, content, metadata: fm, revision: revision || 1, occurredAt }));
     if (fm.type === 'session') {
@@ -309,7 +310,7 @@ export function buildObserverSqlEventBatch({ vaultBase, projectId, input = {}, n
       const content = readFileSync(source.path, 'utf8');
       const fingerprint = hash(content);
       const previousTranscript = state.transcripts?.[source.transcriptId];
-      if (previousTranscript?.content_hash === fingerprint && previousTranscript?.coverage === resolvedCaptureLevel) continue;
+      if (!forceFull && previousTranscript?.content_hash === fingerprint && previousTranscript?.coverage === resolvedCaptureLevel) continue;
       const complete = completeTranscriptEvents({ projectId, sessionId, mainAgentId, provider, model, source, now: occurredAt, captureLevel: resolvedCaptureLevel });
       nextState.transcripts[source.transcriptId] = { content_hash: complete.fingerprint, coverage: resolvedCaptureLevel };
       const summaryId = complete.transcriptId;
@@ -467,11 +468,20 @@ function queueOutbox(vaultBase, batch) {
 
 function eventCoalesceKey(event) {
   const payload = event.payload || {};
+  const entityFields = {
+    'document.upsert': ['logical_path'],
+    'document.delete': ['logical_path'],
+    'session.upsert': ['session_id'],
+    'agent.upsert': ['agent_id'],
+    'usage.rollup': ['rollup_key'],
+    llm_call: ['call_id'],
+    'transcript.upsert': ['transcript_id'],
+  }[event.kind] || [];
+  const entityId = entityFields.map((field) => payload[field]).find(Boolean) || event.event_id;
   return [
     event.project_id,
     event.kind,
-    payload.logical_path || payload.session_id || payload.agent_id || payload.rollup_key
-      || payload.call_id || payload.transcript_id || event.event_id,
+    entityId,
   ].join('\u001f');
 }
 
@@ -480,15 +490,17 @@ function waitSync(milliseconds) { Atomics.wait(WAIT_ARRAY, 0, 0, milliseconds);
 
 function acquireBatchFileLease(path, waitMs = 0) {
   const lock = `${path}.lock`;
+  const token = `${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
   const deadline = Date.now() + Math.max(0, waitMs);
   do {
     try {
       mkdirSync(lock);
-      return lock;
+      atomicJson(join(lock, 'owner.json'), { token, pid: process.pid, acquired_at: new Date().toISOString() });
+      return { path: lock, token };
     } catch (error) {
       if (error?.code !== 'EEXIST') throw error;
       try {
-        if (Date.now() - statSync(lock).mtimeMs > 60_000) {
+        if (Date.now() - statSync(lock).mtimeMs > SQL_LEASE_STALE_MS) {
           const stale = `${lock}.stale-${process.pid}-${Date.now()}`;
           renameSync(lock, stale);
           rmSync(stale, { recursive: true, force: true });
@@ -502,8 +514,10 @@ function acquireBatchFileLease(path, waitMs = 0) {
   return null;
 }
 
-function releaseBatchFileLease(lock) {
-  if (lock) rmSync(lock, { recursive: true, force: true });
+function releaseBatchFileLease(lease) {
+  if (!lease) return;
+  const owner = readJson(join(lease.path, 'owner.json'), {});
+  if (owner.token === lease.token) rmSync(lease.path, { recursive: true, force: true });
 }
 
 /** Queue a precise writer batch and replace older pending state for the same logical scope. */
@@ -625,7 +639,7 @@ function acquirePublisherLease(vaultBase, currentTime = Date.now()) {
     if (error?.code !== 'EEXIST') throw error;
     let age = 0;
     try { age = currentTime - statSync(path).mtimeMs; } catch { return null; }
-    if (age <= 60_000) return null;
+    if (age <= SQL_LEASE_STALE_MS) return null;
     const stale = `${path}.stale-${token}`;
     try {
       renameSync(path, stale);
@@ -770,14 +784,14 @@ export async function publishObserverSqlIncremental({
   };
 }
 
-export async function publishObserverSql({ vaultBase, projectId, url = process.env.WENDKEEP_OBSERVER_URL || '', input = {}, now = new Date(), fetchImpl = globalThis.fetch, token = process.env.WENDKEEP_OBSERVER_TOKEN || '', captureLevel = process.env.WENDKEEP_OBSERVER_CAPTURE_LEVEL || 'metadata' } = {}) {
+export async function publishObserverSql({ vaultBase, projectId, url = process.env.WENDKEEP_OBSERVER_URL || '', input = {}, now = new Date(), fetchImpl = globalThis.fetch, token = process.env.WENDKEEP_OBSERVER_TOKEN || '', captureLevel = process.env.WENDKEEP_OBSERVER_CAPTURE_LEVEL || 'metadata', forceFull = false } = {}) {
   if (!vaultBase || !projectId) throw new Error('vaultBase e projectId são obrigatórios.');
   const replay = await retryObserverSqlOutbox({ vaultBase, projectId, url, fetchImpl, token });
   const state = readState(vaultBase);
-  const remoteDocuments = Object.keys(state.files || {}).length === 0
+  const remoteDocuments = forceFull || Object.keys(state.files || {}).length === 0
     ? await readRemoteDocuments({ url, projectId, fetchImpl, token })
     : {};
-  const batch = buildObserverSqlEventBatch({ vaultBase, projectId, input, now, state, remoteDocuments, captureLevel });
+  const batch = buildObserverSqlEventBatch({ vaultBase, projectId, input, now, state, remoteDocuments, captureLevel, forceFull });
   if (!batch.events.length) {
     atomicJson(statePath(vaultBase), batch.nextState);
     return { ok: true, queued: false, scanned: batch.scanned, changed: batch.changed, pending: listSqlOutbox(vaultBase).length, replay };

package/src/observer.mjs

@@ -147,6 +147,7 @@ export async function runObserver(argv = [], { write = (chunk) => process.stdout
       projectId: snapshot.project_id,
       url,
       token,
+      forceFull: true,
       captureLevel: optionValue(argv, '--capture-level') || process.env.WENDKEEP_OBSERVER_CAPTURE_LEVEL || 'metadata',
     });
     const snapshotResponse = await fetch(`${String(url).replace(/\/$/, '')}/v1/projects/${encodeURIComponent(snapshot.project_id)}/snapshot`, {
@@ -209,6 +210,7 @@ export async function runObserver(argv = [], { write = (chunk) => process.stdout
       projectId: snapshot.project_id,
       url,
       token,
+      forceFull: true,
       captureLevel: optionValue(argv, '--capture-level') || process.env.WENDKEEP_OBSERVER_CAPTURE_LEVEL || 'metadata',
     });
     const snapshotResponse = await fetch(`${String(url).replace(/\/$/, '')}/v1/projects/${encodeURIComponent(snapshot.project_id)}/snapshot`, {