wendkeep 0.77.0 → 0.78.0

package/CHANGELOG.md

@@ -4,6 +4,29 @@ All notable changes to **wendkeep** are documented here. Format based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this project follows
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.78.0] — 2026-08-22
+
+### Added
+
+- **Evidence Envelope v2.** `verify` liga cada prova a projeto, repositório, worktree, work session,
+  branch, base/HEAD, árvore do índice e digest determinístico de staged/unstaged/untracked por
+  SHA-256 canônico; texto normaliza CRLF/CR para LF e binários preservam bytes.
+- **Proveniência por sensor.** Cada resultado registra comando efetivo sanitizado e hash,
+  timestamps, duração, exit code, digest da saída e tail sanitizado limitado; alteração da
+  configuração invalida o binding anterior.
+- **Diagnóstico causal.** `change status`, doctor, handoff e Observer distinguem evidência `bound`,
+  `stale`, `context-mismatch` e `legacy-unbound`; pacote deep e verdict carregam o mesmo
+  `evidenceEnvelopeId` e `evidenceBinding` completo e não podem ser reutilizados entre worktrees.
+
+### Changed
+
+- **Publicação fail-closed.** Mudança de HEAD durante os sensores preserva a evidência anterior e
+  retorna `WENDKEEP_EVIDENCE_HEAD_CHANGED`. Evidência, pacote, verdict trivial e seals são gravados
+  por temporário path-safe no mesmo diretório e rename atômico.
+- **Compatibilidade explícita.** Evidência v1 continua legível para histórico, mas sensores v1 não
+  satisfazem autoridade v2 no archive. README, schema e guias PT-BR/EN documentam formato,
+  normalização, recovery e vínculo do passe independente.
+
 ## [0.77.0] — 2026-08-22
 
 ### Added

package/README.en.md

@@ -531,7 +531,7 @@ explore → propose → apply (TDD) → verify → archive
 
 - **Propose** — `wendkeep change new <slug>` scaffolds `08-Mudanças/<slug>/` (`proposta.md`, `design.md`, `tarefas.md`; `--simple` skips the design). `--guide` creates the compact GUIDE contract and omits automatic design/spec/ADR when `contract_impact:none`. It becomes the global *current* change. When the change declares `spec_impact: required`, you author the delta yourself at `specs/<capability>/spec.md` — there is no placeholder to delete. Multiple changes may remain open: `change list`/`status` and the hooks show every pending one, while commands without `--change` act on the current one alone. `change use <slug>` changes focus and `change continue <archived> <new>` creates an auditable continuation.
 - **Apply** — implement each `tarefas.md` task. Mark machine proof with one or more `[sensor:<id>]` tags on the same task: every distinct ID enters the gate once, in declaration order. Also mark satisfied requirements with one or more `[req:<ID>]` tags.
-- **Verify** — `wendkeep verify` runs the sensors your tasks declared (from `wendkeep.sensors.json` at the project root) and writes `evidencia.json`. A red `critical` fails the gate; a red `warning` is advisory. Failures retain only a bounded, sanitized diagnostic; green output is not persisted. `verify --deep` builds a self-contained package with complete effective requirements (living contract + this change's delta), so the independent verifier never needs to reconstruct unarchived requirements from `07-Specs`. Every change needs a `verdict.json` to archive; `verify --deep` writes a trivial one automatically when the change declares no `[req:]`.
+- **Verify** — `wendkeep verify` runs declared sensors and writes an **Evidence Envelope v2** to `evidencia.json`, SHA-256-bound to project/repository/worktree/session, HEAD, index tree, normalized worktree digest, tasks, effective spec, and sensor configuration. Each sensor records a sanitized command, execution window, duration, exit code, output digest, and a sanitized tail bounded to 2,000 characters. If HEAD changes during the run, no new envelope is published. `change status` reports `bound`, `stale`, `context-mismatch`, or `legacy-unbound`; v1 evidence remains readable but cannot satisfy v2 authority. The public schema is [`schema/wendkeep.evidence-envelope-v2.schema.json`](schema/wendkeep.evidence-envelope-v2.schema.json). `verify --deep` binds both package and verdict to the current `envelope_id`.
 - **Archive** — `wendkeep change archive <slug>` **gates** on the evidence (blocks unless every declared critical sensor is green), promotes each applicable spec delta (`ADDED`/`MODIFIED`/`REMOVED`) into the living `07-Specs/<capability>.md` and moves the change to `_arquivo/`. GOVERN/ASSURE mint an ADR in `04-Decisões/`; compact GUIDE with no contract impact does not mint one automatically.
 
 > The gate blocks unless the scaffold is filled, no task is open, evidence is fresh, and every declared requirement is covered. **`--force` waives exactly one of those — the open-task check — and is the human's call, never the agent's.** An unfilled scaffold, a red critical sensor, stale evidence, an orphan requirement or a missing verdict block regardless.

package/README.md

@@ -531,7 +531,7 @@ explore → propose → apply (TDD) → verify → archive
 
 - **Propose** — `wendkeep change new <slug>` scaffolds `08-Mudanças/<slug>/` (`proposta.md`, `design.md`, `tarefas.md`; `--simple` skips the design). `--guide` creates the compact GUIDE contract and omits automatic design/spec/ADR when `contract_impact:none`. It becomes the global *current* change. When the change declares `spec_impact: required`, you author the delta yourself at `specs/<capability>/spec.md` — there is no placeholder to delete. Multiple changes may remain open: `change list`/`status` and the hooks show every pending one, while commands without `--change` act on the current one alone. `change use <slug>` changes focus and `change continue <archived> <new>` creates an auditable continuation.
 - **Apply** — implement each `tarefas.md` task. Mark machine proof with one or more `[sensor:<id>]` tags on the same task: every distinct ID enters the gate once, in declaration order. Also mark satisfied requirements with one or more `[req:<ID>]` tags.
-- **Verify** — `wendkeep verify` runs the sensors your tasks declared (from `wendkeep.sensors.json` at the project root) and writes `evidencia.json`. A red `critical` fails the gate; a red `warning` is advisory. Failures retain only a bounded, sanitized diagnostic; green output is not persisted. `verify --deep` builds a self-contained package with complete effective requirements (living contract + this change's delta), so the independent verifier never needs to reconstruct unarchived requirements from `07-Specs`. Every change needs a `verdict.json` to archive; `verify --deep` writes a trivial one automatically when the change declares no `[req:]`.
+- **Verify** — `wendkeep verify` runs declared sensors and writes an **Evidence Envelope v2** to `evidencia.json`, SHA-256-bound to project/repository/worktree/session, HEAD, index tree, normalized worktree digest, tasks, effective spec, and sensor configuration. Each sensor records a sanitized command, execution window, duration, exit code, output digest, and a sanitized tail bounded to 2,000 characters. If HEAD changes during the run, no new envelope is published. `change status` reports `bound`, `stale`, `context-mismatch`, or `legacy-unbound`; v1 evidence remains readable but cannot satisfy v2 authority. The public schema is [`schema/wendkeep.evidence-envelope-v2.schema.json`](schema/wendkeep.evidence-envelope-v2.schema.json). `verify --deep` binds both package and verdict to the current `envelope_id`.
 - **Archive** — `wendkeep change archive <slug>` **gates** on the evidence (blocks unless every declared critical sensor is green), promotes each applicable spec delta (`ADDED`/`MODIFIED`/`REMOVED`) into the living `07-Specs/<capability>.md` and moves the change to `_arquivo/`. GOVERN/ASSURE mint an ADR in `04-Decisões/`; compact GUIDE with no contract impact does not mint one automatically.
 
 > The gate blocks unless the scaffold is filled, no task is open, evidence is fresh, and every declared requirement is covered. **`--force` waives exactly one of those — the open-task check — and is the human's call, never the agent's.** An unfilled scaffold, a red critical sensor, stale evidence, an orphan requirement or a missing verdict block regardless.

package/docs/en/commands/changes-and-verification.md

@@ -76,7 +76,12 @@ npx wendkeep sensors add api-contracts "npm run test:contracts" --severity criti
 An archived change promotes its delta into the living spec when applicable and preserves proposal,
 tasks/proof, and design when present. GOVERN/ASSURE mint an ADR; compact GUIDE with no contract
 impact does not mint one automatically. Archive passes only with closed tasks, green required
-sensors, and a fresh verdict.
+sensors, and a fresh verdict bound to the same Evidence Envelope v2. V1 evidence is reported as
+`legacy-unbound`; `change status <slug>` also diagnoses `bound`, `stale`, and `context-mismatch`.
+Archive compares the package/verdict `evidenceEnvelopeId` and complete `evidenceBinding` with the
+proven checkout. On a mismatch, return to the correct worktree/session and rerun `verify`,
+`verify --deep`, and `wk-verify`. Fields, text/binary normalization, error codes, and recovery are
+detailed in the [verify guide](verify.md).
 
 ## Tool-scope fence
 
@@ -105,6 +110,8 @@ selection/lease; never carry authorization from another conversation.
 - Sensor not executed: keep one or more `[sensor:id]` tags on the same checkbox line. Every
   distinct ID on that line is required and runs once, in declaration order.
 - Stale evidence: rerun `verify` and `verify --deep` after task/spec edits.
+- Evidence from another worktree/session: return to the correct causal context; it cannot satisfy
+  the current archive even when every sensor is green.
 - Rebase conflict: resolve the delta or use `--accept-current` only when that is the decision.
 
 ## Next steps

package/docs/en/commands/verify.md

@@ -42,7 +42,8 @@ npx wendkeep change use <slug>
 - **Exit 0:** all required sensors passed and evidence was written.
 - **Exit 1:** the gate ran, but at least one critical sensor was red or a mutant survived.
 - **Exit 2:** invalid usage/context, including `no change (--change or active)`, missing vault,
-  unknown change, or invalid `wendkeep.sensors.json`.
+  unknown change, a project outside a Git repository, invalid `wendkeep.sensors.json`, or
+  `WENDKEEP_EVIDENCE_HEAD_CHANGED`.
 
 `verify --deep` writes `verificacao.json`; it does not replace the reviewer. The `wk-verify` skill
 must be run by a different author and writes `verdict.json`.
@@ -72,10 +73,22 @@ npx wendkeep memory status --gate --vault .MyApp-vault
 
 ## Expected result
 
-`evidencia.json` contains sensor results and a seal binds proof to the current `tarefas.md` hash.
-When a sensor is red, its entry receives only a local, sanitized diagnostic bounded to 2,000
-characters; stdout/stderr from green sensors is not persisted. Deep mode packages requirements,
-tasks, and evidence for read-only review; the verdict covers every `[req:]` before archive.
+`evidencia.json` follows the [public v2 schema](../../../schema/wendkeep.evidence-envelope-v2.schema.json).
+The envelope binds `project_id`, `repository_id`, `worktree_id`, `work_session_id`, change, and
+branch to `base_sha`, `head_sha`, `index_tree_sha`, `worktree_digest`, tasks, effective spec, and
+sensor configuration with complete SHA-256 digests. The worktree digest covers staged, unstaged,
+untracked, rename, and delete state; paths use `/`, text normalizes CRLF/CR to LF, and binaries keep
+their bytes. Binary classification honors Git `binary`/`-text` attributes and known binary
+extensions (including `.bin`); ignored files are excluded.
+
+Each sensor records its sanitized command and hash, start/end, duration, exit code, output digest,
+and a sanitized tail bounded to 2,000 characters. Authority artifacts publish through a path-safe
+temporary in the same directory and an atomic rename. In deep mode, `verificacao.json` and
+`verdict.json` carry the same `evidenceEnvelopeId` and complete `evidenceBinding`; the independent
+reviewer must preserve both.
+
+V1 evidence remains readable as `legacy-unbound`, never as equivalent authority. Run
+`wendkeep change status <slug>` to inspect `bound`, `stale`, or `context-mismatch`.
 
 ## Common errors and diagnosis
 
@@ -85,6 +98,10 @@ tasks, and evidence for read-only review; the verdict covers every `[req:]` befo
 - Red gate: inspect the bounded `note` field on the `evidencia.json` entry, fix the cause, and
   rerun; never choose `archive --force` on your own.
 - Missing/stale verdict: regenerate `--deep` and request a fresh independent pass.
+- `WENDKEEP_EVIDENCE_HEAD_CHANGED`: HEAD moved while sensors ran; stabilize the checkout and rerun.
+  The previous evidence was not replaced.
+- `legacy-unbound`, `stale`, or `context-mismatch`: return to the correct worktree/session, recover
+  the context when needed, and rerun `verify` plus `verify --deep`.
 - Surviving mutants: strengthen the discriminating test; after three rounds, review manually.
 
 ## Next steps

package/docs/pt-BR/commands/changes-and-verification.md

@@ -76,7 +76,12 @@ npx wendkeep sensors add api-contracts "npm run test:contracts" --severity criti
 A change arquivada move seu delta para o spec vivo quando aplicável e preserva proposta,
 tarefas/evidência e design quando existente. GOVERN/ASSURE geram ADR; GUIDE compacta sem impacto
 de contrato não gera ADR automático. O archive só passa com tarefas fechadas, sensores exigidos
-verdes e verdict atual.
+verdes e verdict atual ligado ao mesmo Evidence Envelope v2. Evidência v1 é mostrada como
+`legacy-unbound`; `change status <slug>` também diagnostica `bound`, `stale` e `context-mismatch`.
+O archive compara `evidenceEnvelopeId` e o `evidenceBinding` completo de package/verdict com o
+checkout provado. Se houver divergência, volte à worktree/sessão correta e rode `verify`,
+`verify --deep` e `wk-verify` novamente. Campos, normalização textual/binária, códigos e recovery
+estão detalhados no [guia de verify](verify.md).
 
 ## Cerca de escopo para ferramentas
 
@@ -105,6 +110,8 @@ exige uma nova seleção/lease; não use autorização de outra conversa.
 - Sensor não executado: mantenha uma ou mais tags `[sensor:id]` na mesma linha do checkbox. Todos
   os IDs distintos dessa linha são exigidos e executados uma vez, na ordem declarada.
 - Evidência stale: rode novamente `verify` e `verify --deep` depois de alterar tarefas/spec.
+- Evidência de outra worktree/sessão: retorne ao contexto causal correto; ela não satisfaz o
+  archive atual mesmo que todos os sensores estejam verdes.
 - Rebase em conflito: resolva o delta ou use `--accept-current` apenas quando isso for a decisão.
 
 ## Próximos passos

package/docs/pt-BR/commands/verify.md

@@ -43,7 +43,8 @@ npx wendkeep change use <slug>
 - **Exit 1:** o gate executou, mas ao menos um sensor crítico ficou vermelho ou um mutante
   sobreviveu.
 - **Exit 2:** uso/contexto inválido, como `no change (--change or active)`, vault ausente,
-  change inexistente ou `wendkeep.sensors.json` inválido.
+  change inexistente, projeto fora de um repositório Git, `wendkeep.sensors.json` inválido ou
+  `WENDKEEP_EVIDENCE_HEAD_CHANGED`.
 
 `verify --deep` gera `verificacao.json`; ele não substitui o verificador. A skill `wk-verify`
 precisa ser executada por autor diferente e grava `verdict.json`.
@@ -73,11 +74,22 @@ npx wendkeep memory status --gate --vault .MeuApp-vault
 
 ## Resultado esperado
 
-`evidencia.json` contém resultados dos sensores e um selo liga a prova ao hash atual de
-`tarefas.md`. Quando um sensor fica vermelho, sua entrada recebe somente um diagnóstico local
-sanitizado e limitado a 2.000 caracteres; stdout/stderr de sensores verdes não é persistido. No
-deep, o pacote contém requisitos, tarefas e evidência suficientes para revisão read-only; o
-verdict cobre cada `[req:]` antes do archive.
+`evidencia.json` segue o [schema público v2](../../../schema/wendkeep.evidence-envelope-v2.schema.json).
+O envelope liga `project_id`, `repository_id`, `worktree_id`, `work_session_id`, change e branch a
+`base_sha`, `head_sha`, `index_tree_sha`, `worktree_digest`, tarefas, spec e configuração dos
+sensores por SHA-256 completo. O digest cobre staged, unstaged, untracked, rename e delete; paths
+usam `/`, texto normaliza CRLF/CR para LF e binários preservam bytes. A classificação binária
+respeita atributos Git `binary`/`-text` e extensões binárias conhecidas (incluindo `.bin`); arquivos
+ignorados não entram.
+
+Cada sensor registra comando sanitizado e seu hash, início/fim, duração, exit code, digest da saída
+e tail sanitizado de até 2.000 caracteres. Os artefatos são publicados por temporário path-safe no
+mesmo diretório e rename atômico. No deep, `verificacao.json` e `verdict.json` carregam o mesmo
+`evidenceEnvelopeId` e `evidenceBinding` completo; o verificador independente deve preservar ambos
+no verdict.
+
+Evidência v1 continua legível como `legacy-unbound`, nunca como autoridade equivalente. Rode
+`wendkeep change status <slug>` para ver `bound`, `stale` ou `context-mismatch`.
 
 ## Erros comuns e diagnóstico
 
@@ -87,6 +99,10 @@ verdict cobre cada `[req:]` antes do archive.
 - Gate vermelho: consulte o campo `note` limitado da entrada em `evidencia.json`, corrija a causa
   e repita; não use `archive --force` por conta própria.
 - Verdict stale/ausente: regenere `--deep` e peça novo passe independente.
+- `WENDKEEP_EVIDENCE_HEAD_CHANGED`: o HEAD mudou enquanto os sensores rodavam; estabilize o
+  checkout e repita. A evidência anterior não foi substituída.
+- `legacy-unbound`, `stale` ou `context-mismatch`: volte à worktree/sessão correta, recupere o
+  contexto se necessário e rode `verify` + `verify --deep` novamente.
 - Mutantes sobreviventes: fortaleça o teste discriminante; após três rodadas, revise manualmente.
 
 ## Próximos passos

package/hooks/change-core.mjs

@@ -15,6 +15,7 @@ import {
   resolveActiveContext,
   setActiveContextChange,
 } from './active-context-store.mjs';
+import { evidenceSensors } from '../packages/vault/src/evidence-envelope.mjs';
 
 export const ARCHIVE_DIR = '_arquivo';
 const POINTER = '.brain/CURRENT_CHANGE.md';
@@ -442,7 +443,7 @@ export function quickGateState(vaultBase, { context } = {}) {
   let redCritical = false;
   try {
     const ev = JSON.parse(readFileSync(join(dir, 'evidencia.json'), 'utf8'));
-    redCritical = (Array.isArray(ev) ? ev : []).some((e) => e.status !== 'green' && (e.severity || 'critical') !== 'warning');
+    redCritical = evidenceSensors(ev).some((e) => e.status !== 'green' && (e.severity || 'critical') !== 'warning');
   } catch { /* sem/ilegível = não conta contra o nudge */ }
   let evidenceStale = false;
   try {

package/hooks/harness-doctor.mjs

@@ -17,6 +17,14 @@ import {
 import { parseObservabilityCheckpoint } from './session-observability-state.mjs';
 import { readObservabilityStore } from './session-observability-store.mjs';
 import { assessObservabilityFreshness } from './session-observability-lifecycle.mjs';
+import { evaluateEvidenceBinding } from '../packages/vault/src/evidence-envelope.mjs';
+import { evidenceCheckoutBinding } from '../packages/vault/src/evidence-envelope.mjs';
+import { loadSensorsDetailed, requiredSensors } from './sensors-core.mjs';
+import {
+  captureGitSnapshot,
+  resolveEvidenceIdentity,
+  sensorConfigSha256,
+} from '../src/evidence-envelope.mjs';
 
 export function checkSessionObservability(vaultBase, deps = {}) {
   const readRegistry = deps.readRegistry || readSessionRegistry;
@@ -144,10 +152,52 @@ export function checkHarness(vaultBase, projectRoot) {
     const effective = buildEffectiveRequirementPackage(vaultBase, dir, reqIds);
     errors.push(...effective.errors.map((e) => `${name}: spec efetiva inválida: ${e}`));
     if (effective.missing.length) errors.push(`req órfão em ${name}: ${effective.missing.map((id) => `[req:${id}]`).join(', ')} não existe na spec efetiva`);
+    let evidence = null;
+    try { evidence = JSON.parse(readFileSync(join(dir, 'evidencia.json'), 'utf8')); } catch { /* sem evidência */ }
+    if (evidence) {
+      const expected = {
+        change_slug: name,
+        tasks_sha256: tasksHashOf(tarefasMd),
+        effective_spec_sha256: `sha256:${effective.hash}`,
+      };
+      let bindingUnavailable = '';
+      if (evidence.schema_version === 2 && projectRoot) {
+        try {
+          const loaded = loadSensorsDetailed(projectRoot);
+          if (loaded.error) throw new Error(`wendkeep.sensors.json inválido: ${loaded.error}`);
+          expected.identity = resolveEvidenceIdentity({
+            vaultBase,
+            projectRoot,
+            changeSlug: name,
+            sessionId: evidence.work_session_id,
+          });
+          expected.snapshot = captureGitSnapshot(projectRoot);
+          expected.sensor_config_sha256 = sensorConfigSha256(
+            loaded.sensors,
+            requiredSensors(tasks),
+          );
+        } catch (error) {
+          bindingUnavailable = error.code || error.message;
+        }
+      }
+      const binding = evaluateEvidenceBinding(evidence, expected);
+      if (binding.state === 'legacy-unbound') {
+        attention.push(`${name}: evidence legacy-unbound — rode wendkeep verify novamente`);
+      } else if (binding.state !== 'bound') {
+        attention.push(`${name}: evidence ${binding.state} (${binding.reasons.join('; ')}) — rode wendkeep verify novamente`);
+      } else if (bindingUnavailable) {
+        attention.push(`${name}: evidence binding atual indisponível (${bindingUnavailable}) — rode doctor da raiz Git e depois wendkeep verify`);
+      }
+    }
     let verdict = null;
     try { verdict = JSON.parse(readFileSync(join(dir, 'verdict.json'), 'utf8')); } catch { /* sem verdict */ }
     if (verdict && reqIds.length) {
-      const v = evaluateVerdict(verdict, reqIds, { tasksHash: tasksHashOf(tarefasMd), effectiveSpecHash: effective.hash });
+      const v = evaluateVerdict(verdict, reqIds, {
+        tasksHash: tasksHashOf(tarefasMd),
+        effectiveSpecHash: effective.hash,
+        evidenceEnvelopeId: evidence?.schema_version === 2 ? evidence.envelope_id : undefined,
+        evidenceBinding: evidence?.schema_version === 2 ? evidenceCheckoutBinding(evidence) : undefined,
+      });
       if (!v.ok) attention.push(`verdict stale/incompleto em ${name}${v.missing.length ? `: falta cobrir ${v.missing.join(', ')}` : ''}`);
     }
   }

package/hooks/spec-core.mjs

@@ -5,12 +5,12 @@ import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } 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) {
@@ -168,7 +168,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 +181,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;
 }
@@ -474,10 +478,24 @@ export function promoteSpecs(vaultBase, changeDir, specs, { changeWikilink, date
 // 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.78.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/worktree.mjs && node --check src/worktree-cleanup.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';