wendkeep 0.77.0 → 0.79.0

package/hooks/obsidian-common.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'fs';
 import { LOCK_BUSY, mutateSessionNote, withPathLock } from './session-note-io.mjs';
-import { basename, dirname, join, relative } from 'path';
+import { basename, dirname, join, relative, resolve } from 'path';
 import { getLocale } from './locale.mjs';
 import { resolveProjectVault } from '../src/project-vault.mjs';
 import {
@@ -288,17 +288,183 @@ export function readSessionRegistry(vaultBase) {
   }
 }
 
-export function writeSessionRegistry(vaultBase, registry) {
+function cleanupReservations(registry) {
+  return registry?.cleanup_reservations
+    && typeof registry.cleanup_reservations === 'object'
+    && !Array.isArray(registry.cleanup_reservations)
+    ? registry.cleanup_reservations : {};
+}
+
+function cleanupTombstones(registry) {
+  return registry?.cleanup_tombstones
+    && typeof registry.cleanup_tombstones === 'object'
+    && !Array.isArray(registry.cleanup_tombstones)
+    ? registry.cleanup_tombstones : {};
+}
+
+export function comparableCleanupPath(value) {
+  const raw = String(value || '').trim().replaceAll('\\', '/').replace(/\/+$/, '');
+  const normalized = raw ? resolve(raw).replaceAll('\\', '/') : '';
+  return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+
+function sessionsForCleanupReservation(registry, reservation) {
+  const workSessionId = String(reservation?.work_session_id || '');
+  const worktreePath = comparableCleanupPath(reservation?.worktree_path);
+  return Object.entries(registry?.sessions || {})
+    .filter(([, session]) => {
+      if (session?.status !== 'active') return false;
+      const sameSession = workSessionId && String(session.work_session_id || '') === workSessionId;
+      const samePath = worktreePath && comparableCleanupPath(session?.project_scope?.repoRoot) === worktreePath;
+      return sameSession || samePath;
+    })
+    .map(([key, session]) => [String(key), structuredClone(session)])
+    .sort(([left], [right]) => left.localeCompare(right));
+}
+
+export function cleanupReservationForWorktree(registry, worktreeId, repositoryId = '') {
+  const key = String(worktreeId || '').trim();
+  const repository = String(repositoryId || '').trim();
+  const reservations = cleanupReservations(registry);
+  const composite = repository ? `${repository}:${key}` : '';
+  const reservation = (composite && reservations[composite])
+    || reservations[key]
+    || (!repository
+      ? Object.values(reservations).find((item) => String(item?.worktree_id || '') === key)
+      : null);
+  return reservation?.state === 'cleaning' ? reservation : null;
+}
+
+export function cleanupTombstoneForWorktree(registry, worktreeId, repositoryId = '') {
+  const key = String(worktreeId || '').trim();
+  const repository = String(repositoryId || '').trim();
+  const tombstones = cleanupTombstones(registry);
+  const composite = repository ? `${repository}:${key}` : '';
+  const tombstone = (composite && tombstones[composite])
+    || tombstones[key]
+    || (!repository
+      ? Object.values(tombstones).find((item) => String(item?.worktree_id || '') === key)
+      : null);
+  return tombstone?.state === 'cleaned' ? tombstone : null;
+}
+
+function activeContextsForCleanupWorktree(registry, worktreeId) {
+  return Object.entries(registry?.active_contexts || {})
+    .filter(([, context]) => context?.state === 'active'
+      && String(context?.worktree_id || '') === String(worktreeId || ''));
+}
+
+export function assertCleanupReservationMutation(previous, next, cleanupOperationId = '') {
+  const reservations = cleanupReservations(previous);
+  const operationId = String(cleanupOperationId || '');
+  for (const [worktreeId, reservation] of Object.entries(reservations)) {
+    if (reservation?.state !== 'cleaning') continue;
+    const reservedWorktreeId = String(reservation?.worktree_id || worktreeId);
+    const repositoryId = String(reservation?.repository_id || '');
+    const before = activeContextsForCleanupWorktree(previous, reservedWorktreeId);
+    const after = activeContextsForCleanupWorktree(next, reservedWorktreeId);
+    const contextsChanged = JSON.stringify(before) !== JSON.stringify(after);
+    const sessionsChanged = JSON.stringify(
+      sessionsForCleanupReservation(previous, reservation),
+    ) !== JSON.stringify(sessionsForCleanupReservation(next, reservation));
+    const nextReservation = cleanupReservations(next)[worktreeId];
+    const reservationChanged = JSON.stringify(reservation) !== JSON.stringify(nextReservation);
+    if ((contextsChanged || sessionsChanged || reservationChanged)
+      && operationId !== String(reservation.operation_id || '')) {
+      const error = new Error('active context está reservado por um cleanup em andamento');
+      error.code = 'WENDKEEP_ACTIVE_CONTEXT_CLEANUP_RESERVED';
+      throw error;
+    }
+  }
+}
+
+export function assertCleanupTombstoneMutation(previous, next, cleanupOperationId = '') {
+  const operationId = String(cleanupOperationId || '');
+  const nextTombstones = cleanupTombstones(next);
+  for (const [worktreeId, tombstone] of Object.entries(cleanupTombstones(previous))) {
+    if (tombstone?.state !== 'cleaned') continue;
+    const reservedWorktreeId = String(tombstone?.worktree_id || worktreeId);
+    const before = activeContextsForCleanupWorktree(previous, reservedWorktreeId);
+    const after = activeContextsForCleanupWorktree(next, reservedWorktreeId);
+    const sessionsChanged = JSON.stringify(
+      sessionsForCleanupReservation(previous, tombstone),
+    ) !== JSON.stringify(sessionsForCleanupReservation(next, tombstone));
+    const nextTombstone = nextTombstones[worktreeId];
+    const tombstoneChanged = JSON.stringify(tombstone) !== JSON.stringify(nextTombstone);
+    const sameTerminalSubject = nextTombstone
+      && String(nextTombstone.state || '') === 'cleaned'
+      && String(nextTombstone.operation_id || '') === String(tombstone.operation_id || '')
+      && String(nextTombstone.project_id || '') === String(tombstone.project_id || '')
+      && String(nextTombstone.repository_id || '') === String(tombstone.repository_id || '')
+      && String(nextTombstone.worktree_id || '') === String(tombstone.worktree_id || '')
+      && String(nextTombstone.work_session_id || '') === String(tombstone.work_session_id || '')
+      && String(nextTombstone.change_slug || '') === String(tombstone.change_slug || '')
+      && JSON.stringify(nextTombstone.target_context_ids || [])
+        === JSON.stringify(tombstone.target_context_ids || [])
+      && JSON.stringify(nextTombstone.target_change_slugs || [])
+        === JSON.stringify(tombstone.target_change_slugs || [])
+      && JSON.stringify(nextTombstone.target_context_snapshot || [])
+        === JSON.stringify(tombstone.target_context_snapshot || [])
+      && String(nextTombstone.worktree_path || '') === String(tombstone.worktree_path || '')
+      && String(nextTombstone.actor_context_id || '') === String(tombstone.actor_context_id || '')
+      && String(nextTombstone.mode || '') === String(tombstone.mode || '')
+      && String(nextTombstone.authority || '') === String(tombstone.authority || '')
+      && String(nextTombstone.head || '') === String(tombstone.head || '')
+      && String(nextTombstone.slug || '') === String(tombstone.slug || '')
+      && String(nextTombstone.pull_request_number || '') === String(tombstone.pull_request_number || '')
+      && String(nextTombstone.pull_request_repository || '') === String(tombstone.pull_request_repository || '')
+      && String(nextTombstone.head_ref_oid || '') === String(tombstone.head_ref_oid || '')
+      && String(nextTombstone.merge_commit_oid || '') === String(tombstone.merge_commit_oid || '')
+      && String(nextTombstone.subject_hash || '') === String(tombstone.subject_hash || '');
+    const nextReservation = next?.cleanup_reservations?.[
+      `${String(tombstone.repository_id || '')}:${String(tombstone.worktree_id || '')}`
+    ];
+    const adoptedTerminalIdentity = sameTerminalSubject
+      && String(nextTombstone.attempt_token || '')
+      && String(nextTombstone.attempt_token || '') !== String(tombstone.attempt_token || '')
+      && nextReservation
+      && String(nextReservation.operation_id || '') === String(tombstone.operation_id || '')
+      && String(nextReservation.attempt_token || '') === String(nextTombstone.attempt_token || '');
+    const sameTerminalIdentity = (sameTerminalSubject
+      && String(nextTombstone.attempt_token || '') === String(tombstone.attempt_token || ''))
+      || adoptedTerminalIdentity;
+    if ((JSON.stringify(before) !== JSON.stringify(after) || sessionsChanged
+      || tombstoneChanged)
+      && (!sameTerminalIdentity || operationId !== String(tombstone.operation_id || ''))) {
+      const error = new Error('worktree cleaned permanece sob tombstone terminal');
+      error.code = 'WENDKEEP_ACTIVE_CONTEXT_CLEANUP_TERMINAL';
+      throw error;
+    }
+  }
+}
+
+export function writeSessionRegistry(vaultBase, registry, {
+  cleanupOperationId = '', timeoutMs = 2000, locked = false,
+} = {}) {
   const path = registryPath(vaultBase);
+  const write = () => {
+    const previous = readSessionRegistry(vaultBase);
+    assertCleanupReservationMutation(previous, registry, cleanupOperationId);
+    assertCleanupTombstoneMutation(previous, registry, cleanupOperationId);
+    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.
+    writeVaultFileAtomic(vaultBase, path, `${JSON.stringify(registry, null, 2)}\n`, 'utf-8', {
+      label: 'SESSION_REGISTRY.json',
+    });
+  };
+  if (locked) return write();
   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.
-  writeVaultFileAtomic(vaultBase, path, `${JSON.stringify(registry, null, 2)}\n`, 'utf-8', {
-    label: 'SESSION_REGISTRY.json',
-  });
+  const outcome = withPathLock(path, write, { timeoutMs, vaultBase });
+  if (outcome === LOCK_BUSY) {
+    throw new Error('SESSION_REGISTRY lock indisponível: lock ocupado até o timeout.');
+  }
+  return outcome;
 }
 
-export function mutateSessionRegistry(vaultBase, mutator, { timeoutMs = 2000 } = {}) {
+export function mutateSessionRegistry(vaultBase, mutator, {
+  timeoutMs = 2000, cleanupOperationId = '',
+} = {}) {
   const path = registryPath(vaultBase);
   mkdirVaultPath(vaultBase, dirname(path), { label: 'diretório do SESSION_REGISTRY' });
   const outcome = withPathLock(path, () => {
@@ -307,7 +473,7 @@ export function mutateSessionRegistry(vaultBase, mutator, { timeoutMs = 2000 } =
     registry.version = 2;
     const result = mutator(registry);
     if (JSON.stringify(registry) !== before) {
-      writeSessionRegistry(vaultBase, registry);
+      writeSessionRegistry(vaultBase, registry, { cleanupOperationId, locked: true });
     }
     return result;
   }, { timeoutMs, vaultBase });

package/hooks/spec-core.mjs

@@ -1,16 +1,17 @@
 // hooks/spec-core.mjs — living spec (07-Specs) + change delta merge (OpenSpec native).
-// Pure parsing/merge + promoteSpecs (fs). No import from change-core (avoids a cycle).
-import { createHash } from 'node:crypto';
+// Pure parsing/merge + read-only promotion planning. No import from change-core (avoids a cycle).
+import { createHash, randomUUID } from 'node:crypto';
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, relative } from 'node:path';
 import { getLocale } from './locale.mjs';
 import {
-  assertVaultPathSafe, assertVaultPathsSafe, mkdirVaultPath, writeVaultFileSync,
+  assertVaultPathSafe, assertVaultPathsSafe, mkdirVaultPath,
+  writeVaultFileAtomic, writeVaultFileSync,
 } from './vault-path-safety.mjs';
 
-// Short stable fingerprint of tarefas.md — freshness check between package/verdict and gate.
+// Canonical SHA-256 fingerprint of tarefas.md — freshness binding between package/verdict and gate.
 export function tasksHashOf(md) {
-  return createHash('sha1').update(String(md)).digest('hex').slice(0, 12);
+  return `sha256:${createHash('sha256').update(String(md).replace(/\r\n?/g, '\n')).digest('hex')}`;
 }
 
 export function contentHashOf(value) {
@@ -148,9 +149,20 @@ export function checkSpecsState(vaultBase) {
   return { ok: changed.length === 0, missing: false, changed, current, recorded };
 }
 
-function recordPromotedSpecs(vaultBase, capabilities) {
+function recordPromotedSpecs(vaultBase, capabilities, { writeAtomic = writeVaultFileSync } = {}) {
   const existing = readSpecsState(vaultBase);
-  if (!existing) return adoptSpecsState(vaultBase);
+  if (!existing) {
+    const state = { version: 1, generatedAt: new Date().toISOString(), specs: readLivingSpecs(vaultBase) };
+    mkdirVaultPath(vaultBase, join(vaultBase, '.brain'), { label: 'raiz do estado de specs' });
+    writeAtomic(
+      vaultBase,
+      join(vaultBase, SPECS_STATE_FILE),
+      `${JSON.stringify(state, null, 2)}\n`,
+      'utf8',
+      { label: 'estado consolidado de specs' },
+    );
+    return state;
+  }
   const current = readLivingSpecs(vaultBase);
   const specs = { ...(existing.specs || {}) };
   for (const capability of capabilities) {
@@ -158,7 +170,7 @@ function recordPromotedSpecs(vaultBase, capabilities) {
     else delete specs[capability];
   }
   const state = { version: 1, generatedAt: new Date().toISOString(), specs };
-  writeVaultFileSync(
+  writeAtomic(
     vaultBase,
     join(vaultBase, SPECS_STATE_FILE),
     `${JSON.stringify(state, null, 2)}\n`,
@@ -168,7 +180,11 @@ function recordPromotedSpecs(vaultBase, capabilities) {
   return state;
 }
 
-export function captureSpecBaseline(vaultBase, changeDir, { refresh = false } = {}) {
+export function captureSpecBaseline(vaultBase, changeDir, {
+  refresh = false,
+  writeAtomic = writeVaultFileAtomic,
+  beforeRename,
+} = {}) {
   const path = join(changeDir, SPEC_BASELINE_FILE);
   const checked = assertVaultPathSafe(vaultBase, path, {
     expectedType: 'file', label: 'baseline de specs da change',
@@ -177,12 +193,12 @@ export function captureSpecBaseline(vaultBase, changeDir, { refresh = false } =
     try { return JSON.parse(readFileSync(path, 'utf8')); } catch { /* rebuild malformed baseline */ }
   }
   const baseline = { version: 1, capturedAt: new Date().toISOString(), specs: readLivingSpecs(vaultBase) };
-  writeVaultFileSync(
+  writeAtomic(
     vaultBase,
     path,
     `${JSON.stringify(baseline, null, 2)}\n`,
     'utf8',
-    { label: 'baseline de specs da change' },
+    { scopeRoot: changeDir, label: 'baseline de specs da change', beforeRename },
   );
   return baseline;
 }
@@ -344,12 +360,10 @@ export function discoverSpecDeltas(changeDir) {
 // per-change (many changes promote into the same file; the per-change record lives in
 // _arquivo). Generated + read-only. Written on init and refreshed on every archive so
 // existing vaults self-heal. Bilingual by vault locale.
-export function ensureSpecsReadme(vaultBase) {
+function specsReadmeBody(vaultBase) {
   const loc = getLocale(vaultBase);
   const en = loc.id === 'en';
-  const dir = join(vaultBase, loc.folders.specs);
-  mkdirVaultPath(vaultBase, dir, { label: 'raiz de specs consolidadas' });
-  const body = en
+  return en
     ? `# Specs — generated living contract
 
 **One file per _capability_, not per change.** Each file is the current, cumulative contract
@@ -378,7 +392,18 @@ Pense como código-fonte vs commits: esta pasta é o *código atual* de cada cap
   \`wendkeep change archive\` promove para esta pasta.
 - Histórico por mudança → \`${loc.folders.changes}/_arquivo/\`. Contrato atual → aqui.
 `;
-  writeVaultFileSync(vaultBase, join(dir, 'README.md'), body, 'utf8', { label: 'README de specs' });
+}
+
+export function renderSpecsReadme(vaultBase) {
+  return specsReadmeBody(vaultBase);
+}
+
+export function ensureSpecsReadme(vaultBase, { writeAtomic = writeVaultFileSync } = {}) {
+  const loc = getLocale(vaultBase);
+  const dir = join(vaultBase, loc.folders.specs);
+  mkdirVaultPath(vaultBase, dir, { label: 'raiz de specs consolidadas' });
+  const body = specsReadmeBody(vaultBase);
+  writeAtomic(vaultBase, join(dir, 'README.md'), body, 'utf8', { label: 'README de specs' });
 }
 
 export function assertSpecPromotionTargetsSafe(vaultBase, changeDir, specs) {
@@ -422,8 +447,14 @@ export function assertSpecPromotionTargetsSafe(vaultBase, changeDir, specs) {
   return { specsRoot: checkedRoot.target };
 }
 
-// Merge each capability's delta (in the change) into the living spec in 07-Specs.
-export function promoteSpecs(vaultBase, changeDir, specs, { changeWikilink, dateStr } = {}) {
+// Derive the immutable before/postimage plan used by the archive CLI. This helper
+// is deliberately read-only: publication is private to src/change.mjs, after the
+// provenance gate, receipt, recapture, and operation lock have all succeeded.
+export function buildSpecPromotionPlan(vaultBase, changeDir, specs, {
+  changeWikilink,
+  dateStr,
+  recoveryRoot,
+} = {}) {
   const loc = getLocale(vaultBase);
   const specsDir = loc.folders.specs;
   const promoted = [];
@@ -455,29 +486,80 @@ export function promoteSpecs(vaultBase, changeDir, specs, { changeWikilink, date
       content: renderSpec(cap, applied.reqs, { footer, reqHeading: loc.reqHeading }),
     });
   }
-  mkdirVaultPath(vaultBase, specsRoot, { label: 'raiz de specs consolidadas' });
+  const statePath = join(vaultBase, SPECS_STATE_FILE);
+  const readmePath = join(specsRoot, 'README.md');
+  const existingState = readSpecsState(vaultBase);
+  const nextSpecs = existingState ? { ...(existingState.specs || {}) } : readLivingSpecs(vaultBase);
   for (const item of materialized) {
-    writeVaultFileSync(
-      vaultBase,
-      item.livePath,
-      item.content,
-      'utf8',
-      { label: `spec consolidada ${item.capability}` },
-    );
-    promoted.push(item.capability);
+    nextSpecs[item.capability] = {
+      hash: contentHashOf(item.content),
+      requirements: Object.fromEntries(parseRequirements(item.content)
+        .map((requirement) => [requirement.id || requirement.name, contentHashOf(JSON.stringify(requirement))])),
+    };
   }
-  recordPromotedSpecs(vaultBase, promoted);
-  ensureSpecsReadme(vaultBase); // self-heal the explainer so existing vaults get it on archive
-  return { promoted, warnings };
+  const stateContent = `${JSON.stringify({
+    version: 1,
+    generatedAt: new Date().toISOString(),
+    specs: nextSpecs,
+  }, null, 2)}\n`;
+  const planned = [
+    ...materialized.map((item) => ({
+      kind: 'capability', capability: item.capability, path: item.livePath, content: item.content,
+    })),
+    { kind: 'state', path: statePath, content: stateContent },
+    { kind: 'readme', path: readmePath, content: specsReadmeBody(vaultBase) },
+  ];
+  const image = (content, exists = true) => ({
+    exists,
+    content_base64: Buffer.from(content, 'utf8').toString('base64'),
+    digest: `sha256:${contentHashOf(content)}`,
+  });
+  const promotionRecoveryRoot = recoveryRoot
+    || join(vaultBase, '.brain', 'runtime', 'spec-promotion-plans', randomUUID());
+  const plan = {
+    schema_version: 1,
+    entries: planned.map((entry, index) => {
+      const beforeExists = existsSync(entry.path);
+      const beforeContent = beforeExists ? readFileSync(entry.path, 'utf8') : '';
+      return {
+        kind: entry.kind,
+        capability: entry.capability || null,
+        target: relative(vaultBase, entry.path).replaceAll('\\', '/'),
+        claim_target: relative(vaultBase, join(promotionRecoveryRoot, `${index}-${randomUUID()}.before`)).replaceAll('\\', '/'),
+        candidate_target: relative(vaultBase, join(promotionRecoveryRoot, `${index}-${randomUUID()}.candidate`)).replaceAll('\\', '/'),
+        before: image(beforeContent, beforeExists),
+        after: image(entry.content, true),
+      };
+    }),
+  };
+  const changes = materialized.map((item) => ({
+    capability: item.capability,
+    before_digest: plan.entries.find((entry) => entry.capability === item.capability).before.digest,
+    after_digest: `sha256:${contentHashOf(item.content)}`,
+  }));
+  plan.changes = changes;
+  promoted.push(...materialized.map((item) => item.capability));
+  return { promoted, warnings, changes, plan };
 }
 
-// Gate check for the independent verdict (Wave A). A requirement-bearing change must have
-// a verdict that is ok and covers every declared req id. A requirement-less change passes:
-// nothing for an independent verifier to check — the sensor gate is already the proof.
-export function evaluateVerdict(verdict, reqIds, { tasksHash, effectiveSpecHash } = {}) {
+export function evaluateVerdict(verdict, reqIds, {
+  tasksHash,
+  effectiveSpecHash,
+  evidenceEnvelopeId,
+  evidenceBinding,
+} = {}) {
   const ids = reqIds || [];
-  if (ids.length === 0) return { ok: true, missing: [] };
+  if (ids.length === 0 && !evidenceEnvelopeId) return { ok: true, missing: [] };
   if (!verdict || verdict.ok !== true) return { ok: false, missing: [] };
+  if (evidenceEnvelopeId && verdict.evidenceEnvelopeId !== evidenceEnvelopeId) {
+    return { ok: false, missing: [], stale: true };
+  }
+  if (evidenceBinding && (!verdict.evidenceBinding || Object.entries(evidenceBinding).some(
+    ([key, value]) => verdict.evidenceBinding[key] !== value,
+  ))) {
+    return { ok: false, missing: [], stale: true };
+  }
+  if (ids.length === 0) return { ok: true, missing: [] };
   // Freshness (G3/#6): a verdict minted against a different tarefas.md is stale. Verdicts
   // without a hash (pre-0.6.1) are accepted for backward compat.
   if (tasksHash && verdict.tasksHash && verdict.tasksHash !== tasksHash) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.77.0",
+  "version": "0.79.0",
   "description": "Vault-first persistent memory for AI coding agents, with an optional profile-aware governance runtime: OFF, FLOW, GUIDE, GOVERN, or ASSURE. Local-first and agent-agnostic (Claude Code, Codex, Cursor…).",
   "type": "module",
   "workspaces": [
@@ -41,7 +41,7 @@
     "node": ">=18"
   },
   "scripts": {
-    "precheck": "node --check src/worktree.mjs && node --check src/worktree-cleanup.mjs && node --check src/context.mjs && node --check src/active-context-health.mjs && node --check src/active-context-runtime.mjs && node --check hooks/active-context-store.mjs && node --check hooks/change-core.mjs && node --check hooks/brain-inject.mjs && node --check hooks/change-context.mjs && node --check packages/vault/src/worktree-metadata.mjs",
+    "precheck": "node --check src/change.mjs && node --check src/archive-operation-lock.mjs && node --check src/worktree.mjs && node --check src/worktree-cleanup.mjs && node --check src/provenance-gate.mjs && node --check src/provenance-sources.mjs && node --check src/receipt-ledger.mjs && node --check src/evidence-envelope.mjs && node --check src/context.mjs && node --check src/active-context-health.mjs && node --check src/active-context-runtime.mjs && node --check hooks/active-context-store.mjs && node --check hooks/change-core.mjs && node --check hooks/brain-inject.mjs && node --check hooks/change-context.mjs && node --check packages/vault/src/worktree-metadata.mjs && node --check packages/vault/src/evidence-envelope.mjs",
     "check": "node --check scripts/release.mjs && node --check scripts/release-plan.mjs && node --check scripts/release-provenance.mjs && node --check scripts/run-scope.mjs && node --check src/release-provenance.mjs && node --check bin/wendkeep.mjs && node --check packages/cli/src/index.mjs && node --check src/init.mjs && node --check src/doctor.mjs && node --check src/active-context-health.mjs && node --check src/project-vault.mjs && node --check src/observer-auth.mjs && node --check src/observer-privacy.mjs && node --check src/observer-snapshot.mjs && node --check src/observer-store.mjs && node --check src/observer-memory.mjs && node --check src/observer-memory-publish.mjs && node --check src/observer-sql-store.mjs && node --check src/observer-sql-migrate.mjs && node --check src/observer-sql-publish.mjs && node --check src/observer-transcript-store.mjs && node --check src/observer-server.mjs && node --check src/observer.mjs && node --check src/observer-publish.mjs && node --check src/operating-profile.mjs && node --check src/profile.mjs && node --check src/flow.mjs && node --check src/work-kind.mjs && node --check src/delivery.mjs && node --check web/observer/app.mjs && node --check hooks/observer-publish.mjs && node --check hooks/evidence-context.mjs && node --check hooks/active-context-handoff-evidence.mjs && node --check hooks/evidence-recall.mjs && node --check hooks/memory-scope.mjs && node --check hooks/operating-profile-runtime.mjs && node --check hooks/operating-profile-task-store.mjs && node --check hooks/flow-core.mjs && node --check hooks/flow-protected-policy.mjs && node --check hooks/git-snapshot.mjs && node --check hooks/vault-path-safety.mjs && node --check hooks/vault-runtime-store.mjs && node --check packages/harness/src/index.mjs && node --check packages/harness/src/flow-store.mjs && node --check packages/harness/src/operating-profile.mjs && node --check packages/harness/src/sensors-core.mjs && node --check packages/integrations/src/host-hooks.mjs && node --check packages/integrations/src/hook-envelope.mjs && node --check packages/integrations/src/prompt-content.mjs && node --check packages/integrations/src/transcript-usage.mjs && node --check packages/integrations/src/transcripts.mjs && node --check packages/integrations/src/session-identity.mjs && node --check packages/integrations/src/index.mjs && node --check packages/mcp/src/config.mjs && node --check packages/mcp/src/index.mjs && node --check packages/vault/src/index.mjs && node --check packages/vault/src/project-vault.mjs && node --check packages/vault/src/vault-path-safety.mjs && node --check packages/vault/src/locale.mjs && node --check packages/vault/src/memory-schema.mjs && node --check packages/vault/src/memory-mode.mjs && node --check packages/vault/src/memory-scope.mjs && node --check packages/vault/src/memory-candidate-policy.mjs && node --check packages/vault/src/evidence-recall.mjs && node --check packages/vault/src/memory-handoff.mjs && node --check packages/vault/src/memory-store.mjs && node --check packages/vault/src/validate-core.mjs && node --check packages/vault/src/validate-memory.mjs",
     "test": "node --test --test-concurrency=2",
     "test:core": "node scripts/run-scope.mjs core",

package/packages/harness/src/sensors-core.mjs

@@ -2,6 +2,7 @@
 // Pure-ish: `spawn` is injectable so runs are testable without a shell. Config lives
 // at the PROJECT ROOT (wendkeep.sensors.json); evidence lives per-change in the vault.
 import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 
@@ -22,6 +23,22 @@ function sanitizeSensorDiagnostic(value) {
     .trim();
 }
 
+function sha256(value) {
+  return `sha256:${createHash('sha256').update(String(value || '')).digest('hex')}`;
+}
+
+function sensorNow(now) {
+  const value = typeof now === 'function' ? now() : (now || new Date().toISOString());
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === 'string') return value;
+  return new Date(value).toISOString();
+}
+
+function elapsedMilliseconds(startedAt, finishedAt) {
+  const elapsed = Date.parse(finishedAt) - Date.parse(startedAt);
+  return Number.isFinite(elapsed) ? Math.max(0, elapsed) : 0;
+}
+
 function sensorFailureNote(result = {}) {
   const status = result.status ?? 'null';
   const header = [
@@ -86,11 +103,29 @@ export function requiredSensors(tasks) {
 
 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 startedAt = sensorNow(now);
     const s = byId[id];
-    if (!s) { evidence.push({ id, status: 'red', ts, severity: 'critical', note: 'sensor não definido' }); continue; }
+    if (!s) {
+      const finishedAt = sensorNow(now);
+      evidence.push({
+        id,
+        status: 'red',
+        ts: startedAt,
+        severity: 'critical',
+        started_at: startedAt,
+        finished_at: finishedAt,
+        duration_ms: elapsedMilliseconds(startedAt, finishedAt),
+        exit_code: null,
+        command: '',
+        command_sha256: sha256(''),
+        output_sha256: sha256(''),
+        output_tail: '',
+        note: 'sensor não definido',
+      });
+      continue;
+    }
     const r = spawn(s.command, [], {
       cwd,
       shell: true,
@@ -99,7 +134,26 @@ export function runSensors(sensors, ids, { spawn = spawnSync, cwd, env, now } =
       stdio: ['ignore', 'pipe', 'pipe'],
       ...(env ? { env } : {}),
     });
-    const entry = { id, status: (r.status ?? 1) === 0 ? 'green' : 'red', ts, severity: s.severity || 'critical' };
+    const finishedAt = sensorNow(now);
+    const rawOutput = [r.stdout, r.stderr].filter(Boolean).join('\n');
+    const outputTail = sanitizeSensorDiagnostic(rawOutput);
+    const boundedOutputTail = outputTail.length > SENSOR_DIAGNOSTIC_MAX_LENGTH
+      ? `…${outputTail.slice(-(SENSOR_DIAGNOSTIC_MAX_LENGTH - 1))}`
+      : outputTail;
+    const entry = {
+      id,
+      status: (r.status ?? 1) === 0 ? 'green' : 'red',
+      ts: startedAt,
+      severity: s.severity || 'critical',
+      command: sanitizeSensorDiagnostic(s.command),
+      command_sha256: sha256(s.command),
+      started_at: startedAt,
+      finished_at: finishedAt,
+      duration_ms: elapsedMilliseconds(startedAt, finishedAt),
+      exit_code: Number.isInteger(r.status) ? r.status : null,
+      output_sha256: sha256(rawOutput),
+      output_tail: boundedOutputTail,
+    };
     if (entry.status === 'red') entry.note = sensorFailureNote(r);
     if (s.type === 'mutation' && s.report) {
       // Delegated mutation (Wave B): read the tool's mutation-testing-elements report and

package/packages/vault/src/evidence-envelope.mjs

@@ -0,0 +1,73 @@
+import { createHash } from 'node:crypto';
+
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (value && typeof value === 'object' && !Buffer.isBuffer(value)) {
+    return Object.fromEntries(
+      Object.keys(value).sort().map((key) => [key, stableValue(value[key])]),
+    );
+  }
+  return value;
+}
+
+export function canonicalSha256(value) {
+  const bytes = Buffer.isBuffer(value) || value instanceof Uint8Array
+    ? value
+    : JSON.stringify(stableValue(value));
+  return `sha256:${createHash('sha256').update(bytes).digest('hex')}`;
+}
+
+export function evidenceSensors(evidence) {
+  if (Array.isArray(evidence)) return evidence;
+  return Array.isArray(evidence?.sensors) ? evidence.sensors : [];
+}
+
+const CHECKOUT_BINDING_KEYS = [
+  'project_id', 'repository_id', 'worktree_id', 'head_sha', 'index_tree_sha', 'worktree_digest',
+];
+
+export function evidenceCheckoutBinding(evidence = {}) {
+  return Object.fromEntries(CHECKOUT_BINDING_KEYS.map((key) => [key, evidence[key]]));
+}
+
+export function evidenceCheckoutBindingMatches(actual, expected) {
+  return Boolean(actual && expected) && CHECKOUT_BINDING_KEYS.every(
+    (key) => actual[key] === expected[key] && expected[key] != null,
+  );
+}
+
+export function evaluateEvidenceBinding(evidence, expected = {}) {
+  if (!evidence) return { state: 'unproven', reasons: ['evidence missing'] };
+  if (Array.isArray(evidence) || evidence.schema_version !== 2) {
+    return { state: 'legacy-unbound', reasons: ['evidence schema v1 has no checkout binding'] };
+  }
+
+  const contextReasons = [];
+  if (expected.change_slug != null && evidence.change_slug !== expected.change_slug) {
+    contextReasons.push('change_slug mismatch');
+  }
+  for (const key of ['project_id', 'repository_id', 'worktree_id', 'work_session_id']) {
+    if (expected.identity?.[key] != null && evidence[key] !== expected.identity[key]) {
+      contextReasons.push(`${key} mismatch`);
+    }
+  }
+  if (contextReasons.length) return { state: 'context-mismatch', reasons: contextReasons };
+
+  const staleReasons = [];
+  const unsigned = { ...evidence };
+  delete unsigned.envelope_id;
+  if (!evidence.envelope_id || canonicalSha256(unsigned) !== evidence.envelope_id) {
+    staleReasons.push('envelope_id invalid');
+  }
+  for (const key of ['branch', 'base_sha', 'head_sha', 'index_tree_sha', 'worktree_digest', 'dirty']) {
+    if (expected.snapshot?.[key] != null && evidence[key] !== expected.snapshot[key]) {
+      staleReasons.push(`${key} changed`);
+    }
+  }
+  for (const key of ['tasks_sha256', 'effective_spec_sha256', 'sensor_config_sha256']) {
+    if (expected[key] != null && evidence[key] !== expected[key]) staleReasons.push(`${key} changed`);
+  }
+  return staleReasons.length
+    ? { state: 'stale', reasons: staleReasons }
+    : { state: 'bound', reasons: [] };
+}

package/packages/vault/src/index.mjs

@@ -8,5 +8,6 @@ export * from './memory-handoff.mjs';
 export * from './memory-store.mjs';
 export * from './memory-scope.mjs';
 export * from './evidence-recall.mjs';
+export * from './evidence-envelope.mjs';
 export * from './validate-core.mjs';
 export * from './validate-memory.mjs';