wendkeep 0.76.1 → 0.76.2

package/CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to **wendkeep** are documented here. Format based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this project follows
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.76.2] — 2026-08-21
+
+### Fixed
+
+- **Projeção SHARED bounded na origem.** O projector agora admite eventos completos de forma
+  determinística e priorizada, nunca publica `SHARED_MEMORY.md` acima de 48 linhas/6144 bytes e
+  declara as contagens projetada/omitida sem perder a autoridade integral do ledger.
+- **Omissão bounded verificável.** O gate semântico rederiva a seleção esperada; apenas o recorte
+  exato é aceito como aviso operacional, enquanto IDs ou contagens divergentes continuam bloqueando.
+- **Recuperação antes de rescope.** Com memória estruturalmente bloqueada, o doctor orienta
+  `memory repair` e novo `memory status --gate` antes de voltar ao dry-run, sem recomendar
+  `memory rescope --apply` sobre uma projeção inválida.
+
 ## [0.76.1] — 2026-08-21
 
 ### Added

package/README.en.md

@@ -373,7 +373,7 @@ an installation failure.
 Hot memory now separates human authorship, operational state, and evidence:
 
 - **`CORE.md` is canonical.** It is the short, hand-curated nucleus for durable preferences, active patterns, and open issues; no projector may infer or overwrite it.
-- **`SHARED_MEMORY.md` is generated operational state.** The `Stop` hook turns the session handoff into sanitized events; the projector deterministically reduces the ledger and publishes a verifiable revision, cursor, and hash. Facts are `verified` only with local evidence; unsupported reports remain `reported`, and disagreements become candidates for human judgment.
+- **`SHARED_MEMORY.md` is bounded generated operational state.** The `Stop` hook turns the session handoff into sanitized events; the projector deterministically reduces the ledger and publishes a verifiable revision, cursor, and hash. Admission prioritizes critical operational state and never publishes beyond 48 lines/6 KiB; omitted events remain in the append-only authority and surface only as verifiable counts. Facts are `verified` only with local evidence; unsupported reports remain `reported`, and disagreements become candidates for human judgment.
 - **`MEMORY_EVENTS.jsonl` is the append-only authority.** `Stop` makes events durable in the outbox before acknowledging the attempt; the projector runs outside the registry lock and retries reuse the same IDs. Repeating an identical `event_id`/payload is a no-op; reusing the ID with different bytes is observable corruption.
 - **`MEMORY_CANDIDATES.jsonl` is the curation queue.** Conflicts and legacy content are never silently promoted. `promote` and `reject` record the decision as a new event; promotion preserves the selected event's JSON type, session, activation/epoch, and source turn.
 - **Registers are scoped.** `git.local-head`, handoffs, verdicts, and change status carry project, work-session, change, branch, or worktree scope. Two branches do not create a global conflict; only events in the same scope and causal lineage may advance automatically.
@@ -389,9 +389,9 @@ Codex uses `session_id`/`turn_id` plus transcript order, with no artificial caus
 
 ### Injection and budgets
 
-`CORE.md` is the only manual layer: it accepts up to 40 lines, warns from 35, keeps a 4 KiB ceiling, and caps each line at 320 characters. `SHARED_MEMORY.md` is generated exclusively by the projector and ledger; never edit it to repair state. `brain-inject` delivers the same revision/hash on `startup`, `/clear`, and `/compact` `SessionStart` events, always placing CORE and SHARED before change context. The full envelope is capped at 24 KiB; SHARED reserves up to 6 KiB. Under pressure, lessons are removed first, then non-current changes. CORE and SHARED are never prefix-sliced: a missing, invalid, or over-budget layer becomes a visible, repairable `<wk_memory_error>`.
+`CORE.md` is the only manual layer: it accepts up to 40 lines, warns from 35, keeps a 4 KiB ceiling, and caps each line at 320 characters. `SHARED_MEMORY.md` is generated exclusively by the projector and ledger; never edit it to repair state. `brain-inject` delivers the same revision/hash on `startup`, `/clear`, and `/compact` `SessionStart` events, always placing CORE and SHARED before change context. The full envelope is capped at 24 KiB; SHARED reserves up to 48 lines/6 KiB. Under pressure, lessons are removed first, then non-current changes. CORE is never sliced and SHARED admits deterministic whole events rather than prefix-slicing; a missing, invalid, or over-budget layer becomes a visible, repairable `<wk_memory_error>`.
 
-`memory status --gate` and `validate-memory --vault` also check semantic coverage: they report a code, counts, and active/projected/missing keys. An empty v2 bundle is neutral; a missing projectable event, placeholders as the only content, or an unresolved decision link becomes an explicit degraded/blocking diagnosis without printing memory values.
+`memory status --gate` and `validate-memory --vault` also check semantic coverage: they report a code, counts, and active/projected/missing keys. An empty v2 bundle is neutral; a bounded omission that exactly reproduces ledger selection is an operational warning. An arbitrarily missing event, false count, placeholders as the only content, or an unresolved decision link remains explicitly degraded/blocking without printing memory values.
 
 `DIGEST.md` is no longer the operational handoff: it remains the `/brain-recall` bridge and legacy-vault fallback. A vault without SHARED receives CORE+DIGEST with a deprecation warning; migrate during the compatibility window:
 

package/README.md

@@ -373,7 +373,7 @@ an installation failure.
 Hot memory now separates human authorship, operational state, and evidence:
 
 - **`CORE.md` is canonical.** It is the short, hand-curated nucleus for durable preferences, active patterns, and open issues; no projector may infer or overwrite it.
-- **`SHARED_MEMORY.md` is generated operational state.** The `Stop` hook turns the session handoff into sanitized events; the projector deterministically reduces the ledger and publishes a verifiable revision, cursor, and hash. Facts are `verified` only with local evidence; unsupported reports remain `reported`, and disagreements become candidates for human judgment.
+- **`SHARED_MEMORY.md` is bounded generated operational state.** The `Stop` hook turns the session handoff into sanitized events; the projector deterministically reduces the ledger and publishes a verifiable revision, cursor, and hash. Admission prioritizes critical operational state and never publishes beyond 48 lines/6 KiB; omitted events remain in the append-only authority and surface only as verifiable counts. Facts are `verified` only with local evidence; unsupported reports remain `reported`, and disagreements become candidates for human judgment.
 - **`MEMORY_EVENTS.jsonl` is the append-only authority.** `Stop` makes events durable in the outbox before acknowledging the attempt; the projector runs outside the registry lock and retries reuse the same IDs. Repeating an identical `event_id`/payload is a no-op; reusing the ID with different bytes is observable corruption.
 - **`MEMORY_CANDIDATES.jsonl` is the curation queue.** Conflicts and legacy content are never silently promoted. `promote` and `reject` record the decision as a new event; promotion preserves the selected event's JSON type, session, activation/epoch, and source turn.
 - **Registers are scoped.** `git.local-head`, handoffs, verdicts, and change status carry project, work-session, change, branch, or worktree scope. Two branches do not create a global conflict; only events in the same scope and causal lineage may advance automatically.
@@ -389,9 +389,9 @@ Codex uses `session_id`/`turn_id` plus transcript order, with no artificial caus
 
 ### Injection and budgets
 
-`CORE.md` is the only manual layer: it accepts up to 40 lines, warns from 35, keeps a 4 KiB ceiling, and caps each line at 320 characters. `SHARED_MEMORY.md` is generated exclusively by the projector and ledger; never edit it to repair state. `brain-inject` delivers the same revision/hash on `startup`, `/clear`, and `/compact` `SessionStart` events, always placing CORE and SHARED before change context. The full envelope is capped at 24 KiB; SHARED reserves up to 6 KiB. Under pressure, lessons are removed first, then non-current changes. CORE and SHARED are never prefix-sliced: a missing, invalid, or over-budget layer becomes a visible, repairable `<wk_memory_error>`.
+`CORE.md` is the only manual layer: it accepts up to 40 lines, warns from 35, keeps a 4 KiB ceiling, and caps each line at 320 characters. `SHARED_MEMORY.md` is generated exclusively by the projector and ledger; never edit it to repair state. `brain-inject` delivers the same revision/hash on `startup`, `/clear`, and `/compact` `SessionStart` events, always placing CORE and SHARED before change context. The full envelope is capped at 24 KiB; SHARED reserves up to 48 lines/6 KiB. Under pressure, lessons are removed first, then non-current changes. CORE is never sliced and SHARED admits deterministic whole events rather than prefix-slicing; a missing, invalid, or over-budget layer becomes a visible, repairable `<wk_memory_error>`.
 
-`memory status --gate` and `validate-memory --vault` also check semantic coverage: they report a code, counts, and active/projected/missing keys. An empty v2 bundle is neutral; a missing projectable event, placeholders as the only content, or an unresolved decision link becomes an explicit degraded/blocking diagnosis without printing memory values.
+`memory status --gate` and `validate-memory --vault` also check semantic coverage: they report a code, counts, and active/projected/missing keys. An empty v2 bundle is neutral; a bounded omission that exactly reproduces ledger selection is an operational warning. An arbitrarily missing event, false count, placeholders as the only content, or an unresolved decision link remains explicitly degraded/blocking without printing memory values.
 
 `DIGEST.md` is no longer the operational handoff: it remains the `/brain-recall` bridge and legacy-vault fallback. A vault without SHARED receives CORE+DIGEST with a deprecation warning; migrate during the compatibility window:
 

package/docs/en/commands/memory.md

@@ -98,12 +98,19 @@ npx wendkeep validate-memory --vault <v2-vault>
   and its successor. Replay is CORE-aware, checkpoints use the physical ledger cursor, and the
   command neither rewrites ledger/CORE/notes nor consumes the outbox. Retrying the same applied
   decision is idempotent.
+- The projector deterministically admits whole events, prioritizing critical operational state up
+  to 48 lines/6144 bytes. `projection_mode`, `projected_events`, and `omitted_events` make the
+  selection verifiable; revision, cursor, and `state_hash` still cover the complete ledger. The
+  gate accepts only omissions that re-derive exactly from the same policy.
 - `memory rescope` is a dry run by default and lists only planned IDs, keys, and scopes. With
   `--apply`, it appends explicit project, work-session, change, branch, or worktree events while
   preserving historic bytes as the ledger prefix. Legacy `handoff.latest` events inside candidates
   are also rescoped individually when they carry proven session identity, separating independent
   workflows without selecting a winner. Ambiguities that remain inside one scope stay under human
   curation; retry returns `unchanged`.
+  If doctor reports structurally blocked memory, run `memory repair` first, confirm a green
+  `memory status --gate`, and only then return to the dry run; never apply rescope over an invalid
+  projection.
 - Registers such as `git.local-head`, `handoff.latest`, `quality.latest-*`, and
   `change.<slug>.status` compete only inside the same scope. Automatic resolution still requires
   the same project and causal lineage; incompatible decisions, constraints, and blockers remain

package/docs/pt-BR/commands/memory.md

@@ -98,12 +98,19 @@ npx wendkeep validate-memory --vault <cofre-v2>
   do attempt exato, salva backup do registry e limita a mutação ao attempt ambíguo e à sucessora.
   O replay é CORE-aware, usa cursor físico do ledger no checkpoint e não reescreve ledger, CORE ou
   notas, nem consome a outbox. Repetir a mesma decisão aplicada é idempotente.
+- O projector admite eventos completos de forma determinística e prioriza estado operacional
+  crítico até o limite de 48 linhas/6144 bytes. `projection_mode`, `projected_events` e
+  `omitted_events` tornam o recorte verificável; revision, cursor e `state_hash` continuam cobrindo
+  o ledger integral. O gate aceita somente a omissão que rederiva exatamente da mesma política.
 - `memory rescope` é dry-run por padrão e lista somente IDs, chaves e escopos planejados. Com
   `--apply`, anexa eventos explícitos de projeto, work session, change, branch ou worktree e mantém
   os bytes históricos como prefixo do ledger. Eventos legados de `handoff.latest` que participam
   de candidates também são reescopados individualmente quando possuem identidade de sessão
   comprovável: isso separa workflows independentes sem selecionar vencedor. Ambiguidades que
   permanecem no mesmo escopo continuam sob curadoria; uma repetição retorna `unchanged`.
+  Se o doctor indicar memória estruturalmente bloqueada, execute primeiro `memory repair`, confirme
+  `memory status --gate` verde e só então volte ao dry-run; não aplique rescope sobre uma projeção
+  inválida.
 - Registradores como `git.local-head`, `handoff.latest`, `quality.latest-*` e
   `change.<slug>.status` só competem dentro do mesmo escopo. Resolução automática ainda exige o
   mesmo projeto e linhagem causal; decisões, constraints e blockers incompatíveis permanecem sob

package/hooks/vault-health.mjs

@@ -523,12 +523,21 @@ export function checkMemoryBundle(vaultBase, { registry } = {}) {
     const label = historicalHandoffs.length === 1
       ? '1 handoff histórico reparável'
       : `${historicalHandoffs.length} handoffs históricos reparáveis`;
-    warnings.push(
-      `${label}; sessões de origem estão encerradas e nenhuma versão precisa virar estado atual. `
-      + `Execute primeiro o dry-run: ${memoryRescopeCommand(vaultBase)}. `
-      + `Se a prévia estiver correta: ${memoryRescopeCommand(vaultBase, { apply: true })}. `
-      + `Dívida restante: ${memoryCurateAllCommand(vaultBase)}.`,
-    );
+    if (!bundle.ok) {
+      warnings.push(
+        `${label}; a memória está bloqueada e rescope não deve ampliar uma projeção inválida. `
+        + `Repare primeiro: ${memoryRepairCommand(vaultBase)}. `
+        + `Confirme a recuperação: ${memoryStatusCommand(vaultBase)}. `
+        + 'Somente depois de um gate verde reexecute o doctor para revisar o dry-run de rescope.',
+      );
+    } else {
+      warnings.push(
+        `${label}; sessões de origem estão encerradas e nenhuma versão precisa virar estado atual. `
+        + `Execute primeiro o dry-run: ${memoryRescopeCommand(vaultBase)}. `
+        + `Se a prévia estiver correta: ${memoryRescopeCommand(vaultBase, { apply: true })}. `
+        + `Dívida restante: ${memoryCurateAllCommand(vaultBase)}.`,
+      );
+    }
   }
   if (outbox.count) warnings.push(`${outbox.count} evento(s) pendente(s) na outbox; execute o projector quando seguro.`);
   if (ordinaryCandidates.length) warnings.push(`${ordinaryCandidates.length} candidate(s) aguardando curadoria humana.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.76.1",
+  "version": "0.76.2",
   "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/vault/src/memory-schema.mjs

@@ -14,6 +14,17 @@ export const SHARED_SECTIONS = Object.freeze([
   'Último Handoff',
 ]);
 
+const SHARED_ADMISSION_SECTIONS = Object.freeze([
+  'Bloqueios',
+  'Objetivo Atual',
+  'Restrições Ativas',
+  'Decisões em Vigor',
+  'Próximas Ações',
+  'Riscos Conhecidos',
+  'Último Handoff',
+  'Estado Entregue',
+]);
+
 const AUTHORITIES = new Set(['verified', 'reported', 'candidate']);
 const OPERATIONS = new Set(['assert', 'replace', 'add', 'remove']);
 const ISO_INSTANT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/;
@@ -197,29 +208,63 @@ function defaultInstant(events) {
   return instants.at(-1) || new Date(0).toISOString();
 }
 
-/** Render the generated operational projection. Inputs are sanitized a second time. */
-export function renderSharedMemory({
-  revision = 0,
-  eventCursor = 'none',
-  events = [],
+function authorityPriority(authority) {
+  if (authority === 'verified') return 0;
+  if (authority === 'reported') return 1;
+  return 2;
+}
+
+function compareProjectionEvents(left, right) {
+  return authorityPriority(left?.authority) - authorityPriority(right?.authority)
+    || String(right?.observed_at || '').localeCompare(String(left?.observed_at || ''))
+    || String(left?.projection_key || left?.memory_key || '').localeCompare(
+      String(right?.projection_key || right?.memory_key || ''),
+    )
+    || String(left?.event_id || '').localeCompare(String(right?.event_id || ''));
+}
+
+function admissionOrder(events) {
+  const grouped = new Map(SHARED_ADMISSION_SECTIONS.map((section) => [section, []]));
+  for (const event of events) grouped.get(sectionFor(event?.memory_key)).push(event);
+  for (const bucket of grouped.values()) bucket.sort(compareProjectionEvents);
+
+  const ordered = [];
+  for (let round = 0; ; round += 1) {
+    let admitted = false;
+    for (const section of SHARED_ADMISSION_SECTIONS) {
+      const event = grouped.get(section)[round];
+      if (!event) continue;
+      ordered.push(event);
+      admitted = true;
+    }
+    if (!admitted) return ordered;
+  }
+}
+
+function renderSharedMemoryContent({
+  revision,
+  eventCursor,
+  allEvents,
+  projectedEvents,
   stateHash,
-  updatedAt,
-  reviewAfter,
-} = {}) {
-  const safeEvents = Array.isArray(events) ? events : [];
-  const updated = updatedAt || defaultInstant(safeEvents);
-  const review = reviewAfter || new Date(Date.parse(updated) + (7 * 24 * 60 * 60 * 1000)).toISOString();
+  updated,
+  review,
+}) {
   const grouped = new Map(SHARED_SECTIONS.map((section) => [section, []]));
-  for (const event of safeEvents) grouped.get(sectionFor(event.memory_key)).push(eventLine(event));
+  for (const event of projectedEvents) grouped.get(sectionFor(event.memory_key)).push(eventLine(event));
+  const omittedEvents = allEvents.length - projectedEvents.length;
 
   const lines = [
     '---',
     'schema_version: 2',
     `revision: ${Number.isInteger(revision) ? revision : 0}`,
     `event_cursor: ${sanitizeMemoryText(eventCursor || 'none')}`,
-    `state_hash: ${sanitizeMemoryText(stateHash || hashProjection(safeEvents))}`,
+    `state_hash: ${sanitizeMemoryText(stateHash || hashProjection(allEvents))}`,
     `updated_at: ${sanitizeMemoryText(updated)}`,
     `review_after: ${sanitizeMemoryText(review)}`,
+    `projection_mode: ${omittedEvents ? 'bounded' : 'complete'}`,
+    `projected_events: ${projectedEvents.length}`,
+    `omitted_events: ${omittedEvents}`,
     '---',
     '',
     '# SHARED_MEMORY — projeção operacional gerada',
@@ -231,6 +276,45 @@ export function renderSharedMemory({
   return `${lines.join('\n').trimEnd()}\n`;
 }
 
+function actualLineCount(text) {
+  const lines = text.split('\n');
+  return text.endsWith('\n') ? lines.length - 1 : lines.length;
+}
+
+function sharedFits(content) {
+  return actualLineCount(content) <= SHARED_LIMITS.lines
+    && Buffer.byteLength(content, 'utf8') <= SHARED_LIMITS.bytes;
+}
+
+/** Render the generated operational projection. Inputs are sanitized a second time. */
+export function renderSharedMemory({
+  revision = 0,
+  eventCursor = 'none',
+  events = [],
+  stateHash,
+  updatedAt,
+  reviewAfter,
+} = {}) {
+  const safeEvents = Array.isArray(events) ? events : [];
+  const updated = updatedAt || defaultInstant(safeEvents);
+  const review = reviewAfter || new Date(Date.parse(updated) + (7 * 24 * 60 * 60 * 1000)).toISOString();
+  const render = (projectedEvents) => renderSharedMemoryContent({
+    revision,
+    eventCursor,
+    allEvents: safeEvents,
+    projectedEvents,
+    stateHash,
+    updated,
+    review,
+  });
+  const projectedEvents = [];
+  for (const event of admissionOrder(safeEvents)) {
+    const trial = [...projectedEvents, event];
+    if (sharedFits(render(trial))) projectedEvents.push(event);
+  }
+  return render(projectedEvents);
+}
+
 function parseScalar(value) {
   if (/^-?\d+$/.test(value)) return Number(value);
   return value;
@@ -278,11 +362,6 @@ export function parseSharedMemory(content) {
   return { ok: errors.length === 0, errors, metadata, sections };
 }
 
-function actualLineCount(text) {
-  const lines = text.split('\n');
-  return text.endsWith('\n') ? lines.length - 1 : lines.length;
-}
-
 export function validateSharedMemory(content, { eventIds } = {}) {
   const text = String(content ?? '').replace(/\r\n/g, '\n');
   const parsed = parseSharedMemory(text);
@@ -306,6 +385,31 @@ export function validateSharedMemory(content, { eventIds } = {}) {
   for (const key of ['event_cursor', 'state_hash', 'updated_at', 'review_after']) {
     if (typeof metadata[key] !== 'string' || !metadata[key]) errors.push(`${key} é obrigatório.`);
   }
+  const projectionFields = ['projection_mode', 'projected_events', 'omitted_events'];
+  const projectionFieldCount = projectionFields.filter((key) => metadata[key] !== undefined).length;
+  if (projectionFieldCount && projectionFieldCount !== projectionFields.length) {
+    errors.push('Metadados bounded incompletos: projection_mode, projected_events e omitted_events são inseparáveis.');
+  } else if (projectionFieldCount === projectionFields.length) {
+    const projectedEventLines = [...parsed.sections.values()].flat()
+      .filter((line) => /^\s*-\s+\[[^\]]+\]/.test(line)).length;
+    if (!['complete', 'bounded'].includes(metadata.projection_mode)) {
+      errors.push('projection_mode deve ser complete ou bounded.');
+    }
+    if (!Number.isInteger(metadata.projected_events) || metadata.projected_events < 0) {
+      errors.push('projected_events deve ser inteiro não negativo.');
+    } else if (metadata.projected_events !== projectedEventLines) {
+      errors.push(`projected_events declara ${metadata.projected_events}, mas SHARED contém ${projectedEventLines} evento(s).`);
+    }
+    if (!Number.isInteger(metadata.omitted_events) || metadata.omitted_events < 0) {
+      errors.push('omitted_events deve ser inteiro não negativo.');
+    }
+    if (metadata.projection_mode === 'complete' && metadata.omitted_events !== 0) {
+      errors.push('projection_mode complete exige omitted_events igual a 0.');
+    }
+    if (metadata.projection_mode === 'bounded' && !(metadata.omitted_events > 0)) {
+      errors.push('projection_mode bounded exige omitted_events maior que 0.');
+    }
+  }
   for (const key of ['updated_at', 'review_after']) {
     if (typeof metadata[key] === 'string'
         && (!ISO_INSTANT.test(metadata[key]) || Number.isNaN(Date.parse(metadata[key])))) {

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

@@ -10,6 +10,7 @@ import {
 } from 'node:fs';
 import { join } from 'node:path';
 import {
+  parseSharedMemory,
   renderSharedMemory,
   sanitizeMemoryText,
   validateMemoryEvent,
@@ -1007,6 +1008,7 @@ export function prepareMemoryProjection(vaultBase, allEvents) {
     stateHash: reduced.stateHash,
     updatedAt,
   });
+  const sharedMetadata = parseSharedMemory(shared).metadata;
   const candidates = reduced.candidates.map((item) => canonicalMemoryJson(item)).join('\n')
     + (reduced.candidates.length ? '\n' : '');
   return {
@@ -1018,6 +1020,8 @@ export function prepareMemoryProjection(vaultBase, allEvents) {
     stateHash: reduced.stateHash,
     checkpoint: reduced.checkpoint,
     candidates: reduced.candidates.length,
+    projectedEvents: sharedMetadata.projected_events ?? reduced.activeEvents.length,
+    omittedEvents: sharedMetadata.omitted_events ?? 0,
   };
 }
 

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

@@ -1,6 +1,8 @@
 import { readdirSync, readFileSync } from 'node:fs';
 import { basename, join, relative } from 'node:path';
-import { sanitizeMemoryText, validateMemoryEvent, validateSharedMemory } from './memory-schema.mjs';
+import {
+  parseSharedMemory, renderSharedMemory, sanitizeMemoryText, validateMemoryEvent, validateSharedMemory,
+} from './memory-schema.mjs';
 import { deriveMemoryProjection } from './memory-store.mjs';
 import { assertVaultPathSafe } from './vault-path-safety.mjs';
 import { validateCore } from './validate-core.mjs';
@@ -161,6 +163,10 @@ function sharedEventIds(content) {
   return ids;
 }
 
+function sameStringSet(left, right) {
+  return left.size === right.size && [...left].every((value) => right.has(value));
+}
+
 function walkDecisionFiles(root, vaultBase, output = []) {
   let entries;
   try { entries = readdirSync(root, { withFileTypes: true }); } catch { return output; }
@@ -255,13 +261,41 @@ function semanticMemoryHealth(vaultBase, { ledger, shared, candidates }) {
   const errors = [];
   const warnings = [];
   const codes = [];
+  const metadata = shared.metadata || {};
+  const boundedDeclared = metadata.projection_mode === 'bounded';
+  let boundedProjection = false;
+  if (boundedDeclared) {
+    const expectedContent = renderSharedMemory({
+      revision: metadata.revision,
+      eventCursor: metadata.event_cursor,
+      stateHash: metadata.state_hash,
+      updatedAt: metadata.updated_at,
+      reviewAfter: metadata.review_after,
+      events: replay.activeEvents,
+    });
+    const expectedIds = sharedEventIds(expectedContent);
+    const expectedMetadata = parseSharedMemory(expectedContent).metadata;
+    boundedProjection = sameStringSet(projectedIds, expectedIds)
+      && metadata.projected_events === expectedMetadata.projected_events
+      && metadata.omitted_events === expectedMetadata.omitted_events;
+    if (!boundedProjection) {
+      codes.push('MEMORY_SEMANTIC_COVERAGE_MISSING');
+      errors.push('[MEMORY_SEMANTIC_COVERAGE_MISSING] SHARED declara bounded, mas IDs ou contagens não reproduzem a seleção do ledger.');
+    }
+  }
 
   if (missingKeys.length && placeholderOnly) {
     codes.push('MEMORY_SEMANTIC_PLACEHOLDER_ONLY');
     errors.push(`[MEMORY_SEMANTIC_PLACEHOLDER_ONLY] SHARED contém somente placeholders para ${activeKeys.length} chave(s) ativa(s); candidates=${candidateCount}.`);
   } else if (missingKeys.length) {
-    codes.push('MEMORY_SEMANTIC_COVERAGE_MISSING');
-    errors.push(`[MEMORY_SEMANTIC_COVERAGE_MISSING] SHARED não cobre ${missingKeys.length} chave(s) ativa(s): ${missingKeys.join(', ')}.`);
+    if (boundedProjection) {
+      warnings.push(`[MEMORY_SEMANTIC_BOUNDED_PROJECTION] SHARED omite deterministicamente ${metadata.omitted_events} evento(s) do ledger dentro do budget.`);
+    } else if (!boundedDeclared) {
+      codes.push('MEMORY_SEMANTIC_COVERAGE_MISSING');
+      errors.push(`[MEMORY_SEMANTIC_COVERAGE_MISSING] SHARED não cobre ${missingKeys.length} chave(s) ativa(s): ${missingKeys.join(', ')}.`);
+    }
+  } else if (boundedProjection) {
+    warnings.push(`[MEMORY_SEMANTIC_BOUNDED_PROJECTION] SHARED omite deterministicamente ${metadata.omitted_events} evento(s) do ledger dentro do budget.`);
   }
   if (unresolvedLinks.length) {
     codes.push('MEMORY_SEMANTIC_DECISION_LINK_UNRESOLVED');
@@ -280,6 +314,9 @@ function semanticMemoryHealth(vaultBase, { ledger, shared, candidates }) {
   } else if (codes.length) {
     status = 'degraded';
     code = codes[0];
+  } else if (boundedProjection) {
+    status = 'bounded';
+    code = 'MEMORY_SEMANTIC_BOUNDED_PROJECTION';
   }
 
   return {