wendkeep 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -4,6 +4,26 @@ 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.8.0] — 2026-07-05
+
+Reach: internationalization + agent-agnostic distribution.
+
+### Added
+- **Vault locale (i18n):** `wendkeep init --locale en` creates an English vault
+  (`02-Sessions`, `04-Decisions`, `08-Changes`, …, English months, English change scaffold,
+  English CORE skeleton, localized theme/graph groups). The locale is a vault property
+  (`.brain/config.json`), locked at init; absent = `pt-BR` — existing vaults are untouched
+  and never renamed. Parsers are **bilingual everywhere** (`Requisito|Requirement`,
+  `mata mutante|kill mutant`, CORE section sets), so mixed content never breaks.
+- **AGENTS.md managed section:** `sync-defs`/`init` maintain a marker-delimited section in
+  the project's `AGENTS.md` (loop summary + skill inventory) — one file that Codex, Amp,
+  Cursor, Zed and any AGENTS.md-reading agent picks up. User content around it is preserved.
+- **Harness contract v1.2** (`docs/14`): locale + AGENTS.md channel.
+
+### Deferred
+- Extra mutation-report formats (mutmut/PIT) and per-agent session-hook wiring — backlog
+  (`docs/17`).
+
 ## [0.7.0] — 2026-07-05
 
 Ergonomics: the loop without hand-editing files.
@@ -160,6 +180,7 @@ Initial release — the capture engine, extracted from a system in daily product
 - `wendkeep init` (cross-platform installer) + optional `@bitbonsai/mcpvault` MCP server.
 
 <!-- Only v0.4.0+ is tagged in git (history starts here); older versions link to npm. -->
+[0.8.0]: https://github.com/rogersialves/wendkeep/releases/tag/v0.8.0
 [0.7.0]: https://github.com/rogersialves/wendkeep/releases/tag/v0.7.0
 [0.6.1]: https://github.com/rogersialves/wendkeep/releases/tag/v0.6.1
 [0.6.0]: https://github.com/rogersialves/wendkeep/releases/tag/v0.6.0

package/hooks/brain-core.mjs

@@ -3,6 +3,7 @@
 import { readdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ensureDir, stripYamlQuotes, toVaultRelative } from './obsidian-common.mjs';
+import { getLocale } from './locale.mjs';
 
 export function brainDir(vaultBase) {
   return join(vaultBase, '.brain');
@@ -60,7 +61,7 @@ function derivedLinks(content) {
 // Varre 02-Sessões/** e regrava .brain/index.jsonl inteiro. Provider-agnóstico.
 export function buildBrainIndex(vaultBase) {
   const rows = [];
-  for (const fp of walkMd(join(vaultBase, '02-Sessões'))) {
+  for (const fp of walkMd(join(vaultBase, getLocale(vaultBase).folders.sessions))) {
     let content;
     try { content = readFileSync(fp, 'utf8'); } catch { continue; }
     const fm = parseFrontmatter(content);

package/hooks/change-core.mjs

@@ -2,20 +2,20 @@
 // Native change/spec lifecycle in the vault (Pilar B). Vault-facing lib consumed by
 // 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 { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { ensureDir, wikilinkFromRel } from './obsidian-common.mjs';
 import { parseSpecsList, promoteSpecs } from './spec-core.mjs';
+import { getLocale } from './locale.mjs';
 
-export const CHANGES_DIR = '08-Mudanças';
-export const SPECS_DIR = '07-Specs';
 export const ARCHIVE_DIR = '_arquivo';
 const POINTER = '.brain/CURRENT_CHANGE.md';
 
-export function changeDirRel(slug) {
-  return join(CHANGES_DIR, slug);
+export function changeDirRel(slug, vaultBase) {
+  return join(getLocale(vaultBase).folders.changes, slug);
 }
 
-export function renderChangeScaffold({ slug, sessionRel, dateStr }) {
+export function renderChangeScaffold({ slug, sessionRel, dateStr, locale = 'pt-BR' }) {
+  const en = locale === 'en';
   const source = sessionRel ? `\n  - "${wikilinkFromRel(sessionRel)}"` : ' []';
   const proposta = `---
 type: change
@@ -31,27 +31,20 @@ specs: []
 
 # ${slug}
 
-## Por quê
-
-(motivo da mudança)
-
-## O que muda
-
-(escopo da mudança)
+${en ? '## Why\n\n(reason for the change)\n\n## What changes\n\n(scope of the change)' : '## Por quê\n\n(motivo da mudança)\n\n## O que muda\n\n(escopo da mudança)'}
 `;
   const design = `# ${slug} — design
 
-## Abordagem
-
-(abordagem técnica)
+${en ? '## Approach\n\n(technical approach)' : '## Abordagem\n\n(abordagem técnica)'}
 `;
-  const tarefas = `# ${slug} — tarefas
+  const tarefas = `# ${slug} — ${en ? 'tasks' : 'tarefas'}
 
-- [ ] 1.1 (primeira tarefa)
+- [ ] 1.1 ${en ? '(first task)' : '(primeira tarefa)'}
 `;
+  const reqHeading = en ? 'Requirement' : 'Requisito';
   const specDelta = `## ADDED Requirements
-### Requisito: (nome)
-(comportamento / cenários)
+### ${reqHeading}: ${en ? '(name)' : '(nome)'}
+${en ? '(behaviour / scenarios)' : '(comportamento / cenários)'}
 
 ## MODIFIED Requirements
 
@@ -80,10 +73,11 @@ export function clearActiveChange(vaultBase) {
 }
 
 export function newChange(vaultBase, slug, { sessionRel = '', dateStr, simple = false }) {
-  const dir = join(vaultBase, CHANGES_DIR, slug);
+  const loc = getLocale(vaultBase);
+  const dir = join(vaultBase, loc.folders.changes, slug);
   const existed = existsSync(join(dir, 'proposta.md'));
   mkdirSync(dir, { recursive: true });
-  const files = renderChangeScaffold({ slug, sessionRel, dateStr });
+  const files = renderChangeScaffold({ slug, sessionRel, dateStr, locale: loc.id });
   const write = (name, content) => {
     const f = join(dir, name);
     if (!existsSync(f)) writeFileSync(f, content, 'utf8');
@@ -100,7 +94,7 @@ export function newChange(vaultBase, slug, { sessionRel = '', dateStr, simple =
     }
   }
   setActiveChange(vaultBase, slug);
-  return { rel: changeDirRel(slug), created: !existed };
+  return { rel: changeDirRel(slug, vaultBase), created: !existed };
 }
 
 export function parseTasks(md) {
@@ -135,7 +129,7 @@ export function setTaskDone(changeDir, taskId, done = true) {
 }
 
 export function listChanges(vaultBase) {
-  const base = join(vaultBase, CHANGES_DIR);
+  const base = join(vaultBase, getLocale(vaultBase).folders.changes);
   const active = [];
   let archived = [];
   try {
@@ -153,29 +147,33 @@ export function listChanges(vaultBase) {
 export function buildActiveChangeInjection(vaultBase, { maxTasks = 8 } = {}) {
   const slug = activeChange(vaultBase);
   if (!slug) return '';
+  const chDir = getLocale(vaultBase).folders.changes;
   let md = '';
-  try { md = readFileSync(join(vaultBase, CHANGES_DIR, slug, 'tarefas.md'), 'utf8'); } catch { return ''; }
+  try { md = readFileSync(join(vaultBase, chDir, slug, 'tarefas.md'), 'utf8'); } catch { return ''; }
   const open = parseTasks(md).filter((t) => !t.done).slice(0, maxTasks);
   const lines = open.map((t) => `- [ ] ${t.id} ${t.text}`);
   const more = open.length === maxTasks ? '\n*…mais tarefas em tarefas.md*' : '';
   return `<active_change>
-Mudança ativa: ${slug} — [[${CHANGES_DIR}/${slug}/proposta]]. Tarefas abertas:
+Mudança ativa: ${slug} — [[${chDir}/${slug}/proposta]]. Tarefas abertas:
 ${lines.join('\n')}${more}
 </active_change>`;
 }
 
 export function activeChangeLink(vaultBase) {
   const slug = activeChange(vaultBase);
-  return slug ? `Change ativa: [[${CHANGES_DIR}/${slug}/proposta]]` : '';
+  return slug ? `Change ativa: [[${getLocale(vaultBase).folders.changes}/${slug}/proposta]]` : '';
 }
 
 // Append fix tasks for surviving mutants to a change's tarefas.md (Wave B). Deduped by
 // file:line, numbered M.<n> continuing from any existing fix tasks. Returns count added.
 export function appendFixTasks(changeDir, mutants, sensorId) {
   const path = join(changeDir, 'tarefas.md');
+  // changeDir = <vault>/<changesDir>/<slug> — derive the vault for the locale verb.
+  const verb = getLocale(dirname(dirname(changeDir))).fixTaskVerb;
   let md = '';
   try { md = readFileSync(path, 'utf8'); } catch { /* nova */ }
-  const existing = new Set([...md.matchAll(/mata mutante (\S+):(\d+)/g)].map((m) => `${m[1]}:${m[2]}`));
+  // Dedup is bilingual so a vault that switched locale mid-change never duplicates.
+  const existing = new Set([...md.matchAll(/(?:mata mutante|kill mutant) (\S+):(\d+)/g)].map((m) => `${m[1]}:${m[2]}`));
   const nums = [...md.matchAll(/^-\s+\[[ x]\]\s+M\.(\d+)\b/gm)].map((m) => Number(m[1]));
   let n = nums.length ? Math.max(...nums) : 0;
   const lines = [];
@@ -184,7 +182,7 @@ export function appendFixTasks(changeDir, mutants, sensorId) {
     if (existing.has(key)) continue;
     existing.add(key);
     n += 1;
-    lines.push(`- [ ] M.${n} mata mutante ${mut.file}:${mut.line} (${mut.mutator}) [sensor:${sensorId}]`);
+    lines.push(`- [ ] M.${n} ${verb} ${mut.file}:${mut.line} (${mut.mutator}) [sensor:${sensorId}]`);
   }
   if (!lines.length) return 0;
   const sep = md === '' || md.endsWith('\n') ? '' : '\n';
@@ -198,11 +196,13 @@ export function gateGreen() {
 }
 
 export function archiveChange(vaultBase, slug, { gate = gateGreen, dateStr, adrNum }) {
-  const src = join(vaultBase, CHANGES_DIR, slug);
+  const loc = getLocale(vaultBase);
+  const chDir = loc.folders.changes;
+  const src = join(vaultBase, chDir, slug);
   const verdict = gate(src);
   if (!verdict.ok) return { ok: false, failing: verdict.failing || [] };
 
-  const destRel = join(CHANGES_DIR, ARCHIVE_DIR, `${dateStr}-${slug}`);
+  const destRel = join(chDir, ARCHIVE_DIR, `${dateStr}-${slug}`);
   const changeWikilink = wikilinkFromRel(join(destRel, 'proposta'));
 
   // Promote spec deltas into the living 07-Specs BEFORE moving (deltas live in src).
@@ -220,16 +220,16 @@ export function archiveChange(vaultBase, slug, { gate = gateGreen, dateStr, adrN
   let reqIds = [];
   try { reqIds = [...new Set(parseTasks(readFileSync(join(src, 'tarefas.md'), 'utf8')).map((t) => t.req).filter(Boolean))]; } catch { /* sem tarefas */ }
 
-  ensureDir(join(vaultBase, CHANGES_DIR, ARCHIVE_DIR));
+  ensureDir(join(vaultBase, chDir, ARCHIVE_DIR));
   renameSync(src, join(vaultBase, destRel));
 
   const [year] = String(dateStr).split('-');
-  const adrDirRel = join('04-Decisões', year);
+  const adrDirRel = join(loc.folders.decisions, year);
   ensureDir(join(vaultBase, adrDirRel));
   const num = String(adrNum).padStart(3, '0');
   const adrRel = join(adrDirRel, `ADR-${num}-${slug}.md`);
   const capLine = promoted.length
-    ? `\n\nCapabilities: ${promoted.map((c) => wikilinkFromRel(join(SPECS_DIR, c))).join(', ')}.`
+    ? `\n\nCapabilities: ${promoted.map((c) => wikilinkFromRel(join(loc.folders.specs, c))).join(', ')}.`
     : '';
   const reqLine = reqIds.length ? `\n\nRequisitos: ${reqIds.join(', ')}.` : '';
   writeFileSync(join(vaultBase, adrRel), `---

package/hooks/harness-doctor.mjs

@@ -4,11 +4,12 @@ import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { activeChange, parseTasks } from './change-core.mjs';
 import { parseRequirements, parseSpecsList, parseDelta, evaluateVerdict } from './spec-core.mjs';
-
-const CHANGES_DIR = '08-Mudanças';
-const SPECS_DIR = '07-Specs';
+import { getLocale } from './locale.mjs';
 
 export function checkHarness(vaultBase, projectRoot) {
+  const loc = getLocale(vaultBase);
+  const CHANGES_DIR = loc.folders.changes;
+  const SPECS_DIR = loc.folders.specs;
   const errors = [];
   const warnings = [];
 

package/hooks/linked-notes.mjs

@@ -12,6 +12,7 @@ import {
   toVaultRelative,
   wikilinkFromRel,
 } from './obsidian-common.mjs';
+import { getLocale } from './locale.mjs';
 
 function yamlQuote(value) {
   return `"${String(value || '').replaceAll('"', '\\"')}"`;
@@ -446,7 +447,7 @@ _Registrar como este conhecimento pode ser reutilizado._
 `;
 }
 
-const DERIVED_FOLDERS = { bugs: '05-Bugs', decisions: '04-Decisões', learnings: '06-Aprendizados' };
+const derivedFoldersFor = (vaultBase) => { const f = getLocale(vaultBase).folders; return { bugs: f.bugs, decisions: f.decisions, learnings: f.learnings }; };
 
 function listMd(dir) {
   try { return readdirSync(dir).filter((f) => f.endsWith('.md')); } catch { return []; }
@@ -456,8 +457,8 @@ function listMd(dir) {
 function existingKeysForSession(vaultBase, sessionRel, dateStr) {
   const wikilink = wikilinkFromRel(sessionRel);
   const out = { bugs: [], decisions: [], learnings: [] };
-  for (const [type, folder] of Object.entries(DERIVED_FOLDERS)) {
-    const dir = join(vaultBase, monthFolderRelFromDateStr(folder, dateStr));
+  for (const [type, folder] of Object.entries(derivedFoldersFor(vaultBase))) {
+    const dir = join(vaultBase, monthFolderRelFromDateStr(folder, dateStr, vaultBase));
     for (const fileName of listMd(dir)) {
       try {
         const c = readFileSync(join(dir, fileName), 'utf-8');
@@ -477,9 +478,10 @@ function alreadyHasKey(keys, candidate) {
 export function createLinkedNotes(vaultBase, dateStr, sessionRel, tx, options = {}) {
   const linked = { decisions: [], bugs: [], learnings: [] };
   const provider = providerMeta(options.provider);
-  const bugsDir = join(vaultBase, monthFolderRelFromDateStr('05-Bugs', dateStr));
-  const decisionsDir = join(vaultBase, monthFolderRelFromDateStr('04-Decisões', dateStr));
-  const learningsDir = join(vaultBase, monthFolderRelFromDateStr('06-Aprendizados', dateStr));
+  const locF = getLocale(vaultBase).folders;
+  const bugsDir = join(vaultBase, monthFolderRelFromDateStr(locF.bugs, dateStr, vaultBase));
+  const decisionsDir = join(vaultBase, monthFolderRelFromDateStr(locF.decisions, dateStr, vaultBase));
+  const learningsDir = join(vaultBase, monthFolderRelFromDateStr(locF.learnings, dateStr, vaultBase));
   ensureDir(bugsDir);
   ensureDir(decisionsDir);
   ensureDir(learningsDir);

package/hooks/locale.mjs

@@ -0,0 +1,73 @@
+// hooks/locale.mjs — vault locale (i18n, 0.8.0). The locale is a property of the VAULT,
+// stored at <vault>/.brain/config.json ({ "locale": "en" }); absent = pt-BR (full backward
+// compat). Parsers stay bilingual everywhere; only RENDERING follows the locale.
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export const LOCALES = {
+  'pt-BR': {
+    id: 'pt-BR',
+    folders: {
+      inbox: '00-Inbox',
+      project: '01-Projeto',
+      sessions: '02-Sessões',
+      linear: '03-Linear',
+      decisions: '04-Decisões',
+      bugs: '05-Bugs',
+      learnings: '06-Aprendizados',
+      specs: '07-Specs',
+      changes: '08-Mudanças',
+    },
+    months: ['01-JAN', '02-FEV', '03-MAR', '04-ABR', '05-MAI', '06-JUN', '07-JUL', '08-AGO', '09-SET', '10-OUT', '11-NOV', '12-DEZ'],
+    reqHeading: 'Requisito',
+    fixTaskVerb: 'mata mutante',
+    coreSections: ['Preferências do Usuário', 'Padrões Ativos', 'Pendências Abertas'],
+  },
+  en: {
+    id: 'en',
+    folders: {
+      inbox: '00-Inbox',
+      project: '01-Project',
+      sessions: '02-Sessions',
+      linear: '03-Linear',
+      decisions: '04-Decisions',
+      bugs: '05-Bugs',
+      learnings: '06-Learnings',
+      specs: '07-Specs',
+      changes: '08-Changes',
+    },
+    months: ['01-JAN', '02-FEB', '03-MAR', '04-APR', '05-MAY', '06-JUN', '07-JUL', '08-AUG', '09-SEP', '10-OCT', '11-NOV', '12-DEC'],
+    reqHeading: 'Requirement',
+    fixTaskVerb: 'kill mutant',
+    coreSections: ['User Preferences', 'Active Patterns', 'Open Items'],
+  },
+};
+
+export const DEFAULT_LOCALE = 'pt-BR';
+
+// Per-process cache: one vault per process (hooks + CLI), reads are hot paths.
+const cache = new Map();
+
+export function getLocale(vaultBase) {
+  if (!vaultBase) return LOCALES[DEFAULT_LOCALE];
+  const key = String(vaultBase);
+  if (cache.has(key)) return cache.get(key);
+  let id = DEFAULT_LOCALE;
+  try {
+    const data = JSON.parse(readFileSync(join(key, '.brain', 'config.json'), 'utf8'));
+    if (data.locale && LOCALES[data.locale]) id = data.locale;
+  } catch { /* sem config = pt-BR */ }
+  const loc = LOCALES[id];
+  cache.set(key, loc);
+  return loc;
+}
+
+// Test hook: drop the memoized entry (tests rewrite config.json under one tmpdir).
+export function clearLocaleCache() {
+  cache.clear();
+}
+
+// The full vault taxonomy for a locale (folders + fixed entries), in creation order.
+export function vaultFolders(loc) {
+  return [...Object.values(loc.folders), 'Templates', '.brain'];
+}

package/hooks/obsidian-common.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from 'fs';
 import { basename, dirname, join, relative } from 'path';
+import { getLocale } from './locale.mjs';
 
 // Neutral fallback only. The vault is normally resolved from the
 // OBSIDIAN_VAULT_PATH env var (set by `wendkeep init`) via getVaultBase() below.
@@ -128,26 +129,28 @@ export function formatLocalIso(date = new Date()) {
   return `${formatDate(date)}T${formatTime(date)}`;
 }
 
-export function datedFolderRel(rootFolder, date = new Date()) {
+// Locale (0.8.0): month labels + folder names come from the vault locale when a
+// vaultBase is given; without it, pt-BR (backward compat — every legacy caller).
+export function datedFolderRel(rootFolder, date = new Date(), vaultBase) {
   const p = localDateParts(date);
-  return join(rootFolder, String(p.year), MONTH_FOLDERS[p.month - 1], `DIA ${pad2(p.day)}`);
+  return join(rootFolder, String(p.year), getLocale(vaultBase).months[p.month - 1], `DIA ${pad2(p.day)}`);
 }
 
 // Mesma estrutura datada a partir de uma string 'YYYY-MM-DD' (sessões: até o DIA).
-export function datedFolderRelFromDateStr(rootFolder, dateStr) {
+export function datedFolderRelFromDateStr(rootFolder, dateStr, vaultBase) {
   const [year, month, day] = String(dateStr).split('-');
-  return join(rootFolder, year, MONTH_FOLDERS[Number(month) - 1], `DIA ${pad2(day)}`);
+  return join(rootFolder, year, getLocale(vaultBase).months[Number(month) - 1], `DIA ${pad2(day)}`);
 }
 
 // Estrutura até o MÊS (sem DIA) — usada pelas notas derivadas (decisões/bugs/
 // aprendizados): tudo do mês fica junto em <pasta>/<ano>/<MM-MMM>/.
-export function monthFolderRelFromDateStr(rootFolder, dateStr) {
+export function monthFolderRelFromDateStr(rootFolder, dateStr, vaultBase) {
   const [year, month] = String(dateStr).split('-');
-  return join(rootFolder, year, MONTH_FOLDERS[Number(month) - 1]);
+  return join(rootFolder, year, getLocale(vaultBase).months[Number(month) - 1]);
 }
 
-export function sessionFolderRel(date = new Date()) {
-  return datedFolderRel('02-Sessões', date);
+export function sessionFolderRel(date = new Date(), vaultBase) {
+  return datedFolderRel(getLocale(vaultBase).folders.sessions, date, vaultBase);
 }
 
 export function controlPath(vaultBase) {
@@ -532,7 +535,7 @@ export function listMarkdownFiles(dir) {
 }
 
 export function getNextAdrNumber(vaultBase) {
-  const decisionsDir = join(vaultBase, '04-Decisões');
+  const decisionsDir = join(vaultBase, getLocale(vaultBase).folders.decisions);
   let max = 0;
   // Varre recursivamente: os ADRs agora vivem em subpastas datadas (AAAA/MM-MMM/DIA DD).
   const walk = (dir) => {

package/hooks/session-ensure.mjs

@@ -115,7 +115,7 @@ Sessão ainda em andamento.
 }
 
 function allocateSessionPath(vaultBase, now, summary = 'session') {
-  const folderRel = sessionFolderRel(now);
+  const folderRel = sessionFolderRel(now, vaultBase);
   const folderAbs = join(vaultBase, folderRel);
   ensureDir(folderAbs);
 

package/hooks/session-start.mjs

@@ -113,7 +113,7 @@ Sessão ainda em andamento.
 }
 
 function allocateSessionPath(vaultBase, now, summary = 'session') {
-  const folderRel = sessionFolderRel(now);
+  const folderRel = sessionFolderRel(now, vaultBase);
   const folderAbs = join(vaultBase, folderRel);
   ensureDir(folderAbs);
 

package/hooks/session-stop.mjs

@@ -7,6 +7,7 @@ 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 { getLocale } from './locale.mjs';
 import {
   ensureDir,
   findActiveSessionByTranscript,
@@ -781,10 +782,11 @@ function noteReferencesSession(content, sessionRel) {
 
 function findLinkedDerivedNotes(vaultBase, sessionRel) {
   const linked = { decisions: [], bugs: [], learnings: [] };
+  const locF = getLocale(vaultBase).folders;
   const folders = {
-    decisions: '04-Decisões',
-    bugs: '05-Bugs',
-    learnings: '06-Aprendizados',
+    decisions: locF.decisions,
+    bugs: locF.bugs,
+    learnings: locF.learnings,
   };
 
   for (const [key, folder] of Object.entries(folders)) {

package/hooks/spec-core.mjs

@@ -4,14 +4,15 @@ import { createHash } from 'node:crypto';
 import { readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ensureDir } from './obsidian-common.mjs';
+import { getLocale } from './locale.mjs';
 
 // Short stable fingerprint of tarefas.md — freshness check between package/verdict and gate.
 export function tasksHashOf(md) {
   return createHash('sha1').update(String(md)).digest('hex').slice(0, 12);
 }
 
-const SPECS_DIR = '07-Specs';
-const REQ_RE = /^### Requisito:\s*(.+)$/gm;
+// Parse is BILINGUAL always (mixed vaults never break); rendering follows the vault locale.
+const REQ_RE = /^### (?:Requisito|Requirement):\s*(.+)$/gm;
 
 export function parseRequirements(md) {
   const text = String(md);
@@ -71,8 +72,8 @@ export function applyDelta(reqs, delta) {
   return { reqs: out, warnings };
 }
 
-export function renderSpec(capability, reqs, { footer } = {}) {
-  const blocks = reqs.map((r) => `### Requisito: ${r.id ? `${r.id} — ${r.name}` : r.name}\n${r.body}`).join('\n\n');
+export function renderSpec(capability, reqs, { footer, reqHeading = 'Requisito' } = {}) {
+  const blocks = reqs.map((r) => `### ${reqHeading}: ${r.id ? `${r.id} — ${r.name}` : r.name}\n${r.body}`).join('\n\n');
   const foot = footer ? `\n\n> ${footer}\n` : '\n';
   return `---\ntype: spec\ncssclasses:\n  - topic-spec\ntags:\n  - spec\n---\n\n# ${capability}\n\n## Requisitos\n\n${blocks}${foot}`;
 }
@@ -88,20 +89,22 @@ export function parseSpecsList(propostaMd) {
 
 // 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);
+  const specsDir = loc.folders.specs;
   const promoted = [];
   const warnings = [];
   for (const cap of specs) {
     let delta;
     try { delta = parseDelta(readFileSync(join(changeDir, 'specs', cap, 'spec.md'), 'utf8')); }
     catch { warnings.push(`sem delta para ${cap}`); continue; }
-    const livePath = join(vaultBase, SPECS_DIR, `${cap}.md`);
+    const livePath = join(vaultBase, specsDir, `${cap}.md`);
     let current = [];
     try { current = parseRequirements(readFileSync(livePath, 'utf8')); } catch { /* nova capability */ }
     const applied = applyDelta(current, delta);
     warnings.push(...applied.warnings.map((w) => `${cap}: ${w}`));
-    ensureDir(join(vaultBase, SPECS_DIR));
+    ensureDir(join(vaultBase, specsDir));
     const footer = changeWikilink ? `Atualizado por ${changeWikilink} em ${dateStr}.` : '';
-    writeFileSync(livePath, renderSpec(cap, applied.reqs, { footer }), 'utf8');
+    writeFileSync(livePath, renderSpec(cap, applied.reqs, { footer, reqHeading: loc.reqHeading }), 'utf8');
     promoted.push(cap);
   }
   return { promoted, warnings };

package/hooks/vault-health.mjs

@@ -10,6 +10,7 @@ import {
   readSessionRegistry,
   wikilinkFromRel,
 } from './obsidian-common.mjs';
+import { getLocale } from './locale.mjs';
 
 const DEFAULT_PENDING_PATTERNS = [
   /^- \[ \] Revisar resumo da sessão$/i,
@@ -164,7 +165,8 @@ export function runVaultHealth({ vaultBase, session = '' }) {
     .length;
   if (staleDone) warnings.push(`${staleDone} entradas active com ended_at no SESSION_REGISTRY.`);
 
-  const derivedFolders = ['04-Decisões', '05-Bugs', '06-Aprendizados'];
+  const locF = getLocale(vaultBase).folders;
+  const derivedFolders = [locF.decisions, locF.bugs, locF.learnings];
   const derivedCount = derivedFolders.reduce((total, folder) => {
     const dir = join(vaultBase, folder);
     return total + (existsSync(dir) ? listMarkdownFiles(dir).length : 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Automatically capture AI coding agent sessions (Claude Code, Codex) as local Markdown in your Obsidian vault — turn-by-turn history, cost/token tracking, auto-extracted decisions/bugs/learnings, rendered in the graph. Local-first.",
   "type": "module",
   "bin": {

package/src/change.mjs

@@ -12,6 +12,7 @@ import {
 import { evaluateGate, requiredSensors } from '../hooks/sensors-core.mjs';
 import { evaluateVerdict, tasksHashOf, parseSpecsList, parseDelta, parseRequirements, applyDelta } from '../hooks/spec-core.mjs';
 import { getNextAdrNumber, readControl } from '../hooks/obsidian-common.mjs';
+import { getLocale } from '../hooks/locale.mjs';
 
 function resolveVault(argv) {
   let vault;
@@ -69,7 +70,7 @@ export function runChange(argv) {
     const slug = slugArg();
     if (!slug) { process.stderr.write('wendkeep change show: missing <slug>\n'); process.exit(2); }
     let md;
-    try { md = readFileSync(join(vaultBase, '08-Mudanças', slug, 'tarefas.md'), 'utf8'); }
+    try { md = readFileSync(join(vaultBase, getLocale(vaultBase).folders.changes, slug, 'tarefas.md'), 'utf8'); }
     catch { process.stderr.write(`wendkeep change show: not found: ${slug}\n`); process.exit(2); }
     const tasks = parseTasks(md);
     const open = tasks.filter((t) => !t.done).length;
@@ -81,7 +82,7 @@ export function runChange(argv) {
   if (sub === 'status') {
     const slug = slugArg() || activeChange(vaultBase);
     if (!slug) { process.stderr.write('wendkeep change status: no change (arg or active)\n'); process.exit(2); }
-    const dir = join(vaultBase, '08-Mudanças', slug);
+    const dir = join(vaultBase, getLocale(vaultBase).folders.changes, slug);
     let tarefasMd;
     try { tarefasMd = readFileSync(join(dir, 'tarefas.md'), 'utf8'); }
     catch { process.stderr.write(`wendkeep change status: not found: ${slug}\n`); process.exit(2); }
@@ -117,7 +118,7 @@ export function runChange(argv) {
     if (!taskId) { process.stderr.write(`wendkeep change ${sub}: missing <taskId>\n`); process.exit(2); }
     const slug = opt(rest, '--change') || activeChange(vaultBase);
     if (!slug) { process.stderr.write(`wendkeep change ${sub}: no active change\n`); process.exit(2); }
-    const dir = join(vaultBase, '08-Mudanças', slug);
+    const dir = join(vaultBase, getLocale(vaultBase).folders.changes, slug);
     let ok = false;
     try { ok = setTaskDone(dir, taskId, sub === 'done'); } catch { /* sem tarefas.md */ }
     if (!ok) { process.stderr.write(`wendkeep change ${sub}: task não encontrada: ${taskId}\n`); process.exit(2); }
@@ -128,7 +129,7 @@ export function runChange(argv) {
   if (sub === 'diff') {
     const slug = slugArg() || activeChange(vaultBase);
     if (!slug) { process.stderr.write('wendkeep change diff: no change (arg or active)\n'); process.exit(2); }
-    const dir = join(vaultBase, '08-Mudanças', slug);
+    const dir = join(vaultBase, getLocale(vaultBase).folders.changes, slug);
     let specs = [];
     try { specs = parseSpecsList(readFileSync(join(dir, 'proposta.md'), 'utf8')); }
     catch { process.stderr.write(`wendkeep change diff: not found: ${slug}\n`); process.exit(2); }
@@ -142,7 +143,7 @@ export function runChange(argv) {
       for (const r of delta.modified) process.stdout.write(`  ~ ${r.id || r.name} (MODIFIED)\n`);
       for (const k of delta.removed) process.stdout.write(`  - ${k} (REMOVED)\n`);
       let living = [];
-      try { living = parseRequirements(readFileSync(join(vaultBase, '07-Specs', `${cap}.md`), 'utf8')); } catch { /* nova capability */ }
+      try { living = parseRequirements(readFileSync(join(vaultBase, getLocale(vaultBase).folders.specs, `${cap}.md`), 'utf8')); } catch { /* nova capability */ }
       for (const w of applyDelta(living, delta).warnings) process.stdout.write(`  ! ${w}\n`);
     }
     process.exit(0);

package/src/init.mjs

@@ -33,6 +33,7 @@ import {
 import { renderCoreSkeleton, renderCompactionProtocol } from './validate-core.mjs';
 import { seedDefinitions, syncDefs } from './sync-defs.mjs';
 import { seedWkSkills } from './skills-seed.mjs';
+import { LOCALES, DEFAULT_LOCALE, getLocale, clearLocaleCache, vaultFolders } from '../hooks/locale.mjs';
 import { seedDotcontext, globalHasDotcontext, resolveDotcontextSkipMcp, renderSensorsJson } from './dotcontext-seed.mjs';
 
 function parseArgs(argv) {
@@ -40,6 +41,8 @@ function parseArgs(argv) {
   for (let i = 0; i < argv.length; i += 1) {
     const a = argv[i];
     if (a === '--vault') args.vault = argv[++i];
+    else if (a === '--locale') args.locale = argv[++i];
+    else if (a.startsWith('--locale=')) args.locale = a.slice(9);
     else if (a === '--project') args.project = argv[++i];
     else if (a === '--no-mcp') args.mcp = false;
     else if (a === '--yes' || a === '-y') args.yes = true;
@@ -162,10 +165,11 @@ function runCavemanInstaller(log) {
 // enable it (non-destructive), and add graph color groups. Returns a short note.
 // Unparseable user JSON is left untouched (we only merge into valid/absent files).
 function installVaultColors(vaultPath) {
+  const loc = getLocale(vaultPath);
   const obsidianDir = join(vaultPath, '.obsidian');
   const snippetsDir = join(obsidianDir, 'snippets');
   mkdirSync(snippetsDir, { recursive: true });
-  writeFileSync(join(snippetsDir, `${SNIPPET_NAME}.css`), renderColorSnippetCss(), 'utf8');
+  writeFileSync(join(snippetsDir, `${SNIPPET_NAME}.css`), renderColorSnippetCss(loc), 'utf8');
 
   let enabled = false;
   const appPath = join(obsidianDir, 'appearance.json');
@@ -179,9 +183,9 @@ function installVaultColors(vaultPath) {
   const graphPath = join(obsidianDir, 'graph.json');
   const graphRead = readJsonSafe(graphPath);
   if (graphRead.ok) {
-    const merged = mergeGraphColorGroups(graphRead.data || {}, graphColorGroups());
+    const merged = mergeGraphColorGroups(graphRead.data || {}, graphColorGroups(loc));
     writeJson(graphPath, merged);
-    groups = graphColorGroups().length;
+    groups = graphColorGroups(loc).length;
   }
   return `snippet ${SNIPPET_NAME}.css${enabled ? ' (enabled)' : ' (enable by hand: appearance.json unreadable)'} + ${groups} graph group(s)`;
 }
@@ -253,9 +257,21 @@ export async function runInit(argv) {
   }
 
   // 1. Vault taxonomy ---------------------------------------------------------
+  // Locale (0.8.0): a vault property, locked at init. Written BEFORE folder creation so
+  // the folder names follow it. Invalid/absent = pt-BR (backward compat).
   if (!existsSync(vaultPath)) mkdirSync(vaultPath, { recursive: true });
+  const localeId = args.locale && LOCALES[args.locale] ? args.locale : DEFAULT_LOCALE;
+  if (args.locale && !LOCALES[args.locale]) {
+    log(`  ! locale desconhecido "${args.locale}" — usando ${DEFAULT_LOCALE} (opções: ${Object.keys(LOCALES).join(', ')})`);
+  }
+  mkdirSync(join(vaultPath, '.brain'), { recursive: true });
+  const configPath = join(vaultPath, '.brain', 'config.json');
+  if (!existsSync(configPath)) writeFileSync(configPath, `${JSON.stringify({ locale: localeId }, null, 2)}\n`, 'utf8');
+  clearLocaleCache();
+  const loc = getLocale(vaultPath);
+  const folders = vaultFolders(loc);
   let created = 0;
-  for (const f of VAULT_FOLDERS) {
+  for (const f of folders) {
     const p = join(vaultPath, f);
     if (!existsSync(p)) {
       mkdirSync(p, { recursive: true });
@@ -275,7 +291,7 @@ export async function runInit(argv) {
   const brainDir = join(vaultPath, '.brain');
   mkdirSync(brainDir, { recursive: true });
   const corePath = join(brainDir, 'CORE.md');
-  if (!existsSync(corePath)) writeFileSync(corePath, renderCoreSkeleton(), 'utf8');
+  if (!existsSync(corePath)) writeFileSync(corePath, renderCoreSkeleton(loc.id), 'utf8');
   const protoPath = join(brainDir, 'COMPACTION_PROTOCOL.md');
   if (!existsSync(protoPath)) writeFileSync(protoPath, renderCompactionProtocol(), 'utf8');
   // Seed the definitions layer (.brain/agents + .brain/skills): versioned source of
@@ -283,8 +299,8 @@ export async function runInit(argv) {
   seedDefinitions(brainDir);
   seedWkSkills(brainDir); // Pilar A: native process skills (wk-workflow/tdd/debugging/...).
   // Seed the change/spec layer starters (Pilar B) — non-destructive.
-  const specsReadme = join(vaultPath, '07-Specs', 'README.md');
-  if (!existsSync(specsReadme)) writeFileSync(specsReadme, '# Specs — contrato vivo\n\nCapacidades do projeto (requisitos/cenários). Changes em `08-Mudanças/` promovem deltas aqui no `wendkeep change archive`.\n', 'utf8');
+  const specsReadme = join(vaultPath, loc.folders.specs, 'README.md');
+  if (!existsSync(specsReadme)) writeFileSync(specsReadme, `# Specs — contrato vivo\n\nCapacidades do projeto (requisitos/cenários). Changes em \`${loc.folders.changes}/\` promovem deltas aqui no \`wendkeep change archive\`.\n`, 'utf8');
   const changeTpl = join(vaultPath, 'Templates', 'Change.md');
   if (!existsSync(changeTpl)) writeFileSync(changeTpl, '---\ntype: change\nstatus: active\ncssclasses:\n  - topic-change\n---\n\n# <slug>\n\n## Por quê\n\n## O que muda\n', 'utf8');
   // Seed the native sensor config (Pilar C) at project root — non-destructive.
@@ -294,7 +310,7 @@ 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: ${VAULT_FOLDERS.length} folders (${created} created)${readmeNote}, .brain + change/spec + sensors seeded`);
+  log(`  [1/4] vault taxonomy: ${folders.length} folders (${created} created, locale ${loc.id})${readmeNote}, .brain + change/spec + sensors seeded`);
   // 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/spec.mjs

@@ -2,6 +2,7 @@
 import { readFileSync, readdirSync } from 'node:fs';
 import { isAbsolute, join, resolve } from 'node:path';
 import { parseRequirements } from '../hooks/spec-core.mjs';
+import { getLocale } from '../hooks/locale.mjs';
 
 function resolveVault(argv) {
   let vault;
@@ -21,7 +22,7 @@ function resolveVault(argv) {
 export function runSpec(argv) {
   const [sub, ...rest] = argv;
   const vaultBase = resolveVault(rest);
-  const specsDir = join(vaultBase, '07-Specs');
+  const specsDir = join(vaultBase, getLocale(vaultBase).folders.specs);
 
   if (sub === 'list') {
     let files = [];

package/src/sync-defs.mjs

@@ -5,11 +5,67 @@
 //   .brain/skills/<name>/ -> <project>/.claude/skills/   (skill format)
 // .brain is the source of truth; re-run sync after editing. Copy (not symlink) for
 // cross-platform robustness.
-import { copyFileSync, cpSync, existsSync, mkdirSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join, resolve } from 'node:path';
 
+// Managed AGENTS.md section (0.8.0): the agent-agnostic distribution channel. Codex, Amp,
+// Cursor, Zed et al. read AGENTS.md — one file covers them all. Only the content between
+// the markers is ours; user content around it is never touched.
+const AG_START = '<!-- wendkeep:skills:start -->';
+const AG_END = '<!-- wendkeep:skills:end -->';
+
+function skillInventory(skillsSrc) {
+  const out = [];
+  let names = [];
+  try { names = readdirSync(skillsSrc); } catch { return out; }
+  for (const name of names) {
+    try {
+      if (!statSync(join(skillsSrc, name)).isDirectory()) continue;
+      const md = readFileSync(join(skillsSrc, name, 'SKILL.md'), 'utf8');
+      const desc = (md.match(/^description:\s*(.+)$/m) || [])[1] || '';
+      out.push({ name, description: desc.trim() });
+    } catch { /* skill sem SKILL.md */ }
+  }
+  return out;
+}
+
+function renderAgentsSection(skills) {
+  const list = skills.map((s) => `- **${s.name}** — ${s.description}`).join('\n');
+  return `${AG_START}
+## wendkeep — process skills & loop
+
+This project uses the [wendkeep](https://github.com/rogersialves/wendkeep) harness. Work
+through its change loop: \`wendkeep change new <slug>\` → implement tasks test-first
+(tag proof \`[sensor:id]\` and requirement \`[req:ID]\`) → \`wendkeep verify\` →
+\`wendkeep verify --deep\` + an independent read-only verification pass writing
+\`verdict.json\` → \`wendkeep change archive\` (gated). Inspect with \`wendkeep change
+status\` / \`spec list\` / \`sensors list\`.
+
+Process skills (full text in \`.claude/skills/\` and the vault's \`.brain/skills/\`):
+${list}
+${AG_END}`;
+}
+
+function upsertAgentsMd(projectPath, skillsSrc) {
+  const skills = skillInventory(skillsSrc);
+  if (!skills.length) return false;
+  const path = join(projectPath, 'AGENTS.md');
+  const section = renderAgentsSection(skills);
+  let content = '';
+  try { content = readFileSync(path, 'utf8'); } catch { /* novo */ }
+  if (content.includes(AG_START) && content.includes(AG_END)) {
+    const start = content.indexOf(AG_START);
+    const end = content.indexOf(AG_END) + AG_END.length;
+    content = content.slice(0, start) + section + content.slice(end);
+  } else {
+    content = content ? `${content.trimEnd()}\n\n${section}\n` : `${section}\n`;
+  }
+  writeFileSync(path, content, 'utf8');
+  return true;
+}
+
 export function syncDefs(vaultBase, projectPath) {
-  const out = { agents: [], skills: [] };
+  const out = { agents: [], skills: [], agentsMd: false };
 
   const agentsSrc = join(vaultBase, '.brain', 'agents');
   if (existsSync(agentsSrc)) {
@@ -34,6 +90,9 @@ export function syncDefs(vaultBase, projectPath) {
     }
   }
 
+  // Agent-agnostic channel: the managed AGENTS.md section (docs/17).
+  out.agentsMd = upsertAgentsMd(projectPath, skillsSrc);
+
   return out;
 }
 

package/src/taxonomy.mjs

@@ -25,6 +25,7 @@ export const VAULT_FOLDERS = [
 // entrypoints + price table). Mirrors the list the old setup-vault.ps1 copied.
 export const HOOK_FILES = [
   'obsidian-common.mjs',
+  'locale.mjs',
   'session-start.mjs',
   'session-ensure.mjs',
   'session-stop.mjs',

package/src/validate-core.mjs

@@ -11,11 +11,20 @@ import { isAbsolute, join, resolve } from 'node:path';
 const HARD_LIMIT = 25;
 const SOFT_LIMIT = 22;
 
-const REQUIRED_SECTIONS = [
-  { label: 'Preferências do Usuário', regex: /^##\s+Prefer[êe]ncias\s+do\s+Usu[áa]rio\s*$/im },
-  { label: 'Padrões Ativos', regex: /^##\s+Padr[õo]es\s+Ativos\s*$/im },
-  { label: 'Pendências Abertas', regex: /^##\s+Pend[êe]ncias\s+Abertas\s*$/im },
-];
+// Bilingual (0.8.0): a CORE is valid when it carries the COMPLETE section set of either
+// locale — pt-BR or en. Mixed/partial sets fail (the 3 sections are one contract).
+const SECTION_SETS = {
+  'pt-BR': [
+    { label: 'Preferências do Usuário', regex: /^##\s+Prefer[êe]ncias\s+do\s+Usu[áa]rio\s*$/im },
+    { label: 'Padrões Ativos', regex: /^##\s+Padr[õo]es\s+Ativos\s*$/im },
+    { label: 'Pendências Abertas', regex: /^##\s+Pend[êe]ncias\s+Abertas\s*$/im },
+  ],
+  en: [
+    { label: 'User Preferences', regex: /^##\s+User\s+Preferences\s*$/im },
+    { label: 'Active Patterns', regex: /^##\s+Active\s+Patterns\s*$/im },
+    { label: 'Open Items', regex: /^##\s+Open\s+Items\s*$/im },
+  ],
+};
 
 // Secret patterns reject only "real" values (length floor); abstract mentions like
 // `sk_*` / `whsec_*` (trailing asterisk) are allowed.
@@ -41,9 +50,10 @@ export function validateCore(content) {
   if (lineCount > HARD_LIMIT) {
     errors.push(`Tamanho ${lineCount} > ${HARD_LIMIT} linhas (hard limit). Curar: remover itens resolvidos (detalhe vive no vault/git).`);
   }
-  for (const { label, regex } of REQUIRED_SECTIONS) {
-    if (!regex.test(text)) errors.push(`Seção obrigatória ausente: ## ${label}`);
-  }
+  // Pick the locale set that matches best; require it to be complete.
+  const missingBySet = Object.values(SECTION_SETS).map((set) => set.filter(({ regex }) => !regex.test(text)));
+  const best = missingBySet.reduce((a, b) => (b.length < a.length ? b : a));
+  for (const { label } of best) errors.push(`Seção obrigatória ausente: ## ${label}`);
   for (const { name, regex } of SECRET_PATTERNS) {
     const m = text.match(regex);
     if (m) errors.push(`Possível ${name} detectado: "${m[0].slice(0, 30)}..." — substituir por [REDACTED_SECRET].`);
@@ -61,7 +71,22 @@ export function validateCore(content) {
 
 // The seeded CORE.md (must pass validateCore). Bootstraps the 3 sections so the
 // curated hot layer exists with the right shape from day one.
-export function renderCoreSkeleton() {
+export function renderCoreSkeleton(localeId = 'pt-BR') {
+  if (localeId === 'en') {
+    return `# CORE — curated memory core (.brain)
+
+> RULE #1 — the project's canonical memory. Hand-curated, 25-line cap (validate: \`wendkeep validate-memory\`). Volatile facts live in DIGEST.md (auto). Depth: /brain-recall <topic>.
+
+## User Preferences
+- (durable preferences: language, style, conventions)
+
+## Active Patterns
+- (active patterns/architecture another agent must know)
+
+## Open Items
+- (open items/decisions — remove when resolved)
+`;
+  }
   return `# CORE — núcleo curado da memória (.brain)
 
 > REGRA #1 — memória canônica do projeto. Curado à mão, cap 25 linhas (valide: \`wendkeep validate-memory\`). Volátil vive no DIGEST.md (auto). Profundidade: /brain-recall <tópico>.

package/src/vault-theme.mjs

@@ -8,6 +8,9 @@
 
 export const SNIPPET_NAME = 'wendkeep-colors';
 
+import { LOCALES } from '../hooks/locale.mjs';
+const PT = LOCALES['pt-BR'];
+
 // Base palette (hex + "r, g, b" for rgba()).
 const PALETTE = {
   blue: { hex: '#2f80ed', rgb: '47, 128, 237' },
@@ -20,42 +23,49 @@ const PALETTE = {
   slate: { hex: '#64748b', rgb: '100, 116, 139' },
 };
 
-// File-explorer folder -> palette key (mirrors VAULT_FOLDERS in taxonomy.mjs).
-const FOLDER_PALETTE = [
-  ['00-Inbox', 'amber'],
-  ['01-Projeto', 'indigo'],
-  ['02-Sessões', 'blue'],
-  ['03-Linear', 'teal'],
-  ['04-Decisões', 'violet'],
-  ['05-Bugs', 'red'],
-  ['06-Aprendizados', 'green'],
-  ['07-Specs', 'teal'],
-  ['08-Mudanças', 'amber'],
-  ['Templates', 'slate'],
-];
-
-// Note cssclass -> palette key; `folder` is reused for the graph color groups.
-export const NOTE_COLORS = {
-  session: { cssClass: 'topic-session', folder: '02-Sessões', palette: 'blue' },
-  decision: { cssClass: 'topic-decision', folder: '04-Decisões', palette: 'violet' },
-  bug: { cssClass: 'topic-bug', folder: '05-Bugs', palette: 'red' },
-  learning: { cssClass: 'topic-learning', folder: '06-Aprendizados', palette: 'green' },
-  spec: { cssClass: 'topic-spec', folder: '07-Specs', palette: 'teal' },
-  change: { cssClass: 'topic-change', folder: '08-Mudanças', palette: 'amber' },
+// File-explorer folder KEY -> palette key; folder names resolve via the vault locale.
+const PALETTE_BY_KEY = {
+  inbox: 'amber',
+  project: 'indigo',
+  sessions: 'blue',
+  linear: 'teal',
+  decisions: 'violet',
+  bugs: 'red',
+  learnings: 'green',
+  specs: 'teal',
+  changes: 'amber',
+};
+function folderPalette(loc) {
+  return [...Object.entries(PALETTE_BY_KEY).map(([k, p]) => [loc.folders[k], p]), ['Templates', 'slate']];
+}
+
+// Note cssclass -> palette + locale folder key; `folder` resolves per locale.
+const NOTE_TYPES = {
+  session: { cssClass: 'topic-session', folderKey: 'sessions', palette: 'blue' },
+  decision: { cssClass: 'topic-decision', folderKey: 'decisions', palette: 'violet' },
+  bug: { cssClass: 'topic-bug', folderKey: 'bugs', palette: 'red' },
+  learning: { cssClass: 'topic-learning', folderKey: 'learnings', palette: 'green' },
+  spec: { cssClass: 'topic-spec', folderKey: 'specs', palette: 'teal' },
+  change: { cssClass: 'topic-change', folderKey: 'changes', palette: 'amber' },
 };
+// Legacy pt-shaped export (folder names resolved at pt-BR) kept for compat.
+export const NOTE_COLORS = Object.fromEntries(
+  Object.entries(NOTE_TYPES).map(([k, v]) => [k, { cssClass: v.cssClass, folder: PT.folders[v.folderKey], palette: v.palette }]),
+);
 
-// cssclasses that get the note-accent treatment (the four note types + a home note).
-const TOPIC_CLASSES = [...Object.values(NOTE_COLORS).map((n) => n.cssClass), 'vault-home'];
+// cssclasses that get the note-accent treatment (the note types + a home note).
+const TOPIC_CLASSES = [...Object.values(NOTE_TYPES).map((n) => n.cssClass), 'vault-home'];
 const NOTE_ACCENTS = [
-  ...Object.values(NOTE_COLORS).map((n) => ({ cssClass: n.cssClass, palette: n.palette })),
+  ...Object.values(NOTE_TYPES).map((n) => ({ cssClass: n.cssClass, palette: n.palette })),
   { cssClass: 'vault-home', palette: 'indigo' },
 ];
 
 const FX = '.workspace-leaf-content[data-type="file-explorer"] .nav-folder-title';
-const folderSel = FOLDER_PALETTE.map(([f]) => `[data-path^="${f}"]`).join(',\n  ');
 const topicReading = TOPIC_CLASSES.map((c) => `.${c}`).join(', ');
 
-export function renderColorSnippetCss() {
+export function renderColorSnippetCss(loc = PT) {
+  const FOLDER_PALETTE = folderPalette(loc);
+  const folderSel = FOLDER_PALETTE.map(([f]) => `[data-path^="${f}"]`).join(',\n  ');
   const rootVars = Object.entries(PALETTE)
     .map(([k, v]) => `  --us-${k}: ${v.hex};\n  --us-${k}-rgb: ${v.rgb};`)
     .join('\n');
@@ -181,9 +191,9 @@ export function mergeAppearance(existing, snippetName = SNIPPET_NAME) {
 }
 
 // Graph color groups: one per note folder, colored from the palette.
-export function graphColorGroups() {
-  return Object.values(NOTE_COLORS).map((v) => ({
-    query: `path:"${v.folder}"`,
+export function graphColorGroups(loc = PT) {
+  return Object.values(NOTE_TYPES).map((v) => ({
+    query: `path:"${loc.folders[v.folderKey]}"`,
     color: { a: 1, rgb: parseInt(PALETTE[v.palette].hex.slice(1), 16) },
   }));
 }

package/src/verify.mjs

@@ -7,6 +7,7 @@ import { parseTasks, activeChange, appendFixTasks } from '../hooks/change-core.m
 import { loadSensors, requiredSensors, runSensors, evaluateGate } from '../hooks/sensors-core.mjs';
 import { tasksHashOf } from '../hooks/spec-core.mjs';
 import { addLesson } from '../hooks/lessons-core.mjs';
+import { getLocale } from '../hooks/locale.mjs';
 
 function today() {
   const d = new Date();
@@ -28,7 +29,7 @@ export function runVerify(argv) {
   const slug = opt(argv, '--change') || activeChange(vaultBase);
   if (!slug) { process.stderr.write('wendkeep verify: no change (--change or active).\n'); process.exit(2); }
 
-  const changeDir = join(vaultBase, '08-Mudanças', slug);
+  const changeDir = join(vaultBase, getLocale(vaultBase).folders.changes, slug);
   let tarefas = '';
   try { tarefas = readFileSync(join(changeDir, 'tarefas.md'), 'utf8'); }
   catch { process.stderr.write(`wendkeep verify: change not found: ${slug}\n`); process.exit(2); }