wendkeep 0.67.0 → 0.67.2

package/CHANGELOG.md

@@ -4,6 +4,41 @@ 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.67.2] — 2026-08-02
+
+### Fixed
+
+- **O doctor agora exibe comandos de reparo executáveis no projeto.** Os diagnósticos de memória
+  e observabilidade usam `npx --no-install wendkeep`, informam o Vault absoluto resolvido em
+  `--vault` e
+  mantêm a sequência segura de inspeção (dry-run) antes da variante explícita com `--apply`.
+- **O doctor continua somente leitura.** A correção altera apenas as recomendações exibidas; o
+  reparo continua exigindo execução humana do comando `--apply`.
+
+## [0.67.1] — 2026-08-02
+
+### Fixed
+
+- **Turnos de subagents não bloqueiam mais a captura da sessão-mãe.** `UserPromptSubmit` de rollout
+  filho registra o path para observabilidade sem avançar a sequência principal, e `SessionStop`
+  prefere o mapeamento causal `turn_sequences[turn_id]` antes da ordem local do transcript. Isso
+  preserva os marcadores `wk-turn`, o encerramento e a memória mesmo com filhos intercalados.
+- **`SubagentStop` consome o transcript correto do payload Codex.** O hook resolve o filho por
+  `agent_transcript_path`/`agentTranscriptPath`, valida identidade, sessão e `parent_thread_id`
+  contra um root comprovado e mantém `transcript_path` como contexto da sessão-mãe, permitindo
+  preencher `Subagents e workflows` no último filho sem aceitar sinais de outra cadeia.
+- **O backfill não grava o turno Codex ainda em execução.** `hook session-backfill` exige
+  `task_complete`, separa `missingTurns` de `incompleteTurns`, permanece dry-run por padrão e aplica
+  somente turnos concluídos de forma idempotente. A CLI agora encaminha `--session`, `--vault`,
+  `--write` e demais argumentos ao hook executado. README e guias PT-BR/EN documentam o reparo.
+- **O bloco gerenciado do `AGENTS.md` exige roteamento adaptativo antes de editar.** O harness
+  inspeciona o perfil-base, classifica a solicitação, registra uma lease temporária entre `FLOW`,
+  `GUIDE`, `GOVERN` e `ASSURE` e confirma o perfil efetivo; `OFF` nunca é escolhido pela LLM e a
+  escolha explícita do usuário prevalece.
+- **O scanner de privacidade distingue configuração pública de identificadores privados.** Comandos
+  longos legítimos em `wendkeep.sensors.json` deixam de gerar falso positivo, sem permitir que UUID,
+  hash, token compacto, campo desconhecido ou path absoluto sejam ocultados pela exceção.
+
 ## [0.67.0] — 2026-08-01
 
 ### Added

package/README.en.md

@@ -346,20 +346,20 @@ Codex uses `session_id`/`turn_id` plus transcript order, with no artificial caus
 `DIGEST.md` is no longer the operational handoff: it remains the `/brain-recall` bridge and legacy-vault fallback. A vault without SHARED receives CORE+DIGEST with a deprecation warning; migrate during the compatibility window:
 
 ```bash
-wendkeep memory status --gate --vault .MyApp-vault
-wendkeep memory migrate --vault .MyApp-vault          # preview, zero writes
-wendkeep memory migrate --apply --vault .MyApp-vault  # backup + candidates + v2 bundle
+npx --no-install wendkeep memory status --gate --vault .MyApp-vault
+npx --no-install wendkeep memory migrate --vault .MyApp-vault          # preview, zero writes
+npx --no-install wendkeep memory migrate --apply --vault .MyApp-vault  # backup + candidates + v2 bundle
 ```
 
 ### Health and recovery
 
-Use `wendkeep memory status --gate --vault <vault>` in CI and before `verify`/`archive`. Revision 0
+Use `npx --no-install wendkeep memory status --gate --vault <vault>` in CI and before `verify`/`archive`. Revision 0
 immediately after valid migration is healthy. The gate correlates `last_memory_attempt`, outbox,
 ledger, SHARED, and checkpoint: `degraded` with a durable outbox is a warning; an ambiguous attempt,
 lost publication, or mismatched checkpoint blocks. See [migration](docs/en/commands/memory-migration.md)
 and [diagnostics](docs/en/commands/maintenance-and-diagnostics.md).
 
-If status blocks, preserve the evidence and run `wendkeep memory repair --vault <vault>` to back up
+If status blocks, preserve the evidence and run `npx --no-install wendkeep memory repair --vault <vault>` to back up
 the corrupt ledger, retain valid lines, and re-project. Repair remains structural: its only narrow
 acknowledgement exception covers attempts entirely represented by the outbox consumed by that same
 run; it does not scan or reclassify historical attempts. Valid pre-0.59 causal checkpoints and
@@ -385,7 +385,7 @@ acknowledgement pending on 0.66.4 or later, first run the targeted dry run
 registry/checkpoint. See syntax, preconditions, and fail-closed behavior in
 [memory and curation](docs/en/commands/memory.md).
 
-Session notes use one live `## Agentes, tokens e custos` snapshot. Main-agent and subagent hooks recompose it atomically, with costs, token dimensions, reasoning tokens and effort per model/source. Every hook that rewrites a session note takes a per-file lock and writes through a temp file + rename, so the `SubagentStop` fan-out (one hook run per subagent) can never leave a note half-written; a note whose frontmatter reads back damaged is left untouched rather than patched.
+Session notes use one live `## Agentes, tokens e custos` snapshot. Main-agent and subagent hooks recompose it atomically, with costs, token dimensions, reasoning tokens and effort per model/source. On Codex, subagent prompts register their rollout for observability without advancing the main agent's sequence; `SubagentStop` reads the child from `agent_transcript_path` and persists its signal only when `parent_thread_id` matches a validated session root. The main Stop uses the registry's causal `turn_id` mapping before falling back to local transcript order. To recover missing markers while a conversation is open, `hook session-backfill` is a dry-run by default and never writes a Codex turn without `task_complete`. Every hook that rewrites a session note takes a per-file lock and writes through a temp file + rename, so the `SubagentStop` fan-out (one hook run per subagent) can never leave a note half-written; a note whose frontmatter reads back damaged is left untouched rather than patched.
 
 ## Retroactive memory (`import`) — install today, remember yesterday
 

package/README.md

@@ -346,20 +346,20 @@ Codex uses `session_id`/`turn_id` plus transcript order, with no artificial caus
 `DIGEST.md` is no longer the operational handoff: it remains the `/brain-recall` bridge and legacy-vault fallback. A vault without SHARED receives CORE+DIGEST with a deprecation warning; migrate during the compatibility window:
 
 ```bash
-wendkeep memory status --gate --vault .MyApp-vault
-wendkeep memory migrate --vault .MyApp-vault          # preview, zero writes
-wendkeep memory migrate --apply --vault .MyApp-vault  # backup + candidates + v2 bundle
+npx --no-install wendkeep memory status --gate --vault .MyApp-vault
+npx --no-install wendkeep memory migrate --vault .MyApp-vault          # preview, zero writes
+npx --no-install wendkeep memory migrate --apply --vault .MyApp-vault  # backup + candidates + v2 bundle
 ```
 
 ### Health and recovery
 
-Use `wendkeep memory status --gate --vault <vault>` in CI and before `verify`/`archive`. Revision 0
+Use `npx --no-install wendkeep memory status --gate --vault <vault>` in CI and before `verify`/`archive`. Revision 0
 immediately after valid migration is healthy. The gate correlates `last_memory_attempt`, outbox,
 ledger, SHARED, and checkpoint: `degraded` with a durable outbox is a warning; an ambiguous attempt,
 lost publication, or mismatched checkpoint blocks. See [migration](docs/en/commands/memory-migration.md)
 and [diagnostics](docs/en/commands/maintenance-and-diagnostics.md).
 
-If status blocks, preserve the evidence and run `wendkeep memory repair --vault <vault>` to back up
+If status blocks, preserve the evidence and run `npx --no-install wendkeep memory repair --vault <vault>` to back up
 the corrupt ledger, retain valid lines, and re-project. Repair remains structural: its only narrow
 acknowledgement exception covers attempts entirely represented by the outbox consumed by that same
 run; it does not scan or reclassify historical attempts. Valid pre-0.59 causal checkpoints and
@@ -385,7 +385,7 @@ acknowledgement pending on 0.66.4 or later, first run the targeted dry run
 registry/checkpoint. See syntax, preconditions, and fail-closed behavior in
 [memory and curation](docs/en/commands/memory.md).
 
-Session notes use one live `## Agentes, tokens e custos` snapshot. Main-agent and subagent hooks recompose it atomically, with costs, token dimensions, reasoning tokens and effort per model/source. Every hook that rewrites a session note takes a per-file lock and writes through a temp file + rename, so the `SubagentStop` fan-out (one hook run per subagent) can never leave a note half-written; a note whose frontmatter reads back damaged is left untouched rather than patched.
+Session notes use one live `## Agentes, tokens e custos` snapshot. Main-agent and subagent hooks recompose it atomically, with costs, token dimensions, reasoning tokens and effort per model/source. On Codex, subagent prompts register their rollout for observability without advancing the main agent's sequence; `SubagentStop` reads the child from `agent_transcript_path` and persists its signal only when `parent_thread_id` matches a validated session root. The main Stop uses the registry's causal `turn_id` mapping before falling back to local transcript order. To recover missing markers while a conversation is open, `hook session-backfill` is a dry-run by default and never writes a Codex turn without `task_complete`. Every hook that rewrites a session note takes a per-file lock and writes through a temp file + rename, so the `SubagentStop` fan-out (one hook run per subagent) can never leave a note half-written; a note whose frontmatter reads back damaged is left untouched rather than patched.
 
 ## Retroactive memory (`import`) — install today, remember yesterday
 

package/docs/en/commands/costs-and-observability.md

@@ -24,9 +24,9 @@ A consistent registry, complete price table, and transcript access for rebuilt s
 ## Syntax
 
 ```bash
-npx wendkeep stats [--vault <vault>] [--json]
-npx wendkeep cost [--since <date>] [--top [N]] [--trend day|week|month] [--write] [--json]
-npx wendkeep cost rebuild [--session <id|file>] [--limit N] [--max-graph-nodes N] [--max-fallback-days N] [--max-fallback-candidates N] [--apply] [--json]
+npx --no-install wendkeep stats [--vault <vault>] [--json]
+npx --no-install wendkeep cost [--since <date>] [--top [N]] [--trend day|week|month] [--write] [--json]
+npx --no-install wendkeep cost rebuild [--session <id|file>] [--vault <vault>] [--limit N] [--max-graph-nodes N] [--max-fallback-days N] [--max-fallback-candidates N] [--apply] [--json]
 ```
 
 ## Options and exit codes
@@ -50,11 +50,11 @@ npx wendkeep cost rebuild [--session <id|file>] [--limit N] [--max-graph-nodes N
 ## Examples
 
 ```bash
-npx wendkeep stats --vault .MyApp-vault
-npx wendkeep cost --since 2026-07-01 --top 10 --trend week
-npx wendkeep cost rebuild --session 019abc --json
-npx wendkeep cost rebuild --session 019abc --max-graph-nodes 8192 --json
-npx wendkeep cost rebuild --session 019abc --apply
+npx --no-install wendkeep stats --vault .MyApp-vault
+npx --no-install wendkeep cost --since 2026-07-01 --top 10 --trend week
+npx --no-install wendkeep cost rebuild --session 019abc --json --vault .MyApp-vault
+npx --no-install wendkeep cost rebuild --session 019abc --max-graph-nodes 8192 --json --vault .MyApp-vault
+npx --no-install wendkeep cost rebuild --session 019abc --json --vault .MyApp-vault --apply
 ```
 
 ## Expected result

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

@@ -23,11 +23,11 @@ Run from the project root or provide `--project` and `--vault` explicitly.
 ## Syntax
 
 ```bash
-npx wendkeep doctor [--vault <vault>]
-npx wendkeep sync-defs [--check|--reseed] --vault <vault> --project <root>
-npx wendkeep theme sync --vault <vault>
-npx wendkeep --version
-npx wendkeep --help
+npx --no-install wendkeep doctor [--vault <vault>]
+npx --no-install wendkeep sync-defs [--check|--reseed] --vault <vault> --project <root>
+npx --no-install wendkeep theme sync --vault <vault>
+npx --no-install wendkeep --version
+npx --no-install wendkeep --help
 ```
 
 ## Options and exit codes
@@ -53,12 +53,12 @@ npx wendkeep --help
 Post-update checklist:
 
 ```bash
-npx wendkeep --version
-npx wendkeep sync-defs --check --vault .MyApp-vault --project .
-npx wendkeep doctor --vault .MyApp-vault
-npx wendkeep memory status --gate --vault .MyApp-vault
-npx wendkeep cost rebuild --session <id> --json
-npx wendkeep cost rebuild --session <id> --apply
+npx --no-install wendkeep --version
+npx --no-install wendkeep sync-defs --check --vault .MyApp-vault --project .
+npx --no-install wendkeep doctor --vault .MyApp-vault
+npx --no-install wendkeep memory status --gate --vault .MyApp-vault
+npx --no-install wendkeep cost rebuild --session <id> --json --vault .MyApp-vault
+npx --no-install wendkeep cost rebuild --session <id> --json --vault .MyApp-vault --apply
 ```
 
 ## Expected result
@@ -80,8 +80,8 @@ dry-run path before any write.
   outbox, and SHARED so `last_memory_attempt` can be correlated before repair.
 - Corrupt bundle: preserve evidence and run `memory status --gate` before `memory repair`.
 - `legacy`/`degraded`/`stale`/`manifest-unproven` observability: run
-  `wendkeep cost rebuild --session <id> --json`, review diagnostics, and only then authorize
-  `--apply`.
+  `npx --no-install wendkeep cost rebuild --session <id> --json --vault <vault>`, review diagnostics,
+  and only then authorize the second variant with `--apply`.
 
 ## Next steps
 

package/docs/en/commands/sessions-and-import.md

@@ -30,6 +30,7 @@ npx wendkeep hook <name>
 npx wendkeep session list
 npx wendkeep session show <id>
 npx wendkeep session use <id>
+npx wendkeep hook session-backfill --session <id> [--write]
 npx wendkeep import [options]
 ```
 
@@ -38,19 +39,27 @@ npx wendkeep import [options]
 - `wendkeep hook <name>` reads the agent payload from stdin; valid names are listed by `--help`.
 - `SessionStart` opens an activation: an epoch that remains active across multiple `Stop` events;
   only a new `SessionStart` supersedes the previous epoch.
-- `UserPromptSubmit` advances the active activation's native turn. If it finds a legacy registry
-  with a closed epoch, it opens exactly one recovery activation; replaying the same prompt does
-  not open another one.
-- On Codex, `session_id`, the native `turn_id`, and observed transcript order are enough to resolve
-  the turn. Hook payloads do not need invented `activation_id` or `turn_sequence` fields.
+- Main-agent `UserPromptSubmit` advances the active activation's native turn. A Codex rollout
+  prompt with `source.subagent` only registers its path for observability: it does not advance the
+  sequence, enter `turn_sequences`, or replace the main transcript. If a main prompt finds a
+  legacy registry with a closed epoch, it opens exactly one recovery activation; replaying the
+  same prompt does not open another one.
+- On Codex, `session_id` and the native `turn_id` are enough to resolve the turn. Stop proves the
+  ID in the transcript and prefers `SESSION_REGISTRY.turn_sequences[turn_id]`; local transcript
+  order is the legacy-registry fallback. Interleaved subagent turns therefore cannot make the
+  parent's Stop artificially `stale_turn`. Hook payloads need no invented `activation_id` or
+  `turn_sequence` fields.
 - `Stop` accepts only a transcript-proven turn from the compatible active activation. Duplicates
   are no-ops; stale/superseded Stops neither publish memory nor overwrite a newer epoch's
   checkpoint.
 - `Stop` receives an absolute **45 s** deadline from hook entry. Reads check the clock between
   rollouts and on every chunk; reaching the limit returns `degraded` before the host timeout.
-- `SubagentStop` receives an absolute **15 s** deadline. Signals arriving within the **250 ms**
-  window are coalesced: only the highest sequence recomposes/publishes, without losing the last
-  child.
+- `SubagentStop` receives an absolute **15 s** deadline and resolves the child rollout from Codex's
+  official `agent_transcript_path` field (`agentTranscriptPath` is also accepted);
+  `transcript_path` continues to identify the parent session. Before any write, `source.subagent`,
+  ID, canonical session, and `parent_thread_id` are validated; the parent must match a proven
+  session root. Signals arriving within the **250 ms** window are coalesced: only the highest
+  sequence recomposes/publishes, without losing the last child.
 - Observability is tri-state: `complete` publishes the full snapshot; `none` means zero proven by
   a causal Stop or stable offline scan; `degraded` preserves the previous snapshot and allowlisted
   diagnostics. An isolated `SubagentStop` never publishes `none`.
@@ -64,6 +73,10 @@ npx wendkeep import [options]
 - `import` reconciles observability even when no `wk-turn` is missing: a legacy schema, stale
   frontier, or unproven manifest triggers recomposition without duplicating iterations. A fresh
   checkpoint remains byte-identical; `degraded` is reported and does not change the note.
+- `hook session-backfill` recovers missing `wk-turn` markers for the selected session. Without
+  `--write`, it only reports. On Codex, `missingTurns` contains only turns with `task_complete`;
+  open turns appear under `incompleteTurns` and are never written. `--write` applies only completed
+  candidates, and a second run is idempotent.
 - Exit `0` means consistent processing; non-zero reports invalid source/config/write instead of
   presenting silent partial success.
 
@@ -72,6 +85,8 @@ npx wendkeep import [options]
 ```bash
 npx wendkeep session list
 npx wendkeep session show 019abc-session-id
+npx wendkeep hook session-backfill --session 019abc-session-id
+npx wendkeep hook session-backfill --session 019abc-session-id --write
 npx wendkeep import --source codex --since 2026-07-01 --dry-run --json
 ```
 
@@ -98,6 +113,10 @@ without creating a new turn block.
   was found; the attempt remains observable but does not publish memory.
 - A late Stop reports `stale_turn`/`superseded`: the newer epoch and checkpoint are preserved; do
   not force the old payload to apply.
+- `session-backfill` lists `incompleteTurns`: wait for that turn's `task_complete`/Stop and retry;
+  do not edit the note or force the partial turn. Once that turn receives `task_complete`, the next
+  run may treat it as eligible. Claude transcripts preserve their historical contract and do not
+  require this Codex event.
 - Fork duplicates: bound source/date and inspect `forked_from_id`/`source.subagent`.
 - Codex does not capture: approve hooks and start a new session after `sync`.
 - Contaminated cost: validate `session_id → session_file → transcript_path → provider`.

package/docs/pt-BR/commands/costs-and-observability.md

@@ -24,9 +24,9 @@ Registry consistente, tabela de preços completa e acesso aos transcripts das se
 ## Sintaxe
 
 ```bash
-npx wendkeep stats [--vault <cofre>] [--json]
-npx wendkeep cost [--since <data>] [--top [N]] [--trend day|week|month] [--write] [--json]
-npx wendkeep cost rebuild [--session <id|arquivo>] [--limit N] [--max-graph-nodes N] [--max-fallback-days N] [--max-fallback-candidates N] [--apply] [--json]
+npx --no-install wendkeep stats [--vault <cofre>] [--json]
+npx --no-install wendkeep cost [--since <data>] [--top [N]] [--trend day|week|month] [--write] [--json]
+npx --no-install wendkeep cost rebuild [--session <id|arquivo>] [--vault <cofre>] [--limit N] [--max-graph-nodes N] [--max-fallback-days N] [--max-fallback-candidates N] [--apply] [--json]
 ```
 
 ## Opções e códigos de saída
@@ -50,11 +50,11 @@ npx wendkeep cost rebuild [--session <id|arquivo>] [--limit N] [--max-graph-node
 ## Exemplos
 
 ```bash
-npx wendkeep stats --vault .MeuApp-vault
-npx wendkeep cost --since 2026-07-01 --top 10 --trend week
-npx wendkeep cost rebuild --session 019abc --json
-npx wendkeep cost rebuild --session 019abc --max-graph-nodes 8192 --json
-npx wendkeep cost rebuild --session 019abc --apply
+npx --no-install wendkeep stats --vault .MeuApp-vault
+npx --no-install wendkeep cost --since 2026-07-01 --top 10 --trend week
+npx --no-install wendkeep cost rebuild --session 019abc --json --vault .MeuApp-vault
+npx --no-install wendkeep cost rebuild --session 019abc --max-graph-nodes 8192 --json --vault .MeuApp-vault
+npx --no-install wendkeep cost rebuild --session 019abc --json --vault .MeuApp-vault --apply
 ```
 
 ## Resultado esperado

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

@@ -23,11 +23,11 @@ Execute na raiz do projeto ou informe `--project`/`--vault` explicitamente.
 ## Sintaxe
 
 ```bash
-npx wendkeep doctor [--vault <cofre>]
-npx wendkeep sync-defs [--check|--reseed] --vault <cofre> --project <raiz>
-npx wendkeep theme sync --vault <cofre>
-npx wendkeep --version
-npx wendkeep --help
+npx --no-install wendkeep doctor [--vault <cofre>]
+npx --no-install wendkeep sync-defs [--check|--reseed] --vault <cofre> --project <raiz>
+npx --no-install wendkeep theme sync --vault <cofre>
+npx --no-install wendkeep --version
+npx --no-install wendkeep --help
 ```
 
 ## Opções e códigos de saída
@@ -53,12 +53,12 @@ npx wendkeep --help
 Checklist pós-atualização:
 
 ```bash
-npx wendkeep --version
-npx wendkeep sync-defs --check --vault .MeuApp-vault --project .
-npx wendkeep doctor --vault .MeuApp-vault
-npx wendkeep memory status --gate --vault .MeuApp-vault
-npx wendkeep cost rebuild --session <id> --json
-npx wendkeep cost rebuild --session <id> --apply
+npx --no-install wendkeep --version
+npx --no-install wendkeep sync-defs --check --vault .MeuApp-vault --project .
+npx --no-install wendkeep doctor --vault .MeuApp-vault
+npx --no-install wendkeep memory status --gate --vault .MeuApp-vault
+npx --no-install wendkeep cost rebuild --session <id> --json --vault .MeuApp-vault
+npx --no-install wendkeep cost rebuild --session <id> --json --vault .MeuApp-vault --apply
 ```
 
 ## Resultado esperado
@@ -80,7 +80,8 @@ ou sem manifest comprovado e oferece um caminho dry-run antes de qualquer escrit
   outbox e SHARED para correlacionar `last_memory_attempt` antes de reparar.
 - Bundle corrompido: preserve a evidência e use `memory status --gate` antes de `memory repair`.
 - Observabilidade `legacy`/`degraded`/`stale`/`manifest-unproven`: rode
-  `wendkeep cost rebuild --session <id> --json`, revise diagnostics e só então autorize `--apply`.
+  `npx --no-install wendkeep cost rebuild --session <id> --json --vault <cofre>`, revise diagnostics
+  e só então autorize a segunda variante com `--apply`.
 
 ## Próximos passos
 

package/docs/pt-BR/commands/sessions-and-import.md

@@ -30,6 +30,7 @@ npx wendkeep hook <nome>
 npx wendkeep session list
 npx wendkeep session show <id>
 npx wendkeep session use <id>
+npx wendkeep hook session-backfill --session <id> [--write]
 npx wendkeep import [opções]
 ```
 
@@ -38,18 +39,26 @@ npx wendkeep import [opções]
 - `wendkeep hook <name>` lê o payload do agente em stdin; nomes válidos aparecem em `--help`.
 - `SessionStart` abre uma activation, isto é, um epoch que continua ativo por vários `Stop`; só um
   novo `SessionStart` torna o epoch anterior superseded.
-- `UserPromptSubmit` avança o turno nativo da activation ativa. Se encontrar um registry legado
-  com o epoch fechado, abre exatamente uma activation de recuperação; repetir o mesmo prompt não
-  abre outra.
-- No Codex, `session_id`, o `turn_id` nativo e a ordem observada no transcript bastam para resolver
-  o turno. O payload do hook não precisa inventar `activation_id` nem `turn_sequence`.
+- `UserPromptSubmit` do agente principal avança o turno nativo da activation ativa. Um prompt de
+  rollout Codex com `source.subagent` apenas registra o path para observabilidade: não avança a
+  sequência, não entra em `turn_sequences` e não substitui o transcript principal. Se o prompt
+  principal encontra um registry legado com o epoch fechado, abre exatamente uma activation de
+  recuperação; repetir o mesmo prompt não abre outra.
+- No Codex, `session_id` e o `turn_id` nativo bastam para resolver o turno. O Stop prova o ID no
+  transcript e prefere `SESSION_REGISTRY.turn_sequences[turn_id]`; a ordem local do transcript é
+  fallback para registry legado. Assim, turnos intercalados de subagents não tornam o Stop da mãe
+  artificialmente `stale_turn`. O payload não precisa inventar `activation_id` ou `turn_sequence`.
 - `Stop` aceita somente o turno comprovado pelo transcript e pela activation ativa compatível.
   Duplicatas são no-op; Stops stale/superseded não publicam memória nem sobrescrevem o checkpoint
   de um epoch mais novo.
 - `Stop` recebe deadline absoluto de **45 s** desde a entrada do hook. A leitura verifica o relógio
   entre rollouts e a cada chunk; ao atingir o limite, devolve `degraded` antes do timeout do host.
-- `SubagentStop` recebe deadline absoluto de **15 s**. Sinais que chegam na janela de **250 ms**
-  são coalescidos: somente a maior sequência recompõe/publica, sem perder o último filho.
+- `SubagentStop` recebe deadline absoluto de **15 s** e resolve o rollout filho pelo campo oficial
+  Codex `agent_transcript_path` (também aceita `agentTranscriptPath`); `transcript_path` continua
+  identificando a sessão-mãe. Antes de qualquer escrita, `source.subagent`, ID, sessão canônica e
+  `parent_thread_id` são validados; o pai deve corresponder a um root comprovado da sessão. Sinais
+  que chegam na janela de **250 ms** são coalescidos: somente a maior sequência
+  recompõe/publica, sem perder o último filho.
 - A observabilidade usa tri-state: `complete` publica o snapshot integral; `none` representa zero
   comprovado por Stop causal ou scan offline estável; `degraded` preserva o snapshot anterior e
   diagnostics allowlisted. `SubagentStop` isolado nunca publica `none`.
@@ -63,6 +72,10 @@ npx wendkeep import [opções]
 - `import` reconcilia a observabilidade mesmo quando nenhum `wk-turn` está ausente: schema legado,
   frontier stale ou manifest não comprovado disparam recomposição sem duplicar iterações. Um
   checkpoint fresco permanece byte-idêntico; `degraded` é reportado e não altera a nota.
+- `hook session-backfill` recupera `wk-turn` ausente da sessão selecionada. Sem `--write`, apenas
+  relata. Em Codex, `missingTurns` contém somente turnos com `task_complete`; turnos ainda abertos
+  aparecem em `incompleteTurns` e nunca são gravados. `--write` aplica apenas os candidatos
+  concluídos e uma segunda execução é idempotente.
 - Exit `0` indica processamento consistente; exit não zero indica configuração, fonte ou escrita
   inválida sem transformar isso em sucesso parcial silencioso.
 
@@ -71,6 +84,8 @@ npx wendkeep import [opções]
 ```bash
 npx wendkeep session list
 npx wendkeep session show 019abc-session-id
+npx wendkeep hook session-backfill --session 019abc-session-id
+npx wendkeep hook session-backfill --session 019abc-session-id --write
 npx wendkeep import --source codex --since 2026-07-01 --dry-run --json
 ```
 
@@ -97,6 +112,10 @@ sem criar um novo bloco de turno.
   compatível foi encontrada; o attempt fica observável, mas não publica memória.
 - Stop atrasado aparece como `stale_turn`/`superseded`: o epoch mais novo e seu checkpoint são
   preservados; não force a reaplicação do payload antigo.
+- `session-backfill` lista `incompleteTurns`: aguarde o `task_complete`/Stop desse turno e repita;
+  não edite a nota nem force o turno parcial. Quando o mesmo turno recebe `task_complete`, a
+  próxima execução passa a considerá-lo elegível. Transcripts Claude preservam o contrato
+  histórico e não exigem esse evento Codex.
 - Duplicatas de forks: limite por fonte/data e revise `forked_from_id`/`source.subagent`.
 - Codex não captura: aprove os hooks e reinicie a sessão após `sync`.
 - Custo contaminado: valide `session_id → session_file → transcript_path → provider`.

package/hooks/harness-doctor.mjs

@@ -8,7 +8,12 @@ import { buildEffectiveRequirementPackage, checkSpecsState, evaluateVerdict, tas
 import { getLocale } from './locale.mjs';
 import { priceForModel } from './token-usage.mjs';
 import { countMissing, indexDerivedBySession, listSessionNotes, missingDerivedLinks } from './derived-sections.mjs';
-import { readControl, readSessionRegistry } from './obsidian-common.mjs';
+import {
+  quoteCommandArgument,
+  readControl,
+  readSessionRegistry,
+  WENDKEEP_COMMAND,
+} from './obsidian-common.mjs';
 import { parseObservabilityCheckpoint } from './session-observability-state.mjs';
 import { readObservabilityStore } from './session-observability-store.mjs';
 import { assessObservabilityFreshness } from './session-observability-lifecycle.mjs';
@@ -20,6 +25,7 @@ export function checkSessionObservability(vaultBase, deps = {}) {
   const statSource = deps.statSource || statSync;
   const registry = readRegistry(vaultBase);
   const result = { ok: true, scanned: 0, healthy: 0, issues: [] };
+  const commandPrefix = `${WENDKEEP_COMMAND} cost rebuild`;
   const entries = Object.entries(registry?.sessions || {})
     .map(([sessionId, entry]) => ({ sessionId, ...entry }))
     .filter((entry) => entry.session_file)
@@ -32,7 +38,7 @@ export function checkSessionObservability(vaultBase, deps = {}) {
     try { content = readNote(notePath, 'utf8'); } catch { continue; }
     if (!entry.provider && /^provider:\s*["']?claude/m.test(content)) continue;
     result.scanned += 1;
-    const command = `wendkeep cost rebuild --session ${entry.sessionId} --json`;
+    const command = `${commandPrefix} --session ${quoteCommandArgument(entry.sessionId)} --json --vault ${quoteCommandArgument(vaultBase)}`;
     const checkpoint = parseObservabilityCheckpoint(content);
     if (!checkpoint) {
       result.issues.push({

package/hooks/obsidian-common.mjs

@@ -67,6 +67,14 @@ export function getVaultBase(input = {}) {
   return resolveVault(input).base;
 }
 
+// Diagnostic commands must use the project-local package even when `wendkeep` is not installed
+// globally. Quotes preserve resolved Windows paths with spaces in copy/pasteable output.
+export const WENDKEEP_COMMAND = 'npx --no-install wendkeep';
+
+export function quoteCommandArgument(value) {
+  return `"${String(value ?? '').replaceAll('"', '\\"')}"`;
+}
+
 // Diagnostic logger. No-op unless WENDKEEP_DEBUG is set, so it never pollutes the
 // stdout hook contract during normal runs but makes fail-open paths debuggable.
 export function debugLog(...args) {
@@ -321,6 +329,13 @@ function nonNegativeSequence(value, fallback = null) {
   return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : fallback;
 }
 
+export function resolveRegisteredTurnSequence(entry = {}, turnId = '', fallback = 0) {
+  const registered = turnId
+    ? nonNegativeSequence(entry?.turn_sequences?.[String(turnId)])
+    : null;
+  return registered === null ? nonNegativeSequence(fallback, 0) : registered;
+}
+
 function cloneRegistry(registry = {}) {
   const sessions = Object.fromEntries(Object.entries(registry.sessions || {}).map(([id, entry]) => [
     id,

package/hooks/session-backfill.mjs

@@ -7,6 +7,7 @@ import {
   insertIteration,
   parseTranscript,
 } from './session-stop.mjs';
+import { completedCodexTurnIdsContent } from '../packages/integrations/src/transcripts.mjs';
 import {
   getVaultBase,
   readControl,
@@ -63,6 +64,7 @@ export function backfillSessions({ vaultBase, write = false, limit = 0, session
     scanned: 0,
     candidates: 0,
     inserted: 0,
+    incomplete: 0,
     skipped: 0,
     missing: [],
     sessions: [],
@@ -85,13 +87,35 @@ export function backfillSessions({ vaultBase, write = false, limit = 0, session
       continue;
     }
 
+    const transcriptContent = readFileSync(entry.transcript_path, 'utf-8');
     const tx = parseTranscript(entry.transcript_path);
-    const turns = tx.turns.filter((turn) => turn.turnId && turn.userPrompts.length);
+    const allTurns = tx.turns.filter((turn) => turn.turnId && turn.userPrompts.length);
+    const completedCodexTurns = tx.provider === 'codex'
+      ? completedCodexTurnIdsContent(transcriptContent)
+      : null;
+    const turns = completedCodexTurns
+      ? allTurns.filter((turn) => completedCodexTurns.has(turn.turnId))
+      : allTurns;
     const content = readFileSync(sessionPath, 'utf-8');
     const missingTurns = turns.filter((turn) => !hasTurnMarker(content, turn.turnId));
+    const incompleteTurns = completedCodexTurns
+      ? allTurns.filter((turn) => (
+        !completedCodexTurns.has(turn.turnId) && !hasTurnMarker(content, turn.turnId)
+      ))
+      : [];
+    report.incomplete += incompleteTurns.length;
 
     if (!missingTurns.length) {
       report.skipped += 1;
+      if (incompleteTurns.length) {
+        report.sessions.push({
+          session: entry.session_file,
+          transcript: entry.transcript_path,
+          missingTurns: [],
+          incompleteTurns: incompleteTurns.map((turn) => turn.turnId),
+          inserted: 0,
+        });
+      }
       continue;
     }
 
@@ -100,6 +124,7 @@ export function backfillSessions({ vaultBase, write = false, limit = 0, session
       session: entry.session_file,
       transcript: entry.transcript_path,
       missingTurns: missingTurns.map((turn) => turn.turnId),
+      incompleteTurns: incompleteTurns.map((turn) => turn.turnId),
       inserted: 0,
     };
 

package/hooks/session-ensure.mjs

@@ -32,6 +32,7 @@ import {
   yamlQuote,
 } from './obsidian-common.mjs';
 import { resolveSessionIdentity } from './session-identity.mjs';
+import { readCodexRolloutMeta } from './codex-rollout-meta.mjs';
 import { mutateSessionNote } from './session-note-io.mjs';
 
 function sessionIdFromInput(input) {
@@ -54,6 +55,12 @@ function causalTurnPatch(input, now) {
   };
 }
 
+function isCodexSubagentTranscript(identity) {
+  if (identity?.provider !== 'codex' || !identity.transcriptPath) return false;
+  const inspected = readCodexRolloutMeta(identity.transcriptPath);
+  return Boolean(inspected?.ok && inspected.meta?.source?.subagent);
+}
+
 function buildSessionContent({ relPath, now, summary = 'session', sessionId = '', reason = 'Sessão criada automaticamente pelo hook UserPromptSubmit.' }) {
   const date = formatDate(now);
   const startedAt = formatLocalIso(now);
@@ -341,6 +348,21 @@ function main() {
   }
   const sessionId = identity.canonicalConversationId;
 
+  // UserPromptSubmit also fires inside Codex subagents. The child belongs to the parent's
+  // observability graph, but it is not a new main turn: registering it through causalTurnPatch
+  // permanently inflated the parent's sequence and made every later main Stop stale.
+  if (isCodexSubagentTranscript(identity)) {
+    const registered = readSessionRegistry(vaultBase).sessions?.[sessionId];
+    if (registered) {
+      upsertSessionRegistry(vaultBase, sessionId, {
+        transcript_paths: [identity.transcriptPath],
+        provider: identity.provider,
+      });
+    }
+    writeHookOutput({});
+    return;
+  }
+
   // Fast path: skip all writes if control file touched < 5 min ago and session matches
   try {
     const ctrlPath = controlPath(vaultBase);

package/hooks/session-stop.mjs

@@ -61,6 +61,7 @@ import {
   hasTurnMarker,
   normalizeTurnMarkers,
   mutateSessionRegistry,
+  resolveRegisteredTurnSequence,
   resolveStopActivation,
   applyStopActivation,
 } from './obsidian-common.mjs';
@@ -1180,9 +1181,13 @@ export async function main({
   const turnId = turnIdentity.id;
   const now = finalizing ? new Date() : null;
   const endedAt = finalizing ? formatLocalIso(now) : '';
-  const stopTurnSequence = turnIdentity.order;
   const causalStop = finalizing
     ? mutateSessionRegistry(vaultBase, (registry) => {
+      const stopTurnSequence = resolveRegisteredTurnSequence(
+        registry.sessions?.[sessionId],
+        turnId,
+        turnIdentity.order,
+      );
       const activationId = resolveStopActivation(registry, {
         session_id: sessionId,
         activation_id: input.activation_id || input.activationId || '',
@@ -1214,9 +1219,11 @@ export async function main({
         activation,
         stopDisposition: cas.stopDisposition,
         canPromoteMemory: cas.canPromoteMemory,
+        turnSequence: stopTurnSequence,
       };
     })
     : null;
+  const stopTurnSequence = causalStop?.turnSequence ?? turnIdentity.order;
   let memoryHandoff = null;
   let memoryAttempt = null;
   if (finalizing) {

package/hooks/subagent-stop.mjs

@@ -82,6 +82,32 @@ function claudeRoots(entry) {
   return { state: 'complete', rootPaths: [...paths], descendantPaths: [], diagnostics: [] };
 }
 
+export function subagentIdentityInput(input = {}) {
+  const agentTranscriptPath = input.agent_transcript_path || input.agentTranscriptPath || '';
+  if (!agentTranscriptPath) return input;
+  return {
+    ...input,
+    transcript_path: agentTranscriptPath,
+    transcriptPath: agentTranscriptPath,
+  };
+}
+
+function validatedCodexRootIds(entry, canonicalConversationId, { resolveRoots, readMeta }) {
+  const roots = resolveRoots(entry, { readMeta });
+  if (roots?.state !== 'complete' || !roots.rootPaths?.length) return null;
+
+  const ids = new Set();
+  for (const rootPath of roots.rootPaths) {
+    const result = readMeta(rootPath);
+    const meta = result?.meta;
+    const rootId = String(meta?.id || '');
+    if (!result?.ok || !rootId || meta?.source?.subagent) return null;
+    if (meta.session_id && meta.session_id !== canonicalConversationId) return null;
+    ids.add(rootId);
+  }
+  return ids;
+}
+
 export async function refreshSubagents(vaultBase, input, {
   now = Date.now,
   hookStartedAt = now(),
@@ -100,7 +126,8 @@ export async function refreshSubagents(vaultBase, input, {
 } = {}) {
   const deadlineAt = hookStartedAt + deadlineMs;
   const provider = providerMeta(input.provider).id;
-  const { identity, entry } = resolveEntry(vaultBase, input, provider);
+  const identityInput = subagentIdentityInput(input);
+  const { identity, entry } = resolveEntry(vaultBase, identityInput, provider);
   if (identity.state !== 'resolved') return false;
   const childTranscriptPath = identity.transcriptPath;
   const sessionRel = entry?.session_file || '';
@@ -118,6 +145,11 @@ export async function refreshSubagents(vaultBase, input, {
       || childMeta.meta.source?.subagent?.thread_spawn?.parent_thread_id
       || '',
     );
+    const rootIds = validatedCodexRootIds(entry, identity.canonicalConversationId, {
+      resolveRoots,
+      readMeta,
+    });
+    if (!childParentThreadId || !rootIds?.has(childParentThreadId)) return false;
   }
 
   const observed = causalSnapshot(entry);
@@ -168,7 +200,7 @@ export async function refreshSubagents(vaultBase, input, {
 
   try {
     if (now() >= deadlineAt) return true;
-    const fresh = resolveEntry(vaultBase, input, provider);
+    const fresh = resolveEntry(vaultBase, identityInput, provider);
     if (fresh.identity?.state !== 'resolved'
       || fresh.identity.canonicalConversationId !== identity.canonicalConversationId
       || !fresh.entry?.session_file
@@ -197,7 +229,7 @@ export async function refreshSubagents(vaultBase, input, {
       const currentEntry = guardContext?.entry;
       const currentResolved = currentEntry
         ? { identity: { state: 'resolved', canonicalConversationId: identity.canonicalConversationId }, entry: currentEntry }
-        : resolveEntry(vaultBase, input, provider);
+        : resolveEntry(vaultBase, identityInput, provider);
       if (currentResolved.identity?.state !== 'resolved'
         || currentResolved.identity.canonicalConversationId !== identity.canonicalConversationId
         || !currentResolved.entry) {

package/hooks/vault-health.mjs

@@ -6,8 +6,10 @@ import {
   controlPath,
   getVaultBase,
   listMarkdownFiles,
+  quoteCommandArgument,
   readControl,
   readSessionRegistry,
+  WENDKEEP_COMMAND,
   wikilinkFromRel,
 } from './obsidian-common.mjs';
 import { getLocale } from './locale.mjs';
@@ -98,8 +100,12 @@ function linkedNotesFromSession(content) {
   return notes;
 }
 
-const MEMORY_STATUS_COMMAND = 'wendkeep memory status --gate --vault <vault>';
-const MEMORY_REPAIR_COMMAND = 'wendkeep memory repair --vault <vault>';
+const memoryStatusCommand = (vaultBase) => (
+  `${WENDKEEP_COMMAND} memory status --gate --vault ${quoteCommandArgument(vaultBase)}`
+);
+const memoryRepairCommand = (vaultBase) => (
+  `${WENDKEEP_COMMAND} memory repair --vault ${quoteCommandArgument(vaultBase)}`
+);
 
 function readJsonLines(vaultBase, path, label) {
   let checked;
@@ -279,13 +285,13 @@ function checkMemoryAttempts(registry, {
       : [];
 
     if (state === 'skipped' && disposition === 'ambiguous') {
-      failures.push(`Lifecycle de memória v2 ambíguo: Stop pulou a publicação sem identidade causal suficiente. Inspecione com: ${MEMORY_STATUS_COMMAND}.`);
+      failures.push(`Lifecycle de memória v2 ambíguo: Stop pulou a publicação sem identidade causal suficiente. Inspecione com: ${memoryStatusCommand(vaultBase)}.`);
       continue;
     }
 
     if (state === 'skipped' && ['stale_turn', 'superseded'].includes(disposition)) {
       if (eventIds.length) {
-        failures.push(`Stop stale/superseded emitiu event_ids apesar da rejeição causal. Inspecione com: ${MEMORY_STATUS_COMMAND}.`);
+        failures.push(`Stop stale/superseded emitiu event_ids apesar da rejeição causal. Inspecione com: ${memoryStatusCommand(vaultBase)}.`);
       } else {
         warnings.push('Stop stale/superseded foi descartado sem publicar memória.');
       }
@@ -294,12 +300,12 @@ function checkMemoryAttempts(registry, {
 
     if (disposition !== 'applied') {
       if (state === 'skipped') warnings.push('Attempt de memória v2 foi descartado sem publicação.');
-      else failures.push(`Attempt de memória v2 possui disposition não reconhecida para o estado informado. Inspecione com: ${MEMORY_STATUS_COMMAND}.`);
+      else failures.push(`Attempt de memória v2 possui disposition não reconhecida para o estado informado. Inspecione com: ${memoryStatusCommand(vaultBase)}.`);
       continue;
     }
 
     if (!eventIds.length) {
-      failures.push(`Attempt v2 aplicado não declarou event_ids; publicação perdida. Inspecione com: ${MEMORY_STATUS_COMMAND}.`);
+      failures.push(`Attempt v2 aplicado não declarou event_ids; publicação perdida. Inspecione com: ${memoryStatusCommand(vaultBase)}.`);
       continue;
     }
 
@@ -317,7 +323,7 @@ function checkMemoryAttempts(registry, {
     if (typeof attempt.turn_id !== 'string' || !attempt.turn_id) invalidAttemptFields.push('turn_id');
     if (!Number.isInteger(attempt.turn_sequence) || attempt.turn_sequence < 0) invalidAttemptFields.push('turn_sequence');
     if (invalidAttemptFields.length) {
-      failures.push(`Attempt v2 da sessão ${sessionId} possui identidade causal inválida (${invalidAttemptFields.join(', ')}). Inspecione com: ${MEMORY_STATUS_COMMAND}.`);
+      failures.push(`Attempt v2 da sessão ${sessionId} possui identidade causal inválida (${invalidAttemptFields.join(', ')}). Inspecione com: ${memoryStatusCommand(vaultBase)}.`);
       continue;
     }
     const causalMismatches = [];
@@ -330,14 +336,14 @@ function checkMemoryAttempts(registry, {
       if (fields.length) causalMismatches.push(`${eventId}: ${fields.join(', ')}`);
     }
     if (causalMismatches.length) {
-      failures.push(`Attempt v2 da sessão ${sessionId} referencia evento(s) com identidade causal divergente (${causalMismatches.join('; ')}). Inspecione com: ${MEMORY_STATUS_COMMAND}.`);
+      failures.push(`Attempt v2 da sessão ${sessionId} referencia evento(s) com identidade causal divergente (${causalMismatches.join('; ')}). Inspecione com: ${memoryStatusCommand(vaultBase)}.`);
       continue;
     }
 
     if (state === 'enqueued' || state === 'degraded') {
       const missing = eventIds.filter((eventId) => !ledgerEventIds.has(eventId) && !outboxEventIds.has(eventId));
       if (missing.length) {
-        failures.push(`Attempt v2 perdeu ${missing.length} evento(s): ausentes do ledger e da outbox. Inspecione com: ${MEMORY_STATUS_COMMAND}.`);
+        failures.push(`Attempt v2 perdeu ${missing.length} evento(s): ausentes do ledger e da outbox. Inspecione com: ${memoryStatusCommand(vaultBase)}.`);
       } else if (
         state === 'enqueued'
         && eventIds.every((eventId) => ledgerEventIds.has(eventId))
@@ -353,14 +359,14 @@ function checkMemoryAttempts(registry, {
     if (state === 'projected') {
       const outsideLedger = eventIds.filter((eventId) => !ledgerEventIds.has(eventId));
       if (outsideLedger.length) {
-        failures.push(`Attempt projetado perdeu ${outsideLedger.length} evento(s) no ledger. Inspecione com: ${MEMORY_STATUS_COMMAND}.`);
+        failures.push(`Attempt projetado perdeu ${outsideLedger.length} evento(s) no ledger. Inspecione com: ${memoryStatusCommand(vaultBase)}.`);
       } else if (!checkpointMatchesLedgerPrefix(attempt.checkpoint, eventIds, ledgerEvents, vaultBase)) {
-        failures.push(`Checkpoint do attempt projetado diverge do prefixo rederivado do ledger. Inspecione com: ${MEMORY_STATUS_COMMAND}.`);
+        failures.push(`Checkpoint do attempt projetado diverge do prefixo rederivado do ledger. Inspecione com: ${memoryStatusCommand(vaultBase)}.`);
       }
       continue;
     }
 
-    failures.push(`Attempt de memória v2 possui state inválido. Inspecione com: ${MEMORY_STATUS_COMMAND}.`);
+    failures.push(`Attempt de memória v2 possui state inválido. Inspecione com: ${memoryStatusCommand(vaultBase)}.`);
   }
 
   return { failures, warnings };
@@ -410,26 +416,26 @@ export function checkMemoryBundle(vaultBase, { registry } = {}) {
   const ledgerCorrupt = (bundle.ledger?.errors || []).length > 0;
   if (ledgerCorrupt) {
     for (const error of bundle.ledger.errors) {
-      failures.push(`${error} Execute com segurança: ${MEMORY_REPAIR_COMMAND}.`);
+      failures.push(`${error} Execute com segurança: ${memoryRepairCommand(vaultBase)}.`);
     }
   }
   for (const error of bundle.errors || []) {
     if (error.startsWith('ledger:')) continue;
-    failures.push(`${error} Inspecione com: ${MEMORY_STATUS_COMMAND}.`);
+    failures.push(`${error} Inspecione com: ${memoryStatusCommand(vaultBase)}.`);
   }
 
   if (outbox.errors.length) {
-    failures.push(`Outbox corrompida (${outbox.errors.join('; ')}). Inspecione com: ${MEMORY_STATUS_COMMAND}.`);
+    failures.push(`Outbox corrompida (${outbox.errors.join('; ')}). Inspecione com: ${memoryStatusCommand(vaultBase)}.`);
   }
   if (candidates.errors.length) {
-    failures.push(`${candidates.errors.join('; ')} Execute com segurança: ${MEMORY_REPAIR_COMMAND}.`);
+    failures.push(`${candidates.errors.join('; ')} Execute com segurança: ${memoryRepairCommand(vaultBase)}.`);
   }
 
   let replay = null;
   if (bundle.ledger?.ok) {
     try { replay = deriveMemoryProjection(vaultBase, bundle.ledger.events); }
     catch (error) {
-      failures.push(`Ledger não pode ser reduzido: ${error.message}. Execute com segurança: ${MEMORY_REPAIR_COMMAND}.`);
+      failures.push(`Ledger não pode ser reduzido: ${error.message}. Execute com segurança: ${memoryRepairCommand(vaultBase)}.`);
     }
   }
   if (replay && bundle.shared?.ok) {
@@ -438,7 +444,7 @@ export function checkMemoryBundle(vaultBase, { registry } = {}) {
     if (metadata.event_cursor !== replay.ledgerCursor) divergences.push(`event_cursor ${metadata.event_cursor} != ${replay.ledgerCursor}`);
     if (metadata.state_hash !== replay.stateHash) divergences.push(`state_hash ${metadata.state_hash} != ${replay.stateHash}`);
     if (divergences.length) {
-      failures.push(`Projeção SHARED stale/lag (${divergences.join('; ')}). Inspecione com: ${MEMORY_STATUS_COMMAND}.`);
+      failures.push(`Projeção SHARED stale/lag (${divergences.join('; ')}). Inspecione com: ${memoryStatusCommand(vaultBase)}.`);
     }
   }
 
@@ -460,7 +466,7 @@ export function checkMemoryBundle(vaultBase, { registry } = {}) {
   const activeConflicts = unresolved.filter((item) => item?.reason === 'conflict');
   const ordinaryCandidates = unresolved.filter((item) => item?.reason !== 'conflict');
   if (activeConflicts.length) {
-    failures.push(`${activeConflicts.length} conflito ativo em chave operacional (${activeConflicts.map((item) => item.memory_key || item.candidate_id).join(', ')}). Inspecione com: ${MEMORY_STATUS_COMMAND}.`);
+    failures.push(`${activeConflicts.length} conflito ativo em chave operacional (${activeConflicts.map((item) => item.memory_key || item.candidate_id).join(', ')}). Inspecione com: ${memoryStatusCommand(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.`);
@@ -585,7 +591,7 @@ export function runVaultHealth({ vaultBase, session = '' }) {
     failures.push(...memory.failures.map((item) => `Memória: ${item}`));
     warnings.push(...memory.warnings.map((item) => `Memória: ${item}`));
   } else {
-    warnings.push(`Bundle de memória v2 ausente (vault legado); inspecione com: ${MEMORY_STATUS_COMMAND}.`);
+    warnings.push(`Bundle de memória v2 ausente (vault legado); inspecione com: ${memoryStatusCommand(vaultBase)}.`);
   }
 
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.67.0",
+  "version": "0.67.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": [
@@ -70,6 +70,6 @@
   },
   "devDependencies": {
     "acorn": "^8.18.0",
-    "wendkeep": "^0.66.5"
+    "wendkeep": "^0.67.1"
   }
 }

package/packages/cli/src/index.mjs

@@ -117,7 +117,7 @@ Usage:
   wendkeep --help              Show this help.
 `;
 
-function runHook(name) {
+function runHook(name, args = []) {
   if (!name) {
     process.stderr.write('wendkeep hook: missing hook name\n');
     process.exit(2);
@@ -133,7 +133,7 @@ function runHook(name) {
   }
   // Spawn exactly as the agent would run `node <hook>.mjs`: stdio inherited so the
   // hook's stdin (agent JSON) and stdout (hookSpecificOutput) pass through untouched.
-  const r = spawnSync(process.execPath, [file], { stdio: 'inherit' });
+  const r = spawnSync(process.execPath, [file, ...args], { stdio: 'inherit' });
   process.exit(r.status ?? 0);
 }
 
@@ -207,7 +207,7 @@ async function main(argv) {
       break;
     }
     case 'hook':
-      runHook(rest[0]);
+      runHook(rest[0], rest.slice(1));
       break;
     case 'doctor': {
       const { runDoctor } = await import('../../../src/doctor.mjs');

package/packages/integrations/src/transcripts.mjs

@@ -170,6 +170,16 @@ function jsonLines(content) {
   }).filter(Boolean);
 }
 
+export function completedCodexTurnIdsContent(content = '') {
+  const completed = new Set();
+  for (const event of jsonLines(content)) {
+    if (event.type !== 'event_msg' || event.payload?.type !== 'task_complete') continue;
+    const turnId = String(event.payload?.turn_id || event.turn_id || '').trim();
+    if (turnId) completed.add(turnId);
+  }
+  return completed;
+}
+
 export function parseCodexTranscriptContent(content, options = {}) {
   const result = createResult('codex');
   const eventUserPrompts = [];

package/src/sync-defs.mjs

@@ -64,10 +64,20 @@ This project uses the [wendkeep](https://github.com/rogersialves/wendkeep) harne
 in every profile: Vault, session, identity, memory, lessons, and persistence integrations.
 The persistent profile is selected explicitly; missing or invalid configuration uses **GOVERN as the default**.
 
-Before an implementation, the native LLM harness classifies the current request and may create a
-task-scoped lease with \`wendkeep profile route <FLOW|GUIDE|GOVERN|ASSURE> --session <id> --reason <text>\`.
-The lease expires when that request ends and the persistent session/project profile becomes
-effective again. **OFF is never selected adaptively**; only a human can persist \`profile use OFF\`.
+Before every implementation, the native LLM harness **MUST run the routing gate**:
+1. Inspect \`wendkeep profile status\`.
+2. Classify the request and choose FLOW, GUIDE, GOVERN, or ASSURE from its scope and risk.
+3. Register the choice with
+   \`wendkeep profile route <FLOW|GUIDE|GOVERN|ASSURE> --session <id> --reason <text>\`.
+4. Re-check \`wendkeep profile status\` and follow the effective profile before editing.
+
+The persistent profile is only the base restored after the task lease; it is not an immutable
+decision for the current task. A base OFF does not block a temporary FLOW/GUIDE/GOVERN/ASSURE
+lease, while a base GOVERN does not prevent choosing FLOW or GUIDE for bounded work. An explicit
+user choice for the request takes precedence. If no causal session is available or routing fails,
+do not invent lease state: follow the effective profile and use GOVERN only as the conservative
+fallback when configuration is missing or invalid. The lease expires when the request ends.
+**OFF is never selected adaptively**; only a human can persist \`profile use OFF\`.
 
 Route work by the effective profile:
 - **OFF** — Wend Runtime is disabled and governance belongs to the native LLM harness; Keep Core stays active.