wendkeep 0.73.0 → 0.75.0

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

@@ -0,0 +1,119 @@
+import { createHash } from 'node:crypto';
+
+export const MEMORY_SCOPE_TYPES = Object.freeze([
+  'project',
+  'work_session',
+  'change',
+  'branch',
+  'worktree',
+]);
+
+const SCOPE_TYPES = new Set(MEMORY_SCOPE_TYPES);
+const REGISTER_PATTERNS = [
+  /^git\.local-head$/,
+  /^handoff\.latest$/,
+  /^quality\.latest-(?:sensors|verdict)$/,
+  /^change\.[A-Za-z0-9._-]+\.status$/,
+];
+
+function clean(value) {
+  return String(value ?? '').trim().replace(/[\r\n\t]+/g, ' ').slice(0, 240);
+}
+
+function digest(value) {
+  return createHash('sha256').update(clean(value)).digest('hex').slice(0, 16);
+}
+
+export function normalizeMemoryScope(scope, { projectId = '' } = {}) {
+  if (!scope || typeof scope !== 'object' || Array.isArray(scope)) return null;
+  const type = clean(scope.type);
+  const id = clean(scope.id);
+  if (!SCOPE_TYPES.has(type) || !id) return null;
+  if (type === 'project' && projectId && id !== projectId) return null;
+  return { type, id };
+}
+
+function changeSlug(memoryKey, context) {
+  const fromKey = String(memoryKey || '').match(/^change\.([A-Za-z0-9._-]+)\.status$/)?.[1];
+  return clean(fromKey || context.changeSlug || context.change_slug);
+}
+
+function workSession(context) {
+  return clean(
+    context.workSessionId || context.work_session_id
+    || context.canonicalSessionId || context.canonical_session_id
+    || context.sessionId || context.session_id,
+  );
+}
+
+/** Deterministic scope policy for operational keys. It never uses an absolute local path. */
+export function scopeForMemoryKey(memoryKey, context = {}) {
+  const key = clean(memoryKey);
+  const projectId = clean(context.projectId || context.project_id) || 'unknown-project';
+  if (key === 'handoff.latest') {
+    return { type: 'work_session', id: workSession(context) || `legacy:${projectId}` };
+  }
+  if (key === 'git.local-head') {
+    const branch = clean(context.branch || context.branchName || context.branch_name);
+    const worktree = clean(context.worktreeId || context.worktree_id);
+    const repository = clean(context.repositoryId || context.repository_id);
+    if (branch) {
+      return {
+        type: 'branch',
+        id: [repository && `repo:${repository}`, worktree && `worktree:${worktree}`, `branch:${branch}`]
+          .filter(Boolean).join('|'),
+      };
+    }
+    const lineage = workSession(context) || clean(context.activation_id) || clean(context.event_id);
+    return { type: 'branch', id: `legacy:${projectId}:${digest(lineage || key)}` };
+  }
+  if (/^quality\.latest-(?:sensors|verdict)$/.test(key)) {
+    const slug = changeSlug(key, context) || `legacy:${digest(workSession(context) || key)}`;
+    const proof = clean(context.tasksHash || context.tasks_hash || context.specHash || context.spec_hash);
+    return { type: 'change', id: proof ? `${slug}|proof:${proof}` : slug };
+  }
+  if (/^change\.[A-Za-z0-9._-]+\.status$/.test(key)) {
+    return { type: 'change', id: changeSlug(key, context) };
+  }
+  if (/^(?:decision|adr)\b/.test(key)) {
+    const slug = changeSlug(key, context);
+    return slug ? { type: 'change', id: slug } : { type: 'project', id: projectId };
+  }
+  if (/^(?:constraint|restriction)\b/.test(key)) {
+    const session = workSession(context);
+    return session ? { type: 'work_session', id: session } : { type: 'project', id: projectId };
+  }
+  return { type: 'project', id: projectId };
+}
+
+export function effectiveMemoryScope(event = {}) {
+  // Ledger rows written before scoped registers existed remain project-scoped until an
+  // explicit append-only rescope migration supersedes them. This preserves historic replay.
+  return normalizeMemoryScope(event.scope, { projectId: event.project_id })
+    || { type: 'project', id: clean(event.project_id) || 'unknown-project' };
+}
+
+export function memoryScopeKey(scope) {
+  const normalized = normalizeMemoryScope(scope);
+  return normalized ? `${normalized.type}:${normalized.id}` : 'project:unknown-project';
+}
+
+export function sameMemoryScope(left, right) {
+  return memoryScopeKey(effectiveMemoryScope(left)) === memoryScopeKey(effectiveMemoryScope(right));
+}
+
+/** Project-scoped keys retain their historic public name; narrower registers are qualified. */
+export function memoryRecordKey(event) {
+  const scope = effectiveMemoryScope(event);
+  return scope.type === 'project'
+    ? String(event.memory_key)
+    : `${event.memory_key}@${memoryScopeKey(scope)}`;
+}
+
+export function isRegisterMemoryKey(memoryKey) {
+  return REGISTER_PATTERNS.some((pattern) => pattern.test(String(memoryKey || '')));
+}
+
+export function isHumanCuratedMemoryKey(memoryKey) {
+  return /^(?:decision|adr|constraint|restriction|block|blocker)\b/.test(String(memoryKey || ''));
+}

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

@@ -14,6 +14,12 @@ import {
   sanitizeMemoryText,
   validateMemoryEvent,
 } from './memory-schema.mjs';
+import {
+  effectiveMemoryScope,
+  isRegisterMemoryKey,
+  memoryRecordKey,
+  sameMemoryScope,
+} from './memory-scope.mjs';
 import {
   assertVaultPathSafe, assertVaultPathsSafe, mkdirVaultPath, unlinkVaultFile,
   VAULT_LOCK_BUSY, withVaultPathLock, writeVaultFileAtomic,
@@ -376,6 +382,7 @@ function sameCompleteCausalLineage(left, right) {
 }
 
 function comparable(left, right) {
+  if (left?.project_id !== right?.project_id || !sameMemoryScope(left, right)) return false;
   if (sameCausalActivation(left, right)) return true;
   const leftSupersedes = left.supersedes_event_id || left.supersedes;
   const rightSupersedes = right.supersedes_event_id || right.supersedes;
@@ -387,7 +394,7 @@ function comparable(left, right) {
 function conflictGroupKey(event) {
   if (event.operation !== 'replace') return null;
   if (!Number.isInteger(event.base_revision) || typeof event.base_value_hash !== 'string') return null;
-  return `${event.memory_key}\u0000${event.base_revision}\u0000${event.base_value_hash}`;
+  return `${memoryRecordKey(event)}\u0000${event.base_revision}\u0000${event.base_value_hash}`;
 }
 
 function candidateId(reason, memoryKey, eventIds) {
@@ -421,6 +428,7 @@ function blockedByCoreCandidate(event, coreValue) {
     reason: 'blocked_by_core',
     status: 'blocked_by_core',
     memory_key: event.memory_key,
+    ...(event.scope ? { scope: effectiveMemoryScope(event), record_key: memoryRecordKey(event) } : {}),
     event_ids: [event.event_id],
     proposed_value: event.value,
     core_value: coreValue,
@@ -442,6 +450,10 @@ function conflictCandidate(memoryKey, events, currentEvent = null) {
     candidate_id: candidateId('conflict', memoryKey, eventIds),
     reason: 'conflict',
     memory_key: memoryKey,
+    ...((ordered[0] || currentEvent)?.scope ? {
+      scope: effectiveMemoryScope(ordered[0] || currentEvent || {}),
+      record_key: memoryRecordKey(ordered[0] || currentEvent || { memory_key: memoryKey }),
+    } : {}),
     event_ids: eventIds,
     values: eventIds.map((id) => byId.get(id).value),
     base_revision: ordered[0]?.base_revision ?? currentEvent?.revision ?? 0,
@@ -459,6 +471,7 @@ function conflictReviewEvent(candidate, candidateCount = 1) {
     event_id: `mem-review-${candidate.candidate_id}`,
     project_id: source.project_id || '',
     memory_key: candidate.memory_key,
+    scope: candidate.scope,
     operation: 'assert',
     value: `[revisão pendente: ${memoryKey}; candidates: ${candidateCount}; events: ${eventCount}]`,
     authority: 'candidate',
@@ -508,7 +521,9 @@ function isCausallyOlder(event, current) {
   if (sameCausalActivation(event, current)) {
     return Number(event.turn_sequence) < Number(current.turn_sequence);
   }
-  if (Number.isInteger(event.activation_epoch) && Number.isInteger(current.activation_epoch)
+  if (event.canonical_session_id && event.canonical_session_id === current.canonical_session_id
+      && sameMemoryScope(event, current)
+      && Number.isInteger(event.activation_epoch) && Number.isInteger(current.activation_epoch)
       && event.activation_epoch !== current.activation_epoch) {
     return event.activation_epoch < current.activation_epoch;
   }
@@ -518,6 +533,30 @@ function isCausallyOlder(event, current) {
     && eventEffective < currentEffective;
 }
 
+const AUTHORITY_RANK = Object.freeze({ candidate: 0, reported: 1, verified: 2 });
+
+function sameRegisterLineage(left, right) {
+  return Boolean(left?.canonical_session_id)
+    && left.canonical_session_id === right?.canonical_session_id
+    && left.project_id === right?.project_id
+    && sameMemoryScope(left, right);
+}
+
+/** Positive means `incoming` is a safe successor; null means human comparison is required. */
+function registerPrecedence(incoming, current) {
+  if (!incoming?.scope || !current?.scope
+      || !isRegisterMemoryKey(incoming?.memory_key) || !sameRegisterLineage(incoming, current)) return null;
+  const epoch = Number(incoming.activation_epoch ?? -1) - Number(current.activation_epoch ?? -1);
+  if (epoch) return epoch;
+  const turn = Number(incoming.turn_sequence ?? -1) - Number(current.turn_sequence ?? -1);
+  if (turn) return turn;
+  const authority = (AUTHORITY_RANK[incoming.authority] ?? -1) - (AUTHORITY_RANK[current.authority] ?? -1);
+  if (authority) return authority;
+  const observed = String(incoming.observed_at || '').localeCompare(String(current.observed_at || ''));
+  if (observed) return observed;
+  return String(incoming.event_id || '').localeCompare(String(current.event_id || ''));
+}
+
 /**
  * Pure deterministic reducer. It pre-detects incomparable scalar siblings so replay order
  * never turns one concurrent writer into an accidental winner.
@@ -537,7 +576,21 @@ export function reduceMemoryEvents(inputEvents = [], {
     }
     if (!existing) unique.set(event.event_id, event);
   }
-  const events = [...unique.values()].sort(eventOrder);
+  const rescopeTargets = new Set(
+    [...unique.values()].flatMap((item) => [
+      item.rescopes_event_id,
+      ...(Array.isArray(item.rescopes_event_ids) ? item.rescopes_event_ids : []),
+    ]).filter(Boolean),
+  );
+  const projectIds = new Set([...unique.values()].map((item) => item.project_id).filter(Boolean));
+  if (projectIds.size > 1) {
+    const error = new TypeError('Memory reducer cannot compare events from different projects.');
+    error.code = 'MEMORY_PROJECT_MIXED';
+    throw error;
+  }
+  const events = [...unique.values()]
+    .filter((item) => !rescopeTargets.has(item.event_id))
+    .sort(eventOrder);
   const candidateDecisions = new Map();
   for (const item of events) {
     const decision = item.candidate_decision;
@@ -604,7 +657,8 @@ export function reduceMemoryEvents(inputEvents = [], {
       continue;
     }
 
-    const current = records.get(item.memory_key);
+    const recordKey = memoryRecordKey(item);
+    const current = records.get(recordKey);
     const currentSource = current?.source;
     if (isCausallyOlder(item, currentSource)) {
       superseded.push({ event_id: item.event_id, by_event_id: currentSource.event_id });
@@ -613,10 +667,12 @@ export function reduceMemoryEvents(inputEvents = [], {
 
     if (item.operation === 'assert') {
       if (current && hashMemoryValue(current.value) !== hashMemoryValue(item.value)) {
-        if (sameCausalActivation(item, currentSource)
-            && Number(item.turn_sequence) > Number(currentSource.turn_sequence)) {
-          records.set(item.memory_key, { value: item.value, revision: current.revision + 1, source: item });
-          tombstones.delete(item.memory_key);
+        const precedence = registerPrecedence(item, currentSource);
+        if ((sameCausalActivation(item, currentSource)
+              && Number(item.turn_sequence) > Number(currentSource.turn_sequence))
+            || precedence > 0) {
+          records.set(recordKey, { value: item.value, revision: current.revision + 1, source: item });
+          tombstones.delete(recordKey);
           superseded.push({ event_id: currentSource.event_id, by_event_id: item.event_id });
           revision += 1;
           appliedEventIds.push(item.event_id);
@@ -628,8 +684,8 @@ export function reduceMemoryEvents(inputEvents = [], {
         continue;
       }
       if (!current) {
-        records.set(item.memory_key, { value: item.value, revision: 1, source: item });
-        tombstones.delete(item.memory_key);
+        records.set(recordKey, { value: item.value, revision: 1, source: item });
+        tombstones.delete(recordKey);
         revision += 1;
       }
       appliedEventIds.push(item.event_id);
@@ -642,8 +698,8 @@ export function reduceMemoryEvents(inputEvents = [], {
       const byHash = new Map(oldValues.map((value) => [hashMemoryValue(value), value]));
       additions.forEach((value) => byHash.set(hashMemoryValue(value), value));
       const value = [...byHash.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([, entry]) => entry);
-      records.set(item.memory_key, { value, revision: (current?.revision || 0) + 1, source: item });
-      tombstones.delete(item.memory_key);
+      records.set(recordKey, { value, revision: (current?.revision || 0) + 1, source: item });
+      tombstones.delete(recordKey);
       revision += 1;
       appliedEventIds.push(item.event_id);
       continue;
@@ -664,13 +720,13 @@ export function reduceMemoryEvents(inputEvents = [], {
       if (item.value !== null && item.value !== undefined && Array.isArray(current.value)) {
         const removalHash = hashMemoryValue(item.value);
         const value = current.value.filter((entry) => hashMemoryValue(entry) !== removalHash);
-        records.set(item.memory_key, { value, revision: current.revision + 1, source: item });
-        tombstones.set(`${item.memory_key}:${removalHash}`, {
+        records.set(recordKey, { value, revision: current.revision + 1, source: item });
+        tombstones.set(`${recordKey}:${removalHash}`, {
           event_id: item.event_id, removed_event_id: current.source.event_id, value_hash: removalHash,
         });
       } else {
-        records.delete(item.memory_key);
-        tombstones.set(item.memory_key, {
+        records.delete(recordKey);
+        tombstones.set(recordKey, {
           event_id: item.event_id,
           removed_event_id: current.source.event_id,
           value_hash: hashMemoryValue(current.value),
@@ -691,8 +747,8 @@ export function reduceMemoryEvents(inputEvents = [], {
       candidates.push(conflictCandidate(item.memory_key, current ? [currentEventFromRecord(current), item] : [item]));
       continue;
     }
-    records.set(item.memory_key, { value: item.value, revision: current.revision + 1, source: item });
-    tombstones.delete(item.memory_key);
+    records.set(recordKey, { value: item.value, revision: current.revision + 1, source: item });
+    tombstones.delete(recordKey);
     const explicitlySupersededIds = new Set(
       Array.isArray(item.supersedes)
         ? item.supersedes
@@ -732,16 +788,16 @@ export function reduceMemoryEvents(inputEvents = [], {
       advanced = false;
       for (const pending of deferredAsserts) {
         if (resolvedCandidateIds.has(pending.candidate.candidate_id)) continue;
-        const current = records.get(pending.event.memory_key);
+        const current = records.get(memoryRecordKey(pending.event));
         const currentSource = current?.source;
         if (!sameCompleteCausalLineage(pending.event, currentSource)) continue;
         if (pending.event.turn_sequence > currentSource.turn_sequence) {
-          records.set(pending.event.memory_key, {
+          records.set(memoryRecordKey(pending.event), {
             value: pending.event.value,
             revision: current.revision + 1,
             source: pending.event,
           });
-          tombstones.delete(pending.event.memory_key);
+          tombstones.delete(memoryRecordKey(pending.event));
           superseded.push({ event_id: currentSource.event_id, by_event_id: pending.event.event_id });
           revision += 1;
           appliedEventIds.push(pending.event.event_id);
@@ -762,7 +818,7 @@ export function reduceMemoryEvents(inputEvents = [], {
     .map((candidate) => {
       const pending = pendingByCandidateId.get(candidate.candidate_id);
       if (!pending) return candidate;
-      const finalSource = currentEventFromRecord(records.get(candidate.memory_key));
+      const finalSource = currentEventFromRecord(records.get(candidate.record_key || candidate.memory_key));
       const previousSource = candidate.events?.find(
         (event) => event.event_id !== pending.event.event_id,
       );
@@ -791,10 +847,16 @@ export function reduceMemoryEvents(inputEvents = [], {
   superseded.sort((left, right) => left.event_id.localeCompare(right.event_id));
   const eventCursor = events.at(-1)?.event_id || 'none';
   const stateHash = hashMemoryValue({ state, tombstones: tombstoneObject });
+  const ambiguousRecordKeys = new Set(
+    unresolvedCandidates.map((candidate) => candidate.record_key || candidate.memory_key),
+  );
   const activeEvents = [
-    ...Object.entries(recordObject).map(([memoryKey, record]) => ({
+    ...Object.entries(recordObject)
+      .filter(([recordKey]) => !ambiguousRecordKeys.has(recordKey))
+      .map(([recordKey, record]) => ({
       ...record.source,
-      memory_key: memoryKey,
+      memory_key: record.source.memory_key,
+      projection_key: recordKey,
       operation: 'assert',
       value: record.value,
     })),

package/schema/observer/004-evidence-recall.sql

@@ -0,0 +1,25 @@
+CREATE TABLE IF NOT EXISTS document_chunks (
+  chunk_id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(project_id) ON DELETE CASCADE,
+  logical_path TEXT NOT NULL,
+  title TEXT NOT NULL DEFAULT '',
+  heading TEXT NOT NULL DEFAULT '',
+  entity_type TEXT NOT NULL DEFAULT 'document',
+  change_slug TEXT NOT NULL DEFAULT '',
+  session_id TEXT NOT NULL DEFAULT '',
+  work_session_id TEXT NOT NULL DEFAULT '',
+  authority TEXT NOT NULL DEFAULT 'candidate',
+  observed_at TEXT NOT NULL,
+  validity TEXT NOT NULL DEFAULT 'active',
+  content_hash TEXT NOT NULL,
+  ordinal INTEGER NOT NULL DEFAULT 0,
+  content TEXT NOT NULL,
+  FOREIGN KEY(project_id, logical_path) REFERENCES documents(project_id, logical_path) ON DELETE CASCADE,
+  UNIQUE(project_id, logical_path, ordinal)
+);
+
+CREATE INDEX IF NOT EXISTS idx_document_chunks_project_path
+  ON document_chunks(project_id, logical_path, ordinal);
+
+CREATE INDEX IF NOT EXISTS idx_document_chunks_project_type
+  ON document_chunks(project_id, entity_type, validity, observed_at);

package/schema/observer/005-project-scoped-identities.sql

@@ -0,0 +1,217 @@
+-- wendkeep:structural
+-- Rebuild the operational identity tables so external identifiers are scoped by project.
+-- Internal primary keys remain deterministic and opaque to the public API.
+
+PRAGMA defer_foreign_keys = ON;
+
+CREATE TABLE sessions_v5 (
+  session_pk TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(project_id) ON DELETE CASCADE,
+  session_id TEXT NOT NULL,
+  provider TEXT NOT NULL DEFAULT '',
+  status TEXT NOT NULL DEFAULT 'unknown',
+  summary TEXT NOT NULL DEFAULT '',
+  change_slug TEXT NOT NULL DEFAULT '',
+  started_at TEXT,
+  ended_at TEXT,
+  updated_at TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  UNIQUE(project_id, session_id)
+);
+
+INSERT INTO sessions_v5
+SELECT project_id || char(31) || session_id, project_id, session_id, provider, status,
+       summary, change_slug, started_at, ended_at, updated_at, metadata_json
+FROM sessions;
+
+INSERT OR IGNORE INTO sessions_v5(session_pk, project_id, session_id, updated_at)
+SELECT project_id || char(31) || session_id, project_id, session_id,
+       COALESCE(MAX(occurred_at), CURRENT_TIMESTAMP)
+FROM (
+  SELECT project_id, session_id, occurred_at FROM usage_rollups
+  UNION ALL SELECT project_id, session_id, occurred_at FROM llm_calls
+  UNION ALL SELECT project_id, session_id, occurred_at FROM transcripts
+) GROUP BY project_id, session_id;
+
+INSERT OR IGNORE INTO sessions_v5(session_pk, project_id, session_id, updated_at)
+SELECT project_id || char(31) || session_id, project_id, session_id, CURRENT_TIMESTAMP
+FROM agent_runs;
+
+CREATE TABLE agent_runs_v5 (
+  agent_pk TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(project_id) ON DELETE CASCADE,
+  agent_id TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  parent_agent_id TEXT,
+  role TEXT NOT NULL DEFAULT 'main',
+  agent_name TEXT NOT NULL DEFAULT '',
+  agent_type TEXT NOT NULL DEFAULT '',
+  workflow TEXT NOT NULL DEFAULT '',
+  status TEXT NOT NULL DEFAULT 'unknown',
+  model TEXT NOT NULL DEFAULT '',
+  effort TEXT NOT NULL DEFAULT '',
+  started_at TEXT,
+  ended_at TEXT,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  UNIQUE(project_id, agent_id),
+  FOREIGN KEY(project_id, session_id) REFERENCES sessions_v5(project_id, session_id) ON DELETE CASCADE,
+  FOREIGN KEY(project_id, parent_agent_id) REFERENCES agent_runs_v5(project_id, agent_id) ON DELETE SET NULL
+);
+
+INSERT INTO agent_runs_v5
+SELECT a.project_id || char(31) || a.agent_id, a.project_id, a.agent_id, a.session_id,
+       CASE WHEN EXISTS (
+         SELECT 1 FROM agent_runs parent
+         WHERE parent.project_id = a.project_id AND parent.agent_id = a.parent_agent_id
+       ) THEN a.parent_agent_id ELSE NULL END,
+       a.role, a.agent_name, a.agent_type, a.workflow, a.status, a.model, a.effort,
+       a.started_at, a.ended_at, a.metadata_json
+FROM agent_runs a;
+
+INSERT OR IGNORE INTO agent_runs_v5(
+  agent_pk, project_id, agent_id, session_id, role, status
+)
+SELECT project_id || char(31) || agent_id, project_id, agent_id, session_id, role, 'unknown'
+FROM (
+  SELECT project_id, agent_id, session_id, role FROM usage_rollups
+  UNION ALL SELECT project_id, agent_id, session_id, role FROM llm_calls
+  UNION ALL SELECT project_id, agent_id, session_id, 'main' AS role FROM transcripts
+);
+
+CREATE TABLE usage_rollups_v5 (
+  rollup_pk TEXT PRIMARY KEY,
+  rollup_key TEXT NOT NULL,
+  project_id TEXT NOT NULL REFERENCES projects(project_id) ON DELETE CASCADE,
+  session_id TEXT NOT NULL,
+  agent_id TEXT NOT NULL,
+  role TEXT NOT NULL DEFAULT 'main',
+  provider TEXT NOT NULL DEFAULT '',
+  model_provider TEXT NOT NULL DEFAULT '',
+  model TEXT NOT NULL DEFAULT '',
+  effort TEXT NOT NULL DEFAULT '',
+  calls INTEGER NOT NULL DEFAULT 0,
+  tokens_input INTEGER NOT NULL DEFAULT 0,
+  tokens_cache_write INTEGER NOT NULL DEFAULT 0,
+  tokens_cache_read INTEGER NOT NULL DEFAULT 0,
+  tokens_output INTEGER NOT NULL DEFAULT 0,
+  tokens_reasoning INTEGER NOT NULL DEFAULT 0,
+  tokens_total INTEGER NOT NULL DEFAULT 0,
+  cost_usd REAL NOT NULL DEFAULT 0,
+  cost_status TEXT NOT NULL DEFAULT 'unknown',
+  pricing_source TEXT NOT NULL DEFAULT '',
+  pricing_version TEXT NOT NULL DEFAULT '',
+  wasted_usd REAL NOT NULL DEFAULT 0,
+  revision INTEGER NOT NULL DEFAULT 1,
+  occurred_at TEXT NOT NULL,
+  source_event_id TEXT NOT NULL REFERENCES ingest_events(event_id) ON DELETE CASCADE,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  UNIQUE(project_id, rollup_key),
+  FOREIGN KEY(project_id, session_id) REFERENCES sessions_v5(project_id, session_id) ON DELETE CASCADE,
+  FOREIGN KEY(project_id, agent_id) REFERENCES agent_runs_v5(project_id, agent_id) ON DELETE CASCADE
+);
+
+INSERT INTO usage_rollups_v5
+SELECT project_id || char(31) || rollup_key, rollup_key, project_id, session_id,
+       agent_id, role, provider, model_provider, model, effort, calls, tokens_input,
+       tokens_cache_write, tokens_cache_read, tokens_output, tokens_reasoning,
+       tokens_total, cost_usd, cost_status, pricing_source, pricing_version,
+       wasted_usd, revision, occurred_at, source_event_id, metadata_json
+FROM usage_rollups;
+
+CREATE TABLE llm_calls_v5 (
+  call_pk TEXT PRIMARY KEY,
+  call_id TEXT NOT NULL,
+  project_id TEXT NOT NULL REFERENCES projects(project_id) ON DELETE CASCADE,
+  session_id TEXT NOT NULL,
+  agent_id TEXT NOT NULL,
+  role TEXT NOT NULL DEFAULT 'main',
+  provider TEXT NOT NULL DEFAULT '',
+  model_provider TEXT NOT NULL DEFAULT '',
+  model TEXT NOT NULL DEFAULT '',
+  effort TEXT NOT NULL DEFAULT '',
+  sequence INTEGER NOT NULL DEFAULT 0,
+  occurred_at TEXT NOT NULL,
+  tokens_input INTEGER NOT NULL DEFAULT 0,
+  tokens_cache_write INTEGER NOT NULL DEFAULT 0,
+  tokens_cache_read INTEGER NOT NULL DEFAULT 0,
+  tokens_output INTEGER NOT NULL DEFAULT 0,
+  tokens_reasoning INTEGER NOT NULL DEFAULT 0,
+  tokens_total INTEGER NOT NULL DEFAULT 0,
+  cost_usd REAL NOT NULL DEFAULT 0,
+  cost_status TEXT NOT NULL DEFAULT 'unknown',
+  transcript_id TEXT,
+  prompt_text TEXT NOT NULL DEFAULT '',
+  response_text TEXT NOT NULL DEFAULT '',
+  status TEXT NOT NULL DEFAULT 'complete',
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  UNIQUE(project_id, call_id),
+  FOREIGN KEY(project_id, session_id) REFERENCES sessions_v5(project_id, session_id) ON DELETE CASCADE,
+  FOREIGN KEY(project_id, agent_id) REFERENCES agent_runs_v5(project_id, agent_id) ON DELETE CASCADE
+);
+
+INSERT INTO llm_calls_v5
+SELECT project_id || char(31) || call_id, call_id, project_id, session_id, agent_id,
+       role, provider, model_provider, model, effort, sequence, occurred_at,
+       tokens_input, tokens_cache_write, tokens_cache_read, tokens_output,
+       tokens_reasoning, tokens_total, cost_usd, cost_status, transcript_id,
+       prompt_text, response_text, status, metadata_json
+FROM llm_calls;
+
+CREATE TABLE transcripts_v5 (
+  transcript_pk TEXT PRIMARY KEY,
+  transcript_id TEXT NOT NULL,
+  project_id TEXT NOT NULL REFERENCES projects(project_id) ON DELETE CASCADE,
+  session_id TEXT NOT NULL,
+  agent_id TEXT NOT NULL,
+  coverage TEXT NOT NULL DEFAULT 'summary_only',
+  codec TEXT NOT NULL DEFAULT 'gzip',
+  content_gzip BLOB NOT NULL,
+  content_sha256 TEXT NOT NULL,
+  original_bytes INTEGER NOT NULL,
+  compressed_bytes INTEGER NOT NULL,
+  source TEXT NOT NULL DEFAULT '',
+  occurred_at TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  UNIQUE(project_id, transcript_id),
+  FOREIGN KEY(project_id, session_id) REFERENCES sessions_v5(project_id, session_id) ON DELETE CASCADE,
+  FOREIGN KEY(project_id, agent_id) REFERENCES agent_runs_v5(project_id, agent_id) ON DELETE CASCADE
+);
+
+INSERT INTO transcripts_v5
+SELECT project_id || char(31) || transcript_id, transcript_id, project_id, session_id,
+       agent_id, coverage, codec, content_gzip, content_sha256, original_bytes,
+       compressed_bytes, source, occurred_at, metadata_json
+FROM transcripts;
+
+DROP TABLE llm_calls;
+DROP TABLE transcripts;
+DROP TABLE usage_rollups;
+DROP TABLE agent_runs;
+DROP TABLE sessions;
+
+ALTER TABLE sessions_v5 RENAME TO sessions;
+ALTER TABLE agent_runs_v5 RENAME TO agent_runs;
+ALTER TABLE usage_rollups_v5 RENAME TO usage_rollups;
+ALTER TABLE llm_calls_v5 RENAME TO llm_calls;
+ALTER TABLE transcripts_v5 RENAME TO transcripts;
+
+CREATE INDEX idx_sessions_project_time ON sessions(project_id, started_at, ended_at);
+CREATE INDEX idx_agent_runs_project_session ON agent_runs(project_id, session_id, role);
+CREATE INDEX idx_usage_rollups_project_time ON usage_rollups(project_id, occurred_at);
+CREATE INDEX idx_usage_rollups_project_agent ON usage_rollups(project_id, agent_id, role);
+CREATE INDEX idx_usage_rollups_project_model ON usage_rollups(project_id, model_provider, model);
+CREATE INDEX idx_llm_calls_project_time ON llm_calls(project_id, occurred_at);
+CREATE INDEX idx_llm_calls_project_agent ON llm_calls(project_id, agent_id, sequence);
+CREATE INDEX idx_llm_calls_project_model ON llm_calls(project_id, model_provider, model);
+CREATE INDEX idx_transcripts_project_session ON transcripts(project_id, session_id, occurred_at);
+CREATE INDEX idx_transcripts_project_coverage ON transcripts(project_id, coverage);
+
+CREATE TABLE project_snapshots (
+  project_id TEXT PRIMARY KEY REFERENCES projects(project_id) ON DELETE CASCADE,
+  event_id TEXT NOT NULL,
+  captured_at TEXT NOT NULL,
+  snapshot_json TEXT NOT NULL,
+  UNIQUE(project_id, event_id)
+);
+
+CREATE INDEX idx_project_snapshots_captured ON project_snapshots(captured_at);

package/src/change.mjs

@@ -1,5 +1,5 @@
 // `wendkeep change <sub>` — native change lifecycle CLI (Pilar B).
-import { readFileSync } from 'node:fs';
+import { readFileSync, readdirSync } from 'node:fs';
 import { isAbsolute, join, resolve } from 'node:path';
 import {
   newChange,
@@ -22,6 +22,22 @@ import { evaluateGate, requiredSensors } from '../hooks/sensors-core.mjs';
 import { buildEffectiveRequirementPackage, evaluateVerdict, formatOrphanReqs, tasksHashOf, parseSpecsList, parseDelta, parseRequirements, applyDelta, validateSpecImpact } from '../hooks/spec-core.mjs';
 import { getNextAdrNumber, readControl, readSessionRegistry, upsertSessionRegistry } from '../hooks/obsidian-common.mjs';
 import { getLocale } from '../hooks/locale.mjs';
+import { enqueueObserverDocumentChange } from './observer-sql-publish.mjs';
+import { readProjectForValidation } from '../packages/vault/src/validate-memory.mjs';
+
+function observerMarkdownUnder(vaultBase, relativeRoot) {
+  const output = [];
+  const walk = (absolute, relative) => {
+    for (const entry of readdirSync(absolute, { withFileTypes: true })) {
+      const nextAbsolute = join(absolute, entry.name);
+      const nextRelative = join(relative, entry.name);
+      if (entry.isDirectory()) walk(nextAbsolute, nextRelative);
+      else if (entry.isFile() && entry.name.endsWith('.md')) output.push(nextRelative);
+    }
+  };
+  try { walk(join(vaultBase, relativeRoot), relativeRoot); } catch { /* reconcile recupera */ }
+  return output;
+}
 
 function resolveVault(argv) {
   let vault;
@@ -299,6 +315,30 @@ export function runChange(argv) {
       process.stderr.write(`change archive BLOCKED (gate): ${r.failing.join('; ')}\n`);
       process.exit(1);
     }
+    try {
+      const project = readProjectForValidation(vaultBase);
+      if (project.ok && project.projectId) {
+        const loc = getLocale(vaultBase);
+        for (const archivedPath of observerMarkdownUnder(vaultBase, r.archivedRel)) {
+          enqueueObserverDocumentChange({ vaultBase, projectId: project.projectId, logicalPath: archivedPath });
+          const suffix = archivedPath.slice(String(r.archivedRel).length).replace(/^[\\/]+/, '');
+          enqueueObserverDocumentChange({
+            vaultBase,
+            projectId: project.projectId,
+            logicalPath: join(loc.folders.changes, slug, suffix),
+            deleted: true,
+          });
+        }
+        if (r.adrRel) enqueueObserverDocumentChange({ vaultBase, projectId: project.projectId, logicalPath: r.adrRel });
+        for (const capability of r.promoted || []) {
+          enqueueObserverDocumentChange({
+            vaultBase,
+            projectId: project.projectId,
+            logicalPath: join(loc.folders.specs, capability, 'spec.md'),
+          });
+        }
+      }
+    } catch { /* Observer é fail-open; reconcile recupera qualquer enqueue perdido. */ }
     process.stdout.write(`archived: ${r.archivedRel}${r.adrRel ? `; ADR: ${r.adrRel}` : '; GUIDE compacta: sem ADR'}\n`);
     if (r.promoted && r.promoted.length) process.stdout.write(`specs promovidas: ${r.promoted.join(', ')}\n`);
     if (r.specWarnings && r.specWarnings.length) for (const w of r.specWarnings) process.stderr.write(`  aviso spec: ${w}\n`);