wendkeep 0.21.0 → 0.23.0

package/CHANGELOG.md

@@ -4,6 +4,69 @@ 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.23.0] — 2026-07-08
+
+Vault structure — generated views + housekeeping (audit wave 2).
+
+### Added
+- **Generated Bases + Dashboard MOC**: `wendkeep init` now writes one folder-filtered `.base`
+  per taxonomy area (sessions/decisions/bugs/learnings/specs/changes) and a `00-Dashboard.md`
+  that embeds them — the vault's structural index. Filters are **by folder**
+  (`file.inFolder("05-Bugs")`), fixing the tag-filter that hid ~1/3 of bugs. New
+  `wendkeep dashboard [--force]` (re)generates them; non-destructive (never clobbers your own
+  bases). Locale-aware. `src/vault-views.mjs`.
+
+### Changed
+- **Archive ADRs land in the dated month folder** (`04-Decisões/<year>/<MM-MMM>/`) alongside
+  session-derived decisions, instead of the year root. `hooks/change-core.mjs`.
+- **`SESSION_REGISTRY` is pruned** on the idle sweep: `done` entries older than 90 days, then a
+  cap of 200 most-recent — active entries are never touched. Bounds the per-hook read/serialize
+  cost that had grown to 330 entries / ~170 KB in production. `hooks/obsidian-common.mjs`.
+- **Generated note names truncate on a word boundary** instead of mid-word (`slugify` gained a
+  boundary-aware `maxLen`). `hooks/obsidian-common.mjs`, `hooks/linked-notes.mjs`.
+- **Learnings dedup vault-wide**: a learning already recorded anywhere in `06-Aprendizados`
+  (by `content_key`) is not re-emitted on a later day/session. `hooks/linked-notes.mjs`.
+
+### Deferred
+- Unifying the two `buildSessionContent` skeletons (session-start / session-ensure) stays as
+  tracked tech-debt — pure refactor, high regression risk in the capture layer, and the
+  user-facing drift (`session_id`) was already closed in 0.18/0.21.
+
+## [0.22.0] — 2026-07-08
+
+Hardening — 10 audit-confirmed bugs fixed (each survived an adversarial refuter).
+
+### Fixed
+- **Archive trusted stale evidence**: `verify` now seals `evidencia.json` with a `.evidence-hash`
+  (the `tarefas.md` hash it ran against); the archive gate rejects evidence gone stale (a sensor
+  task added/edited after the last green verify). `src/verify.mjs`, `src/change.mjs`.
+- **Archiving a non-active change wiped the active pointer**: `archiveChange` now only clears
+  `CURRENT_CHANGE` when the archived slug IS the active one. `hooks/change-core.mjs`.
+- **Non-atomic archive**: a destination-exists guard fails BEFORE promoting specs (same-day slug
+  reuse no longer half-promotes `07-Specs` then errors on the move); `renameSync` wrapped.
+- **Archived proposta kept `status: active`** → flipped to `status: archived` on archive.
+- **Import dropped Codex sessions whose `session_meta` exceeded 16KB** (~31% in production): the
+  reader now grows the buffer to the first newline instead of a fixed prefix. `hooks/import-sessions.mjs`.
+- **Cost was silently $0 for untabled models**: `normalizeModelName` strips a `[1m]` context tag
+  generically (so `claude-opus-4-8[1m]` prices), `claude-sonnet-5` added, plus approximate Codex
+  `gpt-5.4`/`gpt-5.3-codex` aliases. `hooks/token-usage.mjs`, `hooks/pricing.json`.
+- **Imported session titles came from harness meta-prompts** ("Generate a concise title…"): those
+  utility prompts are now filtered in both parsers' `shouldIgnoreUserText`.
+- **Session↔change link died on reopen**: the change wikilink moved from an append after
+  `## Encerramento` (stripped every turn) to a durable `## Mudanças` section before it, which
+  accumulates every change the session touched. `hooks/session-stop.mjs`.
+- **`init --force` duplicated every hook group**: now refreshes the managed entry in place instead
+  of appending a second identical group. `src/init.mjs`.
+- **Injected DIGEST carried dead wikilinks**: `buildBrainDigest` now keeps only targets that
+  resolve to a real note and drops truncated placeholders. `hooks/brain-core.mjs`.
+
+### Changed
+- **Docs coherence**: `--help` moved `--top` from `import` to `cost`, gave `import` its real flags
+  (`--source`/`--stamp-ids`/`--from`/`--codex-from`/`--limit`/`--dry-run`, "Claude + Codex"), and
+  added `verify [--deep]`. README dropped the stale "v0.1" framing, fixed the 5→6 skill list
+  (adds `wk-verify`), made the `docs/` link absolute, and documented the `<wk_process>` router +
+  the G0 scaffold gate.
+
 ## [0.21.0] — 2026-07-08
 
 Process enforcement — fixes from a real planning failure (production session): the model planned

package/README.md

@@ -4,7 +4,7 @@
 
 **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.
+> 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`) and the native change loop are the newer parts. See [`docs/`](https://github.com/rogersialves/wendkeep/tree/main/docs) for the project's strategy and decision log.
 
 ---
 
@@ -49,7 +49,7 @@ npx wendkeep init
    Control with `--companions <csv>` or `--no-companions`. The Claude Code plugin layer (`extraKnownMarketplaces` + `enabledPlugins`) is wired as a bonus where the companion has one.
 5. Install a **color system** into the vault's `.obsidian/`: a CSS snippet that accents notes by type (session/decision/bug/learning, via the `cssclasses` the hooks emit) plus graph color groups by folder. Non-destructive merge into `appearance.json`/`graph.json`; skip with `--no-colors`.
 6. Seed the **curated memory layer**: `.brain/CORE.md` (the hand-curated hot layer, with the 3 required sections) and `.brain/COMPACTION_PROTOCOL.md` (the protocol guide). The auto layers (`DIGEST.md`, `index.jsonl`) are generated by the hooks. Validate the curated layer with `wendkeep validate-memory` (cap 25 lines, 3 sections, no secrets/PII).
-7. Seed the **definitions + skills layer**: `.brain/agents/` + `.brain/skills/` (versioned source of truth), including the native process skills `wk-workflow` / `wk-tdd` / `wk-debugging` / `wk-brainstorming` / `wk-planning`. `init` runs `wendkeep sync-defs` for you, delivering them to `.codex/agents/` + `.claude/skills/` (re‑run `sync-defs` after editing `.brain`).
+7. Seed the **definitions + skills layer**: `.brain/agents/` + `.brain/skills/` (versioned source of truth), including the native process skills `wk-workflow` / `wk-tdd` / `wk-debugging` / `wk-brainstorming` / `wk-planning` / `wk-verify` (some ship bundled templates, e.g. `wk-verify`'s `verdict-template.json` + reviewer prompt). `init` runs `wendkeep sync-defs` for you, delivering them to `.codex/agents/` + `.claude/skills/` (re‑run `sync-defs` after editing `.brain`).
 8. Seed the **change/spec lifecycle**: the `07-Specs/` + `08-Mudanças/` folders and a native `wendkeep.sensors.json` (a `validate-memory` sensor plus one per detected `package.json` script). Drives `wendkeep change` / `wendkeep verify` — see **Change lifecycle** below.
 
 ```bash
@@ -170,14 +170,16 @@ agent session ──hooks──▶ wendkeep ──▶ Markdown in vault ──
    (Claude/Codex)        (Node)      (02-Sessões/…)        (CORE+DIGEST, backlinks)
 ```
 
-The agent's settings.json points each hook at `npx wendkeep hook …`. On `Stop`, wendkeep parses the session transcript, appends the turn, updates the token/cost table, and (idempotently) emits any decision/bug/learning notes. On the next `SessionStart`, the curated memory is injected back into context.
+The agent's settings.json points each hook at `npx wendkeep hook …`. On `Stop`, wendkeep parses the session transcript, appends the turn, updates the token/cost table, and (idempotently) emits any decision/bug/learning notes. On every `SessionStart`, `brain-inject` injects back the curated memory (CORE + DIGEST), the active change, project lessons, and a `<wk_process>` router that routes any non‑trivial task through the a2 loop (plan → `change new` + fill the scaffold → TDD → verify → archive).
 
-## Known limitations (`v0.1`)
+The archive **gate** blocks unless: the change scaffold is filled (G0), no task is open (G1), every declared critical sensor is green (with fresh evidence), and — when the change declares `[req:]` — an independent `verdict.json` covers them. `--force` is the human escape hatch; the agent is instructed never to use it on its own.
+
+## Notes & roadmap
 
 - **Vault folder names default to Portuguese** (`02-Sessões`, `04-Decisões`, …). Pass `wendkeep init --locale en` for an English vault (`02-Sessions`, `04-Decisions`, English scaffold/skills). The locale is a vault property, locked at init; parsers are bilingual so mixed content never breaks.
 - **Search is keyword/frontmatter scoring**, not on‑device embeddings (that's on the roadmap).
 - **Transcript formats are agent‑internal** and can change between agent versions; parsing is isolated but may need updates.
-- Installer wires **Claude Code** settings + `.mcp.json`. Codex hooks run on the same scripts but are not auto‑wired yet.
+- Installer wires **Claude Code** settings + `.mcp.json`. Codex hooks run on the same scripts but are not auto‑wired yet (import already covers past Codex sessions via `--source codex`).
 
 ## License
 

package/bin/wendkeep.mjs

@@ -48,9 +48,15 @@ Usage:
   wendkeep spec <sub>          Living specs: list | show <capability>.
   wendkeep sensors <sub>       list | add <id> "<command>" [--severity --type --report].
   wendkeep cost [opts]         Aggregate AI-coding spend across the vault's sessions.
-  wendkeep import [opts]       Backfill: import this project's past Claude sessions into the vault.
                            --since <date> · --top [N] (priciest sessions) · --json.
-  wendkeep verify [--change s] Run a change's task sensors + record evidence (the gate).
+  wendkeep import [opts]       Backfill: import this project's past Claude + Codex sessions into
+                           the vault (deduped by session_id). --source all|claude|codex (default
+                           all) · --stamp-ids (backfill session_id in existing notes) ·
+                           --from <dir> · --codex-from <dir> · --since <date> · --limit N ·
+                           --dry-run · --json.
+  wendkeep verify [--deep] [--change s]  Run a change's task sensors + record evidence (the gate);
+                           --deep assembles the verification package for the wk-verify pass.
+  wendkeep dashboard [--force]  (Re)generate the vault's folder-filtered Bases + 00-Dashboard MOC.
   wendkeep lesson add "t" "l"   Record a project-local lesson (injected at SessionStart).
   wendkeep validate-memory [path]  Validate .brain/CORE.md against the compaction
                            protocol (cap 25, 3 sections, no secrets/PII). Uses
@@ -143,6 +149,11 @@ async function main() {
       runImportCli(rest);
       break;
     }
+    case 'dashboard': {
+      const { runDashboard } = await import('../src/vault-views.mjs');
+      runDashboard(rest);
+      break;
+    }
     case '--version':
     case '-v':
       process.stdout.write(`${version()}\n`);

package/hooks/brain-core.mjs

@@ -1,7 +1,7 @@
 // .agent/hooks/brain-core.mjs
 // Camada fria do brain: indexa o frontmatter das notas de sessão (0 token LLM).
-import { readdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
 import { ensureDir, stripYamlQuotes, toVaultRelative } from './obsidian-common.mjs';
 import { getLocale } from './locale.mjs';
 
@@ -123,10 +123,26 @@ export function buildBrainDigest(vaultBase, rows = null) {
     return out;
   };
 
-  const decisions = pick('decisions', DIGEST_CAPS.decisions).sort((a, b) => adrNumber(b) - adrNumber(a));
+  // The digest is INJECTED into every session, so a dead wikilink is dead weight in the model's
+  // context. Keep only targets that resolve to a real note (by vault-relative path or basename)
+  // and drop placeholder paths (a truncated `…` from a summary line). `pick` collects extra so
+  // caps still fill after filtering.
+  const known = new Set();
+  for (const r of data) {
+    const rel = String(r.file || '').replace(/\.md$/i, '');
+    if (rel) { known.add(rel); known.add(basename(rel)); }
+  }
+  const resolves = (p) => {
+    const t = String(p || '').replace(/\.md$/i, '').trim();
+    if (!t || t.includes('...') || t.includes('…')) return false;
+    return known.has(t) || known.has(basename(t)) || existsSync(join(vaultBase, `${t}.md`));
+  };
+  const pickLive = (kind, max) => pick(kind, max * 4).filter(resolves).slice(0, max);
+
+  const decisions = pickLive('decisions', DIGEST_CAPS.decisions).sort((a, b) => adrNumber(b) - adrNumber(a));
   const sessions = byDateDesc.slice(0, DIGEST_CAPS.sessions);
-  const bugs = pick('bugs', DIGEST_CAPS.bugs);
-  const learnings = pick('learnings', DIGEST_CAPS.learnings);
+  const bugs = pickLive('bugs', DIGEST_CAPS.bugs);
+  const learnings = pickLive('learnings', DIGEST_CAPS.learnings);
 
   const lines = ['<!-- AUTO-GERADO por brain-core.mjs (0 token LLM). NÃO editar. Rebuild: node .agent/hooks/brain-reindex.mjs -->'];
   for (const d of decisions) lines.push(`- Decisão: [[${d}]]`);

package/hooks/change-core.mjs

@@ -3,7 +3,7 @@
 // the `wendkeep change` CLI (src/change.mjs) and the brain-inject hook. No external deps.
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { ensureDir, wikilinkFromRel } from './obsidian-common.mjs';
+import { ensureDir, wikilinkFromRel, monthFolderRelFromDateStr } from './obsidian-common.mjs';
 import { parseSpecsList, promoteSpecs } from './spec-core.mjs';
 import { getLocale } from './locale.mjs';
 
@@ -222,8 +222,16 @@ export function archiveChange(vaultBase, slug, { gate = gateGreen, dateStr, adrN
   if (!verdict.ok) return { ok: false, failing: verdict.failing || [] };
 
   const destRel = join(chDir, ARCHIVE_DIR, `${dateStr}-${slug}`);
+  const destAbs = join(vaultBase, destRel);
   const changeWikilink = wikilinkFromRel(join(destRel, 'proposta'));
 
+  // Atomicity guard: fail BEFORE promoting specs if the destination already exists (e.g. a slug
+  // reused after a same-day archive). Otherwise promoteSpecs would commit to 07-Specs and the
+  // later renameSync would fail, leaving a half-archived state.
+  if (existsSync(destAbs)) {
+    return { ok: false, failing: [`destino de arquivo já existe: ${destRel} — renomeie o slug ou remova o arquivo antigo`] };
+  }
+
   // Promote spec deltas into the living 07-Specs BEFORE moving (deltas live in src).
   let promoted = [];
   let specWarnings = [];
@@ -240,10 +248,22 @@ export function archiveChange(vaultBase, slug, { gate = gateGreen, dateStr, adrN
   try { reqIds = [...new Set(parseTasks(readFileSync(join(src, 'tarefas.md'), 'utf8')).map((t) => t.req).filter(Boolean))]; } catch { /* sem tarefas */ }
 
   ensureDir(join(vaultBase, chDir, ARCHIVE_DIR));
-  renameSync(src, join(vaultBase, destRel));
+  try {
+    renameSync(src, destAbs);
+  } catch (error) {
+    return { ok: false, failing: [`falha ao mover a mudança para ${destRel}: ${error.message} (07-Specs pode ter sido promovido — verifique)`] };
+  }
 
-  const [year] = String(dateStr).split('-');
-  const adrDirRel = join(loc.folders.decisions, year);
+  // Flip the archived proposta's frontmatter status so it no longer reads as active.
+  try {
+    const pp = join(destAbs, 'proposta.md');
+    const c = readFileSync(pp, 'utf8').replace(/^status:\s*active\s*$/m, 'status: archived');
+    writeFileSync(pp, c, 'utf8');
+  } catch { /* proposta ilegível — segue */ }
+
+  // ADR goes in the same dated month folder as session-derived decisions (04-Decisões/ano/MM-MMM/)
+  // — not the year root — so all ADRs sit together in the vault's convention.
+  const adrDirRel = monthFolderRelFromDateStr(loc.folders.decisions, dateStr, vaultBase);
   ensureDir(join(vaultBase, adrDirRel));
   const num = String(adrNum).padStart(3, '0');
   const adrRel = join(adrDirRel, `ADR-${num}-${slug}.md`);
@@ -268,6 +288,8 @@ tags:
 Mudança ${changeWikilink} concluída e arquivada.${capLine}${reqLine}
 `, 'utf8');
 
-  clearActiveChange(vaultBase);
+  // Only clear the pointer when the archived change IS the active one — archiving some other
+  // slug explicitly must not blank the pointer of a different, still-active change.
+  if (activeChange(vaultBase) === slug) clearActiveChange(vaultBase);
   return { ok: true, failing: [], archivedRel: destRel, adrRel, promoted, specWarnings };
 }

package/hooks/import-sessions.mjs

@@ -97,15 +97,39 @@ function readPrefix(path, bytes = 4096) {
   }
 }
 
+// Read the first physical line in full, growing the buffer until a newline is found (capped).
+// A fixed prefix truncated any rollout whose session_meta line exceeded the window, silently
+// dropping that session from discovery — Codex meta lines can be large (env, git, instructions).
+function readFirstLine(path, maxBytes = 4 * 1024 * 1024) {
+  let fd;
+  try {
+    fd = openSync(path, 'r');
+    const chunk = Buffer.alloc(65536);
+    let acc = '';
+    let pos = 0;
+    while (pos < maxBytes) {
+      const n = readSync(fd, chunk, 0, chunk.length, pos);
+      if (n <= 0) break;
+      acc += chunk.slice(0, n).toString('utf-8');
+      const nl = acc.indexOf('\n');
+      if (nl >= 0) return acc.slice(0, nl);
+      pos += n;
+    }
+    return acc; // single-line file, or gave up at the cap
+  } catch {
+    return '';
+  } finally {
+    if (fd !== undefined) { try { closeSync(fd); } catch { /* already closed */ } }
+  }
+}
+
 // Pull the session_meta payload (id + cwd). session_meta is line 1 of a rollout.
 function readSessionMeta(path) {
-  for (const line of readPrefix(path, 16384).split('\n')) {
-    if (!line.trim()) continue;
-    let e;
-    try { e = JSON.parse(line); } catch { return null; } // partial/oversized first line -> skip
-    return e.type === 'session_meta' ? (e.payload || {}) : null;
-  }
-  return null;
+  const line = readFirstLine(path);
+  if (!line.trim()) return null;
+  let e;
+  try { e = JSON.parse(line); } catch { return null; }
+  return e.type === 'session_meta' ? (e.payload || {}) : null;
 }
 
 // The `session_id` recorded in a note's frontmatter (empty when absent).

package/hooks/linked-notes.mjs

@@ -477,6 +477,30 @@ function listMd(dir) {
 }
 
 // Chaves content_key das derivadas já existentes que linkam esta sessão.
+// Vault-wide learning content_keys (recursive over the learnings folder). existingKeysForSession
+// only looks at the current session + month, so the same lesson re-extracted on a later day/
+// session was duplicated. This dedups a learning against everything already learned in the vault.
+function collectLearningKeys(vaultBase) {
+  const keys = new Set();
+  const root = join(vaultBase, getLocale(vaultBase).folders.learnings);
+  const walk = (d) => {
+    let entries;
+    try { entries = readdirSync(d, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      const p = join(d, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (e.name.endsWith('.md')) {
+        try {
+          const m = readFileSync(p, 'utf-8').match(/^content_key:\s*"?(.*?)"?\s*$/m);
+          if (m && m[1]) keys.add(m[1]);
+        } catch { /* nota ilegível */ }
+      }
+    }
+  };
+  walk(root);
+  return keys;
+}
+
 function existingKeysForSession(vaultBase, sessionRel, dateStr) {
   const wikilink = wikilinkFromRel(sessionRel);
   const out = { bugs: [], decisions: [], learnings: [] };
@@ -518,7 +542,7 @@ export function createLinkedNotes(vaultBase, dateStr, sessionRel, tx, options =
     const issueRef = issueRefs[0] || '';
     const bugKey = derivedContentKey(bugDetails.rootCause);
     if (!alreadyHasKey(existingKeys.bugs, bugKey)) {
-      const causeSlug = slugify(bugDetails.rootCause.slice(0, 40), 'bug');
+      const causeSlug = slugify(bugDetails.rootCause, 'bug', 40);
       const fileName = issueRef ? `${issueRef}-${causeSlug}.md` : `${dateStr}-bug-${causeSlug}.md`;
       const filePath = join(bugsDir, fileName);
       if (!existsSync(filePath)) writeFileSync(filePath, buildBugNoteContent(bugDetails, issueRef, dateStr, sessionRel, provider, bugKey, loc.id), 'utf-8');
@@ -531,7 +555,7 @@ export function createLinkedNotes(vaultBase, dateStr, sessionRel, tx, options =
   if (decisionDetails) {
     const decisionKey = derivedContentKey(decisionDetails.title);
     if (!alreadyHasKey(existingKeys.decisions, decisionKey)) {
-      const titleSlug = slugify(decisionDetails.title.slice(0, 40), 'decisao');
+      const titleSlug = slugify(decisionDetails.title, 'decisao', 40);
       const existing = adrFileExistsBySlug(decisionsDir, titleSlug);
       const fileName = existing || `ADR-${String(getNextAdrNumber(vaultBase)).padStart(3, '0')}-${titleSlug}.md`;
       const filePath = join(decisionsDir, fileName);
@@ -546,10 +570,12 @@ export function createLinkedNotes(vaultBase, dateStr, sessionRel, tx, options =
 
   const learnings = extractLearningDetails(tx, bugDetails);
   if (learnings) {
+    const vaultLearningKeys = collectLearningKeys(vaultBase); // vault-wide dedup
     for (const learning of learnings) {
       const learningKey = derivedContentKey(learning.title);
       if (alreadyHasKey(existingKeys.learnings, learningKey)) continue;
-      const learningSlug = slugify(learning.title.slice(0, 40), 'aprendizado');
+      if (vaultLearningKeys.has(learningKey)) continue; // already learned elsewhere in the vault
+      const learningSlug = slugify(learning.title, 'aprendizado', 40);
       const fileName = `${dateStr}-${learningSlug}.md`;
       const filePath = join(learningsDir, fileName);
       if (!existsSync(filePath)) writeFileSync(filePath, buildLearningNoteContent(learning, dateStr, sessionRel, provider, learningKey, loc.id), 'utf-8');

package/hooks/obsidian-common.mjs

@@ -289,12 +289,38 @@ export function sweepStaleSessions(registry, nowMs, maxIdleMs, excludeTranscript
   return closed;
 }
 
-// Wrapper de IO: varre as ociosas, grava o registry e fecha a NOTA `.md` de cada
+// Registry retention. The registry is read/serialized in full on every hook and scanned O(N)
+// for routing — it only needs active + recent sessions (historical audit lives in the notes).
+// Left unbounded it grew to 330 entries / ~170 KB in production.
+export const REGISTRY_KEEP_DONE = 200;
+export const REGISTRY_DONE_MAX_AGE_MS = 90 * 24 * 60 * 60 * 1000;
+
+// Pure: drop 'done' entries older than maxAgeMs, then cap the remaining 'done' at keepDone
+// (newest by ended_at/updated_at/started_at kept). Never touches active entries. Mutates the
+// registry and returns how many were pruned.
+export function pruneRegistry(registry, nowMs, { keepDone = REGISTRY_KEEP_DONE, maxAgeMs = REGISTRY_DONE_MAX_AGE_MS } = {}) {
+  const sessions = registry?.sessions || {};
+  const stamp = (v) => Date.parse((v && (v.ended_at || v.updated_at || v.started_at)) || '') || 0;
+  let pruned = 0;
+  for (const [id, v] of Object.entries(sessions)) {
+    if (!v || v.status !== 'done') continue;
+    const t = stamp(v);
+    if (t && nowMs - t > maxAgeMs) { delete sessions[id]; pruned += 1; }
+  }
+  const done = Object.entries(sessions)
+    .filter(([, v]) => v && v.status === 'done')
+    .sort((a, b) => stamp(b[1]) - stamp(a[1]));
+  for (const [id] of done.slice(keepDone)) { delete sessions[id]; pruned += 1; }
+  return pruned;
+}
+
+// Wrapper de IO: varre as ociosas, poda o registry, grava e fecha a NOTA `.md` de cada
 // sessão encerrada (mantém vault e registry alinhados). Devolve quantas fechou.
 export function sweepStaleSessionsFile(vaultBase, now = new Date(), maxIdleMs = SESSION_IDLE_CLOSE_MS, excludeTranscriptPath = '') {
   const registry = readSessionRegistry(vaultBase);
   const closed = sweepStaleSessions(registry, now.getTime(), maxIdleMs, excludeTranscriptPath);
-  if (closed.length) writeSessionRegistry(vaultBase, registry);
+  const pruned = pruneRegistry(registry, now.getTime());
+  if (closed.length || pruned) writeSessionRegistry(vaultBase, registry);
   for (const { session_file, ended_at } of closed) {
     try { closeSessionNoteFile(vaultBase, session_file, ended_at); } catch { /* nunca derruba o sweep */ }
   }
@@ -335,15 +361,20 @@ export function closeSessionNote(content, endedAt) {
   return next;
 }
 
-export function slugify(text, fallback = 'nota') {
-  const slug = String(text || '')
+export function slugify(text, fallback = 'nota', maxLen = 60) {
+  let slug = String(text || '')
     .normalize('NFD')
     .replace(/[\u0300-\u036f]/g, '')
     .toLowerCase()
     .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .slice(0, 70)
-    .replace(/-+$/g, '');
+    .replace(/^-+|-+$/g, '');
+  if (slug.length > maxLen) {
+    // Truncate on a word boundary (last '-' before maxLen) when a reasonable one exists,
+    // instead of cutting mid-word \u2014 keeps generated note names readable.
+    const cut = slug.slice(0, maxLen);
+    const lastDash = cut.lastIndexOf('-');
+    slug = (lastDash > maxLen * 0.5 ? cut.slice(0, lastDash) : cut).replace(/-+$/g, '');
+  }
   return slug || fallback;
 }
 

package/hooks/pricing.json

@@ -30,6 +30,13 @@
       "cachedInput": 0.3,
       "output": 15
     },
+    "claude-sonnet-5": {
+      "label": "Claude Sonnet 5 API",
+      "provider": "anthropic",
+      "input": 3,
+      "cachedInput": 0.3,
+      "output": 15
+    },
     "claude-haiku-4.5": {
       "label": "Claude Haiku 4.5 API",
       "provider": "anthropic",

package/hooks/session-stop.mjs

@@ -53,7 +53,11 @@ function shouldIgnoreUserText(text) {
     || /^# AGENTS\.md instructions/.test(trimmed)
     || trimmed.startsWith('<permissions instructions>')
     || trimmed.includes('You are Codex, a coding agent')
-    || trimmed.startsWith('## Memory');
+    || trimmed.startsWith('## Memory')
+    // Harness utility meta-prompts (title generation, classifiers) — not real user turns; they
+    // were leaking into note titles/summaries on import.
+    || /^Generate a concise( UI)? title/i.test(trimmed)
+    || /^You are a helpful assistant\. You will be presented with a user prompt/i.test(trimmed);
 }
 
 function addUnique(list, value) {
@@ -1086,12 +1090,18 @@ function main() {
     findLinkedDerivedNotes(vaultBase, sessionRel),
   );
   finalizeSessionFile(sessionPath, tx, created, endedAt);
-  // Link bidirecional sessão↔change ativa no grafo Obsidian. Fail-quiet: nunca derruba o Stop.
+  // Link durável sessão↔change: uma seção "Mudanças" ANTES de `## Encerramento`. O append antigo
+  // (após o Encerramento) era apagado a cada reopen por stripClosingSection, perdendo a aresta do
+  // grafo quando a change fechava antes do turno seguinte. Aqui sobrevive ao reopen e acumula toda
+  // change que passou pela sessão (upsertListSection deduplica). Fail-quiet: nunca derruba o Stop.
   try {
     const chgLink = activeChangeLink(vaultBase);
-    if (chgLink) {
-      const cur = readFileSync(sessionPath, 'utf8');
-      if (!cur.includes(chgLink)) writeFileSync(sessionPath, `${cur.trimEnd()}\n\n${chgLink}\n`, 'utf8');
+    const wl = (chgLink.match(/\[\[[^\]]+\]\]/) || [])[0];
+    if (wl) {
+      let cur = readFileSync(sessionPath, 'utf8');
+      cur = ensureSection(cur, 'Mudanças', '\n## Encerramento');
+      cur = upsertListSection(cur, 'Mudanças', [`- ${wl}`], null);
+      writeFileSync(sessionPath, cur, 'utf8');
     }
   } catch { /* nunca derruba o Stop */ }
   writeControl(vaultBase, {

package/hooks/token-usage.mjs

@@ -41,6 +41,13 @@ const DEFAULT_PRICE_REFERENCE = {
     cachedInput: 0.3,
     output: 15,
   },
+  'claude-sonnet-5': {
+    label: 'Claude Sonnet 5 API',
+    provider: 'anthropic',
+    input: 3,
+    cachedInput: 0.3,
+    output: 15,
+  },
   'claude-haiku-4.5': {
     label: 'Claude Haiku 4.5 API',
     provider: 'anthropic',
@@ -79,6 +86,14 @@ const MODEL_ALIASES = {
   'gpt-5.5': 'gpt-5.5',
   'gpt-5_5': 'gpt-5.5',
   'openai/gpt-5.5': 'gpt-5.5',
+  // Older/adjacent Codex model ids: priced approximately at the gpt-5.5 tier until confirmed
+  // (better a close estimate than a silent $0). Codex sessions surface these via session_meta.
+  'gpt-5.4': 'gpt-5.5',
+  'gpt-5-4': 'gpt-5.5',
+  'gpt-5.4-mini': 'gpt-5.5',
+  'gpt-5.3-codex': 'gpt-5.5',
+  'gpt-5.3': 'gpt-5.5',
+  'openai/gpt-5.4': 'gpt-5.5',
   'claude-opus-4.7': 'claude-opus-4.7',
   'claude-opus-4-7': 'claude-opus-4.7',
   'anthropic/claude-opus-4.7': 'claude-opus-4.7',
@@ -91,6 +106,9 @@ const MODEL_ALIASES = {
   'claude-sonnet-4-6': 'claude-sonnet-4.6',
   'anthropic/claude-sonnet-4.6': 'claude-sonnet-4.6',
   'anthropic/claude-sonnet-4-6': 'claude-sonnet-4.6',
+  'claude-sonnet-5': 'claude-sonnet-5',
+  'claude-sonnet-5-0': 'claude-sonnet-5',
+  'anthropic/claude-sonnet-5': 'claude-sonnet-5',
   'claude-haiku-4.5': 'claude-haiku-4.5',
   'claude-haiku-4-5': 'claude-haiku-4.5',
   'claude-haiku-4-5-20251001': 'claude-haiku-4.5',
@@ -191,7 +209,9 @@ export function addUsage(target, usage) {
 
 function normalizeModelName(model) {
   const clean = String(model || 'unknown').trim() || 'unknown';
-  const lower = clean.toLowerCase();
+  // Strip a trailing context-window tag (e.g. `claude-opus-4-8[1m]`, `claude-fable-5[1m]`) so the
+  // 1M variant of ANY model maps to its base price instead of falling through to $0.
+  const lower = clean.toLowerCase().replace(/\[[^\]]*\]$/, '');
   if (MODEL_ALIASES[lower]) return MODEL_ALIASES[lower];
   // Fallback: remove sufixo de data (ex.: claude-opus-4-8-20260528) e tenta de novo.
   const noDate = lower.replace(/-\d{8}$/, '');
@@ -280,7 +300,9 @@ function shouldIgnoreUserText(text) {
     || text.startsWith('<command-name>')
     || text.startsWith('<ide_')
     || text.startsWith('## Memory')
-    || text.includes('You are Codex, a coding agent');
+    || text.includes('You are Codex, a coding agent')
+    || /^Generate a concise( UI)? title/i.test(text)
+    || /^You are a helpful assistant\. You will be presented with a user prompt/i.test(text);
 }
 
 function emptyParseResult(transcriptPath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "description": "A persistent-memory harness for AI coding agents on your Obsidian vault: turn-by-turn session capture plus a native, zero-dependency spec→change→verify→archive loop (sensor-gated, independent verdict, mutation discrimination). Local-first, agent-agnostic (Claude Code, Codex, Cursor…).",
   "type": "module",
   "bin": {

package/src/change.mjs

@@ -171,6 +171,15 @@ export function runChange(argv) {
         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);
+      // Evidence freshness: block if tarefas.md changed since verify sealed the evidence
+      // (e.g. a sensor task added/edited after the last green verify).
+      if (required.length) {
+        let evHash = '';
+        try { evHash = readFileSync(join(dir, '.evidence-hash'), 'utf8').trim(); } catch { /* pre-seal evidence */ }
+        if (evHash && evHash !== tasksHashOf(tarefasMd)) {
+          return { ok: false, failing: ['evidência stale (tarefas.md mudou desde o último verify) — rode `wendkeep verify` de novo'] };
+        }
+      }
       const reqIds = [...new Set(tasks.map((t) => t.req).filter(Boolean))];
       let evidence = [];
       try { evidence = JSON.parse(readFileSync(join(dir, 'evidencia.json'), 'utf8')); } catch { /* no evidence */ }

package/src/init.mjs

@@ -22,6 +22,7 @@ import {
   DOTCONTEXT_GITIGNORE,
 } from './taxonomy.mjs';
 import { renderVaultReadme } from './vault-readme.mjs';
+import { seedVaultViews } from './vault-views.mjs';
 import { canInteractiveSelect, selectCompanionsInteractive } from './companion-select.mjs';
 import {
   SNIPPET_NAME,
@@ -104,8 +105,17 @@ export function mergeSettings(existing, { vaultPath, withMcp, force, companions
   for (const h of allSpecs) {
     const command = h.command ?? hookCommand(h.name);
     const groups = Array.isArray(s.hooks[h.event]) ? [...s.hooks[h.event]] : [];
-    const present = groups.some((g) => (g.hooks || []).some((x) => x.command === command));
-    if (present && !force) {
+    const owning = groups.find((g) => (g.hooks || []).some((x) => x.command === command));
+    if (owning) {
+      // Already wired: never add a duplicate group (the old `if (present && !force)` fell through
+      // under --force and appended a second identical group). Under --force, refresh the managed
+      // entry's fields in place — without disturbing any sibling hooks the user grouped with it.
+      if (force) {
+        const hk = owning.hooks.find((x) => x.command === command);
+        hk.timeout = h.timeout;
+        if (h.statusMessage) hk.statusMessage = h.statusMessage;
+        if (h.matcher && (owning.hooks || []).length === 1) owning.matcher = h.matcher;
+      }
       s.hooks[h.event] = groups;
       continue;
     }
@@ -355,7 +365,13 @@ export async function runInit(argv) {
     try { scripts = JSON.parse(readFileSync(join(projectPath, 'package.json'), 'utf8')).scripts || {}; } catch { /* no package.json */ }
     writeFileSync(sensorsFile, renderSensorsJson(scripts), 'utf8');
   }
-  log(`  [1/4] vault taxonomy: ${folders.length} folders (${created} created, locale ${loc.id})${readmeNote}, .brain + change/spec + sensors seeded`);
+  // Generated Bases + Dashboard MOC (folder-filtered views over the taxonomy) — non-destructive.
+  let viewsNote = '';
+  try {
+    const views = seedVaultViews(vaultPath);
+    if (views.length) viewsNote = `, ${views.length} view(s) + dashboard`;
+  } catch { /* views são bônus — nunca derrubam o init */ }
+  log(`  [1/4] vault taxonomy: ${folders.length} folders (${created} created, locale ${loc.id})${readmeNote}, .brain + change/spec + sensors seeded${viewsNote}`);
   // Deliver the seeded defs (agents + wk process skills) to the project so they're
   // usable immediately — no separate `wendkeep sync-defs` step needed.
   const synced = syncDefs(vaultPath, projectPath);

package/src/vault-views.mjs

@@ -0,0 +1,99 @@
+// Generated Obsidian Bases + a Dashboard MOC — the vault's structural index (0.23.0).
+// Each taxonomy folder gets a folder-filtered `.base` (NOT tag-filtered: a tag filter hid ~1/3
+// of the corpus in production) and 00-Dashboard.md embeds them. Locale-aware; non-destructive
+// (never overwrites a user's own base) unless force is passed. Zero runtime deps.
+import { existsSync, writeFileSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
+import { getLocale } from '../hooks/locale.mjs';
+
+// Per-area view: which folder, which frontmatter columns, and their display labels.
+function areaSpecs(loc) {
+  const f = loc.folders;
+  const en = loc.id === 'en';
+  const date = en ? 'Date' : 'Data';
+  return [
+    { key: 'sessoes', folder: f.sessions, title: en ? 'Sessions' : 'Sessões',
+      cols: ['date', 'provider', 'custo_modelo_usd', 'prompts', 'tool_calls'],
+      labels: { date, provider: en ? 'Agent' : 'Agente', custo_modelo_usd: 'US$', prompts: 'Prompts', tool_calls: 'Tools' } },
+    { key: 'decisoes', folder: f.decisions, title: en ? 'Decisions' : 'Decisões',
+      cols: ['date', 'status'], labels: { date, status: 'Status' } },
+    { key: 'bugs', folder: f.bugs, title: 'Bugs',
+      cols: ['date', 'status', 'severity'], labels: { date, status: 'Status', severity: en ? 'Severity' : 'Severidade' } },
+    { key: 'aprendizados', folder: f.learnings, title: en ? 'Learnings' : 'Aprendizados',
+      cols: ['date'], labels: { date } },
+    { key: 'specs', folder: f.specs, title: 'Specs', cols: ['date'], labels: { date } },
+    { key: 'mudancas', folder: f.changes, title: en ? 'Changes' : 'Mudanças',
+      cols: ['date', 'status'], labels: { date, status: 'Status' } },
+  ];
+}
+
+// A minimal, valid Base: folder filter + one table view. No formulas (that's where Base syntax
+// errors hide) — the folder filter is the whole fix.
+export function renderBase(spec) {
+  const props = spec.cols.map((c) => `  ${c}:\n    displayName: ${spec.labels[c] || c}`).join('\n');
+  const order = ['file.name', ...spec.cols].map((c) => `      - ${c}`).join('\n');
+  return `filters:
+  and:
+    - file.inFolder("${spec.folder}")
+    - file.ext == "md"
+properties:
+${props}
+views:
+  - type: table
+    name: ${spec.title}
+    order:
+${order}
+`;
+}
+
+export function renderDashboard(specs, en) {
+  const blocks = specs.map((s) => `## ${s.title}\n\n![[${s.key}.base]]`).join('\n\n---\n\n');
+  return `---
+tags:
+  - dashboard
+cssclasses:
+  - topic-dashboard
+---
+
+# ${en ? 'Vault — Overview' : 'Vault — Visão Geral'}
+
+> ${en ? 'Generated by wendkeep. Each section embeds a folder-filtered Base view (needs the Obsidian Bases core plugin).' : 'Gerado pelo wendkeep. Cada seção embeda uma view Base filtrada por pasta (requer o core plugin Bases do Obsidian).'}
+
+---
+
+${blocks}
+`;
+}
+
+// Write one `<key>.base` per area + 00-Dashboard.md. Non-destructive unless force. Returns the
+// list of files written.
+export function seedVaultViews(vaultBase, { force = false } = {}) {
+  const loc = getLocale(vaultBase);
+  const specs = areaSpecs(loc);
+  const written = [];
+  for (const s of specs) {
+    const p = join(vaultBase, `${s.key}.base`);
+    if (force || !existsSync(p)) { writeFileSync(p, renderBase(s), 'utf8'); written.push(`${s.key}.base`); }
+  }
+  const dash = join(vaultBase, '00-Dashboard.md');
+  if (force || !existsSync(dash)) { writeFileSync(dash, renderDashboard(specs, loc.id === 'en'), 'utf8'); written.push('00-Dashboard.md'); }
+  return written;
+}
+
+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;
+}
+
+// `wendkeep dashboard [--vault P] [--force]` — (re)generate the Bases + Dashboard.
+export function runDashboard(argv) {
+  const vaultRaw = opt(argv, '--vault') || process.env.OBSIDIAN_VAULT_PATH;
+  if (!vaultRaw) { process.stderr.write('wendkeep dashboard: no vault (--vault or OBSIDIAN_VAULT_PATH).\n'); process.exit(2); }
+  const vaultBase = isAbsolute(vaultRaw) ? vaultRaw : resolve(process.cwd(), vaultRaw);
+  if (!existsSync(vaultBase)) { process.stderr.write(`wendkeep dashboard: vault not found: ${vaultBase}\n`); process.exit(2); }
+  const written = seedVaultViews(vaultBase, { force: argv.includes('--force') });
+  process.stdout.write(written.length ? `dashboard: ${written.length} arquivo(s) — ${written.join(', ')}\n` : 'dashboard: nada a fazer (use --force para regenerar)\n');
+  process.exit(0);
+}

package/src/verify.mjs

@@ -38,6 +38,9 @@ export function runVerify(argv) {
   const sensors = loadSensors(projectRoot);
   const evidence = runSensors(sensors, ids, { cwd: projectRoot });
   writeFileSync(join(changeDir, 'evidencia.json'), `${JSON.stringify(evidence, null, 2)}\n`, 'utf8');
+  // Freshness seal: bind this evidence to the tarefas.md it was produced against, so the archive
+  // gate can reject evidence gone stale (a sensor task added after this verify run).
+  writeFileSync(join(changeDir, '.evidence-hash'), tasksHashOf(tarefas), 'utf8');
 
   // 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