wendkeep 0.73.0 → 0.75.0

package/src/doctor.mjs

@@ -5,6 +5,7 @@ import { checkHarness, checkVaultLinks, checkSessionActivity, checkStackedFrontm
 import { runVaultHealth } from '../hooks/vault-health.mjs';
 import { checkSyncDefs } from './sync-defs.mjs';
 import { resolveProjectVault } from './project-vault.mjs';
+import { inspectObserverSqlOutbox } from './observer-sql-publish.mjs';
 
 const healthStatusLabel = (status) => ({
   healthy: 'saudável', warning: 'atenção', degraded: 'degradada', blocked: 'bloqueada', legacy: 'legado',
@@ -155,6 +156,10 @@ export function runDoctor(argv) {
   // 3e. Observabilidade materializada: schema vigente não basta sem frontier + manifest frescos.
   const observability = checkSessionObservability(vaultBase);
   process.stdout.write(`\n${renderSessionObservabilityLines(observability).join('\n')}\n`);
+  const observerOutbox = inspectObserverSqlOutbox(vaultBase);
+  const oldestSeconds = Math.round(observerOutbox.oldest_age_ms / 1000);
+  process.stdout.write(`[observer] outbox SQL: ${observerOutbox.batches} lote(s) · ${observerOutbox.events} evento(s) · ${observerOutbox.bytes} bytes${observerOutbox.batches ? ` · mais antigo: ${oldestSeconds}s` : ''}\n`);
+  if (observerOutbox.batches) process.stdout.write('  → wendkeep observer reconcile --project . (ou inicie o servidor para o hook drenar a fila)\n');
 
   // 4. Sessão: não mente "inativa" quando há atividade recente (workflow/subagente em background).
   const act = checkSessionActivity(vaultBase);

package/src/init.mjs

@@ -323,7 +323,7 @@ const MESSAGES = {
     mcpSkipped: '  [4/5] .mcp.json ignorado (--no-mcp, sem companions MCP)',
     colorsSkipped: '  [5/5] cores ignoradas (--no-colors)',
     colors: (r) => `  [5/5] cores: ${r}`,
-    runtimeIgnore: '  [!] ignore runtimes locais do wendkeep no Git quando o vault for versionado: .brain/.change-* .brain/runtime/flows/ .brain/observer-sql-state.json .brain/observer-sql-outbox/',
+    runtimeIgnore: '  [!] ignore runtimes locais do wendkeep no Git quando o vault for versionado: .brain/.change-* .brain/runtime/flows/ .brain/observer-sql-state.json .brain/observer-sql-outbox/ .brain/observer-sql-publisher.lock',
     merged: 'mesclado', created: 'criado', bakSaved: ', .bak salvo',
     nextSteps: '\nPróximos passos:',
     step1: (v) => `  1. Abra o vault no Obsidian: "Abrir pasta como cofre" -> ${v}`,
@@ -352,7 +352,7 @@ const MESSAGES = {
     mcpSkipped: '  [4/5] .mcp.json skipped (--no-mcp, no MCP companions)',
     colorsSkipped: '  [5/5] colors skipped (--no-colors)',
     colors: (r) => `  [5/5] colors: ${r}`,
-    runtimeIgnore: '  [!] keep local wendkeep runtimes out of Git when the vault is versioned: .brain/.change-* .brain/runtime/flows/ .brain/observer-sql-state.json .brain/observer-sql-outbox/',
+    runtimeIgnore: '  [!] keep local wendkeep runtimes out of Git when the vault is versioned: .brain/.change-* .brain/runtime/flows/ .brain/observer-sql-state.json .brain/observer-sql-outbox/ .brain/observer-sql-publisher.lock',
     merged: 'merged', created: 'created', bakSaved: ', .bak saved',
     nextSteps: '\nNext steps:',
     step1: (v) => `  1. Open the vault in Obsidian: "Open folder as vault" -> ${v}`,

package/src/memory.mjs

@@ -20,6 +20,7 @@ import {
 } from './validate-memory.mjs';
 import { validateCore } from './validate-core.mjs';
 import { checkMemoryBundle } from '../hooks/vault-health.mjs';
+import { scopeForMemoryKey } from '../hooks/memory-scope.mjs';
 
 const BRAIN = '.brain';
 const LEDGER = 'MEMORY_EVENTS.jsonl';
@@ -229,6 +230,92 @@ export function migrateMemory(vault, {
   }
 }
 
+function rescopeEventId(sourceEventId, scope) {
+  return `mem-rescope-${hash(`${sourceEventId}\0${scope.type}\0${scope.id}`).slice(0, 24)}`;
+}
+
+/** Plan an append-only migration without choosing a winner for ambiguous keys. */
+export function planScopedMemoryMigration(vault) {
+  const ledger = readMemoryLedger(vault);
+  if (ledger.status !== 'ok') throw new Error('Ledger corrompido; execute memory repair antes do rescope.');
+  const projection = deriveMemoryProjection(vault, ledger.events);
+  const ambiguous = new Set(projection.candidates.map((candidate) => candidate.record_key || candidate.memory_key));
+  const existingIds = new Set(ledger.events.map((event) => event.event_id));
+  const planned = [];
+
+  for (const [recordKey, record] of Object.entries(projection.records)) {
+    if (ambiguous.has(recordKey) || record.source?.scope) continue;
+    const source = record.source;
+    const sameLegacyKey = ledger.events.filter((event) => (
+      !event.scope && event.memory_key === source.memory_key && !event.rescopes_event_id
+    ));
+    const scope = scopeForMemoryKey(source.memory_key, {
+      ...source,
+      projectId: source.project_id,
+      workSessionId: source.work_session_id,
+      branch: source.value?.branch || source.value?.branch_name,
+      worktreeId: source.value?.worktree_id,
+      repositoryId: source.value?.repository_id,
+    });
+    const eventId = rescopeEventId(source.event_id, scope);
+    if (existingIds.has(eventId)) continue;
+    planned.push({
+      v: 1,
+      event_id: eventId,
+      project_id: source.project_id,
+      memory_key: source.memory_key,
+      scope,
+      operation: 'assert',
+      value: record.value,
+      authority: source.authority,
+      canonical_session_id: source.canonical_session_id || 'memory-rescope',
+      activation_id: source.activation_id || 'memory-rescope',
+      activation_epoch: Number.isInteger(source.activation_epoch) ? source.activation_epoch : 0,
+      turn_sequence: Number.isInteger(source.turn_sequence) ? source.turn_sequence : 0,
+      source_turn_id: source.source_turn_id || 'memory-rescope',
+      observed_at: source.observed_at || new Date(0).toISOString(),
+      evidence: [...new Set([...(source.evidence || []), `memory-rescope:${source.event_id}`])],
+      rescopes_event_id: source.event_id,
+      rescopes_event_ids: sameLegacyKey.map((event) => event.event_id).sort(),
+    });
+  }
+
+  return {
+    status: 'dry-run',
+    ledger_events: ledger.events.length,
+    planned: planned.length,
+    ambiguous: projection.candidates.length,
+    events: planned,
+  };
+}
+
+export function rescopeMemoryEvents(vault, { apply = false } = {}) {
+  projectId(vault);
+  const plan = planScopedMemoryMigration(vault);
+  if (!apply) {
+    return {
+      status: 'dry-run',
+      ledger_events: plan.ledger_events,
+      planned: plan.planned,
+      ambiguous: plan.ambiguous,
+      scopes: plan.events.map((event) => ({
+        event_id: event.event_id, memory_key: event.memory_key, scope: event.scope,
+      })),
+    };
+  }
+  if (!plan.events.length) {
+    return { status: 'unchanged', migrated: 0, ambiguous: plan.ambiguous };
+  }
+  for (const event of plan.events) enqueueMemoryEvent(vault, event);
+  const projection = projectMemoryOutbox(vault);
+  return {
+    status: projection.status === 'projected' ? 'migrated' : projection.status,
+    migrated: plan.events.length,
+    ambiguous: plan.ambiguous,
+    checkpoint: projection.checkpoint || null,
+  };
+}
+
 function readCandidates(vault) {
   const path = brainPath(vault, CANDIDATES);
   const checked = checkedVaultFile(vault, path, 'MEMORY_CANDIDATES.jsonl');
@@ -266,6 +353,7 @@ function sanitizedCandidate(candidate, index) {
     reason: candidate.reason,
     status: candidate.status || 'active',
     memory_key: candidate.memory_key,
+    ...(candidate.scope ? { scope: candidate.scope } : {}),
     event_ids: [...eventIds].sort(lexicalCompare),
   };
 }
@@ -328,6 +416,7 @@ export function listMemoryCandidatesForCuration(vault) {
         reason: safe.reason,
         status: safe.status,
         memory_key: safe.memory_key,
+        ...(safe.scope ? { scope: safe.scope } : {}),
         events: safe.event_ids.map((eventId) => sanitizedCurationEvent(candidate, eventId, index)),
       };
     })
@@ -388,7 +477,7 @@ function promotedSupersedes(vault, candidate, selected) {
   const ledger = readMemoryLedger(vault);
   if (ledger.status !== 'ok') throw new Error('Ledger de memória inválido durante a promoção.');
   const projection = deriveMemoryProjection(vault, ledger.events);
-  const current = projection.records?.[candidate.memory_key]?.source;
+  const current = projection.records?.[candidate.record_key || candidate.memory_key]?.source;
   if (!current?.event_id) return [...memberIds].sort();
   if (memberIds.has(current.event_id)) {
     projection.superseded
@@ -572,6 +661,9 @@ export function decideMemoryCandidate(vault, {
     event_id: `cli-${action}-${hash(`${candidateId}\0${selected?.event_id || ''}`).slice(0, 20)}`,
     project_id: projectId(vault),
     memory_key: action === 'promote' ? candidate.memory_key : `candidate.decision.${candidateId}`,
+    scope: action === 'promote'
+      ? (candidate.scope || selected?.scope || { type: 'project', id: projectId(vault) })
+      : { type: 'project', id: projectId(vault) },
     operation: action === 'promote' && selected ? 'replace' : 'assert',
     value: action === 'promote' ? promotedMemoryValue(selectedValue) : 'rejected',
     authority: 'verified',
@@ -2087,6 +2179,7 @@ export function runMemory(argv) {
       result = listMemoryCandidates(vault, { activeOnly: candidatesArgs.activeOnly });
     }
     else if (sub === 'migrate') result = migrateMemory(vault, { apply: argv.includes('--apply') });
+    else if (sub === 'rescope') result = rescopeMemoryEvents(vault, { apply: argv.includes('--apply') });
     else if (sub === 'repair') result = repairMemory(vault);
     else if (sub === 'reconcile') {
       result = reconcileMemory(vault, {
@@ -2109,7 +2202,7 @@ export function runMemory(argv) {
         action: sub, candidateId: positional, ...(eventId ? { eventId } : {}),
       });
     }
-    else { process.stderr.write('wendkeep memory: use status | candidates [--active] | migrate [--apply] | repair | recover-attempt <session> [--apply] | reconcile <session> --by-session <session> --reason <text> [--apply] | promote <candidate> [--event <event-id>] | reject <candidate>.\n'); process.exitCode = 2; return; }
+    else { process.stderr.write('wendkeep memory: use status | candidates [--active] | curate | migrate [--apply] | rescope [--apply] | repair | recover-attempt <session> [--apply] | reconcile <session> --by-session <session> --reason <text> [--apply] | promote <candidate> [--event <event-id>] | reject <candidate>.\n'); process.exitCode = 2; return; }
     process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
     if (sub === 'status' && argv.includes('--gate')) process.exitCode = result.status === 'blocked' ? 1 : 0;
     else if (sub === 'reconcile' && reconcileArgs.apply) process.exitCode = result.health?.status === 'blocked' ? 1 : 0;

package/src/note.mjs

@@ -17,6 +17,8 @@ import { getLocale } from '../hooks/locale.mjs';
 import { buildManualBugNote, buildManualLearningNote, relinkDerivedNotes } from '../hooks/linked-notes.mjs';
 import { repairStackedFrontmatter } from '../hooks/frontmatter-repair.mjs';
 import { repairDerivedSections } from '../hooks/derived-sections.mjs';
+import { enqueueObserverDocumentChange } from './observer-sql-publish.mjs';
+import { readProjectForValidation } from '../packages/vault/src/validate-memory.mjs';
 
 const TYPES = {
   bug: { folderKey: 'bugs', prefix: 'BUG', build: buildManualBugNote },
@@ -120,6 +122,11 @@ export function runNote(argv) {
   } catch { /* sem sessão ativa — nota nasce sem backlink */ }
 
   writeFileSync(filePath, kind.build(title.trim(), { num, dateStr, sessionRel, localeId: loc.id }), 'utf8');
-  process.stdout.write(`${toVaultRelative(vaultBase, filePath)}\n`);
+  const logicalPath = toVaultRelative(vaultBase, filePath);
+  try {
+    const project = readProjectForValidation(vaultBase);
+    if (project.ok && project.projectId) enqueueObserverDocumentChange({ vaultBase, projectId: project.projectId, logicalPath });
+  } catch { /* Observer é fail-open; reconcile recupera qualquer enqueue perdido. */ }
+  process.stdout.write(`${logicalPath}\n`);
   process.exit(0);
 }

package/src/observer-publish.mjs

@@ -1,8 +1,8 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { buildProjectSnapshot } from './observer-snapshot.mjs';
-import { publishObserverSql } from './observer-sql-publish.mjs';
+import { publishObserverSqlIncremental } from './observer-sql-publish.mjs';
 import { observerAuthHeaders, resolveObserverToken } from './observer-auth.mjs';
+import { readProjectForValidation } from '../packages/vault/src/validate-memory.mjs';
 
 const OUTBOX_REL = join('.brain', 'observer-outbox');
 const REQUEST_TIMEOUT_MS = 500;
@@ -88,51 +88,26 @@ export async function retryObserverOutbox({ vaultBase, url, token = process.env.
 
 export async function publishObserverSnapshot({
   vaultBase,
-  projectRoot,
   url = process.env.WENDKEEP_OBSERVER_URL || '',
   now = new Date(),
   input = {},
   token = process.env.WENDKEEP_OBSERVER_TOKEN || '',
 } = {}) {
   try {
-    const event = buildProjectSnapshot({ vaultBase, projectRoot, now });
-    const sql = await publishObserverSql({
+    const project = readProjectForValidation(vaultBase);
+    if (!project.ok || !project.projectId) throw new Error(project.errors?.join(' ') || 'PROJECT.json inválido.');
+    const sql = await publishObserverSqlIncremental({
       vaultBase,
-      projectId: event.project_id,
+      projectId: project.projectId,
       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, token });
-    // SQL is the live authority. Keep the legacy-shaped `memory` field for
-    // older integrations while reporting the real SQL publication separately.
+    // SQLite is the only live authority. The legacy snapshot store remains
+    // readable solely as a migration source for pre-SQL installations.
     const memory = { ok: sql.ok, queued: sql.queued, changed: sql.changed, pending: sql.pending, authority: 'sqlite' };
-    try {
-      const response = await postSnapshot(url, event, resolveObserverToken(token));
-      return {
-        ok: true,
-        queued: false,
-        hookExitCode: 0,
-        event_id: event.event_id,
-        duplicate: response.duplicate === true,
-        memory,
-        sql,
-      };
-    } catch (error) {
-      queueOutbox(vaultBase, event);
-      return {
-        ok: false,
-        queued: true,
-        hookExitCode: 0,
-        event_id: event.event_id,
-        error: error.message,
-        memory,
-        sql,
-      };
-    }
+    return { ok: sql.ok, queued: sql.queued, hookExitCode: 0, memory, sql };
   } catch (error) {
     return { ok: false, queued: false, hookExitCode: 0, error: error.message };
   }

package/src/observer-server.mjs

@@ -4,17 +4,11 @@ import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { gunzipSync } from 'node:zlib';
 import {
-  appendObserverEvent,
-  getObserverProject,
   listRegisteredObserverProjects,
-  readObserverIndex,
-  registerObserverProject,
+  readObserverIndexSource,
 } from './observer-store.mjs';
 import { MAX_SNAPSHOT_BYTES, validateObserverSnapshot } from './observer-snapshot.mjs';
-import {
-  setMemoryMode,
-  validateMemoryEvent,
-} from './observer-memory.mjs';
+import { validateMemoryEvent } from './observer-memory.mjs';
 import {
   OBSERVER_SQL_FILE,
   OBSERVER_SQL_SCHEMA_VERSION,
@@ -22,6 +16,8 @@ import {
   ingestObserverEvents,
   migrateObserverDatabase,
   readSqlProject,
+  readSqlProjectOverview,
+  readSqlProjectSnapshot,
   listSqlProjects,
   readSqlDocument,
   readSqlSync,
@@ -33,6 +29,7 @@ import {
   readUsageCalls,
   readUsageSummary,
   registerSqlProject,
+  upsertSqlProjectSnapshot,
 } from './observer-sql-store.mjs';
 import { migrateObserverContainerData } from './observer-sql-migrate.mjs';
 
@@ -182,8 +179,8 @@ function ensureSqlProjectRegistration(dataDir, sqlDb, projectId) {
   } catch (error) {
     if (error?.code !== 'project_not_registered') throw error;
   }
-  const legacy = getObserverProject(dataDir, projectId)
-    || listRegisteredObserverProjects(dataDir).find((item) => item.projectId === projectId);
+  const legacy = listRegisteredObserverProjects(dataDir).find((item) => item.projectId === projectId)
+    || readObserverIndexSource(dataDir).projects.find((item) => item.projectId === projectId);
   if (!legacy) return false;
   registerSqlProject(sqlDb, {
     projectId: legacy.projectId,
@@ -234,13 +231,16 @@ export async function startObserverServer({
   const legacyMigration = migrateObserverContainerData(dataDir, { database: sqlDb });
   const registered = [
     ...listRegisteredObserverProjects(dataDir),
-    ...readObserverIndex(dataDir).projects.map((item) => ({
+    ...readObserverIndexSource(dataDir).projects.map((item) => ({
       projectId: item.projectId,
       projectName: item.projectName,
       wendkeepVersion: item.snapshot?.wendkeep_version || '',
     })),
   ];
   for (const project of registered) registerSqlProject(sqlDb, project);
+  for (const project of readObserverIndexSource(dataDir).projects) {
+    if (project.snapshot) upsertSqlProjectSnapshot(sqlDb, project.snapshot);
+  }
   const server = createServer(async (req, res) => {
     try {
       const pathname = new URL(req.url || '/', 'http://127.0.0.1').pathname;
@@ -286,21 +286,11 @@ export async function startObserverServer({
       }
 
       if (parts.length === 2 && req.method === 'GET') {
-        const index = readObserverIndex(dataDir);
-        const legacy = new Map(index.projects.map(({ snapshot, ...summary }) => [summary.projectId, summary]));
-        for (const project of listSqlProjects(sqlDb)) {
-          const current = legacy.get(project.project_id) || {};
-          legacy.set(project.project_id, {
-            ...current,
-            projectId: project.project_id,
-            projectName: current.projectName || project.project_name,
-            wendkeepVersion: current.wendkeepVersion || project.wendkeep_version,
-            registeredAt: current.registeredAt || project.registered_at,
-          });
-        }
         json(res, 200, {
-          schema_version: index.schema_version,
-          projects: [...legacy.values()].sort((a, b) => a.projectId.localeCompare(b.projectId)),
+          schema_version: 1,
+          projects: listSqlProjects(sqlDb)
+            .map((project) => readSqlProjectOverview(sqlDb, project.project_id))
+            .sort((a, b) => a.projectId.localeCompare(b.projectId)),
         });
         return;
       }
@@ -386,11 +376,11 @@ export async function startObserverServer({
           return;
         }
         const body = parseJson(await readBody(req));
-        try {
-          json(res, 200, setMemoryMode(dataDir, projectId, body.mode));
-        } catch (error) {
-          errorResponse(res, 400, error?.code || 'invalid_memory_mode', error?.message || 'modo inválido.');
+        if (body.mode && body.mode !== 'container-authority') {
+          errorResponse(res, 409, 'sql_authority_fixed', 'O Observer SQL é a autoridade única; modos legados são somente fonte de migração.');
+          return;
         }
+        json(res, 200, { ...readSqlSync(sqlDb, projectId), mode: 'container-authority', compatibility_noop: true });
         return;
       }
 
@@ -449,19 +439,8 @@ export async function startObserverServer({
       }
 
       if (parts.length === 3 && req.method === 'GET') {
-        let project = getObserverProject(dataDir, projectId);
-        if (!project) {
-          try {
-            const sqlProject = readSqlProject(sqlDb, projectId);
-            project = {
-              projectId: sqlProject.project_id,
-              projectName: sqlProject.project_name,
-              wendkeepVersion: sqlProject.wendkeep_version,
-              registeredAt: sqlProject.registered_at,
-              eventCount: 0,
-            };
-          } catch { /* handled as not found below */ }
-        }
+        let project;
+        try { project = readSqlProjectOverview(sqlDb, projectId); } catch { /* handled below */ }
         if (!project) {
           errorResponse(res, 404, 'project_not_found', `projeto não encontrado: ${projectId}`);
           return;
@@ -476,7 +455,7 @@ export async function startObserverServer({
           errorResponse(res, 400, 'project_mismatch', 'project_id do corpo não corresponde à rota.');
           return;
         }
-        const result = registerObserverProject(dataDir, {
+        const result = registerSqlProject(sqlDb, {
           projectId,
           projectName: body.project_name,
           wendkeepVersion: body.wendkeep_version,
@@ -485,30 +464,23 @@ export async function startObserverServer({
           errorResponse(res, 400, 'invalid_project', result.errors.join(' '));
           return;
         }
-        registerSqlProject(sqlDb, {
-          projectId,
-          projectName: body.project_name,
-          wendkeepVersion: body.wendkeep_version,
+        json(res, 201, {
+          projectId: result.project.project_id,
+          projectName: result.project.project_name,
+          wendkeepVersion: result.project.wendkeep_version,
+          registeredAt: result.project.registered_at,
         });
-        json(res, 201, result.project);
         return;
       }
 
       if (parts.length === 4 && parts[3] === 'changes' && req.method === 'GET') {
-        const project = getObserverProject(dataDir, projectId);
-        if (!project) {
-          let sqlProject;
-          try { sqlProject = readSqlProject(sqlDb, projectId); } catch (error) {
-            if (error?.code !== 'project_not_registered') throw error;
-          }
-          if (!sqlProject) {
-            errorResponse(res, 404, 'project_not_found', `projeto não encontrado: ${projectId}`);
-            return;
-          }
-          json(res, 200, { project_id: projectId, changes: [] });
+        let snapshot;
+        try { snapshot = readSqlProjectSnapshot(sqlDb, projectId); } catch (error) {
+          if (error?.code !== 'project_not_registered') throw error;
+          errorResponse(res, 404, 'project_not_found', `projeto não encontrado: ${projectId}`);
           return;
         }
-        json(res, 200, { project_id: projectId, changes: project.snapshot?.changes || [] });
+        json(res, 200, { project_id: projectId, changes: snapshot?.changes || [] });
         return;
       }
 
@@ -519,14 +491,17 @@ export async function startObserverServer({
           errorResponse(res, 400, 'invalid_snapshot', validation.errors.join(' '));
           return;
         }
-        const result = appendObserverEvent(dataDir, body);
+        const result = upsertSqlProjectSnapshot(sqlDb, body);
         if (!result.accepted && result.duplicate) {
           json(res, 200, { accepted: false, duplicate: true, event_id: body.event_id });
           return;
         }
         if (!result.accepted) {
-          const unregistered = result.errors.some((item) => /não registrado/.test(item));
-          errorResponse(res, unregistered ? 409 : 400, unregistered ? 'project_not_registered' : 'invalid_event', result.errors.join(' '));
+          if (result.stale) {
+            json(res, 200, { accepted: false, stale: true, event_id: body.event_id });
+            return;
+          }
+          errorResponse(res, 400, 'invalid_event', 'snapshot não aceito.');
           return;
         }
         json(res, 201, { accepted: true, duplicate: false, event_id: body.event_id });

package/src/observer-sql-migrate.mjs

@@ -41,7 +41,7 @@ function walk(root, relativeRoot, out) {
   for (const entry of readdirSync(root, { withFileTypes: true })) {
     const logicalPath = relativeRoot ? `${relativeRoot}/${entry.name}` : entry.name;
     if (entry.name.endsWith('.tmp') || entry.name.endsWith('.lock')
-      || ['observer-memory-outbox', 'observer-outbox', 'observer-sql-outbox', 'observer-sql-state.json', 'observer-memory-state.json'].includes(entry.name)) continue;
+      || ['observer-memory-outbox', 'observer-outbox', 'observer-sql-outbox', 'observer-sql-state.json', 'observer-sql-publisher.lock', 'observer-memory-state.json'].includes(entry.name)) continue;
     const absolute = join(root, entry.name);
     if (entry.isDirectory()) walk(absolute, logicalPath, out);
     else if (entry.isFile()) out.push({ absolute, logicalPath });