@dhyasama/totem-merge 7.2.0 → 8.0.0

package/docs/transactional-lead-merges.md

@@ -1,18 +1,19 @@
 # Transactional company and person merges
 
-Status: 7.2.0 release candidate, 2026-10-24. No consumer enables this path yet.
-Publishing this package does not activate its transactional merge option.
+Status: 8.0.0 native-only release candidate, 2026-10-25.
+The 7.3.0 compatibility release is deployed before mirror retirement.
 
 ## First-rollout scope
 
 The owner's first rollout covers Customer settings (already completed), Lead,
 Tag and Valuation. Notes, Documents and custom fields remain on their existing
-records. `transactionalPrivateData: true` opts into the transaction and native
-Lead/Tag/Valuation handling only; it does not activate the deferred migrations.
+records. All public merge entry points require the transaction and native
+Lead/Tag/Valuation collections. The legacy merge mode is removed; no setting
+can opt out. This is a major release and does not activate deferred migrations.
 
 Both document and ID entry points reload the source and target on every retry.
 Source deletion, target save, existing reference updates, Lead/Tag/Valuation
-updates and their legacy mirrors commit together. Company merges union distinct
+updates commit together. Organization mirror arrays are not updated. Company merges union distinct
 leads per customer with no count limit. Person merges replace the source Person
 and deduplicate assignments. Tags combine groups/items per owner. Every valuation
 occurrence and database ID survives; conflicting legacy IDs block the merge.
@@ -20,10 +21,10 @@ occurrence and database ID survives; conflicting legacy IDs block the merge.
 The path requires a replica set, models on one connection, uniqueness indexes on
 Lead/Tag/Valuation, and the existing open customer-settings control record. Its
 transaction fence coordinates with lifecycle admission and private-data writers.
-No write pause or queue/schedule hold is introduced. Missing additive Leads can
-be initialized from chairs; Tags and Valuations must already be reconciled.
-Invalid owners, blocking lifecycle jobs, missing people and destination drift
-fail the whole transaction. A committed retry is recognized by merged history.
+No write pause or queue/schedule hold is introduced. Missing native records
+mean empty data; old arrays never restore private records. Invalid owners,
+blocking lifecycle jobs, missing people and colliding native identities fail
+the whole transaction. A committed retry is recognized by merged history.
 
 ## Deferred fields stay in legacy storage
 
@@ -55,23 +56,20 @@ release review; they are separate from enabling new-store authority.
 42 targeted tests pass, including synthetic replica-set merges against the web
 consumer's published models 17.0.0. Coverage includes unlimited Leads, tenant
 isolation, transaction rollback/retries, concurrent fenced edits, committed replay,
-Tag drift, valuation identity, embedded custom-field preservation/conflicts,
+stale Tag mirrors, valuation identity, embedded custom-field preservation/conflicts,
 untouched native CustomFields/entities, legacy attachment links and lifecycle
 checks. Merges work without a CustomField uniqueness index and never initialize
 attachment entities. Tests use a uniquely named disposable local database.
 
-Before adoption: review/release the package, complete Lead/Tag/Valuation writer
-coverage and reconciliation, test production-sized transaction cost, and verify
-all consumers, caches and Pentest behavior. The narrowed preparation completed a clean 423-Customer production comparison
-on 2026-10-24; repeat live parity checks before activation. Native attachment and CustomField consumers
-must remain disabled. This draft is not readiness to cut over or remove fields.
+## Retirement release verification
 
-## 7.2.0 release review
+The 7.3.0 compatibility release is verified on both web hosts and sheet-sync.
+Version 8.0.0 removes mirror writes and the legacy merge entry paths. All 47
+focused merge/security checks pass on Node 24 with consumer models 19.0.0.
+Notes, documents and embedded custom fields stay in scope only for preserving
+existing associations and values; their deferred migrations remain disabled.
 
-The current consumer baseline is models 17.0.0, including Account.customer and
-retired Interaction/activity-list models. The 42 focused merge/security tests
-pass against that exact dependency. The default constructor remains opt-out.
-Adoption also includes the reviewed default-path fixes above; it is not a claim
-that every legacy merge behavior is identical. Before transactional activation,
-finish writer deployment and production-scale cost checks. Once enabled, rollback
-must retain native/legacy mirroring rather than reverting to an unfenced merger.
+Once mirror writes stop, rollbacks must use 7.3.0 or a later native-authoritative
+release. An earlier legacy reader would observe stale data. Stored-array and
+schema removal is a subsequent deployment after all native-only writers are
+verified; no write pause or schedule hold is required.

package/index.js

@@ -1,13 +1,12 @@
 "use strict";
 
-var organizations = require('./lib/organizations');
-var people = require('./lib/people');
+const atomicMerge = require('./lib/atomicMerge');
 var Logger = require('@dhyasama/totem-logger');
 
 // Constructor
 var Merge = function(mongoose, config) {
 
-  this.transactionalPrivateData = config.transactionalPrivateData === true;
+  this.transactionalPrivateData = true;
   this.env = process.env.NODE_ENV || 'development';
   this.logger = new Logger(config.logentries);
   this.CapTable = mongoose.model('CapTable');
@@ -30,80 +29,11 @@ var Merge = function(mongoose, config) {
 
 //////////////////////////////////////////////
 
-Merge.prototype.organizations = function(target, source, user, customerId, cb) {
-
-  if (this.transactionalPrivateData) return require('./lib/atomicMerge')(this, 'Organization', target, source, user, customerId).then(result => cb(null, result), error => cb(error, null));
-  organizations.merge(this, target, source, user, customerId, cb);
-};
-
-Merge.prototype.organizationsById = function(targetId, sourceId, user, customerId, cb) {
-
-  if (this.transactionalPrivateData) return require('./lib/atomicMerge')(this, 'Organization', targetId, sourceId, user, customerId).then(result => cb(null, result), error => cb(error, null));
-
-  var self = this;
-
-  self.logger.writeToInfoLog('Merge org ' + sourceId + ' into ' + targetId);
-
-  self.Organization.getById(targetId, { CUSTOMER_ID: customerId, isWorkerProcess: true }, function(err, target) {
-
-    if (err) { return cb(err, null); }
-    else if (!target) { return cb(new Error('target not found'), null); }
-
-    self.logger.writeToInfoLog('  Found target ' + target.name);
-
-    self.Organization.getById(sourceId, { CUSTOMER_ID: customerId, isWorkerProcess: true }, function(err, source) {
-
-      if (err) { return cb(err, null); }
-      else if (!source) { return cb(new Error('source not found'), null); }
-
-      self.logger.writeToInfoLog('  Found source ' + source.name);
-      self.logger.writeToInfoLog('  Merging...');
-
-      organizations.merge(self, target, source, user, customerId, cb);
-
-    });
-
-  });
-
-};
-
-Merge.prototype.people = function(target, source, user, customerId, cb) {
-
-  if (this.transactionalPrivateData) return require('./lib/atomicMerge')(this, 'Person', target, source, user, customerId).then(result => cb(null, result), error => cb(error, null));
-  people.merge(this, target, source, user, customerId, cb);
-};
-
-Merge.prototype.peopleById = function(targetId, sourceId, user, customerId, cb) {
-
-  if (this.transactionalPrivateData) return require('./lib/atomicMerge')(this, 'Person', targetId, sourceId, user, customerId).then(result => cb(null, result), error => cb(error, null));
-
-  var self = this;
-
-  self.logger.writeToInfoLog('Merge person ' + sourceId + ' into ' + targetId);
-
-  self.Person.getById(targetId, { CUSTOMER_ID: customerId, isWorkerProcess: true }, function(err, target) {
-
-    if (err) { return cb(err, null); }
-    else if (!target) { return cb(new Error('target not found'), null); }
-
-    console.log('  Found target', target.name.full);
-    console.log('  Target sources:', target.sources.length);
-
-    self.Person.getById(sourceId, { CUSTOMER_ID: customerId, isWorkerProcess: true }, function(err, source) {
-
-      if (err) { return cb(err, null); }
-      else if (!source) { return cb(new Error('source not found'), null); }
-
-      self.logger.writeToInfoLog('  Found source ' + source.name.full);
-      self.logger.writeToInfoLog('  Source sources ' + source.sources.length);
-      self.logger.writeToInfoLog('  Merging...');
-
-      people.merge(self, target, source, user, customerId, cb);
-
-    });
-
-  });
-
-};
+// Native collections and the lifecycle transaction are mandatory after retirement.
+for (const [method, kind] of [['organizations', 'Organization'], ['organizationsById', 'Organization'], ['people', 'Person'], ['peopleById', 'Person']]) {
+  Merge.prototype[method] = function(target, source, user, customerId, cb) {
+    return atomicMerge(this, kind, target, source, user, customerId).then(result => cb(null, result), error => cb(error, null));
+  };
+}
 
 module.exports = Merge;

package/lib/leadMerge.js

@@ -1,5 +1,4 @@
 'use strict';
-const crypto = require('node:crypto');
 const { Types: { ObjectId } } = require('mongoose');
 const text = value => String(value?._id || value || '').toLowerCase();
 function id(value) {
@@ -9,34 +8,19 @@ function id(value) {
 }
 const oid = value => new ObjectId(id(value));
 const unique = values => [...new Set(values.map(id))];
-const equal = (a, b) => JSON.stringify([...a].sort()) === JSON.stringify([...b].sort());
 const key = (customer, organization) => customer + '/' + organization;
 
 // Capture/validate before source deletion. The caller holds the same transaction
 // fence as Lead writers and customer deletion/downgrade admission throughout.
 async function prepare(db, session, kind, target, source) {
   const targetId = id(target), sourceId = id(source);
-  const companyFilter = kind === 'Organization' ? { _id: { $in: [oid(targetId), oid(sourceId)] } } :
-    { $or: ['first', 'second'].map(slot => ({ ['chairs.' + slot]: { $in: [oid(targetId), oid(sourceId)] } })) };
   const leadFilter = kind === 'Organization' ? { organization: { $in: [oid(targetId), oid(sourceId)] } } :
     { people: { $in: [oid(targetId), oid(sourceId)] } };
   const leads = await db.collection('leads').find(leadFilter, { session }).toArray();
   const companyIds = leads.map(lead => oid(lead.organization));
-  const companies = await db.collection('organizations').find({ $or: [companyFilter, { _id: { $in: companyIds } }] },
-    { session, projection: { chairs: 1 } }).toArray();
+  const companies = await db.collection('organizations').find({ _id: { $in: kind === 'Organization' ? [oid(targetId), oid(sourceId)] : companyIds } },
+    { session, projection: { _id: 1 } }).toArray();
   const groups = new Map(), owners = new Set();
-  for (const company of companies) {
-    if (company.chairs != null && !Array.isArray(company.chairs)) throw Error('Malformed legacy lead array');
-    for (const chair of company.chairs || []) {
-      const customer = id(chair.customer), organization = id(company);
-      if (Object.keys(chair).some(field => !['_id', 'customer', 'first', 'second'].includes(field))) throw Error('Unknown legacy lead fields');
-      const groupKey = key(customer, organization);
-      if (!groups.has(groupKey)) groups.set(groupKey, { customer, organization, people: [], lead: null });
-      const group = groups.get(groupKey);
-      group.people = unique([...group.people, ...[chair.first, chair.second].filter(value => value != null)]);
-      owners.add(customer);
-    }
-  }
   // Read all groups on affected companies, including empty/new Lead records.
   const existing = await db.collection('leads').find({ organization: { $in: companies.map(company => company._id) } }, { session }).toArray();
   for (const lead of existing) {
@@ -44,7 +28,8 @@ async function prepare(db, session, kind, target, source) {
     if (typeof lead.customer === 'string' || typeof lead.organization === 'string' || !Array.isArray(lead.people)) throw Error('Malformed Lead storage');
     if (!groups.has(groupKey)) groups.set(groupKey, { customer, organization, people: [], lead: null });
     const group = groups.get(groupKey), people = unique(lead.people);
-    if (group.lead || people.length !== lead.people.length || !equal(group.people, people)) throw Error('Lead merge requires reconciled stores');
+    if (group.lead || people.length !== lead.people.length) throw Error('Duplicate Lead record or person');
+    group.people = people;
     group.lead = lead; owners.add(customer);
   }
   if (leads.some(lead => !companies.some(company => id(company) === id(lead.organization)))) throw Error('Lead company is missing');
@@ -80,21 +65,7 @@ async function apply(db, session, plan) {
         organization: oid(group.organization), people: group.people.map(oid)
       }, $inc: { __v: 1 } }, { session });
       if (result.matchedCount !== 1) throw Error('Lead changed during merge');
-    } else {
-      const stable = crypto.createHash('sha256').update(`customer-data-v1:${group.customer}/organizations/${group.organization}/chairs`).digest('hex').slice(0, 24);
-      await db.collection('leads').insertOne({ _id: new ObjectId(stable), customer: oid(group.customer), organization: oid(group.organization),
-        people: group.people.map(oid), __v: 0 }, { session });
-    }
-  }
-  const organizations = plan.kind === 'Organization' ? [plan.targetId] : plan.companies.map(id);
-  for (const organization of organizations) {
-    const chairs = [];
-    for (const group of output.values()) if (group.organization === organization) {
-      for (let i = 0; i < group.people.length; i += 2) chairs.push({ _id: new ObjectId(), customer: oid(group.customer), first: oid(group.people[i]),
-        ...(group.people[i + 1] ? { second: oid(group.people[i + 1]) } : {}) });
     }
-    const result = await db.collection('organizations').updateOne({ _id: oid(organization) }, { $set: { chairs } }, { session });
-    if (result.matchedCount !== 1) throw Error('Lead company changed during merge');
   }
 }
 module.exports = { prepare, apply };

package/lib/organizations.js

@@ -83,6 +83,9 @@ var mergeSourceIntoTarget = function mergeEntities(target, source, cb) {
   logger.writeToInfoLog('Merge source into target...');
 
   var doNotMergeKeys = [
+    'chairs',
+    'filters',
+    'valuations',
     'merged',
     'deleted',
     'entered',

package/lib/people.js

@@ -483,7 +483,7 @@ var updateOrganizations = function updateOrganizations(newPersonId, oldPersonId,
   cb = _.once(cb);
 
   // Get all orgs for this person
-  self.Organization.collection.find({ $or: [{ 'people.person': oldPersonId }, { 'chairs.first': oldPersonId }, { 'chairs.second': oldPersonId }] }).toArray().then(function(orgs) {
+  self.Organization.collection.find({ 'people.person': oldPersonId }).toArray().then(function(orgs) {
 
     if (!orgs || orgs.length === 0) return cb(null, []);
 
@@ -542,12 +542,6 @@ var updateOrganizations = function updateOrganizations(newPersonId, oldPersonId,
         return person;
       });
 
-      setObj.chairs = _.map(org.chairs || [], function(chair) {
-        if (chair && chair.first && chair.first.toString() === oldPersonId.toString()) { chair.first = newPersonId; }
-        if (chair && chair.second && chair.second.toString() === oldPersonId.toString()) { chair.second = newPersonId; }
-        return chair;
-      });
-
       tasks.push({
         id: org._id,
         update: { $set: setObj }

package/lib/privateRecordMerge.js

@@ -11,30 +11,12 @@ function groups(entries) {
   }
   return result;
 }
-function tagValue(entries) {
-  return [...groups(entries)].map(([name, entry]) => [name, [...entry.items].sort()]).sort((a, b) => a[0].localeCompare(b[0]));
-}
-function valuationValue(entry) {
-  // Stored values only. Do not fill absent values using schema defaults.
-  const result = {};
-  for (const key of ['date', 'valuation', 'pricePerShare', 'method']) if (own(entry, key)) result[key] = entry[key];
-  return result;
-}
-function sameEntries(actual, expected) {
-  const unmatched = [...expected];
-  for (const entry of actual) {
-    const position = unmatched.findIndex(candidate => equal(candidate, entry));
-    if (position < 0) return false;
-    unmatched.splice(position, 1);
-  }
-  return unmatched.length === 0;
-}
 async function prepare(db, session, kind, target, source) {
   const ids = [target._id, source._id], targetId = id(target._id), ownerIds = [];
   const plan = { targetId, kind, records: [], mirrors: {} };
   // Raw parent reads prevent Mongoose defaults from becoming stored values.
   const parents = await db.collection(kind === 'Organization' ? 'organizations' : 'people').find({ _id: { $in: ids } }, { session }).toArray();
-  for (const [collection, field] of [['tags', 'filters'], ['valuations', 'valuations']]) {
+  for (const collection of ['tags', 'valuations']) {
     if (kind === 'Person' && collection !== 'tags') continue;
     const filter = collection === 'valuations' ? { organization: { $in: ids } } :
       { 'entity.model': kind, 'entity.id': { $in: ids } };
@@ -48,27 +30,6 @@ async function prepare(db, session, kind, target, source) {
       if (!entities.has(entity)) entities.set(entity, []);
       entities.get(entity).push(row);
     }
-    if (kind === 'Organization') {
-      for (const parent of parents) {
-        const legacy = array(parent[field]), entity = id(parent._id);
-        const customers = new Set(legacy.map(entry => id(entry.customer)));
-        for (const [customer, entities] of buckets) if (entities.has(entity)) customers.add(customer);
-        for (const customer of customers) {
-          const old = legacy.filter(entry => id(entry.customer) === customer);
-          const current = buckets.get(customer)?.get(entity) || [];
-          let matches;
-          if (collection === 'tags') matches = current.length === 1 && equal(tagValue(current[0].groups), tagValue(old));
-          else matches = sameEntries(current.map(valuationValue), old.map(valuationValue));
-          if (!matches) throw Error('Private merge requires reconciled ' + collection);
-          // A legacy valuation ID is part of its identity, not just its value.
-          if (collection === 'valuations' && current.some(row => row.legacyId &&
-              !old.some(entry => entry._id && id(entry._id) === id(row.legacyId) && equal(valuationValue(entry), valuationValue(row))))) {
-            throw Error('Valuation legacy identity mismatch');
-          }
-        }
-      }
-    }
-    const mirror = [];
     for (const [customer, entities] of buckets) {
       const targetRows = entities.get(targetId) || [], sourceRows = entities.get(id(source._id)) || [];
       if (collection !== 'valuations' && (targetRows.length > 1 || sourceRows.length > 1)) throw Error('Duplicate private records');
@@ -82,7 +43,6 @@ async function prepare(db, session, kind, target, source) {
             seen.add(legacyId);
           }
           plan.records.push({ collection, keep: row, set: { organization: oid(targetId) }, remove: [] });
-          mirror.push({ _id: row.legacyId || row._id, customer: oid(customer), ...valuationValue(row) });
         }
       } else if (collection === 'tags') {
         const combined = new Map();
@@ -93,10 +53,8 @@ async function prepare(db, session, kind, target, source) {
         }
         const next = [...combined.values()];
         plan.records.push({ collection, keep: all[0], remove: all.slice(1), set: { entity: { model: kind, id: oid(targetId) }, groups: next } });
-        mirror.push(...next.map(group => ({ ...group, customer: oid(customer) })));
       }
     }
-    if (kind === 'Organization') plan.mirrors[field] = mirror;
   }
   // Custom fields stay embedded. Preserve both parents' values without consulting
   // or updating the deferred CustomField collection. The old generic array
@@ -125,7 +83,7 @@ async function apply(db, session, plan) {
       { $set: item.set, $inc: { __v: 1 } }, { session });
     if (result.matchedCount !== 1) throw Error('Private record changed during merge');
   }
-  if (plan.kind === 'Organization') {
+  if (plan.kind === 'Organization' && Object.keys(plan.mirrors).length) {
     const result = await db.collection('organizations').updateOne({ _id: oid(plan.targetId) }, { $set: plan.mirrors }, { session });
     if (result.matchedCount !== 1) throw Error('Private merge target changed');
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhyasama/totem-merge",
-  "version": "7.2.0",
+  "version": "8.0.0",
   "description": "Org and person merging package",
   "main": "index.js",
   "scripts": {

package/test/atomic-lead-merge.mongo.test.js

@@ -49,6 +49,14 @@ const uri = process.env.ATOMIC_MERGE_TEST_URI;
   });
   after(async () => { if (db) await db.dropDatabase(); await m.disconnect(); });
 
+  it('cannot opt out of native transactions through the old configuration flag', async () => {
+    context.transactionalPrivateData = false;
+    try {
+      await call('organizations');
+      assert.equal(await db.collection('leads').countDocuments({ organization: source }), 0);
+      assert.equal((await db.collection('leads').findOne({ customer: tenant, organization: target })).people.length, 4);
+    } finally { context.transactionalPrivateData = true; }
+  });
   it('unions unlimited company leads per tenant and atomically relinks every owner’s deals', async () => {
     await db.collection('deals').insertMany([tenant, other].map(customer => ({ customer, organization: source, stage: 'Lead' })));
     const targetLead = await db.collection('leads').findOne({ customer: tenant, organization: target });
@@ -64,15 +72,21 @@ const uri = process.env.ATOMIC_MERGE_TEST_URI;
     assert.deepEqual((await db.collection('leads').findOne({ customer: other })).people, [people[4]]);
     assert.equal(await db.collection('deals').countDocuments({ organization: target }), 2);
     const chairs = (await db.collection('organizations').findOne({ _id: target })).chairs;
-    assert.equal(chairs.filter(chair => String(chair.customer) === String(tenant)).length, 2);
+    assert.equal(chairs.filter(chair => String(chair.customer) === String(tenant)).length, 1);
     const before = await state(); await call('organizations'); assert.deepEqual(await state(), before);
   });
-  it('initializes missing additive groups without losing unlimited legacy leads', async () => {
+  it('does not resurrect legacy leads when native groups are absent', async () => {
     await db.collection('leads').deleteMany({});
     await call('organizations');
-    const lead = await db.collection('leads').findOne({ customer: tenant, organization: target });
-    assert.deepEqual(lead.people.map(String).sort(), people.slice(0, 4).map(String).sort());
-    assert.deepEqual((await db.collection('leads').findOne({ customer: other })).people, [people[4]]);
+    assert.equal(await db.collection('leads').countDocuments({}), 0);
+    assert.equal((await db.collection('organizations').findOne({ _id: target })).chairs.length, 2);
+  });
+  it('merges native lead edits without restoring people from stale mirrors', async () => {
+    await db.collection('leads').updateOne({ customer: tenant, organization: source }, { $set: { people: [] } });
+    const expected = await db.collection('leads').findOne({ customer: tenant, organization: target });
+    await call('organizations');
+    const actual = await db.collection('leads').findOne({ customer: tenant, organization: target });
+    assert.deepEqual(actual.people, expected.people);
   });
   it('preserves zero-lead groups without introducing a placeholder person', async () => {
     await db.collection('organizations').updateMany({}, { $set: { chairs: [] } });
@@ -112,9 +126,9 @@ const uri = process.env.ATOMIC_MERGE_TEST_URI;
     }
     assert.equal(String((await db.collection('documents').findOne({})).createdBy), String(people[0]));
   });
-  it('blocks destination drift, deletion receipts and tenant identity merges before source deletion', async () => {
+  it('blocks deletion receipts and tenant identity merges before source deletion', async () => {
     await db.collection('leads').updateOne({ customer: tenant, organization: source }, { $set: { people: [] } });
-    let before = await state(); await assert.rejects(call('organizations'), /reconciled/); assert.deepEqual(await state(), before);
+    let before;
     await db.collection('leads').updateOne({ customer: tenant, organization: source }, { $set: { people: [people[1], people[2], people[3]] } });
     await db.collection('deletions').insertOne({ _id: tenant, kind: 'job', operation: 'delete', status: 'completed' });
     before = await state(); await assert.rejects(call('organizations'), /lifecycle/); assert.deepEqual(await state(), before);
@@ -187,13 +201,13 @@ const uri = process.env.ATOMIC_MERGE_TEST_URI;
     assert.deepEqual(values.map(row => String(row._id)).sort(), originalValuations.map(row => String(row._id)).sort());
     assert(values.every(row => row.valuation === 0 && !Object.hasOwn(row, 'pricePerShare')));
     const parent = await db.collection('organizations').findOne({ _id: target });
-    assert.equal(parent.valuations.length, 2);
+    assert.equal(parent.valuations.length, 1);
     assert(parent.valuations.every(row => !Object.hasOwn(row, 'pricePerShare')));
     assert(parent.customFields.some(entry => entry.fields.targetOnly === false));
     assert(parent.customFields.some(entry => Array.isArray(entry.fields.sourceOnly)));
     assert(parent.customFields.some(entry => String(entry.customer) === String(other)));
   });
-  it('ignores deferred CustomField drift but still rejects unreconciled Tags', async () => {
+  it('ignores deferred CustomField drift', async () => {
     await privateFixture();
     await db.collection('customfields').updateOne({ customer: tenant, 'entity.id': source }, { $set: { 'fields.shared': 999 } });
     const original = await db.collection('customfields').find({}).sort({ _id: 1 }).toArray();
@@ -206,11 +220,23 @@ const uri = process.env.ATOMIC_MERGE_TEST_URI;
     const before = await state();
     await assert.rejects(call('organizations'), /Conflicting embedded custom fields/); assert.deepEqual(await state(), before);
   });
-  it('blocks unreconciled Tags without modifying any record', async () => {
+  it('does not resurrect stale Tag mirrors during a merge', async () => {
     await privateFixture();
     await db.collection('tags').updateOne({ customer: tenant, 'entity.id': source }, { $set: { groups: [] } });
-    const before = await state();
-    await assert.rejects(call('organizations'), /reconciled tags/); assert.deepEqual(await state(), before);
+    const expected = await db.collection('tags').findOne({ customer: tenant, 'entity.id': target });
+    await call('organizations');
+    assert.deepEqual((await db.collection('tags').findOne({ customer: tenant, 'entity.id': target })).groups, expected.groups);
+  });
+  it('retains native valuation edits when mirrors contain stale amounts', async () => {
+    await privateFixture();
+    await db.collection('valuations').updateMany({ organization: source }, { $set: { valuation: 12345 } });
+    const expected = await db.collection('valuations').find({ organization: source }).toArray();
+    await call('organizations');
+    for (const row of expected) {
+      const actual = await db.collection('valuations').findOne({ _id: row._id });
+      assert.equal(actual.valuation, 12345);
+      assert.equal(String(actual.organization), String(target));
+    }
   });
   it('blocks colliding valuation identities rather than losing an occurrence', async () => {
     await privateFixture();