wendkeep 0.37.0 → 0.38.1

package/hooks/vault-health.mjs

@@ -1,209 +1,212 @@
-#!/usr/bin/env node
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { pathToFileURL } from 'url';
-import {
-  controlPath,
-  getVaultBase,
-  listMarkdownFiles,
-  readControl,
-  readSessionRegistry,
-  wikilinkFromRel,
-} from './obsidian-common.mjs';
-import { getLocale } from './locale.mjs';
-
-const DEFAULT_PENDING_PATTERNS = [
-  /^- \[ \] Revisar resumo da sessão$/i,
-  /^- \[ \] Verificar se houve decisões a registrar$/i,
-  /^- \[ \] Verificar se houve bugs a registrar$/i,
-  /^- \[ \] Verificar se houve aprendizados a registrar$/i,
-];
-
-function parseArgs(argv) {
-  const args = {};
-  for (let i = 0; i < argv.length; i += 1) {
-    const item = argv[i];
-    if (!item.startsWith('--')) continue;
-    const key = item.slice(2);
-    const next = argv[i + 1];
-    if (!next || next.startsWith('--')) {
-      args[key] = true;
-    } else {
-      args[key] = next;
-      i += 1;
-    }
-  }
-  return args;
-}
-
-function findDuplicateTurnMarkers(content) {
-  const seen = new Set();
-  const duplicated = new Set();
-  const regex = /<!-- (?:wk-turn|codex-turn): ([^>]+) -->/g;
-  let match;
-  while ((match = regex.exec(content)) !== null) {
-    const turnId = match[1].trim();
-    if (seen.has(turnId)) duplicated.add(turnId);
-    seen.add(turnId);
-  }
-  return [...duplicated];
-}
-
-function hasHeadingAfterClosing(content) {
-  const closing = content.indexOf('\n## Encerramento');
-  if (closing === -1) return false;
-  return /\n#{2,3} /.test(content.slice(closing + '\n## Encerramento'.length));
-}
-
-function sectionBody(content, heading) {
-  const marker = `\n## ${heading}\n`;
-  const start = content.indexOf(marker);
-  if (start === -1) return '';
-  const bodyStart = start + marker.length;
-  const next = content.slice(bodyStart).search(/\n## /);
-  const bodyEnd = next === -1 ? content.length : bodyStart + next;
-  return content.slice(bodyStart, bodyEnd);
-}
-
-function hasDefaultPending(content) {
-  return sectionBody(content, 'Pendências')
-    .split('\n')
-    .some((line) => DEFAULT_PENDING_PATTERNS.some((pattern) => pattern.test(line.trim())));
-}
-
+#!/usr/bin/env node
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { pathToFileURL } from 'url';
+import {
+  controlPath,
+  getVaultBase,
+  listMarkdownFiles,
+  readControl,
+  readSessionRegistry,
+  wikilinkFromRel,
+} from './obsidian-common.mjs';
+import { getLocale } from './locale.mjs';
+
+const DEFAULT_PENDING_PATTERNS = [
+  /^- \[ \] Revisar resumo da sessão$/i,
+  /^- \[ \] Verificar se houve decisões a registrar$/i,
+  /^- \[ \] Verificar se houve bugs a registrar$/i,
+  /^- \[ \] Verificar se houve aprendizados a registrar$/i,
+];
+
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const item = argv[i];
+    if (!item.startsWith('--')) continue;
+    const key = item.slice(2);
+    const next = argv[i + 1];
+    if (!next || next.startsWith('--')) {
+      args[key] = true;
+    } else {
+      args[key] = next;
+      i += 1;
+    }
+  }
+  return args;
+}
+
+function findDuplicateTurnMarkers(content) {
+  const seen = new Set();
+  const duplicated = new Set();
+  const regex = /<!-- (?:wk-turn|codex-turn): ([^>]+) -->/g;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    const turnId = match[1].trim();
+    if (seen.has(turnId)) duplicated.add(turnId);
+    seen.add(turnId);
+  }
+  return [...duplicated];
+}
+
+function hasHeadingAfterClosing(content) {
+  const closing = content.indexOf('\n## Encerramento');
+  if (closing === -1) return false;
+  return /\n#{2,3} /.test(content.slice(closing + '\n## Encerramento'.length));
+}
+
+function sectionBody(content, heading) {
+  const marker = `\n## ${heading}\n`;
+  const start = content.indexOf(marker);
+  if (start === -1) return '';
+  const bodyStart = start + marker.length;
+  const next = content.slice(bodyStart).search(/\n## /);
+  const bodyEnd = next === -1 ? content.length : bodyStart + next;
+  return content.slice(bodyStart, bodyEnd);
+}
+
+function hasDefaultPending(content) {
+  return sectionBody(content, 'Pendências')
+    .split('\n')
+    .some((line) => DEFAULT_PENDING_PATTERNS.some((pattern) => pattern.test(line.trim())));
+}
+
 function usageSectionIsPlaced(content, { active = false } = {}) {
   const unified = content.indexOf('\n## Agentes, tokens e custos');
   const legacy = content.indexOf('\n## Uso de tokens e custos');
   const usage = unified !== -1 ? unified : legacy;
-  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 (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 || (!active && closing === -1)) return false;
   return usage < pending && (active || usage < closing) && (changed === -1 || usage > changed);
-}
-
-function linkedNotesFromSession(content) {
-  const notes = [];
-  const regex = /\[\[((?:04-Decisões|05-Bugs|06-Aprendizados)\/[^\]]+)\]\]/g;
-  let match;
-  while ((match = regex.exec(content)) !== null) {
-    if (!notes.includes(match[1])) notes.push(match[1]);
-  }
-  return notes;
-}
-
-function checkSession({ vaultBase, sessionRel, control, registry }) {
-  const failures = [];
-  const warnings = [];
-  const metrics = {};
-  const sessionPath = join(vaultBase, sessionRel);
-
-  if (!existsSync(sessionPath)) {
-    failures.push(`Sessão não encontrada: ${sessionRel}`);
-    return { failures, warnings, metrics };
-  }
-
+}
+
+function linkedNotesFromSession(content) {
+  const notes = [];
+  const regex = /\[\[((?:04-Decisões|05-Bugs|06-Aprendizados)\/[^\]]+)\]\]/g;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    if (!notes.includes(match[1])) notes.push(match[1]);
+  }
+  return notes;
+}
+
+function checkSession({ vaultBase, sessionRel, control, registry }) {
+  const failures = [];
+  const warnings = [];
+  const metrics = {};
+  const sessionPath = join(vaultBase, sessionRel);
+
+  if (!existsSync(sessionPath)) {
+    failures.push(`Sessão não encontrada: ${sessionRel}`);
+    return { failures, warnings, metrics };
+  }
+
   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;
-
+  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, { active: activeSession })) failures.push('A seção de agentes, tokens e custos está fora da posição esperada.');
   if (content.includes('\n## Agentes, tokens e custos') && (content.includes('\n## Uso de tokens e custos') || content.includes('\n## Subagents & Workflows'))) {
     failures.push('A sessão mistura observabilidade consolidada e seções legadas.');
   }
-  if (hasDefaultPending(content)) warnings.push('Pendências ainda contém placeholders padrão.');
-
-  const registryEntry = registry.sessions?.[control.session_id];
-  if (control.session_id && !registryEntry) {
-    failures.push(`SESSION_REGISTRY não possui session_id ativo: ${control.session_id}`);
-  } else if (registryEntry) {
-    if (registryEntry.session_file !== sessionRel) {
-      failures.push('SESSION_REGISTRY diverge do CURRENT_SESSION.md para a sessão ativa.');
-    }
-    if (!registryEntry.transcript_path) {
-      warnings.push('SESSION_REGISTRY não possui transcript_path para a sessão ativa.');
-    } else if (!existsSync(registryEntry.transcript_path)) {
-      warnings.push(`Transcript da sessão ativa não encontrado: ${registryEntry.transcript_path}`);
-    }
-  }
-
-  const sessionLink = wikilinkFromRel(sessionRel);
-  for (const noteRel of linkedNotesFromSession(content)) {
-    const notePath = join(vaultBase, noteRel.endsWith('.md') ? noteRel : `${noteRel}.md`);
-    if (!existsSync(notePath)) {
-      failures.push(`Nota derivada linkada não existe: ${noteRel}`);
-      continue;
-    }
-    const noteContent = readFileSync(notePath, 'utf-8');
-    if (!noteContent.includes(sessionLink) && !noteContent.includes(sessionRel)) {
-      failures.push(`Nota derivada sem backlink para a sessão: ${noteRel}`);
-    }
-  }
-
-  return { failures, warnings, metrics };
-}
-
-export function runVaultHealth({ vaultBase, session = '' }) {
-  const control = readControl(vaultBase);
-  const registry = readSessionRegistry(vaultBase);
-  const sessionRel = session || control.session_file || control.last_session_file || '';
-  const failures = [];
-  const warnings = [];
-
-  if (!existsSync(controlPath(vaultBase))) {
-    failures.push('CURRENT_SESSION.md não encontrado.');
-  }
-  if (!sessionRel) failures.push('Nenhuma sessão ativa ou última sessão encontrada no controle.');
-
-  const sessionResult = sessionRel
-    ? checkSession({ vaultBase, sessionRel, control, registry })
-    : { failures: [], warnings: [], metrics: {} };
-  failures.push(...sessionResult.failures);
-  warnings.push(...sessionResult.warnings);
-
-  const staleDone = Object.values(registry.sessions || {})
-    .filter((item) => item.status === 'active' && item.ended_at)
-    .length;
-  if (staleDone) warnings.push(`${staleDone} entradas active com ended_at no SESSION_REGISTRY.`);
-
-  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);
-  }, 0);
-
-  return {
-    ok: failures.length === 0,
-    session: sessionRel,
-    failures,
-    warnings,
-    metrics: {
-      ...sessionResult.metrics,
-      registrySessions: Object.keys(registry.sessions || {}).length,
-      derivedNotes: derivedCount,
-    },
-  };
-}
-
-function main() {
-  const args = parseArgs(process.argv.slice(2));
-  const vaultBase = getVaultBase({ obsidian_vault_path: args.vault });
-  const result = runVaultHealth({ vaultBase, session: args.session || '' });
-  console.log(JSON.stringify(result, null, 2));
-  if (!result.ok) process.exitCode = 1;
-}
-
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
-  try {
-    main();
-  } catch (error) {
-    process.stderr.write(`[wendkeep] Vault health falhou: ${error.message}\n`);
-    process.exitCode = 1;
-  }
-}
+  if (hasDefaultPending(content)) warnings.push('Pendências ainda contém placeholders padrão.');
+
+  const registryPair = Object.entries(registry.sessions || {}).find(([, entry]) => entry?.session_file === sessionRel);
+  const registryEntry = registryPair?.[1];
+  if (!registryEntry) {
+    failures.push(`SESSION_REGISTRY não possui a sessão: ${sessionRel}`);
+  } else {
+    if (!registryEntry.transcript_path) {
+      warnings.push('SESSION_REGISTRY não possui transcript_path para a sessão ativa.');
+    } else if (!existsSync(registryEntry.transcript_path)) {
+      warnings.push(`Transcript da sessão ativa não encontrado: ${registryEntry.transcript_path}`);
+    }
+  }
+
+  const sessionLink = wikilinkFromRel(sessionRel);
+  for (const noteRel of linkedNotesFromSession(content)) {
+    const notePath = join(vaultBase, noteRel.endsWith('.md') ? noteRel : `${noteRel}.md`);
+    if (!existsSync(notePath)) {
+      failures.push(`Nota derivada linkada não existe: ${noteRel}`);
+      continue;
+    }
+    const noteContent = readFileSync(notePath, 'utf-8');
+    if (!noteContent.includes(sessionLink) && !noteContent.includes(sessionRel)) {
+      failures.push(`Nota derivada sem backlink para a sessão: ${noteRel}`);
+    }
+  }
+
+  return { failures, warnings, metrics };
+}
+
+export function runVaultHealth({ vaultBase, session = '' }) {
+  const control = readControl(vaultBase);
+  const registry = readSessionRegistry(vaultBase);
+  const sessionRel = session || control.session_file || control.last_session_file || '';
+  const failures = [];
+  const warnings = [];
+
+  if (!existsSync(controlPath(vaultBase))) {
+    failures.push('CURRENT_SESSION.md não encontrado.');
+  }
+  if (!sessionRel) failures.push('Nenhuma sessão ativa ou última sessão encontrada no controle.');
+
+  const sessionResult = sessionRel
+    ? checkSession({ vaultBase, sessionRel, control, registry })
+    : { failures: [], warnings: [], metrics: {} };
+  failures.push(...sessionResult.failures);
+  warnings.push(...sessionResult.warnings);
+
+  const staleDone = Object.values(registry.sessions || {})
+    .filter((item) => item.status === 'active' && item.ended_at)
+    .length;
+  if (staleDone) warnings.push(`${staleDone} entradas active com ended_at no SESSION_REGISTRY.`);
+  const activeEntries = Object.values(registry.sessions || {}).filter((item) => item?.status === 'active');
+  for (const entry of activeEntries) {
+    if (!entry.session_file) failures.push('SESSION_REGISTRY possui sessão ativa sem session_file.');
+    if (!entry.transcript_path) warnings.push(`Sessão ativa sem transcript_path: ${entry.session_file || '(sem arquivo)'}`);
+  }
+
+  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);
+  }, 0);
+
+  return {
+    ok: failures.length === 0,
+    session: sessionRel,
+    failures,
+    warnings,
+    metrics: {
+      ...sessionResult.metrics,
+      registrySessions: Object.keys(registry.sessions || {}).length,
+      derivedNotes: derivedCount,
+    },
+  };
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const vaultBase = getVaultBase({ obsidian_vault_path: args.vault });
+  const result = runVaultHealth({ vaultBase, session: args.session || '' });
+  console.log(JSON.stringify(result, null, 2));
+  if (!result.ok) process.exitCode = 1;
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  try {
+    main();
+  } catch (error) {
+    process.stderr.write(`[wendkeep] Vault health falhou: ${error.message}\n`);
+    process.exitCode = 1;
+  }
+}

package/package.json

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

@@ -18,7 +18,7 @@ import {
 } from '../hooks/change-core.mjs';
 import { evaluateGate, requiredSensors } from '../hooks/sensors-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 { getNextAdrNumber, readControl, readSessionRegistry, upsertSessionRegistry } from '../hooks/obsidian-common.mjs';
 import { getLocale } from '../hooks/locale.mjs';
 
 function resolveVault(argv) {
@@ -51,7 +51,7 @@ function today() {
 export function runChange(argv) {
   const [sub, ...rest] = argv;
   const vaultBase = resolveVault(rest);
-  const VALUE_FLAGS = new Set(['--vault', '--change', '--project']);
+  const VALUE_FLAGS = new Set(['--vault', '--change', '--project', '--session']);
   const slugArg = () => rest.find((a, i) => !a.startsWith('-') && !VALUE_FLAGS.has(rest[i - 1]));
 
   if (sub === 'new') {
@@ -74,6 +74,18 @@ export function runChange(argv) {
     process.exit(0);
   }
 
+  if (sub === 'bind') {
+    const slug = slugArg();
+    const sessionId = opt(rest, '--session');
+    if (!slug || !sessionId) { process.stderr.write('wendkeep change bind: use <slug> --session <id>\n'); process.exit(2); }
+    const state = allChangesState(vaultBase);
+    if (!state.changes.some((item) => item.slug === slug)) { process.stderr.write(`wendkeep change bind: open change not found: ${slug}\n`); process.exit(2); }
+    if (!readSessionRegistry(vaultBase).sessions?.[sessionId]) { process.stderr.write(`wendkeep change bind: session not found: ${sessionId}\n`); process.exit(2); }
+    upsertSessionRegistry(vaultBase, sessionId, { change_slug: slug });
+    process.stdout.write(`session ${sessionId} -> 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;

package/src/rebuild-costs.mjs

@@ -9,19 +9,19 @@ export function rebuildSessionCosts(vaultBase, { apply = false, session = '', li
   const registry = readSessionRegistry(vaultBase);
   const report = { version: 1, generatedAt: new Date().toISOString(), mode: apply ? 'apply' : 'dry-run', scanned: 0, changed: 0, unchanged: 0, missing: [], errors: [], sessions: [] };
   const entries = Object.entries(registry.sessions || {}).map(([sessionId, value]) => ({ sessionId, ...value }))
-    .filter((e) => e.session_file && e.transcript_path)
+    .filter((e) => e.session_file)
     .filter((e) => !session || e.sessionId === session || e.session_file === session);
   for (const entry of entries) {
     if (limit && report.scanned >= limit) break;
     report.scanned += 1;
     const note = join(vaultBase, entry.session_file);
-    if (!existsSync(note) || !existsSync(entry.transcript_path)) {
-      report.missing.push({ sessionId: entry.sessionId, session: entry.session_file, note: existsSync(note), transcript: existsSync(entry.transcript_path) });
+    if (!entry.transcript_path || !existsSync(note) || !existsSync(entry.transcript_path)) {
+      report.missing.push({ sessionId: entry.sessionId, session: entry.session_file, note: existsSync(note), transcript: !!entry.transcript_path && existsSync(entry.transcript_path), transcriptPath: entry.transcript_path || '' });
       continue;
     }
     const before = readFileSync(note, 'utf8');
     try {
-      updateSessionObservability({ sessionPath: note, transcriptPath: entry.transcript_path });
+      updateSessionObservability({ sessionPath: note, transcriptPath: entry.transcript_path, caller: 'cost-rebuild', canonicalConversationId: entry.sessionId });
       const after = readFileSync(note, 'utf8');
       const changed = before !== after;
       if (changed) report.changed += 1; else report.unchanged += 1;
@@ -32,7 +32,7 @@ export function rebuildSessionCosts(vaultBase, { apply = false, session = '', li
       report.errors.push({ sessionId: entry.sessionId, session: entry.session_file, error: error.message });
     }
   }
-  report.ok = report.errors.length === 0;
+  report.ok = report.errors.length === 0 && report.missing.length === 0;
   if (apply) writeFileSync(join(vaultBase, '.brain', 'COST_REBUILD.json'), `${JSON.stringify(report, null, 2)}\n`, 'utf8');
   return report;
 }

package/src/session.mjs

@@ -0,0 +1,37 @@
+import { isAbsolute, resolve } from 'node:path';
+import { readControl, readSessionRegistry, writeControl } from '../hooks/obsidian-common.mjs';
+
+function vaultOf(argv) {
+  const i = argv.indexOf('--vault');
+  const raw = i >= 0 ? argv[i + 1] : argv.find((a) => a.startsWith('--vault='))?.slice(8) || process.env.OBSIDIAN_VAULT_PATH;
+  if (!raw) throw new Error('pass --vault <path> or set OBSIDIAN_VAULT_PATH');
+  return isAbsolute(raw) ? raw : resolve(process.cwd(), raw);
+}
+
+function positionals(argv) {
+  return argv.filter((arg, index) => !arg.startsWith('-') && argv[index - 1] !== '--vault');
+}
+
+export function runSession(argv) {
+  const vault = vaultOf(argv);
+  const [sub, id] = positionals(argv);
+  const registry = readSessionRegistry(vault);
+  const rows = Object.entries(registry.sessions || {}).sort((a, b) => String(b[1].last_seen || '').localeCompare(String(a[1].last_seen || '')));
+  if (sub === 'list') {
+    for (const [sessionId, item] of rows) process.stdout.write(`${sessionId}\t${item.status || 'unknown'}\t${item.provider || 'unknown'}\t${item.change_slug || '-'}\t${item.session_file || '-'}\n`);
+    return;
+  }
+  const entry = registry.sessions?.[id];
+  if (!entry) throw new Error(`session not found: ${id || '(missing id)'}`);
+  if (sub === 'show') {
+    process.stdout.write(`${JSON.stringify({ session_id: id, ...entry }, null, 2)}\n`);
+    return;
+  }
+  if (sub === 'use') {
+    const control = readControl(vault);
+    writeControl(vault, { ...control, status: entry.status || 'active', session_id: id, session_file: entry.session_file || '', started_at: entry.started_at || '' });
+    process.stdout.write(`session focus: ${id}\n`);
+    return;
+  }
+  throw new Error('use: wendkeep session list | show <id> | use <id>');
+}