wendkeep 0.29.1 → 0.30.0

package/CHANGELOG.md

@@ -4,6 +4,43 @@ 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
+- **Iteration turn marker renamed `codex-turn` → `wk-turn`** (provider-neutral). A **Claude**
+  session's iterations carried `<!-- codex-turn: … -->` — a legacy name from when this was a
+  Codex-only tool, confusing in the note source. The marker is a dedup key, so the change is
+  backward-compatible: `hasTurnMarker` still recognizes the legacy name, and `insertIteration`
+  **self-migrates** any `codex-turn` → `wk-turn` on the next write (backfill re-processes older
+  notes). Shared helpers `turnMarker` / `hasTurnMarker` / `normalizeTurnMarkers` in obsidian-common;
+  `vault-health` recognizes both.
+- Note-visible fallback text "Checkpoint registrado pelo hook Stop do **Codex**" → provider-neutral.
+- Stderr log prefix `[codex-obsidian]` → `[wendkeep]` across the hooks.
+
 ## [0.29.1] — 2026-07-09
 
 ### Added

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/obsidian-common.mjs

@@ -557,6 +557,27 @@ export function wikilinkFromRel(relPath) {
   return `[[${relPath.replace(/\.md$/i, '').replaceAll('\\', '/')}]]`;
 }
 
+// Per-iteration dedup marker (an invisible HTML comment). Provider-neutral name `wk-turn`; the
+// old `codex-turn` (legacy, from when this was a Codex-only tool) is still RECOGNIZED so notes
+// written by older versions keep deduping, and normalizeTurnMarkers migrates them on the next write.
+export const TURN_MARKER = 'wk-turn';
+export const LEGACY_TURN_MARKERS = ['codex-turn'];
+
+export function turnMarker(id) {
+  return `<!-- ${TURN_MARKER}: ${id} -->`;
+}
+
+export function hasTurnMarker(content, id) {
+  return [TURN_MARKER, ...LEGACY_TURN_MARKERS].some((m) => String(content || '').includes(`<!-- ${m}: ${id} -->`));
+}
+
+// Rewrite any legacy turn markers in a note to the current name (self-healing migration).
+export function normalizeTurnMarkers(content) {
+  let c = String(content || '');
+  for (const m of LEGACY_TURN_MARKERS) c = c.replaceAll(`<!-- ${m}: `, `<!-- ${TURN_MARKER}: `);
+  return c;
+}
+
 export function listMarkdownFiles(dir) {
   try {
     return readdirSync(dir).filter((f) => f.endsWith('.md'));

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-backfill.mjs

@@ -36,7 +36,9 @@ function parseArgs(argv) {
 }
 
 function hasTurnMarker(content, turnId) {
-  return content.includes(`<!-- codex-turn: ${turnId} -->`);
+  // recognize both the current `wk-turn` and the legacy `codex-turn`
+  return content.includes(`<!-- wk-turn: ${turnId} -->`)
+    || content.includes(`<!-- codex-turn: ${turnId} -->`);
 }
 
 function sessionEntries(vaultBase, args) {
@@ -135,7 +137,7 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
   try {
     main();
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] Backfill falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] Backfill falhou: ${error.message}\n`);
     process.exitCode = 1;
   }
 }

package/hooks/session-ensure.mjs

@@ -387,6 +387,6 @@ function main() {
 try {
   main();
 } catch (error) {
-  process.stderr.write(`[codex-obsidian] UserPromptSubmit falhou: ${error.message}\n`);
+  process.stderr.write(`[wendkeep] UserPromptSubmit falhou: ${error.message}\n`);
   writeHookOutput({});
 }

package/hooks/session-start.mjs

@@ -161,7 +161,7 @@ function main() {
   try {
     sweepStaleSessionsFile(vaultBase, now, undefined, input.transcript_path || input.transcriptPath || '');
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] sweep de sessões falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] sweep de sessões falhou: ${error.message}\n`);
   }
 
   // Reuso da nota apontada pelo CURRENT_SESSION só quando é a MESMA conversa
@@ -309,9 +309,9 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
   try {
     main();
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] SessionStart falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] SessionStart falhou: ${error.message}\n`);
     writeHookOutput({
-      systemMessage: `[codex-obsidian] Não foi possível criar a sessão Obsidian: ${error.message}`,
+      systemMessage: `[wendkeep] Não foi possível criar a sessão Obsidian: ${error.message}`,
     });
   }
 }

package/hooks/session-stop.mjs

@@ -30,6 +30,9 @@ import {
   wikilinkFromRel,
   writeControl,
   writeHookOutput,
+  turnMarker,
+  hasTurnMarker,
+  normalizeTurnMarkers,
 } from './obsidian-common.mjs';
 
 function extractContentText(content) {
@@ -596,7 +599,7 @@ export function buildIterationBlock(tx, input) {
   // inclui recortes da conversa do turno, sem despejar outputs brutos.
   return `
 ### ${formatTimeForHeading(now)} - ${heading}
-<!-- codex-turn: ${turnId} -->
+${turnMarker(turnId)}
 
 **Pedido:** ${compactText(promptText, 1000)}
 
@@ -609,7 +612,7 @@ ${formatConversation(turn)}
 
 **Arquivos detectados no turno:** ${formatInlineList(files, 'Nenhum arquivo detectado automaticamente.')}
 
-**Estado ao final do turno:** ${compactText(latestAssistant || 'Checkpoint registrado pelo hook Stop do Codex.', 900)}
+**Estado ao final do turno:** ${compactText(latestAssistant || 'Checkpoint registrado automaticamente ao final do turno.', 900)}
 `;
 }
 
@@ -751,17 +754,19 @@ function relocateOrphanIterations(content) {
 }
 
 export function insertIteration(sessionPath, block, turnId, tx) {
-  let content = readFileSync(sessionPath, 'utf-8');
-  if (content.includes(`<!-- codex-turn: ${turnId} -->`)) {
+  const original = readFileSync(sessionPath, 'utf-8');
+  // Self-heal: migrate any legacy `codex-turn` markers to the neutral name on this write.
+  let content = normalizeTurnMarkers(original);
+  if (hasTurnMarker(content, turnId)) {
     // Turno já registrado: ainda assim repara órfãos e seções dedicadas.
     const repaired = applyDedicatedSections(relocateOrphanIterations(content), tx);
-    if (repaired !== content) writeFileSync(sessionPath, repaired, 'utf-8');
+    if (repaired !== original) writeFileSync(sessionPath, repaired, 'utf-8');
     return false;
   }
   content = relocateOrphanIterations(content);
   content = insertIntoIteracoes(content, block);
   content = applyDedicatedSections(content, tx);
-  writeFileSync(sessionPath, content, 'utf-8');
+  if (content !== original) writeFileSync(sessionPath, content, 'utf-8');
   return true;
 }
 
@@ -1037,7 +1042,7 @@ function main() {
   try {
     applyLinearLinks(sessionPath, tx, vaultBase, sessionRel);
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] Linear link falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] Linear link falhou: ${error.message}\n`);
   }
 
   try {
@@ -1048,7 +1053,7 @@ function main() {
       transcriptPath,
     });
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] Token usage falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] Token usage falhou: ${error.message}\n`);
   }
 
   // Subagent/workflow telemetry (0.10.0): fold sibling subagent transcripts into the note.
@@ -1056,7 +1061,7 @@ function main() {
   try {
     upsertSubagentUsage(sessionPath, transcriptPath);
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] Subagent usage falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] Subagent usage falhou: ${error.message}\n`);
   }
 
   if (!shouldFinalizeSession()) {
@@ -1127,7 +1132,7 @@ function main() {
     const rows = buildBrainIndex(vaultBase);
     buildBrainDigest(vaultBase, rows);
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] brain index/digest falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] brain index/digest falhou: ${error.message}\n`);
   }
 
   pingObsidianVault(input.obsidian_api_key);
@@ -1138,7 +1143,7 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
   try {
     main();
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] Stop falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] Stop falhou: ${error.message}\n`);
     writeHookOutput({});
   }
 }

package/hooks/token-usage.mjs

@@ -966,7 +966,7 @@ if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
   try {
     runCli();
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] Token usage falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] Token usage falhou: ${error.message}\n`);
     process.exitCode = 1;
   }
 }

package/hooks/vault-health.mjs

@@ -39,7 +39,7 @@ function parseArgs(argv) {
 function findDuplicateTurnMarkers(content) {
   const seen = new Set();
   const duplicated = new Set();
-  const regex = /<!-- codex-turn: ([^>]+) -->/g;
+  const regex = /<!-- (?:wk-turn|codex-turn): ([^>]+) -->/g;
   let match;
   while ((match = regex.exec(content)) !== null) {
     const turnId = match[1].trim();
@@ -104,10 +104,10 @@ function checkSession({ vaultBase, sessionRel, control, registry }) {
 
   const content = readFileSync(sessionPath, 'utf-8');
   const duplicates = findDuplicateTurnMarkers(content);
-  metrics.turnMarkers = (content.match(/<!-- codex-turn:/g) || []).length;
+  metrics.turnMarkers = (content.match(/<!-- (?:wk-turn|codex-turn):/g) || []).length;
   metrics.duplicateTurnMarkers = duplicates.length;
 
-  if (duplicates.length) failures.push(`Marcadores codex-turn duplicados: ${duplicates.join(', ')}`);
+  if (duplicates.length) failures.push(`Marcadores de turno duplicados: ${duplicates.join(', ')}`);
   if (hasHeadingAfterClosing(content)) failures.push('Há headings/iterações após ## Encerramento.');
   if (!usageSectionIsPlaced(content)) failures.push('## Uso de tokens e custos está fora da posição esperada.');
   if (hasDefaultPending(content)) warnings.push('Pendências ainda contém placeholders padrão.');
@@ -197,7 +197,7 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
   try {
     main();
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] Vault health falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] Vault health falhou: ${error.message}\n`);
     process.exitCode = 1;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.29.1",
+  "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',