wendkeep 0.32.0 → 0.34.0

package/hooks/spec-core.mjs

@@ -11,6 +11,14 @@ export function tasksHashOf(md) {
   return createHash('sha1').update(String(md)).digest('hex').slice(0, 12);
 }
 
+export function contentHashOf(value) {
+  return createHash('sha256').update(String(value)).digest('hex');
+}
+
+export const SPECS_STATE_FILE = '.brain/SPECS_STATE.json';
+export const SPEC_BASELINE_FILE = '.spec-base.json';
+export const MANAGED_SPEC_MARKER = '<!-- wendkeep:managed-spec — generated from 08-Mudanças; do not edit directly -->';
+
 // Parse is BILINGUAL always (mixed vaults never break); rendering follows the vault locale.
 const REQ_RE = /^### (?:Requisito|Requirement):\s*(.+)$/gm;
 
@@ -21,7 +29,7 @@ export function parseRequirements(md) {
   for (let i = 0; i < matches.length; i += 1) {
     const raw = matches[i][1].trim();
     // Identity is the ID (e.g. GATE-1) when the heading is "<ID> — <nome>"; else the whole text.
-    const idM = raw.match(/^([A-Z][A-Z0-9]*-\d+)\s*—\s*(.+)$/);
+    const idM = raw.match(/^([A-Z][A-Z0-9]*(?:-[A-Z0-9]+)*-\d+)\s*—\s*(.+)$/);
     const id = idM ? idM[1] : null;
     const name = idM ? idM[2].trim() : raw;
     const start = matches[i].index + matches[i][0].length;
@@ -75,7 +83,148 @@ export function applyDelta(reqs, delta) {
 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}`;
+  return `${MANAGED_SPEC_MARKER}\n---\ntype: spec\ncssclasses:\n  - topic-spec\ntags:\n  - spec\n---\n\n# ${capability}\n\n## Requisitos\n\n${blocks}${foot}`;
+}
+
+function readLivingSpecs(vaultBase) {
+  const specsDir = join(vaultBase, getLocale(vaultBase).folders.specs);
+  const specs = {};
+  let files = [];
+  try { files = readdirSync(specsDir).filter((f) => f.endsWith('.md') && f !== 'README.md'); } catch { return specs; }
+  for (const file of files) {
+    const capability = file.replace(/\.md$/, '');
+    const md = readFileSync(join(specsDir, file), 'utf8');
+    specs[capability] = {
+      hash: contentHashOf(md),
+      requirements: Object.fromEntries(parseRequirements(md).map((r) => [r.id || r.name, contentHashOf(JSON.stringify(r))])),
+    };
+  }
+  return specs;
+}
+
+export function livingSpecCapabilities(vaultBase) {
+  return Object.keys(readLivingSpecs(vaultBase));
+}
+
+export function adoptSpecsState(vaultBase) {
+  const state = { version: 1, generatedAt: new Date().toISOString(), specs: readLivingSpecs(vaultBase) };
+  ensureDir(join(vaultBase, '.brain'));
+  writeFileSync(join(vaultBase, SPECS_STATE_FILE), `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+  return state;
+}
+
+export function readSpecsState(vaultBase) {
+  try { return JSON.parse(readFileSync(join(vaultBase, SPECS_STATE_FILE), 'utf8')); } catch { return null; }
+}
+
+export function checkSpecsState(vaultBase) {
+  const recorded = readSpecsState(vaultBase);
+  if (!recorded) return { ok: false, missing: true, changed: [] };
+  const current = readLivingSpecs(vaultBase);
+  const names = new Set([...Object.keys(recorded.specs || {}), ...Object.keys(current)]);
+  const changed = [...names].filter((name) => recorded.specs?.[name]?.hash !== current[name]?.hash);
+  return { ok: changed.length === 0, missing: false, changed, current, recorded };
+}
+
+function recordPromotedSpecs(vaultBase, capabilities) {
+  const existing = readSpecsState(vaultBase);
+  if (!existing) return adoptSpecsState(vaultBase);
+  const current = readLivingSpecs(vaultBase);
+  const specs = { ...(existing.specs || {}) };
+  for (const capability of capabilities) {
+    if (current[capability]) specs[capability] = current[capability];
+    else delete specs[capability];
+  }
+  const state = { version: 1, generatedAt: new Date().toISOString(), specs };
+  writeFileSync(join(vaultBase, SPECS_STATE_FILE), `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+  return state;
+}
+
+export function captureSpecBaseline(vaultBase, changeDir, { refresh = false } = {}) {
+  const path = join(changeDir, SPEC_BASELINE_FILE);
+  if (!refresh && existsSync(path)) {
+    try { return JSON.parse(readFileSync(path, 'utf8')); } catch { /* rebuild malformed baseline */ }
+  }
+  const baseline = { version: 1, capturedAt: new Date().toISOString(), specs: readLivingSpecs(vaultBase) };
+  writeFileSync(path, `${JSON.stringify(baseline, null, 2)}\n`, 'utf8');
+  return baseline;
+}
+
+export function specConflicts(vaultBase, changeDir, capabilities = discoverSpecDeltas(changeDir)) {
+  let baseline = null;
+  try { baseline = JSON.parse(readFileSync(join(changeDir, SPEC_BASELINE_FILE), 'utf8')); } catch { /* legacy change */ }
+  if (!baseline) return [];
+  const current = readLivingSpecs(vaultBase);
+  const conflicts = [];
+  for (const capability of capabilities) {
+    let delta;
+    try { delta = parseDelta(readFileSync(join(changeDir, 'specs', capability, 'spec.md'), 'utf8')); } catch { continue; }
+    const baseReqs = baseline.specs?.[capability]?.requirements || {};
+    const currentReqs = current[capability]?.requirements || {};
+    for (const req of delta.added || []) {
+      const key = req.id || req.name;
+      if (!(key in baseReqs) && key in currentReqs) conflicts.push(`${capability}:${key} foi adicionado por outra change`);
+    }
+    for (const req of delta.modified || []) {
+      const key = req.id || req.name;
+      if (baseReqs[key] !== currentReqs[key]) conflicts.push(`${capability}:${key} mudou desde a abertura da change`);
+    }
+    for (const key of delta.removed || []) {
+      if (baseReqs[key] !== currentReqs[key]) conflicts.push(`${capability}:${key} mudou desde a abertura da change`);
+    }
+  }
+  return conflicts;
+}
+
+export function resolveEffectiveSpecs(vaultBase, changeDir, capabilities = discoverSpecDeltas(changeDir)) {
+  const specsDir = join(vaultBase, getLocale(vaultBase).folders.specs);
+  const result = [];
+  const warnings = [];
+  const errors = [];
+  for (const capability of capabilities) {
+    let living = [];
+    try { living = parseRequirements(readFileSync(join(specsDir, `${capability}.md`), 'utf8')); } catch { /* new capability */ }
+    let deltaMd = '';
+    try { deltaMd = readFileSync(join(changeDir, 'specs', capability, 'spec.md'), 'utf8'); } catch { /* unchanged living capability */ }
+    if (deltaMd && isPlaceholderDelta(deltaMd)) deltaMd = '';
+    const delta = deltaMd ? parseDelta(deltaMd) : { added: [], modified: [], removed: [] };
+    const operations = new Map(living.map((r) => [r.id || r.name, { operation: 'BASE', source: 'living' }]));
+    for (const r of delta.added) operations.set(r.id || r.name, { operation: 'ADDED', source: 'change' });
+    for (const r of delta.modified) operations.set(r.id || r.name, { operation: 'MODIFIED', source: 'change' });
+    for (const key of delta.removed) operations.delete(key);
+    const applied = applyDelta(living, delta);
+    warnings.push(...applied.warnings.map((w) => `${capability}: ${w}`));
+    for (const warning of applied.warnings) {
+      if (/^(ADDED já existe|MODIFIED inexistente|REMOVED inexistente)/.test(warning)) errors.push(`${capability}: ${warning}`);
+    }
+    result.push({
+      capability,
+      requirements: applied.reqs.map((r) => ({ ...r, capability, ...(operations.get(r.id || r.name) || { operation: 'BASE', source: 'living' }) })),
+    });
+  }
+  const serializable = result.map((s) => ({ capability: s.capability, requirements: s.requirements }));
+  return { specs: result, requirements: result.flatMap((s) => s.requirements), warnings, errors, hash: contentHashOf(JSON.stringify(serializable)) };
+}
+
+export function buildEffectiveRequirementPackage(vaultBase, changeDir, reqIds = []) {
+  let listed = [];
+  try { listed = parseSpecsList(readFileSync(join(changeDir, 'proposta.md'), 'utf8')); } catch { /* caller validates change */ }
+  const changed = [...new Set([...listed, ...discoverSpecDeltas(changeDir)])];
+  const capabilities = [...new Set([...livingSpecCapabilities(vaultBase), ...changed])];
+  const effective = resolveEffectiveSpecs(vaultBase, changeDir, capabilities);
+  const byId = new Map(effective.requirements.filter((r) => r.id).map((r) => [r.id, r]));
+  const missing = reqIds.filter((id) => !byId.has(id));
+  const requirements = reqIds.map((id) => byId.get(id)).filter(Boolean);
+  const relevantCaps = new Set([...changed, ...requirements.map((r) => r.capability)]);
+  const relevant = effective.specs.filter((spec) => relevantCaps.has(spec.capability));
+  return {
+    ...effective,
+    specs: relevant,
+    requirements,
+    missing,
+    changedCapabilities: changed,
+    hash: contentHashOf(JSON.stringify(relevant)),
+  };
 }
 
 export function parseSpecsList(propostaMd) {
@@ -160,6 +309,13 @@ export function promoteSpecs(vaultBase, changeDir, specs, { changeWikilink, date
   const specsDir = loc.folders.specs;
   const promoted = [];
   const warnings = [];
+  const state = checkSpecsState(vaultBase);
+  const unmanaged = state.missing ? [] : state.changed.filter((capability) => specs.includes(capability));
+  if (unmanaged.length) {
+    throw new Error(`07-Specs alterado fora do WendKeep: ${unmanaged.join(', ')} — mova o delta para 08-Mudanças/<change>/specs`);
+  }
+  const conflicts = specConflicts(vaultBase, changeDir, specs);
+  if (conflicts.length) throw new Error(`conflito de spec: ${conflicts.join('; ')} — reconcilie o delta e rode \`wendkeep spec rebase --change <slug> --accept-current\``);
   for (const cap of specs) {
     let deltaMd;
     try { deltaMd = readFileSync(join(changeDir, 'specs', cap, 'spec.md'), 'utf8'); }
@@ -176,13 +332,14 @@ export function promoteSpecs(vaultBase, changeDir, specs, { changeWikilink, date
     writeFileSync(livePath, renderSpec(cap, applied.reqs, { footer, reqHeading: loc.reqHeading }), 'utf8');
     promoted.push(cap);
   }
+  recordPromotedSpecs(vaultBase, promoted);
   return { promoted, warnings };
 }
 
 // Gate check for the independent verdict (Wave A). A requirement-bearing change must have
 // a verdict that is ok and covers every declared req id. A requirement-less change passes:
 // nothing for an independent verifier to check — the sensor gate is already the proof.
-export function evaluateVerdict(verdict, reqIds, { tasksHash } = {}) {
+export function evaluateVerdict(verdict, reqIds, { tasksHash, effectiveSpecHash } = {}) {
   const ids = reqIds || [];
   if (ids.length === 0) return { ok: true, missing: [] };
   if (!verdict || verdict.ok !== true) return { ok: false, missing: [] };
@@ -191,6 +348,9 @@ export function evaluateVerdict(verdict, reqIds, { tasksHash } = {}) {
   if (tasksHash && verdict.tasksHash && verdict.tasksHash !== tasksHash) {
     return { ok: false, missing: [], stale: true };
   }
+  if (effectiveSpecHash && verdict.effectiveSpecHash && verdict.effectiveSpecHash !== effectiveSpecHash) {
+    return { ok: false, missing: [], stale: true };
+  }
   const covered = new Set((verdict.coverage || []).filter((c) => c.covered).map((c) => c.req));
   const missing = ids.filter((r) => !covered.has(r));
   return { ok: missing.length === 0, missing };

package/package.json

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

package/src/change.mjs

@@ -3,8 +3,12 @@ import { readFileSync } from 'node:fs';
 import { isAbsolute, join, resolve } from 'node:path';
 import {
   newChange,
+  useChange,
+  continueChange,
   activeChange,
+  allChangesState,
   listChanges,
+  renderOpenChanges,
   parseTasks,
   setTaskDone,
   archiveChange,
@@ -12,7 +16,7 @@ import {
   scaffoldPlaceholders,
 } from '../hooks/change-core.mjs';
 import { evaluateGate, requiredSensors } from '../hooks/sensors-core.mjs';
-import { evaluateVerdict, tasksHashOf, parseSpecsList, parseDelta, parseRequirements, applyDelta, validateSpecImpact } from '../hooks/spec-core.mjs';
+import { buildEffectiveRequirementPackage, evaluateVerdict, tasksHashOf, parseSpecsList, parseDelta, parseRequirements, applyDelta, validateSpecImpact } from '../hooks/spec-core.mjs';
 import { getNextAdrNumber, readControl } from '../hooks/obsidian-common.mjs';
 import { getLocale } from '../hooks/locale.mjs';
 
@@ -60,10 +64,36 @@ export function runChange(argv) {
     process.exit(0);
   }
 
+  if (sub === 'use') {
+    const slug = slugArg();
+    if (!slug) { process.stderr.write('wendkeep change use: missing <slug>\n'); process.exit(2); }
+    const r = useChange(vaultBase, slug);
+    if (!r.ok) { process.stderr.write(`wendkeep change use: ${r.error}\n`); process.exit(2); }
+    process.stdout.write(`current change: ${slug}\n`);
+    process.exit(0);
+  }
+
+  if (sub === 'continue') {
+    const positionals = rest.filter((a, i) => !a.startsWith('-') && !VALUE_FLAGS.has(rest[i - 1]));
+    const [archivedSlug, newSlug] = positionals;
+    if (!archivedSlug || !newSlug) {
+      process.stderr.write('wendkeep change continue: use <archived-slug> <new-slug>\n');
+      process.exit(2);
+    }
+    let sessionRel = '';
+    try { sessionRel = readControl(vaultBase).session_file || ''; } catch { /* no control */ }
+    const r = continueChange(vaultBase, archivedSlug, newSlug, {
+      dateStr: today(), simple: rest.includes('--simple'), sessionRel,
+    });
+    if (!r.ok) { process.stderr.write(`wendkeep change continue: ${r.error}\n`); process.exit(2); }
+    process.stdout.write(`change created: ${r.rel} (continues ${r.archived}; active)\n`);
+    process.exit(0);
+  }
+
   if (sub === 'list') {
-    const { active, archived } = listChanges(vaultBase);
-    const cur = activeChange(vaultBase);
-    process.stdout.write(`active: ${active.map((s) => (s === cur ? `*${s}` : s)).join(', ') || '(none)'}\n`);
+    const state = allChangesState(vaultBase);
+    const { archived } = listChanges(vaultBase);
+    process.stdout.write(`${renderOpenChanges(state, { tag: '' }) || 'open changes: (none)'}\n`);
     process.stdout.write(`archived: ${archived.join(', ') || '(none)'}\n`);
     process.exit(0);
   }
@@ -82,8 +112,16 @@ 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 slug = slugArg();
+    if (!slug) {
+      const state = allChangesState(vaultBase);
+      if (!state.changes.length && !state.pointerWarning) {
+        process.stderr.write('wendkeep change status: no open changes\n');
+        process.exit(2);
+      }
+      process.stdout.write(`${renderOpenChanges(state, { tag: '' })}\n`);
+      process.exit(0);
+    }
     const dir = join(vaultBase, getLocale(vaultBase).folders.changes, slug);
     let tarefasMd;
     try { tarefasMd = readFileSync(join(dir, 'tarefas.md'), 'utf8'); }
@@ -103,12 +141,16 @@ export function runChange(argv) {
     if (evidence) for (const e of evidence) process.stdout.write(`  ${e.status === 'green' ? '✓' : '✗'} ${e.id} (${e.severity || 'critical'})\n`);
     else process.stdout.write('evidencia: ausente\n');
     const reqIds = [...new Set(tasks.map((t) => t.req).filter(Boolean))];
+    const effective = buildEffectiveRequirementPackage(vaultBase, dir, reqIds);
+    if (effective.errors.length || effective.missing.length) {
+      process.stdout.write(`spec efetiva: inválida (${[...effective.errors, ...effective.missing.map((id) => `req órfão ${id}`)].join('; ')})\n`);
+    }
     let verdict = null;
     try { verdict = JSON.parse(readFileSync(join(dir, 'verdict.json'), 'utf8')); } catch { /* sem verdict */ }
     if (!verdict) process.stdout.write(`verdict: ausente — rode \`wendkeep verify --deep\`${reqIds.length ? ' + wk-verify' : ' (verdict trivial automático)'}\n`);
     else if (!reqIds.length) process.stdout.write(`verdict: ${verdict.ok === true ? 'ok (trivial)' : 'não-ok — re-verifique'}\n`);
     else {
-      const v = evaluateVerdict(verdict, reqIds, { tasksHash: tasksHashOf(tarefasMd) });
+      const v = evaluateVerdict(verdict, reqIds, { tasksHash: tasksHashOf(tarefasMd), effectiveSpecHash: effective.hash });
       process.stdout.write(`verdict: ${v.ok ? 'ok' : v.stale ? 'stale — re-verifique' : `incompleto: falta ${v.missing.join(', ')}`}\n`);
     }
     try { process.stdout.write(`mutation-round: ${readFileSync(join(dir, '.mutation-round'), 'utf8').trim()}/3\n`); } catch { /* sem rodadas */ }
@@ -185,6 +227,9 @@ export function runChange(argv) {
         }
       }
       const reqIds = [...new Set(tasks.map((t) => t.req).filter(Boolean))];
+      const effective = buildEffectiveRequirementPackage(vaultBase, dir, reqIds);
+      if (effective.errors.length) return { ok: false, failing: [`spec efetiva inválida: ${effective.errors.join('; ')}`] };
+      if (effective.missing.length) return { ok: false, failing: [`requisito(s) órfão(s) na spec efetiva: ${effective.missing.join(', ')}`] };
       let evidence = [];
       try { evidence = JSON.parse(readFileSync(join(dir, 'evidencia.json'), 'utf8')); } catch { /* no evidence */ }
       const s = evaluateGate(evidence, required);
@@ -204,8 +249,16 @@ export function runChange(argv) {
       if (verdict.tasksHash && verdict.tasksHash !== hash) {
         return { ok: false, failing: [`verdict stale (tarefas.md mudou depois da verificação) — re-verifique: \`wendkeep verify --deep\`${reqIds.length ? ' + wk-verify' : ''}`] };
       }
+      let verification = null;
+      try { verification = JSON.parse(readFileSync(join(dir, 'verificacao.json'), 'utf8')); } catch { /* none */ }
+      if (verification?.effectiveSpecHash && verification.effectiveSpecHash !== effective.hash) {
+        return { ok: false, failing: ['pacote de verificação stale (spec efetiva mudou) — rode `wendkeep verify --deep` novamente'] };
+      }
+      if (reqIds.length && verification?.effectiveSpecHash && !verdict.effectiveSpecHash) {
+        return { ok: false, failing: ['verdict sem effectiveSpecHash — rode a skill wk-verify novamente'] };
+      }
       if (reqIds.length) {
-        const v = evaluateVerdict(verdict, reqIds, { tasksHash: hash });
+        const v = evaluateVerdict(verdict, reqIds, { tasksHash: hash, effectiveSpecHash: effective.hash });
         if (!v.ok) {
           if (v.stale) return { ok: false, failing: ['verdict stale (tarefas.md mudou depois da verificação) — re-verifique: `wendkeep verify --deep` + wk-verify'] };
           return { ok: false, failing: [`verdict incompleto: falta ${v.missing.join(', ')}`] };
@@ -240,6 +293,6 @@ export function runChange(argv) {
     process.exit(0);
   }
 
-  process.stderr.write(`wendkeep change: unknown subcommand "${sub}". Known: new, list, show, status, done, undone, diff, archive, abandon.\n`);
+  process.stderr.write(`wendkeep change: unknown subcommand "${sub}". Known: new, use, continue, list, show, status, done, undone, diff, archive, abandon.\n`);
   process.exit(2);
 }

package/src/doctor.mjs

@@ -5,6 +5,7 @@ import { existsSync } from 'node:fs';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { checkHarness } from '../hooks/harness-doctor.mjs';
+import { checkSyncDefs } from './sync-defs.mjs';
 
 export function runDoctor(argv) {
   const here = dirname(fileURLToPath(import.meta.url));
@@ -40,6 +41,11 @@ export function runDoctor(argv) {
 
   // 2. Harness integrity (Wave B).
   const { errors, warnings } = checkHarness(vaultBase, projectRoot);
+  const defs = checkSyncDefs(vaultBase, projectRoot);
+  if (!defs.ok) {
+    warnings.push(...defs.issues.map((issue) => `defs: ${issue}`));
+    warnings.push('defs stale — rode `wendkeep sync-defs --reseed` e reinicie Claude Code/Codex');
+  }
   process.stdout.write(`\n[harness] ${errors.length} erro(s), ${warnings.length} aviso(s)\n`);
   for (const e of errors) process.stdout.write(`  ✗ ${e}\n`);
   for (const w of warnings) process.stdout.write(`  ! ${w}\n`);

package/src/init.mjs

@@ -3,7 +3,7 @@
 // OBSIDIAN_VAULT_PATH into .claude/settings.json, and adds the mcpvault server to
 // .mcp.json. Idempotent: re-running only adds what is missing.
 import { spawnSync } from 'node:child_process';
-import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { basename, isAbsolute, join, resolve } from 'node:path';
 import { createInterface } from 'node:readline/promises';
 import {
@@ -40,6 +40,7 @@ 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';
+import { adoptSpecsState, SPECS_STATE_FILE } from '../hooks/spec-core.mjs';
 
 function parseArgs(argv) {
   const args = { mcp: true, yes: false, force: false };
@@ -278,7 +279,7 @@ const MESSAGES = {
     colorsOn: 'wendkeep-colors (snippet + grupos do grafo)',
     taxonomy: (n, c, loc, readme, views) => `  [1/4] taxonomia do vault: ${n} pastas (${c} criadas, locale ${loc})${readme}, .brain + change/spec + sensores semeados${views}`,
     readmeCreated: ', README.md criado', viewsNote: (n) => `, ${n} view(s) + dashboard`,
-    defs: (s, a) => `        defs entregues: ${s} skill(s) -> .claude/skills, ${a} agent(s) -> .codex/agents`,
+    defs: (s, a) => `        defs entregues: ${s} skill(s) -> .claude/skills + .agents/skills, ${a} agent(s) -> .codex/agents`,
     settingsBadJson: (p) => `  [2/4] settings.json existe mas não é JSON válido -> escrevi ${p}.new (mescle à mão)`,
     settings: (verb, added, bak) => `  [2/4] settings.json ${verb} (${added} hook(s) wirados, OBSIDIAN_VAULT_PATH setado${bak})`,
     mcpBadJson: (p) => `  [3/4] .mcp.json existe mas não é JSON válido -> escrevi ${p}.new (mescle à mão)`,
@@ -303,7 +304,7 @@ const MESSAGES = {
     colorsOn: 'wendkeep-colors (snippet + graph groups)',
     taxonomy: (n, c, loc, readme, views) => `  [1/4] vault taxonomy: ${n} folders (${c} created, locale ${loc})${readme}, .brain + change/spec + sensors seeded${views}`,
     readmeCreated: ', README.md created', viewsNote: (n) => `, ${n} view(s) + dashboard`,
-    defs: (s, a) => `        defs delivered: ${s} skill(s) -> .claude/skills, ${a} agent(s) -> .codex/agents`,
+    defs: (s, a) => `        defs delivered: ${s} skill(s) -> .claude/skills + .agents/skills, ${a} agent(s) -> .codex/agents`,
     settingsBadJson: (p) => `  [2/4] settings.json exists but is not valid JSON -> wrote ${p}.new (merge by hand)`,
     settings: (verb, added, bak) => `  [2/4] settings.json ${verb} (${added} hook(s) wired, OBSIDIAN_VAULT_PATH set${bak})`,
     mcpBadJson: (p) => `  [3/4] .mcp.json exists but is not valid JSON -> wrote ${p}.new (merge by hand)`,
@@ -482,8 +483,12 @@ export async function runInit(argv) {
   const specsReadme = join(vaultPath, loc.folders.specs, 'README.md');
   if (!existsSync(specsReadme)) {
     writeFileSync(specsReadme, en
-      ? `# Specs — living contract\n\nThe project's capabilities (requirements/scenarios). Changes in \`${loc.folders.changes}/\` promote deltas here on \`wendkeep change archive\`.\n`
-      : `# Specs — contrato vivo\n\nCapacidades do projeto (requisitos/cenários). Changes em \`${loc.folders.changes}/\` promovem deltas aqui no \`wendkeep change archive\`.\n`, 'utf8');
+      ? `# Specs — generated living contract\n\nRead-only: do not author here. Write deltas only in \`${loc.folders.changes}/<slug>/specs/\`; archive promotes them here.\n`
+      : `# Specs — contrato consolidado gerado\n\nSomente leitura: não edite aqui. Escreva deltas apenas em \`${loc.folders.changes}/<slug>/specs/\`; o archive promove para cá.\n`, 'utf8');
+  }
+  if (!existsSync(join(vaultPath, SPECS_STATE_FILE))) {
+    const livingSpecs = readdirSync(join(vaultPath, loc.folders.specs)).filter((name) => name.endsWith('.md') && name !== 'README.md');
+    if (!livingSpecs.length) adoptSpecsState(vaultPath);
   }
   const changeTpl = join(vaultPath, 'Templates', 'Change.md');
   if (!existsSync(changeTpl)) {

package/src/skills-seed.mjs

@@ -1,6 +1,6 @@
 // src/skills-seed.mjs — native, zero-dep process skills (Pilar A: the HOW layer).
 // Seeded into the vault's .brain/skills; distributed by `wendkeep sync-defs` to
-// .claude/skills. Wendkeep-flavored (reference change/verify), concise native prose.
+// .claude/skills + .agents/skills. Wendkeep-flavored, concise native prose.
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 
@@ -29,8 +29,9 @@ vault cego. Exceção única: mudança trivial (typo, 1 linha).
    - \`proposta.md\` — *por quê* e *o que muda* (o WHAT).
    - \`design.md\` — a abordagem técnica.
    - \`tarefas.md\` — a lista de tarefas \`- [ ] N.N descrição\`.
-   A mudança vira a *ativa* (ponteiro \`.brain/CURRENT_CHANGE.md\`) e é injetada no
-   próximo SessionStart, então você retoma o trabalho em curso automaticamente.
+   A mudança vira a *atual* (ponteiro global \`.brain/CURRENT_CHANGE.md\`). Podem existir
+   várias changes abertas: hooks e \`change list/status\` mostram todas as pendências; comandos
+   sem \`--change\` usam somente a atual.
    Antes de implementar, resolva \`spec_impact\` na proposta:
    - \`required\`: liste a capability em \`specs:\` e preencha
      \`specs/<capability>/spec.md\` com ADDED/MODIFIED/REMOVED; ligue tarefas com \`[req:ID]\`.
@@ -40,12 +41,13 @@ vault cego. Exceção única: mudança trivial (typo, 1 linha).
    (teste vermelho antes do código). Marque \`- [x]\` ao concluir. Declare nas tarefas:
    - \`[sensor:<id>]\` — a prova automatizada (roda no verify).
    - \`[req:<ID>]\` — o requisito do spec que a tarefa satisfaz (ex.: \`[req:GATE-1]\`),
-     quando a change mexe numa capability de \`07-Specs\`.
+      quando a change mexe numa capability. Toda autoria de spec ocorre somente em
+      \`08-Mudanças/<slug>/specs/<capability>/spec.md\`; \`07-Specs\` é gerado/read-only.
    Ex.: \`- [ ] 2.1 valida CORE [req:MEM-1] [sensor:memory-validation]\`.
 4. **Verify** — \`wendkeep verify\` roda os sensores → \`evidencia.json\`. Depois
    \`wendkeep verify --deep\` monta o *pacote de verificação* pro passe independente.
 5. **Verify deep** — a skill **wk-verify** (passe fresco, autor≠verificador) lê o pacote,
-   re-deriva a cobertura do \`07-Specs\` e grava \`verdict.json\`. Change trivial (sem
+   usa somente os requisitos autocontidos de \`verificacao.json\` e grava \`verdict.json\`. Change trivial (sem
    \`[req:]\`) recebe verdict automático — pula este passe.
 6. **Archive** — \`wendkeep change archive <slug>\`. O *gate* exige sensores verdes **E**
    \`verdict.json\` cobrindo os \`[req:]\`. Passando, promove os deltas pro \`07-Specs\`,
@@ -53,7 +55,9 @@ vault cego. Exceção única: mudança trivial (typo, 1 linha).
 
 ## Regras
 
-- Uma mudança ativa por vez. Termine (archive) antes de abrir outra.
+- Várias changes podem ficar abertas. \`CURRENT_CHANGE.md\` marca uma atual, sem esconder as
+  outras pendências. Claude, Codex ou outro agente assumem uma change existente com
+  \`wendkeep change use <slug>\` ou \`--change <slug>\` quando disponível.
 - Se uma tarefa não precisa de prova automatizada, não declare sensor — o gate só exige
   o que você declarou. Sem \`[sensor:]\`, o archive não trava.
 - A proposta linka a sessão de origem; a sessão linka a mudança ativa. É de propósito:
@@ -74,7 +78,8 @@ vermelho pedindo por ele — e nunca escreva um teste que passaria sob a impleme
 
 ## Derive do spec, não do código
 
-Escreva a asserção a partir do *critério de aceite* do requisito (\`07-Specs\`), não lendo a
+Escreva a asserção a partir do *critério de aceite* da spec efetiva
+(\`wendkeep spec effective --change <slug>\`), não lendo a
 implementação. Cada asserção mira o resultado que o spec definiu. Escrever o teste lendo o
 código = ele só confirma o que o código já faz, bugs inclusos.
 
@@ -211,13 +216,13 @@ nunca tivesse visto a implementação. Contexto fresco, read-only.
 ## O que fazer
 
 1. Leia o pacote \`08-Mudanças/<slug>/verificacao.json\` (requisitos, tarefas, evidência).
-2. **Re-derive a cobertura do \`07-Specs\`** — pra cada \`[req:ID]\` da change, cheque se o
-   comportamento definido no requisito está coberto por um teste que discrimina (não
+2. **Re-derive a cobertura do pacote autocontido** — pra cada requisito completo em
+   \`verificacao.json\`, cheque se o comportamento está coberto por um teste que discrimina (não
    passaria sob impl errada). Evidência \`arquivo:linha\`.
 3. Outcome check ancorado no spec: o resultado observável bate com o critério de aceite?
 4. Grave \`08-Mudanças/<slug>/verdict.json\`:
-   \`{ "slug": "...", "ok": true, "coverage": [{ "req": "GATE-1", "covered": true, "evidence": "arquivo:linha" }], "tasksHash": "<copie do verificacao.json>", "notes": [] }\`.
-   O \`tasksHash\` vem do pacote — é o selo de frescor; sem ele (ou com tarefas alteradas
+   \`{ "slug": "...", "ok": true, "coverage": [{ "req": "GATE-1", "covered": true, "evidence": "arquivo:linha" }], "tasksHash": "<copie do verificacao.json>", "effectiveSpecHash": "<copie do verificacao.json>", "notes": [] }\`.
+   \`tasksHash\` e \`effectiveSpecHash\` vêm do pacote — são selos de frescor; sem eles (ou com tarefas/spec alteradas
    depois), o gate rejeita o verdict como stale.
 
 ## Regras
@@ -248,13 +253,15 @@ leaves the vault blind. Single exception: a trivial change (typo, one line).
 
 1. **Explore** — understand the problem before proposing.
 2. **Propose** — \`wendkeep change new <slug>\` scaffolds \`08-Changes/<slug>/\`
-   (proposta/design/tarefas + a \`specs/\` delta). The change becomes *active* and is
-   injected at the next SessionStart.
+   (proposta/design/tarefas + a \`specs/\` delta). The change becomes *current* through global
+   \`.brain/CURRENT_CHANGE.md\`. Multiple changes may stay open; hooks and \`change list/status\`
+   show every pending task, while commands without \`--change\` use only the current change.
    Before implementation, resolve \`spec_impact\`: \`required\` needs the capability listed in
    \`specs:\` plus a real \`specs/<capability>/spec.md\` delta and \`[req:ID]\` links; \`none\`
    needs a real \`spec_impact_reason\`. \`pending\` is never ready for implementation/archive.
 3. **Apply** — implement each task in tarefas.md with **wk-tdd** (red test first). Tag tasks:
    \`[sensor:<id>]\` (automated proof) and \`[req:<ID>]\` (the spec requirement it satisfies).
+   Author specs only in \`08-Changes/<slug>/specs/\`; \`07-Specs\` is generated/read-only.
 4. **Verify** — \`wendkeep verify\` runs the sensors; then \`wendkeep verify --deep\` builds
    the verification package.
 5. **Verify deep** — the **wk-verify** skill (fresh, author≠verifier) writes \`verdict.json\`.
@@ -263,7 +270,9 @@ leaves the vault blind. Single exception: a trivial change (typo, one line).
    verdict AND no open tasks. It promotes the delta into \`07-Specs\` and mints an ADR.
 
 ## Rules
-- One active change at a time. Finish (archive) before starting another.
+- Multiple changes may stay open. \`CURRENT_CHANGE.md\` marks one current change without hiding
+  other pending tasks. Any agent may take over an existing change with
+  \`wendkeep change use <slug>\` or \`--change <slug>\` where available.
 - No \`[sensor:]\` on a task = no automated gate for it. No \`[req:]\` = no independent verdict.
 - The graph links session ↔ change ↔ requirement ↔ decision. That is the point.
 `;
@@ -280,7 +289,7 @@ would pass under the wrong implementation.
 4. **Refactor** with the greens protecting you.
 
 ## Derive from the spec, not the code
-Write assertions from the requirement's acceptance criteria (\`07-Specs\`), not by reading the
+Write assertions from the effective requirement (\`wendkeep spec effective --change <slug>\`), not by reading the
 implementation. Reading the code to write the test = it only confirms what the code already does.
 
 ## Non-shallow litmus
@@ -369,17 +378,18 @@ the author — even if you wrote the code, enter as if you'd never seen it. Fres
 
 ## What to do
 1. Read the package \`08-Changes/<slug>/verificacao.json\` (requirements, tasks, evidence).
-2. **Re-derive coverage from \`07-Specs\`** — for each \`[req:ID]\`, check the requirement's behaviour
+2. **Re-derive coverage from the self-contained package** — for each complete requirement in
+   \`verificacao.json\`, check its behaviour
    is covered by a test that discriminates (wouldn't pass under a wrong impl). \`file:line\` evidence.
 3. Spec-anchored outcome check: does the observable result match the acceptance criterion?
 4. Write \`08-Changes/<slug>/verdict.json\`:
-   \`{ "slug": "...", "ok": true, "coverage": [{ "req": "GATE-1", "covered": true, "evidence": "file:line" }], "tasksHash": "<copy from the package>", "notes": [] }\`.
+   \`{ "slug": "...", "ok": true, "coverage": [{ "req": "GATE-1", "covered": true, "evidence": "file:line" }], "tasksHash": "<copy from the package>", "effectiveSpecHash": "<copy from the package>", "notes": [] }\`.
 
 ## Rules
 - **Author ≠ verifier.** On Claude, spawn a read-only sub-agent for real isolation.
 - \`ok: false\` if any requirement lacks discriminating coverage. A gap is red, not "almost".
 - Don't fix here — a gap becomes a fix task; re-verify after.
-- The archive gate **requires** a fresh \`verdict.json\` (matching \`tasksHash\`) covering every \`[req:]\`.
+- The archive gate **requires** a fresh \`verdict.json\` (matching \`tasksHash\` and \`effectiveSpecHash\`) covering every \`[req:]\`.
 
 ## Templates (in this folder)
 - \`spec-reviewer-prompt.md\` — hand it to the verifier sub-agent you spawn (read-only, author≠verifier).
@@ -396,6 +406,7 @@ const VERDICT_TEMPLATE = `{
     { "req": "GATE-1", "covered": true, "evidence": "tests/foo.test.mjs:42" }
   ],
   "tasksHash": "<copie de verificacao.json — selo de frescor / copy from verificacao.json — freshness seal>",
+  "effectiveSpecHash": "<copie de verificacao.json / copy from verificacao.json>",
   "notes": []
 }
 `;
@@ -409,8 +420,8 @@ Claude). Ele NÃO é o autor: entra fresco, read-only, não edita nada.
 Você é o verificador independente de uma mudança do wendkeep. Não escreveu este código —
 entre como se nunca o tivesse visto. Read-only.
 
-Leia o pacote \`08-Mudanças/<slug>/verificacao.json\` (requisitos, tarefas, evidência) e os
-specs vivos em \`07-Specs/<capability>.md\`.
+Leia somente o pacote autocontido \`08-Mudanças/<slug>/verificacao.json\` (requisitos completos,
+tarefas e evidência). Não reabra \`07-Specs\`: ele ainda não contém deltas não arquivados.
 
 Para cada \`[req:ID]\` da mudança:
 1. Leia o **critério de aceite do requisito** no spec — NÃO leia a implementação primeiro.
@@ -421,7 +432,7 @@ Para cada \`[req:ID]\` da mudança:
 
 Grave \`08-Mudanças/<slug>/verdict.json\` no formato de \`verdict-template.json\`. \`ok: false\` se
 qualquer \`[req:]\` não tem cobertura que discrimina. Não conserte aqui — gap vira tarefa de
-correção. O \`tasksHash\` vem do pacote (selo de frescor; alterou tarefa depois, o gate rejeita).
+correção. \`tasksHash\` e \`effectiveSpecHash\` vêm do pacote; alterações posteriores deixam o verdict stale.
 ---
 `;
 
@@ -434,8 +445,8 @@ It is NOT the author: fresh context, read-only, edits nothing.
 You are the independent verifier of a wendkeep change. You did not write this code — enter as if
 you'd never seen it. Read-only.
 
-Read the package \`08-Changes/<slug>/verificacao.json\` (requirements, tasks, evidence) and the
-living specs in \`07-Specs/<capability>.md\`.
+Read only the self-contained \`08-Changes/<slug>/verificacao.json\` package (complete requirements,
+tasks, evidence). Do not reopen \`07-Specs\`: it does not contain unarchived deltas yet.
 
 For each \`[req:ID]\`:
 1. Read the requirement's **acceptance criterion** in the spec — do NOT read the implementation first.
@@ -446,7 +457,7 @@ For each \`[req:ID]\`:
 
 Write \`08-Changes/<slug>/verdict.json\` in the shape of \`verdict-template.json\`. \`ok: false\` if any
 \`[req:]\` lacks discriminating coverage. Don't fix here — a gap becomes a fix task. \`tasksHash\`
-comes from the package (freshness seal; edit a task later and the gate rejects it as stale).
+and \`effectiveSpecHash\` come from the package (freshness seals; later task/spec edits make verdict stale).
 ---
 `;