wendkeep 0.68.0 → 0.68.5

package/hooks/session-start.mjs

@@ -17,6 +17,7 @@ import {
   readControl,
   readHookInput,
   readSessionRegistry,
+  resolveVault,
   sessionFileName,
   sessionFolderRel,
   sessionSummaryFromInput,
@@ -32,6 +33,7 @@ import {
   yamlQuote,
 } from './obsidian-common.mjs';
 import { resolveSessionIdentity } from './session-identity.mjs';
+import { captureProjectScope, projectScopePatch } from './project-scope.mjs';
 
 export function buildSessionContent({ relPath, now, summary = 'session', provider: providerId, sessionId = '' }) {
   const date = formatDate(now);
@@ -153,6 +155,7 @@ function buildAdditionalContext({ relPath, startedAt, vaultBase }) {
 function main() {
   const input = readHookInput();
   const vaultBase = getVaultBase(input);
+  const projectResolution = resolveVault(input);
   warnIfDefaultVault(input);
   const now = new Date();
   const provider = providerMeta();
@@ -169,11 +172,23 @@ function main() {
   }
   const sessionId = identity.canonicalConversationId;
   const transcriptPath = identity.transcriptPath;
+  const initialScope = captureProjectScope({
+    input,
+    projectRoot: projectResolution.projectRoot,
+    projectId: projectResolution.projectId,
+    provider: provider.id,
+    sessionId,
+  });
+  const scopePatchFor = (canonicalSessionId) => projectScopePatch(
+    readSessionRegistry(vaultBase).sessions?.[canonicalSessionId]?.project_scope,
+    { ...initialScope, sessionId: canonicalSessionId },
+  );
   const control = readControl(vaultBase);
   const activationId = input.activation_id || input.activationId || randomUUID();
   const activationStartedAt = formatLocalIso(now);
   const registerActivation = (canonicalSessionId, patch) => upsertSessionRegistry(vaultBase, canonicalSessionId, {
     ...patch,
+    ...scopePatchFor(canonicalSessionId),
     activation_id: activationId,
     activation_started_at: activationStartedAt,
     last_turn_sequence: 0,

package/hooks/session-stop.mjs

@@ -16,6 +16,7 @@ import {
   readObservabilityStore,
 } from './session-observability-store.mjs';
 import { mutateSessionNote } from './session-note-io.mjs';
+import { appendIterationOutcome } from './session-iteration-outcome.mjs';
 import { applyDerivedSections, provenanceSessions } from './derived-sections.mjs';
 import { buildSessionMemoryEvents, collectLifecycleEvidence } from './memory-handoff.mjs';
 import { enqueueMemoryEvent, projectMemoryOutbox } from './memory-store.mjs';
@@ -33,7 +34,15 @@ import {
   parseTranscriptContent,
   resolveTurnIdentity,
 } from '../packages/integrations/src/transcripts.mjs';
-import { sanitizeAssistantMessage } from '../packages/integrations/src/prompt-content.mjs';
+import {
+  isSyntheticTranscriptText,
+  sanitizeAssistantMessage,
+} from '../packages/integrations/src/prompt-content.mjs';
+
+const UNRESOLVED_SESSION_ID = 'unresolved';
+const UNRESOLVED_TURN_ID = 'unresolved-turn';
+const ABORTED_TURN_NOTICE = 'wendkeep: Stop ignorado; o turno foi abortado no transcript.';
+
 export { resolveTurnIdentity };
 import {
   ensureDir,
@@ -43,7 +52,6 @@ import {
   formatLocalIso,
   getNextAdrNumber,
   getVaultBase,
-  isBootstrapPrompt,
   warnIfDefaultVault,
   listMarkdownFiles,
   readControl,
@@ -61,28 +69,15 @@ import {
   hasTurnMarker,
   normalizeTurnMarkers,
   mutateSessionRegistry,
+  closeSessionActivation,
   resolveRegisteredTurnSequence,
   resolveStopActivation,
   applyStopActivation,
 } from './obsidian-common.mjs';
 
-// Tags injetadas pelo harness (não são fala humana): notificações de task,
-// reminders do sistema, stdout de comando local, wrappers de slash-command e
-// contexto da IDE. Nunca devem virar título/Pedido/Usuário de iteração no Vault.
-const SYNTHETIC_EVENT_TAG = /^<\/?(?:task-notification|system-reminder|local-command-stdout|local-command-stderr|command-message|command-name|command-args|user-prompt-submit-hook|ide_selection|ide_opened_file|environment_context)\b/i;
-
 function shouldIgnoreUserText(text) {
-  const trimmed = String(text || '').trim();
-  // Bootstrap detection is DELEGATED, not copied: this used to duplicate isBootstrapPrompt's
-  // prefix list and the copies drifted — <recommended_plugins> made it into one and not the
-  // other, so the title came out clean while the same block still showed as "Usuário" in the
-  // conversation context. One filter, one place to add the next injected block.
-  return SYNTHETIC_EVENT_TAG.test(trimmed)
-    || isBootstrapPrompt(trimmed)
-    // Harness utility meta-prompts (title generation, classifiers) — not real user turns; they
-    // were leaking into note titles/summaries on import.
-    || /^Generate a concise( UI)? title/i.test(trimmed)
-    || /^You are a helpful assistant\. You will be presented with a user prompt/i.test(trimmed);
+  // Tags injetadas pelo harness não são fala humana e nunca viram título/Pedido/Usuário.
+  return isSyntheticTranscriptText(text);
 }
 
 function addUnique(list, value) {
@@ -486,11 +481,13 @@ function relocateOrphanIterations(content) {
 
 export function insertIteration(sessionPath, block, turnId, tx, vaultBase = '') {
   let inserted = false;
+  let duplicate = false;
   // Sob lock: outro hook (subagent-stop) pode estar reescrevendo a mesma nota agora.
-  mutateSessionNote(sessionPath, (original) => {
+  const mutation = mutateSessionNote(sessionPath, (original) => {
     // Self-heal: migrate any legacy `codex-turn` markers to the neutral name on this write.
     let content = normalizeTurnMarkers(original);
     if (hasTurnMarker(content, turnId)) {
+      duplicate = true;
       // Turno já registrado: ainda assim repara órfãos e seções dedicadas.
       return applyDedicatedSections(relocateOrphanIterations(content), tx);
     }
@@ -499,7 +496,24 @@ export function insertIteration(sessionPath, block, turnId, tx, vaultBase = '')
     inserted = true;
     return applyDedicatedSections(content, tx);
   }, { vaultBase });
-  return inserted;
+  const result = duplicate
+    ? 'duplicate'
+    : mutation.written && inserted
+      ? 'inserted'
+      : mutation.reason === 'busy'
+        ? 'busy'
+        : 'failed';
+  return {
+    inserted: result === 'inserted',
+    confirmed: result === 'inserted' || result === 'duplicate',
+    written: Boolean(mutation.written),
+    result,
+    reason: mutation.reason || 'unknown',
+  };
+}
+
+export function confirmedLoggedTurnId(currentTurnId, candidateTurnId, projection) {
+  return projection?.confirmed ? candidateTurnId : currentTurnId;
 }
 
 function shouldFinalizeSession() {
@@ -993,10 +1007,14 @@ export async function refreshStopObservability({
   readStore = readObservabilityStore,
   resolveRoots = resolveObservabilityRoots,
   materialize = materializeStopObservability,
+  returnDetails = false,
 } = {}) {
-  if (causalStop && !causalStop.canPromoteMemory) return false;
+  const outcome = (ok, status, reason = '') => (
+    returnDetails ? { ok, status, reason } : ok
+  );
+  if (causalStop && !causalStop.canPromoteMemory) return outcome(false, 'skipped', 'causal-stop-not-promotable');
   const deadlineAt = hookStartedAt + STOP_OBSERVABILITY_DEADLINE_MS;
-  if (now() >= deadlineAt) return false;
+  if (now() >= deadlineAt) return outcome(false, 'stale', 'deadline-before-refresh');
 
   const expected = expectedStopCausalSnapshot(entry, causalStop, turnSequence);
   const fresh = resolveEntry(vaultBase, input, entry?.provider);
@@ -1004,18 +1022,24 @@ export async function refreshStopObservability({
     || fresh.identity.canonicalConversationId !== sessionId
     || !fresh.entry?.session_file
     || fresh.entry.session_file !== entry?.session_file
-    || !sameStopCausalSnapshot(expected, stopEntryCausalSnapshot(fresh.entry))) return false;
+    || !sameStopCausalSnapshot(expected, stopEntryCausalSnapshot(fresh.entry))) {
+    return outcome(false, 'stale', 'causal-snapshot-changed');
+  }
 
   const runtime = readStore(vaultBase, sessionId);
   const signalSequence = Number(runtime?.observability_signal_sequence || 0);
   if (expectedSignalSequence !== undefined
-    && signalSequence !== Number(expectedSignalSequence)) return false;
-  if (now() >= deadlineAt) return false;
+    && signalSequence !== Number(expectedSignalSequence)) {
+    return outcome(false, 'stale', 'signal-sequence-changed');
+  }
+  if (now() >= deadlineAt) return outcome(false, 'stale', 'deadline-before-materialize');
 
   const roots = fresh.identity.provider === 'codex'
     ? resolveRoots(fresh.entry)
     : stopClaudeRoots(fresh.entry);
-  if (roots?.state !== 'complete' || !roots.rootPaths?.length) return false;
+  if (roots?.state !== 'complete' || !roots.rootPaths?.length) {
+    return outcome(false, 'missing', 'observability-roots-missing');
+  }
 
   const frontier = {
     canonical_session_id: sessionId,
@@ -1106,7 +1130,64 @@ export async function refreshStopObservability({
     withPublicationGuard,
     writeRegistryCheckpoint,
   }));
-  return !['stale', 'conflict', 'degraded', 'missing'].includes(result?.status);
+  const status = result?.status || (result?.ok === false ? 'failed' : 'published');
+  return outcome(!['stale', 'conflict', 'degraded', 'missing'].includes(status), status);
+}
+
+export function recordStopOutcome(vaultBase, {
+  sessionId = UNRESOLVED_SESSION_ID,
+  transcriptId = '',
+  turnId = UNRESOLVED_TURN_ID,
+  turnSequence = 0,
+  hook = 'Stop',
+  stage = 'iteration',
+  result = 'failed',
+  lockStatus = 'unknown',
+  durationMs = 0,
+  reason = '',
+} = {}) {
+  try {
+    return appendIterationOutcome(vaultBase, {
+      session_id: sessionId,
+      transcript_id: transcriptId,
+      turn_id: turnId,
+      turn_sequence: turnSequence,
+      hook,
+      stage,
+      result,
+      lock_status: lockStatus,
+      duration_ms: durationMs,
+      occurred_at: new Date().toISOString(),
+      reason,
+    });
+  } catch {
+    // O ledger é diagnóstico: um problema nele nunca deve bloquear a sessão nem publicar o erro.
+    return { written: false, result: 'failed', reason: 'outcome-ledger-write-failed' };
+  }
+}
+
+export function finalizeSessionRegistry(vaultBase, {
+  sessionId = '',
+  activationId = '',
+  turnId = '',
+  endedAt = '',
+} = {}) {
+  let disposition = 'ambiguous';
+  mutateSessionRegistry(vaultBase, (registry) => {
+    const closed = closeSessionActivation(registry, {
+      session_id: sessionId,
+      activation_id: activationId,
+      turn_id: turnId,
+      ended_at: endedAt,
+    });
+    disposition = closed.stopDisposition;
+    if (closed.stopDisposition === 'finalized') {
+      registry.version = closed.registry.version;
+      registry.sessions = closed.registry.sessions;
+    }
+    return null;
+  });
+  return disposition;
 }
 
 export async function main({
@@ -1128,6 +1209,14 @@ export async function main({
   const { identity, entry } = resolveSessionEntry(vaultBase, input);
   if (identity.state !== 'resolved' || !entry?.session_file) {
     const why = identity.diagnostics?.join('; ') || 'sessão não registrada';
+    recordStopOutcome(vaultBase, {
+      sessionId: identity.canonicalConversationId || input.session_id || 'unresolved',
+      transcriptId: identity.transcriptId || input.transcript_id || '',
+      turnId: input.turn_id || input.turnId || 'unresolved-turn',
+      hook: input.hook_event_name || 'Stop',
+      result: 'ambiguous',
+      reason: `identity-unresolved: ${why}`,
+    });
     process.stderr.write(`[wendkeep] Stop sem identidade segura: ${why}\n`);
     // stderr alone is a black hole here: Codex discards it, which is how an entire session of
     // lost turns produced no signal at all. systemMessage is what the UI actually shows.
@@ -1141,6 +1230,14 @@ export async function main({
   // no global (contaminaria nota alheia): pulamos e o backfill recupera depois.
   const sessionRel = entry.session_file;
   if (!sessionRel) {
+    recordStopOutcome(vaultBase, {
+      sessionId: identity.canonicalConversationId,
+      transcriptId: identity.transcriptId,
+      turnId: input.turn_id || input.turnId || 'unresolved-turn',
+      hook: input.hook_event_name || 'Stop',
+      result: 'ambiguous',
+      reason: 'session-note-not-registered',
+    });
     writeHookOutput({});
     return;
   }
@@ -1149,6 +1246,14 @@ export async function main({
     expectedType: 'file', label: 'nota de sessão do Stop',
   });
   if (!checkedSession.exists) {
+    recordStopOutcome(vaultBase, {
+      sessionId: identity.canonicalConversationId,
+      transcriptId: identity.transcriptId,
+      turnId: input.turn_id || input.turnId || 'unresolved-turn',
+      hook: input.hook_event_name || 'Stop',
+      result: 'failed',
+      reason: 'session-note-missing-on-disk',
+    });
     writeHookOutput({});
     return;
   }
@@ -1173,12 +1278,36 @@ export async function main({
         observedAt: new Date(0).toISOString(),
       });
     }
+    recordStopOutcome(vaultBase, {
+      sessionId,
+      transcriptId: identity.transcriptId,
+      turnId: requestedTurnId || 'unresolved-turn',
+      turnSequence: Number(entry.last_turn_sequence || 0),
+      hook: input.hook_event_name || 'Stop',
+      result: 'ambiguous',
+      reason: 'turn-not-proven-by-transcript',
+    });
     const message = 'wendkeep: Stop ambiguous; o turno solicitado não foi provado pelo transcript.';
     process.stderr.write(`[wendkeep] ${message}\n`);
     writeHookOutput({ systemMessage: message });
     return;
   }
   const turnId = turnIdentity.id;
+  const parsedTurn = tx.turns.find((turn) => turn.turnId === turnId);
+  if (parsedTurn?.status === 'aborted') {
+    recordStopOutcome(vaultBase, {
+      sessionId,
+      transcriptId: identity.transcriptId,
+      turnId,
+      turnSequence: turnIdentity.order,
+      hook: input.hook_event_name || 'Stop',
+      result: 'aborted',
+      reason: 'transcript-turn-aborted',
+    });
+    process.stderr.write(`[wendkeep] ${ABORTED_TURN_NOTICE}\n`);
+    writeHookOutput({ systemMessage: ABORTED_TURN_NOTICE });
+    return;
+  }
   const now = finalizing ? new Date() : null;
   const endedAt = finalizing ? formatLocalIso(now) : '';
   const causalStop = finalizing
@@ -1269,6 +1398,17 @@ export async function main({
   }
   if (shouldAbortStopAfterStaging(causalStop, memoryAttempt)) {
     const disposition = memoryAttempt?.disposition || causalStop?.stopDisposition || 'ambiguous';
+    recordStopOutcome(vaultBase, {
+      sessionId,
+      transcriptId: identity.transcriptId,
+      turnId,
+      turnSequence: stopTurnSequence,
+      hook: input.hook_event_name || 'Stop',
+      result: disposition === 'duplicate' && memoryAttempt?.state === 'duplicate'
+        ? 'duplicate'
+        : 'skipped',
+      reason: `staging-${disposition}`,
+    });
     if (disposition === 'duplicate' && memoryAttempt?.state === 'duplicate') {
       writeHookOutput({});
       return;
@@ -1278,7 +1418,19 @@ export async function main({
     writeHookOutput({ systemMessage: message });
     return;
   }
+  const iterationStartedAt = clock();
   const logged = insertIteration(sessionPath, buildIterationBlock(tx, input), turnId, tx, vaultBase);
+  recordStopOutcome(vaultBase, {
+    sessionId,
+    transcriptId: identity.transcriptId,
+    turnId,
+    turnSequence: stopTurnSequence,
+    hook: input.hook_event_name || 'Stop',
+    result: logged.result,
+    lockStatus: logged.result === 'busy' ? 'busy' : logged.confirmed ? 'acquired' : 'unknown',
+    durationMs: Math.max(0, clock() - iterationStartedAt),
+    reason: `note-${logged.reason}`,
+  });
 
   try {
     applyLinearLinks(sessionPath, tx, vaultBase, sessionRel);
@@ -1287,7 +1439,7 @@ export async function main({
   }
 
   try {
-    await refreshObservability({
+    const refreshed = await refreshObservability({
       vaultBase,
       input,
       sessionPath,
@@ -1298,9 +1450,33 @@ export async function main({
       hookStartedAt,
     }, {
       now: clock,
+      returnDetails: true,
+    });
+    const observability = typeof refreshed === 'boolean'
+      ? { status: refreshed ? 'published' : 'failed', reason: 'legacy-boolean-result' }
+      : (refreshed || { status: 'missing', reason: 'empty-result' });
+    recordStopOutcome(vaultBase, {
+      sessionId,
+      transcriptId: identity.transcriptId,
+      turnId,
+      turnSequence: stopTurnSequence,
+      hook: input.hook_event_name || 'Stop',
+      stage: 'observability',
+      result: observability.status,
+      reason: observability.reason || 'observability-refresh',
     });
   } catch (error) {
-    process.stderr.write(`[wendkeep] Token usage falhou: ${error.message}\n`);
+    recordStopOutcome(vaultBase, {
+      sessionId,
+      transcriptId: identity.transcriptId,
+      turnId,
+      turnSequence: stopTurnSequence,
+      hook: input.hook_event_name || 'Stop',
+      stage: 'observability',
+      result: 'failed',
+      reason: 'observability-refresh-threw',
+    });
+    process.stderr.write(`[wendkeep] Observabilidade falhou: ${error.message}\n`);
   }
 
   if (!finalizing) {
@@ -1310,7 +1486,7 @@ export async function main({
       session_file: sessionRel,
       last_session_file: control.last_session_file || sessionRel,
       session_id: sessionId,
-      last_logged_turn_id: logged ? turnId : control.last_logged_turn_id,
+      last_logged_turn_id: confirmedLoggedTurnId(control.last_logged_turn_id, turnId, logged),
     });
     upsertSessionRegistry(vaultBase, sessionId, {
       session_file: sessionRel,
@@ -1319,7 +1495,7 @@ export async function main({
       // (definido no SessionStart). Usar control.started_at contaminava com o
       // started_at de sessões concorrentes que sobrescrevem o ponteiro global.
       ended_at: '',
-      last_turn_id: logged ? turnId : control.last_logged_turn_id,
+      last_turn_id: confirmedLoggedTurnId(control.last_logged_turn_id, turnId, logged),
       transcript_path: transcriptPath,
       transcript_id: identity.transcriptId,
       provider: identity.provider,
@@ -1333,7 +1509,6 @@ export async function main({
     createLinkedNotes(vaultBase, formatDate(now), sessionRel, tx),
     findLinkedDerivedNotes(vaultBase, sessionRel),
   );
-  finalizeSessionFile(sessionPath, tx, created, endedAt, vaultBase);
   // Link durável sessão↔change: uma seção "Mudanças" ANTES de `## Encerramento`. O append antigo
   // (após o Encerramento) era apagado a cada reopen por stripClosingSection, perdendo a aresta do
   // grafo quando a change fechava antes do turno seguinte. Aqui sobrevive ao reopen e acumula toda
@@ -1349,16 +1524,6 @@ export async function main({
       ), { vaultBase });
     }
   } catch { /* nunca derruba o Stop */ }
-  writeControl(vaultBase, {
-    status: 'inactive',
-    session_file: '',
-    last_session_file: sessionRel,
-    started_at: control.started_at,
-    ended_at: endedAt,
-    session_id: sessionId,
-    last_logged_turn_id: turnId,
-  });
-
   const memoryResult = projectStopMemoryAttempt(vaultBase, memoryAttempt);
   if (memoryResult.status === 'legacy') {
     mutateSessionRegistry(vaultBase, (registry) => {
@@ -1378,6 +1543,62 @@ export async function main({
     recordStopMemoryOutcome(vaultBase, memoryAttempt, memoryResult);
   }
 
+  // A memória compartilhada é um consumidor causal do fechamento. Se o projetor estiver
+  // ocupado ou falhar, o outbox é a autoridade de retry e a sessão não pode ser marcada como
+  // encerrada: fechar aqui criaria uma sessão `done` sem a publicação que o fechamento promete.
+  if (memoryResult.status === 'degraded') {
+    upsertSessionRegistry(vaultBase, sessionId, {
+      session_file: sessionRel,
+      status: 'active',
+      ended_at: '',
+      last_turn_id: confirmedLoggedTurnId(control.last_logged_turn_id, turnId, logged),
+      transcript_path: transcriptPath,
+      transcript_id: identity.transcriptId,
+      provider: identity.provider,
+    });
+    writeControl(vaultBase, {
+      ...control,
+      status: 'active',
+      session_file: sessionRel,
+      last_session_file: sessionRel,
+      session_id: sessionId,
+      ended_at: '',
+      last_logged_turn_id: confirmedLoggedTurnId(control.last_logged_turn_id, turnId, logged),
+    });
+    pingObsidianVault(input.obsidian_api_key);
+    writeHookOutput({
+      systemMessage: 'wendkeep: memória compartilhada degradada; outbox preservado para retry e sessão mantida ativa.',
+    });
+    return;
+  }
+
+  finalizeSessionFile(sessionPath, tx, created, endedAt, vaultBase);
+
+  // Só fecha a activation depois do último consumidor causal (memória compartilhada) ter lido
+  // a activation ainda ativa. O registry fechado alimenta a visão CURRENT_SESSION abaixo.
+  let registryFinalization = 'ambiguous';
+  try {
+    registryFinalization = finalizeSessionRegistry(vaultBase, {
+      sessionId,
+      activationId: causalStop?.activationId || '',
+      turnId,
+      endedAt,
+    });
+  } catch (error) {
+    process.stderr.write(`[wendkeep] fechamento do registry falhou: ${error.message}\n`);
+  }
+
+  const registryClosed = registryFinalization === 'finalized' || registryFinalization === 'duplicate';
+  writeControl(vaultBase, {
+    status: registryClosed ? 'inactive' : 'active',
+    session_file: registryClosed ? '' : sessionRel,
+    last_session_file: sessionRel,
+    started_at: control.started_at,
+    ended_at: registryClosed ? endedAt : '',
+    session_id: sessionId,
+    last_logged_turn_id: confirmedLoggedTurnId(control.last_logged_turn_id, turnId, logged),
+  });
+
   // Reconstrói índice (camada fria) + digest (camada quente) ao finalizar. Nunca derruba o Stop.
   try {
     const rows = buildBrainIndex(vaultBase);

package/hooks/token-usage.mjs

@@ -14,6 +14,7 @@ import {
   normalizeClaudeUsage,
   normalizeCodexUsage,
 } from '../packages/integrations/src/transcript-usage.mjs';
+import { isSyntheticTranscriptText } from '../packages/integrations/src/prompt-content.mjs';
 export {
   addUsage,
   emptyTokenUsage,
@@ -277,17 +278,7 @@ function extractTextContent(content) {
 }
 
 function shouldIgnoreUserText(text) {
-  return /^# AGENTS\.md instructions/.test(text)
-    || text.startsWith('<environment_context>')
-    || text.startsWith('<permissions instructions>')
-    || text.startsWith('<system-reminder>')
-    || text.startsWith('<local-command-caveat>')
-    || text.startsWith('<command-name>')
-    || text.startsWith('<ide_')
-    || text.startsWith('## Memory')
-    || text.includes('You are Codex, a coding agent')
-    || /^Generate a concise( UI)? title/i.test(text)
-    || /^You are a helpful assistant\. You will be presented with a user prompt/i.test(text);
+  return isSyntheticTranscriptText(text);
 }
 
 function emptyParseResult(transcriptPath) {
@@ -371,6 +362,17 @@ function parseCodexLines(lines, result) {
       continue;
     }
 
+    if (event.type === 'response_item' && payload.type === 'custom_tool_call') {
+      result.toolCalls += 1;
+      addUnique(result.tools, payload.name || payload.tool_name || payload.tool || 'custom_tool_call');
+      continue;
+    }
+
+    if (event.type === 'response_item' && payload.type === 'custom_tool_call_output') {
+      // The output closes the call; it is not a second tool invocation and never a prompt.
+      continue;
+    }
+
     if (event.type === 'response_item' && payload.type === 'tool_search_call') {
       result.toolCalls += 1;
       addUnique(result.tools, 'tool_search');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.68.0",
+  "version": "0.68.5",
   "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": [
@@ -40,7 +40,7 @@
     "node": ">=18"
   },
   "scripts": {
-    "check": "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/operating-profile.mjs && node --check src/profile.mjs && node --check src/flow.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-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 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/operating-profile.mjs && node --check src/profile.mjs && node --check src/flow.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-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",
     "release": "node scripts/release.mjs",
     "release:dry": "node scripts/release.mjs --dry-run",
@@ -70,6 +70,6 @@
   },
   "devDependencies": {
     "acorn": "^8.18.0",
-    "wendkeep": "^0.67.1"
+    "wendkeep": "^0.68.0"
   }
 }

package/packages/harness/src/flow-store.mjs

@@ -84,10 +84,16 @@ function immutableJson(vaultBase, path, value) {
   return { created: true, path };
 }
 
+// Lock failures on the FLOW paths surface with the domain boundary code, like every other
+// Vault write in the promotion saga — not with the physical-boundary default.
 function underSessionLock(vaultBase, sessionId, fn) {
   const root = sessionRoot(vaultBase, sessionId);
-  mkdirVaultPath(vaultBase, root, { label: 'raiz runtime da sessão FLOW' });
-  const outcome = withVaultPathLock(vaultBase, join(root, '.state'), fn, { timeoutMs: 5000 });
+  mkdirVaultPath(vaultBase, root, {
+    label: 'raiz runtime da sessão FLOW', code: 'FLOW_VAULT_BOUNDARY',
+  });
+  const outcome = withVaultPathLock(vaultBase, join(root, '.state'), fn, {
+    timeoutMs: 5000, code: 'FLOW_VAULT_BOUNDARY',
+  });
   if (typeof outcome === 'symbol') {
     const error = new Error(`store FLOW ocupado para sessão ${sessionId}`);
     error.code = 'FLOW_STORE_BUSY';
@@ -107,10 +113,13 @@ export function withFlowPromotionLock(vaultBase, changeSlug, fn, {
 } = {}) {
   const slug = safeId(changeSlug, 'change_slug');
   const root = join(vaultBase, '.brain', 'runtime', 'flow-promotion-locks');
-  mkdirVaultPath(vaultBase, root, { label: 'raiz de locks de promoção FLOW' });
+  mkdirVaultPath(vaultBase, root, {
+    label: 'raiz de locks de promoção FLOW', code: 'FLOW_VAULT_BOUNDARY',
+  });
   const outcome = withVaultPathLock(vaultBase, join(root, slug), fn, {
     timeoutMs,
     staleMs: ownerGraceMs,
+    code: 'FLOW_VAULT_BOUNDARY',
   });
   if (outcome === VAULT_LOCK_BUSY) {
     const busy = new Error(`promoção FLOW ocupada para a change ${slug}`);

package/packages/integrations/src/host-hooks.mjs

@@ -41,7 +41,7 @@ export function hookCommandLocalLegacy(name) {
 }
 
 // Hooks do lifecycle de change (0.31.0) — enforcement do loop a2. Nudges (contexto/aviso/
-// cobrança/captura de plano) e gate (deny/ask no Bash). Separados em dois grupos para
+// cobrança/captura de plano) e gate (deny/ask no Bash/PreToolUse). Separados em dois grupos para
 // preservar a opção futura de gates opt-in; hoje o init wira TODOS por default.
 // preferLocal: alta frequência → invocação node-direta quando houver instalação local.
 export const CHANGE_NUDGE_HOOKS = [
@@ -54,9 +54,9 @@ export const CHANGE_NUDGE_HOOKS = [
 ];
 
 export const CHANGE_GATE_HOOKS = [
-  // codex: reads tool_input.command; Codex's exec sends a raw string and exec_command an argv,
-  // so the guard would silently fail OPEN — worse than absent, since the docs would promise it.
-  { event: 'PreToolUse', matcher: 'Bash', name: 'change-guard', timeout: 10, order: 10, preferLocal: true, statusMessage: 'wendkeep: change gate' },
+  // The adapter accepts Codex's object, raw-string and argv forms and fails closed when a
+  // mutable target cannot be proven. Keep the matcher narrow to the payloads covered by tests.
+  { event: 'PreToolUse', matcher: 'Bash|exec_command|apply_patch|mcp__.*', name: 'change-guard', timeout: 10, order: 10, preferLocal: true, codex: true, statusMessage: 'wendkeep: change gate' },
 ];
 
 // --- Codex projection ---------------------------------------------------------
@@ -65,9 +65,9 @@ export const CHANGE_GATE_HOOKS = [
 // rest carry a `// codex:` comment above them saying why. Three deltas from Claude, each
 // verified against codex-rs and each silent when wrong: the timeout key is `timeoutSec`
 // (`timeout` is not a field and falls through to a 600s default), there is no
-// ${CLAUDE_PROJECT_DIR} so `preferLocal` never applies, and matcher is only honoured on
-// SessionStart (UserPromptSubmit/Stop null it at discovery).
-export const CODEX_MATCHER_EVENTS = new Set(['SessionStart']);
+// ${CLAUDE_PROJECT_DIR} so `preferLocal` never applies, and matcher is honoured only for
+// events whose host contract is covered by tests.
+export const CODEX_MATCHER_EVENTS = new Set(['SessionStart', 'PreToolUse']);
 
 export function codexHookSpecs(specs) {
   return specs.filter((h) => h.codex === true && !h.command);