wendkeep 0.65.0 → 0.66.1

package/src/memory.mjs

@@ -237,37 +237,191 @@ function readCandidates(vault) {
     .split('\n').filter(Boolean).map((line) => JSON.parse(line));
 }
 
-export function decideMemoryCandidate(vault, { action, candidateId, value } = {}) {
+function priorCandidateDecision(vault, candidateId) {
+  return readMemoryLedger(vault).events.find(
+    (event) => event.candidate_decision?.candidate_id === candidateId,
+  ) || null;
+}
+
+function candidateEvent(candidate, eventId) {
+  const events = Array.isArray(candidate.events) ? candidate.events : [];
+  if (candidate.reason === 'conflict' && !eventId) {
+    throw new Error('Candidate de conflito exige eventId (--event na CLI).');
+  }
+  if (!eventId) return events.length === 1 ? events[0] : null;
+  const selected = events.find((event) => event.event_id === eventId);
+  if (!selected) throw new Error(`event_id ${eventId} não pertence ao candidate ${candidate.candidate_id}.`);
+  return selected;
+}
+
+function assertCompatibleDecision(prior, { action, eventId }) {
+  const decision = prior.candidate_decision;
+  const sameSelection = action !== 'promote'
+    || (decision.selected_event_id || null) === (eventId || null);
+  if (decision.action !== action || !sameSelection) {
+    throw new Error(`Candidate ${decision.candidate_id} já possui decisão incompatível (${decision.action}).`);
+  }
+}
+
+function matchesPromotedAttempt(attempt, selected) {
+  if (attempt?.memory_mode !== 'v2' || attempt.state !== 'projected'
+      || !Array.isArray(attempt.event_ids) || !attempt.event_ids.includes(selected.event_id)) return false;
+  if (attempt.activation_id && selected.activation_id
+      && attempt.activation_id !== selected.activation_id) return false;
+  if (Number.isInteger(attempt.activation_epoch) && Number.isInteger(selected.activation_epoch)
+      && attempt.activation_epoch !== selected.activation_epoch) return false;
+  if (Number.isInteger(attempt.turn_sequence) && Number.isInteger(selected.turn_sequence)
+      && attempt.turn_sequence !== selected.turn_sequence) return false;
+  if (attempt.canonical_session_id && selected.canonical_session_id
+      && attempt.canonical_session_id !== selected.canonical_session_id) return false;
+  return true;
+}
+
+function snapshotPromotedAttemptCheckpoints(vault, selected) {
+  if (!selected) return new Map();
+  const registry = readSessionRegistry(vault);
+  return new Map(Object.entries(registry.sessions || {})
+    .filter(([, entry]) => matchesPromotedAttempt(entry?.last_memory_attempt, selected))
+    .map(([sessionId, entry]) => [sessionId, {
+      attempt: attemptFingerprint(entry.last_memory_attempt),
+      checkpoint: memoryCheckpointFingerprint(entry),
+    }]));
+}
+
+function refreshPromotedAttemptCheckpoint(vault, {
+  candidateId, decisionEventId, selected, checkpoint, decidedAt, expectedAttempts,
+}) {
+  if (!selected || !checkpoint || !expectedAttempts?.size) return 0;
+  return mutateSessionRegistry(vault, (registry) => {
+    let refreshed = 0;
+    for (const [sessionId, entry] of Object.entries(registry.sessions || {})) {
+      const expected = expectedAttempts.get(sessionId);
+      if (!expected) continue;
+      const attempt = entry?.last_memory_attempt;
+      if (attemptFingerprint(attempt) !== expected.attempt
+          || memoryCheckpointFingerprint(entry) !== expected.checkpoint) continue;
+
+      const alreadyAudited = (entry.memory_candidate_decisions || [])
+        .some((audit) => audit.decision_event_id === decisionEventId);
+      if (alreadyAudited && sameCheckpoint(attempt.checkpoint, checkpoint)
+          && sameCheckpoint(entry.memory_checkpoint, checkpoint)) continue;
+      const originalCheckpoint = cloneJson(attempt.checkpoint || entry.memory_checkpoint || null);
+      attempt.checkpoint = cloneJson(checkpoint);
+      entry.memory_checkpoint = cloneJson(checkpoint);
+      entry.memory_status = 'projected';
+      if (!alreadyAudited) {
+        entry.memory_candidate_decisions = [
+          ...(Array.isArray(entry.memory_candidate_decisions) ? entry.memory_candidate_decisions : []),
+          {
+            v: 1,
+            type: 'candidate_checkpoint_refreshed',
+            candidate_id: candidateId,
+            decision_event_id: decisionEventId,
+            selected_event_id: selected.event_id,
+            decided_at: decidedAt,
+            original_checkpoint: originalCheckpoint,
+            checkpoint: cloneJson(checkpoint),
+          },
+        ];
+      }
+      refreshed += 1;
+    }
+    return refreshed;
+  });
+}
+
+export function decideMemoryCandidate(vault, {
+  action, candidateId, value, eventId, beforeCheckpointRefresh,
+} = {}) {
   if (!['promote', 'reject'].includes(action)) throw new TypeError('action deve ser promote ou reject.');
   if (!candidateId) throw new TypeError('candidateId é obrigatório.');
+  const preflight = projectMemoryOutbox(vault);
+  if (preflight.status === 'busy') return { status: 'busy', candidateId };
+  const prior = priorCandidateDecision(vault, candidateId);
+  if (prior) {
+    assertCompatibleDecision(prior, { action, eventId });
+    const selected = action === 'promote' && prior.candidate_decision.selected_event_id
+      ? readMemoryLedger(vault).events.find(
+        (event) => event.event_id === prior.candidate_decision.selected_event_id,
+      )
+      : null;
+    const expectedAttempts = snapshotPromotedAttemptCheckpoints(vault, selected);
+    beforeCheckpointRefresh?.();
+    const checkpointRefreshed = action === 'promote'
+      ? refreshPromotedAttemptCheckpoint(vault, {
+        candidateId,
+        decisionEventId: prior.event_id,
+        selected,
+        checkpoint: preflight.checkpoint,
+        decidedAt: prior.observed_at,
+        expectedAttempts,
+      })
+      : 0;
+    return {
+      status: action === 'promote' ? 'promoted' : 'rejected',
+      candidateId,
+      eventId: prior.event_id,
+      alreadyApplied: true,
+      checkpointRefreshed,
+      projection: preflight,
+    };
+  }
   const candidates = readCandidates(vault);
   const candidate = candidates.find((item) => item.candidate_id === candidateId);
   if (!candidate) throw new Error(`Candidate não encontrado: ${candidateId}`);
+  if (action === 'promote' && candidate.reason === 'blocked_by_core') {
+    throw new Error(`Candidate ${candidateId} está blocked_by_core; edite CORE ou rejeite o candidate.`);
+  }
+  const selected = action === 'promote' ? candidateEvent(candidate, eventId) : null;
+  const expectedAttempts = snapshotPromotedAttemptCheckpoints(vault, selected);
+  const selectedValue = selected?.value ?? value ?? candidate.value ?? candidate.proposed_value;
+  if (action === 'promote' && selectedValue === undefined) {
+    throw new Error(`Candidate ${candidateId} não contém valor promovível.`);
+  }
   const now = new Date().toISOString();
+  const decision = {
+    candidate_id: candidateId,
+    action,
+    event_ids: Array.isArray(candidate.event_ids) ? [...candidate.event_ids].sort() : [],
+    ...(selected ? { selected_event_id: selected.event_id } : {}),
+  };
   const event = {
     v: 1,
-    event_id: `cli-${action}-${hash(candidateId).slice(0, 20)}`,
+    event_id: `cli-${action}-${hash(`${candidateId}\0${selected?.event_id || ''}`).slice(0, 20)}`,
     project_id: projectId(vault),
-    memory_key: action === 'promote' ? candidate.memory_key : `candidate.rejected.${candidateId}`,
-    operation: 'assert',
-    value: sanitizeMemoryText(action === 'promote' ? (value ?? candidate.value ?? candidate.values?.[0] ?? '') : 'rejected'),
+    memory_key: action === 'promote' ? candidate.memory_key : `candidate.decision.${candidateId}`,
+    operation: action === 'promote' && selected ? 'replace' : 'assert',
+    value: sanitizeMemoryText(action === 'promote' ? selectedValue : 'rejected'),
     authority: 'verified',
-    activation_id: 'wendkeep-memory-cli',
-    turn_sequence: 0,
+    activation_id: selected?.activation_id || 'wendkeep-memory-cli',
+    ...(Number.isInteger(selected?.activation_epoch) ? { activation_epoch: selected.activation_epoch } : {}),
+    turn_sequence: selected?.turn_sequence ?? 0,
     observed_at: now,
     evidence: [`candidate:${candidateId}`],
+    candidate_decision: decision,
+    ...(selected ? { supersedes: decision.event_ids } : {}),
   };
   enqueueMemoryEvent(vault, event);
   const projection = projectMemoryOutbox(vault);
   if (projection.status === 'busy') return { status: 'busy', candidateId };
-  const remaining = candidates.filter((item) => item.candidate_id !== candidateId);
-  const projected = readCandidates(vault);
-  const merged = new Map([...remaining, ...projected].map((item) => [item.candidate_id, item]));
-  writeVaultFileAtomic(
-    vault, brainPath(vault, CANDIDATES), candidateText([...merged.values()]), 'utf8',
-    { label: 'candidates após decisão humana' },
-  );
-  return { status: action === 'promote' ? 'promoted' : 'rejected', candidateId, eventId: event.event_id, projection };
+  beforeCheckpointRefresh?.();
+  const checkpointRefreshed = action === 'promote'
+    ? refreshPromotedAttemptCheckpoint(vault, {
+      candidateId,
+      decisionEventId: event.event_id,
+      selected,
+      checkpoint: projection.checkpoint,
+      decidedAt: now,
+      expectedAttempts,
+    })
+    : 0;
+  return {
+    status: action === 'promote' ? 'promoted' : 'rejected',
+    candidateId,
+    eventId: event.event_id,
+    checkpointRefreshed,
+    projection,
+  };
 }
 
 function cloneJson(value) {
@@ -1038,8 +1192,14 @@ export function runMemory(argv) {
         apply: reconcileArgs.apply,
       });
     }
-    else if (sub === 'promote' || sub === 'reject') result = decideMemoryCandidate(vault, { action: sub, candidateId: positional });
-    else { process.stderr.write('wendkeep memory: use status | migrate [--apply] | repair | reconcile <session> --by-session <session> --reason <text> [--apply] | promote <candidate> | reject <candidate>.\n'); process.exitCode = 2; return; }
+    else if (sub === 'promote' || sub === 'reject') {
+      const eventId = option(argv, '--event');
+      if (sub === 'reject' && eventId) throw memoryUsageError('--event é permitido somente em memory promote.');
+      result = decideMemoryCandidate(vault, {
+        action: sub, candidateId: positional, ...(eventId ? { eventId } : {}),
+      });
+    }
+    else { process.stderr.write('wendkeep memory: use status | migrate [--apply] | repair | reconcile <session> --by-session <session> --reason <text> [--apply] | promote <candidate> [--event <event-id>] | reject <candidate>.\n'); process.exitCode = 2; return; }
     process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
     if (sub === 'status' && argv.includes('--gate')) process.exitCode = result.status === 'blocked' ? 1 : 0;
     else if (sub === 'reconcile' && reconcileArgs.apply) process.exitCode = result.health?.status === 'blocked' ? 1 : 0;

package/src/taxonomy.mjs

@@ -3,8 +3,31 @@ import {
   mcpServerEntry,
   selectMcpServers,
 } from '../packages/mcp/src/index.mjs';
+import {
+  CHANGE_GATE_HOOKS,
+  CHANGE_NUDGE_HOOKS,
+  CODEX_MATCHER_EVENTS,
+  SESSION_HOOKS,
+  codexHookEntry,
+  codexHookSpecs,
+  hookCommand,
+  hookCommandLocal,
+  hookCommandLocalLegacy,
+} from '../packages/integrations/src/host-hooks.mjs';
 
-export { MCP_SERVER_KEY, mcpServerEntry };
+export {
+  CHANGE_GATE_HOOKS,
+  CHANGE_NUDGE_HOOKS,
+  CODEX_MATCHER_EVENTS,
+  MCP_SERVER_KEY,
+  SESSION_HOOKS,
+  codexHookEntry,
+  codexHookSpecs,
+  hookCommand,
+  hookCommandLocal,
+  hookCommandLocalLegacy,
+  mcpServerEntry,
+};
 
 // Shared, data-only constants for the wendkeep installer and CLI.
 // Kept free of side effects so both bin/ and src/ can import it cheaply.
@@ -101,83 +124,6 @@ export const RUNNABLE_HOOKS = [
   'plan-capture',
 ];
 
-// The three Claude Code session hooks, expressed as `wendkeep hook <name>` so the
-// installed package is the single source of truth (update with `npm update wendkeep`,
-// no re-copying). Returned as a spec the merge logic folds into settings.json.
-export const SESSION_HOOKS = [
-  // Memory + active-change injection. Runs FIRST on SessionStart (order -10, folds before
-  // session-start) so the agent gets CORE + DIGEST + the active change + lessons as context.
-  // matcher 'startup|clear|compact' re-injects after a compaction/clear, not only cold startup.
-  // timeout 45 (was 15): measured ~4s warm via npx, but Windows startup contention (several npx
-  // cold-starts at once — a sibling MCP took 26s in a real log) blew 15s and silently dropped the
-  // memory injection for the whole session.
-  { event: 'SessionStart', matcher: 'startup|clear|compact', name: 'brain-inject', timeout: 45, order: -10, codex: true, statusMessage: 'wendkeep: injecting memory + active change' },
-  { event: 'SessionStart', matcher: 'startup', name: 'session-start', timeout: 30, codex: true, statusMessage: 'wendkeep: opening Obsidian session' },
-  { event: 'Stop', matcher: null, name: 'session-stop', timeout: 60, codex: true, statusMessage: 'wendkeep: writing session checkpoint' },
-  { event: 'UserPromptSubmit', matcher: null, name: 'session-ensure', timeout: 30, codex: true, statusMessage: 'wendkeep: ensuring active session' },
-  // Capture an interactive decision (AskUserQuestion) — options + the user's choice — into 04-Decisões.
-  // codex: AskUserQuestion is a Claude-only tool; there is nothing to match on.
-  { event: 'PostToolUse', matcher: 'AskUserQuestion', name: 'decision-capture', timeout: 15, statusMessage: 'wendkeep: recording decision' },
-  // Refresh subagent/workflow telemetry as each subagent finishes (resilient to a missed Stop).
-  { event: 'SubagentStop', matcher: null, name: 'subagent-stop', timeout: 20, codex: true, statusMessage: 'wendkeep: subagent telemetry' },
-  // Log plan/task progress into the active session note when a task is marked complete.
-  // codex: TaskCompleted is not in Codex's hook event enum.
-  { event: 'TaskCompleted', matcher: null, name: 'task-log', timeout: 10, statusMessage: 'wendkeep: plan progress' },
-];
-
-export function hookCommand(name) {
-  return `npx wendkeep hook ${name}`;
-}
-
-// Forma node-direta do comando de hook: 1 processo (~100-250ms) em vez dos 3 do npx (cold-start
-// de segundos no Windows). Usada pelos hooks de ALTA FREQUÊNCIA (por prompt / por tool-call)
-// quando o projeto tem wendkeep instalado localmente; o init decide (hookCommandFor).
-export function hookCommandLocal(name) {
-  return `node "${'${CLAUDE_PROJECT_DIR}'}/node_modules/wendkeep/hooks/${name}.mjs"`;
-}
-
-export function hookCommandLocalLegacy(name) {
-  return `node node_modules/wendkeep/hooks/${name}.mjs`;
-}
-
-// 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
-// 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 = [
-  { event: 'UserPromptSubmit', matcher: null, name: 'change-context', timeout: 15, order: 10, preferLocal: true, codex: true, statusMessage: 'wendkeep: change ping' },
-  // codex: reads tool_input.file_path, which Codex's apply_patch envelope does not carry.
-  { event: 'PostToolUse', matcher: 'Edit|Write|MultiEdit', name: 'change-warn', timeout: 10, order: 10, preferLocal: true, statusMessage: 'wendkeep: change warn' },
-  // codex: no ExitPlanMode equivalent — update_plan is the running TODO list, not an approval.
-  { event: 'PostToolUse', matcher: 'ExitPlanMode', name: 'plan-capture', timeout: 15, order: 10, preferLocal: true, statusMessage: 'wendkeep: capturing approved plan' },
-  { event: 'Stop', matcher: null, name: 'change-nag', timeout: 15, order: 10, preferLocal: true, codex: true, statusMessage: 'wendkeep: open tasks check' },
-];
-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' },
-];
-
-// --- Codex projection ---------------------------------------------------------
-// Codex reads <project>/.codex/hooks.json (PascalCase event keys, same group shape as
-// Claude's settings.json). Only specs that opt in with `codex: true` are projected — the
-// 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']);
-
-export function codexHookSpecs(specs) {
-  return specs.filter((h) => h.codex === true && !h.command);
-}
-
-export function codexHookEntry(spec) {
-  const entry = { type: 'command', command: hookCommand(spec.name), timeoutSec: spec.timeout };
-  if (spec.statusMessage) entry.statusMessage = spec.statusMessage;
-  return entry;
-}
-
 // --- companion plugins / MCP --------------------------------------------------
 // Optional tools wendkeep init can pin alongside the vault. Each is wired through
 // the MOST agent-agnostic mechanism it supports; the Claude Code plugin entry