wendkeep 0.57.2 → 0.58.1

package/hooks/obsidian-common.mjs

@@ -338,9 +338,12 @@ export function mutateSessionRegistry(vaultBase, mutator, { timeoutMs = 2000 } =
 
   try {
     const registry = readSessionRegistry(vaultBase);
+    const before = JSON.stringify(registry);
     registry.version = 2;
     const result = mutator(registry);
-    writeSessionRegistry(vaultBase, registry);
+    if (JSON.stringify(registry) !== before) {
+      writeSessionRegistry(vaultBase, registry);
+    }
     return result;
   } finally {
     // rmSync recursivo não remove diretório em caminho não-ASCII no Windows — ver
@@ -350,14 +353,204 @@ export function mutateSessionRegistry(vaultBase, mutator, { timeoutMs = 2000 } =
 }
 
 function meaningfulPatch(patch = {}) {
-  const protectedNonEmpty = new Set(['session_file', 'transcript_path', 'transcript_id', 'provider', 'started_at', 'change_slug']);
+  const protectedNonEmpty = new Set(['session_file', 'transcript_path', 'transcript_id', 'provider', 'started_at', 'change_slug', 'activation_id']);
   return Object.fromEntries(Object.entries(patch).filter(([key, value]) => {
+    if (key === 'advance_turn_sequence' || key === 'turn_sequence') return false;
     if (value === undefined || value === null) return false;
     if (value === '' && protectedNonEmpty.has(key)) return false;
     return true;
   }));
 }
 
+function nonNegativeSequence(value, fallback = null) {
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : fallback;
+}
+
+function cloneRegistry(registry = {}) {
+  const sessions = Object.fromEntries(Object.entries(registry.sessions || {}).map(([id, entry]) => [
+    id,
+    {
+      ...(entry || {}),
+      ...(entry?.activations && typeof entry.activations === 'object'
+        ? { activations: Object.fromEntries(Object.entries(entry.activations).map(([activationId, activation]) => [activationId, { ...(activation || {}) }])) }
+        : {}),
+    },
+  ]));
+  return { ...registry, version: Math.max(2, registry.version || 1), sessions };
+}
+
+// Pure causal helpers. Keeping them independent from filesystem I/O lets Stop perform its
+// compare-and-swap under the same registry lock used by the existing upsert path.
+export function openActivation(registry, session = {}, explicitActivationId = '') {
+  const next = cloneRegistry(registry);
+  const sessionId = session.session_id || session.canonical_session_id || session.id || '';
+  const activationId = explicitActivationId || session.activation_id || '';
+  if (!sessionId || !activationId) throw new TypeError('session_id and activation_id are required');
+
+  const current = next.sessions[sessionId] || {};
+  const activations = { ...(current.activations || {}) };
+  const requestedSequence = nonNegativeSequence(
+    session.turn_sequence ?? session.last_turn_sequence,
+    0,
+  );
+
+  if (current.active_activation_id === activationId && activations[activationId]?.status === 'active') {
+    const sequence = Math.max(nonNegativeSequence(current.last_turn_sequence, 0), requestedSequence);
+    activations[activationId] = {
+      ...activations[activationId],
+      last_turn_sequence: sequence,
+    };
+    next.sessions[sessionId] = {
+      ...current,
+      activation_id: activationId,
+      active_activation_id: activationId,
+      last_turn_sequence: sequence,
+      activations,
+    };
+    return next;
+  }
+
+  const previousId = current.active_activation_id || '';
+  if (previousId && activations[previousId]?.status === 'active') {
+    activations[previousId] = {
+      ...activations[previousId],
+      status: 'superseded',
+      superseded_by: activationId,
+      superseded_at: session.started_at || session.activation_started_at || '',
+    };
+  }
+
+  const epoch = Math.max(
+    nonNegativeSequence(current.activation_epoch, 0),
+    ...Object.values(activations).map((activation) => nonNegativeSequence(activation?.epoch, 0)),
+  ) + 1;
+  activations[activationId] = {
+    activation_id: activationId,
+    epoch,
+    status: 'active',
+    started_at: session.activation_started_at || session.started_at || '',
+    last_turn_sequence: requestedSequence,
+    ...(session.transcript_id ? { transcript_id: session.transcript_id } : {}),
+    ...(session.transcript_path ? { transcript_path: session.transcript_path } : {}),
+    ...(session.provider ? { provider: session.provider } : {}),
+  };
+  next.sessions[sessionId] = {
+    ...current,
+    activation_id: activationId,
+    active_activation_id: activationId,
+    activation_epoch: epoch,
+    activation_started_at: session.activation_started_at || session.started_at || '',
+    last_turn_sequence: requestedSequence,
+    activations,
+  };
+  return next;
+}
+
+export function advanceActivationTurn(registry, turn = {}) {
+  const next = cloneRegistry(registry);
+  const sessionId = turn.session_id || turn.canonical_session_id || '';
+  const current = next.sessions[sessionId];
+  if (!current) return next;
+
+  const activeId = current.active_activation_id || '';
+  if (turn.activation_id && activeId && turn.activation_id !== activeId) return next;
+  const previous = nonNegativeSequence(current.last_turn_sequence, 0);
+  const explicit = nonNegativeSequence(turn.turn_sequence ?? turn.last_turn_sequence);
+  const sequence = explicit === null ? previous + 1 : Math.max(previous, explicit);
+  const activations = { ...(current.activations || {}) };
+  if (activeId && activations[activeId]) {
+    activations[activeId] = {
+      ...activations[activeId],
+      last_turn_sequence: Math.max(
+        nonNegativeSequence(activations[activeId].last_turn_sequence, 0),
+        sequence,
+      ),
+    };
+  }
+  next.sessions[sessionId] = { ...current, last_turn_sequence: sequence, activations };
+  return next;
+}
+
+export function resolveStopActivation(registry, stop = {}) {
+  const sessionId = stop.session_id || stop.canonical_session_id || '';
+  const entry = registry?.sessions?.[sessionId];
+  if (!entry) return '';
+  if (stop.activation_id) return String(stop.activation_id);
+
+  const transcriptId = String(stop.transcript_id || '');
+  const transcriptPath = String(stop.transcript_path || '');
+  if (!transcriptId && !transcriptPath) return '';
+  const matches = Object.entries(entry.activations || {}).filter(([, activation]) => {
+    if (!activation) return false;
+    if (transcriptId && activation.transcript_id && activation.transcript_id !== transcriptId) return false;
+    const paths = [
+      ...(Array.isArray(activation.transcript_paths) ? activation.transcript_paths : []),
+      activation.transcript_path,
+    ].filter(Boolean);
+    if (transcriptPath && paths.length && !paths.some((path) => transcriptsMatch(path, transcriptPath))) return false;
+    return Boolean(
+      (transcriptId && activation.transcript_id === transcriptId)
+      || (transcriptPath && paths.some((path) => transcriptsMatch(path, transcriptPath))),
+    );
+  });
+  return matches.length === 1 ? matches[0][0] : '';
+}
+
+function stopResult(registry, stopDisposition, canPromoteMemory = false) {
+  return {
+    ...registry,
+    registry,
+    stopDisposition,
+    canPromoteMemory,
+  };
+}
+
+export function applyStopActivation(registry, stop = {}) {
+  const next = cloneRegistry(registry);
+  const sessionId = stop.session_id || stop.canonical_session_id || '';
+  const current = next.sessions[sessionId];
+  const activeId = current?.active_activation_id || '';
+  const stopActivationId = stop.activation_id || '';
+  if (!current || !activeId || !stopActivationId) return stopResult(next, 'ambiguous');
+  if (current.activations?.[activeId]?.status !== 'active') return stopResult(next, 'ambiguous');
+
+  if (activeId !== stopActivationId) {
+    const activations = { ...(current.activations || {}) };
+    if (activations[stopActivationId]?.status === 'active') {
+      activations[stopActivationId] = {
+        ...activations[stopActivationId],
+        status: 'superseded',
+        superseded_by: activeId,
+      };
+      next.sessions[sessionId] = { ...current, activations };
+    }
+    return stopResult(next, 'superseded');
+  }
+
+  const stopSequence = nonNegativeSequence(stop.turn_sequence ?? stop.last_turn_sequence);
+  const lastSequence = nonNegativeSequence(current.last_turn_sequence, 0);
+  if (stopSequence === null) return stopResult(next, 'ambiguous');
+  if (stopSequence < lastSequence) return stopResult(next, 'stale_turn');
+
+  const activations = { ...(current.activations || {}) };
+  activations[activeId] = {
+    ...(activations[activeId] || { activation_id: activeId, epoch: current.activation_epoch }),
+    status: 'done',
+    ended_at: stop.ended_at || '',
+    last_turn_sequence: stopSequence,
+  };
+  next.sessions[sessionId] = {
+    ...current,
+    status: 'done',
+    ended_at: stop.ended_at || current.ended_at || '',
+    active_activation_id: '',
+    last_turn_sequence: stopSequence,
+    activations,
+  };
+  return stopResult(next, 'applied', true);
+}
+
 // Remove one registry entry, but ONLY when its transcript matches the given path — this is
 // self-healing for entries wendkeep itself mis-wrote (a subagent rollout registered as a
 // top-level session by import <=0.46.1), never generic registry cleanup. An entry with the
@@ -382,16 +575,58 @@ export function upsertSessionRegistry(vaultBase, sessionId, patch) {
   const clean = meaningfulPatch(patch);
   const next = mutateSessionRegistry(vaultBase, (registry) => {
     const current = registry.sessions[sessionId] || {};
+    let causalCurrent = current;
+    if (clean.activation_id) {
+      causalCurrent = openActivation(
+        { version: registry.version, sessions: { [sessionId]: current } },
+        {
+          session_id: sessionId,
+          activation_id: clean.activation_id,
+          activation_started_at: clean.activation_started_at,
+          started_at: clean.activation_started_at || clean.started_at,
+          last_turn_sequence: clean.last_turn_sequence,
+          transcript_id: clean.transcript_id || current.transcript_id,
+          transcript_path: clean.transcript_path || current.transcript_path,
+          provider: clean.provider || current.provider,
+        },
+      ).sessions[sessionId];
+    }
+    if (patch?.advance_turn_sequence === true || patch?.turn_sequence !== undefined) {
+      causalCurrent = advanceActivationTurn(
+        { version: registry.version, sessions: { [sessionId]: causalCurrent } },
+        {
+          session_id: sessionId,
+          activation_id: causalCurrent.active_activation_id || '',
+          turn_sequence: patch.turn_sequence,
+        },
+      ).sessions[sessionId];
+    }
+    const activeId = causalCurrent.active_activation_id || '';
+    if (activeId && causalCurrent.activations?.[activeId]) {
+      const active = causalCurrent.activations[activeId];
+      causalCurrent = {
+        ...causalCurrent,
+        activations: {
+          ...causalCurrent.activations,
+          [activeId]: {
+            ...active,
+            ...(!active.transcript_id && clean.transcript_id ? { transcript_id: clean.transcript_id } : {}),
+            ...(!active.transcript_path && clean.transcript_path ? { transcript_path: clean.transcript_path } : {}),
+            ...(!active.provider && clean.provider ? { provider: clean.provider } : {}),
+          },
+        },
+      };
+    }
     const transcriptPaths = [...new Set([
-      ...(Array.isArray(current.transcript_paths) ? current.transcript_paths : []),
-      current.transcript_path,
+      ...(Array.isArray(causalCurrent.transcript_paths) ? causalCurrent.transcript_paths : []),
+      causalCurrent.transcript_path,
       ...(Array.isArray(clean.transcript_paths) ? clean.transcript_paths : []),
       clean.transcript_path,
     ].filter(Boolean))];
     const value = {
-      ...current,
+      ...causalCurrent,
       ...clean,
-      ...(transcriptPaths.length ? { transcript_paths: transcriptPaths, transcript_path: clean.transcript_path || current.transcript_path || transcriptPaths.at(-1) } : {}),
+      ...(transcriptPaths.length ? { transcript_paths: transcriptPaths, transcript_path: clean.transcript_path || causalCurrent.transcript_path || transcriptPaths.at(-1) } : {}),
       last_seen: clean.last_seen || clean.updated_at || formatLocalIso(new Date()),
       updated_at: clean.updated_at || formatLocalIso(new Date()),
     };

package/hooks/session-ensure.mjs

@@ -37,6 +37,12 @@ function sessionIdFromInput(input) {
   return input.session_id || input.sessionId || input.codex_session_id || '';
 }
 
+function turnSequenceFromInput(input = {}) {
+  const value = input.turn_sequence ?? input.turnSequence;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : undefined;
+}
+
 function buildSessionContent({ relPath, now, summary = 'session', sessionId = '', reason = 'Sessão criada automaticamente pelo hook UserPromptSubmit.' }) {
   const date = formatDate(now);
   const startedAt = formatLocalIso(now);
@@ -262,6 +268,8 @@ function activateExistingSession({ vaultBase, relPath, startedAt, sessionId, inp
     transcript_path: identity.transcriptPath,
     transcript_id: identity.transcriptId,
     provider: identity.provider,
+    advance_turn_sequence: true,
+    turn_sequence: turnSequenceFromInput(input),
   });
   return true;
 }
@@ -288,6 +296,8 @@ function createSession({ vaultBase, sessionId, input, now, identity }) {
     transcript_path: identity.transcriptPath,
     transcript_id: identity.transcriptId,
     provider: identity.provider,
+    advance_turn_sequence: true,
+    turn_sequence: turnSequenceFromInput(input),
   });
   return { relPath, startedAt };
 }
@@ -333,6 +343,14 @@ function main() {
         existsSync(join(vaultBase, ctrl.session_file)) &&
         ctrl.session_id === sessionId
       ) {
+        upsertSessionRegistry(vaultBase, sessionId, {
+          status: 'active',
+          transcript_path: identity.transcriptPath,
+          transcript_id: identity.transcriptId,
+          provider: identity.provider,
+          advance_turn_sequence: true,
+          turn_sequence: turnSequenceFromInput(input),
+        });
         writeHookOutput({});
         return;
       }
@@ -375,6 +393,8 @@ function main() {
         transcript_path: identity.transcriptPath,
         transcript_id: identity.transcriptId,
         provider: identity.provider,
+        advance_turn_sequence: true,
+        turn_sequence: turnSequenceFromInput(input),
       });
       writeHookOutput({});
       return;

package/hooks/session-start.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { existsSync, writeFileSync } from 'fs';
+import { randomUUID } from 'crypto';
 import { basename, join } from 'path';
 import { pathToFileURL } from 'url';
 import {
@@ -169,6 +170,14 @@ function main() {
   const sessionId = identity.canonicalConversationId;
   const transcriptPath = identity.transcriptPath;
   const control = readControl(vaultBase);
+  const activationId = input.activation_id || input.activationId || randomUUID();
+  const activationStartedAt = formatLocalIso(now);
+  const registerActivation = (canonicalSessionId, patch) => upsertSessionRegistry(vaultBase, canonicalSessionId, {
+    ...patch,
+    activation_id: activationId,
+    activation_started_at: activationStartedAt,
+    last_turn_sequence: 0,
+  });
 
   // Fecha sessões `active` órfãs (sem evento de fim — janela fechada/crash) antes
   // de seguir. Preserva a deste transcript: pode ser reaproveitada logo abaixo.
@@ -186,7 +195,7 @@ function main() {
   if (control.status === 'active' && control.session_file && control.session_id === sessionId) {
     const activePath = join(vaultBase, control.session_file);
     if (existsSync(activePath)) {
-      upsertSessionRegistry(vaultBase, sessionId, {
+      registerActivation(sessionId, {
         session_file: control.session_file,
         status: 'active',
         started_at: control.started_at,
@@ -232,7 +241,7 @@ function main() {
         session_id: sessionId,
         last_logged_turn_id: control.last_logged_turn_id || '',
       });
-      upsertSessionRegistry(vaultBase, sessionId, {
+      registerActivation(sessionId, {
         session_file: known.session_file,
         status: 'active',
         started_at: startedAt,
@@ -275,7 +284,7 @@ function main() {
         session_id: sessionId || match.sessionId,
         last_logged_turn_id: control.last_logged_turn_id || '',
       });
-      upsertSessionRegistry(vaultBase, sessionId || match.sessionId, {
+      registerActivation(sessionId || match.sessionId, {
         session_file: match.session_file,
         status: 'active',
         started_at: startedAt,
@@ -305,7 +314,7 @@ function main() {
     started_at: startedAt,
     session_id: sessionId,
   });
-  upsertSessionRegistry(vaultBase, sessionId, {
+  registerActivation(sessionId, {
     session_file: relPath,
     status: 'active',
     started_at: startedAt,

package/hooks/session-stop.mjs

@@ -12,6 +12,10 @@ import { updateSessionObservability } from './session-observability.mjs';
 import { resolveSessionEntry } from './session-identity.mjs';
 import { mutateSessionNote } from './session-note-io.mjs';
 import { applyDerivedSections, provenanceSessions } from './derived-sections.mjs';
+import { buildSessionMemoryEvents, collectLifecycleEvidence } from './memory-handoff.mjs';
+import { enqueueMemoryEvent, projectMemoryOutbox } from './memory-store.mjs';
+import { detectMemoryMode } from './memory-mode.mjs';
+import { sanitizeMemoryText } from './memory-schema.mjs';
 import {
   ensureDir,
   findActiveSessionByTranscript,
@@ -37,6 +41,9 @@ import {
   turnMarker,
   hasTurnMarker,
   normalizeTurnMarkers,
+  mutateSessionRegistry,
+  resolveStopActivation,
+  applyStopActivation,
 } from './obsidian-common.mjs';
 
 function extractContentText(content) {
@@ -792,6 +799,45 @@ function shouldFinalizeSession() {
   return process.env.OBSIDIAN_NO_AUTO_FINALIZE !== '1';
 }
 
+export function commitSessionMemory(vaultBase, handoff, { projectOptions = {} } = {}) {
+  if (detectMemoryMode(vaultBase).mode === 'legacy') {
+    return { status: 'legacy', eventCount: 0, eventIds: [], checkpoint: null };
+  }
+  const events = buildSessionMemoryEvents(handoff);
+  const eventIds = events.map((event) => event.event_id);
+  try {
+    for (const event of events) enqueueMemoryEvent(vaultBase, event);
+    const projection = projectMemoryOutbox(vaultBase, projectOptions);
+    if (projection.status === 'busy') {
+      return {
+        status: 'degraded',
+        error: 'memory projector busy; outbox preserved for replay',
+        eventCount: events.length,
+        eventIds,
+        checkpoint: null,
+      };
+    }
+    return {
+      status: 'projected',
+      eventCount: events.length,
+      eventIds,
+      checkpoint: {
+        revision: projection.revision,
+        event_cursor: projection.eventCursor,
+        state_hash: projection.stateHash,
+      },
+    };
+  } catch (error) {
+    return {
+      status: 'degraded',
+      error: sanitizeMemoryText(error?.message || String(error)),
+      eventCount: events.length,
+      eventIds,
+      checkpoint: null,
+    };
+  }
+}
+
 // Só captura checkboxes de tarefa reais (`- [ ] ...`). Antes casava as palavras
 // `todo`/`pendência`/`pendente` em prosa (ex.: "todo" dentro de "todos"), o que
 // despejava trechos de conversa na seção Pendências.
@@ -913,9 +959,7 @@ function replaceClosingSection(content, closing) {
 export function finalizeSessionFile(sessionPath, tx, created, endedAt) {
   const pending = extractPending(tx.rawTextForDetection);
   const links = (items) => items.length ? items.map((rel) => `  - ${wikilinkFromRel(rel)}`).join('\n') : '  - Nenhuma';
-  const summary = tx.latestAssistantMessage
-    ? truncate(tx.latestAssistantMessage, 500)
-    : `Sessão encerrada com ${tx.userPrompts.length} prompts e ${tx.tools.length} ferramentas registradas.`;
+  const summary = sessionFinalSummary(tx);
 
   const closing = `## Encerramento
 
@@ -943,6 +987,12 @@ ${formatPendingClosing(pending)}
   ));
 }
 
+export function sessionFinalSummary(tx) {
+  return tx.latestAssistantMessage
+    ? truncate(tx.latestAssistantMessage, 500)
+    : `Sessão encerrada com ${tx.userPrompts.length} prompts e ${tx.tools.length} ferramentas registradas.`;
+}
+
 // --- Vínculo Sessão ↔ Issues Linear (03-Linear) -------------------------------
 // Coleta IDs `NUT-\d+` citados na conversa, resolve as notas em 03-Linear e, ao
 // ler cada nota, descobre NUTs conectadas (1 salto) mencionadas no corpo dela.
@@ -1085,6 +1135,53 @@ function main() {
   const tx = parseTranscript(input.transcript_path || input.transcriptPath);
   const turnId = input.turn_id || tx.latestTurnId || String(Date.now());
   const sessionId = identity.canonicalConversationId;
+  const finalizing = shouldFinalizeSession();
+  const now = finalizing ? new Date() : null;
+  const endedAt = finalizing ? formatLocalIso(now) : '';
+  const stopTurnSequence = Number.isSafeInteger(Number(input.turn_sequence))
+    ? Number(input.turn_sequence)
+    : Number(entry.last_turn_sequence || 0);
+  const causalStop = finalizing
+    ? mutateSessionRegistry(vaultBase, (registry) => {
+      const activationId = resolveStopActivation(registry, {
+        session_id: sessionId,
+        activation_id: input.activation_id || input.activationId || '',
+        transcript_id: identity.transcriptId,
+        transcript_path: identity.transcriptPath || transcriptPath,
+      });
+      const cas = applyStopActivation(registry, {
+        session_id: sessionId,
+        activation_id: activationId,
+        turn_sequence: stopTurnSequence,
+        ended_at: endedAt,
+      });
+      const activation = cas.registry.sessions[sessionId]?.activations?.[activationId] || null;
+      if (cas.canPromoteMemory) {
+        registry.version = cas.registry.version;
+        registry.sessions = cas.registry.sessions;
+        registry.sessions[sessionId] = {
+          ...registry.sessions[sessionId],
+          session_file: sessionRel,
+          last_turn_id: turnId,
+          transcript_path: transcriptPath,
+          transcript_id: identity.transcriptId,
+          provider: identity.provider,
+        };
+      }
+      return {
+        activationId,
+        activation,
+        stopDisposition: cas.stopDisposition,
+        canPromoteMemory: cas.canPromoteMemory,
+      };
+    })
+    : null;
+  if (causalStop && !causalStop.canPromoteMemory) {
+    const message = `wendkeep: Stop ${causalStop.stopDisposition}; uma activation mais nova foi preservada e a memória não foi promovida.`;
+    process.stderr.write(`[wendkeep] ${message}\n`);
+    writeHookOutput({ systemMessage: message });
+    return;
+  }
   const logged = insertIteration(sessionPath, buildIterationBlock(tx, input), turnId, tx);
 
   try {
@@ -1099,7 +1196,7 @@ function main() {
     process.stderr.write(`[wendkeep] Token usage falhou: ${error.message}\n`);
   }
 
-  if (!shouldFinalizeSession()) {
+  if (!finalizing) {
     writeControl(vaultBase, {
       ...control,
       status: 'active',
@@ -1125,8 +1222,6 @@ function main() {
     return;
   }
 
-  const now = new Date();
-  const endedAt = formatLocalIso(now);
   const created = mergeCreatedNotes(
     createLinkedNotes(vaultBase, formatDate(now), sessionRel, tx),
     findLinkedDerivedNotes(vaultBase, sessionRel),
@@ -1156,15 +1251,40 @@ function main() {
     session_id: sessionId,
     last_logged_turn_id: turnId,
   });
-  upsertSessionRegistry(vaultBase, sessionId, {
-    session_file: sessionRel,
-    status: 'done',
-    // started_at omitido: preserva o da própria entry (ver branch acima).
-    ended_at: endedAt,
-    last_turn_id: turnId,
-    transcript_path: transcriptPath,
-    transcript_id: identity.transcriptId,
-    provider: identity.provider,
+
+  let projectId = '';
+  try {
+    projectId = JSON.parse(readFileSync(join(vaultBase, '.brain', 'PROJECT.json'), 'utf8')).projectId || '';
+  } catch { /* store validator reports a degraded handoff below */ }
+  const finalSummary = sessionFinalSummary(tx);
+  const memoryEvidence = collectLifecycleEvidence(vaultBase, {
+    changeSlug: entry.change_slug,
+    summary: finalSummary,
+    noteRel: sessionRel,
+  });
+  const memoryResult = commitSessionMemory(vaultBase, {
+    projectId,
+    identity,
+    activation: {
+      id: causalStop.activationId,
+      epoch: Number(causalStop.activation?.epoch || entry.activation_epoch || 0),
+    },
+    turn: { id: turnId, sequence: stopTurnSequence },
+    noteRel: sessionRel,
+    observedAt: new Date().toISOString(),
+    summary: finalSummary,
+    evidence: memoryEvidence,
+  });
+  mutateSessionRegistry(vaultBase, (registry) => {
+    const current = registry.sessions[sessionId];
+    if (!current) return null;
+    registry.sessions[sessionId] = {
+      ...current,
+      memory_status: memoryResult.status,
+      memory_activation_id: causalStop.activationId,
+      ...(memoryResult.checkpoint ? { memory_checkpoint: memoryResult.checkpoint } : {}),
+    };
+    return null;
   });
 
   // Reconstrói índice (camada fria) + digest (camada quente) ao finalizar. Nunca derruba o Stop.
@@ -1179,7 +1299,9 @@ function main() {
   try { pruneChangeSentinels(vaultBase); } catch { /* bônus */ }
 
   pingObsidianVault(input.obsidian_api_key);
-  writeHookOutput({});
+  writeHookOutput(memoryResult.status === 'degraded'
+    ? { systemMessage: `wendkeep: sessão salva; memória compartilhada degradada (${memoryResult.error}). Outbox preservada para replay.` }
+    : {});
 }
 
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {