wendkeep 0.58.3 → 0.59.0

package/hooks/change-context.mjs

@@ -6,9 +6,14 @@
 //      Skill wk-workflow ANTES de editar — 1x por sessão. É o empurrão de ativação da skill.
 // Fail-open; brain-inject grava a sentinela ctx no SessionStart para não duplicar no 1º prompt.
 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 { changeCtxState, readSentinel, renderOpenChanges, writeSentinel } from './change-core.mjs';
-import { resolveSessionEntry } from './session-identity.mjs';
+import {
+  hookProfilePolicy,
+  profileSentinelId,
+  resolveHookOperatingProfile,
+} from './operating-profile-runtime.mjs';
 
 // Conservador de propósito: verbos de tarefa comuns (pt+en) + tamanho mínimo. Falso-negativo
 // custa só o nudge; falso-positivo em pergunta curta viraria ruído.
@@ -20,18 +25,22 @@ export function looksLikeTask(prompt) {
 }
 
 // Retorna { context, hash? } quando há algo a injetar; null = silêncio.
-export function buildChangePing(vaultBase, sessionId, prompt = '', changeSlug = '') {
+export function buildChangePing(vaultBase, sessionId, prompt = '', changeSlug = '', { profile = 'GOVERN' } = {}) {
+  const policy = hookProfilePolicy(profile);
+  if (!policy.harness) return null;
+  const sentinelId = profileSentinelId(sessionId, profile);
   const st = changeCtxState(vaultBase);
   if (st) {
-    if (readSentinel(vaultBase, 'ctx', sessionId) === st.hash) return null;
-    writeSentinel(vaultBase, 'ctx', sessionId, st.hash);
+    if (readSentinel(vaultBase, 'ctx', sentinelId) === st.hash) return null;
+    writeSentinel(vaultBase, 'ctx', sentinelId, st.hash);
     const focus = changeSlug ? `\n<session_change>Change vinculada a esta sessão: ${changeSlug}.</session_change>` : '';
     return { context: `${renderOpenChanges(st, { tag: 'open_changes_ping' })}${focus}`, hash: st.hash };
   }
   // Sem changes abertas: gate de skill para prompt-tarefa, 1x por sessão.
+  if (!policy.requiresChange) return null;
   if (!looksLikeTask(prompt)) return null;
-  if (readSentinel(vaultBase, 'gate', sessionId)) return null;
-  writeSentinel(vaultBase, 'gate', sessionId);
+  if (readSentinel(vaultBase, 'gate', sentinelId)) return null;
+  writeSentinel(vaultBase, 'gate', sentinelId);
   return {
     context: [
       '<wk_skill_gate>',
@@ -44,10 +53,15 @@ export function buildChangePing(vaultBase, sessionId, prompt = '', changeSlug =
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   try {
     const input = readHookInput();
-    const vaultBase = getVaultBase(input);
-    const { identity, entry } = resolveSessionEntry(vaultBase, input);
+    const runtime = resolveHookOperatingProfile({ input });
+    const vaultBase = runtime.vaultBase;
+    const { identity, entry } = runtime;
     const sid = identity.state === 'resolved' ? identity.canonicalConversationId : (input.session_id || input.sessionId || '');
-    const ping = buildChangePing(vaultBase, sid, input.prompt || '', entry?.change_slug || '');
+    const ping = runtime.bindingError
+      ? { context: profileRuntimeError(runtime.bindingError) }
+      : buildChangePing(vaultBase, sid, input.prompt || '', entry?.change_slug || '', {
+        profile: runtime.profile,
+      });
     if (!ping) { writeHookOutput({}); }
     else writeHookOutput({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: ping.context } });
   } catch {

package/hooks/change-core.mjs

@@ -1,11 +1,15 @@
 // hooks/change-core.mjs
 // Native change/spec lifecycle in the vault (Pilar B). Vault-facing lib consumed by
 // the `wendkeep change` CLI (src/change.mjs) and the brain-inject hook. No external deps.
-import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { dirname, join, relative } from 'node:path';
-import { ensureDir, wikilinkFromRel, monthFolderRelFromDateStr } from './obsidian-common.mjs';
+import { wikilinkFromRel, monthFolderRelFromDateStr } from './obsidian-common.mjs';
 import { parseSpecsList, promoteSpecs, discoverSpecDeltas, tasksHashOf, captureSpecBaseline, REQ_ID_RE_SRC } from './spec-core.mjs';
 import { getLocale, LOCALES } from './locale.mjs';
+import {
+  assertVaultPathSafe, assertVaultPathsSafe, mkdirVaultPath, renameVaultPath,
+  unlinkVaultFile, writeVaultFileSync,
+} from './vault-path-safety.mjs';
 
 export const ARCHIVE_DIR = '_arquivo';
 const POINTER = '.brain/CURRENT_CHANGE.md';
@@ -97,24 +101,83 @@ export function activeChange(vaultBase) {
 }
 
 export function setActiveChange(vaultBase, slug) {
-  mkdirSync(join(vaultBase, '.brain'), { recursive: true });
-  writeFileSync(join(vaultBase, POINTER), `change: ${slug}\n`, 'utf8');
+  mkdirVaultPath(vaultBase, join(vaultBase, '.brain'), { label: 'raiz de controle da change' });
+  writeVaultFileSync(
+    vaultBase,
+    join(vaultBase, POINTER),
+    `change: ${slug}\n`,
+    'utf8',
+    { label: 'ponteiro CURRENT_CHANGE.md' },
+  );
 }
 
 export function clearActiveChange(vaultBase) {
   const p = join(vaultBase, POINTER);
-  if (existsSync(p)) writeFileSync(p, 'change:\n', 'utf8');
+  const checked = assertVaultPathSafe(vaultBase, p, {
+    expectedType: 'file', label: 'ponteiro CURRENT_CHANGE.md',
+  });
+  if (checked.exists) {
+    writeVaultFileSync(vaultBase, p, 'change:\n', 'utf8', { label: 'ponteiro CURRENT_CHANGE.md' });
+  }
 }
 
-export function newChange(vaultBase, slug, { sessionRel = '', dateStr, simple = false }) {
+export function assertChangeScaffoldTargetsSafe(vaultBase, slug, {
+  simple = false,
+  mustNotExist = false,
+  includeSessionControl = false,
+  code = 'VAULT_PATH_UNSAFE',
+} = {}) {
   const loc = getLocale(vaultBase);
   const dir = join(vaultBase, loc.folders.changes, slug);
+  const fileNames = [
+    'proposta.md',
+    'tarefas.md',
+    '.spec-impact-v1',
+    '.spec-impact-v1.json',
+    '.spec-base.json',
+    'flow-origin.json',
+    ...(!simple ? ['design.md'] : []),
+  ];
+  assertVaultPathsSafe(vaultBase, [
+    { path: join(vaultBase, loc.folders.changes), expectedType: 'directory', label: 'raiz de changes', code },
+    {
+      path: dir,
+      expectedType: 'directory',
+      mustNotExist,
+      label: 'destino da change',
+      code,
+    },
+    ...fileNames.map((name) => ({
+      path: join(dir, name), expectedType: 'file', label: `artefato ${name} da change`, code,
+    })),
+    { path: join(vaultBase, '.brain'), expectedType: 'directory', label: 'raiz de controle da change', code },
+    {
+      path: join(vaultBase, POINTER), expectedType: 'file', label: 'ponteiro CURRENT_CHANGE.md', code,
+    },
+    ...(includeSessionControl ? [{
+      path: join(vaultBase, '.brain', 'CURRENT_SESSION.md'),
+      expectedType: 'file',
+      label: 'projeção CURRENT_SESSION.md',
+      code,
+    }] : []),
+  ]);
+  return { dir, rel: changeDirRel(slug, vaultBase) };
+}
+
+export function newChange(vaultBase, slug, { sessionRel = '', dateStr, simple = false }) {
+  const loc = getLocale(vaultBase);
+  const { dir } = assertChangeScaffoldTargetsSafe(vaultBase, slug, { simple });
   const existed = existsSync(join(dir, 'proposta.md'));
-  mkdirSync(dir, { recursive: true });
+  mkdirVaultPath(vaultBase, dir, { label: 'destino da change' });
   const files = renderChangeScaffold({ slug, sessionRel, dateStr, locale: loc.id, simple });
   const write = (name, content) => {
     const f = join(dir, name);
-    if (!existsSync(f)) writeFileSync(f, content, 'utf8');
+    const checked = assertVaultPathSafe(vaultBase, f, {
+      expectedType: 'file', label: `artefato ${name} da change`,
+    });
+    if (!checked.exists) {
+      writeVaultFileSync(vaultBase, f, content, 'utf8', { label: `artefato ${name} da change` });
+    }
   };
   write('proposta.md', files.proposta);
   write('tarefas.md', files.tarefas);
@@ -160,26 +223,27 @@ export function continueChange(vaultBase, archivedSlug, newSlug, options = {}) {
     ? `Continues ${wikilinkFromRel(archivedProposal)}. Archived evidence and verdict are not inherited.`
     : `Continua ${wikilinkFromRel(archivedProposal)}. Evidências e verdict da change arquivada não são herdados.`;
   proposal = `${proposal.trimEnd()}\n\n${heading}\n\n${note}\n`;
-  writeFileSync(proposalPath, proposal, 'utf8');
+  writeVaultFileSync(vaultBase, proposalPath, proposal, 'utf8', { label: 'proposta da change continuada' });
   return { ok: true, ...result, archived: archivedName };
 }
 
 export function parseTasks(md) {
   const tasks = [];
   const re = /^-\s+\[( |x)\]\s+(\S+)\s+(.*)$/gm;
-  const sensorRe = /\[sensor:\s*([\w.-]+)\]/;
+  const sensorReG = /\[sensor:\s*([\w.-]+)\]/g;
   const reqReG = new RegExp(`\\[req:\\s*(${REQ_ID_RE_SRC})\\]`, 'g');
   let m;
   while ((m = re.exec(String(md))) !== null) {
     let text = m[3].trim();
-    const sm = text.match(sensorRe);
+    const sensors = [...new Set([...text.matchAll(sensorReG)].map((entry) => entry[1]))];
     const reqs = [...text.matchAll(reqReG)].map((r) => r[1]);
-    const sensor = sm ? sm[1] : undefined;
-    if (sm) text = text.replace(sensorRe, '');
+    const sensor = sensors[0];
+    if (sensors.length) text = text.replace(sensorReG, '');
     if (reqs.length) text = text.replace(reqReG, '');
     text = text.replace(/\s+/g, ' ').trim();
+    // `sensor` stays as alias of the first id — older consumers keep working.
     // `req` stays as alias of the first id — older consumers keep working.
-    tasks.push({ id: m[2], text, done: m[1] === 'x', ...(sensor ? { sensor } : {}), ...(reqs.length ? { req: reqs[0], reqs } : {}) });
+    tasks.push({ id: m[2], text, done: m[1] === 'x', ...(sensor ? { sensor, sensors } : {}), ...(reqs.length ? { req: reqs[0], reqs } : {}) });
   }
   return tasks;
 }
@@ -191,7 +255,14 @@ export function setTaskDone(changeDir, taskId, done = true) {
   const esc = String(taskId).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   const re = new RegExp(`^(-\\s+\\[)( |x)(\\]\\s+${esc}\\s)`, 'm');
   if (!re.test(md)) return false;
-  writeFileSync(path, md.replace(re, `$1${done ? 'x' : ' '}$3`), 'utf8');
+  const vaultBase = dirname(dirname(changeDir));
+  writeVaultFileSync(
+    vaultBase,
+    path,
+    md.replace(re, `$1${done ? 'x' : ' '}$3`),
+    'utf8',
+    { label: 'tarefas.md da change' },
+  );
   return true;
 }
 
@@ -350,8 +421,14 @@ export function readSentinel(vaultBase, kind, sid) {
 
 export function writeSentinel(vaultBase, kind, sid, value = '1') {
   try {
-    mkdirSync(join(vaultBase, '.brain'), { recursive: true });
-    writeFileSync(sentinelPath(vaultBase, kind, sid), value, 'utf8');
+    mkdirVaultPath(vaultBase, join(vaultBase, '.brain'), { label: 'raiz de sentinelas de change' });
+    writeVaultFileSync(
+      vaultBase,
+      sentinelPath(vaultBase, kind, sid),
+      value,
+      'utf8',
+      { label: 'sentinela de change' },
+    );
   } catch { /* fail-open: pior caso = aviso repetido */ }
 }
 
@@ -386,7 +463,10 @@ export function pruneChangeSentinels(vaultBase, { now = Date.now() } = {}) {
       .filter(Boolean);
   } catch { return []; }
   const stale = staleSentinelNames(entries, now);
-  for (const name of stale) { try { unlinkSync(join(dir, name)); } catch { /* fail-quiet */ } }
+  for (const name of stale) {
+    try { unlinkVaultFile(vaultBase, join(dir, name), { label: 'sentinela stale de change' }); }
+    catch { /* fail-quiet */ }
+  }
   return stale;
 }
 
@@ -412,7 +492,14 @@ export function appendFixTasks(changeDir, mutants, sensorId) {
   }
   if (!lines.length) return 0;
   const sep = md === '' || md.endsWith('\n') ? '' : '\n';
-  writeFileSync(path, `${md}${sep}${lines.join('\n')}\n`, 'utf8');
+  const vaultBase = dirname(dirname(changeDir));
+  writeVaultFileSync(
+    vaultBase,
+    path,
+    `${md}${sep}${lines.join('\n')}\n`,
+    'utf8',
+    { label: 'tarefas.md com mutantes sobreviventes' },
+  );
   return lines.length;
 }
 
@@ -431,11 +518,29 @@ export function archiveChange(vaultBase, slug, { gate = gateGreen, dateStr, adrN
   const destRel = join(chDir, ARCHIVE_DIR, `${dateStr}-${slug}`);
   const destAbs = join(vaultBase, destRel);
   const changeWikilink = wikilinkFromRel(join(destRel, 'proposta'));
+  const archiveRoot = join(vaultBase, chDir, ARCHIVE_DIR);
+  const adrDirRel = monthFolderRelFromDateStr(loc.folders.decisions, dateStr, vaultBase);
+  const num = String(adrNum).padStart(4, '0');
+  const adrRel = join(adrDirRel, `ADR-${num}-${slug}.md`);
+
+  // Validate every later mutation target before spec promotion can change living state.
+  const [checkedSource, checkedDestination] = assertVaultPathsSafe(vaultBase, [
+    { path: src, allowMissing: false, expectedType: 'directory', label: 'change a arquivar' },
+    { path: destAbs, expectedType: 'directory', label: 'destino da change arquivada' },
+    { path: archiveRoot, expectedType: 'directory', label: 'raiz de changes arquivadas' },
+    { path: join(vaultBase, adrDirRel), expectedType: 'directory', label: 'pasta mensal de ADR' },
+    { path: join(vaultBase, adrRel), expectedType: 'file', label: 'ADR da change arquivada' },
+    { path: join(vaultBase, POINTER), expectedType: 'file', label: 'ponteiro CURRENT_CHANGE.md' },
+  ]);
+  assertVaultPathsSafe(vaultBase, [
+    { path: join(checkedSource.target, 'proposta.md'), expectedType: 'file', label: 'proposta da change' },
+    { path: join(checkedSource.target, 'tarefas.md'), expectedType: 'file', label: 'tarefas da change' },
+  ]);
 
   // Atomicity guard: fail BEFORE promoting specs if the destination already exists (e.g. a slug
   // reused after a same-day archive). Otherwise promoteSpecs would commit to 07-Specs and the
   // later renameSync would fail, leaving a half-archived state.
-  if (existsSync(destAbs)) {
+  if (checkedDestination.exists) {
     return { ok: false, failing: [`destino de arquivo já existe: ${destRel} — renomeie o slug ou remova o arquivo antigo`] };
   }
 
@@ -469,9 +574,11 @@ export function archiveChange(vaultBase, slug, { gate = gateGreen, dateStr, adrN
   // abaixo retargeta o wikilink pro _arquivo junto com os demais. Fail-quiet.
   try { healSpecBacklinks(src, vaultBase); } catch { /* heal é bônus */ }
 
-  ensureDir(join(vaultBase, chDir, ARCHIVE_DIR));
+  mkdirVaultPath(vaultBase, archiveRoot, { label: 'raiz de changes arquivadas' });
   try {
-    renameSync(src, destAbs);
+    renameVaultPath(vaultBase, src, destAbs, {
+      sourceType: 'directory', label: 'archive da change',
+    });
   } catch (error) {
     return { ok: false, failing: [`falha ao mover a mudança para ${destRel}: ${error.message} (07-Specs pode ter sido promovido — verifique)`] };
   }
@@ -480,7 +587,7 @@ export function archiveChange(vaultBase, slug, { gate = gateGreen, dateStr, adrN
   try {
     const pp = join(destAbs, 'proposta.md');
     const c = readFileSync(pp, 'utf8').replace(/^status:\s*active\s*$/m, 'status: archived');
-    writeFileSync(pp, c, 'utf8');
+    writeVaultFileSync(vaultBase, pp, c, 'utf8', { label: 'proposta arquivada' });
   } catch { /* proposta ilegível — segue */ }
 
   // O move quebrava TODO wikilink gravado antes (sessões fechadas, decisões, outras changes —
@@ -490,10 +597,7 @@ export function archiveChange(vaultBase, slug, { gate = gateGreen, dateStr, adrN
 
   // ADR goes in the same dated month folder as session-derived decisions (04-Decisões/ano/MM-MMM/)
   // — not the year root — so all ADRs sit together in the vault's convention.
-  const adrDirRel = monthFolderRelFromDateStr(loc.folders.decisions, dateStr, vaultBase);
-  ensureDir(join(vaultBase, adrDirRel));
-  const num = String(adrNum).padStart(4, '0');
-  const adrRel = join(adrDirRel, `ADR-${num}-${slug}.md`);
+  mkdirVaultPath(vaultBase, join(vaultBase, adrDirRel), { label: 'pasta mensal de ADR' });
   const capLine = promoted.length
     ? `\n\nCapabilities: ${promoted.map((c) => wikilinkFromRel(join(loc.folders.specs, c))).join(', ')}.`
     : '';
@@ -501,7 +605,7 @@ export function archiveChange(vaultBase, slug, { gate = gateGreen, dateStr, adrN
   // Rastro auditável (0.31.0): um archive forçado ou sem prova declarada fica marcado no ADR.
   const flagLines = `${adrFlags.forced ? '\nforced: true' : ''}${adrFlags.trivial ? '\ntrivial: true' : ''}`;
   const forcedNote = adrFlags.forced ? '\n\n> ⚠️ Arquivada com --force — havia tarefa(s) aberta(s) pulada(s) no gate.' : '';
-  writeFileSync(join(vaultBase, adrRel), `---
+  writeVaultFileSync(vaultBase, join(vaultBase, adrRel), `---
 type: decision
 status: accepted
 date: ${dateStr}${flagLines}
@@ -516,7 +620,7 @@ tags:
 ## Decisão
 
 Mudança ${changeWikilink} concluída e arquivada.${capLine}${reqLine}${forcedNote}
-`, 'utf8');
+`, 'utf8', { label: 'ADR da change arquivada' });
 
   // Only clear the pointer when the archived change IS the active one — archiving some other
   // slug explicitly must not blank the pointer of a different, still-active change.
@@ -530,6 +634,11 @@ function allVaultMarkdown(vaultBase) {
   const out = [];
   const skip = new Set(['.git', '.obsidian', 'node_modules']);
   const walk = (dir) => {
+    try {
+      assertVaultPathSafe(vaultBase, dir, {
+        allowMissing: false, expectedType: 'directory', label: 'diretório varrido para wikilinks',
+      });
+    } catch { return; }
     let entries;
     try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
     for (const e of entries) {
@@ -556,7 +665,10 @@ function rewriteChangeLinks(vaultBase, fromRel, toRel) {
       .split(`[[${fromRel}]]`).join(`[[${toRel}]]`)
       .split(`[[${fromRel}|`).join(`[[${toRel}|`);
     if (next !== content) {
-      try { writeFileSync(abs, next, 'utf8'); touched += 1; } catch { /* nota readonly — segue */ }
+      try {
+        writeVaultFileSync(vaultBase, abs, next, 'utf8', { label: 'nota com wikilink reescrito' });
+        touched += 1;
+      } catch { /* nota readonly/unsafe — segue */ }
     }
   }
   return touched;
@@ -604,7 +716,10 @@ export function healSpecBacklinks(changeDir, vaultBase) {
     let c;
     try { c = readFileSync(p, 'utf8'); } catch { continue; }
     if (c.includes(link)) continue;
-    try { writeFileSync(p, insertBacklink(c, line), 'utf8'); healed += 1; } catch { /* readonly — segue */ }
+    try {
+      writeVaultFileSync(vaultBase, p, insertBacklink(c, line), 'utf8', { label: 'delta de spec com backlink' });
+      healed += 1;
+    } catch { /* readonly/unsafe — segue */ }
   }
   return healed;
 }
@@ -645,7 +760,11 @@ export function backfillArtifactLinks(vaultBase, { apply = false } = {}) {
       let c;
       try { c = readFileSync(p, 'utf8'); } catch { continue; }
       if (c.includes(link)) continue;
-      if (apply) { try { writeFileSync(p, insertBacklink(c, line), 'utf8'); } catch { continue; } }
+      if (apply) {
+        try {
+          writeVaultFileSync(vaultBase, p, insertBacklink(c, line), 'utf8', { label: 'artefato com backlink' });
+        } catch { continue; }
+      }
       changed.push(relative(vaultBase, p).replaceAll('\\', '/'));
     }
   }
@@ -701,15 +820,33 @@ export function relinkChanges(vaultBase, { apply = false } = {}) {
 export function abandonChange(vaultBase, slug, { dateStr }) {
   const chDir = getLocale(vaultBase).folders.changes;
   const src = join(vaultBase, chDir, slug);
-  if (!existsSync(join(src, 'proposta.md'))) return { ok: false, failing: [`change não encontrada: ${slug}`] };
+  const checkedProposal = assertVaultPathSafe(vaultBase, join(src, 'proposta.md'), {
+    expectedType: 'file', label: 'proposta da change abandonada',
+  });
+  if (!checkedProposal.exists) return { ok: false, failing: [`change não encontrada: ${slug}`] };
   const destRel = join(chDir, ARCHIVE_DIR, `${dateStr}-${slug}-abandonada`);
   const destAbs = join(vaultBase, destRel);
-  if (existsSync(destAbs)) return { ok: false, failing: [`destino já existe: ${destRel}`] };
-  ensureDir(join(vaultBase, chDir, ARCHIVE_DIR));
-  try { renameSync(src, destAbs); } catch (e) { return { ok: false, failing: [`falha ao mover: ${e.message}`] }; }
+  const checkedDestination = assertVaultPathSafe(vaultBase, destAbs, {
+    expectedType: 'directory', label: 'destino da change abandonada',
+  });
+  if (checkedDestination.exists) return { ok: false, failing: [`destino já existe: ${destRel}`] };
+  mkdirVaultPath(vaultBase, join(vaultBase, chDir, ARCHIVE_DIR), {
+    label: 'raiz de changes arquivadas',
+  });
+  try {
+    renameVaultPath(vaultBase, src, destAbs, {
+      sourceType: 'directory', label: 'abandono da change',
+    });
+  } catch (e) { return { ok: false, failing: [`falha ao mover: ${e.message}`] }; }
   try {
     const pp = join(destAbs, 'proposta.md');
-    writeFileSync(pp, readFileSync(pp, 'utf8').replace(/^status:\s*active\s*$/m, 'status: abandoned'), 'utf8');
+    writeVaultFileSync(
+      vaultBase,
+      pp,
+      readFileSync(pp, 'utf8').replace(/^status:\s*active\s*$/m, 'status: abandoned'),
+      'utf8',
+      { label: 'proposta abandonada' },
+    );
   } catch { /* proposta sem frontmatter — segue */ }
   let linksRewritten = 0;
   try { linksRewritten = rewriteChangeLinks(vaultBase, `${chDir}/${slug}`, destRel.replaceAll('\\', '/')); } catch { /* abandono já íntegro */ }

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({});
   }