wendkeep 0.58.1 → 0.59.0

package/hooks/obsidian-common.mjs

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'fs';
-import { releaseLockDir } from './session-note-io.mjs';
+import { LOCK_BUSY, mutateSessionNote, withPathLock } from './session-note-io.mjs';
 import { basename, dirname, join, relative } from 'path';
 import { getLocale } from './locale.mjs';
 import { resolveProjectVault } from '../src/project-vault.mjs';
+import {
+  assertVaultPathSafe, mkdirVaultPath, writeVaultFileAtomic,
+} from './vault-path-safety.mjs';
 
 // Deprecated export kept for consumers that imported it before 0.39.0. Automatic
 // hooks never use this fallback: an unbound project fails closed.
@@ -212,9 +215,12 @@ export function yamlQuote(value = '') {
 
 export function readControl(vaultBase) {
   const path = controlPath(vaultBase);
-  if (!existsSync(path)) return {};
+  const checked = assertVaultPathSafe(vaultBase, path, {
+    expectedType: 'file', label: 'CURRENT_SESSION.md',
+  });
+  if (!checked.exists) return {};
 
-  const content = readFileSync(path, 'utf-8');
+  const content = readFileSync(checked.target, 'utf-8');
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return {};
 
@@ -228,7 +234,10 @@ export function readControl(vaultBase) {
 
 export function writeControl(vaultBase, data) {
   const path = controlPath(vaultBase);
-  ensureDir(dirname(path));
+  mkdirVaultPath(vaultBase, dirname(path), { label: 'diretório do CURRENT_SESSION' });
+  assertVaultPathSafe(vaultBase, path, {
+    expectedType: 'file', label: 'CURRENT_SESSION.md',
+  });
 
   const status = data.status || 'inactive';
   const sessionFile = data.session_file || '';
@@ -275,15 +284,20 @@ ${activeRows}
 Regra crítica: sempre anexar conteúdo à sessão ativa. Nunca sobrescrever o histórico de iterações.
 `;
 
-  writeFileSync(path, content, 'utf-8');
+  writeVaultFileAtomic(vaultBase, path, content, 'utf-8', {
+    label: 'CURRENT_SESSION.md',
+  });
 }
 
 export function readSessionRegistry(vaultBase) {
   const path = registryPath(vaultBase);
-  if (!existsSync(path)) return { version: 2, sessions: {} };
+  const checked = assertVaultPathSafe(vaultBase, path, {
+    expectedType: 'file', label: 'SESSION_REGISTRY.json',
+  });
+  if (!checked.exists) return { version: 2, sessions: {} };
 
   try {
-    const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+    const parsed = JSON.parse(readFileSync(checked.target, 'utf-8'));
     return {
       version: Math.max(2, parsed.version || 1),
       sessions: parsed.sessions && typeof parsed.sessions === 'object' ? parsed.sessions : {},
@@ -295,48 +309,18 @@ export function readSessionRegistry(vaultBase) {
 
 export function writeSessionRegistry(vaultBase, registry) {
   const path = registryPath(vaultBase);
-  ensureDir(dirname(path));
+  mkdirVaultPath(vaultBase, dirname(path), { label: 'diretório do SESSION_REGISTRY' });
   // Escrita atômica: grava em tmp e renomeia (rename é atômico no mesmo volume),
   // evitando registry truncado/corrompido quando dois hooks gravam ao mesmo tempo.
-  const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
-  writeFileSync(tmp, `${JSON.stringify(registry, null, 2)}\n`, 'utf-8');
-  renameSync(tmp, path);
-}
-
-function registryLockPath(vaultBase) {
-  return `${registryPath(vaultBase)}.lock`;
-}
-
-function waitBriefly(ms) {
-  const signal = new Int32Array(new SharedArrayBuffer(4));
-  Atomics.wait(signal, 0, 0, ms);
+  writeVaultFileAtomic(vaultBase, path, `${JSON.stringify(registry, null, 2)}\n`, 'utf-8', {
+    label: 'SESSION_REGISTRY.json',
+  });
 }
 
 export function mutateSessionRegistry(vaultBase, mutator, { timeoutMs = 2000 } = {}) {
-  const lock = registryLockPath(vaultBase);
-  ensureDir(dirname(lock));
-  const deadline = Date.now() + timeoutMs;
-  while (true) {
-    try {
-      mkdirSync(lock);
-      break;
-    } catch (error) {
-      if (error?.code === 'EEXIST') {
-        try {
-          if (Date.now() - statSync(lock).mtimeMs > 10_000) {
-            releaseLockDir(lock);
-            continue;
-          }
-        } catch { /* outro processo pode ter liberado o lock */ }
-      }
-      if (error?.code !== 'EEXIST' || Date.now() >= deadline) {
-        throw new Error(`SESSION_REGISTRY lock indisponível: ${error.message}`);
-      }
-      waitBriefly(10);
-    }
-  }
-
-  try {
+  const path = registryPath(vaultBase);
+  mkdirVaultPath(vaultBase, dirname(path), { label: 'diretório do SESSION_REGISTRY' });
+  const outcome = withPathLock(path, () => {
     const registry = readSessionRegistry(vaultBase);
     const before = JSON.stringify(registry);
     registry.version = 2;
@@ -345,17 +329,17 @@ export function mutateSessionRegistry(vaultBase, mutator, { timeoutMs = 2000 } =
       writeSessionRegistry(vaultBase, registry);
     }
     return result;
-  } finally {
-    // rmSync recursivo não remove diretório em caminho não-ASCII no Windows — ver
-    // releaseLockDir. Vault sob pasta acentuada travaria o registry após a 1ª mutação.
-    releaseLockDir(lock);
+  }, { timeoutMs, vaultBase });
+  if (outcome === LOCK_BUSY) {
+    throw new Error('SESSION_REGISTRY lock indisponível: lock ocupado até o timeout.');
   }
+  return outcome;
 }
 
 function meaningfulPatch(patch = {}) {
   const protectedNonEmpty = new Set(['session_file', 'transcript_path', 'transcript_id', 'provider', 'started_at', 'change_slug', 'activation_id']);
   return Object.fromEntries(Object.entries(patch).filter(([key, value]) => {
-    if (key === 'advance_turn_sequence' || key === 'turn_sequence') return false;
+    if (['advance_turn_sequence', 'turn_sequence', 'turn_id', 'last_turn_sequence', 'recovery_activation_id', 'recovery_started_at'].includes(key)) return false;
     if (value === undefined || value === null) return false;
     if (value === '' && protectedNonEmpty.has(key)) return false;
     return true;
@@ -390,9 +374,13 @@ export function openActivation(registry, session = {}, explicitActivationId = ''
 
   const current = next.sessions[sessionId] || {};
   const activations = { ...(current.activations || {}) };
+  const openedAfterSequence = nonNegativeSequence(
+    session.opened_after_turn_sequence,
+    nonNegativeSequence(current.last_turn_sequence, 0),
+  );
   const requestedSequence = nonNegativeSequence(
     session.turn_sequence ?? session.last_turn_sequence,
-    0,
+    openedAfterSequence,
   );
 
   if (current.active_activation_id === activationId && activations[activationId]?.status === 'active') {
@@ -430,7 +418,9 @@ export function openActivation(registry, session = {}, explicitActivationId = ''
     epoch,
     status: 'active',
     started_at: session.activation_started_at || session.started_at || '',
-    last_turn_sequence: requestedSequence,
+    opened_after_turn_sequence: openedAfterSequence,
+    ...(current.last_turn_id ? { opened_after_turn_id: current.last_turn_id } : {}),
+    last_turn_sequence: Math.max(openedAfterSequence, requestedSequence),
     ...(session.transcript_id ? { transcript_id: session.transcript_id } : {}),
     ...(session.transcript_path ? { transcript_path: session.transcript_path } : {}),
     ...(session.provider ? { provider: session.provider } : {}),
@@ -441,19 +431,40 @@ export function openActivation(registry, session = {}, explicitActivationId = ''
     active_activation_id: activationId,
     activation_epoch: epoch,
     activation_started_at: session.activation_started_at || session.started_at || '',
-    last_turn_sequence: requestedSequence,
+    last_turn_sequence: Math.max(openedAfterSequence, requestedSequence),
     activations,
   };
   return next;
 }
 
 export function advanceActivationTurn(registry, turn = {}) {
-  const next = cloneRegistry(registry);
+  let next = cloneRegistry(registry);
   const sessionId = turn.session_id || turn.canonical_session_id || '';
-  const current = next.sessions[sessionId];
+  let current = next.sessions[sessionId];
   if (!current) return next;
 
-  const activeId = current.active_activation_id || '';
+  const turnId = String(turn.turn_id || '');
+  const knownTurn = Boolean(turnId && (
+    current.last_turn_id === turnId
+    || current.last_prompt_turn_id === turnId
+    || Object.prototype.hasOwnProperty.call(current.turn_sequences || {}, turnId)
+  ));
+  if (knownTurn) return next;
+
+  let activeId = current.active_activation_id || '';
+  if ((!activeId || current.activations?.[activeId]?.status !== 'active') && turn.recovery_activation_id) {
+    next = openActivation(next, {
+      session_id: sessionId,
+      activation_id: turn.recovery_activation_id,
+      activation_started_at: turn.recovery_started_at || turn.started_at || '',
+      turn_sequence: turn.turn_sequence ?? current.last_turn_sequence,
+      transcript_id: turn.transcript_id || current.transcript_id,
+      transcript_path: turn.transcript_path || current.transcript_path,
+      provider: turn.provider || current.provider,
+    });
+    current = next.sessions[sessionId];
+    activeId = current.active_activation_id || '';
+  }
   if (turn.activation_id && activeId && turn.activation_id !== activeId) return next;
   const previous = nonNegativeSequence(current.last_turn_sequence, 0);
   const explicit = nonNegativeSequence(turn.turn_sequence ?? turn.last_turn_sequence);
@@ -466,9 +477,18 @@ export function advanceActivationTurn(registry, turn = {}) {
         nonNegativeSequence(activations[activeId].last_turn_sequence, 0),
         sequence,
       ),
+      ...(turnId ? { last_prompt_turn_id: turnId } : {}),
     };
   }
-  next.sessions[sessionId] = { ...current, last_turn_sequence: sequence, activations };
+  next.sessions[sessionId] = {
+    ...current,
+    last_turn_sequence: sequence,
+    ...(turnId ? {
+      last_prompt_turn_id: turnId,
+      turn_sequences: { ...(current.turn_sequences || {}), [turnId]: sequence },
+    } : {}),
+    activations,
+  };
   return next;
 }
 
@@ -478,23 +498,22 @@ export function resolveStopActivation(registry, stop = {}) {
   if (!entry) return '';
   if (stop.activation_id) return String(stop.activation_id);
 
+  const activeId = entry.active_activation_id || '';
+  const active = entry.activations?.[activeId];
+  if (!activeId || active?.status !== 'active') return '';
   const transcriptId = String(stop.transcript_id || '');
   const transcriptPath = String(stop.transcript_path || '');
   if (!transcriptId && !transcriptPath) return '';
-  const matches = Object.entries(entry.activations || {}).filter(([, activation]) => {
-    if (!activation) return false;
-    if (transcriptId && activation.transcript_id && activation.transcript_id !== transcriptId) return false;
-    const paths = [
-      ...(Array.isArray(activation.transcript_paths) ? activation.transcript_paths : []),
-      activation.transcript_path,
-    ].filter(Boolean);
-    if (transcriptPath && paths.length && !paths.some((path) => transcriptsMatch(path, transcriptPath))) return false;
-    return Boolean(
-      (transcriptId && activation.transcript_id === transcriptId)
-      || (transcriptPath && paths.some((path) => transcriptsMatch(path, transcriptPath))),
-    );
-  });
-  return matches.length === 1 ? matches[0][0] : '';
+  if (transcriptId && active.transcript_id && active.transcript_id !== transcriptId) return '';
+  const paths = [
+    ...(Array.isArray(active.transcript_paths) ? active.transcript_paths : []),
+    active.transcript_path,
+  ].filter(Boolean);
+  if (transcriptPath && paths.length && !paths.some((path) => transcriptsMatch(path, transcriptPath))) return '';
+  return (
+    (transcriptId && active.transcript_id === transcriptId)
+    || (transcriptPath && paths.some((path) => transcriptsMatch(path, transcriptPath)))
+  ) ? activeId : '';
 }
 
 function stopResult(registry, stopDisposition, canPromoteMemory = false) {
@@ -531,21 +550,31 @@ export function applyStopActivation(registry, stop = {}) {
   const stopSequence = nonNegativeSequence(stop.turn_sequence ?? stop.last_turn_sequence);
   const lastSequence = nonNegativeSequence(current.last_turn_sequence, 0);
   if (stopSequence === null) return stopResult(next, 'ambiguous');
+  const active = current.activations?.[activeId] || {};
+  const openedAfterSequence = nonNegativeSequence(active.opened_after_turn_sequence, 0);
+  if (stopSequence <= openedAfterSequence && active.epoch > 1) {
+    return stopResult(next, 'superseded');
+  }
+  const stopTurnId = String(stop.turn_id || '');
+  if (stopTurnId && active.last_stop_turn_id === stopTurnId) {
+    return stopResult(next, 'duplicate');
+  }
   if (stopSequence < lastSequence) return stopResult(next, 'stale_turn');
 
   const activations = { ...(current.activations || {}) };
   activations[activeId] = {
     ...(activations[activeId] || { activation_id: activeId, epoch: current.activation_epoch }),
-    status: 'done',
-    ended_at: stop.ended_at || '',
+    status: 'active',
     last_turn_sequence: stopSequence,
+    last_stop_turn_sequence: stopSequence,
+    ...(stopTurnId ? { last_stop_turn_id: stopTurnId } : {}),
   };
   next.sessions[sessionId] = {
     ...current,
-    status: 'done',
-    ended_at: stop.ended_at || current.ended_at || '',
-    active_activation_id: '',
-    last_turn_sequence: stopSequence,
+    status: 'active',
+    active_activation_id: activeId,
+    last_turn_sequence: Math.max(lastSequence, stopSequence),
+    ...(stopTurnId ? { last_turn_id: stopTurnId } : {}),
     activations,
   };
   return stopResult(next, 'applied', true);
@@ -584,7 +613,7 @@ export function upsertSessionRegistry(vaultBase, sessionId, patch) {
           activation_id: clean.activation_id,
           activation_started_at: clean.activation_started_at,
           started_at: clean.activation_started_at || clean.started_at,
-          last_turn_sequence: clean.last_turn_sequence,
+          last_turn_sequence: patch.last_turn_sequence,
           transcript_id: clean.transcript_id || current.transcript_id,
           transcript_path: clean.transcript_path || current.transcript_path,
           provider: clean.provider || current.provider,
@@ -597,7 +626,13 @@ export function upsertSessionRegistry(vaultBase, sessionId, patch) {
         {
           session_id: sessionId,
           activation_id: causalCurrent.active_activation_id || '',
+          recovery_activation_id: patch.recovery_activation_id || '',
+          recovery_started_at: patch.recovery_started_at || '',
+          turn_id: patch.turn_id || '',
           turn_sequence: patch.turn_sequence,
+          transcript_id: clean.transcript_id || causalCurrent.transcript_id,
+          transcript_path: clean.transcript_path || causalCurrent.transcript_path,
+          provider: clean.provider || causalCurrent.provider,
         },
       ).sessions[sessionId];
     }
@@ -705,13 +740,13 @@ export function sweepStaleSessionsFile(vaultBase, now = new Date(), maxIdleMs =
 // já fechada com o mesmo `endedAt`). Devolve true se gravou.
 export function closeSessionNoteFile(vaultBase, sessionFileRel, endedAt) {
   if (!sessionFileRel) return false;
-  const path = join(vaultBase, sessionFileRel);
-  if (!existsSync(path)) return false;
-  const content = readFileSync(path, 'utf-8');
-  const next = closeSessionNote(content, endedAt);
-  if (next === content) return false;
-  writeFileSync(path, next, 'utf-8');
-  return true;
+  const checked = assertVaultPathSafe(vaultBase, join(vaultBase, sessionFileRel), {
+    expectedType: 'file', label: 'nota de sessão encerrada',
+  });
+  if (!checked.exists) return false;
+  return mutateSessionNote(checked.target, (content) => closeSessionNote(content, endedAt), {
+    vaultBase,
+  }).written;
 }
 
 // Marca de sessão ainda aberta no corpo da nota (template do hook de início).

package/hooks/operating-profile-runtime.mjs

@@ -0,0 +1,157 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+import {
+  DEFAULT_OPERATING_PROFILE,
+  normalizeOperatingProfile,
+  operatingProfilePolicy,
+  resolveOperatingProfile,
+} from '../src/operating-profile.mjs';
+import { findProjectBinding, resolveProjectVault } from '../src/project-vault.mjs';
+import { readSessionRegistry } from './obsidian-common.mjs';
+import { resolveSessionIdentity } from './session-identity.mjs';
+
+function bindingDiagnostic(error, configPath = '') {
+  return {
+    code: error?.code || 'WENDKEEP_VAULT_CONFIG_INVALID',
+    message: error?.message
+      || `Configuração WendKeep inválida${configPath ? ` em "${configPath}"` : ''}.`,
+  };
+}
+
+function readResolvedConfig(resolution, suppliedConfig) {
+  if (suppliedConfig && typeof suppliedConfig === 'object' && !Array.isArray(suppliedConfig)) {
+    return { config: suppliedConfig, bindingError: null };
+  }
+  if (resolution?.config && typeof resolution.config === 'object' && !Array.isArray(resolution.config)) {
+    return { config: resolution.config, bindingError: null };
+  }
+  if (!resolution?.configPath || !existsSync(resolution.configPath)) {
+    return { config: {}, bindingError: null };
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(resolution.configPath, 'utf8'));
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      return { config: parsed, bindingError: null };
+    }
+    return {
+      config: {},
+      bindingError: bindingDiagnostic(null, resolution.configPath),
+    };
+  } catch (error) {
+    return {
+      config: {},
+      bindingError: bindingDiagnostic(error, resolution.configPath),
+    };
+  }
+}
+
+function sessionOverride(entry) {
+  if (!entry || !Object.prototype.hasOwnProperty.call(entry, 'operating_profile')) return null;
+  const raw = entry.operating_profile;
+  try {
+    return {
+      profile: normalizeOperatingProfile(raw, { strict: true }),
+      source: 'session-override',
+      valid: true,
+      configured: true,
+      raw,
+    };
+  } catch {
+    return {
+      profile: DEFAULT_OPERATING_PROFILE,
+      source: 'session-override-invalid',
+      valid: false,
+      configured: true,
+      raw,
+    };
+  }
+}
+
+function canonicalPath(value) {
+  const path = resolve(value).replaceAll('\\', '/');
+  return process.platform === 'win32' ? path.toLowerCase() : path;
+}
+
+function matchingProjectBinding(vaultResolution, input) {
+  if (vaultResolution?.config) {
+    return { binding: null, bindingError: vaultResolution.bindingError || null };
+  }
+  if (vaultResolution?.bindingError) {
+    return { binding: null, bindingError: vaultResolution.bindingError };
+  }
+  const start = input?.cwd
+    || input?.project_dir
+    || input?.projectDir
+    || input?.workspace?.cwd
+    || vaultResolution?.projectRoot
+    || process.cwd();
+  try {
+    const binding = findProjectBinding(start);
+    return {
+      binding: binding && canonicalPath(binding.base) === canonicalPath(vaultResolution.base)
+        ? binding
+        : null,
+      bindingError: vaultResolution.bindingError || null,
+    };
+  } catch (error) {
+    // An explicitly supplied vault is authoritative even when an unrelated
+    // nearby project config is malformed, but corruption remains observable.
+    if (input?.obsidian_vault_path
+      || ['explicit', 'payload', 'legacy-project-settings'].includes(vaultResolution?.source)) {
+      return { binding: null, bindingError: bindingDiagnostic(error) };
+    }
+    throw error;
+  }
+}
+
+// Resolution precedence for hooks: explicit session override -> project binding -> GOVERN.
+// Binding corruption is never interpreted as OFF: an authoritative Vault keeps the Keep Core
+// alive under GOVERN and carries a visible diagnostic to each entrypoint.
+export function resolveHookOperatingProfile({
+  input = {},
+  resolution = null,
+  config = null,
+  provider,
+} = {}) {
+  const initialResolution = resolution || resolveProjectVault({ input });
+  const matched = matchingProjectBinding(initialResolution, input);
+  const binding = matched.binding;
+  const vaultResolution = binding ? {
+    ...initialResolution,
+    projectRoot: binding.projectRoot,
+    projectId: binding.config.projectId,
+    configPath: binding.configPath,
+    config: binding.config,
+  } : initialResolution;
+  const configState = readResolvedConfig(vaultResolution, config);
+  const bindingError = initialResolution.bindingError
+    || matched.bindingError
+    || configState.bindingError
+    || null;
+  const project = resolveOperatingProfile(bindingError ? {} : configState.config);
+  const identity = resolveSessionIdentity(vaultResolution.base, input, provider);
+  const entry = identity.state === 'resolved'
+    ? readSessionRegistry(vaultResolution.base).sessions?.[identity.canonicalConversationId] || null
+    : null;
+  const selected = sessionOverride(entry) || project;
+  return {
+    ...selected,
+    policy: operatingProfilePolicy(selected.profile),
+    vaultBase: vaultResolution.base,
+    projectRoot: vaultResolution.projectRoot,
+    identity,
+    entry,
+    resolution: vaultResolution,
+    ...(bindingError ? { bindingError } : {}),
+  };
+}
+
+export function hookProfilePolicy(profile = DEFAULT_OPERATING_PROFILE) {
+  return operatingProfilePolicy(profile);
+}
+
+// Prefix the profile so change-core's 64-char filename cap can never truncate it away.
+export function profileSentinelId(sessionId, profile = DEFAULT_OPERATING_PROFILE) {
+  return `${normalizeOperatingProfile(profile).toLowerCase()}--${sessionId || 'nosession'}`;
+}

package/hooks/plan-capture.mjs

@@ -9,7 +9,6 @@ import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import {
   formatDate,
-  getVaultBase,
   readHookInput,
   slugify,
   upsertSessionRegistry,
@@ -18,6 +17,7 @@ import {
 } from './obsidian-common.mjs';
 import { activeChange, newChange } from './change-core.mjs';
 import { getLocale } from './locale.mjs';
+import { hookProfilePolicy, resolveHookOperatingProfile } from './operating-profile-runtime.mjs';
 import { resolveSessionEntry } from './session-identity.mjs';
 
 // O plano aprovado chega por um de três canais, conforme a versão do Claude Code:
@@ -87,7 +87,9 @@ export function planTasks(plan) {
   return boxes.map((m, i) => `- [${m[1]}] 1.${i + 1} ${m[2].trim()}`);
 }
 
-export function capturePlan(vaultBase, input) {
+export function capturePlan(vaultBase, input, { profile = 'GOVERN' } = {}) {
+  const policy = hookProfilePolicy(profile);
+  if (!policy.harness) return null;
   const plan = extractPlan(input);
   if (!plan) return null;
   const loc = getLocale(vaultBase);
@@ -111,6 +113,10 @@ export function capturePlan(vaultBase, input) {
     };
   }
 
+  // FLOW deliberately has no implicit change lifecycle. It may enrich a change the user
+  // explicitly opened, but an approved plan alone must not create one.
+  if (!policy.requiresChange) return null;
+
   const slug = planSlug(plan);
   newChange(vaultBase, slug, { dateStr, sessionRel });
   upsertSessionRegistry(vaultBase, identity.canonicalConversationId, { change_slug: slug });
@@ -156,7 +162,12 @@ ${en ? 'See design.md and plano-aprovado.md (captured from the approved plan-mod
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   try {
     const input = readHookInput();
-    const r = capturePlan(getVaultBase(input), input);
+    const runtime = resolveHookOperatingProfile({ input });
+    if (runtime.bindingError) {
+      const code = runtime.bindingError.code || 'WENDKEEP_VAULT_CONFIG_INVALID';
+      throw new Error(`${code}: ${runtime.bindingError.message || 'binding WendKeep inválido'}`);
+    }
+    const r = capturePlan(runtime.vaultBase, input, { profile: runtime.profile });
     if (!r) { writeHookOutput({}); }
     else writeHookOutput({ hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: r.context } });
   } catch (error) {

package/hooks/sensors-core.mjs

@@ -5,6 +5,16 @@ import { spawnSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 
+export const SENSOR_VAULT_ENV = 'WENDKEEP_SENSOR_VAULT';
+
+export function sensorProcessEnv(vaultBase, inherited = process.env) {
+  return {
+    ...inherited,
+    OBSIDIAN_VAULT_PATH: vaultBase,
+    [SENSOR_VAULT_ENV]: vaultBase,
+  };
+}
+
 export function loadSensors(projectRoot, file = 'wendkeep.sensors.json') {
   return loadSensorsDetailed(projectRoot, file).sensors;
 }
@@ -37,17 +47,19 @@ export function findProjectRoot(startDir) {
 }
 
 export function requiredSensors(tasks) {
-  return [...new Set((tasks || []).map((t) => t.sensor).filter(Boolean))];
+  return [...new Set((tasks || []).flatMap((task) => (
+    Array.isArray(task.sensors) && task.sensors.length ? task.sensors : [task.sensor]
+  )).filter(Boolean))];
 }
 
-export function runSensors(sensors, ids, { spawn = spawnSync, cwd, now } = {}) {
+export function runSensors(sensors, ids, { spawn = spawnSync, cwd, env, now } = {}) {
   const byId = Object.fromEntries((sensors || []).map((s) => [s.id, s]));
   const ts = now || new Date().toISOString();
   const evidence = [];
   for (const id of ids) {
     const s = byId[id];
     if (!s) { evidence.push({ id, status: 'red', ts, severity: 'critical', note: 'sensor não definido' }); continue; }
-    const r = spawn(s.command, [], { cwd, shell: true, stdio: 'ignore' });
+    const r = spawn(s.command, [], { cwd, shell: true, stdio: 'ignore', ...(env ? { env } : {}) });
     const entry = { id, status: (r.status ?? 1) === 0 ? 'green' : 'red', ts, severity: s.severity || 'critical' };
     if (s.type === 'mutation' && s.report) {
       // Delegated mutation (Wave B): read the tool's mutation-testing-elements report and

package/hooks/session-backfill.mjs

@@ -12,6 +12,7 @@ import {
   readControl,
   readSessionRegistry,
 } from './obsidian-common.mjs';
+import { assertVaultPathSafe } from './vault-path-safety.mjs';
 
 function parseArgs(argv) {
   const args = { write: false, limit: 0, session: '' };
@@ -71,8 +72,11 @@ export function backfillSessions({ vaultBase, write = false, limit = 0, session
     if (args.limit && report.scanned >= args.limit) break;
     report.scanned += 1;
 
-    const sessionPath = join(vaultBase, entry.session_file);
-    if (!existsSync(sessionPath) || !existsSync(entry.transcript_path)) {
+    const checkedSession = assertVaultPathSafe(vaultBase, join(vaultBase, entry.session_file), {
+      expectedType: 'file', label: 'nota de sessão do backfill',
+    });
+    const sessionPath = checkedSession.target;
+    if (!checkedSession.exists || !existsSync(entry.transcript_path)) {
       report.missing.push({
         session: entry.session_file,
         sessionExists: existsSync(sessionPath),
@@ -106,6 +110,7 @@ export function backfillSessions({ vaultBase, write = false, limit = 0, session
           buildIterationBlock(tx, { turn_id: turn.turnId, now: turn.timestamp }),
           turn.turnId,
           tx,
+          vaultBase,
         );
         if (inserted) {
           report.inserted += 1;