wendkeep 0.66.3 → 0.66.5

package/hooks/token-usage.mjs

@@ -510,16 +510,19 @@ function detectTranscriptFormat(lines) {
   return 'codex';
 }
 
-export function parseTokenUsageFromTranscript(transcriptPath) {
+export function parseTokenUsageFromContent(content, { transcriptPath = '' } = {}) {
   const result = emptyParseResult(transcriptPath);
-  if (!transcriptPath || !existsSync(transcriptPath)) return result;
-
-  const lines = readFileSync(transcriptPath, 'utf-8').split('\n').filter(Boolean);
+  const lines = String(content || '').split('\n').filter(Boolean);
   return detectTranscriptFormat(lines) === 'claude'
     ? parseClaudeLines(lines, result)
     : parseCodexLines(lines, result);
 }
 
+export function parseTokenUsageFromTranscript(transcriptPath) {
+  if (!transcriptPath || !existsSync(transcriptPath)) return emptyParseResult(transcriptPath);
+  return parseTokenUsageFromContent(readFileSync(transcriptPath, 'utf-8'), { transcriptPath });
+}
+
 function modelCost(usage, model) {
   const normalized = normalizeModelName(model);
   const price = PRICE_REFERENCE[normalized];
@@ -935,6 +938,80 @@ export function collectSessionUsage({ sessionContent, transcriptPath }) {
   };
 }
 
+function normalizedTranscriptKey(value) {
+  return String(value || '').replace(/\.jsonl?$/i, '').trim().toLowerCase();
+}
+
+// Rebuild the main bucket from every validated top-level rollout. Existing history is used
+// only to preserve stable timestamps; an entry that is neither a known root nor a proven
+// descendant makes the reconstruction fail closed instead of silently deleting a legitimate
+// reopening.
+export function collectSessionUsageForRoots({
+  sessionContent,
+  rootPaths = [],
+  descendantIds = [],
+} = {}) {
+  const fmMatch = String(sessionContent || '').match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) return null;
+
+  const roots = [...new Set(rootPaths.filter(Boolean))].sort((a, b) => String(a).localeCompare(String(b)));
+  const rootKeys = new Set(roots.map((path) => normalizedTranscriptKey(transcriptIdFromPath(path))));
+  const descendantKeys = new Set(descendantIds.map(normalizedTranscriptKey).filter(Boolean));
+  const existingEntries = parseUsageHistory(fmMatch[1]);
+  const unresolved = existingEntries.filter((entry) => {
+    const key = normalizedTranscriptKey(entry.transcript_id);
+    return key && !rootKeys.has(key) && !descendantKeys.has(key);
+  });
+  if (unresolved.length) {
+    return {
+      state: 'degraded',
+      diagnostics: [{ code: 'MAIN_TRANSCRIPT_UNRESOLVED', count: unresolved.length }],
+      entries: existingEntries,
+      content: sessionContent,
+    };
+  }
+
+  const entries = [];
+  const summaries = [];
+  for (const transcriptPath of roots) {
+    if (!existsSync(transcriptPath)) {
+      return {
+        state: 'degraded',
+        diagnostics: [{ code: 'MAIN_TRANSCRIPT_UNRESOLVED', count: 1 }],
+        entries: existingEntries,
+        content: sessionContent,
+      };
+    }
+    const summary = summarizeTokenUsage(parseTokenUsageFromTranscript(transcriptPath));
+    if (!summary.calls) {
+      return {
+        state: 'degraded',
+        diagnostics: [{ code: 'MAIN_TRANSCRIPT_UNRESOLVED', count: 1 }],
+        entries: existingEntries,
+        content: sessionContent,
+      };
+    }
+    const transcriptId = transcriptIdFromPath(transcriptPath);
+    const current = entryFromSummary(summary, transcriptId);
+    const previous = existingEntries.find((entry) => normalizedTranscriptKey(entry.transcript_id) === normalizedTranscriptKey(transcriptId));
+    if (previous && sameUsageData(previous, current)) current.atualizado_em = previous.atualizado_em;
+    entries.push(current);
+    summaries.push(summary);
+  }
+
+  const agg = aggregateEntries(entries);
+  const content = upsertSessionFrontmatter(sessionContent, agg, entries);
+  if (content === null) return null;
+  return {
+    state: 'complete',
+    diagnostics: [],
+    summaries,
+    aggregate: agg,
+    entries,
+    content,
+  };
+}
+
 export function updateSessionUsage({ vaultBase, sessionRel, sessionPath, transcriptPath, lockTimeoutMs }) {
   if (!sessionPath || !existsSync(sessionPath)) return null;
   let result = null;

package/hooks/vault-health.mjs

@@ -338,6 +338,12 @@ function checkMemoryAttempts(registry, {
       const missing = eventIds.filter((eventId) => !ledgerEventIds.has(eventId) && !outboxEventIds.has(eventId));
       if (missing.length) {
         failures.push(`Attempt v2 perdeu ${missing.length} evento(s): ausentes do ledger e da outbox. Inspecione com: ${MEMORY_STATUS_COMMAND}.`);
+      } else if (
+        state === 'enqueued'
+        && eventIds.every((eventId) => ledgerEventIds.has(eventId))
+        && eventIds.every((eventId) => !outboxEventIds.has(eventId))
+      ) {
+        warnings.push(`Attempt de memória v2 possui acknowledgement projetado pendente. Recupere com: wendkeep memory recover-attempt ${sessionId}.`);
       } else {
         warnings.push(`Attempt de memória v2 ${state} permanece recuperável: ${eventIds.length} evento(s) durável(is) no ledger e/ou outbox.`);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.66.3",
+  "version": "0.66.5",
   "description": "Vault-first persistent memory for AI coding agents, with an optional profile-aware governance runtime: OFF, FLOW, GUIDE, GOVERN, or ASSURE. Local-first and agent-agnostic (Claude Code, Codex, Cursor…).",
   "type": "module",
   "workspaces": [

package/packages/cli/src/index.mjs

@@ -100,6 +100,7 @@ Usage:
                            behind the closing block. Dry-run by default · --apply · --json.
   wendkeep lesson add "t" "l"   Record a project-local lesson (injected at SessionStart).
   wendkeep memory <sub>          Shared memory v2: status | migrate [--apply] | repair |
+                           recover-attempt <session> [--apply] |
                            reconcile <session> --by-session <session> --reason <text> [--apply] |
                            promote <candidate> [--event <event-id>] | reject <candidate>. --vault P.
                            Reconcile is dry-run by default; the original attempt remains audited.

package/packages/vault/src/memory-store.mjs

@@ -313,6 +313,8 @@ export function readMemoryLedger(vaultBase) {
     if (eventIds.has(parsed.event_id)) {
       if (eventPayloads.get(parsed.event_id) !== payload) {
         errors.push(ledgerError(lineNumber, `event_id collision: ${parsed.event_id}`, partial));
+      } else {
+        errors.push(ledgerError(lineNumber, `duplicate event_id: ${parsed.event_id}`, partial));
       }
       return;
     }
@@ -911,15 +913,18 @@ function projectLocked(vaultBase, { faultAt } = {}) {
   const projection = publishMemoryProjection(vaultBase, prepared);
   injectFault(faultAt, 'after-projection');
 
+  const consumedEventIds = [];
   for (const entry of outbox) {
     unlinkVaultFile(vaultBase, entry.path, {
       missingOk: false, label: 'evento consumido do outbox de memória',
     });
+    consumedEventIds.push(entry.event.event_id);
   }
   return {
     status: 'projected',
     appended: newEvents.length,
     consumed: outbox.length,
+    consumedEventIds,
     pending: 0,
     ...projection,
   };

package/src/cost.mjs

@@ -196,19 +196,53 @@ function opt(argv, name) {
   return eq ? eq.slice(name.length + 1) : undefined;
 }
 
+const REBUILD_LIMIT_FLAGS = [
+  ['--max-graph-nodes', 'maxGraphNodes'],
+  ['--max-fallback-days', 'maxFallbackDays'],
+  ['--max-fallback-candidates', 'maxFallbackCandidates'],
+];
+
+export function parseRebuildOptions(argv = []) {
+  const session = opt(argv, '--session') || '';
+  const overrides = {};
+  for (const [flag, key] of REBUILD_LIMIT_FLAGS) {
+    const present = argv.includes(flag) || argv.some((arg) => arg.startsWith(`${flag}=`));
+    if (!present) continue;
+    const value = Number(opt(argv, flag));
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      return { ok: false, exitCode: 2, code: 'INVALID_LIMIT_OVERRIDE' };
+    }
+    overrides[key] = value;
+  }
+  if (Object.keys(overrides).length > 0 && !session) {
+    return { ok: false, exitCode: 2, code: 'TARGET_REQUIRED_FOR_LIMIT_OVERRIDE' };
+  }
+  return {
+    ok: true,
+    options: {
+      apply: argv.includes('--apply'),
+      session,
+      limit: Number(opt(argv, '--limit')) || 0,
+      limits: { ...overrides },
+      overrides: { ...overrides },
+    },
+  };
+}
+
 export function runCost(argv) {
   const vaultRaw = opt(argv, '--vault') || process.env.OBSIDIAN_VAULT_PATH;
   if (!vaultRaw) { process.stderr.write('wendkeep cost: no vault (--vault or OBSIDIAN_VAULT_PATH).\n'); process.exit(2); }
   const vaultBase = isAbsolute(vaultRaw) ? vaultRaw : resolve(process.cwd(), vaultRaw);
   if (!existsSync(vaultBase)) { process.stderr.write(`wendkeep cost: vault not found: ${vaultBase}\n`); process.exit(2); }
   if (argv[0] === 'rebuild') {
-    const report = rebuildSessionCosts(vaultBase, {
-      apply: argv.includes('--apply'),
-      session: opt(argv, '--session') || '',
-      limit: Number(opt(argv, '--limit')) || 0,
-    });
+    const parsed = parseRebuildOptions(argv);
+    if (!parsed.ok) {
+      process.stderr.write(`wendkeep cost rebuild: ${parsed.code}\n`);
+      process.exit(parsed.exitCode);
+    }
+    const report = rebuildSessionCosts(vaultBase, parsed.options);
     if (argv.includes('--json')) process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
-    else process.stdout.write(`cost rebuild (${report.mode}): ${report.scanned} lidas · ${report.changed} alteradas · ${report.unchanged} iguais · ${report.missing.length} sem fonte · ${report.errors.length} erros\n${report.mode === 'apply' ? 'Relatório: .brain/COST_REBUILD.json\n' : 'Nenhum arquivo foi alterado; use --apply para gravar.\n'}`);
+    else process.stdout.write(`cost rebuild (${report.mode}): ${report.scanned} lidas · ${report.changed} alteradas · ${report.unchanged} iguais · ${report.degraded} degradadas · ${report.stale} stale · ${report.missing} sem fonte · ${report.errors} erros\n${report.mode === 'apply' ? 'Relatório: .brain/COST_REBUILD.json\n' : 'Nenhum arquivo foi alterado; use --apply para gravar.\n'}`);
     process.exit(report.ok ? 0 : 1);
   }
   const agg = collectVaultCost(vaultBase, { since: opt(argv, '--since') });

package/src/doctor.mjs

@@ -4,7 +4,7 @@ import { spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { checkHarness, checkVaultLinks, checkSessionActivity, checkStackedFrontmatter, renderStackedFrontmatterLines, checkUnpricedModels, renderUnpricedModelLines, checkStaleDerivedSections, renderStaleDerivedSectionLines } from '../hooks/harness-doctor.mjs';
+import { checkHarness, checkVaultLinks, checkSessionActivity, checkStackedFrontmatter, renderStackedFrontmatterLines, checkUnpricedModels, renderUnpricedModelLines, checkStaleDerivedSections, renderStaleDerivedSectionLines, checkSessionObservability, renderSessionObservabilityLines } from '../hooks/harness-doctor.mjs';
 import { checkSyncDefs } from './sync-defs.mjs';
 import { resolveProjectVault } from './project-vault.mjs';
 
@@ -79,6 +79,9 @@ export function runDoctor(argv) {
   // 3d. Seções derivadas do corpo que ficaram para trás do Encerramento (notas pré-0.53.0).
   process.stdout.write(`\n${renderStaleDerivedSectionLines(checkStaleDerivedSections(vaultBase)).join('\n')}\n`);
 
+  // 3e. Observabilidade materializada: schema vigente não basta sem frontier + manifest frescos.
+  process.stdout.write(`\n${renderSessionObservabilityLines(checkSessionObservability(vaultBase)).join('\n')}\n`);
+
   // 4. Sessão: não mente "inativa" quando há atividade recente (workflow/subagente em background).
   const act = checkSessionActivity(vaultBase);
   if (act.lastSession) {