wendkeep 0.6.0 → 0.7.0

package/CHANGELOG.md

@@ -4,6 +4,46 @@ 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.7.0] — 2026-07-05
+
+Ergonomics: the loop without hand-editing files.
+
+### Added
+- **`change status`** — one screen: tasks (done/open with `[req:]`/`[sensor:]`), sensor
+  evidence, verdict state (ok / stale / incomplete / absent), mutation round.
+- **`change done <id>` / `undone <id>`** — tick tasks from the CLI (exact-id anchored).
+- **`change diff`** — dry-run preview of the spec promotion (`+` ADDED / `~` MODIFIED /
+  `-` REMOVED / `!` warnings) without touching `07-Specs`.
+- **`spec list` / `spec show <capability>`** — read-only views over the living specs.
+- **`sensors list`** — the sensors from `wendkeep.sensors.json`; a **JSON Schema** for the
+  file now ships in the package (`schema/`) and the init seed points `$schema` at it.
+- README: "the loop in five minutes" worked example.
+
+### Fixed
+- `change` subcommands without a positional argument no longer mistake the `--vault` value
+  for a slug.
+
+## [0.6.1] — 2026-07-05
+
+Hardening: CI + real-world gate holes found by self-audit.
+
+### Added
+- **CI (GitHub Actions):** test + check matrix on ubuntu/windows × Node 18/20/22.
+- **Open-task gate:** `change archive` blocks while tasks are open (`- [ ]`, including mutation
+  fix-tasks `M.n` — a surviving mutant can no longer be archived). Explicit escape: `--force`.
+- **Freshness seal (`tasksHash`):** `verify --deep` fingerprints `tarefas.md` into the package
+  and verdict; the gate rejects a verdict minted against different tasks as stale. Pre-0.6.1
+  verdicts (no hash) still accepted.
+- **Auto-lesson on mutation escalation:** the 3rd surviving round records a project-local lesson.
+- **Session link in proposta:** `change new` fills `source:` with the active session (graph edge
+  proposta → sessão).
+
+### Fixed
+- `.mutation-round` now resets when the report comes back clean (a future survivor starts a
+  fresh 3-round cycle instead of instantly escalating).
+- `verify` exits 1 when mutants survive (was 0 — CI couldn't see it).
+- `.brain/lessons/` capped at 50 (oldest pruned) instead of growing unbounded.
+
 ## [0.6.0] — 2026-07-05
 
 Enforcement layer (Wave B of the TLC-parity program) — closes TLC parity.
@@ -120,6 +160,8 @@ Initial release — the capture engine, extracted from a system in daily product
 - `wendkeep init` (cross-platform installer) + optional `@bitbonsai/mcpvault` MCP server.
 
 <!-- Only v0.4.0+ is tagged in git (history starts here); older versions link to npm. -->
+[0.7.0]: https://github.com/rogersialves/wendkeep/releases/tag/v0.7.0
+[0.6.1]: https://github.com/rogersialves/wendkeep/releases/tag/v0.6.1
 [0.6.0]: https://github.com/rogersialves/wendkeep/releases/tag/v0.6.0
 [0.5.0]: https://github.com/rogersialves/wendkeep/releases/tag/v0.5.0
 [0.4.0]: https://github.com/rogersialves/wendkeep/releases/tag/v0.4.0

package/README.md

@@ -1,5 +1,7 @@
 # wendkeep
 
+![test](https://github.com/rogersialves/wendkeep/actions/workflows/test.yml/badge.svg)
+
 **A persistent‑memory harness for AI coding agents, built on your Obsidian vault.** Every Claude Code / Codex session is captured turn‑by‑turn into local Markdown — with token/cost tracking, auto‑extracted decisions, bugs and learnings, and a curated memory layer injected back at the start of the next session. On top of that memory core sits a native, zero‑dependency **change lifecycle** (spec → change → TDD → sensor‑gated archive) that keeps intent, work and proof wikilinked in one graph. 100% local, open‑core.
 
 > Status: `v0.1` — extracted from a system in daily production use. The capture engine, cost tracking and graph wiring are battle‑tested; the cross‑platform installer (`wendkeep init`) is the new part. See [`docs/`](docs/) for the project's strategy and decision log.
@@ -68,8 +70,11 @@ No re‑copying, no snapshot to re‑sync — the package is the single source o
 |---|---|
 | `wendkeep init` | Set up wendkeep in a project (vault taxonomy + settings + MCP + skills). |
 | `wendkeep hook <name>` | Run a session hook; invoked by `settings.json` (reads agent JSON on stdin). |
-| `wendkeep change <sub>` | Change lifecycle: `new <slug>` / `list` / `show <slug>` / `archive <slug>`. |
-| `wendkeep verify [--change s]` | Run the active (or named) change's task sensors; record evidence (the gate). |
+| `wendkeep change <sub>` | Change lifecycle: `new [--simple]` / `list` / `show` / `status` / `done <id>` / `undone <id>` / `diff` / `archive [--force]`. |
+| `wendkeep verify [--deep]` | Run the change's task sensors; `--deep` assembles the independent-verification package. |
+| `wendkeep spec <sub>` | Living specs: `list` / `show <capability>`. |
+| `wendkeep sensors list` | Show the sensors from `wendkeep.sensors.json` (JSON Schema included in the package). |
+| `wendkeep lesson add "t" "l"` | Record a project-local lesson (injected at the next SessionStart). |
 | `wendkeep sync-defs` | Copy `.brain/agents\|skills` into the project (`.codex/agents`, `.claude/skills`). |
 | `wendkeep validate-memory [path]` | Validate `.brain/CORE.md` (cap 25, 3 sections, no secrets/PII). |
 | `wendkeep doctor [--vault P]` | Run a vault health check (integrity of sessions, registry, links). |
@@ -88,7 +93,37 @@ explore → propose → apply (TDD) → verify → archive
 - **Verify** — `wendkeep verify` runs the sensors your tasks declared (from `wendkeep.sensors.json` at the project root) and records `evidencia.json`. A critical red fails the gate; a `warning` red is advisory.
 - **Archive** — `wendkeep change archive <slug>` **gates** on the evidence (blocks unless every declared critical sensor is green), promotes each capability's spec delta (`ADDED`/`MODIFIED`/`REMOVED`) into the living `07-Specs/<capability>.md`, moves the change to `_arquivo/`, and mints an ADR in `04-Decisões/`.
 
-`wendkeep init` also seeds **native process skills** (`wk-workflow`, `wk-tdd`, `wk-debugging`, `wk-brainstorming`, `wk-planning`) into `.brain/skills` and delivers them to `.claude/skills` — the *how* layer, zero‑dep. Optional companions (`context-mode`, `dotcontext`, `understand-anything`, `caveman`) remain an opt‑in extra layer.
+`wendkeep init` also seeds **native process skills** (`wk-workflow`, `wk-tdd`, `wk-debugging`, `wk-brainstorming`, `wk-planning`, `wk-verify`) into `.brain/skills` and delivers them to `.claude/skills` — the *how* layer, zero‑dep. Optional companions (`context-mode`, `dotcontext`, `understand-anything`, `caveman`) remain an opt‑in extra layer.
+
+### The loop in five minutes
+
+```bash
+npx wendkeep init --yes                        # vault + hooks + sensors + skills
+npx wendkeep change new dark-mode              # proposta/design/tarefas — change is now active
+```
+
+Edit `tarefas.md` — tag proof and requirement per task:
+
+```markdown
+- [ ] 1.1 toggle persists across sessions [req:UI-1] [sensor:tests]
+```
+
+Declare the capability in `proposta.md` (`specs: [ui]`) and author its delta in
+`specs/ui/spec.md` (`## ADDED Requirements` → `### Requisito: UI-1 — dark mode toggle`). Then:
+
+```bash
+npx wendkeep change status                     # one screen: tasks / sensors / verdict
+npx wendkeep change done 1.1                   # tick a task from the CLI
+npx wendkeep verify                            # run the declared sensors -> evidencia.json
+npx wendkeep verify --deep                     # assemble the verification package
+# the wk-verify skill (fresh, read-only pass) writes verdict.json
+npx wendkeep change diff                       # preview what will land in 07-Specs
+npx wendkeep change archive dark-mode          # gate: sensors + verdict + no open tasks
+```
+
+The archive promotes the delta into the living `07-Specs/ui.md`, mints an ADR, and the
+Obsidian graph now links *session ↔ change ↔ requirement ↔ decision*. A change that names
+no `[req:]` skips the independent verdict — the sensor gate is its proof.
 
 ## How it works
 

package/bin/wendkeep.mjs

@@ -43,7 +43,10 @@ Usage:
                            agent's JSON on stdin. Names: ${RUNNABLE_HOOKS.join(', ')}.
 
   wendkeep doctor [--vault P]  Run a vault health check.
-  wendkeep change <sub>        Change lifecycle: new <slug> | list | show <slug> | archive <slug>.
+  wendkeep change <sub>        Change lifecycle: new [--simple] | list | show | status |
+                           done <id> | undone <id> | diff | archive [--force].
+  wendkeep spec <sub>          Living specs: list | show <capability>.
+  wendkeep sensors list        Show the sensors from wendkeep.sensors.json.
   wendkeep verify [--change s] Run a change's task sensors + record evidence (the gate).
   wendkeep lesson add "t" "l"   Record a project-local lesson (injected at SessionStart).
   wendkeep validate-memory [path]  Validate .brain/CORE.md against the compaction
@@ -117,6 +120,16 @@ async function main() {
       runLesson(rest);
       break;
     }
+    case 'spec': {
+      const { runSpec } = await import('../src/spec.mjs');
+      runSpec(rest);
+      break;
+    }
+    case 'sensors': {
+      const { runSensors } = await import('../src/sensors.mjs');
+      runSensors(rest);
+      break;
+    }
     case '--version':
     case '-v':
       process.stdout.write(`${version()}\n`);

package/hooks/change-core.mjs

@@ -123,6 +123,17 @@ export function parseTasks(md) {
   return tasks;
 }
 
+// Toggle a task checkbox by its exact id (0.7.0 ergonomics). Returns false when absent.
+export function setTaskDone(changeDir, taskId, done = true) {
+  const path = join(changeDir, 'tarefas.md');
+  const md = readFileSync(path, 'utf8');
+  const esc = String(taskId).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const re = new RegExp(`^(-\\s+\\[)( |x)(\\]\\s+${esc}\\s)`, 'm');
+  if (!re.test(md)) return false;
+  writeFileSync(path, md.replace(re, `$1${done ? 'x' : ' '}$3`), 'utf8');
+  return true;
+}
+
 export function listChanges(vaultBase) {
   const base = join(vaultBase, CHANGES_DIR);
   const active = [];

package/hooks/lessons-core.mjs

@@ -1,9 +1,11 @@
 // hooks/lessons-core.mjs — project-local lessons from verification failures (Wave B).
 // A failure distilled into a terse lesson; brain-inject surfaces the recent ones at
 // SessionStart so the framework gets sharper on your codebase. No external deps.
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 
+const MAX_LESSONS = 50; // dir cap (#7): oldest (filename asc = date asc) pruned first
+
 function slugify(s) {
   return String(s)
     .toLowerCase()
@@ -22,6 +24,13 @@ export function addLesson(vaultBase, { trigger, lesson, sourceChange = '', dateS
     `---\ntype: lesson\ntrigger: ${JSON.stringify(String(trigger))}\nsource: ${sourceChange}\ndate: ${dateStr}\n---\n\n${lesson}\n`,
     'utf8',
   );
+  // Cap the directory (#7): prune oldest-by-name (date-prefixed = chronological).
+  try {
+    const files = readdirSync(dir).filter((f) => f.endsWith('.md')).sort();
+    for (const f of files.slice(0, Math.max(0, files.length - MAX_LESSONS))) {
+      unlinkSync(join(dir, f));
+    }
+  } catch { /* prune é bônus */ }
   return path;
 }
 

package/hooks/spec-core.mjs

@@ -1,9 +1,15 @@
 // 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';
 import { readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ensureDir } from './obsidian-common.mjs';
 
+// Short stable fingerprint of tarefas.md — freshness check between package/verdict and gate.
+export function tasksHashOf(md) {
+  return createHash('sha1').update(String(md)).digest('hex').slice(0, 12);
+}
+
 const SPECS_DIR = '07-Specs';
 const REQ_RE = /^### Requisito:\s*(.+)$/gm;
 
@@ -104,10 +110,15 @@ 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) {
+export function evaluateVerdict(verdict, reqIds, { tasksHash } = {}) {
   const ids = reqIds || [];
   if (ids.length === 0) return { ok: true, missing: [] };
   if (!verdict || verdict.ok !== true) return { ok: false, 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) {
+    return { ok: false, missing: [], stale: true };
+  }
   const covered = new Set((verdict.coverage || []).filter((c) => c.covered).map((c) => c.req));
   const missing = ids.filter((r) => !covered.has(r));
   return { ok: missing.length === 0, missing };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Automatically capture AI coding agent sessions (Claude Code, Codex) as local Markdown in your Obsidian vault — turn-by-turn history, cost/token tracking, auto-extracted decisions/bugs/learnings, rendered in the graph. Local-first.",
   "type": "module",
   "bin": {
@@ -11,6 +11,7 @@
     "bin",
     "src",
     "hooks",
+    "schema",
     "README.md",
     "CHANGELOG.md"
   ],

package/schema/wendkeep.sensors.schema.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://raw.githubusercontent.com/rogersialves/wendkeep/main/schema/wendkeep.sensors.schema.json",
+  "title": "wendkeep.sensors.json",
+  "description": "Native sensor config for the wendkeep harness (harness contract v1.1).",
+  "type": "object",
+  "required": ["version", "sensors"],
+  "properties": {
+    "$schema": { "type": "string" },
+    "version": { "const": 1 },
+    "source": { "type": "string" },
+    "sensors": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "command"],
+        "properties": {
+          "id": { "type": "string", "minLength": 1 },
+          "name": { "type": "string" },
+          "description": { "type": "string" },
+          "severity": { "enum": ["critical", "warning"], "default": "critical" },
+          "type": { "enum": ["command", "mutation"], "default": "command" },
+          "command": { "type": "string", "minLength": 1 },
+          "report": {
+            "type": "string",
+            "description": "type: mutation only — path (project-relative) to the mutation-testing-elements report."
+          }
+        },
+        "additionalProperties": false
+      }
+    }
+  },
+  "additionalProperties": false
+}

package/src/change.mjs

@@ -6,11 +6,12 @@ import {
   activeChange,
   listChanges,
   parseTasks,
+  setTaskDone,
   archiveChange,
 } from '../hooks/change-core.mjs';
 import { evaluateGate, requiredSensors } from '../hooks/sensors-core.mjs';
-import { evaluateVerdict } from '../hooks/spec-core.mjs';
-import { getNextAdrNumber } from '../hooks/obsidian-common.mjs';
+import { evaluateVerdict, tasksHashOf, parseSpecsList, parseDelta, parseRequirements, applyDelta } from '../hooks/spec-core.mjs';
+import { getNextAdrNumber, readControl } from '../hooks/obsidian-common.mjs';
 
 function resolveVault(argv) {
   let vault;
@@ -27,6 +28,13 @@ function resolveVault(argv) {
   return isAbsolute(base) ? base : resolve(process.cwd(), base);
 }
 
+function opt(argv, name) {
+  const i = argv.indexOf(name);
+  if (i >= 0) return argv[i + 1];
+  const eq = argv.find((a) => a.startsWith(`${name}=`));
+  return eq ? eq.slice(name.length + 1) : undefined;
+}
+
 function today() {
   const d = new Date();
   return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
@@ -35,12 +43,16 @@ function today() {
 export function runChange(argv) {
   const [sub, ...rest] = argv;
   const vaultBase = resolveVault(rest);
-  const slugArg = () => rest.find((a) => !a.startsWith('-'));
+  const VALUE_FLAGS = new Set(['--vault', '--change', '--project']);
+  const slugArg = () => rest.find((a, i) => !a.startsWith('-') && !VALUE_FLAGS.has(rest[i - 1]));
 
   if (sub === 'new') {
     const slug = slugArg();
     if (!slug) { process.stderr.write('wendkeep change new: missing <slug>\n'); process.exit(2); }
-    const r = newChange(vaultBase, slug, { dateStr: today(), simple: rest.includes('--simple') });
+    // G2: link the active session into the proposta's source: (graph edge proposta->sessão).
+    let sessionRel = '';
+    try { sessionRel = readControl(vaultBase).session_file || ''; } catch { /* sem control */ }
+    const r = newChange(vaultBase, slug, { dateStr: today(), simple: rest.includes('--simple'), sessionRel });
     process.stdout.write(`change ${r.created ? 'created' : 'exists'}: ${r.rel} (active)\n`);
     process.exit(0);
   }
@@ -66,13 +78,89 @@ export function runChange(argv) {
     process.exit(0);
   }
 
+  if (sub === 'status') {
+    const slug = slugArg() || activeChange(vaultBase);
+    if (!slug) { process.stderr.write('wendkeep change status: no change (arg or active)\n'); process.exit(2); }
+    const dir = join(vaultBase, '08-Mudanças', slug);
+    let tarefasMd;
+    try { tarefasMd = readFileSync(join(dir, 'tarefas.md'), 'utf8'); }
+    catch { process.stderr.write(`wendkeep change status: not found: ${slug}\n`); process.exit(2); }
+    const tasks = parseTasks(tarefasMd);
+    const done = tasks.filter((t) => t.done).length;
+    process.stdout.write(`change: ${slug}${slug === activeChange(vaultBase) ? ' (ativa)' : ''}\n`);
+    let specs = [];
+    try { specs = parseSpecsList(readFileSync(join(dir, 'proposta.md'), 'utf8')); } catch { /* sem proposta */ }
+    process.stdout.write(`specs: ${specs.join(', ') || '(nenhuma)'}\n`);
+    process.stdout.write(`tarefas: ${done} done / ${tasks.length - done} open\n`);
+    for (const t of tasks) {
+      process.stdout.write(`  [${t.done ? 'x' : ' '}] ${t.id} ${t.text}${t.req ? ` [req:${t.req}]` : ''}${t.sensor ? ` [sensor:${t.sensor}]` : ''}\n`);
+    }
+    let evidence = null;
+    try { evidence = JSON.parse(readFileSync(join(dir, 'evidencia.json'), 'utf8')); } catch { /* sem evidência */ }
+    if (evidence) for (const e of evidence) process.stdout.write(`  ${e.status === 'green' ? '✓' : '✗'} ${e.id} (${e.severity || 'critical'})\n`);
+    else process.stdout.write('evidencia: ausente\n');
+    const reqIds = [...new Set(tasks.map((t) => t.req).filter(Boolean))];
+    let verdict = null;
+    try { verdict = JSON.parse(readFileSync(join(dir, 'verdict.json'), 'utf8')); } catch { /* sem verdict */ }
+    if (!reqIds.length) process.stdout.write('verdict: não exigido (sem [req:])\n');
+    else if (!verdict) process.stdout.write('verdict: ausente — rode `wendkeep verify --deep` + wk-verify\n');
+    else {
+      const v = evaluateVerdict(verdict, reqIds, { tasksHash: tasksHashOf(tarefasMd) });
+      process.stdout.write(`verdict: ${v.ok ? 'ok' : v.stale ? 'stale — re-verifique' : `incompleto: falta ${v.missing.join(', ')}`}\n`);
+    }
+    try { process.stdout.write(`mutation-round: ${readFileSync(join(dir, '.mutation-round'), 'utf8').trim()}/3\n`); } catch { /* sem rodadas */ }
+    process.exit(0);
+  }
+
+  if (sub === 'done' || sub === 'undone') {
+    const taskId = slugArg();
+    if (!taskId) { process.stderr.write(`wendkeep change ${sub}: missing <taskId>\n`); process.exit(2); }
+    const slug = opt(rest, '--change') || activeChange(vaultBase);
+    if (!slug) { process.stderr.write(`wendkeep change ${sub}: no active change\n`); process.exit(2); }
+    const dir = join(vaultBase, '08-Mudanças', slug);
+    let ok = false;
+    try { ok = setTaskDone(dir, taskId, sub === 'done'); } catch { /* sem tarefas.md */ }
+    if (!ok) { process.stderr.write(`wendkeep change ${sub}: task não encontrada: ${taskId}\n`); process.exit(2); }
+    process.stdout.write(`task ${taskId}: ${sub === 'done' ? '[x]' : '[ ]'}\n`);
+    process.exit(0);
+  }
+
+  if (sub === 'diff') {
+    const slug = slugArg() || activeChange(vaultBase);
+    if (!slug) { process.stderr.write('wendkeep change diff: no change (arg or active)\n'); process.exit(2); }
+    const dir = join(vaultBase, '08-Mudanças', slug);
+    let specs = [];
+    try { specs = parseSpecsList(readFileSync(join(dir, 'proposta.md'), 'utf8')); }
+    catch { process.stderr.write(`wendkeep change diff: not found: ${slug}\n`); process.exit(2); }
+    if (!specs.length) { process.stdout.write('diff: sem specs declaradas na proposta\n'); process.exit(0); }
+    for (const cap of specs) {
+      let delta;
+      try { delta = parseDelta(readFileSync(join(dir, 'specs', cap, 'spec.md'), 'utf8')); }
+      catch { process.stdout.write(`! sem delta para ${cap}\n`); continue; }
+      process.stdout.write(`spec: ${cap}\n`);
+      for (const r of delta.added) process.stdout.write(`  + ${r.id || r.name} (ADDED)\n`);
+      for (const r of delta.modified) process.stdout.write(`  ~ ${r.id || r.name} (MODIFIED)\n`);
+      for (const k of delta.removed) process.stdout.write(`  - ${k} (REMOVED)\n`);
+      let living = [];
+      try { living = parseRequirements(readFileSync(join(vaultBase, '07-Specs', `${cap}.md`), 'utf8')); } catch { /* nova capability */ }
+      for (const w of applyDelta(living, delta).warnings) process.stdout.write(`  ! ${w}\n`);
+    }
+    process.exit(0);
+  }
+
   if (sub === 'archive') {
     const slug = slugArg() || activeChange(vaultBase);
     if (!slug) { process.stderr.write('wendkeep change archive: missing <slug> and no active change\n'); process.exit(2); }
     // Real gate (Pilar C): every sensor a task declared must be green in evidencia.json.
     const gate = (dir) => {
-      let tasks = [];
-      try { tasks = parseTasks(readFileSync(join(dir, 'tarefas.md'), 'utf8')); } catch { /* no tasks */ }
+      let tarefasMd = '';
+      try { tarefasMd = readFileSync(join(dir, 'tarefas.md'), 'utf8'); } catch { /* no tasks */ }
+      const tasks = parseTasks(tarefasMd);
+      // G1: uma change não arquiva com tarefa aberta (inclui fix-tasks M.n de mutação).
+      const open = tasks.filter((t) => !t.done);
+      if (open.length && !rest.includes('--force')) {
+        return { ok: false, failing: [`${open.length} tarefa(s) aberta(s) (ex.: ${open[0].id} ${open[0].text}) — conclua ou use --force`] };
+      }
       const required = requiredSensors(tasks);
       const reqIds = [...new Set(tasks.map((t) => t.req).filter(Boolean))];
       let evidence = [];
@@ -82,8 +170,11 @@ export function runChange(argv) {
       // Independent verdict (Wave A): required only when the change declares [req:] tasks.
       let verdict = null;
       try { verdict = JSON.parse(readFileSync(join(dir, 'verdict.json'), 'utf8')); } catch { /* none */ }
-      const v = evaluateVerdict(verdict, reqIds);
-      if (!v.ok) return { ok: false, failing: verdict ? [`verdict incompleto: falta ${v.missing.join(', ')}`] : ['sem verdict — rode `wendkeep verify --deep` + skill wk-verify'] };
+      const v = evaluateVerdict(verdict, reqIds, { tasksHash: tasksHashOf(tarefasMd) });
+      if (!v.ok) {
+        if (v.stale) return { ok: false, failing: ['verdict stale (tarefas.md mudou depois da verificação) — re-verifique: `wendkeep verify --deep` + wk-verify'] };
+        return { ok: false, failing: verdict ? [`verdict incompleto: falta ${v.missing.join(', ')}`] : ['sem verdict — rode `wendkeep verify --deep` + skill wk-verify'] };
+      }
       return { ok: true, failing: [] };
     };
     const r = archiveChange(vaultBase, slug, { dateStr: today(), adrNum: getNextAdrNumber(vaultBase), gate });
@@ -97,6 +188,6 @@ export function runChange(argv) {
     process.exit(0);
   }
 
-  process.stderr.write(`wendkeep change: unknown subcommand "${sub}". Known: new, list, show, archive.\n`);
+  process.stderr.write(`wendkeep change: unknown subcommand "${sub}". Known: new, list, show, status, done, undone, diff, archive.\n`);
   process.exit(2);
 }

package/src/dotcontext-seed.mjs

@@ -37,7 +37,7 @@ export function renderSensorsJson(scripts = {}) {
       });
     }
   }
-  return `${JSON.stringify({ version: 1, source: 'manual', sensors }, null, 2)}\n`;
+  return `${JSON.stringify({ $schema: 'https://raw.githubusercontent.com/rogersialves/wendkeep/main/schema/wendkeep.sensors.schema.json', version: 1, source: 'manual', sensors }, null, 2)}\n`;
 }
 
 function readProjectScripts(projectPath) {

package/src/sensors.mjs

@@ -0,0 +1,23 @@
+// `wendkeep sensors list` — read-only view over wendkeep.sensors.json (0.7.0).
+import { resolve } from 'node:path';
+import { loadSensors } from '../hooks/sensors-core.mjs';
+
+export function runSensors(argv) {
+  const [sub, ...rest] = argv;
+  if (sub !== 'list') {
+    process.stderr.write(`wendkeep sensors: unknown subcommand "${sub}". Known: list.\n`);
+    process.exit(2);
+  }
+  let project;
+  for (let i = 0; i < rest.length; i += 1) {
+    if (rest[i] === '--project') project = rest[++i];
+    else if (rest[i].startsWith('--project=')) project = rest[i].slice(10);
+  }
+  const projectRoot = resolve(project || process.cwd());
+  const sensors = loadSensors(projectRoot);
+  if (!sensors.length) { process.stdout.write('sensors: (nenhum — crie wendkeep.sensors.json na raiz)\n'); process.exit(0); }
+  for (const s of sensors) {
+    process.stdout.write(`${s.id}: ${s.type || 'command'} · ${s.severity || 'critical'} · ${s.command}\n`);
+  }
+  process.exit(0);
+}

package/src/skills-seed.mjs

@@ -190,7 +190,9 @@ nunca tivesse visto a implementação. Contexto fresco, read-only.
    passaria sob impl errada). Evidência \`arquivo:linha\`.
 3. Outcome check ancorado no spec: o resultado observável bate com o critério de aceite?
 4. Grave \`08-Mudanças/<slug>/verdict.json\`:
-   \`{ "slug": "...", "ok": true, "coverage": [{ "req": "GATE-1", "covered": true, "evidence": "arquivo:linha" }], "notes": [] }\`.
+   \`{ "slug": "...", "ok": true, "coverage": [{ "req": "GATE-1", "covered": true, "evidence": "arquivo:linha" }], "tasksHash": "<copie do verificacao.json>", "notes": [] }\`.
+   O \`tasksHash\` vem do pacote — é o selo de frescor; sem ele (ou com tarefas alteradas
+   depois), o gate rejeita o verdict como stale.
 
 ## Regras
 

package/src/spec.mjs

@@ -0,0 +1,53 @@
+// `wendkeep spec <sub>` — read-only views over the living specs in 07-Specs (0.7.0).
+import { readFileSync, readdirSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
+import { parseRequirements } from '../hooks/spec-core.mjs';
+
+function resolveVault(argv) {
+  let vault;
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === '--vault') vault = argv[++i];
+    else if (a.startsWith('--vault=')) vault = a.slice(8);
+  }
+  const base = vault || process.env.OBSIDIAN_VAULT_PATH;
+  if (!base) {
+    process.stderr.write('wendkeep spec: no vault. Pass --vault <path> or set OBSIDIAN_VAULT_PATH.\n');
+    process.exit(2);
+  }
+  return isAbsolute(base) ? base : resolve(process.cwd(), base);
+}
+
+export function runSpec(argv) {
+  const [sub, ...rest] = argv;
+  const vaultBase = resolveVault(rest);
+  const specsDir = join(vaultBase, '07-Specs');
+
+  if (sub === 'list') {
+    let files = [];
+    try { files = readdirSync(specsDir).filter((f) => f.endsWith('.md') && f !== 'README.md'); } catch { /* sem specs */ }
+    if (!files.length) { process.stdout.write('specs: (nenhuma)\n'); process.exit(0); }
+    for (const f of files) {
+      const md = readFileSync(join(specsDir, f), 'utf8');
+      const n = parseRequirements(md).length;
+      const upd = md.match(/> Atualizado por .* em (\d{4}-\d{2}-\d{2})/);
+      process.stdout.write(`${f.replace(/\.md$/, '')}: ${n} requisito(s)${upd ? ` (atualizado ${upd[1]})` : ''}\n`);
+    }
+    process.exit(0);
+  }
+
+  if (sub === 'show') {
+    const cap = rest.find((a, i) => !a.startsWith('-') && rest[i - 1] !== '--vault');
+    if (!cap) { process.stderr.write('wendkeep spec show: missing <capability>\n'); process.exit(2); }
+    let md;
+    try { md = readFileSync(join(specsDir, `${cap}.md`), 'utf8'); }
+    catch { process.stderr.write(`wendkeep spec show: not found: ${cap}\n`); process.exit(2); }
+    const reqs = parseRequirements(md);
+    process.stdout.write(`${cap}: ${reqs.length} requisito(s)\n`);
+    for (const r of reqs) process.stdout.write(`  ${r.id ? `${r.id} — ` : ''}${r.name}\n`);
+    process.exit(0);
+  }
+
+  process.stderr.write(`wendkeep spec: unknown subcommand "${sub}". Known: list, show.\n`);
+  process.exit(2);
+}

package/src/verify.mjs

@@ -1,10 +1,17 @@
 // `wendkeep verify [--change <slug>]` — run a change's task sensors, record evidence.
 // Sensors run at the PROJECT root (--project or cwd); the change + evidence live in
 // the VAULT. Writes 08-Mudanças/<slug>/evidencia.json; exit 1 if a critical sensor is red.
-import { readFileSync, writeFileSync } from 'node:fs';
+import { readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join, resolve } from 'node:path';
 import { parseTasks, activeChange, appendFixTasks } from '../hooks/change-core.mjs';
 import { loadSensors, requiredSensors, runSensors, evaluateGate } from '../hooks/sensors-core.mjs';
+import { tasksHashOf } from '../hooks/spec-core.mjs';
+import { addLesson } from '../hooks/lessons-core.mjs';
+
+function today() {
+  const d = new Date();
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
 
 function opt(argv, name) {
   const i = argv.indexOf(name);
@@ -31,20 +38,35 @@ export function runVerify(argv) {
   const evidence = runSensors(sensors, ids, { cwd: projectRoot });
   writeFileSync(join(changeDir, 'evidencia.json'), `${JSON.stringify(evidence, null, 2)}\n`, 'utf8');
 
-  // Mutation survivors -> fix tasks (Wave B), bounded at 3 rounds then escalate.
+  // Mutation survivors -> fix tasks (Wave B), bounded at 3 rounds then escalate. A surviving
+  // mutant always fails verify (exit 1): the suite does not discriminate yet. A clean report
+  // resets the round counter so a future survivor starts a fresh cycle.
   const withSurvivors = evidence.filter((e) => e.survivors && e.survivors.length);
-  if (withSurvivors.length) {
-    const roundFile = join(changeDir, '.mutation-round');
+  const roundFile = join(changeDir, '.mutation-round');
+  if (!withSurvivors.length) {
+    try { unlinkSync(roundFile); } catch { /* nunca houve rodada */ }
+  } else {
     let round = 0;
     try { round = Number(readFileSync(roundFile, 'utf8').trim()) || 0; } catch { /* first round */ }
     if (round >= 3) {
       process.stderr.write('verify: mutantes ainda sobrevivem após 3 rodadas — revise os testes à mão.\n');
+      const flat = withSurvivors.flatMap((e) => e.survivors.map((s) => `${s.file}:${s.line}`));
+      try {
+        addLesson(vaultBase, {
+          trigger: `mutantes persistentes em ${slug}`,
+          lesson: `3 rodadas de fix-tasks não mataram: ${flat.join(', ')} — os testes desses pontos não discriminam.`,
+          sourceChange: slug,
+          dateStr: today(),
+        });
+      } catch { /* lesson é bônus, nunca derruba o verify */ }
     } else {
       let added = 0;
       for (const e of withSurvivors) added += appendFixTasks(changeDir, e.survivors, e.id);
       writeFileSync(roundFile, String(round + 1), 'utf8');
       process.stdout.write(`verify: ${added} fix-task(s) de mutação (rodada ${round + 1}/3)\n`);
     }
+    process.stderr.write('verify: mutantes sobreviventes — a suíte não discrimina ainda.\n');
+    process.exit(1);
   }
 
   // Same rule as the archive gate: evidence carries severity, so evaluateGate blocks
@@ -61,15 +83,17 @@ export function runVerify(argv) {
   if (argv.includes('--deep')) {
     const tasks = parseTasks(tarefas);
     const reqIds = [...new Set(tasks.map((t) => t.req).filter(Boolean))];
+    const tasksHash = tasksHashOf(tarefas);
     const pkg = {
       slug,
+      tasksHash,
       requirements: reqIds.map((id) => ({ id })),
       tasks: tasks.map((t) => ({ id: t.id, text: t.text, req: t.req || null, done: t.done })),
       sensors: evidence,
     };
     writeFileSync(join(changeDir, 'verificacao.json'), `${JSON.stringify(pkg, null, 2)}\n`, 'utf8');
     if (reqIds.length === 0) {
-      writeFileSync(join(changeDir, 'verdict.json'), `${JSON.stringify({ slug, ok: true, coverage: [], notes: ['trivial: sem requisito'] }, null, 2)}\n`, 'utf8');
+      writeFileSync(join(changeDir, 'verdict.json'), `${JSON.stringify({ slug, ok: true, coverage: [], tasksHash, notes: ['trivial: sem requisito'] }, null, 2)}\n`, 'utf8');
       process.stdout.write('verify --deep: pacote + verdict trivial escritos\n');
     } else {
       process.stdout.write('verify --deep: pacote escrito — rode a skill wk-verify pra gravar verdict.json\n');