wendkeep 0.66.5 → 0.67.1

package/docs/pt-BR/commands/operating-profiles.md

@@ -14,9 +14,9 @@ deliberado e executa as validações e gates próprios daquele comando.
 
 ## Quando usar
 
-Use `profile` para consultar ou selecionar explicitamente um Perfil de Operação. Use `FLOW` para
-manutenção local, reversível e com `spec_impact:none` que caiba num microcontrato Executar →
-Validar, sem change.
+Use `profile use` para uma seleção humana persistente e `profile route` para o harness registrar a
+rota temporária da implementação atual. Use `FLOW` para manutenção local, reversível e com
+`spec_impact:none` que caiba num microcontrato Executar → Validar, sem change.
 
 ## Quando não usar
 
@@ -28,7 +28,8 @@ gates/policies do WendKeep; promova o trabalho para uma change.
 ## Pré-requisitos
 
 - Projeto inicializado, com `.wendkeep.json` vinculado ao Vault correto.
-- Para override de sessão, uma sessão inequívoca no `SESSION_REGISTRY.json`.
+- Para override ou rota temporária, uma sessão inequívoca no `SESSION_REGISTRY.json`; `route`
+  também exige que o prompt atual já tenha fronteira causal registrada.
 - Para FLOW, repositório Git, allowlist de paths, motivo e ao menos um sensor existente em
   `wendkeep.sensors.json`.
 
@@ -37,6 +38,7 @@ gates/policies do WendKeep; promova o trabalho para uma change.
 ```bash
 npx wendkeep profile status [--project <path>] [--vault <path>] [--session <id>] [--json]
 npx wendkeep profile use <perfil> [--project <path>] [--vault <path>] [--session <id>] [--json]
+npx wendkeep profile route <FLOW|GUIDE|GOVERN|ASSURE> --session <id> --reason <texto> [--project <path>] [--vault <path>] [--json]
 npx wendkeep flow start <slug> --allow <path> [--allow <path>...] --sensor <id> [--sensor <id>...] --reason <texto> [--session <id>]
 npx wendkeep flow status [<id>]
 npx wendkeep flow show <id> [--session <id>]
@@ -76,15 +78,42 @@ independentes.
 | `GOVERN` | P → R → E → V | Loop a2 atual e fallback conservador. |
 | `ASSURE` | P → R → E → V → C | Governança acrescida de confirmação e handoff. |
 
-- A resolução segue override explícito da sessão → `harness.profile` do projeto → `GOVERN`.
-  Heurística, tamanho do diff, texto do prompt, variável de ambiente ou erro de leitura nunca
+### Legenda da rota
+
+As letras são etapas do trabalho, não comandos individuais:
+
+- `P` = **Planejar/Propor** — entender o pedido, delimitar o escopo e registrar a abordagem.
+- `R` = **Revisar** — revisar proposta/design antes da execução; é a revisão formal do loop a2.
+- `E` = **Executar** — editar os paths e artefatos permitidos.
+- `V` = **Validar** — rodar testes, sensores e verificações e registrar evidência.
+- `C` = **Confirmar/entregar** — obter confirmação explícita e fazer handoff.
+
+Logo, `P → R → E → V` é “planejar/propor, revisar, executar e validar”. `FLOW` começa no
+microcontrato de execução/validação; `OFF` não impõe rota Wend automática e entrega o processo ao
+harness nativo da LLM.
+
+- O harness da LLM classifica semanticamente o pedido e registra `profile route`; o Wend Runtime
+  não classifica texto, tamanho do diff, heurística ou variável de ambiente. Ele valida e aplica a
+  lease determinística.
+- Para correção local, reversível e sem contrato/spec, escolha `FLOW`. Para mudança compacta de
+  comportamento que precisa de change sem revisão formal, escolha `GUIDE`. Em dúvida, risco,
+  segurança, contrato público, dependências, CI/release ou policy, escolha `GOVERN`. Use `ASSURE`
+  quando confirmação e handoff forem parte do contrato.
+- `OFF` nunca pode ser uma rota adaptativa; somente uma pessoa o persiste explicitamente por
+  `profile use OFF`. Uma base `OFF` ainda pode receber uma elevação temporária para rota Wend.
+
+- A resolução segue lease ativa do prompt → override persistente da sessão →
+  `harness.profile` do projeto → `GOVERN`. Lease inválida/expirada e erro de leitura nunca
   selecionam `OFF`.
-- `profile status` mostra perfil efetivo e origem; `--json` produz saída estruturada. Quando um
-  Vault explícito preserva a escolha apesar de binding corrompido, a saída inclui `binding_error`
-  e o diagnóstico também vai para stderr.
+- `profile status` mostra perfil efetivo e origem. Com `--session`, a saída humana acrescenta
+  `base=<perfil>/<origem>` e `lease=<estado>`; `--json` produz os mesmos dados estruturados. Quando
+  um Vault explícito preserva a escolha apesar de binding corrompido, a saída inclui
+  `binding_error` e o diagnóstico também vai para stderr.
 - `profile use` valida nome e flags estritamente; opção singleton duplicada, incompleta ou com
   valor iniciado por `--` falha antes de I/O. Sem `--session`, altera atomicamente o binding do
   projeto; com `--session`, grava override, origem e timestamp sem trocar a identidade da sessão.
+- `profile route` exige `--session` e `--reason`, aceita somente os quatro perfis adaptativos e
+  grava `lease_id`, motivo, turno/sequência e timestamp sem tocar no perfil persistente.
 - `.wendkeep.json` continua em `schemaVersion: 1`; o campo aditivo usa, por exemplo,
   `"harness": { "profile": "GOVERN" }`. Binding legado sem o campo também resolve `GOVERN`.
 - Binding corrompido nunca equivale a `OFF`. Quando o payload ou a integração legada identifica
@@ -126,13 +155,39 @@ independentes.
 - Exit `0` indica consulta ou transição concluída; exit `1` indica política/sensor vermelho; exit
   `2` indica perfil, sessão, flow ou argumentos inválidos, sem mutação parcial.
 
+### Escopo da escolha
+
+Sem `--session`, `profile use` grava `harness.profile` no `.wendkeep.json` e muda o padrão do
+projeto para as conversas/hooks que não tenham override de sessão. Com `--session <id>`, grava o
+override somente no `SESSION_REGISTRY.json` daquela sessão e preserva o padrão do projeto. Por
+isso, `profile use OFF` sem `--session` não é um teste isolado; se o `.wendkeep.json` for commitado,
+essa escolha também será compartilhada com outros checkouts.
+
+`profile route` cria uma lease apenas para a solicitação atual. Um `Stop` aceito a consome por
+CAS; se o cleanup não rodar, o próximo `UserPromptSubmit` avança a sequência e a lease deixa de ser
+efetiva. Stop bloqueado preserva a lease para o retry do mesmo pedido. Não há TTL de relógio que
+interrompa trabalho longo. Sessão ainda sem prompt causal registrado (turno ausente, sequência
+zero, mapa causal ausente ou divergente) é rejeitada antes de qualquer mutação. `status --session`
+inclui o perfil-base e o estado da lease tanto na saída humana quanto em `--json`; neste, os campos
+são `base_profile`, `base_source` e `task_lease.state` (`active`, `consumed`, `expired`, `invalid` ou
+`absent`).
+
+```bash
+npx wendkeep profile status                       # padrão do projeto
+npx wendkeep profile use GUIDE                   # altera o padrão do projeto
+npx wendkeep profile use FLOW --session <id>     # altera somente uma sessão
+npx wendkeep profile route FLOW --session <id> --reason "ajuste local"  # pedido atual
+npx wendkeep profile status --session <id>       # consulta a sessão efetiva
+```
+
 ## Exemplos
 
-Consultar o padrão efetivo e aplicar override somente à sessão atual:
+Consultar o padrão efetivo e rotear somente a implementação atual:
 
 ```bash
 npx wendkeep profile status
-npx wendkeep profile use OFF --session 019abc-session-id --json
+npx wendkeep profile route FLOW --session 019abc-session-id --reason "corrige typo local" --json
+npx wendkeep profile status --session 019abc-session-id --json
 ```
 
 Executar uma manutenção FLOW capturando o `flow_id` retornado por `start`:

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
 ```
 
@@ -80,7 +95,13 @@ Cada sessão canônica aponta para provider, transcript, arquivo de nota e custo
 O registry mantém um epoch de `SessionStart` por activation e o turno nativo mais recente; vários
 `Stop` podem confirmar turnos do mesmo epoch sem fechá-lo. Importações repetidas do mesmo
 `session_id` são deduplicadas; o foco humano não encerra nem altera a identidade dos hooks. Cada
-iteração automática permanece Markdown válido mesmo quando uma fala precisa ser truncada. Hooks
+iteração automática permanece Markdown válido mesmo quando uma fala precisa ser truncada.
+Metadados internos terminais completos ou truncados são removidos somente das mensagens do
+assistente; uma reprodução escrita pelo usuário permanece no transcript. Na nota, tags XML-like
+são codificadas como texto visível — inclusive placeholders como `<session>` — sem alterar
+autolinks `<https://...>`. Reimport e `SessionStop` compartilham o mesmo normalizador idempotente;
+ao finalizar uma nota antiga, somente campos gerados reconhecíveis em `Iterações` e
+`Encerramento` são migrados, sem reescrever a prosa autoral. Hooks
 duplicados/stale convergem no mesmo frontier, e importações podem atualizar só a observabilidade
 sem criar um novo bloco de turno.
 
@@ -91,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/docs/pt-BR/commands/verify.md

@@ -74,15 +74,18 @@ npx wendkeep memory status --gate --vault .MeuApp-vault
 ## Resultado esperado
 
 `evidencia.json` contém resultados dos sensores e um selo liga a prova ao hash atual de
-`tarefas.md`. No deep, o pacote contém requisitos, tarefas e evidência suficientes para revisão
-read-only; o verdict cobre cada `[req:]` antes do archive.
+`tarefas.md`. Quando um sensor fica vermelho, sua entrada recebe somente um diagnóstico local
+sanitizado e limitado a 2.000 caracteres; stdout/stderr de sensores verdes não é persistido. No
+deep, o pacote contém requisitos, tarefas e evidência suficientes para revisão read-only; o
+verdict cobre cada `[req:]` antes do archive.
 
 ## Erros comuns e diagnóstico
 
 - `no change`: isso é exit 2 e estado ocioso válido; crie/use uma change ou não rode verify.
 - Zero/sensores ausentes: confira todas as tags na mesma linha e `sensors list`; várias tags na
   mesma tarefa são válidas e todas entram no gate.
-- Gate vermelho: corrija a causa e repita; não use `archive --force` por conta própria.
+- Gate vermelho: consulte o campo `note` limitado da entrada em `evidencia.json`, corrija a causa
+  e repita; não use `archive --force` por conta própria.
 - Verdict stale/ausente: regenere `--deep` e peça novo passe independente.
 - Mutantes sobreviventes: fortaleça o teste discriminante; após três rodadas, revise manualmente.
 

package/hooks/change-nag.mjs

@@ -13,6 +13,7 @@ import {
   profileSentinelId,
   resolveHookOperatingProfile,
 } from './operating-profile-runtime.mjs';
+import { consumeSessionTaskOperatingProfile } from './operating-profile-task-store.mjs';
 
 export function nagDecision(input, vaultBase, { profile = 'GOVERN' } = {}) {
   if (input && input.stop_hook_active) return null; // anti-loop: sempre primeiro
@@ -39,6 +40,13 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
       : runtime.bindingError
         ? { decision: 'block', reason: profileRuntimeError(runtime.bindingError) }
         : nagDecision(input, runtime.vaultBase, { profile: runtime.profile });
+    if (!decision && runtime.taskLease?.state === 'active') {
+      consumeSessionTaskOperatingProfile(
+        runtime.vaultBase,
+        runtime.identity?.canonicalConversationId || input?.session_id || input?.sessionId || '',
+        runtime.taskLease.lease_id,
+      );
+    }
     writeHookOutput(decision || {});
   } catch {
     writeHookOutput({});

package/hooks/obsidian-common.mjs

@@ -321,6 +321,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/operating-profile-runtime.mjs

@@ -3,6 +3,7 @@ import { resolve } from 'node:path';
 
 import {
   DEFAULT_OPERATING_PROFILE,
+  evaluateTaskOperatingProfileLease,
   normalizeOperatingProfile,
   operatingProfilePolicy,
   resolveOperatingProfile,
@@ -68,6 +69,22 @@ function sessionOverride(entry) {
   }
 }
 
+function nonNegativeSequence(value, fallback = null) {
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : fallback;
+}
+
+function taskLeaseContext(entry, input, sessionId) {
+  return {
+    sessionId,
+    turnId: input?.turn_id || input?.turnId || entry?.last_prompt_turn_id || '',
+    turnSequence: nonNegativeSequence(
+      input?.turn_sequence ?? input?.turnSequence,
+      nonNegativeSequence(entry?.last_turn_sequence),
+    ),
+  };
+}
+
 function canonicalPath(value) {
   const path = resolve(value).replaceAll('\\', '/');
   return process.platform === 'win32' ? path.toLowerCase() : path;
@@ -105,7 +122,8 @@ function matchingProjectBinding(vaultResolution, input) {
   }
 }
 
-// Resolution precedence for hooks: explicit session override -> project binding -> GOVERN.
+// Resolution precedence for hooks: active request lease -> explicit session override
+// -> project binding -> GOVERN.
 // Binding corruption is never interpreted as OFF: an authoritative Vault keeps the Keep Core
 // alive under GOVERN and carries a visible diagnostic to each entrypoint.
 export function resolveHookOperatingProfile({
@@ -134,7 +152,20 @@ export function resolveHookOperatingProfile({
   const entry = identity.state === 'resolved'
     ? readSessionRegistry(vaultResolution.base).sessions?.[identity.canonicalConversationId] || null
     : null;
-  const selected = sessionOverride(entry) || project;
+  const base = sessionOverride(entry) || project;
+  const taskLease = evaluateTaskOperatingProfileLease(
+    entry?.operating_profile_task,
+    taskLeaseContext(entry, input, identity.canonicalConversationId || ''),
+  );
+  const selected = taskLease.state === 'active'
+    ? {
+      profile: taskLease.profile,
+      source: 'task-lease',
+      valid: true,
+      configured: true,
+      raw: taskLease.profile,
+    }
+    : base;
   return {
     ...selected,
     policy: operatingProfilePolicy(selected.profile),
@@ -142,6 +173,9 @@ export function resolveHookOperatingProfile({
     projectRoot: vaultResolution.projectRoot,
     identity,
     entry,
+    baseProfile: base.profile,
+    baseSource: base.source,
+    taskLease,
     resolution: vaultResolution,
     ...(bindingError ? { bindingError } : {}),
   };

package/hooks/operating-profile-task-store.mjs

@@ -0,0 +1,77 @@
+import { randomUUID } from 'node:crypto';
+
+import {
+  createTaskOperatingProfileLease,
+} from '../src/operating-profile.mjs';
+import { mutateSessionRegistry } from './obsidian-common.mjs';
+
+function isoTimestamp(now) {
+  if (typeof now === 'string') return now;
+  if (now instanceof Date) return now.toISOString();
+  return new Date().toISOString();
+}
+
+function missingSessionError(sessionId) {
+  const error = new Error(`sessão não encontrada: ${sessionId}`);
+  error.code = 'WENDKEEP_SESSION_NOT_FOUND';
+  return error;
+}
+
+export function setSessionTaskOperatingProfile(vaultBase, sessionId, profile, {
+  reason,
+  leaseId = randomUUID(),
+  now,
+} = {}) {
+  const issuedAt = isoTimestamp(now);
+  return mutateSessionRegistry(vaultBase, (registry) => {
+    const sessions = registry.sessions || (registry.sessions = {});
+    if (!Object.hasOwn(sessions, sessionId)) throw missingSessionError(sessionId);
+    const current = sessions[sessionId];
+    const turnId = typeof current.last_prompt_turn_id === 'string'
+      ? current.last_prompt_turn_id.trim()
+      : '';
+    const hasRegisteredTurn = Boolean(
+      turnId
+      && current.turn_sequences
+      && Object.hasOwn(current.turn_sequences, turnId)
+      && current.turn_sequences[turnId] === current.last_turn_sequence
+    );
+    const lease = createTaskOperatingProfileLease({
+      profile,
+      reason,
+      sessionId,
+      turnId,
+      turnSequence: hasRegisteredTurn ? current.last_turn_sequence : undefined,
+      leaseId,
+      issuedAt,
+    });
+    sessions[sessionId] = {
+      ...current,
+      operating_profile_task: lease,
+      updated_at: issuedAt,
+    };
+    return lease;
+  });
+}
+
+export function consumeSessionTaskOperatingProfile(vaultBase, sessionId, leaseId, {
+  now,
+} = {}) {
+  if (!sessionId || !leaseId) return false;
+  const consumedAt = isoTimestamp(now);
+  return mutateSessionRegistry(vaultBase, (registry) => {
+    const current = registry.sessions?.[sessionId];
+    const lease = current?.operating_profile_task;
+    if (!lease || lease.state !== 'active' || lease.lease_id !== leaseId) return false;
+    registry.sessions[sessionId] = {
+      ...current,
+      operating_profile_task: {
+        ...lease,
+        state: 'consumed',
+        consumed_at: consumedAt,
+      },
+      updated_at: consumedAt,
+    };
+    return true;
+  });
+}

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);