wendkeep 0.72.0 → 0.73.0

package/src/observer-privacy.mjs

@@ -0,0 +1,23 @@
+import { basename } from 'node:path';
+
+const TRANSCRIPT_PATH_KEY = /^(?:transcript_path|agent_transcript_path|transcriptPath|agentTranscriptPath)$/i;
+const TRANSCRIPT_PATH_LINE = /^(\s*["']?(?:transcript_path|agent_transcript_path|transcriptPath|agentTranscriptPath)["']?\s*:\s*)(["']?)(.*?)(\2)(\s*,?\s*)$/gmi;
+
+function sourceLabel(value) {
+  return basename(String(value || '').replaceAll('\\', '/'));
+}
+
+export function sanitizeObserverContent(content) {
+  return String(content || '').replace(TRANSCRIPT_PATH_LINE, (_line, prefix, quote, value, _closing, suffix) => (
+    `${prefix}${quote}${sourceLabel(value)}${quote}${suffix}`
+  ));
+}
+
+export function sanitizeObserverMetadata(value) {
+  if (Array.isArray(value)) return value.map(sanitizeObserverMetadata);
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+    key,
+    TRANSCRIPT_PATH_KEY.test(key) ? sourceLabel(item) : sanitizeObserverMetadata(item),
+  ]));
+}

package/src/observer-publish.mjs

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, unlinkSyn
 import { join } from 'node:path';
 import { buildProjectSnapshot } from './observer-snapshot.mjs';
 import { publishObserverSql } from './observer-sql-publish.mjs';
+import { observerAuthHeaders, resolveObserverToken } from './observer-auth.mjs';
 
 const OUTBOX_REL = join('.brain', 'observer-outbox');
 const REQUEST_TIMEOUT_MS = 500;
@@ -46,15 +47,15 @@ function removeOutbox(vaultBase, eventId) {
   if (existsSync(path)) unlinkSync(path);
 }
 
-async function postSnapshot(url, event) {
+async function postSnapshot(url, event, token) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
   try {
     const response = await fetch(`${String(url).replace(/\/$/, '')}/v1/projects/${encodeURIComponent(event.project_id)}/snapshot`, {
       method: 'POST',
-      headers: {
+      headers: observerAuthHeaders(token, {
         'content-type': 'application/json',
-      },
+      }),
       body: JSON.stringify(event),
       signal: controller.signal,
     });
@@ -70,14 +71,14 @@ async function postSnapshot(url, event) {
   }
 }
 
-export async function retryObserverOutbox({ vaultBase, url } = {}) {
+export async function retryObserverOutbox({ vaultBase, url, token = process.env.WENDKEEP_OBSERVER_TOKEN || '' } = {}) {
   if (!url) return { attempted: 0, confirmed: 0, pending: listOutbox(vaultBase).length };
   let attempted = 0;
   let confirmed = 0;
   for (const event of listOutbox(vaultBase)) {
     attempted += 1;
     try {
-      await postSnapshot(url, event);
+      await postSnapshot(url, event, token);
       removeOutbox(vaultBase, event.event_id);
       confirmed += 1;
     } catch { /* preserve the event for a later retry */ }
@@ -91,6 +92,7 @@ export async function publishObserverSnapshot({
   url = process.env.WENDKEEP_OBSERVER_URL || '',
   now = new Date(),
   input = {},
+  token = process.env.WENDKEEP_OBSERVER_TOKEN || '',
 } = {}) {
   try {
     const event = buildProjectSnapshot({ vaultBase, projectRoot, now });
@@ -100,15 +102,16 @@ export async function publishObserverSnapshot({
       url,
       input,
       now,
+      token,
     });
     if (!url) return { ok: sql.ok, skipped: true, queued: sql.queued, hookExitCode: 0, event_id: event.event_id, sql };
 
-    await retryObserverOutbox({ vaultBase, url });
+    await retryObserverOutbox({ vaultBase, url, token });
     // SQL is the live authority. Keep the legacy-shaped `memory` field for
     // older integrations while reporting the real SQL publication separately.
     const memory = { ok: sql.ok, queued: sql.queued, changed: sql.changed, pending: sql.pending, authority: 'sqlite' };
     try {
-      const response = await postSnapshot(url, event);
+      const response = await postSnapshot(url, event, resolveObserverToken(token));
       return {
         ok: true,
         queued: false,

package/src/observer-server.mjs

@@ -1,4 +1,5 @@
 import { createServer } from 'node:http';
+import { createHash, timingSafeEqual } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { gunzipSync } from 'node:zlib';
@@ -52,6 +53,39 @@ function loopbackOnly(host) {
   return LOOPBACK_HOSTS.has(String(host || '').toLowerCase());
 }
 
+function safeTokenEqual(actual, expected) {
+  if (!actual || !expected) return false;
+  const left = createHash('sha256').update(String(actual)).digest();
+  const right = createHash('sha256').update(String(expected)).digest();
+  return timingSafeEqual(left, right);
+}
+
+function bearerToken(req) {
+  const match = String(req.headers.authorization || '').match(/^Bearer\s+(.+)$/i);
+  return match?.[1] || '';
+}
+
+function requestHostname(value) {
+  try { return new URL(`http://${String(value || '')}`).hostname.toLowerCase(); }
+  catch { return ''; }
+}
+
+function validateAuthority(req, { loopback }) {
+  const hostname = requestHostname(req.headers.host);
+  if (!hostname || (loopback && !LOOPBACK_HOSTS.has(hostname))) {
+    return { ok: false, status: 421, code: 'invalid_host', message: 'Host não corresponde ao binding do Observer.' };
+  }
+  const origin = String(req.headers.origin || '');
+  if (origin) {
+    let originHostname = '';
+    try { originHostname = new URL(origin).hostname.toLowerCase(); } catch { /* invalid below */ }
+    if (!originHostname || originHostname !== hostname) {
+      return { ok: false, status: 403, code: 'invalid_origin', message: 'Origin não corresponde ao Host do Observer.' };
+    }
+  }
+  return { ok: true };
+}
+
 function json(res, status, body) {
   const content = JSON.stringify(body);
   res.writeHead(status, {
@@ -184,10 +218,16 @@ export async function startObserverServer({
   port = 8787,
   dataDir,
   allowNonLoopback = false,
+  token = process.env.WENDKEEP_OBSERVER_TOKEN || '',
 } = {}) {
   if (!loopbackOnly(host) && !allowNonLoopback) {
     throw new Error(`Observer HTTP aceita somente host loopback; recebido: ${host}`);
   }
+  if (!loopbackOnly(host) && !token) {
+    const error = new Error('Observer non-loopback exige --token ou WENDKEEP_OBSERVER_TOKEN.');
+    error.code = 'WENDKEEP_OBSERVER_TOKEN_REQUIRED';
+    throw error;
+  }
   if (!dataDir) throw new Error('dataDir é obrigatório.');
   const sqlDb = ensureObserverDatabase(dataDir);
   const databaseMigration = migrateObserverDatabase(sqlDb);
@@ -204,6 +244,17 @@ export async function startObserverServer({
   const server = createServer(async (req, res) => {
     try {
       const pathname = new URL(req.url || '/', 'http://127.0.0.1').pathname;
+      const authority = validateAuthority(req, { loopback: loopbackOnly(host) });
+      if (!authority.ok) {
+        errorResponse(res, authority.status, authority.code, authority.message);
+        return;
+      }
+      const authenticated = safeTokenEqual(bearerToken(req), token);
+      const mutating = !['GET', 'HEAD', 'OPTIONS'].includes(String(req.method || '').toUpperCase());
+      if ((mutating || !loopbackOnly(host)) && !authenticated) {
+        errorResponse(res, 401, 'observer_auth_required', 'Bearer token válido é obrigatório para esta operação.');
+        return;
+      }
       if (req.method === 'GET' && pathname === '/healthz') {
         json(res, 200, {
           ok: true,

package/src/observer-sql-publish.mjs

@@ -13,6 +13,8 @@ import { gzipSync } from 'node:zlib';
 import { parseTranscriptContent } from '../packages/integrations/src/transcripts.mjs';
 import { parseSessionCost, } from './cost.mjs';
 import { buildSessionIdentityMap, listMigrationDocuments, parseFrontmatter, sessionEvents } from './observer-sql-migrate.mjs';
+import { observerAuthHeaders } from './observer-auth.mjs';
+import { sanitizeObserverContent, sanitizeObserverMetadata } from './observer-privacy.mjs';
 
 export const SQL_OUTBOX_REL = '.brain/observer-sql-outbox';
 export const SQL_STATE_REL = '.brain/observer-sql-state.json';
@@ -20,6 +22,28 @@ const SQL_SCHEMA_VERSION = 1;
 export const SQL_EVENT_BATCH_SIZE = 64;
 export const SQL_EVENT_BATCH_BYTES = 8 * 1024 * 1024;
 const REQUEST_TIMEOUT_MS = 15000;
+const MAX_REQUEST_TIMEOUT_MS = 120000;
+const REQUEST_TIMEOUT_BYTES_STEP = 1024 * 1024;
+const CAPTURE_LEVELS = new Set(['metadata', 'messages', 'full-transcript']);
+
+export function observerSqlRequestTimeoutMs(rawBytes) {
+  const size = Math.max(0, Number(rawBytes) || 0);
+  const oversizedBytes = Math.max(0, size - SQL_EVENT_BATCH_BYTES);
+  return Math.min(
+    MAX_REQUEST_TIMEOUT_MS,
+    REQUEST_TIMEOUT_MS + Math.ceil(oversizedBytes / REQUEST_TIMEOUT_BYTES_STEP) * 1000,
+  );
+}
+
+export function normalizeObserverCaptureLevel(value = process.env.WENDKEEP_OBSERVER_CAPTURE_LEVEL || 'metadata') {
+  const level = String(value || 'metadata').trim().toLowerCase();
+  if (!CAPTURE_LEVELS.has(level)) {
+    const error = new Error(`Nível de captura inválido: ${level}. Use metadata, messages ou full-transcript.`);
+    error.code = 'WENDKEEP_OBSERVER_CAPTURE_LEVEL_INVALID';
+    throw error;
+  }
+  return level;
+}
 
 function text(value, fallback = '') { return String(value ?? fallback); }
 function hash(value) { return createHash('sha256').update(typeof value === 'string' ? value : JSON.stringify(value)).digest('hex'); }
@@ -73,7 +97,9 @@ function tokenPayload(usage = {}) {
 }
 
 function documentEvent({ projectId, logicalPath, content, metadata, revision, occurredAt }) {
-  const contentHash = hash(content);
+  const safeContent = sanitizeObserverContent(content);
+  const safeMetadata = sanitizeObserverMetadata(metadata);
+  const contentHash = hash(safeContent);
   return {
     schema_version: 1,
     event_id: eventId('document', projectId, `${logicalPath}:${revision}:${contentHash}`),
@@ -89,11 +115,11 @@ function documentEvent({ projectId, logicalPath, content, metadata, revision, oc
               : logicalPath.startsWith('07-Specs/') ? 'spec'
                 : logicalPath.startsWith('08-Mudanças/') ? 'change' : 'memory',
       title: basename(logicalPath).replace(/\.md$/i, ''),
-      content,
+      content: safeContent,
       content_hash: contentHash,
       revision,
-      metadata,
-      source_session_id: text(metadata?.session_id),
+      metadata: safeMetadata,
+      source_session_id: text(safeMetadata?.session_id),
     },
   };
 }
@@ -123,7 +149,7 @@ function agentEvent({ projectId, sessionId, agentId, parentAgentId = '', role =
   };
 }
 
-function transcriptCalls({ projectId, sessionId, agentId, role, provider, modelFallback, transcriptId, content, occurredAt }) {
+function transcriptCalls({ projectId, sessionId, agentId, role, provider, modelFallback, transcriptId, content, occurredAt, includeMessages }) {
   let parsed;
   try { parsed = parseTranscriptContent(content); } catch { return []; }
   return (parsed.turns || []).flatMap((turn, index) => {
@@ -154,8 +180,8 @@ function transcriptCalls({ projectId, sessionId, agentId, role, provider, modelF
         cost_usd: 0,
         cost_status: 'unknown',
         transcript_id: transcriptId,
-        prompt_text: prompt,
-        response_text: response,
+        prompt_text: includeMessages ? prompt : '',
+        response_text: includeMessages ? response : '',
         status: turn.status === 'aborted' ? 'aborted' : 'complete',
         metadata: { tools: turn.tools || [], source: 'transcript-parser' },
       },
@@ -180,7 +206,7 @@ function sourceCandidates({ vaultBase, logicalPath, fm, input }) {
   return candidates;
 }
 
-function completeTranscriptEvents({ projectId, sessionId, mainAgentId, provider, model, source, now }) {
+function completeTranscriptEvents({ projectId, sessionId, mainAgentId, provider, model, source, now, captureLevel }) {
   const content = readFileSync(source.path, 'utf8');
   const agentId = source.role === 'subagent'
     ? `${projectId}:${sessionId}:subagent:${hash(source.path).slice(0, 16)}`
@@ -189,7 +215,7 @@ function completeTranscriptEvents({ projectId, sessionId, mainAgentId, provider,
     ? agentEvent({ projectId, sessionId, agentId, parentAgentId: mainAgentId, role: 'subagent', provider, model, input: source.agentInput, occurredAt: now })
     : null;
   const fingerprint = hash(content);
-  const transcript = {
+  const transcript = captureLevel === 'full-transcript' ? {
     schema_version: 1,
     event_id: eventId('transcript', projectId, `${source.transcriptId}:${fingerprint}`),
     kind: 'transcript.upsert',
@@ -202,10 +228,21 @@ function completeTranscriptEvents({ projectId, sessionId, mainAgentId, provider,
       coverage: 'complete',
       content,
       source: 'hook-transcript',
-      metadata: { original_path: source.path.replaceAll('\\', '/') },
+      metadata: { source_label: basename(source.path), source_hash: hash(normalizePath(source.path)) },
     },
-  };
-  const calls = transcriptCalls({ projectId, sessionId, agentId, role: source.role, provider, modelFallback: model, transcriptId: source.transcriptId, content, occurredAt: now });
+  } : null;
+  const calls = transcriptCalls({
+    projectId,
+    sessionId,
+    agentId,
+    role: source.role,
+    provider,
+    modelFallback: model,
+    transcriptId: source.transcriptId,
+    content,
+    occurredAt: now,
+    includeMessages: captureLevel !== 'metadata',
+  });
   return { events: [agent, transcript, ...calls].filter(Boolean), fingerprint, transcriptId: source.transcriptId };
 }
 
@@ -218,9 +255,10 @@ function dedupeEvents(events) {
   });
 }
 
-export function buildObserverSqlEventBatch({ vaultBase, projectId, input = {}, now = new Date(), state = readState(vaultBase), remoteDocuments = {} } = {}) {
+export function buildObserverSqlEventBatch({ vaultBase, projectId, input = {}, now = new Date(), state = readState(vaultBase), remoteDocuments = {}, captureLevel = process.env.WENDKEEP_OBSERVER_CAPTURE_LEVEL || 'metadata' } = {}) {
   if (!vaultBase || !projectId) throw new Error('vaultBase e projectId são obrigatórios.');
   const occurredAt = isoNow(now);
+  const resolvedCaptureLevel = normalizeObserverCaptureLevel(captureLevel);
   const nextState = { schema_version: SQL_SCHEMA_VERSION, files: { ...(state.files || {}) }, transcripts: { ...(state.transcripts || {}) } };
   const events = [];
   const sessionContexts = [];
@@ -235,7 +273,7 @@ export function buildObserverSqlEventBatch({ vaultBase, projectId, input = {}, n
   let changed = 0;
   for (const file of files) {
     const content = readFileSync(file.absolute, 'utf8');
-    const contentHash = hash(content);
+    const contentHash = hash(sanitizeObserverContent(content));
     const previous = state.files?.[file.logicalPath];
     const remote = remoteDocuments?.[file.logicalPath];
     const baseRevision = Math.max(Number(previous?.revision || 0), Number(remote?.revision || 0));
@@ -263,9 +301,10 @@ export function buildObserverSqlEventBatch({ vaultBase, projectId, input = {}, n
     for (const source of sources) {
       const content = readFileSync(source.path, 'utf8');
       const fingerprint = hash(content);
-      if (state.transcripts?.[source.transcriptId]?.content_hash === fingerprint) continue;
-      const complete = completeTranscriptEvents({ projectId, sessionId, mainAgentId, provider, model, source, now: occurredAt });
-      nextState.transcripts[source.transcriptId] = { content_hash: complete.fingerprint, coverage: 'complete' };
+      const previousTranscript = state.transcripts?.[source.transcriptId];
+      if (previousTranscript?.content_hash === fingerprint && previousTranscript?.coverage === resolvedCaptureLevel) continue;
+      const complete = completeTranscriptEvents({ projectId, sessionId, mainAgentId, provider, model, source, now: occurredAt, captureLevel: resolvedCaptureLevel });
+      nextState.transcripts[source.transcriptId] = { content_hash: complete.fingerprint, coverage: resolvedCaptureLevel };
       const summaryId = complete.transcriptId;
       for (const event of complete.events) {
         if (event.kind === 'agent.upsert' && event.payload.agent_id !== mainAgentId) events.push(event);
@@ -297,14 +336,15 @@ export function listSqlOutbox(vaultBase) {
   });
 }
 
-async function postSqlChunk({ url, projectId, events, fetchImpl = globalThis.fetch }) {
+async function postSqlChunk({ url, projectId, events, fetchImpl = globalThis.fetch, token = '' }) {
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
-  const wireBody = gzipSync(Buffer.from(JSON.stringify({ events }), 'utf8'));
+  const rawBody = Buffer.from(JSON.stringify({ events }), 'utf8');
+  const timer = setTimeout(() => controller.abort(), observerSqlRequestTimeoutMs(rawBody.byteLength));
+  const wireBody = gzipSync(rawBody);
   try {
     const response = await fetchImpl(`${String(url).replace(/\/$/, '')}/v1/projects/${encodeURIComponent(projectId)}/ingest`, {
       method: 'POST',
-      headers: { 'content-type': 'application/json', 'content-encoding': 'gzip', accept: 'application/json' },
+      headers: observerAuthHeaders(token, { 'content-type': 'application/json', 'content-encoding': 'gzip', accept: 'application/json' }),
       body: wireBody,
       signal: controller.signal,
     });
@@ -314,11 +354,11 @@ async function postSqlChunk({ url, projectId, events, fetchImpl = globalThis.fet
   } finally { clearTimeout(timer); }
 }
 
-async function readRemoteDocuments({ url, projectId, fetchImpl = globalThis.fetch }) {
+async function readRemoteDocuments({ url, projectId, fetchImpl = globalThis.fetch, token = '' }) {
   if (!url) return {};
   try {
     const response = await fetchImpl(`${String(url).replace(/\/$/, '')}/v1/projects/${encodeURIComponent(projectId)}/memory/tree`, {
-      headers: { accept: 'application/json' },
+      headers: observerAuthHeaders(token, { accept: 'application/json' }),
     });
     if (!response.ok) return {};
     const body = await response.json().catch(() => ({}));
@@ -328,7 +368,7 @@ async function readRemoteDocuments({ url, projectId, fetchImpl = globalThis.fetc
   }
 }
 
-async function postSqlBatch({ url, projectId, events, fetchImpl = globalThis.fetch }) {
+async function postSqlBatch({ url, projectId, events, fetchImpl = globalThis.fetch, token = '' }) {
   const aggregate = { accepted: 0, rejected: 0, conflicts: 0, stale: 0, duplicates: 0 };
   let chunk = [];
   let chunkBytes = 0;
@@ -339,6 +379,7 @@ async function postSqlBatch({ url, projectId, events, fetchImpl = globalThis.fet
       projectId,
       events: items,
       fetchImpl,
+      token,
     });
     for (const key of Object.keys(aggregate)) aggregate[key] += Number(response?.[key]) || 0;
   };
@@ -358,7 +399,7 @@ async function postSqlBatch({ url, projectId, events, fetchImpl = globalThis.fet
   return aggregate;
 }
 
-export async function retryObserverSqlOutbox({ vaultBase, projectId, url, fetchImpl = globalThis.fetch } = {}) {
+export async function retryObserverSqlOutbox({ vaultBase, projectId, url, fetchImpl = globalThis.fetch, token = process.env.WENDKEEP_OBSERVER_TOKEN || '' } = {}) {
   const pending = listSqlOutbox(vaultBase);
   if (!url) return { attempted: 0, confirmed: 0, pending: pending.length };
   let attempted = 0;
@@ -366,7 +407,7 @@ export async function retryObserverSqlOutbox({ vaultBase, projectId, url, fetchI
   for (const batch of pending) {
     attempted += 1;
     try {
-      await postSqlBatch({ url, projectId, events: batch.events, fetchImpl });
+      await postSqlBatch({ url, projectId, events: batch.events, fetchImpl, token });
       unlinkSync(batch.path);
       confirmed += 1;
     } catch { break; }
@@ -374,14 +415,14 @@ export async function retryObserverSqlOutbox({ vaultBase, projectId, url, fetchI
   return { attempted, confirmed, pending: listSqlOutbox(vaultBase).length };
 }
 
-export async function publishObserverSql({ vaultBase, projectId, url = process.env.WENDKEEP_OBSERVER_URL || '', input = {}, now = new Date(), fetchImpl = globalThis.fetch } = {}) {
+export async function publishObserverSql({ vaultBase, projectId, url = process.env.WENDKEEP_OBSERVER_URL || '', input = {}, now = new Date(), fetchImpl = globalThis.fetch, token = process.env.WENDKEEP_OBSERVER_TOKEN || '', captureLevel = process.env.WENDKEEP_OBSERVER_CAPTURE_LEVEL || 'metadata' } = {}) {
   if (!vaultBase || !projectId) throw new Error('vaultBase e projectId são obrigatórios.');
-  const replay = await retryObserverSqlOutbox({ vaultBase, projectId, url, fetchImpl });
+  const replay = await retryObserverSqlOutbox({ vaultBase, projectId, url, fetchImpl, token });
   const state = readState(vaultBase);
   const remoteDocuments = Object.keys(state.files || {}).length === 0
-    ? await readRemoteDocuments({ url, projectId, fetchImpl })
+    ? await readRemoteDocuments({ url, projectId, fetchImpl, token })
     : {};
-  const batch = buildObserverSqlEventBatch({ vaultBase, projectId, input, now, state, remoteDocuments });
+  const batch = buildObserverSqlEventBatch({ vaultBase, projectId, input, now, state, remoteDocuments, captureLevel });
   atomicJson(statePath(vaultBase), batch.nextState);
   if (!batch.events.length) return { ok: true, queued: false, scanned: batch.scanned, changed: batch.changed, pending: listSqlOutbox(vaultBase).length, replay };
   if (!url) {
@@ -389,7 +430,7 @@ export async function publishObserverSql({ vaultBase, projectId, url = process.e
     return { ok: false, queued: true, scanned: batch.scanned, changed: batch.changed, pending: listSqlOutbox(vaultBase).length, replay, hookExitCode: 0 };
   }
   try {
-    const response = await postSqlBatch({ url, projectId, events: batch.events, fetchImpl });
+    const response = await postSqlBatch({ url, projectId, events: batch.events, fetchImpl, token });
     return { ok: true, queued: false, scanned: batch.scanned, changed: batch.changed, pending: listSqlOutbox(vaultBase).length, replay, response };
   } catch (error) {
     queueOutbox(vaultBase, { schema_version: SQL_SCHEMA_VERSION, project_id: projectId, events: batch.events });

package/src/observer-sql-store.mjs

@@ -1,8 +1,8 @@
 import { createHash } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, readdirSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { join, basename, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { DatabaseSync } from 'node:sqlite';
 import { decodeTranscript, encodeTranscript } from './observer-transcript-store.mjs';
 
 export const OBSERVER_SQL_FILE = 'observer.sqlite';
@@ -16,6 +16,36 @@ const EVENT_KINDS = new Set([
   'usage.rollup', 'llm_call', 'transcript.upsert',
 ]);
 
+const OBSERVER_SQL_MINIMUM_NODE = '22.13.0';
+const require = createRequire(import.meta.url);
+let DatabaseSync;
+
+export function observerSqlRuntimeSupport(version = process.versions.node) {
+  const current = String(version || '0.0.0');
+  const [major = 0, minor = 0] = current.split('.').map((part) => Number(part) || 0);
+  return {
+    supported: major > 22 || (major === 22 && minor >= 13),
+    minimum: OBSERVER_SQL_MINIMUM_NODE,
+    current,
+  };
+}
+
+function observerSqlRuntimeError(support = observerSqlRuntimeSupport()) {
+  const error = new Error(`Observer SQL requer Node.js >= ${support.minimum}; atual: ${support.current}. O Keep Core continua compatível com Node.js >= 18.`);
+  error.code = 'WENDKEEP_OBSERVER_NODE_UNSUPPORTED';
+  return error;
+}
+
+function observerDatabaseSync() {
+  const support = observerSqlRuntimeSupport();
+  if (!support.supported) throw observerSqlRuntimeError(support);
+  if (!DatabaseSync) {
+    try { ({ DatabaseSync } = require('node:sqlite')); }
+    catch { throw observerSqlRuntimeError(support); }
+  }
+  return DatabaseSync;
+}
+
 function now() { return new Date().toISOString(); }
 
 function text(value, fallback = '') { return String(value ?? fallback); }
@@ -63,7 +93,8 @@ function migrationFiles() {
 export function openObserverDatabase(dataDir) {
   if (!dataDir) throw new Error('dataDir é obrigatório.');
   mkdirSync(dataDir, { recursive: true });
-  const db = new DatabaseSync(join(dataDir, OBSERVER_SQL_FILE));
+  const SqliteDatabase = observerDatabaseSync();
+  const db = new SqliteDatabase(join(dataDir, OBSERVER_SQL_FILE));
   db.exec('PRAGMA foreign_keys = ON; PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;');
   return db;
 }

package/src/observer.mjs

@@ -7,15 +7,17 @@ import { publishObserverSql } from './observer-sql-publish.mjs';
 import { startObserverServer } from './observer-server.mjs';
 import { ensureObserverDatabase, migrateObserverDatabase, listSqlProjects, OBSERVER_SQL_FILE, OBSERVER_SQL_SCHEMA_VERSION } from './observer-sql-store.mjs';
 import { resolveProjectVault } from '../packages/vault/src/project-vault.mjs';
+import { observerAuthHeaders, resolveObserverToken } from './observer-auth.mjs';
 
 export const OBSERVER_HELP = `wendkeep observer — Observer local multi-projeto
 
 Uso:
   wendkeep observer serve [--data-dir P] [--host 127.0.0.1] [--port 8787]
-                          [--allow-non-loopback]
+                          [--allow-non-loopback] [--token TOKEN]
   wendkeep observer register --project P [--vault V] [--data-dir D] [--json]
   wendkeep observer publish --project P [--vault V] [--data-dir D] [--json]
-  wendkeep observer memory import --project P [--vault V] [--url U] [--json]
+  wendkeep observer memory import --project P [--vault V] [--url U] [--token TOKEN]
+                                    [--capture-level metadata|messages|full-transcript] [--json]
   wendkeep observer status [--data-dir D] [--json]
 
 O Observer local pode manter snapshots operacionais e uma cópia completa da memória em volume
@@ -79,6 +81,7 @@ export async function runObserver(argv = [], { write = (chunk) => process.stdout
     return 0;
   }
   const dir = dataDir(argv);
+  const token = resolveObserverToken(optionValue(argv, '--token'));
 
   if (sub === 'status') {
     print({ ...summary(readObserverIndex(dir)), database: databaseSummary(dir) }, asJson, write);
@@ -92,6 +95,7 @@ export async function runObserver(argv = [], { write = (chunk) => process.stdout
       host,
       port: Number(optionValue(argv, '--port') || 8787),
       allowNonLoopback: argv.includes('--allow-non-loopback'),
+      token,
     });
     const address = server.address();
     process.stdout.write(`wendkeep observer listening: http://${address.address}:${address.port}\n`);
@@ -106,7 +110,7 @@ export async function runObserver(argv = [], { write = (chunk) => process.stdout
     const snapshot = buildProjectSnapshot({ vaultBase: vault, projectRoot: root });
     const url = optionValue(argv, '--url') || process.env.WENDKEEP_OBSERVER_URL || '';
     if (!url) throw new Error('observer memory import: --url ou WENDKEEP_OBSERVER_URL é obrigatório.');
-    const headers = { 'content-type': 'application/json', accept: 'application/json' };
+    const headers = observerAuthHeaders(token, { 'content-type': 'application/json', accept: 'application/json' });
     const registration = await fetch(
       String(url).replace(/\/$/, '') + '/v1/projects/' + encodeURIComponent(snapshot.project_id),
       {
@@ -124,11 +128,14 @@ export async function runObserver(argv = [], { write = (chunk) => process.stdout
       vaultBase: vault,
       projectId: snapshot.project_id,
       url,
+      token,
+      captureLevel: optionValue(argv, '--capture-level') || process.env.WENDKEEP_OBSERVER_CAPTURE_LEVEL || 'metadata',
     });
     const parity = await compareMemoryParity({
       vaultBase: vault,
       projectId: snapshot.project_id,
       url,
+      token,
     });
     const result = {
       ok: sql.ok && parity.missing === 0 && parity.mismatched === 0,

package/src/release-changelog.mjs

@@ -1,5 +1,5 @@
 // Pure helper: extract a single version's release notes from a Keep-a-Changelog
-// file. Reused by scripts/release.mjs and .github/workflows/release.yml so the
+// file. Reused by scripts/release.mjs and .github/workflows/auto-tag.yml so the
 // GitHub Release body always matches the committed CHANGELOG.
 
 const HEADER_RE = /^##\s*\[([^\]]+)\]\s*[—–-]\s*(.+?)\s*$/;

package/src/release-provenance.mjs

@@ -0,0 +1,115 @@
+import { execFileSync } from 'node:child_process';
+import { cpSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, join } from 'node:path';
+
+const DEPENDENCY_FIELDS = Object.freeze([
+  'dependencies',
+  'devDependencies',
+  'optionalDependencies',
+  'peerDependencies',
+]);
+
+export function parsePackIntegrity(raw) {
+  const text = String(raw || '');
+  const start = text.indexOf('[');
+  const end = text.lastIndexOf(']');
+  if (start < 0 || end < start) return '';
+  try {
+    return String(JSON.parse(text.slice(start, end + 1))[0]?.integrity || '');
+  } catch {
+    return '';
+  }
+}
+
+export function packIntegrityInIsolatedCopy(root, { execute = execFileSync } = {}) {
+  const tempRoot = mkdtempSync(join(tmpdir(), 'wendkeep-release-pack-'));
+  const packageRoot = join(tempRoot, 'package');
+  const ignored = new Set(['.git', 'node_modules']);
+  try {
+    const binding = JSON.parse(readFileSync(join(root, '.wendkeep.json'), 'utf8'));
+    const vault = String(binding.vault || '');
+    if (vault && !vault.includes('/') && !vault.includes('\\')) ignored.add(vault);
+  } catch { /* unbound package: nothing else to exclude */ }
+  try {
+    cpSync(root, packageRoot, {
+      recursive: true,
+      filter(source) {
+        if (source === root) return true;
+        const relativeName = basename(source);
+        return !ignored.has(relativeName);
+      },
+    });
+    const command = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const raw = execute(command, ['pack', '--dry-run', '--json'], {
+      cwd: packageRoot,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return parsePackIntegrity(raw);
+  } finally {
+    rmSync(tempRoot, { recursive: true, force: true });
+  }
+}
+
+export function packageHasSelfDependency(pkg = {}) {
+  const name = String(pkg.name || '');
+  if (!name) return false;
+  return DEPENDENCY_FIELDS.some((field) => Object.hasOwn(pkg[field] || {}, name));
+}
+
+export function evaluateReleaseProvenance({
+  name,
+  version,
+  headCommit,
+  tagCommit = '',
+  publishedIntegrity = '',
+  localIntegrity = '',
+  requirePublished = false,
+} = {}) {
+  const tag = `v${version}`;
+  if (tagCommit && tagCommit !== headCommit) {
+    return {
+      ok: false,
+      code: 'tag_commit_mismatch',
+      message: `${tag} aponta para ${tagCommit.slice(0, 7)}, não para ${headCommit.slice(0, 7)}. Bump a versão antes de alterar a árvore publicada.`,
+    };
+  }
+  if (publishedIntegrity && !tagCommit) {
+    return {
+      ok: false,
+      code: 'published_tag_missing',
+      message: `${name}@${version} está publicado, mas ${tag} não comprova o commit correspondente.`,
+    };
+  }
+  if (requirePublished && !publishedIntegrity) {
+    return {
+      ok: false,
+      code: 'published_artifact_missing',
+      message: `${name}@${version} ainda não possui integridade consultável no npm.`,
+    };
+  }
+  if (publishedIntegrity && localIntegrity && publishedIntegrity !== localIntegrity) {
+    return {
+      ok: false,
+      code: 'tarball_integrity_mismatch',
+      message: `o tarball de ${tag} diverge do artefato publicado no npm.`,
+    };
+  }
+  if (publishedIntegrity && !localIntegrity) {
+    return {
+      ok: false,
+      code: 'local_integrity_missing',
+      message: `não foi possível calcular a integridade do tarball de ${tag}.`,
+    };
+  }
+  return {
+    ok: true,
+    code: publishedIntegrity ? 'verified' : 'release_candidate',
+    name,
+    version,
+    tag,
+    commit: headCommit,
+    integrity: publishedIntegrity || localIntegrity || '',
+  };
+}