create-walle 0.10.2 → 0.10.3

package/template/wall-e/brain/deterministic-id.js

@@ -0,0 +1,51 @@
+'use strict';
+
+// WP-0 (docs/shared-memory-every-machine-2026-10-31.html §5 D-4, §6.2): source-derived
+// identity. Two machines that ingest the SAME source item must mint the SAME row id —
+// dedupe on (source, source_id) is a unique index (brain.js:917-924), so with random
+// uuids the second machine's copy is silently dropped on apply while every knowledge row
+// naming the first machine's id points at nothing (measured: one iMessage under two ids,
+// design §1.3/§2 I-3). A memory therefore derives its id from (source, source_id) and a
+// newly created entity from (lower(canonical_name), entity_type).
+//
+// RFC 9562 §5.5 UUIDv5 over node:crypto's sha1 — no `uuid` package is installed in this
+// repo and this is the whole of what is needed from one.
+//
+// The two namespace constants are FIXED FOREVER. Changing one forks the identity space of
+// every replica: a machine still running the old constant keeps minting ids the others can
+// never dedupe against, which is exactly the divergence this file exists to end.
+// tests/deterministic-id.test.js pins the literals.
+
+const crypto = require('node:crypto');
+
+const MEMORY_NS = '6f1c2b7e-3d4a-5e8f-9a0b-1c2d3e4f5a6b';
+const ENTITY_NS = '9b8a7c6d-5e4f-5a3b-8c2d-1e0f9a8b7c6d';
+
+// namespace: a UUID string (its 16 bytes are the hash prefix). name: any value — it is
+// UTF-8 encoded, so callers can pass a NUL-joined composite without escaping.
+function uuidv5(namespace, name) {
+  const ns = Buffer.from(String(namespace).replace(/-/g, ''), 'hex');
+  const hash = crypto.createHash('sha1')
+    .update(ns)
+    .update(Buffer.from(String(name), 'utf8'))
+    .digest();
+  // Set the version nibble (5) and the RFC 4122 variant (10xx), then format 8-4-4-4-12.
+  hash[6] = (hash[6] & 0x0f) | 0x50;
+  hash[8] = (hash[8] & 0x3f) | 0x80;
+  const h = hash.subarray(0, 16).toString('hex');
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
+}
+
+// The NUL separator makes the composite unambiguous: ("a", "b\0c") and ("a\0b", "c") hash
+// differently, so two different (source, source_id) pairs can never collide by concatenation.
+function deterministicMemoryId(source, sourceId) {
+  return uuidv5(MEMORY_NS, `${source}\u0000${sourceId}`);
+}
+
+// The name is lower-cased and the type is optional so that the two producers that spell the
+// same entity differently ("Ada Example"/"ada example", missing entity_type) converge on one row.
+function deterministicEntityId(canonicalName, entityType) {
+  return uuidv5(ENTITY_NS, `${String(canonicalName).toLowerCase()}\u0000${entityType || ''}`);
+}
+
+module.exports = { uuidv5, deterministicMemoryId, deterministicEntityId, MEMORY_NS, ENTITY_NS };

package/template/wall-e/brain/memories.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { randomUUID: uuidv4 } = require('node:crypto');
+const { randomUUID: uuidv4 } = require('node:crypto'); const { deterministicMemoryId } = require('./deterministic-id');
 const conversationProjectionV2 = require('../memory/conversation-projection-v2');
 const { EXTRACTABLE_PREDICATE, EXTRACTABLE_PARAMS } = require('./knowledge-categories');
 
@@ -64,7 +64,7 @@ function insertMemory(mem) {
   const _effectiveRaw = mem.content_raw || mem.content;
   const _rawToStore = _effectiveRaw === cleanContent ? null : _effectiveRaw;
 
-  const id = uuidv4();
+  const id = mem.source_id ? deterministicMemoryId(mem.source, mem.source_id) : uuidv4(); // shared-memory D-4: same item, same id on every machine
   const ingestedAt = String(mem.ingested_at || new Date().toISOString());
   const triggerHint = _memoryRecallHint(mem.metadata);
   // surface-redesign WP-0: occurred_at_ms is the sortable form of `timestamp` (which

package/template/wall-e/brain/migrations.js

@@ -2517,14 +2517,13 @@ const MIGRATIONS = {
   97: (d) => {
     d.exec(DROP_RETIRED_TABLES_SQL);
   },
-  // Migration 98 (multi-machine WP-5): brain_outbox + brain_sync_hwm +
-  // brain_sync_applied + brain_row_clock and the eight capture triggers — see
+  // Migration 98 (multi-machine WP-5): brain_row_clock and the capture triggers — see
   // brain/schema.js's ensureBrainSyncSchema for the why (R-10 LWW clock, R-11
   // host-local tables excluded, the brain_sync_applying sentinel) and why the DDL
   // text lives in schema.js: createTables() (the runner baseline) executes the same
   // string, the ladder never runs on a fresh DB, and reaching back here from
   // schema.js would make the two modules a require cycle (round3 walle-scc-size).
-  // Additive and idempotent.
+  // Additive and idempotent. Since WP-6 (105) this body creates brain_row_clock alone.
   98: (d) => { require('./schema').ensureBrainSyncSchema(d); },
   // Migration 99 (surface-redesign follow-up FU-6, D-26 tail): retire the last
   // remnant of the deleted task engine. `task_events` is the event child of
@@ -2552,8 +2551,44 @@ const MIGRATIONS = {
   // same text, same reason (tests-integration/migration-baseline-parity.test.js). Additive and
   // idempotent: the ALTERs are `PRAGMA table_info`-guarded, the index is `IF NOT EXISTS`.
   101: (d) => { require('./helper-rules-schema').ensureHelperRulesSchemaV2(d); },
+  // Migration 102 (opencode-lead-and-delegate-model-selection-2026-10-28.html §6.4, §8 WP-4, S-13):
+  // delegate_model_prefs.scope_key admits `default:opencode`, the per-agent default rung of an
+  // OpenCode lead's delegate ladder. SQLite cannot ALTER a CHECK, so an EXISTING table is REBUILT
+  // (see the helper below): every column and every row, one transaction. model-identity-migration.js
+  // carries the widened CHECK for a fresh brain (the createTaskLedgerTables baseline); this is the
+  // forward step a database created before it needs. Idempotent by inspection of the SCHEMA, never
+  // by the version counter, so both a re-run and ensureSchema's invariant rewind are no-ops.
+  102: (d) => { widenDelegateModelPrefsScope(d, 102, ['claude', 'codex'], 'opencode'); },
+  // Migration 103 (deepseek-harness-acp-agent-2026-10-28.html WP-10, D-24): same rebuild, admits `default:dsh`.
+  103: (d) => { widenDelegateModelPrefsScope(d, 103, ['claude', 'codex', 'opencode'], 'dsh'); },
+  104: (d) => { require('./schema').ensureBrainSyncSchemaV2(d); }, // shared-memory WP-0 §6.1: v2 clock (origin_seq/deleted, 12 triggers, host-local vv tables); idempotent by inspection
+  105: (d) => { require('./schema').ensureBrainSyncSchemaV3(d); }, // shared-memory WP-6b: drop the v1 outbox tables + the outbox INSERT from the 8 ai/au triggers (idempotent by inspection)
 };
 
+// Migrations 102/103's body: rebuild from the table's OWN stored DDL with only the scope_key CHECK
+// widened, so nothing can drift. Absent or already-widened table -> 0 and no DDL; an unknown DDL throws.
+function widenDelegateModelPrefsScope(d, version, narrow, agent) {
+  const row = d.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'delegate_model_prefs'").get();
+  if (!row || typeof row.sql !== 'string') return 0;
+  // Probe the WIDENED literal ('default:<agent>'): a test for `'<agent>'` never matches (a colon precedes it).
+  if (row.sql.includes(`'default:${agent}'`)) return 0;
+  const keys = narrow.map((name) => `'default:${name}'`);
+  const widened = row.sql.replace(
+    new RegExp(`scope_key\\s+IN\\s*\\(\\s*${keys.join('\\s*,\\s*')}\\s*\\)`),
+    `scope_key IN (${[...keys, `'default:${agent}'`].join(',')})`,
+  );
+  if (widened === row.sql) throw new Error(`migration ${version}: delegate_model_prefs.scope_key has no ${narrow.join('/')} CHECK to widen`);
+  const staging = `delegate_model_prefs__v${version - 1}`;
+  // The canonical 12-step SQLite rebuild: rename, recreate, copy every row and column, drop.
+  d.transaction(() => {
+    d.exec(`ALTER TABLE delegate_model_prefs RENAME TO ${staging}`);
+    d.exec(widened);
+    d.exec(`INSERT INTO delegate_model_prefs SELECT * FROM ${staging}`);
+    d.exec(`DROP TABLE ${staging}`);
+  })();
+  return 1;
+}
+
 // --- Migration 91 (surface-redesign WP-3) ---------------------------------
 // The Jobs record: ONE table pair replacing the two legacy engines. Column
 // notes from the design doc (§6.1), kept here rather than as SQL comments so
@@ -2947,9 +2982,8 @@ assertMigrationRegistry('walle', MIGRATIONS);
 }
 
 // The WP-5 capture DDL is exported by brain/schema.js as BRAIN_SYNC_DDL /
-// ensureBrainSyncSchema; the ladder reaches it lazily in migration 89 above so
-// this module never requires schema.js at load time (schema.js -> migrations.js
-// would otherwise be the only require cycle in the wall-e graph).
+// ensureBrainSyncSchema (98) / V2 (104) / V3 (105); the ladder reaches them lazily above so
+// this module never requires schema.js at load time (that would be the only require cycle in wall-e).
 
 module.exports = createMigrationsModule;
 // Statics on the factory, for callers that hold the module rather than a built

package/template/wall-e/brain/model-identity-migration.js

@@ -74,7 +74,7 @@ function ensureModelIdentitySchema(d) {
       PRIMARY KEY (identity_id, harness)
     );
     CREATE TABLE IF NOT EXISTS delegate_model_prefs (
-      scope_key    TEXT PRIMARY KEY CHECK (scope_key IN ('default:claude','default:codex') OR scope_key LIKE 'session:_%'),
+      scope_key    TEXT PRIMARY KEY CHECK (scope_key IN ('default:claude','default:codex','default:opencode','default:dsh') OR scope_key LIKE 'session:_%'),
       lane         TEXT NOT NULL CHECK (lane IN ('native','routed','inherit')),
       model        TEXT NOT NULL DEFAULT '',
       identity_id  TEXT NOT NULL DEFAULT '',

package/template/wall-e/brain/owner-call-whitelist.js

@@ -29,13 +29,28 @@ const BRAIN_CALL_WHITELIST = new Set([
   // entry, not a bare brain.js export — see that map below and
   // wall-e/loops/brain-custom-writes.js for what it does and why.
   'commitThinkExtraction',
-  // multi-machine WP-5: the brain sync pair (wall-e/http/sync-api.js) — the outbox
-  // page read and the one-transaction batch apply both run on the OWNER's connection
-  // (the apply creates a connection-scoped TEMP sentinel the capture triggers test).
-  'brainSyncOutbox',
-  'brainSyncApplyEntries',
-  // follow-up #17: outbox retention (POST /api/walle/sync/prune) — a bounded delete, same owner.
-  'brainSyncPrune',
+  // WP-0 §6.3: the v2 clock seed walk (wall-e/brain/brain-sync-store.js seedClockPage) — one
+  // bounded page per call, on the owner's connection, driven by the brain-clock-seed job. Same
+  // CUSTOM_BRAIN_CALLS pattern as the other v2 sync ops — see loops/brain-custom-writes.js.
+  // (WP-6/migration 104 retired the v1 trio brainSyncOutbox/brainSyncApplyEntries/brainSyncPrune.)
+  'brainSyncClockSeed',
+  // WP-1 §6.4: the v2 change feed (wall-e/brain/brain-sync-v2.js, served by the
+  // /api/walle/sync/v2/* routes). The apply is the one that must run on the OWNER's connection —
+  // it opens an IMMEDIATE transaction with the connection-scoped TEMP sentinel the capture
+  // triggers test; the rest are reads and one small hub-bookkeeping write.
+  'brainSyncV2Vector',
+  'brainSyncV2Changes',
+  'brainSyncV2Apply',
+  'brainSyncV2MemberVector',
+  'brainSyncV2PruneTombstones',
+  'brainSyncV2Digest',
+  // WP-4 §6.7: the join trio + the import job's step. The snapshot runs where the backup API
+  // runs (the owner's connection); the import records and then imports only the four replicated
+  // tables on the owner, with the sentinel on; the step is what the brain-join-import job drives.
+  'brainSyncV2JoinSnapshot',
+  'brainSyncV2JoinImport',
+  'brainSyncV2JoinStatus',
+  'brainSyncV2JoinStep',
   // WP-2b: same CUSTOM_BRAIN_CALLS pattern for loops/backfill.js — three
   // per-row transaction batches, see brain-custom-writes.js.
   'backfillClassifyBatch',
@@ -151,6 +166,7 @@ const BRAIN_CALL_WHITELIST = new Set([
   'setKv',
   'setCurrentLocation',
   'setBackupDir',
+  'setBackupRetentionDays',
   'setDefaultProviderSelection',
   'setModelDefault',
   'setTaskModelDefault',

package/template/wall-e/brain/schema.js

@@ -1173,13 +1173,15 @@ function createTables() {
   ensureConnectionTables(db); // WP-5a: same constraint — every exec must precede ensureMemorySourceUniqueIndexOnly()
   ensureSlackCursorTables(db); // WP-6a: same constraint — every exec must precede ensureMemorySourceUniqueIndexOnly()
   ensureChatThreadTables(db); // WP-7a: same constraint — every exec must precede ensureMemorySourceUniqueIndexOnly()
-  // WP-5 (multi-machine brain sync): brain_outbox/brain_sync_hwm/brain_sync_applied/
-  // brain_row_clock + the eight capture triggers. Migration 89 owns the same DDL
-  // for existing databases, but the ladder never runs on a fresh install
-  // (baseline()+stamp) — and createTables() also runs unconditionally on every
-  // non-fresh boot — so the baseline has to carry it too (T-2 AC-2a parity). It is
+  // WP-5 (multi-machine brain sync): brain_row_clock + the 12 capture triggers, now at v2
+  // (origin_seq/deleted, the four AFTER DELETE triggers — WP-0) and with the v1 outbox
+  // transport retired (migration 105, WP-6). Migration 98 owns the clock DDL, 104 the v2
+  // upgrade and 105 the v1 teardown for existing databases, but the ladder never runs on a
+  // fresh install (baseline()+stamp) — and createTables() also runs unconditionally on every
+  // non-fresh boot — so the baseline has to carry all three too (T-2 AC-2a parity). It is
   // part of this function's OWN DDL, so it runs before the delegated helpers.
-  ensureBrainSyncSchema(db);
+  ensureBrainSyncSchemaV2(db);
+  ensureBrainSyncSchemaV3(db);
   ensureMemorySourceUniqueIndexOnly(db);
   createTaskLedgerTables(db);
 }
@@ -1379,12 +1381,10 @@ createSchemaModule.ensureTurnLedgerSchema = ensureTurnLedgerSchema;
 module.exports = createSchemaModule;
 
 // Migration 89 (multi-machine WP-5, design doc §6.6 / R-10 / R-11): the brain
-// outbox. The four replicated tables (memories / knowledge / entities / people)
-// gain an AFTER INSERT / AFTER UPDATE trigger each, capturing the row into
-// brain_outbox in the writer's own transaction; the apply path (the
-// /api/walle/sync/apply route) creates a connection-scoped TEMP TABLE
-// `brain_sync_applying` for the duration of a batch and every trigger skips while
-// it exists, so an applied row never re-enqueues.
+// outbox. WP-6 (migration 105) retired the outbox transport — the three v1 tables
+// (brain_outbox / brain_sync_hwm / brain_sync_applied) and the ai/au outbox INSERT
+// are gone — but this module still owns the one object both paths need: the LWW clock,
+// and the text below is what createTables() and migration 98 execute.
 //
 // The DDL text lives in schema.js (a sanctioned DDL file) because createTables()
 // executes it on the fresh path; a brain/ module would mean schema.js ->
@@ -1392,62 +1392,29 @@ module.exports = createSchemaModule;
 //
 // LWW clock: only `entities` has an `updated_at` column, so instead of adding an
 // `updated_at` to memories/knowledge/people (which every existing writer and the
-// PG shadow would then have to stamp) the triggers also maintain
+// PG shadow would then have to stamp) the capture triggers maintain
 // `brain_row_clock(table_name, row_id, updated_at, origin_instance_id)` — one
 // clock row per replicated row, the WP-5 brief's option (b); '' = this host.
+// The eight v1 capture triggers and the `brain_sync_applying` sentinel they tested lived
+// here too; the capture triggers are now the 12 v2 ones (brain/brain-sync-v2-schema.js),
+// which also own the sentinel's test.
 //
 // Host-local tables (loop_checkpoints, channel_outbound_locks, kv_store, owner,
 // activity_log, runtime_events, *_fts, memory_index, embeddings) get NO trigger:
 // R-11 is enforced by construction, not by a filter.
-// Built once per process: the same string is executed by migration 89 (existing
+// Built once per process: the same string is executed by migration 98 (existing
 // databases, via the ladder) AND by createTables() (the runner baseline — fresh
 // installs run ZERO migration bodies, and every non-fresh boot re-runs
-// createTables(), so this is what makes the capture schema exist on both paths;
-// see tests-integration/migration-baseline-parity.test.js T-2 AC-2a).
+// createTables(), so this is what makes the clock exist on both paths;
+// see tests-integration/migration-baseline-parity.test.js T-2 AC-2a). v2's
+// applyBrainSyncSchemaV2 indexes brain_row_clock, so it must be created first.
+//
+// WP-6 (migration 105) is why this string no longer creates brain_outbox /
+// brain_sync_hwm / brain_sync_applied and no longer installs the eight v1 capture
+// triggers: a fresh brain must never carry either. brain_row_clock's CREATE TABLE text
+// is deliberately unchanged, so fresh and migrated sqlite_master stay byte-equal.
 function buildBrainSyncDdl() {
-  // SQLite refuses `temp.sqlite_master` inside a trigger ("cannot reference
-  // objects in database temp") and a bare sqlite_temp_master resolves to
-  // main.sqlite_temp_master; pragma_table_list does list temp tables.
-  const skipWhen = "NOT EXISTS (SELECT 1 FROM pragma_table_list WHERE name = 'brain_sync_applying')";
-  // The triggers reference NO column but `new.id`: the payload is built at READ time from the
-  // live row (wall-e/http/sync-api.js listBrainOutbox via brain/brain-sync-store.js), so the
-  // outbox never holds a second copy of a memory's bytes (the prompt purge sanitizer stays
-  // exact) and a column added or dropped by a later migration never breaks a trigger
-  // (`ALTER TABLE ... DROP COLUMN` fails while any trigger names the column). The UPDATE
-  // triggers watch only columns present in the earliest baseline of each table — never one a
-  // migration added (memories.consolidated_at / trigger_hint / embed_failed_count,
-  // knowledge.metadata_json) — and never the read-stamp columns (access_count,
-  // last_accessed), so a recall is not a replication event.
-  const watchColumns = {
-    memories: ['content', 'content_raw', 'subject', 'metadata', 'importance', 'archived_at'],
-    knowledge: ['category', 'subject', 'predicate', 'object', 'confidence', 'source_memory_ids', 'status', 'superseded_by', 'valid_from', 'valid_to', 'last_confirmed', 'times_confirmed'],
-    entities: ['canonical_name', 'entity_type', 'aliases', 'properties', 'updated_at'],
-    people: ['name', 'aliases', 'identities', 'relationship', 'trust_level', 'trust_reason', 'interaction_freq', 'last_interaction', 'notes'],
-  };
-  let sql = `
-    CREATE TABLE IF NOT EXISTS brain_outbox (
-      seq INTEGER PRIMARY KEY AUTOINCREMENT,
-      operation_id TEXT NOT NULL UNIQUE,
-      table_name TEXT NOT NULL CHECK (table_name IN ('memories', 'knowledge', 'entities', 'people')),
-      row_id TEXT NOT NULL,
-      op TEXT NOT NULL CHECK (op IN ('upsert', 'delete')),
-      updated_at TEXT NOT NULL,
-      origin_instance_id TEXT NOT NULL DEFAULT '',
-      created_at TEXT NOT NULL DEFAULT (datetime('now')),
-      delivered_at TEXT NOT NULL DEFAULT ''
-    );
-    CREATE INDEX IF NOT EXISTS idx_brain_outbox_seq ON brain_outbox(seq);
-    CREATE TABLE IF NOT EXISTS brain_sync_hwm (
-      source_instance_id TEXT PRIMARY KEY,
-      last_seq INTEGER NOT NULL DEFAULT 0,
-      updated_at TEXT NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS brain_sync_applied (
-      source_instance_id TEXT NOT NULL,
-      operation_id TEXT NOT NULL,
-      applied_at TEXT NOT NULL,
-      PRIMARY KEY (source_instance_id, operation_id)
-    );
+  return `
     CREATE TABLE IF NOT EXISTS brain_row_clock (
       table_name TEXT NOT NULL,
       row_id TEXT NOT NULL,
@@ -1456,41 +1423,32 @@ function buildBrainSyncDdl() {
       PRIMARY KEY (table_name, row_id)
     );
   `;
-  // origin_instance_id '' in the clock and the outbox means "this host": a trigger cannot know
-  // the instance id cheaply, so the reader (and the LWW compare) substitutes the local id.
-  for (const table of Object.keys(watchColumns)) {
-    const watch = watchColumns[table].map((column) => `"${column}"`).join(', ');
-    const body = `
-      INSERT INTO brain_row_clock (table_name, row_id, updated_at, origin_instance_id)
-      VALUES ('${table}', new.id, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'), '')
-      ON CONFLICT(table_name, row_id) DO UPDATE SET
-        updated_at = excluded.updated_at,
-        origin_instance_id = '';
-      INSERT INTO brain_outbox (operation_id, table_name, row_id, op, updated_at)
-      VALUES (lower(hex(randomblob(16))), '${table}', new.id, 'upsert',
-              (SELECT updated_at FROM brain_row_clock WHERE table_name = '${table}' AND row_id = new.id));`;
-    sql += `
-      CREATE TRIGGER IF NOT EXISTS brain_outbox_${table}_ai AFTER INSERT ON ${table}
-      WHEN ${skipWhen}
-      BEGIN${body}
-      END;
-      CREATE TRIGGER IF NOT EXISTS brain_outbox_${table}_au AFTER UPDATE OF ${watch} ON ${table}
-      WHEN ${skipWhen}
-      BEGIN${body}
-      END;
-    `;
-  }
-  return sql;
 }
 
 const BRAIN_SYNC_DDL = buildBrainSyncDdl();
 
-// Migration 89's body, and the reason the DDL above is a plain string with two
+// Migration 98's body, and the reason the DDL above is a plain string with two
 // callers rather than an exec-in-place: the ladder never runs on a fresh DB.
 function ensureBrainSyncSchema(d) {
   d.exec(BRAIN_SYNC_DDL);
 }
 
+// Migration 104's body (WP-0, shared-memory-every-machine-2026-10-31.html §6.1): the v1
+// brain_row_clock, then the v2 clock from brain/brain-sync-v2-schema.js. Idempotent by
+// inspection; createTables() runs it every boot on both paths.
+function ensureBrainSyncSchemaV2(d) {
+  d.exec(BRAIN_SYNC_DDL);
+  require('./brain-sync-v2-schema').applyBrainSyncSchemaV2(d);
+}
+
+// Migration 105's body (WP-6, shared-memory-every-machine-2026-10-31.html §11): retire the
+// v1 outbox transport — the three v1 tables and the outbox INSERT the ai/au capture bodies
+// appended. createTables() runs it every boot, so a fresh brain never carries them; an
+// existing v104 brain drops them here. v2 behaviour is untouched.
+function ensureBrainSyncSchemaV3(d) {
+  require('./brain-sync-v2-schema').applyBrainSyncSchemaV3(d);
+}
+
 // WP-5 §6.6: the connection-scoped sentinel that silences the eight capture
 // triggers for the duration of one apply batch. TEMP, so no other connection can
 // see it and it vanishes with the connection (an apply can never suppress capture
@@ -1509,5 +1467,7 @@ function dropBrainSyncSentinel(d) {
 
 createSchemaModule.BRAIN_SYNC_DDL = BRAIN_SYNC_DDL;
 createSchemaModule.ensureBrainSyncSchema = ensureBrainSyncSchema;
+createSchemaModule.ensureBrainSyncSchemaV2 = ensureBrainSyncSchemaV2;
+createSchemaModule.ensureBrainSyncSchemaV3 = ensureBrainSyncSchemaV3;
 createSchemaModule.createBrainSyncSentinel = createBrainSyncSentinel;
 createSchemaModule.dropBrainSyncSentinel = dropBrainSyncSentinel;