wendkeep 0.64.0 → 0.66.0

package/packages/integrations/src/transcripts.mjs

@@ -0,0 +1,423 @@
+import { isBootstrapPrompt, redactSecrets } from './prompt-content.mjs';
+import {
+  addUsage,
+  emptyTokenUsage,
+  normalizeClaudeUsage,
+  normalizeCodexUsage,
+} from './transcript-usage.mjs';
+
+function extractContentText(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .map((item) => item?.text || item?.input_text || item?.output_text || '')
+    .filter(Boolean)
+    .join('\n')
+    .trim();
+}
+
+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();
+  return SYNTHETIC_EVENT_TAG.test(trimmed)
+    || isBootstrapPrompt(trimmed)
+    || /^Generate a concise( UI)? title/i.test(trimmed)
+    || /^You are a helpful assistant\. You will be presented with a user prompt/i.test(trimmed);
+}
+
+function addUnique(list, value) {
+  const clean = redactSecrets(String(value || '').trim());
+  if (clean && !list.includes(clean)) list.push(clean);
+}
+
+function createTurn(turnId = '', timestamp = '') {
+  return {
+    turnId,
+    timestamp,
+    userPrompts: [],
+    assistantMessages: [],
+    tools: [],
+    consultedFiles: [],
+    changedFiles: [],
+    conversation: [],
+    usage: emptyTokenUsage(),
+    model: '',
+  };
+}
+
+function createResult(provider) {
+  return {
+    provider,
+    sessionId: '',
+    model: '',
+    latestTurnId: '',
+    latestUserPrompt: '',
+    latestAssistantMessage: '',
+    userPrompts: [],
+    assistantMessages: [],
+    tools: [],
+    consultedFiles: [],
+    changedFiles: [],
+    turns: [],
+    rawTextForDetection: '',
+  };
+}
+
+function addConversation(turn, role, value) {
+  if (!turn) return;
+  const text = redactSecrets(String(value || '').trim());
+  if (!text) return;
+  if (!turn.conversation.some((item) => item.role === role && item.text === text)) {
+    turn.conversation.push({ role, text });
+  }
+}
+
+function normalizeRoot(value) {
+  return String(value || '').replace(/\\+/g, '/').replace(/\/+$/, '');
+}
+
+function pathContext(options = {}) {
+  const repoRoot = normalizeRoot(options.repoRoot);
+  const vaultRoot = normalizeRoot(options.vaultRoot).toLowerCase();
+  const repoLower = repoRoot.toLowerCase();
+  const vaultRel = vaultRoot && repoLower && vaultRoot.startsWith(`${repoLower}/`)
+    ? vaultRoot.slice(repoLower.length + 1)
+    : '';
+  return { repoRoot, repoLower, vaultRoot, vaultRel };
+}
+
+function normalizeExtractedPath(value, context) {
+  const cleaned = String(value || '')
+    .replace(/\\+/g, '/')
+    .replace(/\/+/g, '/')
+    .replace(/^(?:\.\/)+/, '')
+    .replace(/[:.,;)}\]]+$/, '');
+  if (context.repoRoot && cleaned.toLowerCase().startsWith(`${context.repoLower}/`)) {
+    return cleaned.slice(context.repoRoot.length + 1);
+  }
+  return cleaned;
+}
+
+function shouldIgnoreExtractedPath(path, context) {
+  if (!path) return true;
+  const lower = path.toLowerCase();
+  if (context.vaultRoot && lower.startsWith(`${context.vaultRoot}/`)) return true;
+  if (context.vaultRel && lower.startsWith(`${context.vaultRel}/`)) return true;
+  if (lower.includes('/.codex/sessions/')) return true;
+  if (lower.includes('/.claude/projects/')) return true;
+  if (path.startsWith('../') || path.includes('/../')) return true;
+  if (/(?:^|\/)(?:CURRENT_SESSION\.md|SESSION_REGISTRY\.json)$/i.test(path)) return true;
+  if (/^[A-Za-z]:\/[A-Za-z]:\//.test(path)) return true;
+  if (/^Alves\/\.codex\//i.test(path)) return true;
+  if (/\/\.[A-Za-z0-9]+(?::\d+)?$/.test(path)) return true;
+  return false;
+}
+
+function extractPaths(text, context) {
+  const paths = [];
+  const addPath = (value) => {
+    const path = normalizeExtractedPath(value, context);
+    if (!shouldIgnoreExtractedPath(path, context) && !paths.includes(path)) paths.push(path);
+  };
+  const windowsRegex = /[A-Za-z]:[\\/]+[^"'`\r\n{}()[\],]+\.[A-Za-z0-9]+(?::\d+)?/g;
+  const source = String(text || '');
+  let match;
+  while ((match = windowsRegex.exec(source)) !== null) addPath(match[0]);
+  const masked = source.replace(windowsRegex, ' ');
+  const regex = /(?:^|[\s"'`(])((?:\/(?:home|mnt)\/|\.{1,2}\/|[A-Za-z0-9_.-]+\/)[A-Za-z0-9_./@+:-]+\.[A-Za-z0-9]+(?::\d+)?)/g;
+  while ((match = regex.exec(masked)) !== null) addPath(match[1]);
+  return paths.slice(0, 20);
+}
+
+function extractPatchFiles(text) {
+  const files = [];
+  const regex = /^\*\*\* (?:Add|Update|Delete) File:\s+(.+)$/gm;
+  let match;
+  while ((match = regex.exec(text || '')) !== null) addUnique(files, match[1]);
+  return files;
+}
+
+function parseToolArguments(args) {
+  if (!args) return {};
+  if (typeof args === 'object') return args;
+  try { return JSON.parse(args); } catch { return { raw: String(args) }; }
+}
+
+function toolArgumentText(value) {
+  if (value == null) return '';
+  if (typeof value === 'string') return value;
+  if (Array.isArray(value)) return value.map(toolArgumentText).filter(Boolean).join('\n');
+  if (typeof value === 'object') return Object.values(value).map(toolArgumentText).filter(Boolean).join('\n');
+  return String(value);
+}
+
+function jsonLines(content) {
+  return String(content || '').split('\n').filter(Boolean).map((line) => {
+    try { return JSON.parse(line); } catch { return null; }
+  }).filter(Boolean);
+}
+
+export function parseCodexTranscriptContent(content, options = {}) {
+  const result = createResult('codex');
+  const eventUserPrompts = [];
+  const paths = pathContext(options);
+  let currentTurn = null;
+  const ensureTurn = (turnId = '', timestamp = '') => {
+    const normalized = turnId || currentTurn?.turnId || `turn-${result.turns.length + 1}`;
+    const existing = result.turns.find((turn) => turn.turnId === normalized);
+    if (existing) {
+      currentTurn = existing;
+      return existing;
+    }
+    currentTurn = createTurn(normalized, timestamp);
+    result.turns.push(currentTurn);
+    return currentTurn;
+  };
+
+  for (const event of jsonLines(content)) {
+    if (event.type === 'session_meta') {
+      result.sessionId = event.payload?.id || result.sessionId;
+      result.model = event.payload?.model || event.payload?.model_provider || result.model;
+      continue;
+    }
+    if (event.type === 'event_msg' && event.payload?.type === 'task_started') {
+      result.latestTurnId = event.payload.turn_id || result.latestTurnId;
+      ensureTurn(result.latestTurnId, event.timestamp);
+      continue;
+    }
+    if (event.type === 'turn_context') {
+      result.latestTurnId = event.payload?.turn_id || result.latestTurnId;
+      result.model = event.payload?.model || result.model;
+      ensureTurn(result.latestTurnId, event.timestamp);
+      continue;
+    }
+    if (event.type === 'event_msg' && event.payload?.type === 'user_message') {
+      const text = event.payload.message || '';
+      if (text && !shouldIgnoreUserText(text)) {
+        const turn = ensureTurn(event.payload.turn_id || result.latestTurnId, event.timestamp);
+        addUnique(eventUserPrompts, text);
+        addUnique(result.userPrompts, text);
+        addUnique(turn.userPrompts, text);
+        addConversation(turn, 'Usuário', text);
+      }
+      continue;
+    }
+    if (event.type === 'event_msg' && event.payload?.type === 'agent_message') {
+      const text = event.payload.message || event.payload.text || '';
+      if (text) {
+        const turn = ensureTurn(event.payload.turn_id || result.latestTurnId, event.timestamp);
+        addUnique(result.assistantMessages, text);
+        addUnique(turn.assistantMessages, text);
+        addConversation(turn, 'Assistente', text);
+      }
+      continue;
+    }
+    if (event.type === 'event_msg' && event.payload?.type === 'token_count') {
+      const raw = event.payload?.info?.last_token_usage;
+      if (raw) {
+        const turn = currentTurn || ensureTurn(result.latestTurnId, event.timestamp);
+        addUsage(turn.usage, normalizeCodexUsage(raw));
+        if (event.payload?.info?.model) turn.model = event.payload.info.model;
+      }
+      continue;
+    }
+    if (event.type !== 'response_item') continue;
+    const payload = event.payload || {};
+    if (payload.type === 'message') {
+      const text = extractContentText(payload.content);
+      if (!text) continue;
+      const turn = ensureTurn(payload.turn_id || event.turn_id || result.latestTurnId, event.timestamp);
+      if (payload.role === 'user' && !shouldIgnoreUserText(text)) {
+        addUnique(result.userPrompts, text);
+        addUnique(turn.userPrompts, text);
+        addConversation(turn, 'Usuário', text);
+      }
+      if (payload.role === 'assistant') {
+        addUnique(result.assistantMessages, text);
+        addUnique(turn.assistantMessages, text);
+        addConversation(turn, 'Assistente', text);
+      }
+      continue;
+    }
+    if (payload.type === 'function_call') {
+      const name = payload.name || 'function_call';
+      const turn = ensureTurn(payload.turn_id || event.turn_id || result.latestTurnId, event.timestamp);
+      addUnique(result.tools, name);
+      addUnique(turn.tools, name);
+      const parsed = parseToolArguments(payload.arguments);
+      const combined = typeof parsed.raw === 'string' ? parsed.raw : toolArgumentText(parsed);
+      for (const path of extractPaths(combined, paths)) {
+        addUnique(result.consultedFiles, path);
+        addUnique(turn.consultedFiles, path);
+      }
+      for (const path of extractPatchFiles(combined)) {
+        addUnique(result.changedFiles, path);
+        addUnique(turn.changedFiles, path);
+      }
+      if (/apply_patch|edit|write|create/i.test(name)) {
+        for (const path of extractPaths(combined, paths)) {
+          addUnique(result.changedFiles, path);
+          addUnique(turn.changedFiles, path);
+        }
+      }
+    }
+    if (payload.type === 'tool_search_call') {
+      const turn = ensureTurn(payload.turn_id || event.turn_id || result.latestTurnId, event.timestamp);
+      addUnique(result.tools, 'tool_search');
+      addUnique(turn.tools, 'tool_search');
+    }
+    if (payload.type === 'web_search_call') {
+      const turn = ensureTurn(payload.turn_id || event.turn_id || result.latestTurnId, event.timestamp);
+      addUnique(result.tools, 'web_search');
+      addUnique(turn.tools, 'web_search');
+    }
+  }
+
+  for (const prompt of eventUserPrompts) addUnique(result.userPrompts, prompt);
+  const latestTurn = result.turns.find((turn) => turn.turnId === result.latestTurnId)
+    || result.turns.at(-1);
+  result.latestUserPrompt = latestTurn?.userPrompts.at(-1)
+    || eventUserPrompts.at(-1)
+    || result.userPrompts.at(-1)
+    || '';
+  result.latestAssistantMessage = latestTurn?.assistantMessages.at(-1)
+    || result.assistantMessages.at(-1)
+    || '';
+  result.rawTextForDetection = redactSecrets([
+    ...result.userPrompts,
+    ...result.assistantMessages,
+  ].join('\n\n'));
+  return result;
+}
+
+function claudeUserText(content) {
+  if (typeof content === 'string') return content.trim();
+  if (!Array.isArray(content)) return '';
+  return content
+    .map((block) => (typeof block === 'string' ? block : (block?.type === 'text' ? block.text || '' : '')))
+    .map((text) => String(text || '').trim())
+    .filter((text) => text && !text.startsWith('<'))
+    .join('\n')
+    .trim();
+}
+
+export function parseClaudeTranscriptContent(content, options = {}) {
+  const result = createResult('claude');
+  const paths = pathContext(options);
+  let currentTurn = null;
+  const ensureTurn = (turnId = '', timestamp = '') => {
+    const normalized = turnId || currentTurn?.turnId || `turn-${result.turns.length + 1}`;
+    const existing = result.turns.find((turn) => turn.turnId === normalized);
+    if (existing) {
+      currentTurn = existing;
+      return existing;
+    }
+    currentTurn = createTurn(normalized, timestamp);
+    result.turns.push(currentTurn);
+    return currentTurn;
+  };
+  const recordToolFiles = (turn, name, input) => {
+    const text = toolArgumentText(input);
+    for (const path of extractPaths(text, paths)) {
+      addUnique(result.consultedFiles, path);
+      addUnique(turn.consultedFiles, path);
+    }
+    for (const path of extractPatchFiles(text)) {
+      addUnique(result.changedFiles, path);
+      addUnique(turn.changedFiles, path);
+    }
+    if (/edit|write|create|apply_patch|notebook/i.test(name)) {
+      for (const path of extractPaths(text, paths)) {
+        addUnique(result.changedFiles, path);
+        addUnique(turn.changedFiles, path);
+      }
+    }
+  };
+
+  for (const event of jsonLines(content)) {
+    if (event.isSidechain || event.isMeta) continue;
+    if (event.sessionId && !result.sessionId) result.sessionId = event.sessionId;
+    if (event.type === 'user') {
+      const text = claudeUserText(event.message?.content);
+      if (!text || shouldIgnoreUserText(text)) continue;
+      const turn = ensureTurn(event.uuid || event.promptId || event.timestamp || '', event.timestamp || '');
+      result.latestTurnId = turn.turnId;
+      addUnique(result.userPrompts, text);
+      addUnique(turn.userPrompts, text);
+      addConversation(turn, 'Usuário', text);
+      continue;
+    }
+    if (event.type === 'assistant') {
+      const turn = currentTurn || ensureTurn(event.uuid || event.timestamp || '', event.timestamp || '');
+      result.model = event.message?.model || result.model;
+      if (event.message?.model) turn.model = event.message.model;
+      if (event.message?.usage) addUsage(turn.usage, normalizeClaudeUsage(event.message.usage));
+      const blocks = Array.isArray(event.message?.content) ? event.message.content : [];
+      for (const block of blocks) {
+        if (block?.type === 'text' && block.text && block.text.trim()) {
+          addUnique(result.assistantMessages, block.text);
+          addUnique(turn.assistantMessages, block.text);
+          addConversation(turn, 'Assistente', block.text);
+        } else if (block?.type === 'tool_use') {
+          const name = block.name || 'tool_use';
+          addUnique(result.tools, name);
+          addUnique(turn.tools, name);
+          recordToolFiles(turn, name, block.input);
+        }
+      }
+    }
+  }
+
+  const latestTurn = result.turns.find((turn) => turn.turnId === result.latestTurnId)
+    || result.turns.at(-1);
+  result.latestUserPrompt = latestTurn?.userPrompts.at(-1) || result.userPrompts.at(-1) || '';
+  result.latestAssistantMessage = latestTurn?.assistantMessages.at(-1)
+    || result.assistantMessages.at(-1)
+    || '';
+  result.rawTextForDetection = redactSecrets([
+    ...result.userPrompts,
+    ...result.assistantMessages,
+  ].join('\n\n'));
+  return result;
+}
+
+function looksLikeCodexEvent(event) {
+  return event.payload !== undefined
+    || event.type === 'session_meta'
+    || event.type === 'response_item'
+    || event.type === 'turn_context'
+    || event.type === 'event_msg';
+}
+
+function looksLikeClaudeEvent(event) {
+  return (event.type === 'user' || event.type === 'assistant') && event.message !== undefined;
+}
+
+export function parseTranscriptContent(content, options = {}) {
+  for (const event of jsonLines(content)) {
+    if (looksLikeCodexEvent(event)) return parseCodexTranscriptContent(content, options);
+    if (looksLikeClaudeEvent(event)) return parseClaudeTranscriptContent(content, options);
+  }
+  return parseCodexTranscriptContent(content, options);
+}
+
+export function resolveTurnIdentity(transcript, requestedTurnId = '') {
+  const turns = Array.isArray(transcript?.turns) ? transcript.turns : [];
+  const requested = String(requestedTurnId || '');
+  let index = requested
+    ? turns.findIndex((turn) => String(turn?.turnId || '') === requested)
+    : -1;
+  if (requested && index < 0) return null;
+  if (index < 0 && transcript?.latestTurnId) {
+    index = turns.findIndex((turn) => String(turn?.turnId || '') === String(transcript.latestTurnId));
+  }
+  if (index < 0) index = turns.length - 1;
+  const turn = turns[index];
+  if (!turn?.turnId) return null;
+  return {
+    id: String(turn.turnId),
+    order: index + 1,
+    observedAt: String(turn.timestamp || ''),
+  };
+}

package/packages/mcp/package.json

@@ -1,5 +1,6 @@
 {
   "name": "@wendkeep/mcp",
   "private": true,
-  "type": "module"
+  "type": "module",
+  "exports": "./src/index.mjs"
 }

package/packages/mcp/src/config.mjs

@@ -0,0 +1,33 @@
+export const MCP_SERVER_KEY = 'wendkeep-vault';
+
+export function mcpServerEntry(vaultPath) {
+  return {
+    type: 'stdio',
+    command: 'npx',
+    args: ['-y', '@bitbonsai/mcpvault@latest', vaultPath],
+  };
+}
+
+export function selectMcpServers(descriptors, skipIds = []) {
+  const skipSet = new Set(skipIds);
+  const servers = {};
+  for (const descriptor of descriptors || []) {
+    if (!descriptor || skipSet.has(descriptor.id)) continue;
+    if (typeof descriptor.key !== 'string' || !descriptor.key) continue;
+    if (!descriptor.entry || typeof descriptor.entry !== 'object') continue;
+    servers[descriptor.key] = descriptor.entry;
+  }
+  return servers;
+}
+
+export function mergeMcpConfig(existing, {
+  vaultPath,
+  withVault = true,
+  servers = {},
+} = {}) {
+  const config = existing && typeof existing === 'object' ? { ...existing } : {};
+  config.mcpServers = { ...(config.mcpServers || {}) };
+  if (withVault) config.mcpServers[MCP_SERVER_KEY] = mcpServerEntry(vaultPath);
+  Object.assign(config.mcpServers, servers);
+  return config;
+}

package/packages/mcp/src/index.mjs

@@ -0,0 +1 @@
+export * from './config.mjs';

package/src/init.mjs

@@ -6,13 +6,12 @@ import { spawnSync } from 'node:child_process';
 import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { basename, isAbsolute, join, resolve } from 'node:path';
 import { createInterface } from 'node:readline/promises';
+import { MCP_SERVER_KEY, mergeMcpConfig } from '../packages/mcp/src/index.mjs';
 import {
   VAULT_FOLDERS,
   SESSION_HOOKS,
   CHANGE_NUDGE_HOOKS,
   CHANGE_GATE_HOOKS,
-  MCP_SERVER_KEY,
-  mcpServerEntry,
   hookCommand,
   hookCommandLocal,
   hookCommandLocalLegacy,
@@ -245,11 +244,11 @@ export function mergeCodexHooks(existing, { force = false } = {}) {
 }
 
 export function mergeMcp(existing, { vaultPath, withVault = true, companions = [], skipMcp = [] }) {
-  const m = existing && typeof existing === 'object' ? { ...existing } : {};
-  m.mcpServers = { ...(m.mcpServers || {}) };
-  if (withVault) m.mcpServers[MCP_SERVER_KEY] = mcpServerEntry(vaultPath);
-  Object.assign(m.mcpServers, companionMcpPatch(companions, skipMcp));
-  return m;
+  return mergeMcpConfig(existing, {
+    vaultPath,
+    withVault,
+    servers: companionMcpPatch(companions, skipMcp),
+  });
 }
 
 // Run caveman's cross-agent installer (non-Claude skill coverage). Downloads the

package/src/taxonomy.mjs

@@ -1,3 +1,34 @@
+import {
+  MCP_SERVER_KEY,
+  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 {
+  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.
 
@@ -93,94 +124,6 @@ export const RUNNABLE_HOOKS = [
   'plan-capture',
 ];
 
-// The MCP server entry wendkeep wires into .mcp.json so the agent can read/write the
-// vault. Uses the published mcpvault server (no secrets).
-export function mcpServerEntry(vaultPath) {
-  return {
-    type: 'stdio',
-    command: 'npx',
-    args: ['-y', '@bitbonsai/mcpvault@latest', vaultPath],
-  };
-}
-export const MCP_SERVER_KEY = 'wendkeep-vault';
-
-// 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
@@ -281,14 +224,11 @@ export function companionSettingsPatch(ids) {
 // `skip` omits ids whose MCP is already configured elsewhere (e.g. dotcontext set
 // globally in ~/.claude.json — avoids a duplicate project-scoped server).
 export function companionMcpPatch(ids, skip = []) {
-  const skipSet = new Set(skip);
-  const servers = {};
-  for (const id of ids) {
-    if (skipSet.has(id)) continue;
-    const c = COMPANION_BY_ID[id];
-    if (c?.mcp) servers[c.mcp.key] = c.mcp.entry;
-  }
-  return servers;
+  const descriptors = ids.map((id) => {
+    const mcp = COMPANION_BY_ID[id]?.mcp;
+    return mcp ? { id, key: mcp.key, entry: mcp.entry } : { id };
+  });
+  return selectMcpServers(descriptors, skip);
 }
 
 // SessionStart hook specs wendkeep must author for companions that lack a native