wendkeep 0.29.2 → 0.31.0

package/hooks/decision-capture.mjs

@@ -3,16 +3,36 @@
 // options, this records the decision — the question, EVERY option (label + description), and the
 // user's choice — as a note in 04-Decisões, wikilinked to the session. Explicit, high-signal
 // decisions get full traceability in the graph (better than heuristic extraction). Fail-open.
-import { existsSync, writeFileSync } from 'fs';
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { pathToFileURL } from 'url';
 import {
   readHookInput, writeHookOutput, getVaultBase, providerMeta, ensureDir, formatDate,
   formatLocalIso, monthFolderRelFromDateStr, slugify, findActiveSessionByTranscript,
-  wikilinkFromRel, readControl, toVaultRelative,
+  wikilinkFromRel, readControl, toVaultRelative, getNextAdrNumber, derivedContentKey,
 } from './obsidian-common.mjs';
 import { getLocale } from './locale.mjs';
 
+// Decision notes follow the ADR naming convention: ADR-NNNN-<slug>, NNNN a 4-digit sequential
+// number assigned in the order decisions are made (getNextAdrNumber scans the whole 04-Decisões).
+export const padAdr = (n) => String(n).padStart(4, '0');
+
+// Dedup is content-based now (the filename carries a fresh ADR number, so it can't dedup): a
+// decision already recorded (same content_key) in the target folder is not written again.
+export function decisionKeyExists(dir, key) {
+  if (!key) return false;
+  let names;
+  try { names = readdirSync(dir); } catch { return false; }
+  for (const n of names) {
+    if (!n.endsWith('.md')) continue;
+    try {
+      const m = readFileSync(join(dir, n), 'utf8').match(/^content_key:\s*"?(.*?)"?\s*$/m);
+      if (m && m[1] === key) return true;
+    } catch { /* nota ilegível */ }
+  }
+  return false;
+}
+
 // The AskUserQuestion tool_output reads: `... "Question"="chosen labels"  "Q2"="..."`.
 export function parseAnswers(output) {
   const map = {};
@@ -25,10 +45,11 @@ export function parseAnswers(output) {
 const clean = (s) => String(s || '').replace(/\r/g, '').replace(/\n{3,}/g, '\n\n').trim();
 
 // Render the decision note from an AskUserQuestion tool call.
-export function buildDecisionCaptureNote({ questions, answers, dateStr, startedAt, sessionRel, provider, localeId }) {
+export function buildDecisionCaptureNote({ questions, answers, dateStr, startedAt, sessionRel, provider, localeId, adrNum = 0, contentKey = '' }) {
   const en = localeId === 'en';
   const src = sessionRel ? `\n  - "${wikilinkFromRel(sessionRel)}"` : ' []';
   const title = clean(questions[0]?.question || (en ? 'User decision' : 'Decisão do usuário')).slice(0, 90);
+  const adrLabel = adrNum ? `ADR-${padAdr(adrNum)} — ` : '';
 
   const blocks = questions.map((q) => {
     const chosen = (answers[clean(q.question)] || '').split(',').map((s) => s.trim()).filter(Boolean);
@@ -52,6 +73,7 @@ subtype: user-choice
 date: ${dateStr}
 started_at: ${startedAt}
 provider: ${provider.id}
+${adrNum ? `adr: ${adrNum}\n` : ''}content_key: "${contentKey}"
 cssclasses:
   - topic-decision
 tags:
@@ -60,7 +82,7 @@ tags:
 source:${src}
 ---
 
-# ${title}
+# ${adrLabel}${title}
 
 > ${en ? 'Decision captured from an interactive question (options + the user\'s choice).' : 'Decisão capturada de uma pergunta interativa (opções + a escolha do usuário).'}
 
@@ -99,7 +121,7 @@ export function extractProseDecisions(tx) {
 }
 
 // Write one decision note per extracted prose decision (same shape as the hook capture).
-// Deduped by filename (day + question slug). Returns the vault-relative paths written.
+// Deduped by content_key (question). Returns the vault-relative paths written.
 export function captureProseDecisions(vaultBase, { tx, dateStr, sessionRel, provider, localeId }) {
   const written = [];
   const decisions = extractProseDecisions(tx);
@@ -107,14 +129,17 @@ export function captureProseDecisions(vaultBase, { tx, dateStr, sessionRel, prov
   const loc = getLocale(vaultBase);
   const dir = join(vaultBase, monthFolderRelFromDateStr(loc.folders.decisions, dateStr, vaultBase));
   for (const d of decisions) {
+    const contentKey = derivedContentKey(d.question);
     ensureDir(dir);
-    const filePath = join(dir, `${dateStr}-escolha-${slugify(d.question, 'decisao', 50)}.md`);
+    if (decisionKeyExists(dir, contentKey)) continue;
+    const adrNum = getNextAdrNumber(vaultBase);
+    const filePath = join(dir, `ADR-${padAdr(adrNum)}-${slugify(d.question, 'decisao', 50)}.md`);
     if (existsSync(filePath)) continue;
     writeFileSync(filePath, buildDecisionCaptureNote({
       questions: [{ question: d.question, multiSelect: false, options: d.options.map((label) => ({ label, description: '' })) }],
       answers: { [d.question]: d.answer },
       dateStr, startedAt: `${dateStr}T00:00:00`, sessionRel,
-      provider: provider || providerMeta(tx?.provider), localeId: localeId || loc.id,
+      provider: provider || providerMeta(tx?.provider), localeId: localeId || loc.id, adrNum, contentKey,
     }), 'utf-8');
     written.push(toVaultRelative(vaultBase, filePath));
   }
@@ -137,12 +162,15 @@ export function captureDecision(vaultBase, input) {
 
   const dir = join(vaultBase, monthFolderRelFromDateStr(loc.folders.decisions, dateStr, vaultBase));
   ensureDir(dir);
+  const contentKey = derivedContentKey(questions[0]?.question || 'decisao');
+  if (decisionKeyExists(dir, contentKey)) return { rel: '', skipped: true };
+  const adrNum = getNextAdrNumber(vaultBase);
   const slug = slugify(questions[0]?.question || 'decisao', 'decisao', 50);
-  const filePath = join(dir, `${dateStr}-escolha-${slug}.md`);
+  const filePath = join(dir, `ADR-${padAdr(adrNum)}-${slug}.md`);
   if (existsSync(filePath)) return { rel: toVaultRelative(vaultBase, filePath), skipped: true };
 
   writeFileSync(filePath, buildDecisionCaptureNote({
-    questions, answers, dateStr, startedAt: formatLocalIso(now), sessionRel, provider, localeId: loc.id,
+    questions, answers, dateStr, startedAt: formatLocalIso(now), sessionRel, provider, localeId: loc.id, adrNum, contentKey,
   }), 'utf-8');
   return { rel: toVaultRelative(vaultBase, filePath), skipped: false };
 }

package/hooks/linked-notes.mjs

@@ -38,7 +38,7 @@ function normalizeInline(text, max = 0) {
 
 function adrFileExistsBySlug(dir, slug) {
   try {
-    return readdirSync(dir).find((file) => /^ADR-\d{3}-.+\.md$/i.test(file) && file.includes(`-${slug}`));
+    return readdirSync(dir).find((file) => /^ADR-\d+-.+\.md$/i.test(file) && file.includes(`-${slug}`));
   } catch {
     return '';
   }
@@ -333,7 +333,7 @@ export function extractDecisionDetails(tx) {
 
 export function buildDecisionNoteContent(decision, adrNum, dateStr, sessionRel, provider = providerMeta(), contentKey = derivedContentKey(decision.title), localeId = 'pt-BR') {
   const L = noteLabels(localeId);
-  const adrId = `ADR-${String(adrNum).padStart(3, '0')}`;
+  const adrId = `ADR-${String(adrNum).padStart(4, '0')}`;
   return `---
 type: decision
 date: ${dateStr}
@@ -558,7 +558,7 @@ export function createLinkedNotes(vaultBase, dateStr, sessionRel, tx, options =
     if (!alreadyHasKey(existingKeys.decisions, decisionKey)) {
       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 fileName = existing || `ADR-${String(getNextAdrNumber(vaultBase)).padStart(4, '0')}-${titleSlug}.md`;
       const filePath = join(decisionsDir, fileName);
       if (!existsSync(filePath)) {
         const adrNum = Number(fileName.match(/^ADR-(\d+)/i)?.[1]) || getNextAdrNumber(vaultBase);

package/hooks/plan-capture.mjs

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+// PostToolUse hook (matcher: ExitPlanMode). A ponte determinística entre o plan mode do Claude
+// Code e o vault: quando o usuário APROVA um plano, o plano vira registro — anexado à change
+// ativa, ou uma change nova criada e preenchida a partir dele (proposta do Contexto, design do
+// corpo, tarefas dos checkboxes). Não depende de a LLM lembrar do processo. Rejeição = no-op.
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { formatDate, getVaultBase, readHookInput, slugify, writeHookOutput } from './obsidian-common.mjs';
+import { activeChange, newChange } from './change-core.mjs';
+import { getLocale } from './locale.mjs';
+
+// O plano aprovado chega por um de três canais, conforme a versão do Claude Code:
+// tool_input.plan (legado), o bloco "## Approved Plan" do tool_response, ou o arquivo de plano
+// citado em "saved to: <path>". Rejeição (ou ausência de sinal de aprovação) → null.
+export function extractPlan(input) {
+  const tr = input?.tool_response ?? input?.toolResponse ?? '';
+  const resp = typeof tr === 'string' ? tr : JSON.stringify(tr || '');
+  if (/doesn'?t want to proceed|user rejected|rejected the plan/i.test(resp)) return null;
+  if (!/approved (your |the )?plan|Approved Plan/i.test(resp)) return null;
+  const direct = input?.tool_input?.plan ?? input?.toolInput?.plan;
+  if (direct && String(direct).trim()) return String(direct);
+  const marker = resp.match(/## Approved Plan[^\n]*:\s*\n([\s\S]+)$/);
+  if (marker && marker[1].trim()) return marker[1].trim();
+  const path = resp.match(/saved to:\s*([^\n]+\.md)/i);
+  if (path) { try { return readFileSync(path[1].trim(), 'utf8'); } catch { /* arquivo inacessível */ } }
+  return null;
+}
+
+export function planSlug(plan) {
+  const h1 = String(plan || '').match(/^#\s+(.+)$/m);
+  return h1 ? slugify(h1[1], 'plano-aprovado', 60) : 'plano-aprovado';
+}
+
+function sectionBody(plan, headings) {
+  for (const h of headings) {
+    const m = String(plan).match(new RegExp(`^##\\s+${h}\\s*\\n([\\s\\S]*?)(?=\\n##\\s|$)`, 'm'));
+    if (m && m[1].trim()) return m[1].trim();
+  }
+  return '';
+}
+
+// Checkboxes do plano viram tarefas numeradas 1.N (estado [x] preservado). [] quando não há.
+export function planTasks(plan) {
+  const boxes = [...String(plan || '').matchAll(/^\s*-\s+\[( |x)\]\s+(.+)$/gm)];
+  return boxes.map((m, i) => `- [${m[1]}] 1.${i + 1} ${m[2].trim()}`);
+}
+
+export function capturePlan(vaultBase, input) {
+  const plan = extractPlan(input);
+  if (!plan) return null;
+  const loc = getLocale(vaultBase);
+  const en = loc.id === 'en';
+  const dateStr = formatDate(new Date());
+  const rawNote = `---\ntype: plan\ndate: ${dateStr}\ntags:\n  - plano\n---\n\n${plan.trim()}\n`;
+
+  const active = activeChange(vaultBase);
+  if (active) {
+    const dir = join(vaultBase, loc.folders.changes, active);
+    writeFileSync(join(dir, 'plano-aprovado.md'), rawNote, 'utf8');
+    return {
+      slug: active, created: false,
+      context: `<plan_captured>\n${en
+        ? `Approved plan attached to the active change "${active}" (plano-aprovado.md). Sync tarefas.md with the plan's tasks.`
+        : `Plano aprovado anexado à change ativa "${active}" (plano-aprovado.md). Sincronize tarefas.md com as tarefas do plano.`}\n</plan_captured>`,
+    };
+  }
+
+  const slug = planSlug(plan);
+  newChange(vaultBase, slug, { dateStr });
+  const dir = join(vaultBase, loc.folders.changes, slug);
+  const ctx = sectionBody(plan, ['Contexto', 'Context']) || plan.trim().split('\n').slice(0, 6).join('\n');
+  writeFileSync(join(dir, 'proposta.md'), `---
+type: change
+status: active
+date: ${dateStr}
+cssclasses:
+  - topic-change
+tags:
+  - mudanca
+source: []
+specs: []
+---
+
+# ${slug}
+
+${en ? '## Why' : '## Por quê'}
+
+${ctx}
+
+${en ? '## What changes' : '## O que muda'}
+
+${en ? 'See design.md and plano-aprovado.md (captured from the approved plan-mode plan).' : 'Ver design.md e plano-aprovado.md (capturados do plano aprovado no plan mode).'}
+`, 'utf8');
+  writeFileSync(join(dir, 'design.md'), `# ${slug} — design\n\n${plan.trim()}\n`, 'utf8');
+  const tasks = planTasks(plan);
+  if (tasks.length) writeFileSync(join(dir, 'tarefas.md'), `# ${slug} — ${en ? 'tasks' : 'tarefas'}\n\n${tasks.join('\n')}\n`, 'utf8');
+  writeFileSync(join(dir, 'plano-aprovado.md'), rawNote, 'utf8');
+  return {
+    slug, created: true,
+    context: `<plan_captured>\n${en
+      ? `Approved plan recorded in the vault: change "${slug}" created and set active (${loc.folders.changes}/${slug}/). Review tarefas.md${tasks.length ? '' : ' — the plan had no checkboxes, fill the tasks'} and follow the a2 loop (wk-tdd per task, \`wendkeep change done <id>\`, \`wendkeep verify\`).`
+      : `Plano aprovado — change "${slug}" registrada no vault e ativa (${loc.folders.changes}/${slug}/). Revise tarefas.md${tasks.length ? '' : ' — o plano não tinha checkboxes, preencha as tarefas'} e siga o loop a2 (wk-tdd por tarefa, \`wendkeep change done <id>\`, \`wendkeep verify\`).`}\n</plan_captured>`,
+  };
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  try {
+    const input = readHookInput();
+    const r = capturePlan(getVaultBase(input), input);
+    if (!r) { writeHookOutput({}); }
+    else writeHookOutput({ hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: r.context } });
+  } catch {
+    writeHookOutput({});
+  }
+}

package/hooks/renumber-decisions.mjs

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+// Retroactive ADR renumbering (0.30.0). The decision folder accumulated three naming eras:
+// canonical ADR-NNN, dated `YYYY-MM-DD-escolha-<slug>` (hook capture pre-0.30), and hand-written
+// `YYYY-MM-DD-<slug>`. This renumbers EVERY note in 04-Decisões to `ADR-<NNNN>-<slug>` in strict
+// chronological order (the order decisions were made), renames the files in place, updates every
+// wikilink to them across the whole vault, and normalizes each note's `type`/`adr`/H1. Idempotent:
+// running it again on an already-canonical vault is a no-op (same order, same names).
+import { readdirSync, readFileSync, renameSync, writeFileSync, existsSync } from 'node:fs';
+import { join, dirname, relative } from 'node:path';
+import { getLocale } from './locale.mjs';
+
+export const padAdr = (n) => String(n).padStart(4, '0');
+
+// Every .md under 04-Decisões, absolute + vault-relative (posix slashes for wikilinks).
+function walkDecisions(vaultBase, decisionsDir) {
+  const out = [];
+  const walk = (dir) => {
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      const abs = join(dir, e.name);
+      if (e.isDirectory()) walk(abs);
+      else if (e.name.endsWith('.md')) {
+        out.push({ abs, rel: relative(vaultBase, abs).replaceAll('\\', '/'), base: e.name });
+      }
+    }
+  };
+  walk(join(vaultBase, decisionsDir));
+  return out;
+}
+
+// Chronological sort key: date, then time, then existing ADR number, then filename — all derived
+// from (in priority) frontmatter, filename prefix, and the dated folder path.
+export function decisionSortKey({ abs, base, content }) {
+  const c = content ?? (existsSync(abs) ? safeRead(abs) : '');
+  const fmDate = c.match(/^date:\s*(\d{4}-\d{2}-\d{2})/m);
+  const fnDate = base.match(/^(\d{4}-\d{2}-\d{2})/);
+  const folderDate = abs.replaceAll('\\', '/').match(/\/(\d{4})\/(\d{2})-[^/]+\/DIA\s+(\d{1,2})\//i);
+  let date = '9999-12-31';
+  if (fmDate) date = fmDate[1];
+  else if (fnDate) date = fnDate[1];
+  else if (folderDate) date = `${folderDate[1]}-${folderDate[2]}-${String(folderDate[3]).padStart(2, '0')}`;
+
+  const fmTime = c.match(/^started_at:\s*\S*T(\d{2}:\d{2}:\d{2})/m);
+  const srcTime = c.match(/\[\[[^\]]*\/(\d{2})-(\d{2})-[^\]]*\]\]/); // session wikilink HH-MM prefix
+  let time = '00:00:00';
+  if (fmTime) time = fmTime[1];
+  else if (srcTime) time = `${srcTime[1]}:${srcTime[2]}:00`;
+
+  const adr = base.match(/^ADR-(\d+)/i);
+  const adrNum = adr ? Number(adr[1]) : 999999;
+  return `${date}T${time}#${String(adrNum).padStart(6, '0')}#${base}`;
+}
+
+function safeRead(abs) {
+  try { return readFileSync(abs, 'utf8'); } catch { return ''; }
+}
+
+// Descriptive slug from any of the three eras' filenames.
+export function slugFromDecisionName(base) {
+  let s = base.replace(/\.md$/i, '');
+  s = s.replace(/^ADR-\d+-/i, '');
+  s = s.replace(/^\d{4}-\d{2}-\d{2}-/, '');
+  s = s.replace(/^escolha-/i, '');
+  return s || 'decisao';
+}
+
+// Normalize one decision note's body: type -> decision, adr: <num>, and an `ADR-NNNN — ` H1 prefix.
+export function normalizeDecisionContent(content, adrNum) {
+  let c = String(content || '');
+  const label = `ADR-${padAdr(adrNum)}`;
+
+  // type: decisao|decisão|decision  ->  decision
+  if (/^type:\s*.*$/m.test(c)) c = c.replace(/^type:\s*.*$/m, 'type: decision');
+  else c = c.replace(/^---\n/, `---\ntype: decision\n`);
+
+  // adr: <num>  (replace if present, else insert right after the type line)
+  if (/^adr:\s*.*$/m.test(c)) c = c.replace(/^adr:\s*.*$/m, `adr: ${adrNum}`);
+  else c = c.replace(/^type: decision$/m, `type: decision\nadr: ${adrNum}`);
+
+  // H1: strip any existing `ADR-\d+ — ` prefix, then prepend the canonical label.
+  c = c.replace(/^#\s+(.*)$/m, (_, title) => {
+    const bare = title.replace(/^ADR-\d+\s*[—–-]\s*/i, '').trim();
+    return `# ${label} — ${bare}`;
+  });
+  return c;
+}
+
+// Replace every wikilink to a renamed note across one file's text. `renames` carries the old/new
+// vault-relative path (no extension) and basename so both full-path and basename links are caught.
+export function rewriteLinks(content, renames) {
+  let c = String(content || '');
+  for (const r of renames) {
+    if (r.oldRelNoExt === r.newRelNoExt) continue;
+    c = c.split(`[[${r.oldRelNoExt}]]`).join(`[[${r.newRelNoExt}]]`);
+    c = c.split(`[[${r.oldRelNoExt}|`).join(`[[${r.newRelNoExt}|`);
+    c = c.split(`[[${r.oldBaseNoExt}]]`).join(`[[${r.newBaseNoExt}]]`);
+    c = c.split(`[[${r.oldBaseNoExt}|`).join(`[[${r.newBaseNoExt}|`);
+    // Best-effort: refresh a `|ADR-006]]` display alias to the new padded id.
+    if (r.oldAdrLabel) c = c.split(`|${r.oldAdrLabel}]]`).join(`|${r.newAdrLabel}]]`);
+  }
+  return c;
+}
+
+function allVaultMarkdown(vaultBase) {
+  const out = [];
+  const skip = new Set(['.git', '.obsidian', 'node_modules', '_arquivo']);
+  const walk = (dir) => {
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (e.name.startsWith('.') && e.name !== '.brain') continue;
+      const abs = join(dir, e.name);
+      if (e.isDirectory()) { if (!skip.has(e.name)) walk(abs); }
+      else if (e.name.endsWith('.md')) out.push(abs);
+    }
+  };
+  walk(vaultBase);
+  return out;
+}
+
+// Build the chronological renumber plan. Pure: reads notes, sorts, computes new names. No writes.
+export function planRenumber(vaultBase) {
+  const decisionsDir = getLocale(vaultBase).folders.decisions;
+  const notes = walkDecisions(vaultBase, decisionsDir)
+    .map((n) => ({ ...n, content: safeRead(n.abs) }))
+    .sort((a, b) => decisionSortKey(a).localeCompare(decisionSortKey(b)));
+
+  const renames = [];
+  notes.forEach((n, i) => {
+    const num = i + 1;
+    const slug = slugFromDecisionName(n.base);
+    const newBase = `ADR-${padAdr(num)}-${slug}.md`;
+    const folderRel = dirname(n.rel);
+    const newRel = folderRel === '.' ? newBase : `${folderRel}/${newBase}`;
+    const oldAdr = n.base.match(/^ADR-(\d+)/i);
+    renames.push({
+      num, slug,
+      oldAbs: n.abs,
+      newAbs: join(dirname(n.abs), newBase),
+      oldRelNoExt: n.rel.replace(/\.md$/i, ''),
+      newRelNoExt: newRel.replace(/\.md$/i, ''),
+      oldBaseNoExt: n.base.replace(/\.md$/i, ''),
+      newBaseNoExt: newBase.replace(/\.md$/i, ''),
+      oldAdrLabel: oldAdr ? `ADR-${String(Number(oldAdr[1])).padStart(3, '0')}` : '',
+      newAdrLabel: `ADR-${padAdr(num)}`,
+      renamed: n.base !== newBase,
+    });
+  });
+  return renames;
+}
+
+// Execute the plan: collision-safe rename (via temp), body normalization, vault-wide link rewrite.
+export function renumberDecisions(vaultBase, { apply = false } = {}) {
+  const renames = planRenumber(vaultBase);
+  const changed = renames.filter((r) => r.renamed);
+  const report = {
+    total: renames.length,
+    renamed: changed.length,
+    normalized: 0,
+    linksUpdated: 0,
+    filesTouched: 0,
+    plan: renames.map((r) => ({ num: r.num, from: r.oldRelNoExt, to: r.newRelNoExt, renamed: r.renamed })),
+    applied: apply,
+  };
+  if (!apply) return report;
+
+  // Phase A — park every renamed source under a temp name so no target clobbers a not-yet-moved source.
+  const temps = new Map();
+  changed.forEach((r, i) => {
+    const tmp = join(dirname(r.oldAbs), `.wk-renum-${i}.tmp`);
+    renameSync(r.oldAbs, tmp);
+    temps.set(r, tmp);
+  });
+
+  // Phase B — normalize each note's body, then land it at its final path. For a renamed note we
+  // write the normalized content back over its temp and renameSync temp -> final (no delete: the
+  // temp file becomes the final file). For an unchanged name we just rewrite in place.
+  for (const r of renames) {
+    const tmp = temps.get(r);
+    if (tmp) {
+      writeFileSync(tmp, normalizeDecisionContent(safeRead(tmp), r.num), 'utf8');
+      renameSync(tmp, r.newAbs);
+    } else {
+      writeFileSync(r.newAbs, normalizeDecisionContent(safeRead(r.oldAbs), r.num), 'utf8');
+    }
+    report.normalized += 1;
+  }
+
+  // Phase C — rewrite wikilinks to any renamed note across the whole vault.
+  const linkRenames = changed;
+  for (const abs of allVaultMarkdown(vaultBase)) {
+    const before = safeRead(abs);
+    const after = rewriteLinks(before, linkRenames);
+    if (after !== before) { writeFileSync(abs, after, 'utf8'); report.filesTouched += 1; report.linksUpdated += 1; }
+  }
+  return report;
+}

package/hooks/session-stop.mjs

@@ -6,7 +6,7 @@ import { pathToFileURL } from 'url';
 import { createLinkedNotes } from './linked-notes.mjs';
 import { addUsage, costBreakdown, emptyTokenUsage, normalizeClaudeUsage, normalizeCodexUsage, priceForModel, updateSessionUsage } from './token-usage.mjs';
 import { buildBrainDigest, buildBrainIndex } from './brain-core.mjs';
-import { activeChangeLink } from './change-core.mjs';
+import { activeChangeLink, pruneChangeSentinels } from './change-core.mjs';
 import { getLocale } from './locale.mjs';
 import { upsertSubagentUsage } from './subagent-usage.mjs';
 import {
@@ -855,12 +855,19 @@ function replacePendingSection(content, pending) {
   const end = content.indexOf(closingMarker, start + marker.length);
   if (end === -1) return content;
 
+  // Preserva seções que outros writers inseriram dentro do span (## Subagents & Workflows,
+  // ## Progresso do plano, ## Mudanças…) — só o texto das Pendências em si é regenerado.
+  const span = content.slice(start + marker.length, end);
+  const innerIdx = span.indexOf('\n## ');
+  const preserved = innerIdx === -1 ? '' : span.slice(innerIdx).trimEnd();
+
   return [
     content.slice(0, start).trimEnd(),
     '',
     '## Pendências',
     '',
     formatPendingSection(pending),
+    ...(preserved ? [preserved] : []),
     content.slice(end),
   ].join('\n');
 }
@@ -1135,6 +1142,9 @@ function main() {
     process.stderr.write(`[wendkeep] brain index/digest falhou: ${error.message}\n`);
   }
 
+  // GC das sentinelas dos hooks de lifecycle (>7 dias) — fail-quiet, nunca derruba o Stop.
+  try { pruneChangeSentinels(vaultBase); } catch { /* bônus */ }
+
   pingObsidianVault(input.obsidian_api_key);
   writeHookOutput({});
 }

package/hooks/spec-core.mjs

@@ -1,7 +1,7 @@
 // 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 { readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ensureDir } from './obsidian-common.mjs';
 import { getLocale } from './locale.mjs';
@@ -87,6 +87,30 @@ export function parseSpecsList(propostaMd) {
   return [];
 }
 
+// Um delta ainda no estado do scaffold (só o requisito "(nome)"/"(name)", nada removido) não é
+// contrato — a promoção o filtra. Um delta com REMOVED é sempre intenção real.
+export function isPlaceholderDelta(md) {
+  const d = parseDelta(md);
+  if (d.removed.length) return false;
+  const all = [...d.added, ...d.modified];
+  if (!all.length) return true;
+  return all.every((r) => /^\((?:nome|name)\)$/.test(r.name));
+}
+
+// Capabilities com delta REAL no disco (<change>/specs/<cap>/spec.md), independente do
+// frontmatter `specs:` da proposta — o scaffold deixa `specs: []` e o buraco engolia deltas
+// preenchidos mas não listados (visto em produção: 07-Specs vazio com delta real no disco).
+export function discoverSpecDeltas(changeDir) {
+  let names = [];
+  try { names = readdirSync(join(changeDir, 'specs')); } catch { return []; }
+  const caps = [];
+  for (const cap of names) {
+    try { if (!isPlaceholderDelta(readFileSync(join(changeDir, 'specs', cap, 'spec.md'), 'utf8'))) caps.push(cap); }
+    catch { /* sem spec.md */ }
+  }
+  return caps;
+}
+
 // Merge each capability's delta (in the change) into the living spec in 07-Specs.
 export function promoteSpecs(vaultBase, changeDir, specs, { changeWikilink, dateStr } = {}) {
   const loc = getLocale(vaultBase);

package/hooks/subagent-usage.mjs

@@ -208,7 +208,9 @@ function upsertSection(content, heading, body) {
   const esc = heading.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   const re = new RegExp(`${esc}\\n[\\s\\S]*?(?=\\n## |$)`);
   if (re.test(content)) return content.replace(re, `${body}\n`);
-  for (const anchor of ['\n## Encerramento', '\n## Issues Linear', '\n## Pendências']) {
+  // Âncora ANTES de '## Pendências': o finalize do Stop reescreve o span Pendências→Encerramento
+  // inteiro, então qualquer seção inserida lá dentro seria apagada (visto em produção).
+  for (const anchor of ['\n## Pendências', '\n## Issues Linear', '\n## Encerramento']) {
     const i = content.indexOf(anchor);
     if (i >= 0) return `${content.slice(0, i)}\n\n${body}\n${content.slice(i)}`;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.29.2",
+  "version": "0.31.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

@@ -8,6 +8,7 @@ import {
   parseTasks,
   setTaskDone,
   archiveChange,
+  abandonChange,
   scaffoldPlaceholders,
 } from '../hooks/change-core.mjs';
 import { evaluateGate, requiredSensors } from '../hooks/sensors-core.mjs';
@@ -104,8 +105,8 @@ export function runChange(argv) {
     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');
+    if (!verdict) process.stdout.write(`verdict: ausente — rode \`wendkeep verify --deep\`${reqIds.length ? ' + wk-verify' : ' (verdict trivial automático)'}\n`);
+    else if (!reqIds.length) process.stdout.write(`verdict: ${verdict.ok === true ? 'ok (trivial)' : 'não-ok — re-verifique'}\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`);
@@ -156,11 +157,11 @@ export function runChange(argv) {
     // Real gate (Pilar C): every sensor a task declared must be green in evidencia.json.
     const gate = (dir) => {
       // G0: um scaffold nunca preenchido não é uma mudança concluída — arquivar geraria um
-      // ADR falso. Bloqueia antes de qualquer outro check (o --force ainda escapa, mas a
-      // regra injetada proíbe o agente de usá-lo sem o usuário pedir).
+      // ADR falso. INESCAPÁVEL desde 0.31.0 (--force não pula — visto em produção: change
+      // 100% placeholder arquivada via --force mintou ADR falso). Saída legítima: abandon.
       const placeholders = scaffoldPlaceholders(dir);
-      if (placeholders.length && !rest.includes('--force')) {
-        return { ok: false, failing: [`scaffold não preenchido (${placeholders.join('; ')}) — preencha proposta/design/tarefas com o design e o plano antes de arquivar`] };
+      if (placeholders.length) {
+        return { ok: false, failing: [`scaffold não preenchido (${placeholders.join('; ')}) — preencha proposta/design/tarefas antes de arquivar, ou \`wendkeep change abandon ${slug}\` se a change não vai adiante (--force não pula este check)`] };
       }
       let tarefasMd = '';
       try { tarefasMd = readFileSync(join(dir, 'tarefas.md'), 'utf8'); } catch { /* no tasks */ }
@@ -185,17 +186,38 @@ export function runChange(argv) {
       try { evidence = JSON.parse(readFileSync(join(dir, 'evidencia.json'), 'utf8')); } catch { /* no evidence */ }
       const s = evaluateGate(evidence, required);
       if (!s.ok) return s;
-      // Independent verdict (Wave A): required only when the change declares [req:] tasks.
+      // Verdict SEMPRE exigido (0.31.0) — a exigência universal vive AQUI no gate; a semântica
+      // reqless→ok de evaluateVerdict (spec-core) não muda porque `verify --deep` e `change
+      // status` dependem dela. Change sem [req:] destrava com o auto-verdict do verify --deep.
       let verdict = null;
       try { verdict = JSON.parse(readFileSync(join(dir, 'verdict.json'), 'utf8')); } catch { /* none */ }
-      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'] };
+      const hash = tasksHashOf(tarefasMd);
+      if (!verdict) {
+        return { ok: false, failing: [reqIds.length
+          ? 'sem verdict — rode `wendkeep verify --deep` + skill wk-verify'
+          : 'sem verdict — rode `wendkeep verify --deep` (verdict trivial automático)'] };
+      }
+      if (verdict.ok !== true) return { ok: false, failing: ['verdict não-ok — re-verifique a change antes de arquivar'] };
+      if (verdict.tasksHash && verdict.tasksHash !== hash) {
+        return { ok: false, failing: [`verdict stale (tarefas.md mudou depois da verificação) — re-verifique: \`wendkeep verify --deep\`${reqIds.length ? ' + wk-verify' : ''}`] };
+      }
+      if (reqIds.length) {
+        const v = evaluateVerdict(verdict, reqIds, { tasksHash: hash });
+        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 incompleto: falta ${v.missing.join(', ')}`] };
+        }
       }
       return { ok: true, failing: [] };
     };
-    const r = archiveChange(vaultBase, slug, { dateStr: today(), adrNum: getNextAdrNumber(vaultBase), gate });
+    // Rastro auditável: forced só quando o --force de fato pulou G1 (tarefa aberta); trivial
+    // quando a change não declarou nenhuma prova ([req:]/[sensor:]).
+    let tasks = [];
+    try { tasks = parseTasks(readFileSync(join(vaultBase, getLocale(vaultBase).folders.changes, slug, 'tarefas.md'), 'utf8')); } catch { /* sem tarefas */ }
+    const forced = rest.includes('--force') && tasks.some((t) => !t.done);
+    const trivial = !tasks.some((t) => t.req) && !tasks.some((t) => t.sensor);
+    if (trivial) process.stderr.write('aviso: change trivial (sem [req:]/[sensor:]) — ADR marcado trivial: true\n');
+    const r = archiveChange(vaultBase, slug, { dateStr: today(), adrNum: getNextAdrNumber(vaultBase), gate, adrFlags: { forced, trivial } });
     if (!r.ok) {
       process.stderr.write(`change archive BLOCKED (gate): ${r.failing.join('; ')}\n`);
       process.exit(1);
@@ -206,6 +228,15 @@ export function runChange(argv) {
     process.exit(0);
   }
 
-  process.stderr.write(`wendkeep change: unknown subcommand "${sub}". Known: new, list, show, status, done, undone, diff, archive.\n`);
+  if (sub === 'abandon') {
+    const slug = slugArg() || activeChange(vaultBase);
+    if (!slug) { process.stderr.write('wendkeep change abandon: missing <slug> and no active change\n'); process.exit(2); }
+    const r = abandonChange(vaultBase, slug, { dateStr: today() });
+    if (!r.ok) { process.stderr.write(`wendkeep change abandon: ${r.failing.join('; ')}\n`); process.exit(2); }
+    process.stdout.write(`abandoned: ${r.archivedRel}\n`);
+    process.exit(0);
+  }
+
+  process.stderr.write(`wendkeep change: unknown subcommand "${sub}". Known: new, list, show, status, done, undone, diff, archive, abandon.\n`);
   process.exit(2);
 }