wendkeep 0.29.2 → 0.30.0

package/CHANGELOG.md

@@ -4,6 +4,30 @@ 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.30.0] — 2026-07-09
+
+### Changed
+- **Decision notes follow the ADR convention: `ADR-<NNNN>-<slug>`.** Every decision note now carries
+  a 4-digit, zero-padded sequential number assigned in the order decisions are made (`ADR-0001`,
+  `ADR-0002`, …) — replacing the old `YYYY-MM-DD-escolha-<slug>` filenames from the interactive and
+  prose captures. The number goes in the filename, in an `adr:` frontmatter field, and as an
+  `# ADR-NNNN — <title>` H1 prefix. The native `wendkeep change archive` ADR and the
+  `createLinkedNotes` heuristic ADR widen from 3 to 4 digits (`ADR-007` → `ADR-0007`) to match.
+- **Decision capture dedups by `content_key`, not by filename.** Because the filename now carries a
+  fresh ADR number it can't dedup, so a decision already recorded in the target folder (same
+  normalized question) is skipped by content — both the AskUserQuestion hook (`captureDecision`) and
+  the agnostic prose capture (`captureProseDecisions`). New `decisionKeyExists` / `padAdr` helpers.
+
+### Added
+- **`wendkeep renumber-decisions`** — retroactive fix for vaults that accumulated the three historical
+  naming eras (`ADR-NNN`, dated `escolha`, hand-written). Renumbers **every** note in 04-Decisões to
+  `ADR-<NNNN>-<slug>` in strict chronological order, renames the files in place, and **rewrites every
+  wikilink to them across the whole vault** (full-path, basename, and `|ADR-006` display aliases).
+  Normalizes each note's `type: decision` / `adr:` / H1. Preview by default (writes nothing); pass
+  `--apply` to commit the renames. Idempotent — a second run on a canonical vault is a no-op.
+  `--vault P` / `--json`. New `hooks/renumber-decisions.mjs` (`planRenumber`, `renumberDecisions`,
+  `slugFromDecisionName`, `decisionSortKey`, `normalizeDecisionContent`, `rewriteLinks`).
+
 ## [0.29.2] — 2026-07-09
 
 ### Fixed

package/bin/wendkeep.mjs

@@ -60,6 +60,9 @@ Usage:
   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 renumber-decisions   Renumber 04-Decisões to ADR-<NNNN>-<slug> in chronological order,
+                           renaming files + rewriting every wikilink. Preview by default; --apply to
+                           write. --vault P · --json.
   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
@@ -162,6 +165,11 @@ async function main() {
       runDashboard(rest);
       break;
     }
+    case 'renumber-decisions': {
+      const { runRenumberDecisions } = await import('../src/renumber.mjs');
+      runRenumberDecisions(rest);
+      break;
+    }
     case '--version':
     case '-v':
       process.stdout.write(`${version()}\n`);

package/hooks/change-core.mjs

@@ -265,7 +265,7 @@ export function archiveChange(vaultBase, slug, { gate = gateGreen, dateStr, adrN
   // — 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 num = String(adrNum).padStart(4, '0');
   const adrRel = join(adrDirRel, `ADR-${num}-${slug}.md`);
   const capLine = promoted.length
     ? `\n\nCapabilities: ${promoted.map((c) => wikilinkFromRel(join(loc.folders.specs, c))).join(', ')}.`

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/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/package.json

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

@@ -0,0 +1,32 @@
+// `wendkeep renumber-decisions` — retroactive ADR fix. Renumbers every note in 04-Decisões to
+// `ADR-<NNNN>-<slug>` in chronological order, renames the files, and rewrites every wikilink to
+// them across the vault. Preview by default; pass --apply to write. Idempotent.
+import { existsSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+import { renumberDecisions } from '../hooks/renumber-decisions.mjs';
+
+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;
+}
+
+export function runRenumberDecisions(argv) {
+  const vaultRaw = opt(argv, '--vault') || process.env.OBSIDIAN_VAULT_PATH;
+  if (!vaultRaw) { process.stderr.write('wendkeep renumber-decisions: 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 renumber-decisions: vault not found: ${vaultBase}\n`); process.exit(2); }
+
+  const apply = argv.includes('--apply');
+  const report = renumberDecisions(vaultBase, { apply });
+
+  if (argv.includes('--json')) { process.stdout.write(`${JSON.stringify(report, null, 2)}\n`); process.exit(0); }
+
+  process.stdout.write(`${report.total} decisão(ões) · ${report.renamed} a renomear${apply ? ` · ${report.filesTouched} arquivo(s) com links atualizados` : ''}\n`);
+  for (const p of report.plan.filter((x) => x.renamed)) {
+    process.stdout.write(`  ADR-${String(p.num).padStart(4, '0')}  ${p.from}\n              → ${p.to}\n`);
+  }
+  if (!apply) process.stdout.write('\nNada foi escrito (preview). Rode com --apply para renomear e atualizar os wikilinks.\n');
+  process.exit(0);
+}

package/src/taxonomy.mjs

@@ -45,6 +45,7 @@ export const HOOK_FILES = [
   'session-backfill.mjs',
   'import-sessions.mjs',
   'decision-capture.mjs',
+  'renumber-decisions.mjs',
   'subagent-stop.mjs',
   'task-log.mjs',
   'vault-health.mjs',