wendkeep 0.6.0 → 0.6.1

package/CHANGELOG.md

@@ -4,6 +4,27 @@ 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.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 +141,7 @@ 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.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.

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.6.1",
   "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": {

package/src/change.mjs

@@ -9,8 +9,8 @@ import {
   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 } from '../hooks/spec-core.mjs';
+import { getNextAdrNumber, readControl } from '../hooks/obsidian-common.mjs';
 
 function resolveVault(argv) {
   let vault;
@@ -40,7 +40,10 @@ export function runChange(argv) {
   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);
   }
@@ -71,8 +74,14 @@ export function runChange(argv) {
     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 +91,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 });

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/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');