wendkeep 0.66.4 → 0.67.0

package/hooks/session-stop.mjs

@@ -8,8 +8,13 @@ import { addUsage, costBreakdown, emptyTokenUsage, normalizeClaudeUsage, normali
 import { buildBrainDigest, buildBrainIndex } from './brain-core.mjs';
 import { activeChangeLink, pruneChangeSentinels } from './change-core.mjs';
 import { getLocale } from './locale.mjs';
-import { updateSessionObservability } from './session-observability.mjs';
+import { materializeSessionObservability } from './session-observability.mjs';
 import { resolveSessionEntry } from './session-identity.mjs';
+import { resolveObservabilityRoots } from './session-observability-lifecycle.mjs';
+import {
+  markObservabilityCheckpoint,
+  readObservabilityStore,
+} from './session-observability-store.mjs';
 import { mutateSessionNote } from './session-note-io.mjs';
 import { applyDerivedSections, provenanceSessions } from './derived-sections.mjs';
 import { buildSessionMemoryEvents, collectLifecycleEvidence } from './memory-handoff.mjs';
@@ -28,6 +33,7 @@ import {
   parseTranscriptContent,
   resolveTurnIdentity,
 } from '../packages/integrations/src/transcripts.mjs';
+import { sanitizeAssistantMessage } from '../packages/integrations/src/prompt-content.mjs';
 export { resolveTurnIdentity };
 import {
   ensureDir,
@@ -208,6 +214,13 @@ function escapeMarkdownBackticks(text) {
   return escaped;
 }
 
+function escapeMarkdownHtmlTags(text) {
+  return String(text || '').replace(
+    /<(\/?[\p{L}][\p{L}\p{N}_.-]*)(?=[\s/>])([^<>\n]*)>/gu,
+    '&lt;$1$2&gt;',
+  );
+}
+
 function compactText(text, max = 600) {
   const clean = redactSecrets(String(text || ''))
     .replace(/\r/g, '\n')
@@ -218,7 +231,8 @@ function compactText(text, max = 600) {
   const clipped = truncate(source, max);
   // Um corte no meio de código inline/fence pode casar com backticks da próxima
   // entrada gerada. Só snippets realmente truncados perdem a formatação incompleta.
-  return compact.length > max ? escapeMarkdownBackticks(clipped) : clipped;
+  const markdownSafe = compact.length > max ? escapeMarkdownBackticks(clipped) : clipped;
+  return escapeMarkdownHtmlTags(markdownSafe);
 }
 
 function selectTurn(tx, turnId) {
@@ -230,6 +244,11 @@ function selectTurn(tx, turnId) {
 
 function formatConversation(turn) {
   const entries = (turn.conversation || [])
+    .map((entry) => (
+      entry.role === 'Assistente'
+        ? { ...entry, text: sanitizeAssistantMessage(entry.text) }
+        : entry
+    ))
     .filter((entry) => entry.text && !shouldIgnoreUserText(entry.text));
   if (!entries.length) return '- Nenhuma mensagem útil capturada no transcript.';
 
@@ -299,7 +318,9 @@ export function buildIterationBlock(tx, input) {
   const now = Number.isFinite(parsedDate.getTime()) ? parsedDate : new Date();
   const promptText = turn.userPrompts.at(-1) || tx.latestUserPrompt || '';
   const latestAssistant = turn.assistantMessages.at(-1) || tx.latestAssistantMessage || '';
-  const heading = truncate(promptText.replace(/[\r\n#]+/g, ' ').replace(/\s+/g, ' ').trim() || 'Iteração', 80);
+  const heading = escapeMarkdownHtmlTags(
+    truncate(promptText.replace(/[\r\n#]+/g, ' ').replace(/\s+/g, ' ').trim() || 'Iteração', 80),
+  );
   const files = [...new Set([...(turn.consultedFiles || []), ...(turn.changedFiles || [])])];
   const model = turn.model || tx.model || '';
 
@@ -320,7 +341,7 @@ ${formatConversation(turn)}
 
 **Arquivos detectados no turno:** ${formatInlineList(files, 'Nenhum arquivo detectado automaticamente.')}
 
-**Estado ao final do turno:** ${compactText(latestAssistant || 'Checkpoint registrado automaticamente ao final do turno.', 900)}
+**Estado ao final do turno:** ${compactText(sanitizeAssistantMessage(latestAssistant) || 'Checkpoint registrado automaticamente ao final do turno.', 900)}
 `;
 }
 
@@ -644,6 +665,104 @@ function replaceClosingSection(content, closing) {
   return `${content.slice(0, index).trimEnd()}\n\n${closing}\n`;
 }
 
+const GENERATED_ITERATION_LINE_RULES = [
+  { pattern: /^(### \d{2}:\d{2} - )(.*)$/u, assistant: false },
+  { pattern: /^(\*\*Pedido:\*\* )(.*)$/u, assistant: false },
+  { pattern: /^(- \*\*Usuário:\*\* )(.*)$/u, assistant: false },
+  { pattern: /^(- \*\*Assistente:\*\* )(.*)$/u, assistant: true },
+  { pattern: /^(- \*\*Resumo:\*\* )(.*)$/u, assistant: true },
+  { pattern: /^(\*\*Estado ao final do turno:\*\* )(.*)$/u, assistant: true },
+];
+const GENERATED_CLOSING_LINE_RULES = [
+  { pattern: /^(- \*\*Resumo final:\*\* )(.*)$/u, assistant: true },
+];
+
+function generatedSessionLine(line, rules) {
+  for (const rule of rules) {
+    const match = rule.pattern.exec(line);
+    if (match) return { ...rule, prefix: match[1], value: match[2] };
+  }
+  return null;
+}
+
+function splitSessionMarkdownLines(source) {
+  const lines = [];
+  let cursor = 0;
+  while (cursor < source.length) {
+    const newline = source.indexOf('\n', cursor);
+    if (newline === -1) {
+      lines.push({ text: source.slice(cursor), eol: '' });
+      break;
+    }
+    const textEnd = source[newline - 1] === '\r' ? newline - 1 : newline;
+    lines.push({ text: source.slice(cursor, textEnd), eol: source.slice(textEnd, newline + 1) });
+    cursor = newline + 1;
+  }
+  return lines;
+}
+
+function generatedMetadataContinuation(line, mode = '') {
+  const clean = line.trim();
+  if (!clean) return null;
+  if (/^<\/?session\s*>/i.test(clean)) return mode;
+  if (/^<\/?(?:oai-mem-citation|citation_entries|rollout_ids)\b/i.test(clean)) {
+    const nested = [...clean.matchAll(/<(citation_entries|rollout_ids)\b[^>]*>/gi)].at(-1);
+    return nested ? nested[1].toLowerCase() : mode;
+  }
+  if (mode === 'citation_entries' && (
+    /\|note=\[[^\]]*\]\s*$/i.test(clean)
+      || /^[^\s<>]+:\d+(?:-\d+)?(?:\|[^\s].*)?$/i.test(clean)
+  )) return mode;
+  if (mode === 'rollout_ids' && /^(?:[0-9a-f]{8,}(?:-[0-9a-f-]+)*|019f-[A-Za-z0-9_-]+)$/i.test(clean)) {
+    return mode;
+  }
+  return null;
+}
+
+export function sanitizeGeneratedSessionMarkdown(content) {
+  const lines = splitSessionMarkdownLines(String(content || ''));
+  let section = '';
+  let output = '';
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (/^## /u.test(line.text)) {
+      section = line.text === '## Iterações'
+        ? 'iterations'
+        : (line.text === '## Encerramento' ? 'closing' : '');
+      output += `${line.text}${line.eol}`;
+      continue;
+    }
+
+    const rules = section === 'iterations'
+      ? GENERATED_ITERATION_LINE_RULES
+      : (section === 'closing' ? GENERATED_CLOSING_LINE_RULES : []);
+    const generated = generatedSessionLine(line.text, rules);
+    if (!generated) {
+      output += `${line.text}${line.eol}`;
+      continue;
+    }
+
+    let value = generated.value;
+    let last = index;
+    let mode = '';
+    if (generated.assistant) {
+      for (let next = index + 1; next < lines.length; next += 1) {
+        const nextMode = generatedMetadataContinuation(lines[next].text, mode);
+        if (nextMode === null) break;
+        value += `${lines[last].eol}${lines[next].text}`;
+        last = next;
+        mode = nextMode;
+      }
+      value = sanitizeAssistantMessage(value);
+    }
+
+    output += `${generated.prefix}${escapeMarkdownHtmlTags(value)}${lines[last].eol}`;
+    index = last;
+  }
+  return output;
+}
+
 export function finalizeSessionFile(sessionPath, tx, created, endedAt, vaultBase = '') {
   const pending = extractPending(tx.rawTextForDetection);
   const links = (items) => items.length ? items.map((rel) => `  - ${wikilinkFromRel(rel)}`).join('\n') : '  - Nenhuma';
@@ -668,7 +787,7 @@ ${formatPendingClosing(pending)}
     // As três seções derivadas saem do MESMO `created` que monta o Encerramento — antes
     // elas ficavam de fora deste write e a nota mentia no corpo (ver hooks/derived-sections.mjs).
     applyDerivedSections(
-      replacePendingSection(updateFrontmatter(content, endedAt), pending),
+      replacePendingSection(updateFrontmatter(sanitizeGeneratedSessionMarkdown(content), endedAt), pending),
       created,
     ),
     closing,
@@ -676,8 +795,9 @@ ${formatPendingClosing(pending)}
 }
 
 export function sessionFinalSummary(tx) {
-  return tx.latestAssistantMessage
-    ? truncate(tx.latestAssistantMessage, 500)
+  const assistantSummary = sanitizeAssistantMessage(tx.latestAssistantMessage);
+  return assistantSummary
+    ? compactText(assistantSummary, 500)
     : `Sessão encerrada com ${tx.userPrompts.length} prompts e ${tx.tools.length} ferramentas registradas.`;
 }
 
@@ -794,7 +914,206 @@ export function shouldAbortStopAfterStaging(causalStop, memoryAttempt) {
   );
 }
 
-export function main({ stageMemory = stageStopMemoryAttempt } = {}) {
+const STOP_OBSERVABILITY_DEADLINE_MS = 45_000;
+
+function stopEntryCausalSnapshot(entry) {
+  const activationId = String(entry?.active_activation_id || '');
+  const activation = entry?.activations?.[activationId] || {};
+  return {
+    activationId,
+    activationEpoch: Number(activation.epoch || entry?.activation_epoch || 0),
+    turnSequence: Number(entry?.last_turn_sequence || activation.last_turn_sequence || 0),
+  };
+}
+
+function expectedStopCausalSnapshot(entry, causalStop, turnSequence) {
+  if (!causalStop) return stopEntryCausalSnapshot(entry);
+  return {
+    activationId: String(causalStop.activationId || ''),
+    activationEpoch: Number(causalStop.activation?.epoch || entry?.activation_epoch || 0),
+    turnSequence: Number(turnSequence || 0),
+  };
+}
+
+function sameStopCausalSnapshot(left, right) {
+  return left.activationId === right.activationId
+    && left.activationEpoch === right.activationEpoch
+    && left.turnSequence === right.turnSequence;
+}
+
+function stopClaudeRoots(entry) {
+  const paths = new Set();
+  const add = (value) => {
+    if (typeof value === 'string' && value.trim()) paths.add(value.trim());
+  };
+  add(entry?.transcript_path);
+  for (const path of entry?.transcript_paths || []) add(path);
+  for (const activation of Object.values(entry?.activations || {})) {
+    add(activation?.transcript_path);
+    for (const path of activation?.transcript_paths || []) add(path);
+  }
+  return { state: 'complete', rootPaths: [...paths], descendantPaths: [], diagnostics: [] };
+}
+
+function materializeStopObservability(request) {
+  return materializeSessionObservability({
+    vaultBase: request.vaultBase,
+    sessionPath: request.sessionPath,
+    transcriptPath: request.transcriptPath,
+    entry: request.entry,
+    canonicalConversationId: request.canonicalConversationId,
+    frontier: request.frontier,
+    signals: request.signals,
+    cache: request.cache,
+    mode: 'live',
+    deadlineAt: request.deadlineAt,
+    now: request.now,
+    allowNone: request.allowNone,
+    readRuntimeFrontier: request.readRuntimeFrontier,
+    withPublicationGuard: request.withPublicationGuard,
+    writeRegistryCheckpoint: request.writeRegistryCheckpoint,
+  });
+}
+
+export async function refreshStopObservability({
+  vaultBase,
+  input,
+  sessionPath,
+  sessionId,
+  entry,
+  causalStop,
+  turnSequence,
+  hookStartedAt,
+  expectedSignalSequence,
+}, {
+  now = Date.now,
+  resolveEntry = resolveSessionEntry,
+  mutateRegistry = mutateSessionRegistry,
+  readStore = readObservabilityStore,
+  resolveRoots = resolveObservabilityRoots,
+  materialize = materializeStopObservability,
+} = {}) {
+  if (causalStop && !causalStop.canPromoteMemory) return false;
+  const deadlineAt = hookStartedAt + STOP_OBSERVABILITY_DEADLINE_MS;
+  if (now() >= deadlineAt) return false;
+
+  const expected = expectedStopCausalSnapshot(entry, causalStop, turnSequence);
+  const fresh = resolveEntry(vaultBase, input, entry?.provider);
+  if (fresh.identity?.state !== 'resolved'
+    || fresh.identity.canonicalConversationId !== sessionId
+    || !fresh.entry?.session_file
+    || fresh.entry.session_file !== entry?.session_file
+    || !sameStopCausalSnapshot(expected, stopEntryCausalSnapshot(fresh.entry))) return false;
+
+  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;
+
+  const roots = fresh.identity.provider === 'codex'
+    ? resolveRoots(fresh.entry)
+    : stopClaudeRoots(fresh.entry);
+  if (roots?.state !== 'complete' || !roots.rootPaths?.length) return false;
+
+  const frontier = {
+    canonical_session_id: sessionId,
+    activation_id: expected.activationId || 'legacy',
+    activation_epoch: expected.activationEpoch,
+    turn_sequence: expected.turnSequence,
+    signal_sequence: signalSequence,
+    roots_stat_hash: 'pending',
+    graph_cursor: 'pending',
+    source_manifest_hash: 'pending',
+  };
+  const readRuntimeFrontier = (candidateFrontier, guardContext) => {
+    const currentEntry = guardContext?.entry;
+    const current = currentEntry
+      ? { identity: { state: 'resolved', canonicalConversationId: sessionId }, entry: currentEntry }
+      : resolveEntry(vaultBase, input, entry?.provider);
+    if (current.identity?.state !== 'resolved'
+      || current.identity.canonicalConversationId !== sessionId
+      || !current.entry) {
+      return { ...candidateFrontier, canonical_session_id: 'unresolved' };
+    }
+    const currentCausal = stopEntryCausalSnapshot(current.entry);
+    const currentRuntime = readStore(vaultBase, sessionId);
+    return {
+      ...candidateFrontier,
+      activation_id: currentCausal.activationId || 'legacy',
+      activation_epoch: currentCausal.activationEpoch,
+      turn_sequence: currentCausal.turnSequence,
+      signal_sequence: Math.max(
+        Number(currentRuntime?.observability_signal_sequence || 0),
+        Number(current.entry.observability_signal_sequence || 0),
+      ),
+    };
+  };
+  const withPublicationGuard = (_candidateFrontier, publishGuarded) => (
+    mutateRegistry(vaultBase, (registry) => publishGuarded({
+      registry,
+      entry: registry.sessions?.[sessionId] || null,
+    }))
+  );
+  const writeRegistryCheckpoint = ({
+    frontier: checkpointFrontier,
+    state,
+    diagnostics,
+    snapshot,
+  }, guardContext) => {
+    const registry = guardContext?.registry;
+    const current = registry?.sessions?.[sessionId];
+    if (!current) return null;
+    const currentSignal = Number(current.observability_signal_sequence || checkpointFrontier.signal_sequence);
+    registry.sessions[sessionId] = {
+      ...current,
+      observability_signal_sequence: currentSignal,
+      observability_checkpoint_sequence: checkpointFrontier.signal_sequence,
+      observability_dirty: currentSignal > checkpointFrontier.signal_sequence,
+      observability_checkpoint_frontier: checkpointFrontier,
+      subagents_observability_state: state,
+      subagents_diagnostics: diagnostics || [],
+    };
+    return markObservabilityCheckpoint(vaultBase, sessionId, {
+      checkpointSequence: checkpointFrontier.signal_sequence,
+      frontier: checkpointFrontier,
+      sourceManifest: snapshot?.subagents?.sourceManifest,
+      graphCache: snapshot?.subagents?.cache,
+      diagnostics,
+    });
+  };
+
+  const result = await Promise.resolve(materialize({
+    vaultBase,
+    sessionPath,
+    entry: fresh.entry,
+    rootPaths: roots.rootPaths,
+    transcriptPath: roots.rootPaths[0],
+    caller: 'stop',
+    canonicalConversationId: sessionId,
+    activationId: expected.activationId,
+    activationEpoch: expected.activationEpoch,
+    turnSequence: expected.turnSequence,
+    signalSequence,
+    deadlineAt,
+    allowNone: true,
+    frontier,
+    signals: runtime?.signals || [],
+    cache: runtime?.graph_cache || null,
+    now,
+    readRuntimeFrontier,
+    withPublicationGuard,
+    writeRegistryCheckpoint,
+  }));
+  return !['stale', 'conflict', 'degraded', 'missing'].includes(result?.status);
+}
+
+export async function main({
+  stageMemory = stageStopMemoryAttempt,
+  clock = Date.now,
+  refreshObservability = refreshStopObservability,
+} = {}) {
+  const hookStartedAt = clock();
   const input = readHookInput();
   if (input.stop_hook_active) {
     writeHookOutput({});
@@ -961,8 +1280,17 @@ export function main({ stageMemory = stageStopMemoryAttempt } = {}) {
   }
 
   try {
-    updateSessionObservability({
-      vaultBase, sessionPath, transcriptPath, caller: 'stop', canonicalConversationId: sessionId,
+    await refreshObservability({
+      vaultBase,
+      input,
+      sessionPath,
+      sessionId,
+      entry,
+      causalStop,
+      turnSequence: stopTurnSequence,
+      hookStartedAt,
+    }, {
+      now: clock,
     });
   } catch (error) {
     process.stderr.write(`[wendkeep] Token usage falhou: ${error.message}\n`);
@@ -1062,7 +1390,7 @@ export function main({ stageMemory = stageStopMemoryAttempt } = {}) {
 
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   try {
-    main();
+    await main();
   } catch (error) {
     process.stderr.write(`[wendkeep] Stop falhou: ${error.message}\n`);
     // Same reasoning as the identity bail: stderr is discarded by Codex. Exit stays 0 —