wendkeep 0.85.0 → 0.86.0

package/src/doctor.mjs

@@ -4,6 +4,11 @@ import { resolve } from 'node:path';
 import { checkHarness, checkVaultLinks, checkSessionActivity, checkStackedFrontmatter, renderStackedFrontmatterLines, checkUnpricedModels, renderUnpricedModelLines, checkStaleDerivedSections, renderStaleDerivedSectionLines, checkSessionObservability, renderSessionObservabilityLines } from '../hooks/harness-doctor.mjs';
 import { diagnoseManagedWorktrees } from './worktree.mjs';
 import { runVaultHealth } from '../hooks/vault-health.mjs';
+import {
+  inspectEvidenceSearchHealth,
+  renderEvidenceSearchHealthLines,
+} from './evidence-search-health.mjs';
+import { augmentVaultHealthWithMemoryScale } from './memory-scale-health.mjs';
 import { checkSyncDefs } from './sync-defs.mjs';
 import { resolveProjectVault } from './project-vault.mjs';
 import { inspectObserverSqlOutbox } from './observer-sql-publish.mjs';
@@ -19,6 +24,12 @@ const healthStatusLabel = (status) => ({
   healthy: 'saudável', warning: 'atenção', degraded: 'degradada', blocked: 'bloqueada', legacy: 'legado',
 }[status] || status || 'desconhecido');
 
+const artifactStatusLabel = (status) => ({
+  ok: 'saudável', healthy: 'saudável', warning: 'atenção', degraded: 'degradado',
+  missing: 'ausente', empty: 'vazio', invalid: 'inválido', corrupt: 'corrompido',
+  blocked: 'bloqueado', unknown: 'desconhecido',
+}[status] || status || 'desconhecido');
+
 const metricValue = (value) => value === null || value === undefined || value === '' ? 'n/a' : value;
 
 export function renderVaultHealthLines(result) {
@@ -49,6 +60,19 @@ export function renderVaultHealthLines(result) {
   );
   const repairableHandoffs = Number(memory.repairableHandoffs || 0);
   lines.push(`  ledger: ${metricValue(memory.ledgerEvents)} evento(s) · outbox: ${metricValue(memory.pendingOutbox)} · candidates: ${metricValue(memory.candidates)} · conflitos: ${metricValue(memory.activeConflicts)}${repairableHandoffs ? ` · handoffs reparáveis: ${repairableHandoffs}` : ''}`);
+  if (memory.scaleSchemaVersion === 1) {
+    lines.push(
+      `  replay: snapshot ${artifactStatusLabel(memory.snapshotStatus)} · cobertos: ${metricValue(memory.snapshotEvents)} evento(s) · tail: ${metricValue(memory.snapshotTailEvents)} evento(s)/${metricValue(memory.snapshotTailBytes)} bytes · ledger no snapshot: ${metricValue(memory.snapshotLedgerBytes)} bytes`,
+    );
+    if (memory.snapshotReason) lines.push(`    ↳ snapshot: ${memory.snapshotReason}`);
+    lines.push(
+      `  segmentos: ${artifactStatusLabel(memory.segmentStatus)} · ${metricValue(memory.segmentCount)} segmento(s) · cobertos: ${metricValue(memory.segmentCoveredEvents)} evento(s)/${metricValue(memory.segmentCoveredBytes)} bytes · pendentes: ${metricValue(memory.segmentPendingEvents)}`,
+    );
+    lines.push(
+      `  rotação: geração ${artifactStatusLabel(memory.generationStatus)} #${metricValue(memory.generation)} · origem: ${metricValue(memory.generationSourceEvents)} · tail ativo: ${metricValue(memory.generationActiveTailEvents)} · journal: ${artifactStatusLabel(memory.rotationJournal)} · receipts: ${metricValue(memory.rotationReceipts)} (${artifactStatusLabel(memory.rotationReceiptCheckpoint)})`,
+    );
+    if (memory.scaleErrorCode) lines.push(`    ↳ escala: ${memory.scaleErrorCode}`);
+  }
   const semanticKeys = memory.semanticActiveKeys || [];
   const semanticProjected = memory.semanticProjectedKeys || [];
   const semanticMissing = memory.semanticMissingKeys || [];
@@ -105,7 +129,10 @@ export function runDoctor(argv) {
   // 1. Session/vault integrity. The standalone hook remains JSON; doctor renders it for humans.
   let health;
   try {
-    health = runVaultHealth({ vaultBase, session });
+    health = augmentVaultHealthWithMemoryScale(
+      runVaultHealth({ vaultBase, session }),
+      vaultBase,
+    );
   } catch (error) {
     health = {
       ok: false,
@@ -116,16 +143,24 @@ export function runDoctor(argv) {
       memoryStatus: 'blocked',
     };
   }
-  if (scope !== 'runtime') process.stdout.write(`${renderVaultHealthLines(health).join('\n')}\n`);
+  const recall = scope === 'runtime'
+    ? { status: 'skipped' }
+    : inspectEvidenceSearchHealth(vaultBase);
+  if (scope !== 'runtime') {
+    process.stdout.write(`${renderVaultHealthLines(health).join('\n')}\n`);
+    process.stdout.write(`${renderEvidenceSearchHealthLines(recall).join('\n')}\n`);
+  }
   const healthStatus = health.ok ? 0 : 1;
+  const recallStatus = recall.status === 'blocked' ? 1 : 0;
 
   if (scope === 'core') {
     const strictDebt = strict && (
       (health.warnings || []).length > 0
       || !['healthy'].includes(health.memoryStatus)
+      || !['healthy', 'missing'].includes(recall.status)
     );
-    process.stdout.write(`\n[core] ${healthStatus ? 'erro estrutural' : health.memoryStatus === 'degraded' ? 'saudável com memória degradada' : 'saudável'}\n`);
-    return healthStatus || strictDebt ? 1 : 0;
+    process.stdout.write(`\n[core] ${healthStatus || recallStatus ? 'erro estrutural' : health.memoryStatus === 'degraded' ? 'saudável com memória degradada' : 'saudável'}\n`);
+    return healthStatus || recallStatus || strictDebt ? 1 : 0;
   }
 
   // 2. Harness integrity (Wave B).
@@ -217,6 +252,7 @@ export function runDoctor(argv) {
   const strictDebt = strict && (
     (scope !== 'runtime' && (health.warnings || []).length)
     || (scope !== 'runtime' && health.memoryStatus !== 'healthy')
+    || (scope !== 'runtime' && !['healthy', 'missing'].includes(recall.status))
     || attention.length
     || repairable.length
     || warnings.length
@@ -233,5 +269,5 @@ export function runDoctor(argv) {
     || (staleDerived.notes || staleDerived.items || []).length
     || !observability.ok
   );
-  return (scope !== 'runtime' && healthStatus !== 0) || errors.length || strictDebt ? 1 : 0;
+  return (scope !== 'runtime' && (healthStatus !== 0 || recallStatus !== 0)) || errors.length || strictDebt ? 1 : 0;
 }

package/src/evidence-search-health.mjs

@@ -0,0 +1,221 @@
+import { statSync } from 'node:fs';
+import { join } from 'node:path';
+
+import {
+  EVIDENCE_INDEX_FILE,
+} from '../packages/vault/src/evidence-recall.mjs';
+import {
+  EVIDENCE_INDEX_STATE_FILE,
+  loadEvidenceIndexState,
+} from '../packages/vault/src/evidence-index-store.mjs';
+import {
+  EVIDENCE_SEARCH_STATE_FILE,
+  evidenceSearchSqliteAvailable,
+  loadEvidenceSearchState,
+} from '../packages/vault/src/evidence-search-index.mjs';
+import { assertVaultPathSafe } from '../packages/vault/src/vault-path-safety.mjs';
+
+export const EVIDENCE_SEARCH_HEALTH_SCHEMA_VERSION = 1;
+
+function brainDir(vaultBase) {
+  return join(vaultBase, '.brain');
+}
+
+function nsText(value, fallbackMs = 0) {
+  if (typeof value === 'bigint') return value.toString();
+  return BigInt(Math.max(0, Math.trunc(Number(fallbackMs || 0) * 1_000_000))).toString();
+}
+
+function fileInfo(vaultBase, path, label) {
+  let checked = assertVaultPathSafe(vaultBase, path, {
+    expectedType: 'file',
+    label,
+  });
+  if (!checked.exists) return { exists: false, bytes: 0, fingerprint: null };
+  checked = assertVaultPathSafe(vaultBase, checked.target, {
+    allowMissing: false,
+    expectedType: 'file',
+    label,
+  });
+  const stat = statSync(checked.target, { bigint: true });
+  return {
+    exists: true,
+    bytes: Number(stat.size),
+    fingerprint: {
+      size: stat.size.toString(),
+      mtime_ns: nsText(stat.mtimeNs, stat.mtimeMs),
+      ctime_ns: nsText(stat.ctimeNs, stat.ctimeMs),
+    },
+  };
+}
+
+function sameFingerprint(left, right) {
+  if (left === null || right === null) return left === right;
+  return Boolean(left && right)
+    && String(left.size) === String(right.size)
+    && String(left.mtime_ns) === String(right.mtime_ns)
+    && String(left.ctime_ns) === String(right.ctime_ns);
+}
+
+function safeCode(value, fallback = '') {
+  const text = String(value || fallback).trim();
+  return text
+    ? text.replace(/[^A-Za-z0-9._:-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 120)
+    : null;
+}
+
+function artifactInfo(vaultBase, artifact, kind) {
+  if (!artifact) {
+    return { status: 'not-built', bytes: 0, current: false };
+  }
+  const path = join(brainDir(vaultBase), ...String(artifact.path || '').split('/'));
+  const file = fileInfo(vaultBase, path, `artefato ${kind} da busca de evidências`);
+  if (!file.exists) return { status: 'missing', bytes: 0, current: false };
+  const current = sameFingerprint(artifact.fingerprint, file.fingerprint);
+  return {
+    status: current ? 'current' : 'stale',
+    bytes: file.bytes,
+    current,
+  };
+}
+
+export function emptyEvidenceSearchHealth() {
+  return {
+    schemaVersion: EVIDENCE_SEARCH_HEALTH_SCHEMA_VERSION,
+    status: 'unknown',
+    errorCode: null,
+    authorityStatus: 'unknown',
+    authorityBytes: 0,
+    incrementalStateStatus: 'unknown',
+    incrementalStateBytes: 0,
+    documentCount: 0,
+    searchStateStatus: 'unknown',
+    searchStateBytes: 0,
+    rowCount: 0,
+    sourceIndexCurrent: false,
+    sourceStateCurrent: false,
+    lexicalStatus: 'unknown',
+    lexicalBytes: 0,
+    sqliteStatus: 'unknown',
+    sqliteBytes: 0,
+    sqliteCapability: false,
+    backend: 'unavailable',
+  };
+}
+
+function deriveStatus(metrics) {
+  if (metrics.authorityStatus === 'missing') return 'missing';
+  if (metrics.incrementalStateStatus === 'invalid'
+      || metrics.searchStateStatus === 'invalid') return 'degraded';
+  if (metrics.searchStateStatus !== 'current') return 'warning';
+  if (metrics.lexicalStatus !== 'current') return 'degraded';
+  return 'healthy';
+}
+
+export function inspectEvidenceSearchHealth(vaultBase) {
+  const metrics = emptyEvidenceSearchHealth();
+  try {
+    const brain = brainDir(vaultBase);
+    const authority = fileInfo(
+      vaultBase,
+      join(brain, EVIDENCE_INDEX_FILE),
+      'autoridade EVIDENCE_INDEX.jsonl',
+    );
+    const incrementalFile = fileInfo(
+      vaultBase,
+      join(brain, EVIDENCE_INDEX_STATE_FILE),
+      'estado incremental EVIDENCE_INDEX_STATE.json',
+    );
+    const searchFile = fileInfo(
+      vaultBase,
+      join(brain, EVIDENCE_SEARCH_STATE_FILE),
+      'estado derivado EVIDENCE_SEARCH_STATE.json',
+    );
+
+    metrics.authorityStatus = authority.exists ? 'present' : 'missing';
+    metrics.authorityBytes = authority.bytes;
+    metrics.incrementalStateBytes = incrementalFile.bytes;
+    metrics.searchStateBytes = searchFile.bytes;
+    metrics.sqliteCapability = evidenceSearchSqliteAvailable();
+
+    const incremental = incrementalFile.exists ? loadEvidenceIndexState(vaultBase) : null;
+    metrics.incrementalStateStatus = incrementalFile.exists
+      ? (incremental ? 'ok' : 'invalid')
+      : 'missing';
+    metrics.documentCount = incremental
+      ? Object.keys(incremental.documents || {}).length
+      : 0;
+
+    const state = searchFile.exists ? loadEvidenceSearchState(vaultBase) : null;
+    if (!searchFile.exists) {
+      metrics.searchStateStatus = 'missing';
+      metrics.lexicalStatus = 'not-built';
+      metrics.sqliteStatus = 'not-built';
+      metrics.backend = authority.exists ? 'lexical-ephemeral' : 'unavailable';
+      metrics.status = deriveStatus(metrics);
+      return metrics;
+    }
+    if (!state) {
+      metrics.searchStateStatus = 'invalid';
+      metrics.lexicalStatus = 'unknown';
+      metrics.sqliteStatus = 'unknown';
+      metrics.backend = authority.exists ? 'lexical-ephemeral' : 'unavailable';
+      metrics.status = deriveStatus(metrics);
+      return metrics;
+    }
+
+    metrics.rowCount = Number(state.row_count || 0);
+    metrics.sourceIndexCurrent = sameFingerprint(state.source?.index, authority.fingerprint);
+    metrics.sourceStateCurrent = sameFingerprint(
+      state.source?.state ?? null,
+      incrementalFile.fingerprint,
+    );
+    const lexical = artifactInfo(vaultBase, state.lexical, 'lexical');
+    const sqlite = artifactInfo(vaultBase, state.sqlite, 'SQLite FTS');
+    metrics.lexicalStatus = lexical.status;
+    metrics.lexicalBytes = lexical.bytes;
+    metrics.sqliteStatus = sqlite.status;
+    metrics.sqliteBytes = sqlite.bytes;
+
+    const sourceCurrent = metrics.sourceIndexCurrent && metrics.sourceStateCurrent;
+    const artifactsCurrent = lexical.current && (!state.sqlite || sqlite.current);
+    metrics.searchStateStatus = sourceCurrent && artifactsCurrent ? 'current' : 'stale';
+    metrics.backend = metrics.searchStateStatus === 'current'
+      && sqlite.current
+      && metrics.sqliteCapability
+      ? 'sqlite-fts5'
+      : metrics.searchStateStatus === 'current' && lexical.current
+        ? 'lexical-sidecar'
+        : authority.exists
+          ? 'lexical-ephemeral'
+          : 'unavailable';
+    metrics.status = deriveStatus(metrics);
+    return metrics;
+  } catch (error) {
+    return {
+      ...metrics,
+      status: 'blocked',
+      errorCode: safeCode(error?.code, 'EVIDENCE_SEARCH_HEALTH_UNSAFE'),
+    };
+  }
+}
+
+const statusLabel = (status) => ({
+  healthy: 'saudável', warning: 'atenção', degraded: 'degradado', blocked: 'bloqueado',
+  missing: 'ausente', current: 'atual', stale: 'stale', present: 'presente', ok: 'saudável',
+  invalid: 'inválido', 'not-built': 'não construído', unknown: 'desconhecido',
+}[status] || status || 'desconhecido');
+
+export function renderEvidenceSearchHealthLines(metrics) {
+  const lines = [
+    `[recall] ${statusLabel(metrics.status)} — backend: ${metrics.backend} · SQLite/FTS5: ${metrics.sqliteCapability ? 'disponível' : 'indisponível'}`,
+    `  autoridade: ${statusLabel(metrics.authorityStatus)} · ${metrics.authorityBytes} bytes · documentos: ${metrics.documentCount} · chunks: ${metrics.rowCount}`,
+    `  incremental: ${statusLabel(metrics.incrementalStateStatus)} · ${metrics.incrementalStateBytes} bytes · busca: ${statusLabel(metrics.searchStateStatus)} · ${metrics.searchStateBytes} bytes`,
+    `  lexical: ${statusLabel(metrics.lexicalStatus)} · ${metrics.lexicalBytes} bytes · SQLite: ${statusLabel(metrics.sqliteStatus)} · ${metrics.sqliteBytes} bytes`,
+  ];
+  if (metrics.searchStateStatus === 'stale' || metrics.searchStateStatus === 'missing') {
+    lines.push('  ! o próximo recall pode reconstruir o índice derivado a partir da autoridade JSONL');
+  }
+  if (metrics.errorCode) lines.push(`  ✗ ${metrics.errorCode}`);
+  return lines;
+}

package/src/memory-scale-health.mjs

@@ -0,0 +1,210 @@
+import {
+  readMemoryLedgerGeneration,
+  readMemoryProjectionSnapshot,
+  readMemoryRotationJournal,
+  readMemoryRotationReceipts,
+  readMemorySegmentManifest,
+} from '../hooks/memory-store.mjs';
+import {
+  quoteCommandArgument,
+  WENDKEEP_COMMAND,
+} from '../hooks/obsidian-common.mjs';
+
+export const MEMORY_SCALE_HEALTH_SCHEMA_VERSION = 1;
+
+function safeReason(value, fallback = '') {
+  const text = String(value || fallback).trim();
+  return text
+    ? text.replace(/[^A-Za-z0-9._:-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 120)
+    : null;
+}
+
+function numberMetric(value) {
+  const number = Number(value || 0);
+  return Number.isSafeInteger(number) && number >= 0 ? number : 0;
+}
+
+export function emptyMemoryScaleMetrics() {
+  return {
+    scaleSchemaVersion: MEMORY_SCALE_HEALTH_SCHEMA_VERSION,
+    scaleStatus: 'unknown',
+    scaleErrorCode: null,
+    snapshotStatus: 'unknown',
+    snapshotReason: null,
+    snapshotEvents: 0,
+    snapshotLedgerBytes: 0,
+    snapshotTailEvents: 0,
+    snapshotTailBytes: 0,
+    segmentStatus: 'unknown',
+    segmentCount: 0,
+    segmentCoveredEvents: 0,
+    segmentCoveredBytes: 0,
+    segmentPendingEvents: 0,
+    generationStatus: 'unknown',
+    generation: 0,
+    generationSourceEvents: 0,
+    generationActiveTailEvents: 0,
+    generationRotatedAt: null,
+    rotationJournal: 'unknown',
+    rotationRecoveryRequired: false,
+    rotationReceiptsStatus: 'unknown',
+    rotationReceipts: 0,
+    rotationReceiptCheckpoint: 'unknown',
+  };
+}
+
+function inspectSnapshot(vaultBase, metrics) {
+  try {
+    const snapshot = readMemoryProjectionSnapshot(vaultBase);
+    const tailStatus = snapshot.status === 'ok' ? snapshot.tail?.status : null;
+    metrics.snapshotStatus = snapshot.status === 'ok' && tailStatus !== 'ok'
+      ? 'invalid'
+      : snapshot.status;
+    metrics.snapshotReason = safeReason(
+      snapshot.reason || snapshot.tail?.reason,
+      metrics.snapshotStatus === 'invalid' ? 'snapshot-tail-unavailable' : '',
+    );
+    if (snapshot.status === 'ok') {
+      metrics.snapshotEvents = numberMetric(snapshot.snapshot?.event_count);
+      metrics.snapshotLedgerBytes = numberMetric(snapshot.snapshot?.ledger_bytes);
+      metrics.snapshotTailEvents = Array.isArray(snapshot.tail?.events)
+        ? snapshot.tail.events.length
+        : 0;
+      metrics.snapshotTailBytes = numberMetric(snapshot.tail?.bytes);
+    }
+  } catch (error) {
+    if (error?.code === 'VAULT_PATH_UNSAFE') throw error;
+    metrics.snapshotStatus = 'invalid';
+    metrics.snapshotReason = safeReason(error?.code, 'snapshot-read-failed');
+  }
+}
+
+function inspectSegments(vaultBase, ledgerEvents, metrics) {
+  try {
+    const manifest = readMemorySegmentManifest(vaultBase);
+    metrics.segmentStatus = manifest.status;
+    if (manifest.status === 'ok') {
+      metrics.segmentCount = numberMetric(manifest.manifest?.segment_count);
+      metrics.segmentCoveredEvents = numberMetric(manifest.manifest?.covered_event_count);
+      metrics.segmentCoveredBytes = numberMetric(manifest.manifest?.covered_bytes);
+    }
+    metrics.segmentPendingEvents = Math.max(
+      0,
+      numberMetric(ledgerEvents) - metrics.segmentCoveredEvents,
+    );
+  } catch (error) {
+    if (error?.code === 'VAULT_PATH_UNSAFE') throw error;
+    metrics.segmentStatus = 'invalid';
+    metrics.scaleErrorCode ||= safeReason(error?.code, 'segment-manifest-read-failed');
+  }
+}
+
+function inspectRotation(vaultBase, ledgerEvents, metrics) {
+  try {
+    const generation = readMemoryLedgerGeneration(vaultBase);
+    metrics.generationStatus = generation.status;
+    if (generation.status === 'ok') {
+      metrics.generation = numberMetric(generation.state?.generation);
+      metrics.generationSourceEvents = numberMetric(generation.state?.source_event_count);
+      metrics.generationActiveTailEvents = Math.max(
+        0,
+        numberMetric(ledgerEvents) - metrics.generationSourceEvents,
+      );
+      metrics.generationRotatedAt = String(generation.state?.rotated_at || '') || null;
+    }
+  } catch (error) {
+    if (error?.code === 'VAULT_PATH_UNSAFE') throw error;
+    metrics.generationStatus = 'invalid';
+    metrics.scaleErrorCode ||= safeReason(error?.code, 'generation-read-failed');
+  }
+
+  try {
+    const journal = readMemoryRotationJournal(vaultBase);
+    metrics.rotationJournal = journal.status === 'ok'
+      ? String(journal.journal?.stage || 'invalid')
+      : journal.status;
+    metrics.rotationRecoveryRequired = journal.status !== 'missing';
+  } catch (error) {
+    if (error?.code === 'VAULT_PATH_UNSAFE') throw error;
+    metrics.rotationJournal = 'invalid';
+    metrics.rotationRecoveryRequired = true;
+    metrics.scaleErrorCode ||= safeReason(error?.code, 'rotation-journal-read-failed');
+  }
+
+  try {
+    const receipts = readMemoryRotationReceipts(vaultBase);
+    metrics.rotationReceiptsStatus = receipts.status;
+    metrics.rotationReceipts = Array.isArray(receipts.receipts)
+      ? receipts.receipts.length
+      : 0;
+    metrics.rotationReceiptCheckpoint = String(receipts.checkpointStatus || 'unknown');
+  } catch (error) {
+    if (error?.code === 'VAULT_PATH_UNSAFE') throw error;
+    metrics.rotationReceiptsStatus = 'invalid';
+    metrics.rotationReceiptCheckpoint = 'invalid';
+    metrics.scaleErrorCode ||= safeReason(error?.code, 'rotation-receipts-read-failed');
+  }
+}
+
+function deriveScaleStatus(metrics) {
+  const invalid = [
+    metrics.snapshotStatus,
+    metrics.segmentStatus,
+    metrics.generationStatus,
+    metrics.rotationJournal,
+    metrics.rotationReceiptsStatus,
+    metrics.rotationReceiptCheckpoint,
+  ].some((status) => ['invalid', 'corrupt', 'blocked'].includes(status));
+  if (invalid || metrics.scaleErrorCode) return 'degraded';
+  if (metrics.rotationRecoveryRequired) return 'warning';
+  return 'healthy';
+}
+
+export function inspectMemoryScaleHealth(vaultBase, { ledgerEvents = 0 } = {}) {
+  const metrics = emptyMemoryScaleMetrics();
+  inspectSnapshot(vaultBase, metrics);
+  inspectSegments(vaultBase, ledgerEvents, metrics);
+  inspectRotation(vaultBase, ledgerEvents, metrics);
+  metrics.scaleStatus = deriveScaleStatus(metrics);
+  return metrics;
+}
+
+function statusCommand(vaultBase) {
+  return `${WENDKEEP_COMMAND} memory status --gate --vault ${quoteCommandArgument(vaultBase)}`;
+}
+
+export function augmentVaultHealthWithMemoryScale(result, vaultBase) {
+  const memory = result?.metrics?.memory;
+  if (!memory || ['legacy', 'blocked'].includes(result.memoryStatus)) return result;
+
+  try {
+    const scale = inspectMemoryScaleHealth(vaultBase, {
+      ledgerEvents: memory.ledgerEvents,
+    });
+    return {
+      ...result,
+      metrics: {
+        ...result.metrics,
+        memory: { ...memory, ...scale },
+      },
+    };
+  } catch (error) {
+    const code = safeReason(error?.code, 'memory-scale-boundary-unsafe');
+    const failure = `Memória: Artefatos de escala da memória estão inseguros ou ilegíveis (${code}). Inspecione com: ${statusCommand(vaultBase)}.`;
+    return {
+      ...result,
+      ok: false,
+      memoryStatus: 'blocked',
+      failures: [...(result.failures || []), failure],
+      metrics: {
+        ...result.metrics,
+        memory: {
+          ...memory,
+          ...emptyMemoryScaleMetrics(),
+          scaleStatus: 'blocked',
+          scaleErrorCode: code,
+        },
+      },
+    };
+  }
+}

package/src/observer-snapshot.mjs

@@ -5,6 +5,8 @@ import { allChangesState } from '../hooks/change-core.mjs';
 import { readControl, readSessionRegistry } from '../hooks/obsidian-common.mjs';
 import { runVaultHealth } from '../hooks/vault-health.mjs';
 import { readProjectForValidation } from '../packages/vault/src/validate-memory.mjs';
+import { inspectEvidenceSearchHealth } from './evidence-search-health.mjs';
+import { augmentVaultHealthWithMemoryScale } from './memory-scale-health.mjs';
 import { inspectSyncOutbox, readLocalSyncState } from './sync-outbox.mjs';
 
 export const OBSERVER_SCHEMA_VERSION = 1;
@@ -27,6 +29,11 @@ function safeText(value, max = MAX_TEXT) {
     .slice(0, max);
 }
 
+function safeCount(value) {
+  const number = Number(value || 0);
+  return Number.isSafeInteger(number) && number >= 0 ? number : 0;
+}
+
 function isoNow(value) {
   const date = value instanceof Date ? value : new Date(value ?? Date.now());
   if (Number.isNaN(date.getTime())) throw fail('captured_at inválido.');
@@ -65,9 +72,86 @@ function activeSessionSummary(vaultBase, control, registry) {
   };
 }
 
+function recallSearchSummary(metrics) {
+  return {
+    schema_version: 1,
+    status: safeText(metrics?.status || 'unknown', 32),
+    ...(metrics?.errorCode ? { error_code: safeText(metrics.errorCode, 120) } : {}),
+    authority: {
+      status: safeText(metrics?.authorityStatus || 'unknown', 32),
+      bytes: safeCount(metrics?.authorityBytes),
+    },
+    incremental: {
+      status: safeText(metrics?.incrementalStateStatus || 'unknown', 32),
+      bytes: safeCount(metrics?.incrementalStateBytes),
+      documents: safeCount(metrics?.documentCount),
+    },
+    search: {
+      status: safeText(metrics?.searchStateStatus || 'unknown', 32),
+      bytes: safeCount(metrics?.searchStateBytes),
+      chunks: safeCount(metrics?.rowCount),
+      source_index_current: metrics?.sourceIndexCurrent === true,
+      source_state_current: metrics?.sourceStateCurrent === true,
+    },
+    lexical: {
+      status: safeText(metrics?.lexicalStatus || 'unknown', 32),
+      bytes: safeCount(metrics?.lexicalBytes),
+    },
+    sqlite: {
+      status: safeText(metrics?.sqliteStatus || 'unknown', 32),
+      bytes: safeCount(metrics?.sqliteBytes),
+      capability: metrics?.sqliteCapability === true,
+    },
+    backend: safeText(metrics?.backend || 'unavailable', 40),
+  };
+}
+
+function memoryScaleSummary(memory = {}) {
+  if (memory.scaleSchemaVersion !== 1) return null;
+  return {
+    schema_version: 1,
+    status: safeText(memory.scaleStatus || 'unknown', 32),
+    ...(memory.scaleErrorCode ? { error_code: safeText(memory.scaleErrorCode, 120) } : {}),
+    snapshot: {
+      status: safeText(memory.snapshotStatus || 'unknown', 32),
+      ...(memory.snapshotReason ? { reason: safeText(memory.snapshotReason, 120) } : {}),
+      event_count: safeCount(memory.snapshotEvents),
+      ledger_bytes: safeCount(memory.snapshotLedgerBytes),
+      tail_events: safeCount(memory.snapshotTailEvents),
+      tail_bytes: safeCount(memory.snapshotTailBytes),
+    },
+    segments: {
+      status: safeText(memory.segmentStatus || 'unknown', 32),
+      count: safeCount(memory.segmentCount),
+      covered_events: safeCount(memory.segmentCoveredEvents),
+      covered_bytes: safeCount(memory.segmentCoveredBytes),
+      pending_events: safeCount(memory.segmentPendingEvents),
+    },
+    generation: {
+      status: safeText(memory.generationStatus || 'unknown', 32),
+      number: safeCount(memory.generation),
+      source_events: safeCount(memory.generationSourceEvents),
+      active_tail_events: safeCount(memory.generationActiveTailEvents),
+      rotated_at: safeText(memory.generationRotatedAt || '', 40),
+    },
+    rotation: {
+      journal: safeText(memory.rotationJournal || 'unknown', 32),
+      recovery_required: memory.rotationRecoveryRequired === true,
+      receipts_status: safeText(memory.rotationReceiptsStatus || 'unknown', 32),
+      receipts: safeCount(memory.rotationReceipts),
+      receipt_checkpoint: safeText(memory.rotationReceiptCheckpoint || 'unknown', 32),
+    },
+  };
+}
+
 function healthSummary(vaultBase) {
   try {
-    const health = runVaultHealth({ vaultBase });
+    const health = augmentVaultHealthWithMemoryScale(
+      runVaultHealth({ vaultBase }),
+      vaultBase,
+    );
+    const recall = recallSearchSummary(inspectEvidenceSearchHealth(vaultBase));
+    const memoryScale = memoryScaleSummary(health.metrics?.memory);
     return {
       ok: health.ok === true,
       status: safeText(health.memoryStatus || (health.ok ? 'healthy' : 'degraded'), 40),
@@ -75,6 +159,8 @@ function healthSummary(vaultBase) {
       warning_count: Array.isArray(health.warnings) ? health.warnings.length : 0,
       registry_sessions: Number(health.metrics?.registrySessions || 0),
       derived_notes: Number(health.metrics?.derivedNotes || 0),
+      recall_search: recall,
+      ...(memoryScale ? { memory_scale: memoryScale } : {}),
     };
   } catch {
     return {