wendkeep 0.58.1 → 0.59.0

package/hooks/change-guard.mjs

@@ -5,21 +5,105 @@
 //        no ambiente do processo — env inline no texto do comando NÃO conta).
 //   R2 — `git commit` com change ativa E (--no-verify OU sensor crítico vermelho) vira `ask`
 //        (o usuário decide com 1 clique; falso-positivo custa pouco).
-// Fast-path: comando sem wendkeep/wk/git sai sem NENHUM I/O. Fail-open.
+// Fast-path: comando sem wendkeep/wk/git sai sem NENHUM I/O. Ausência normal continua
+// fail-open; corrupção do binding é diagnóstico visível e fail-closed.
 import { pathToFileURL } from 'node:url';
-import { getVaultBase, readHookInput, writeHookOutput } from './obsidian-common.mjs';
+import { readHookInput, writeHookOutput } from './obsidian-common.mjs';
 import { activeChange, quickGateState } from './change-core.mjs';
+import { hookProfilePolicy, resolveHookOperatingProfile } from './operating-profile-runtime.mjs';
+import { isProjectVaultIntegrityError } from '../src/project-vault.mjs';
 
-const FORCE_RE = /\b(?:wendkeep|wk)\s+change\s+archive\b[^|&;\n]*--force\b/;
-const GIT_SEG_RE = /(^|&&|;|\|)\s*git\b[^|&;]*\bcommit\b/;
-const FAST_RE = /\b(?:wendkeep|wk|git)\b/;
+const WK_EXECUTABLES = new Set([
+  'wendkeep', 'wendkeep.cmd', 'wendkeep.exe', 'wendkeep.ps1', 'wendkeep.mjs',
+  'wk', 'wk.cmd', 'wk.exe', 'wk.ps1',
+]);
+const NODE_EXECUTABLES = new Set(['node', 'node.exe']);
+const NPX_EXECUTABLES = new Set(['npx', 'npx.cmd', 'npx.exe']);
+const GIT_EXECUTABLES = new Set(['git', 'git.exe', 'git.cmd']);
 
-export function guardDecision(command, { vaultBase, env = process.env } = {}) {
+function shellSegments(command) {
+  const tokens = String(command || '').match(/"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|&&|\|\||[;|\n]|&|[^\s;&|]+/g) || [];
+  const segments = [];
+  let current = [];
+  const flush = () => {
+    if (current.length) segments.push(current);
+    current = [];
+  };
+  for (const token of tokens) {
+    if (['&&', '||', ';', '|', '\n'].includes(token) || (token === '&' && current.length)) {
+      flush();
+      continue;
+    }
+    current.push(token);
+  }
+  flush();
+  return segments;
+}
+
+function unquote(token) {
+  const value = String(token || '');
+  if (value.length >= 2 && ((value[0] === '"' && value.at(-1) === '"')
+    || (value[0] === "'" && value.at(-1) === "'"))) return value.slice(1, -1);
+  return value;
+}
+
+function executableName(token) {
+  return unquote(token).replaceAll('\\', '/').split('/').at(-1).toLowerCase();
+}
+
+function invocationOf(segment) {
+  let index = 0;
+  while (segment[index] === '&' || /^[A-Za-z_][A-Za-z0-9_]*=/.test(segment[index] || '')) index += 1;
+  const executable = executableName(segment[index]);
+  if (WK_EXECUTABLES.has(executable)) {
+    return { kind: 'wendkeep', args: segment.slice(index + 1).map(unquote) };
+  }
+  if (NODE_EXECUTABLES.has(executable)) {
+    let scriptIndex = index + 1;
+    while (String(segment[scriptIndex] || '').startsWith('-')) scriptIndex += 1;
+    if (executableName(segment[scriptIndex]) === 'wendkeep.mjs') {
+      return { kind: 'wendkeep', args: segment.slice(scriptIndex + 1).map(unquote) };
+    }
+  }
+  if (NPX_EXECUTABLES.has(executable)) {
+    let packageIndex = index + 1;
+    while (String(segment[packageIndex] || '').startsWith('-')) packageIndex += 1;
+    if (WK_EXECUTABLES.has(executableName(segment[packageIndex]))) {
+      return { kind: 'wendkeep', args: segment.slice(packageIndex + 1).map(unquote) };
+    }
+  }
+  if (GIT_EXECUTABLES.has(executable)) {
+    return { kind: 'git', args: segment.slice(index + 1).map(unquote) };
+  }
+  return null;
+}
+
+function commandInvocations(command) {
+  return shellSegments(command).map(invocationOf).filter(Boolean);
+}
+
+function bindingFailureDecision(diagnostic) {
+  const code = diagnostic?.code || 'WENDKEEP_VAULT_CONFIG_INVALID';
+  const raw = diagnostic?.message || String(diagnostic || 'Configuração WendKeep inválida.');
+  const detail = raw.replace(/\s+/g, ' ').trim().slice(0, 420);
+  return {
+    permissionDecision: 'deny',
+    permissionDecisionReason: `${code}: ${detail} Corrija o binding antes de executar uma ação mutável.`,
+  };
+}
+
+export function guardDecision(command, { vaultBase, env = process.env, profile = 'GOVERN' } = {}) {
+  if (!hookProfilePolicy(profile).harness) return null;
   const cmd = String(command || '');
-  if (!FAST_RE.test(cmd)) return null; // fast-path: zero I/O para o caso comum
+  const invocations = commandInvocations(cmd);
+  if (!invocations.length) return null; // fast-path: parsing puro, zero I/O para o caso comum
 
-  // R1: archive --force — puro regex, ainda sem I/O. Reason fala com o AGENTE (deny).
-  if (FORCE_RE.test(cmd)) {
+  // R1: archive --force — parser puro, ainda sem I/O. Reason fala com o AGENTE (deny).
+  const forcedArchive = invocations.find(({ kind, args }) => kind === 'wendkeep'
+    && args[0]?.toLowerCase() === 'change'
+    && args[1]?.toLowerCase() === 'archive'
+    && args.some((arg) => /^--force(?:=|$)/i.test(arg)));
+  if (forcedArchive) {
     if (env.WENDKEEP_ALLOW_FORCE === '1') return null;
     return {
       permissionDecision: 'deny',
@@ -28,12 +112,12 @@ export function guardDecision(command, { vaultBase, env = process.env } = {}) {
   }
 
   // R2: git commit — 1ª leitura de fs só acontece aqui. Reason fala com o USUÁRIO (ask).
-  const m = cmd.match(GIT_SEG_RE);
-  if (m) {
+  const gitCommit = invocations.find(({ kind, args }) => kind === 'git'
+    && args.some((arg) => arg.toLowerCase() === 'commit'));
+  if (gitCommit) {
     const slug = activeChange(vaultBase);
     if (!slug) return null;
-    const seg = cmd.slice(m.index + m[1].length).split(/&&|;|\|/)[0];
-    const noVerify = /\s--no-verify\b/.test(seg);
+    const noVerify = gitCommit.args.some((arg) => /^--no-verify(?:=|$)/i.test(arg));
     const gate = noVerify ? null : quickGateState(vaultBase);
     if (noVerify || (gate && gate.redCritical)) {
       return {
@@ -50,10 +134,25 @@ export function guardDecision(command, { vaultBase, env = process.env } = {}) {
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   try {
     const input = readHookInput();
-    const d = guardDecision(input.tool_input?.command, { vaultBase: getVaultBase(input) });
+    const runtime = resolveHookOperatingProfile({ input });
+    const d = runtime.bindingError
+      ? bindingFailureDecision(runtime.bindingError)
+      : guardDecision(input.tool_input?.command, {
+        vaultBase: runtime.vaultBase,
+        profile: runtime.profile,
+      });
     if (d) writeHookOutput({ hookSpecificOutput: { hookEventName: 'PreToolUse', ...d } });
     // allow implícito: exit 0 sem output
-  } catch {
-    writeHookOutput({}); // fail-open = allow
+  } catch (error) {
+    if (isProjectVaultIntegrityError(error)) {
+      writeHookOutput({
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          ...bindingFailureDecision(error),
+        },
+      });
+    } else {
+      writeHookOutput({}); // ausência/erro não-corrupto preserva compatibilidade fail-open
+    }
   }
 }

package/hooks/change-nag.mjs

@@ -5,16 +5,25 @@
 // ela o modelo é incentivado a marcar done falso só para conseguir parar).
 // Anti-loop absoluto: stop_hook_active é o PRIMEIRO check, antes de qualquer I/O.
 import { pathToFileURL } from 'node:url';
-import { getVaultBase, readHookInput, writeHookOutput } from './obsidian-common.mjs';
+import { readHookInput, writeHookOutput } from './obsidian-common.mjs';
+import { profileRuntimeError } from './brain-inject.mjs';
 import { quickGateState, readSentinel, writeSentinel } from './change-core.mjs';
+import {
+  hookProfilePolicy,
+  profileSentinelId,
+  resolveHookOperatingProfile,
+} from './operating-profile-runtime.mjs';
 
-export function nagDecision(input, vaultBase) {
+export function nagDecision(input, vaultBase, { profile = 'GOVERN' } = {}) {
   if (input && input.stop_hook_active) return null; // anti-loop: sempre primeiro
+  const policy = hookProfilePolicy(profile);
+  if (!policy.harness) return null;
   const gate = quickGateState(vaultBase);
   if (!gate || !gate.openTasks) return null;
   const sid = input?.session_id || input?.sessionId || '';
-  if (readSentinel(vaultBase, 'nag', sid)) return null;
-  writeSentinel(vaultBase, 'nag', sid);
+  const sentinelId = profileSentinelId(sid, profile);
+  if (readSentinel(vaultBase, 'nag', sentinelId)) return null;
+  writeSentinel(vaultBase, 'nag', sentinelId);
   return {
     decision: 'block',
     reason: `A change ativa "${gate.slug}" tem ${gate.openTasks} tarefa(s) aberta(s). Antes de encerrar: marque as concluídas com \`wendkeep change done <id>\`, rode \`wendkeep verify\`, ou informe a pendência ao usuário e encerre.`,
@@ -24,7 +33,13 @@ export function nagDecision(input, vaultBase) {
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   try {
     const input = readHookInput();
-    writeHookOutput(nagDecision(input, getVaultBase(input)) || {});
+    const runtime = resolveHookOperatingProfile({ input });
+    const decision = input?.stop_hook_active
+      ? null
+      : runtime.bindingError
+        ? { decision: 'block', reason: profileRuntimeError(runtime.bindingError) }
+        : nagDecision(input, runtime.vaultBase, { profile: runtime.profile });
+    writeHookOutput(decision || {});
   } catch {
     writeHookOutput({});
   }

package/hooks/change-warn.mjs

@@ -4,8 +4,14 @@
 // bloqueia — mudança trivial pode seguir. Ignora edições no vault e em .claude/.agent/.brain.
 import { isAbsolute, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { getVaultBase, readHookInput, writeHookOutput } from './obsidian-common.mjs';
+import { readHookInput, writeHookOutput } from './obsidian-common.mjs';
+import { profileRuntimeError } from './brain-inject.mjs';
 import { activeChange, readSentinel, writeSentinel } from './change-core.mjs';
+import {
+  hookProfilePolicy,
+  profileSentinelId,
+  resolveHookOperatingProfile,
+} from './operating-profile-runtime.mjs';
 
 const CODE_EXT = /\.(ts|tsx|js|jsx|mjs|cjs|py|prisma|sql|go|rs|java|cs)$/i;
 
@@ -16,15 +22,23 @@ export function isCodeFile(p) {
 const norm = (p) => String(p || '').replace(/\\/g, '/');
 
 // Retorna o additionalContext do aviso, ou null (caso comum).
-export function warnDecision(filePath, { vaultBase, cwd = '.', sessionId = '' } = {}) {
+export function warnDecision(filePath, {
+  vaultBase,
+  cwd = '.',
+  sessionId = '',
+  profile = 'GOVERN',
+} = {}) {
+  const policy = hookProfilePolicy(profile);
+  if (!policy.requiresChange) return null;
   if (!filePath || !isCodeFile(filePath)) return null;
   if (activeChange(vaultBase)) return null;
   const abs = norm(isAbsolute(filePath) ? filePath : resolve(cwd, filePath));
   // Dentro do vault (NTFS é case-insensitive) ou em dirs de config de agente: não é código do projeto.
   if (abs.toLowerCase().startsWith(`${norm(resolve(vaultBase)).toLowerCase()}/`)) return null;
   if (/\/(\.claude|\.agent|\.brain)\//.test(`${abs}/`)) return null;
-  if (readSentinel(vaultBase, 'warn', sessionId)) return null;
-  writeSentinel(vaultBase, 'warn', sessionId);
+  const sentinelId = profileSentinelId(sessionId, profile);
+  if (readSentinel(vaultBase, 'warn', sentinelId)) return null;
+  writeSentinel(vaultBase, 'warn', sentinelId);
   return [
     '<change_warn>',
     `Você editou código (${filePath}) sem change ativa. Para trabalho não-trivial, roteie pelo processo: \`wendkeep change new <slug>\` e preencha proposta/design/tarefas (skill wk-workflow). Ignore se for um ajuste trivial — este aviso não repete nesta sessão.`,
@@ -35,11 +49,15 @@ export function warnDecision(filePath, { vaultBase, cwd = '.', sessionId = '' }
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   try {
     const input = readHookInput();
-    const warn = warnDecision(input.tool_input?.file_path, {
-      vaultBase: getVaultBase(input),
-      cwd: input.cwd || '.',
-      sessionId: input.session_id || input.sessionId || '',
-    });
+    const runtime = resolveHookOperatingProfile({ input });
+    const warn = runtime.bindingError
+      ? profileRuntimeError(runtime.bindingError)
+      : warnDecision(input.tool_input?.file_path, {
+        vaultBase: runtime.vaultBase,
+        cwd: input.cwd || '.',
+        sessionId: input.session_id || input.sessionId || '',
+        profile: runtime.profile,
+      });
     if (!warn) { writeHookOutput({}); }
     else writeHookOutput({ hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: warn } });
   } catch {

package/hooks/decision-capture.mjs

@@ -212,7 +212,7 @@ export function captureDecision(vaultBase, input) {
           session = anchor === -1 ? `${session.trimEnd()}${section}` : `${session.slice(0, anchor).trimEnd()}${section}${session.slice(anchor)}`;
         }
         return session;
-      });
+      }, { vaultBase });
     } catch { /* backlink auxiliar nunca derruba a captura */ }
   }
   return { rel, skipped: false };

package/hooks/derived-sections.mjs

@@ -178,7 +178,7 @@ export function repairDerivedSections(vaultBase, { apply = false, lockTimeoutMs
     const outcome = mutateSessionNote(
       abs,
       (original) => applyDerivedSections(original, mergedForNote(entry)),
-      lockTimeoutMs ? { timeoutMs: lockTimeoutMs } : {},
+      { ...(lockTimeoutMs ? { timeoutMs: lockTimeoutMs } : {}), vaultBase },
     );
     if (!outcome.written) { skipped.push({ file: rel, reason: `gravação não ocorreu (${outcome.reason})` }); continue; }
     repaired.push({ file: rel, missing });