@sanqianx/project-knowledge 4.6.1 → 4.8.0

package/_site/lib/data-dir.js

@@ -1,54 +1,54 @@
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const crypto = require('crypto');
-const { LEGACY_ASSETS, assetPath } = require('./legacy-data-manifest');
-const { isEmptyJson } = require('./data-state-classifier');
-
-let _resolved = null;
-
-function resolveDataDirPath(options = {}) {
-  const fromEnv = options.dataDir === undefined ? process.env.KB_DATA_DIR : options.dataDir;
-  const homeDir = options.homeDir || os.homedir();
-  return path.resolve(fromEnv || path.join(homeDir, '.project-knowledge'));
-}
-function ensureDataDir(dataDir = resolveDataDirPath()) { fs.mkdirSync(dataDir, { recursive: true }); return path.resolve(dataDir); }
-function getDataDir() { if (!_resolved) _resolved = resolveDataDirPath(); return _resolved; }
-function _resetCache() { _resolved = null; }
-function fileDigest(filePath) { return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex'); }
-function directoryDigest(root) {
-  const hash = crypto.createHash('sha256');
-  const walk = current => {
-    for (const entry of fs.readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-      const filePath = path.join(current, entry.name);
-      const relative = path.relative(root, filePath).replace(/\\/g, '/');
-      hash.update(`${entry.isDirectory() ? 'd' : 'f'}:${relative}\0`);
-      if (entry.isDirectory()) walk(filePath); else if (entry.isFile()) hash.update(fs.readFileSync(filePath));
-    }
-  };
-  walk(root); return hash.digest('hex');
-}
-function isEmptyAsset(filePath, asset) {
-  if (!fs.existsSync(filePath)) return true;
-  if (asset.kind === 'dir') return fs.readdirSync(filePath).length === 0;
-  if (fs.statSync(filePath).size === 0) return true;
-  if (!filePath.endsWith('.json')) return false;
-  try { const raw = fs.readFileSync(filePath, 'utf8'); return isEmptyJson(JSON.parse(raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw)); } catch { return false; }
-}
-function assetsEqual(source, target, asset) { return asset.kind === 'dir' ? directoryDigest(source) === directoryDigest(target) : fileDigest(source) === fileDigest(target); }
-function copyDir(source, target) {
-  fs.mkdirSync(target, { recursive: true });
-  for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
-    const from = path.join(source, entry.name); const to = path.join(target, entry.name);
-    if (entry.isDirectory()) copyDir(from, to); else if (entry.isFile()) fs.copyFileSync(from, to);
-  }
-}
-
-function migrateFromLegacy({ legacyRoot, logger } = {}) {
-  if (process.env.KB_SKIP_MIGRATION === '1') return { ok: true, migrated: false, reason: 'skipped via KB_SKIP_MIGRATION=1' };
-  if (!legacyRoot || !fs.existsSync(legacyRoot)) return { ok: true, migrated: false, reason: legacyRoot ? 'legacy root does not exist' : 'no legacy root provided' };
-  const dataDir = getDataDir();
-  if (path.resolve(legacyRoot) === dataDir) return { ok: true, migrated: false, reason: 'legacy root equals data dir' };
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const { LEGACY_ASSETS, assetPath } = require('./legacy-data-manifest');
+const { isEmptyJson } = require('./data-state-classifier');
+
+let _resolved = null;
+
+function resolveDataDirPath(options = {}) {
+  const fromEnv = options.dataDir === undefined ? process.env.KB_DATA_DIR : options.dataDir;
+  const homeDir = options.homeDir || os.homedir();
+  return path.resolve(fromEnv || path.join(homeDir, '.project-knowledge'));
+}
+function ensureDataDir(dataDir = resolveDataDirPath()) { fs.mkdirSync(dataDir, { recursive: true }); return path.resolve(dataDir); }
+function getDataDir() { if (!_resolved) _resolved = resolveDataDirPath(); return _resolved; }
+function _resetCache() { _resolved = null; }
+function fileDigest(filePath) { return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex'); }
+function directoryDigest(root) {
+  const hash = crypto.createHash('sha256');
+  const walk = current => {
+    for (const entry of fs.readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const filePath = path.join(current, entry.name);
+      const relative = path.relative(root, filePath).replace(/\\/g, '/');
+      hash.update(`${entry.isDirectory() ? 'd' : 'f'}:${relative}\0`);
+      if (entry.isDirectory()) walk(filePath); else if (entry.isFile()) hash.update(fs.readFileSync(filePath));
+    }
+  };
+  walk(root); return hash.digest('hex');
+}
+function isEmptyAsset(filePath, asset) {
+  if (!fs.existsSync(filePath)) return true;
+  if (asset.kind === 'dir') return fs.readdirSync(filePath).length === 0;
+  if (fs.statSync(filePath).size === 0) return true;
+  if (!filePath.endsWith('.json')) return false;
+  try { const raw = fs.readFileSync(filePath, 'utf8'); return isEmptyJson(JSON.parse(raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw)); } catch { return false; }
+}
+function assetsEqual(source, target, asset) { return asset.kind === 'dir' ? directoryDigest(source) === directoryDigest(target) : fileDigest(source) === fileDigest(target); }
+function copyDir(source, target) {
+  fs.mkdirSync(target, { recursive: true });
+  for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
+    const from = path.join(source, entry.name); const to = path.join(target, entry.name);
+    if (entry.isDirectory()) copyDir(from, to); else if (entry.isFile()) fs.copyFileSync(from, to);
+  }
+}
+
+function migrateFromLegacy({ legacyRoot, logger } = {}) {
+  if (process.env.KB_SKIP_MIGRATION === '1') return { ok: true, migrated: false, reason: 'skipped via KB_SKIP_MIGRATION=1' };
+  if (!legacyRoot || !fs.existsSync(legacyRoot)) return { ok: true, migrated: false, reason: legacyRoot ? 'legacy root does not exist' : 'no legacy root provided' };
+  const dataDir = getDataDir();
+  if (path.resolve(legacyRoot) === dataDir) return { ok: true, migrated: false, reason: 'legacy root equals data dir' };
   // Packaged application roots may include empty scaffolding such as
   // `projects/`. It is not user data and must never conflict with populated
   // runtime data during startup relocation.
@@ -56,26 +56,26 @@ function migrateFromLegacy({ legacyRoot, logger } = {}) {
     const source = assetPath(legacyRoot, asset);
     return fs.existsSync(source) && !isEmptyAsset(source, asset);
   });
-  if (!sources.length) return { ok: true, migrated: false, reason: 'no legacy assets found' };
-  const conflicts = [];
-  for (const asset of sources) {
-    const source = assetPath(legacyRoot, asset); const target = assetPath(dataDir, asset, 'target');
-    if (fs.existsSync(target) && !isEmptyAsset(target, asset) && !assetsEqual(source, target, asset)) conflicts.push(asset.target);
-  }
-  if (conflicts.length) return { ok: false, migrated: false, requiresManualRecovery: true, reason: 'legacy-data-conflict', conflicts, source: legacyRoot, target: dataDir };
-  ensureDataDir(dataDir);
-  const result = { ok: true, migrated: false, files: 0, dirs: 0, source: legacyRoot, target: dataDir };
-  try {
-    for (const asset of sources) {
-      const source = assetPath(legacyRoot, asset); const target = assetPath(dataDir, asset, 'target');
-      if (fs.existsSync(target) && assetsEqual(source, target, asset)) continue;
-      if (asset.kind === 'dir') { if (fs.existsSync(target)) fs.rmSync(target, { recursive: true, force: true }); copyDir(source, target); result.dirs++; }
-      else { fs.mkdirSync(path.dirname(target), { recursive: true }); fs.copyFileSync(source, target); result.files++; }
-    }
-    result.migrated = result.files > 0 || result.dirs > 0;
-    if (result.migrated && logger) logger(`migrated runtime data to ${dataDir} (${result.files} files, ${result.dirs} dirs from ${legacyRoot})`);
-    return result;
-  } catch (error) { return { ...result, ok: false, error: `failed to relocate legacy runtime data: ${error.message}` }; }
-}
-
-module.exports = { resolveDataDirPath, ensureDataDir, getDataDir, migrateFromLegacy, LEGACY_ASSETS, _resetCache };
+  if (!sources.length) return { ok: true, migrated: false, reason: 'no legacy assets found' };
+  const conflicts = [];
+  for (const asset of sources) {
+    const source = assetPath(legacyRoot, asset); const target = assetPath(dataDir, asset, 'target');
+    if (fs.existsSync(target) && !isEmptyAsset(target, asset) && !assetsEqual(source, target, asset)) conflicts.push(asset.target);
+  }
+  if (conflicts.length) return { ok: false, migrated: false, requiresManualRecovery: true, reason: 'legacy-data-conflict', conflicts, source: legacyRoot, target: dataDir };
+  ensureDataDir(dataDir);
+  const result = { ok: true, migrated: false, files: 0, dirs: 0, source: legacyRoot, target: dataDir };
+  try {
+    for (const asset of sources) {
+      const source = assetPath(legacyRoot, asset); const target = assetPath(dataDir, asset, 'target');
+      if (fs.existsSync(target) && assetsEqual(source, target, asset)) continue;
+      if (asset.kind === 'dir') { if (fs.existsSync(target)) fs.rmSync(target, { recursive: true, force: true }); copyDir(source, target); result.dirs++; }
+      else { fs.mkdirSync(path.dirname(target), { recursive: true }); fs.copyFileSync(source, target); result.files++; }
+    }
+    result.migrated = result.files > 0 || result.dirs > 0;
+    if (result.migrated && logger) logger(`migrated runtime data to ${dataDir} (${result.files} files, ${result.dirs} dirs from ${legacyRoot})`);
+    return result;
+  } catch (error) { return { ...result, ok: false, error: `failed to relocate legacy runtime data: ${error.message}` }; }
+}
+
+module.exports = { resolveDataDirPath, ensureDataDir, getDataDir, migrateFromLegacy, LEGACY_ASSETS, _resetCache };

package/_site/lib/data-state-classifier.js

@@ -1,40 +1,40 @@
-const fs = require('fs');
-const path = require('path');
-const { SCHEMAS } = require('./contracts');
-const { LEGACY_ASSETS, assetPath } = require('./legacy-data-manifest');
-
-const STATES = Object.freeze({ FRESH: 'FRESH', LEGACY: 'LEGACY', V2_VALID: 'V2_VALID', MIGRATION_INCOMPLETE: 'MIGRATION_INCOMPLETE', CONFLICT: 'CONFLICT', CORRUPT: 'CORRUPT' });
-
-function readJson(filePath) {
-  if (!fs.existsSync(filePath)) return { exists: false, value: null };
-  try { const raw = fs.readFileSync(filePath, 'utf8'); return { exists: true, value: JSON.parse(raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw) }; }
-  catch (error) { return { exists: true, error }; }
-}
-function isEmptyJson(value) {
-  if (value == null || typeof value !== 'object') return false;
-  if (Array.isArray(value)) return value.length === 0;
-  if (value.schema === SCHEMAS.projectRegistry) return Array.isArray(value.projectOrder) && value.projectOrder.length === 0;
-  return Object.keys(value).length === 0;
-}
-function hasRecovery(root) { const recovery = path.join(root, 'recovery'); return fs.existsSync(recovery) && fs.statSync(recovery).isDirectory() && fs.readdirSync(recovery).length > 0; }
-function classifyDataState(root) {
-  const projects = readJson(path.join(root, 'projects.json'));
-  const settings = readJson(path.join(root, 'settings.json'));
-  if (projects.error || settings.error) return { state: STATES.CORRUPT, projects, settings };
-  // Logs and hook diagnostics can be created before startup classification;
-  // alone they are not user configuration evidence and must not turn a clean
-  // install into an impossible legacy migration.
-  const hasLegacyAssets = LEGACY_ASSETS.some(asset => asset.authority !== 'history' && fs.existsSync(assetPath(root, asset)));
-  const isV2 = projects.value && projects.value.schema === SCHEMAS.projectRegistry && projects.value.schemaVersion === 2;
-  const settingsV2 = settings.value && settings.value.schema === SCHEMAS.settings && settings.value.schemaVersion === 2;
-  if (isV2 && settingsV2) return { state: STATES.V2_VALID, projects, settings, hasLegacyAssets };
-  // A failed migration may have written default v2 settings before activation.
-  // A non-v2 projects registry remains authoritative legacy evidence and is
-  // eligible for a controlled retry; it must never be classified as Fresh.
-  if (projects.exists && !isV2 && hasLegacyAssets) return { state: STATES.LEGACY, projects, settings, hasLegacyAssets };
-  if (isV2 || settingsV2 || hasRecovery(root)) return { state: STATES.MIGRATION_INCOMPLETE, projects, settings, hasLegacyAssets };
-  if (hasLegacyAssets) return { state: STATES.LEGACY, projects, settings, hasLegacyAssets };
-  return { state: STATES.FRESH, projects, settings, hasLegacyAssets };
-}
-
-module.exports = { STATES, readJson, isEmptyJson, classifyDataState };
+const fs = require('fs');
+const path = require('path');
+const { SCHEMAS } = require('./contracts');
+const { LEGACY_ASSETS, assetPath } = require('./legacy-data-manifest');
+
+const STATES = Object.freeze({ FRESH: 'FRESH', LEGACY: 'LEGACY', V2_VALID: 'V2_VALID', MIGRATION_INCOMPLETE: 'MIGRATION_INCOMPLETE', CONFLICT: 'CONFLICT', CORRUPT: 'CORRUPT' });
+
+function readJson(filePath) {
+  if (!fs.existsSync(filePath)) return { exists: false, value: null };
+  try { const raw = fs.readFileSync(filePath, 'utf8'); return { exists: true, value: JSON.parse(raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw) }; }
+  catch (error) { return { exists: true, error }; }
+}
+function isEmptyJson(value) {
+  if (value == null || typeof value !== 'object') return false;
+  if (Array.isArray(value)) return value.length === 0;
+  if (value.schema === SCHEMAS.projectRegistry) return Array.isArray(value.projectOrder) && value.projectOrder.length === 0;
+  return Object.keys(value).length === 0;
+}
+function hasRecovery(root) { const recovery = path.join(root, 'recovery'); return fs.existsSync(recovery) && fs.statSync(recovery).isDirectory() && fs.readdirSync(recovery).length > 0; }
+function classifyDataState(root) {
+  const projects = readJson(path.join(root, 'projects.json'));
+  const settings = readJson(path.join(root, 'settings.json'));
+  if (projects.error || settings.error) return { state: STATES.CORRUPT, projects, settings };
+  // Logs and hook diagnostics can be created before startup classification;
+  // alone they are not user configuration evidence and must not turn a clean
+  // install into an impossible legacy migration.
+  const hasLegacyAssets = LEGACY_ASSETS.some(asset => asset.authority !== 'history' && fs.existsSync(assetPath(root, asset)));
+  const isV2 = projects.value && projects.value.schema === SCHEMAS.projectRegistry && projects.value.schemaVersion === 2;
+  const settingsV2 = settings.value && settings.value.schema === SCHEMAS.settings && settings.value.schemaVersion === 2;
+  if (isV2 && settingsV2) return { state: STATES.V2_VALID, projects, settings, hasLegacyAssets };
+  // A failed migration may have written default v2 settings before activation.
+  // A non-v2 projects registry remains authoritative legacy evidence and is
+  // eligible for a controlled retry; it must never be classified as Fresh.
+  if (projects.exists && !isV2 && hasLegacyAssets) return { state: STATES.LEGACY, projects, settings, hasLegacyAssets };
+  if (isV2 || settingsV2 || hasRecovery(root)) return { state: STATES.MIGRATION_INCOMPLETE, projects, settings, hasLegacyAssets };
+  if (hasLegacyAssets) return { state: STATES.LEGACY, projects, settings, hasLegacyAssets };
+  return { state: STATES.FRESH, projects, settings, hasLegacyAssets };
+}
+
+module.exports = { STATES, readJson, isEmptyJson, classifyDataState };

package/_site/lib/engine-cutover.js

@@ -0,0 +1,97 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const AtomicFile = require('./atomic-file');
+const { DomainError } = require('./contracts');
+const { execGit } = require('./git-runner');
+
+function engineRegistration(runtime, projectId) {
+  const config = runtime.projectStore.readConfig(projectId);
+  const state = runtime.projectStore.readState(projectId);
+  return { projectId, name: config.displayName || projectId, repoPath: config.repoPath, knowledgePath: config.knowledgePath, knowledgeLanguage: config.knowledgeLanguage || 'zh-CN', brainId: config.brainId || 'brain-default', domainId: config.domainId || null, repoIdentity: config.repoIdentity, trackingStartCommit: state.trackingStartCommit || null, conversationBaselineCursor: state.conversationBaselineCursor || 0, conversationBaselineCursors: state.conversationBaselineCursors || {}, journalId: state.modules?.eventBridge?.projectId || null, vectorProjectId: state.modules?.vectorHub?.projectName || projectId };
+}
+
+async function prepareEngineCutover(runtime) {
+  const markerPath = runtime.layout.getRuntimePath('engine-cutover.json');
+  if (fs.existsSync(markerPath)) return AtomicFile.readJsonStrict(markerPath);
+  if (runtime.activeTasks.size || runtime.indexService.pending?.size) throw new DomainError('PROJECT_BUSY', '请等待旧维护任务结束后再升级。', { status: 409 });
+  const migrationId = `cutover-${crypto.randomUUID()}`;
+  const backup = runtime.layout.getRecoveryPath('engine-cutover', migrationId);
+  fs.mkdirSync(backup, { recursive: true, mode: 0o700 });
+  function copy(source, target) {
+    if (!fs.existsSync(source)) return;
+    const stat = fs.lstatSync(source);
+    if (stat.isSymbolicLink() || !runtime.layout.isPathInside(runtime.dataPath, source, { realpath: true }) || !runtime.layout.isPathInside(backup, target, { realpath: true })) throw new DomainError('PATH_OUTSIDE_ROOT', '升级备份包含不安全路径。', { status: 409 });
+    if (stat.isDirectory()) { for (const name of fs.readdirSync(source)) copy(path.join(source, name), path.join(target, name)); }
+    else if (stat.isFile()) AtomicFile.writeFileAtomic(target, fs.readFileSync(source));
+  }
+  for (const name of ['settings.json', 'projects.json']) copy(path.join(runtime.dataPath, name), path.join(backup, name));
+  for (const name of ['runs', 'claims', 'promotions', 'processed-commits']) copy(runtime.layout.getRuntimePath(name), path.join(backup, 'runtime', name));
+  copy(runtime.layout.getRecoveryPath('promotions'), path.join(backup, 'recovery', 'promotions'));
+  const projects = runtime.registryStore.listIds().map(projectId => {
+    const state = runtime.projectStore.readState(projectId);
+    copy(runtime.layout.getProjectMetadataDir(projectId), path.join(backup, 'projects', projectId));
+    return { registration: engineRegistration(runtime, projectId), runtime: { lastAnalyzedCommit: state.lastAnalyzedCommit, conversationBaselineCursor: state.conversationBaselineCursor, conversationBaselineCursors: state.conversationBaselineCursors || {}, analysis: state.analysis, index: { dirty: state.index.dirty } } };
+  });
+  const snapshot = { migrationId, sourceDataDir: runtime.dataPath, projects, createdAt: new Date().toISOString() };
+  AtomicFile.writeJsonAtomic(path.join(backup, 'snapshot.json'), snapshot);
+  const marker = { schema: 'engine-cutover/v1', migrationId, phase: 'prepared', backupPath: backup, createdAt: snapshot.createdAt };
+  AtomicFile.writeJsonAtomic(markerPath, marker);
+  return marker;
+}
+
+async function finishEngineCutover(runtime) {
+  if (runtime.analysisOwner === 'legacy' || runtime.cutoverRunning) return;
+  runtime.cutoverRunning = true;
+  const markerPath = runtime.layout.getRuntimePath('engine-cutover.json');
+  try {
+    const marker = await prepareEngineCutover(runtime);
+    const bridge = runtime.moduleBridge;
+    const headers = { 'Content-Type': 'application/json', Authorization: `Bearer ${bridge.runtimeToken}` };
+    if (!marker.profilesMigrated) {
+      const settings = runtime.settingsStore.read();
+      if (settings.ai.profiles.length) {
+        const imported = await bridge._fetch(`${bridge.terminalUrl}/api/claude-workbench/v1/internal/import-profiles`, { method: 'POST', headers, body: JSON.stringify({ migrationId: marker.migrationId, profiles: settings.ai.profiles, defaultProfileId: settings.ai.defaultProfileId }) });
+        if (!imported.ok) throw new Error('PROFILE_MIGRATION_PENDING');
+        // Protected rollback copies retain the old secrets; active settings only
+        // retain a reference to the Workbench configuration from this point.
+        await runtime.settingsStore.updatePatch({ ai: { profiles: [], defaultProfileId: null }, modelConfigurationRef: 'workbench' });
+      }
+      marker.profilesMigrated = true; AtomicFile.writeJsonAtomic(markerPath, marker);
+    }
+    if (marker.phase !== 'complete') {
+      const snapshot = AtomicFile.readJsonStrict(path.join(marker.backupPath, 'snapshot.json'));
+      const migrated = await bridge._fetch(`${bridge.engineUrl}/api/migrate`, { method: 'POST', headers, body: JSON.stringify(snapshot), timeoutMs: 60000 });
+      if (!migrated.ok) throw new Error('MIGRATION_PENDING');
+      for (const id of runtime.registryStore.listIds()) {
+        const config = runtime.projectStore.readConfig(id);
+        const modules = await bridge.registerProjectLinks({ projectId: id, name: config.displayName, workspacePath: config.repoPath, knowledgePath: config.knowledgePath });
+        if (!modules.engine.ok || !modules.eventBridge.ok) throw new Error('WIRING_PENDING');
+      }
+      marker.phase = 'complete'; marker.completedAt = new Date().toISOString();
+      AtomicFile.writeJsonAtomic(markerPath, marker);
+    }
+    await bridge.syncEngineConfiguration();
+    const activated = await bridge._fetch(`${bridge.engineUrl}/api/control`, { method: 'POST', headers, body: JSON.stringify({ enabled: true }) });
+    if (!activated.ok) throw new Error('ACTIVATION_PENDING');
+    runtime.analysisOwner = 'engine';
+    runtime.ownership = { owner: 'engine', ready: true, backupPath: marker.backupPath };
+  } catch {
+    runtime.ownership = { owner: 'engine', ready: false, message: '引擎接管待恢复；旧分析已停用，提交证据与升级备份保留。' };
+  } finally { runtime.cutoverRunning = false; }
+}
+
+async function forwardCommitToBridge(runtime, event) {
+  const config = runtime.projectStore.readConfig(event.projectId);
+  if (!runtime.layout.pathsEqual(config.repoPath, event.repoRoot) || !/^[a-f0-9]{40}$/i.test(event.head || '')) throw new DomainError('INVALID_ARGUMENT', '提交通知与项目绑定不匹配。');
+  const exists = await execGit(config.repoPath, ['cat-file', '-e', `${event.head}^{commit}`]);
+  if (!exists.ok) throw new DomainError('INVALID_ARGUMENT', '提交不属于当前仓库。');
+  // Even legacy notifications enter the same journal; they never execute analysis.
+  const identity = await runtime.bridgeAdapter.resolveRepoIdentity(config.repoPath);
+  const result = await runtime.bridgeAdapter.appendCommitBoundary({ projectId: event.projectId, repoIdentity: identity.repoIdentity, commitSha: event.head, branch: event.branch || null, operationId: event.operationId });
+  if (result.status !== 'captured') throw new DomainError('MODULE_UNREACHABLE', '事件记录失败，请恢复事件模块后重试。', { status: 503 });
+  runtime.moduleBridge._fetch(`${runtime.moduleBridge.engineUrl}/api/bridge/notify`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: '{}' }).catch(() => {});
+  return { journalSequence: result.boundary?.journalSequence || result.boundary?.sequence };
+}
+
+module.exports = { prepareEngineCutover, finishEngineCutover, forwardCommitToBridge, engineRegistration };