wendkeep 0.30.0 → 0.32.0

package/hooks/decision-capture.mjs

@@ -33,9 +33,20 @@ export function decisionKeyExists(dir, key) {
   return false;
 }
 
-// The AskUserQuestion tool_output reads: `... "Question"="chosen labels"  "Q2"="..."`.
+// Claude Code >= 2.1 returns `{ answers: { Question: choice } }` in tool_response.
+// Older releases expose a text tool_output: `... "Question"="chosen labels"  "Q2"="..."`.
 export function parseAnswers(output) {
   const map = {};
+  if (output && typeof output === 'object') {
+    const answers = output.answers && typeof output.answers === 'object'
+      ? output.answers
+      : output;
+    for (const [question, answer] of Object.entries(answers)) {
+      if (typeof answer === 'string') map[clean(question)] = clean(answer);
+      else if (Array.isArray(answer)) map[clean(question)] = answer.map(clean).filter(Boolean).join(',');
+    }
+    if (Object.keys(map).length) return map;
+  }
   const re = /"([^"]+)"\s*=\s*"([^"]*)"/g;
   let m;
   while ((m = re.exec(String(output || '')))) map[m[1].trim()] = m[2].trim();
@@ -172,7 +183,35 @@ export function captureDecision(vaultBase, input) {
   writeFileSync(filePath, buildDecisionCaptureNote({
     questions, answers, dateStr, startedAt: formatLocalIso(now), sessionRel, provider, localeId: loc.id, adrNum, contentKey,
   }), 'utf-8');
-  return { rel: toVaultRelative(vaultBase, filePath), skipped: false };
+  const rel = toVaultRelative(vaultBase, filePath);
+  if (sessionRel) {
+    try {
+      const sessionPath = join(vaultBase, sessionRel);
+      let session = readFileSync(sessionPath, 'utf8');
+      const wikilink = wikilinkFromRel(rel);
+      const link = `- ${wikilink}`;
+      if (!session.includes(wikilink)) {
+        const heading = '\n## Decisões geradas nesta sessão\n';
+        const at = session.indexOf(heading);
+        if (at !== -1) {
+          const bodyStart = at + heading.length;
+          const nextRel = session.slice(bodyStart).search(/\n## /);
+          const bodyEnd = nextRel === -1 ? session.length : bodyStart + nextRel;
+          const body = session.slice(bodyStart, bodyEnd)
+            .replace(/\n?Nenhuma decisão registrada ainda\.\s*/i, '\n')
+            .trim();
+          const merged = [body, link].filter(Boolean).join('\n');
+          session = `${session.slice(0, bodyStart)}\n${merged}\n\n${session.slice(bodyEnd).replace(/^\n+/, '')}`;
+        } else {
+          const anchor = session.indexOf('\n## Encerramento');
+          const section = `\n## Decisões geradas nesta sessão\n\n${link}\n`;
+          session = anchor === -1 ? `${session.trimEnd()}${section}` : `${session.slice(0, anchor).trimEnd()}${section}${session.slice(anchor)}`;
+        }
+        writeFileSync(sessionPath, session, 'utf8');
+      }
+    } catch { /* backlink auxiliar nunca derruba a captura */ }
+  }
+  return { rel, skipped: false };
 }
 
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {

package/hooks/harness-doctor.mjs

@@ -3,7 +3,7 @@
 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';
+import { parseRequirements, parseSpecsList, parseDelta, evaluateVerdict, validateSpecImpact } from './spec-core.mjs';
 import { getLocale } from './locale.mjs';
 
 export function checkHarness(vaultBase, projectRoot) {
@@ -43,6 +43,9 @@ export function checkHarness(vaultBase, projectRoot) {
     let entries;
     try { entries = readdirSync(dir); } catch { continue; } // a file, not a change dir
     if (!entries.includes('proposta.md')) { errors.push(`change sem proposta.md: ${name}`); continue; }
+    const impact = validateSpecImpact(dir);
+    errors.push(...impact.errors.map((e) => `${name}: ${e}`));
+    warnings.push(...impact.warnings.map((w) => `${name}: ${w}`));
     if (name === active) {
       try {
         for (const cap of parseSpecsList(readFileSync(join(dir, 'proposta.md'), 'utf8'))) {

package/hooks/plan-capture.mjs

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

package/hooks/session-stop.mjs

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

package/hooks/spec-core.mjs

@@ -1,7 +1,7 @@
 // hooks/spec-core.mjs — living spec (07-Specs) + change delta merge (OpenSpec native).
 // Pure parsing/merge + promoteSpecs (fs). No import from change-core (avoids a cycle).
 import { createHash } from 'node:crypto';
-import { readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ensureDir } from './obsidian-common.mjs';
 import { getLocale } from './locale.mjs';
@@ -87,6 +87,73 @@ export function parseSpecsList(propostaMd) {
   return [];
 }
 
+function yamlScalar(text, key) {
+  const m = String(text).match(new RegExp(`^${key}:\\s*(.*)$`, 'm'));
+  return m ? m[1].trim().replace(/^['"]|['"]$/g, '') : '';
+}
+
+export function parseSpecImpact(propostaMd) {
+  const text = String(propostaMd || '');
+  const status = yamlScalar(text, 'spec_impact') || yamlScalar(text, 'spec-impact');
+  const reason = yamlScalar(text, 'spec_impact_reason') || yamlScalar(text, 'spec-impact-reason');
+  return { status, reason };
+}
+
+export function validateSpecImpact(changeDir) {
+  let proposta = '';
+  try { proposta = readFileSync(join(changeDir, 'proposta.md'), 'utf8'); }
+  catch { return { ok: false, errors: ['proposta.md ausente'], warnings: [], status: '', listed: [], onDisk: [] }; }
+
+  const { status, reason } = parseSpecImpact(proposta);
+  const listed = parseSpecsList(proposta);
+  const onDisk = discoverSpecDeltas(changeDir);
+  const enforced = existsSync(join(changeDir, '.spec-impact-v1'));
+  const errors = [];
+  const warnings = [];
+
+  if (!status) {
+    if (enforced) errors.push('spec_impact ausente — classifique como required ou none');
+    else warnings.push('change legada sem spec_impact — migre para required ou none antes do próximo ciclo');
+    return { ok: errors.length === 0, errors, warnings, status: '', listed, onDisk, legacy: !enforced };
+  }
+  if (!['pending', 'required', 'none'].includes(status)) errors.push(`spec_impact inválido: ${status}`);
+  if (status === 'pending') errors.push('spec_impact pending — classifique o impacto antes de arquivar');
+  if (status === 'none') {
+    if (!reason) errors.push('spec_impact none exige justificativa em spec_impact_reason');
+    if (listed.length || onDisk.length) errors.push('spec_impact none contradiz specs/deltas declarados');
+  }
+  if (status === 'required') {
+    if (!listed.length) errors.push('spec_impact required exige ao menos uma capability em specs');
+    for (const cap of listed) if (!onDisk.includes(cap)) errors.push(`delta real ausente para capability ${cap}`);
+    for (const cap of onDisk) if (!listed.includes(cap)) errors.push(`delta ${cap} existe no disco mas não está listado em specs`);
+  }
+  return { ok: errors.length === 0, errors, warnings, status, reason, listed, onDisk, legacy: false };
+}
+
+// Um delta ainda no estado do scaffold (só o requisito "(nome)"/"(name)", nada removido) não é
+// contrato — a promoção o filtra. Um delta com REMOVED é sempre intenção real.
+export function isPlaceholderDelta(md) {
+  const d = parseDelta(md);
+  if (d.removed.length) return false;
+  const all = [...d.added, ...d.modified];
+  if (!all.length) return true;
+  return all.every((r) => /^\((?:nome|name)\)$/.test(r.name));
+}
+
+// Capabilities com delta REAL no disco (<change>/specs/<cap>/spec.md), independente do
+// frontmatter `specs:` da proposta — o scaffold deixa `specs: []` e o buraco engolia deltas
+// preenchidos mas não listados (visto em produção: 07-Specs vazio com delta real no disco).
+export function discoverSpecDeltas(changeDir) {
+  let names = [];
+  try { names = readdirSync(join(changeDir, 'specs')); } catch { return []; }
+  const caps = [];
+  for (const cap of names) {
+    try { if (!isPlaceholderDelta(readFileSync(join(changeDir, 'specs', cap, 'spec.md'), 'utf8'))) caps.push(cap); }
+    catch { /* sem spec.md */ }
+  }
+  return caps;
+}
+
 // Merge each capability's delta (in the change) into the living spec in 07-Specs.
 export function promoteSpecs(vaultBase, changeDir, specs, { changeWikilink, dateStr } = {}) {
   const loc = getLocale(vaultBase);
@@ -94,9 +161,11 @@ export function promoteSpecs(vaultBase, changeDir, specs, { changeWikilink, date
   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; }
+    let deltaMd;
+    try { deltaMd = readFileSync(join(changeDir, 'specs', cap, 'spec.md'), 'utf8'); }
+    catch { throw new Error(`delta ausente para ${cap}`); }
+    if (isPlaceholderDelta(deltaMd)) throw new Error(`delta placeholder para ${cap}`);
+    const delta = parseDelta(deltaMd);
     const livePath = join(vaultBase, specsDir, `${cap}.md`);
     let current = [];
     try { current = parseRequirements(readFileSync(livePath, 'utf8')); } catch { /* nova capability */ }

package/hooks/subagent-usage.mjs

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

package/hooks/vault-health.mjs

@@ -71,14 +71,14 @@ function hasDefaultPending(content) {
     .some((line) => DEFAULT_PENDING_PATTERNS.some((pattern) => pattern.test(line.trim())));
 }
 
-function usageSectionIsPlaced(content) {
+function usageSectionIsPlaced(content, { active = false } = {}) {
   const usage = content.indexOf('\n## Uso de tokens e custos');
   if (usage === -1) return true;
   const changed = content.indexOf('\n## Arquivos criados ou alterados');
   const pending = content.indexOf('\n## Pendências');
   const closing = content.indexOf('\n## Encerramento');
-  if (pending === -1 || closing === -1) return false;
-  return usage < pending && usage < closing && (changed === -1 || usage > changed);
+  if (pending === -1 || (!active && closing === -1)) return false;
+  return usage < pending && (active || usage < closing) && (changed === -1 || usage > changed);
 }
 
 function linkedNotesFromSession(content) {
@@ -102,14 +102,15 @@ function checkSession({ vaultBase, sessionRel, control, registry }) {
     return { failures, warnings, metrics };
   }
 
-  const content = readFileSync(sessionPath, 'utf-8');
+  const content = readFileSync(sessionPath, 'utf-8');
+  const activeSession = control.status === 'active' && control.session_file === sessionRel;
   const duplicates = findDuplicateTurnMarkers(content);
   metrics.turnMarkers = (content.match(/<!-- (?:wk-turn|codex-turn):/g) || []).length;
   metrics.duplicateTurnMarkers = duplicates.length;
 
   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 (!usageSectionIsPlaced(content, { active: activeSession })) 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.');
 
   const registryEntry = registry.sessions?.[control.session_id];

package/package.json

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

package/src/change.mjs

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