create-walle 0.10.2 → 0.10.3

package/template/coding-task-manager/lib/hosted-sync-worker.js

@@ -6,6 +6,11 @@ const { MAX_BATCH_BYTES, jsonByteLength, batchEntriesByBytes } = require('./sync
 // WP-0 (remote-machine-hub-sessions-2026-10-22.html D-4): the machine registry's liveness probe
 // rides THIS tick rather than owning a timer, so the hub keeps exactly one outbound cadence.
 const machineRegistry = require('./machine-registry');
+// WP-3 (docs/shared-memory-every-machine-2026-10-31.html D-1/D-2, §6.6): the v2 brain replica rides
+// the SAME tick for the SAME members — membership is pairing (the registry), so `CTM_SYNC_PEERS`
+// plays no part in the memory domains. The round is a leaf here (machine-registry only), so this
+// edge adds no lib/** cycle.
+const memorySync = require('./memory-sync');
 
 const DEFAULT_INTERVAL_MS = 15000;
 const DEFAULT_GAP_BACKOFF_MS = 5 * 60 * 1000;
@@ -445,269 +450,6 @@ async function pushSyncPeerOnce(options = {}) {
   };
 }
 
-// ---------------------------------------------------------------------------
-// WP-5 (multi-machine login/resume sync §6.6, R-10/R-11, S-15..S-18): brain
-// replication rides the SAME tick as the CTM legs but never the same failure
-// domain — a brain leg that fails (peer carries no walle url, Wall-E is down,
-// the peer 401s) must leave the CTM verdict of that tick alone and is reported
-// per peer in status().brain.
-//
-//   pull: peer  /api/walle/sync/outbox -> LOCAL Wall-E /api/walle/sync/apply
-//   push: local /api/walle/sync/outbox -> peer        /api/walle/sync/apply
-//
-// The cursors are the settings rows `sync.brain_pull.<peer>` / `sync.brain_push.<peer>`.
-// A brain cursor is deliberately NOT recorded through `markSyncOutboxDeliveredThrough`:
-// that mutation also stamps the GLOBAL `sync_outbox.delivered_at`, which would hide CTM
-// rows from the other peers (F4).
-// ---------------------------------------------------------------------------
-
-const DEFAULT_BRAIN_BATCH_LIMIT = 200;
-
-// peer.walleUrl is the explicit form (the JSON form of CTM_SYNC_PEERS can carry it);
-// otherwise Wall-E is CTM's port + 1 — 3456/3457 on the laptop, 3556/3557 through the
-// SSH forwards.
-function _wallePeerUrl(peer = {}, walle = {}) {
-  const explicit = _string(walle.peerUrl || peer.walleUrl || peer.walle_url, 1000).replace(/\/+$/, '');
-  if (explicit) return explicit;
-  const baseUrl = _string(peer.url, 1000).replace(/\/+$/, '');
-  if (!baseUrl) return '';
-  try {
-    const parsed = new URL(baseUrl);
-    const port = Number(parsed.port || (parsed.protocol === 'https:' ? 443 : 80));
-    if (!Number.isFinite(port) || port <= 0) return '';
-    parsed.port = String(port + 1);
-    return parsed.toString().replace(/\/+$/, '');
-  } catch {
-    return '';
-  }
-}
-
-// WALL_E_PORT is the knob the rest of CTM resolves the local Wall-E with; an explicit
-// '0' means "this host has no local Wall-E" and disables the local half of the brain pair.
-function _localWalleUrl(env = {}, walle = {}) {
-  const explicit = _string(walle.localUrl, 1000).replace(/\/+$/, '');
-  if (explicit) return explicit;
-  const raw = env.WALL_E_PORT;
-  if (raw !== undefined && String(raw).trim() === '0') return '';
-  return `http://127.0.0.1:${Number(raw || 0) || 3457}`;
-}
-
-function _brainHeaders(env) {
-  return { ..._authHeaders(env), Accept: 'application/json', 'Content-Type': 'application/json' };
-}
-
-function _brainCursorKey(direction, peerKey) {
-  return `sync.brain_${direction === 'push' ? 'push' : 'pull'}.${_string(peerKey, 160)}`;
-}
-
-function _readBrainCursor(db, key) {
-  if (!db || typeof db.getSetting !== 'function') return 0;
-  try {
-    return Math.max(0, Number(db.getSetting(key, 0)) || 0);
-  } catch {
-    return 0;
-  }
-}
-
-// Best-effort: a cursor that fails to persist costs a re-send next tick, and the
-// operation_id keyed by the receiver makes the re-send idempotent.
-async function _writeBrainCursor(db, key, seq) {
-  if (!db || typeof db.setSetting !== 'function') return false;
-  try {
-    await dispatchOwnerMutation(db, 'setSetting', [key, String(seq)], 'hosted sync brain cursor');
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function _brainBatchLimit(env = {}, options = {}, walle = {}) {
-  // No new flag: the brain legs page with the same CTM_SYNC_BATCH_LIMIT knob the
-  // CTM legs already use (default 200 rows for brain, see DEFAULT_BRAIN_BATCH_LIMIT).
-  const raw = env.CTM_SYNC_BATCH_LIMIT || walle.limit || options.brainLimit || DEFAULT_BRAIN_BATCH_LIMIT;
-  return Math.max(1, Math.min(1000, Number(raw) || DEFAULT_BRAIN_BATCH_LIMIT));
-}
-
-function _brainMaxBatches(env = {}, options = {}) {
-  return Math.max(1, Math.min(100, Number(env.CTM_SYNC_MAX_BATCHES || options.maxBatches || 20) || 20));
-}
-
-// The copy loop both directions share: page from `fromUrl`, hand the page to `toUrl`,
-// advance the cursor only as far as the receiver accepted.
-async function _copyBrainEntries({ fromUrl, toUrl, sourceInstanceId, headers, fetchImpl, db, cursorKey, limit, maxBatches }) {
-  let afterSeq = _readBrainCursor(db, cursorKey);
-  let moved = 0;
-  let batches = 0;
-  let parked = false;
-  // Follow-up #16: the source's history-backfill progress and live backlog, as of the last page read.
-  let backfill = null;
-  let pending = null;
-  while (batches < maxBatches) {
-    const page = await _jsonFetch(fetchImpl, `${fromUrl}/api/walle/sync/outbox?after_seq=${afterSeq}&limit=${limit}`, { headers });
-    if (page.backfill && typeof page.backfill === 'object') backfill = page.backfill;
-    if (Number.isFinite(Number(page.pending))) pending = Number(page.pending);
-    const entries = Array.isArray(page.entries) ? page.entries : [];
-    if (!entries.length) break;
-    batches += 1;
-    const tailSeq = entries.reduce((max, entry) => Math.max(max, Number(entry.seq) || 0), 0);
-    const applied = await _jsonFetch(fetchImpl, `${toUrl}/api/walle/sync/apply`, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({ sourceInstanceId, entries }),
-    });
-    const next = Math.max(afterSeq, Number(applied.lastSeq ?? page.lastSeq ?? 0) || 0);
-    // The receiver reports how far it got (its lastSeq). A receiver that stops short of
-    // the batch tail is defensive only — the Wall-E apply route settles every row it is
-    // given — so the cursor never steps past what the receiver acknowledged.
-    if (next <= afterSeq) {
-      parked = true;
-      break;
-    }
-    await _writeBrainCursor(db, cursorKey, next);
-    moved += entries.filter((entry) => Number(entry.seq) <= next).length;
-    afterSeq = next;
-    if (next < tailSeq) {
-      parked = true;
-      break;
-    }
-    if (entries.length < limit) break;
-  }
-  return { moved, batches, lastSeq: afterSeq, parked, backfill, pending };
-}
-
-async function pullBrainOnce(options = {}) {
-  const env = options.env || process.env;
-  const peer = options.peer || {};
-  const walle = options.walle || {};
-  const db = options.db;
-  const fetchImpl = options.fetch || global.fetch;
-  if (!db) throw new Error('db required');
-  if (typeof fetchImpl !== 'function') throw new Error('fetch required');
-  const peerUrl = _wallePeerUrl(peer, walle);
-  if (!peerUrl) throw new Error('peer_walle_url_required');
-  const localUrl = _localWalleUrl(env, walle);
-  if (!localUrl) throw new Error('local_walle_url_required');
-  const peerKey = _peerIdentity(peer) || _string(peer.url, 1000);
-  // The source identity the LOCAL Wall-E files this peer under is the peer's own id,
-  // so the local brain_sync_hwm row names the peer that produced the rows.
-  const copy = await _copyBrainEntries({
-    fromUrl: peerUrl,
-    toUrl: localUrl,
-    sourceInstanceId: peerKey,
-    headers: _brainHeaders(env),
-    fetchImpl,
-    db,
-    cursorKey: _brainCursorKey('pull', peerKey),
-    limit: _brainBatchLimit(env, options, walle),
-    maxBatches: _brainMaxBatches(env, options),
-  });
-  return {
-    ok: true,
-    peer: peerKey,
-    direction: 'pull',
-    walleUrl: peerUrl,
-    fetched: copy.moved,
-    batches: copy.batches,
-    lastSeq: copy.lastSeq,
-    parked: copy.parked,
-    backfill: copy.backfill,
-    pending: copy.pending,
-  };
-}
-
-async function pushBrainOnce(options = {}) {
-  const env = options.env || process.env;
-  const peer = options.peer || {};
-  const walle = options.walle || {};
-  const db = options.db;
-  const fetchImpl = options.fetch || global.fetch;
-  if (!db) throw new Error('db required');
-  if (typeof fetchImpl !== 'function') throw new Error('fetch required');
-  const peerUrl = _wallePeerUrl(peer, walle);
-  if (!peerUrl) throw new Error('peer_walle_url_required');
-  const localUrl = _localWalleUrl(env, walle);
-  if (!localUrl) throw new Error('local_walle_url_required');
-  const localInstanceId = _localInstanceId(db, env);
-  if (!localInstanceId) throw new Error('sync_local_instance_required');
-  const peerKey = _peerIdentity(peer) || _string(peer.url, 1000);
-  const copy = await _copyBrainEntries({
-    fromUrl: localUrl,
-    toUrl: peerUrl,
-    sourceInstanceId: localInstanceId,
-    headers: _brainHeaders(env),
-    fetchImpl,
-    db,
-    cursorKey: _brainCursorKey('push', peerKey),
-    limit: _brainBatchLimit(env, options, walle),
-    maxBatches: _brainMaxBatches(env, options),
-  });
-  return {
-    ok: true,
-    peer: peerKey,
-    direction: 'push',
-    walleUrl: peerUrl,
-    pushed: copy.moved,
-    batches: copy.batches,
-    lastSeq: copy.lastSeq,
-    parked: copy.parked,
-    backfill: copy.backfill,
-    pending: copy.pending,
-  };
-}
-
-// Runs both directions for one peer, isolating each from the other and from the CTM
-// legs: the return value is always a report, never a throw.
-async function syncPeerBrainOnce(options = {}) {
-  const peer = options.peer || {};
-  const peerKey = _peerIdentity(peer) || _string(peer.url, 1000);
-  const report = { peer: peerKey, ok: true, pull: null, push: null };
-  for (const [direction, fn] of [['pull', pullBrainOnce], ['push', pushBrainOnce]]) {
-    try {
-      report[direction] = await fn(options);
-    } catch (err) {
-      report[direction] = {
-        ok: false,
-        peer: peerKey,
-        direction,
-        error: err.message || String(err),
-        status: Number(err.status || 0) || null,
-      };
-      report.ok = false;
-    }
-  }
-  return report;
-}
-
-// Follow-up #17: local outbox retention. Called only after a tick in which EVERY configured peer's
-// brain push leg ended ok; `pushReports` are those legs' reports. The push leg is what delivers
-// every local outbox row to each peer, so the prune point is the minimum persisted push cursor
-// (`sync.brain_push.<peer>`) — a peer's pull of our outbox is redundant delivery and does not
-// count. One bounded call per tick (the Wall-E side deletes at most 5,000 rows and says `more`).
-async function pruneLocalBrainOutbox(options = {}) {
-  const env = options.env || process.env;
-  const walle = options.walle || {};
-  const db = options.db;
-  const fetchImpl = options.fetch || global.fetch;
-  const pushReports = Array.isArray(options.pushReports) ? options.pushReports : [];
-  if (!pushReports.length) return { ok: true, skipped: 'no_peers', throughSeq: 0, pruned: 0 };
-  const localUrl = _localWalleUrl(env, walle);
-  if (!localUrl) return { ok: true, skipped: 'no_local_walle', throughSeq: 0, pruned: 0 };
-  const throughSeq = Math.min(...pushReports.map((push) => _readBrainCursor(db, _brainCursorKey('push', push.peer))));
-  if (!(throughSeq > 0)) return { ok: true, skipped: 'nothing_delivered', throughSeq: 0, pruned: 0 };
-  const res = await _jsonFetch(fetchImpl, `${localUrl}/api/walle/sync/prune`, {
-    method: 'POST',
-    headers: _brainHeaders(env),
-    body: JSON.stringify({ throughSeq }),
-  });
-  return {
-    ok: true,
-    throughSeq,
-    pruned: Number(res.pruned || 0) || 0,
-    more: res.more === true,
-    appliedPruned: Number(res.appliedPruned || 0) || 0,
-  };
-}
-
 function _failureDelayMs(env, options, intervalMs, attempt) {
   const base = Math.max(1000, Number(env.CTM_SYNC_FAILURE_BACKOFF_MS || options.failureBackoffMs || intervalMs) || intervalMs);
   const max = Math.max(base, Number(env.CTM_SYNC_FAILURE_BACKOFF_MAX_MS || options.failureBackoffMaxMs || 60 * 1000) || 60 * 1000);
@@ -719,7 +461,7 @@ function _failureDelayMs(env, options, intervalMs, attempt) {
 // WP-0 (remote-machine-hub-sessions-2026-10-22.html §8): the machine-registry sweep, plus the WP-6
 // live-catalog refresh riding it. Shared by the sync tick and the machines-only loop below; a
 // probe failure is reported, never thrown, and never folded into a sync verdict.
-async function _sweepMachines({ db, fetchImpl, env, peerHeadersFor, selfInstanceId }) {
+async function _sweepMachines({ db, fetchImpl, env, peerHeadersFor, selfInstanceId, walleClient }) {
   try {
     const machineProbe = await machineRegistry.probeMachinesOnce({ fetchImpl }, {
       db,
@@ -737,7 +479,37 @@ async function _sweepMachines({ db, fetchImpl, env, peerHeadersFor, selfInstance
     try {
       require('./remote-machine-catalog').refreshAll({ db }).catch(() => { /* expected: refreshAll resolves its own per-machine failures */ });
     } catch { /* expected: a catalog fault must never fail a machine probe sweep */ }
-    return machineProbe;
+    // WP-2 (docs/fleet-auto-update-pooled-machines-2026-10-26.html §8 WP-2, §9 S-8): the fleet
+    // reconciler rides the same sweep — deliberately NOT awaited, because its bundle POST may take up
+    // to FLEET_SEND_TIMEOUT_MS and the tick's cadence must not be held hostage by one box. Only when
+    // the server injected a real per-target credential: the fixed env-token fallback cannot update a
+    // box (a pool member authenticates with the pool secret), so firing it would only produce refusals.
+    if (typeof peerHeadersFor === 'function') {
+      try {
+        require('./fleet-hub').reconcileFleetOnce({ db, fetchImpl, peerHeadersFor, dataDir: require('./data-dir').getDataDir() })
+          .catch((err) => console.warn(`[fleet] reconcile failed: ${err.message || err}`)); // REPORT: the next sweep retries
+      } catch (err) {
+        console.warn(`[fleet] reconcile not started: ${err.message || err}`); // REPORT: a wiring fault must never fail a probe sweep
+      }
+    }
+    // WP-3 (D-1/D-2, §6.6): the v2 brain replica rides the SAME sweep, for the SAME registry members
+    // and on the SAME per-target credential — `CTM_SYNC_PEERS` is irrelevant to the memory domains,
+    // so this runs in BOTH the peers loop and the machines-only loop. AWAITED (the probe read is
+    // already done by now, and the tick owns the cadence) but its failure is REPORTED into the sweep
+    // result as `brainSync`, never folded into the probe verdict.
+    let brainSync = null;
+    try {
+      brainSync = await memorySync.runBrainMemberRound({
+        db, fetchImpl, env, peerHeadersFor, selfInstanceId,
+        // Tests inject a stub; production omits it and lib/memory-sync.js takes the co-located
+        // lib/walle-client (the hub's own loopback Wall-E).
+        ...(walleClient ? { walle: walleClient } : {}),
+      });
+    } catch (brainErr) {
+      // REPORT: surfaced as status().machines.brainSync; the next tick retries with backoff.
+      brainSync = { ok: false, error: brainErr.message || String(brainErr) };
+    }
+    return { ...machineProbe, brainSync };
   } catch (probeErr) {
     // REPORT: surfaced as status().machines / lastResult.machineProbe; the next tick retries.
     return { ok: false, error: probeErr.message || String(probeErr) };
@@ -749,7 +521,7 @@ async function _sweepMachines({ db, fetchImpl, env, peerHeadersFor, selfInstance
 // surfaces read that as "sync off"), but the registered machines are still probed on the same
 // cadence — otherwise a machine's health would freeze at whatever registration recorded and a
 // stopped box would read "reachable" forever. Zero registered machines => zero fetches (AC-0d).
-function _startMachinesOnlyLoop({ db, fetchImpl, intervalMs, env, peerHeadersFor, selfInstanceId }) {
+function _startMachinesOnlyLoop({ db, fetchImpl, intervalMs, env, peerHeadersFor, selfInstanceId, walleClient }) {
   let running = false;
   let stopped = false;
   let machineProbe = null;
@@ -757,7 +529,7 @@ function _startMachinesOnlyLoop({ db, fetchImpl, intervalMs, env, peerHeadersFor
     if (running || stopped) return;
     running = true;
     try {
-      machineProbe = await _sweepMachines({ db, fetchImpl, env, peerHeadersFor, selfInstanceId });
+      machineProbe = await _sweepMachines({ db, fetchImpl, env, peerHeadersFor, selfInstanceId, walleClient });
     } finally {
       running = false;
     }
@@ -786,9 +558,9 @@ function startHostedSyncWorker(options = {}) {
   const fetchImpl = options.fetch || global.fetch;
   const intervalMs = Math.max(1000, Number(env.CTM_SYNC_POLL_INTERVAL_MS || options.intervalMs || DEFAULT_INTERVAL_MS) || DEFAULT_INTERVAL_MS);
   // R-12: "peers configured" is the gate (there is no separate enable flag any more).
-  if (!syncEnabledByConfig(env)) return _startMachinesOnlyLoop({ db, fetchImpl, intervalMs, env, peerHeadersFor: options.peerHeadersFor, selfInstanceId: options.selfInstanceId });
+  if (!syncEnabledByConfig(env)) return _startMachinesOnlyLoop({ db, fetchImpl, intervalMs, env, peerHeadersFor: options.peerHeadersFor, selfInstanceId: options.selfInstanceId, walleClient: options.walleClient });
   const peers = options.peers || parseSyncPeers(env);
-  if (!peers.length) return _startMachinesOnlyLoop({ db, fetchImpl, intervalMs, env, peerHeadersFor: options.peerHeadersFor, selfInstanceId: options.selfInstanceId });
+  if (!peers.length) return _startMachinesOnlyLoop({ db, fetchImpl, intervalMs, env, peerHeadersFor: options.peerHeadersFor, selfInstanceId: options.selfInstanceId, walleClient: options.walleClient });
   // WP-0 (§8 "seed-from-CTM_SYNC_PEERS"): this worker starts exactly once per boot, which makes
   // it the hub's seeding hook. Every configured peer that is not yet in the registry becomes a
   // DISABLED machines row — env is a seed, never an authority, so nothing is auto-enabled or
@@ -813,15 +585,6 @@ function startHostedSyncWorker(options = {}) {
     const prev = pushState.get(peerKey) || { peer: peerKey, lastAttemptAt: null, lastOkAt: null, lastDeliveredSeq: 0, lastError: null };
     pushState.set(peerKey, { ...prev, ...patch });
   };
-  // WP-5: the brain pair (memories/knowledge/entities/people) keeps its own state so a
-  // failure there is visible in status().brain without ever marking the CTM legs failed.
-  const brainState = new Map();
-  const _recordBrain = (peerKey, patch) => {
-    const prev = brainState.get(peerKey) || { peer: peerKey, lastAttemptAt: null, lastOkAt: null, lastSeq: 0, lastError: null, pull: null, push: null, backfill: null };
-    brainState.set(peerKey, { ...prev, ...patch });
-  };
-  // Follow-up #17: the last local outbox prune (null until one is attempted).
-  let brainPrune = null;
   // WP-0: the last machine-registry sweep (null until one is attempted). Reported, never folded
   // into the sync verdict.
   let machineProbe = null;
@@ -872,26 +635,6 @@ function startHostedSyncWorker(options = {}) {
               lastError: pushErr.message || String(pushErr),
             });
           }
-          // WP-5: the brain legs run in the same tick and are independent of the CTM push
-          // outcome above — `result.ok` is only ever set false by the CTM legs, so a failed
-          // brain leg is reported (status().brain) without failing the CTM leg's verdict.
-          const brain = await syncPeerBrainOnce({ peer, db, env, fetch: fetchImpl, ...(options.brain || {}) });
-          result.brain = brain;
-          const attemptAt = new Date().toISOString();
-          _recordBrain(peerKey, {
-            lastAttemptAt: attemptAt,
-            lastOkAt: brain.ok ? attemptAt : (brainState.get(peerKey)?.lastOkAt || null),
-            lastSeq: Math.max(Number(brain.pull?.lastSeq || 0) || 0, Number(brain.push?.lastSeq || 0) || 0),
-            lastError: brain.ok ? null : (brain.pull?.error || brain.push?.error || 'brain_sync_failed'),
-            pull: brain.pull,
-            push: brain.push,
-            // Follow-up #16: history-backfill progress per side — `local` is this host's brain (read
-            // by the push leg), `peer` the peer's brain (read by the pull leg).
-            backfill: {
-              local: brain.push?.backfill || brainState.get(peerKey)?.backfill?.local || null,
-              peer: brain.pull?.backfill || brainState.get(peerKey)?.backfill?.peer || null,
-            },
-          });
         }
         results.push(result);
         if (result.ok === false) {
@@ -904,27 +647,13 @@ function startHostedSyncWorker(options = {}) {
           nextPollAt.delete(peerKey);
         }
       }
-      // Follow-up #17: prune the local outbox only when every configured peer's brain push leg ran
-      // and ended ok in THIS tick (a skipped/backed-off peer has no push leg, so it blocks the
-      // prune). A prune failure is reported and never fails the tick.
-      const pushReports = results.map((r) => r?.brain?.push);
-      let pruneReport = null;
-      if (peers.length && pushReports.length === peers.length && pushReports.every((push) => push && push.ok === true)) {
-        try {
-          pruneReport = await pruneLocalBrainOutbox({ db, env, fetch: fetchImpl, pushReports, ...(options.brain || {}) });
-        } catch (pruneErr) {
-          // REPORT: surfaced as status().brainPrune / lastResult.brainPrune; the rows stay and the next tick retries.
-          pruneReport = { ok: false, error: pruneErr.message || String(pruneErr), status: Number(pruneErr.status || 0) || null };
-        }
-        brainPrune = { ...pruneReport, lastAttemptAt: new Date().toISOString() };
-      }
       // WP-0 (remote-machine-hub-sessions-2026-10-22.html §8): the machine-registry sweep rides
       // this tick, AFTER the peer legs and independent of them — it shares the cadence (D-4) but
       // not the verdict, so a probe failure never marks a sync leg failed. Zero registered
       // machines ⇒ zero fetches (AC-0d), so an instance with no machines performs no extra
       // network work per tick.
-      machineProbe = await _sweepMachines({ db, fetchImpl, env, peerHeadersFor: options.peerHeadersFor, selfInstanceId: options.selfInstanceId });
-      lastResult = { ok: results.every((r) => r.ok !== false), checkedAt: new Date().toISOString(), results, brainPrune: pruneReport, machineProbe };
+      machineProbe = await _sweepMachines({ db, fetchImpl, env, peerHeadersFor: options.peerHeadersFor, selfInstanceId: options.selfInstanceId, walleClient: options.walleClient });
+      lastResult = { ok: results.every((r) => r.ok !== false), checkedAt: new Date().toISOString(), results, machineProbe };
     } catch (err) {
       lastResult = { ok: false, checkedAt: new Date().toISOString(), error: err.message || String(err) };
     } finally {
@@ -950,8 +679,6 @@ function startHostedSyncWorker(options = {}) {
         running,
         lastResult,
         push: [...pushState.values()],
-        brain: [...brainState.values()],
-        brainPrune,
         machines: machineProbe,
         machineSeed,
       };
@@ -964,9 +691,5 @@ module.exports = {
   syncEnabledByConfig,
   pollSyncPeerOnce,
   pushSyncPeerOnce,
-  pullBrainOnce,
-  pushBrainOnce,
-  syncPeerBrainOnce,
-  pruneLocalBrainOutbox,
   startHostedSyncWorker,
 };