Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

32.4 KB
Raw Blame
import { describe, it, expect } from 'vitest';
import {
  mergeObjectLWW,
  mergeDeepUnion,
  unionByKey,
  mergeTaste,
  mergeMeta,
  mergeConfidence,
  mergeSocialAccounts,
  mergeAutobiographyStories,
  mergeTasteObserved,
  mergeChronotypeObserved,
  safeMdName,
  TEST_HISTORY_KEYS,
} from './digital-twin-sync.js';

// Minimal shape of a digital-twin evaluation-run history entry — the real
// schemas (digitalTwinValidation.js) key each run on `runId`, never `id`.
const run = (runId, timestamp) => ({ runId, timestamp, providerId: 'example-provider', model: 'example-model', score: 0.5 });

describe('mergeObjectLWW', () => {
  it('takes remote when local is missing', () => {
    expect(mergeObjectLWW(null, { updatedAt: '2026-01-01' })).toEqual({
      merged: { updatedAt: '2026-01-01' },
      changed: true,
    });
  });
  it('keeps local when remote is missing/invalid', () => {
    expect(mergeObjectLWW({ updatedAt: '2026-01-01' }, null).changed).toBe(false);
  });
  it('remote wins only when strictly newer', () => {
    const local = { v: 'L', updatedAt: '2026-01-02' };
    expect(mergeObjectLWW(local, { v: 'R', updatedAt: '2026-01-01' }).merged.v).toBe('L');
    expect(mergeObjectLWW(local, { v: 'R', updatedAt: '2026-01-03' }).merged.v).toBe('R');
    expect(mergeObjectLWW(local, { v: 'R', updatedAt: '2026-01-02' }).changed).toBe(false);
  });
  it('federates observed evidence (#2156) LWW on derivedAt — newest observation wins', () => {
    // taste-observed.json / chronotype-observed.json are regenerated derived
    // records, so the sync merges them wholesale on the derivedAt stamp.
    const local = { source: 'observed', derivedAt: '2026-07-01T00:00:00Z', observedType: 'morning' };
    const remote = { source: 'observed', derivedAt: '2026-07-05T00:00:00Z', observedType: 'evening' };
    expect(mergeObjectLWW(local, remote, 'derivedAt').merged.observedType).toBe('evening');
    expect(mergeObjectLWW(remote, local, 'derivedAt').merged.observedType).toBe('evening');
    // A peer that sends no observed evidence can't blank the local record.
    expect(mergeObjectLWW(local, null, 'derivedAt')).toEqual({ merged: local, changed: false });
  });
});

describe('mergeTasteObserved (#2156 — preserve user AI interpretation across LWW)', () => {
  // Signal = a populated month window; empty = zeroed rollups (idle peer).
  const withSignal = (derivedAt, extra = {}) => ({
    source: 'observed', derivedAt,
    windows: { month: { listen: { total: 5 }, watch: { total: 0 } } },
    ...extra,
  });
  const empty = (derivedAt, extra = {}) => ({
    source: 'observed', derivedAt,
    windows: { month: { listen: { total: 0 }, watch: { total: 0 } } },
    ...extra,
  });
  const body = (derivedAt, extra = {}) => withSignal(derivedAt, extra);
  const interp = (generatedAt, text = 'x') => ({ text, generatedAt });

  it('LWW on derivedAt for the rollup body when both sides have signal', () => {
    const local = withSignal('2026-07-01T00:00:00Z', { windows: { month: { listen: { total: 1 }, watch: { total: 0 } } } });
    const remote = withSignal('2026-07-05T00:00:00Z', { windows: { month: { listen: { total: 9 }, watch: { total: 0 } } } });
    expect(mergeTasteObserved(local, remote).merged.windows.month.listen.total).toBe(9);
  });

  it('a populated record is never clobbered by a newer EMPTY one (idle peer)', () => {
    const local = withSignal('2026-07-01T00:00:00Z');
    const remoteEmptyNewer = empty('2026-07-09T00:00:00Z'); // newer, but no signal
    const { merged, changed } = mergeTasteObserved(local, remoteEmptyNewer);
    expect(merged.derivedAt).toBe('2026-07-01T00:00:00Z'); // local (populated) kept
    expect(changed).toBe(false);
  });

  it('a populated remote replaces an empty local regardless of recency', () => {
    const localEmptyNewer = empty('2026-07-09T00:00:00Z');
    const remotePopulatedOlder = withSignal('2026-07-01T00:00:00Z');
    expect(mergeTasteObserved(localEmptyNewer, remotePopulatedOlder).merged.windows.month.listen.total).toBe(5);
  });

  it('keeps the local interpretation when a newer remote recompute carries none', () => {
    // The exact drop bug: peer recompute wins the body but must NOT lose the
    // user's interpretation.
    const local = body('2026-07-01T00:00:00Z', { interpretation: interp('2026-07-02T00:00:00Z', 'mine') });
    const remote = body('2026-07-05T00:00:00Z'); // newer body, no interpretation
    const { merged, changed } = mergeTasteObserved(local, remote);
    expect(merged.derivedAt).toBe('2026-07-05T00:00:00Z'); // remote body won
    expect(merged.interpretation.text).toBe('mine');       // interpretation survived
    expect(changed).toBe(true);
  });

  it('takes the newer interpretation regardless of which body won', () => {
    const local = body('2026-07-05T00:00:00Z', { interpretation: interp('2026-07-01T00:00:00Z', 'old') });
    const remote = body('2026-07-01T00:00:00Z', { interpretation: interp('2026-07-06T00:00:00Z', 'new') });
    const merged = mergeTasteObserved(local, remote).merged;
    expect(merged.derivedAt).toBe('2026-07-05T00:00:00Z'); // local body won (newer)
    expect(merged.interpretation.text).toBe('new');        // remote interpretation is newer
  });

  it('is a no-op when neither side has an interpretation and the body is unchanged', () => {
    const local = body('2026-07-05T00:00:00Z');
    const remote = body('2026-07-01T00:00:00Z');
    expect(mergeTasteObserved(local, remote).changed).toBe(false);
  });
});

describe('mergeChronotypeObserved (#2156 — signal-aware LWW)', () => {
  const rec = (derivedAt, sampleSize, observedType) => ({ source: 'observed', derivedAt, sampleSize, observedType });
  it('LWW on derivedAt when both sides have activity', () => {
    const local = rec('2026-07-01T00:00:00Z', 40, 'morning');
    const remote = rec('2026-07-05T00:00:00Z', 60, 'evening');
    expect(mergeChronotypeObserved(local, remote).merged.observedType).toBe('evening');
  });
  it('a populated histogram is not clobbered by a newer empty one (sampleSize 0)', () => {
    const local = rec('2026-07-01T00:00:00Z', 40, 'morning');
    const remoteEmpty = rec('2026-07-09T00:00:00Z', 0, null);
    expect(mergeChronotypeObserved(local, remoteEmpty).merged.observedType).toBe('morning');
  });
});

describe('mergeDeepUnion', () => {
  it('unions nested marker objects, local wins per-key', () => {
    const local = { markers: { a: 1 }, derivedAt: '2026-01-01' };
    const remote = { markers: { a: 9, b: 2 }, derivedAt: '2026-01-02' };
    const { merged, changed } = mergeDeepUnion(local, remote, 'derivedAt');
    expect(merged.markers).toEqual({ a: 1, b: 2 });
    expect(merged.derivedAt).toBe('2026-01-02');
    expect(changed).toBe(true);
  });
  it('fills locally-missing/default scalars from remote', () => {
    const { merged } = mergeDeepUnion({ score: 0, derivedAt: '' }, { score: 5, age: 40, derivedAt: '' }, 'derivedAt');
    expect(merged.score).toBe(5);
    expect(merged.age).toBe(40);
  });
});

describe('unionByKey', () => {
  it('adds remote records not present locally; keeps local on conflict (add-only)', () => {
    const { merged, changed } = unionByKey(
      [{ id: 'a', v: 'L' }],
      [{ id: 'a', v: 'R' }, { id: 'b', v: 'R' }],
      'id'
    );
    expect(merged).toHaveLength(2);
    expect(merged.find((x) => x.id === 'a').v).toBe('L');
    expect(changed).toBe(true);
  });
  it('LWW on conflict when a timestampField is provided', () => {
    const { merged } = unionByKey(
      [{ id: 'a', v: 'L', updatedAt: '2026-01-01' }],
      [{ id: 'a', v: 'R', updatedAt: '2026-01-09' }],
      'id',
      'updatedAt'
    );
    expect(merged[0].v).toBe('R');
  });
  it('tolerates non-array inputs', () => {
    expect(unionByKey(null, undefined, 'id')).toEqual({ merged: [], changed: false });
  });

  // Regression guard for the whole class of bug behind #3529: a keyField that
  // no record actually carries must not silently collapse the array.
  it('keeps every record when NONE of them carry the key field', () => {
    const { merged } = unionByKey(
      [{ runId: 'a' }, { runId: 'b' }],
      [{ runId: 'c' }],
      'nonexistentKey'
    );
    expect(merged.map((x) => x.runId).sort()).toEqual(['a', 'b', 'c']);
  });

  it('treats a blank-string key as unkeyed rather than collapsing on it', () => {
    const { merged } = unionByKey([{ id: '', v: 1 }, { id: '', v: 2 }], [], 'id');
    expect(merged).toHaveLength(2);
  });

  it('is idempotent for unkeyed records — re-merging the same remote adds nothing', () => {
    const local = [{ runId: 'a' }];
    const remote = [{ runId: 'b' }];
    const first = unionByKey(local, remote, 'nonexistentKey');
    const second = unionByKey(first.merged, remote, 'nonexistentKey');
    expect(second.merged).toHaveLength(2);
    expect(second.changed).toBe(false);
  });

  it('signature-matches unkeyed records regardless of property order', () => {
    const { merged, changed } = unionByKey([{ a: 1, b: 2 }], [{ b: 2, a: 1 }], 'id');
    expect(merged).toHaveLength(1);
    expect(changed).toBe(false);
  });
});

describe('mergeTaste', () => {
  it('unions responses across machines so no answer is lost', () => {
    const local = {
      updatedAt: '2026-03-01',
      sections: { movies: { status: 'in_progress', responses: [{ questionId: 'movies-core-1', answer: 'A', answeredAt: '2026-02-01' }], summary: null } },
    };
    const remote = {
      updatedAt: '2026-03-02',
      sections: { movies: { status: 'in_progress', responses: [{ questionId: 'movies-core-2', answer: 'B', answeredAt: '2026-02-02' }], summary: null } },
    };
    const { merged, changed } = mergeTaste(local, remote);
    const ids = merged.sections.movies.responses.map((r) => r.questionId).sort();
    expect(ids).toEqual(['movies-core-1', 'movies-core-2']);
    expect(changed).toBe(true);
  });

  it('LWW per response by updatedAt||answeredAt', () => {
    const local = { updatedAt: '2026-03-01', sections: { music: { status: 'in_progress', responses: [{ questionId: 'q', answer: 'old', answeredAt: '2026-01-01' }], summary: null } } };
    const remote = { updatedAt: '2026-03-01', sections: { music: { status: 'in_progress', responses: [{ questionId: 'q', answer: 'new', updatedAt: '2026-02-01' }], summary: null } } };
    const { merged } = mergeTaste(local, remote);
    expect(merged.sections.music.responses[0].answer).toBe('new');
  });

  it('adds a whole section the local profile is missing', () => {
    const local = { updatedAt: '2026-03-01', sections: { movies: { status: 'completed', responses: [], summary: 'm' } } };
    const remote = { updatedAt: '2026-03-01', sections: { food: { status: 'in_progress', responses: [{ questionId: 'food-core-1', answer: 'x' }], summary: null } } };
    const { merged, changed } = mergeTaste(local, remote);
    expect(merged.sections.food).toBeDefined();
    expect(merged.sections.movies).toBeDefined();
    expect(changed).toBe(true);
  });

  it('takes the more-complete section status and fills a missing summary', () => {
    const local = { updatedAt: '2026-03-01', sections: { art: { status: 'in_progress', responses: [], summary: null } } };
    const remote = { updatedAt: '2026-03-01', sections: { art: { status: 'completed', responses: [], summary: 'done' } } };
    const { merged } = mergeTaste(local, remote);
    expect(merged.sections.art.status).toBe('completed');
    expect(merged.sections.art.summary).toBe('done');
  });

  it('does not clobber a local summary with remote', () => {
    const local = { updatedAt: '2026-03-01', sections: { art: { status: 'completed', responses: [], summary: 'mine' } } };
    const remote = { updatedAt: '2026-03-09', sections: { art: { status: 'completed', responses: [], summary: 'theirs' } } };
    const { merged } = mergeTaste(local, remote);
    expect(merged.sections.art.summary).toBe('mine');
  });

  it('takes remote profileSummary only when the file is newer', () => {
    const base = { sections: {} };
    expect(mergeTaste({ ...base, updatedAt: '2026-03-09', profileSummary: 'L' }, { ...base, updatedAt: '2026-03-01', profileSummary: 'R' }).merged.profileSummary).toBe('L');
    expect(mergeTaste({ ...base, updatedAt: '2026-03-01', profileSummary: 'L' }, { ...base, updatedAt: '2026-03-09', profileSummary: 'R' }).merged.profileSummary).toBe('R');
  });

  it('takes remote wholesale when local is absent', () => {
    const remote = { updatedAt: '2026-03-01', sections: { movies: { status: 'in_progress', responses: [], summary: null } } };
    expect(mergeTaste(null, remote)).toEqual({ merged: remote, changed: true });
  });

  it('sorts merged responses by questionId (stable on-disk order)', () => {
    const local = { updatedAt: '2026-03-01', sections: { movies: { status: 'in_progress', responses: [{ questionId: 'movies-core-3', answer: 'c' }], summary: null } } };
    const remote = { updatedAt: '2026-03-01', sections: { movies: { status: 'in_progress', responses: [{ questionId: 'movies-core-1', answer: 'a' }, { questionId: 'movies-core-2', answer: 'b' }], summary: null } } };
    const { merged } = mergeTaste(local, remote);
    expect(merged.sections.movies.responses.map((r) => r.questionId)).toEqual(['movies-core-1', 'movies-core-2', 'movies-core-3']);
  });
});

describe('mergeMeta', () => {
  it('unions documents by filename (add-only) and keeps local entry on conflict', () => {
    const local = { documents: [{ id: '1', filename: 'SOUL.md', weight: 9 }] };
    const remote = { documents: [{ id: '1', filename: 'SOUL.md', weight: 1 }, { id: '2', filename: 'FAVORITES.md', weight: 5 }] };
    const { merged, changed } = mergeMeta(local, remote);
    expect(merged.documents).toHaveLength(2);
    expect(merged.documents.find((d) => d.filename === 'SOUL.md').weight).toBe(9);
    expect(changed).toBe(true);
  });

  it('unions all four test histories by runId and personas by id', () => {
    const local = { testHistory: [run('t1', '2026-01-01T00:00:00.000Z')], personas: [{ id: 'p1' }] };
    const remote = {
      testHistory: [run('t2', '2026-01-02T00:00:00.000Z')],
      valuesTestHistory: [run('v1', '2026-01-01T00:00:00.000Z')],
      adversarialTestHistory: [run('a1', '2026-01-01T00:00:00.000Z')],
      multiTurnTestHistory: [run('m1', '2026-01-01T00:00:00.000Z')],
      personas: [{ id: 'p2' }],
    };
    const { merged } = mergeMeta(local, remote);
    expect(merged.testHistory.map((x) => x.runId).sort()).toEqual(['t1', 't2']);
    expect(merged.valuesTestHistory).toHaveLength(1);
    expect(merged.adversarialTestHistory).toHaveLength(1);
    expect(merged.multiTurnTestHistory).toHaveLength(1);
    expect(merged.personas.map((x) => x.id).sort()).toEqual(['p1', 'p2']);
  });

  // #3529: these arrays were unioned on 'id', which no run entry carries, so
  // every entry collided on the `undefined` map key and the merge collapsed
  // each history down to a single record on the FIRST peer sync.
  it('preserves multi-entry test histories from BOTH peers without collapsing', () => {
    const local = Object.fromEntries(TEST_HISTORY_KEYS.map((key) => [key, [
      run(`${key}-L1`, '2026-01-03T00:00:00.000Z'),
      run(`${key}-L2`, '2026-01-01T00:00:00.000Z'),
    ]]));
    const remote = Object.fromEntries(TEST_HISTORY_KEYS.map((key) => [key, [
      run(`${key}-R1`, '2026-01-04T00:00:00.000Z'),
      run(`${key}-R2`, '2026-01-02T00:00:00.000Z'),
    ]]));

    const { merged, changed } = mergeMeta(local, remote);
    expect(changed).toBe(true);
    for (const key of TEST_HISTORY_KEYS) {
      expect(merged[key].map((x) => x.runId).sort()).toEqual(
        [`${key}-L1`, `${key}-L2`, `${key}-R1`, `${key}-R2`].sort()
      );
    }
  });

  it('re-sorts a merged history newest-first so the readers\' slice(0, N) stays "most recent N"', () => {
    const local = { testHistory: [run('L1', '2026-01-03T00:00:00.000Z'), run('L2', '2026-01-01T00:00:00.000Z')] };
    const remote = { testHistory: [run('R1', '2026-01-04T00:00:00.000Z'), run('R2', '2026-01-02T00:00:00.000Z')] };
    const { merged } = mergeMeta(local, remote);
    expect(merged.testHistory.map((x) => x.runId)).toEqual(['R1', 'L1', 'R2', 'L2']);
  });

  it('orders same-timestamp runs identically on both peers (runId tiebreak)', () => {
    const a = run('aaa', '2026-01-01T00:00:00.000Z');
    const b = run('bbb', '2026-01-01T00:00:00.000Z');
    const onPeerA = mergeMeta({ testHistory: [a] }, { testHistory: [b] }).merged.testHistory;
    const onPeerB = mergeMeta({ testHistory: [b] }, { testHistory: [a] }).merged.testHistory;
    expect(onPeerA.map((x) => x.runId)).toEqual(['aaa', 'bbb']);
    expect(onPeerB.map((x) => x.runId)).toEqual(onPeerA.map((x) => x.runId));
  });

  it('sorts timestamp-less legacy runs last instead of ahead of dated ones', () => {
    const local = { testHistory: [{ runId: 'legacy' }] };
    const remote = { testHistory: [run('R1', '2026-01-04T00:00:00.000Z')] };
    const { merged } = mergeMeta(local, remote);
    expect(merged.testHistory.map((x) => x.runId)).toEqual(['R1', 'legacy']);
  });

  it('keeps the local copy of a run that both peers already have (add-only)', () => {
    const local = { testHistory: [{ ...run('shared', '2026-01-01T00:00:00.000Z'), score: 0.9 }] };
    const remote = { testHistory: [{ ...run('shared', '2026-01-01T00:00:00.000Z'), score: 0.1 }] };
    const { merged, changed } = mergeMeta(local, remote);
    expect(merged.testHistory).toHaveLength(1);
    expect(merged.testHistory[0].score).toBe(0.9);
    expect(changed).toBe(false);
  });

  // #3530: documents unioned add-only with no deletion tracking, so a peer that
  // still held a document the user deleted re-inserted its metadata entry (and
  // applyDocuments re-wrote the .md file) on every subsequent sync.
  describe('deleted-document tombstones (#3530)', () => {
    const DELETED_AT = '2026-02-01T00:00:00.000Z';
    const tomb = (filename, deletedAt = DELETED_AT) => ({ filename, deletedAt });
    const doc = (filename, extra = {}) => ({ id: `id-${filename}`, filename, weight: 5, ...extra });

    it('does not resurrect a document the local machine deleted', () => {
      const local = { documents: [doc('SOUL.md')], deletedDocuments: [tomb('CUSTOM_ROUTINE.md')] };
      const remote = { documents: [doc('SOUL.md'), doc('CUSTOM_ROUTINE.md', { createdAt: '2026-01-01T00:00:00.000Z' })] };
      const { merged, changed } = mergeMeta(local, remote);
      expect(merged.documents.map((d) => d.filename)).toEqual(['SOUL.md']);
      expect(changed).toBe(false);
    });

    it('suppresses a resurrected document that carries no creation stamp (legacy entry)', () => {
      const local = { documents: [], deletedDocuments: [tomb('CUSTOM_ROUTINE.md')] };
      const { merged, changed } = mergeMeta(local, { documents: [doc('CUSTOM_ROUTINE.md')] });
      expect(merged.documents ?? []).toEqual([]);
      expect(changed).toBe(false);
    });

    it('propagates a peer\'s delete: drops the local entry and adopts the tombstone', () => {
      const local = { documents: [doc('CUSTOM_ROUTINE.md', { createdAt: '2026-01-01T00:00:00.000Z' })], deletedDocuments: [] };
      const remote = { documents: [], deletedDocuments: [tomb('CUSTOM_ROUTINE.md')] };
      const { merged, changed } = mergeMeta(local, remote);
      expect(merged.documents).toEqual([]);
      expect(merged.deletedDocuments).toEqual([tomb('CUSTOM_ROUTINE.md')]);
      expect(changed).toBe(true);
    });

    it('does NOT suppress a document re-created after the delete, and prunes the stale tombstone', () => {
      const recreated = doc('CUSTOM_ROUTINE.md', { createdAt: '2026-03-01T00:00:00.000Z' });
      // The peer still holds the tombstone from the earlier delete.
      const local = { documents: [recreated], deletedDocuments: [] };
      const remote = { documents: [], deletedDocuments: [tomb('CUSTOM_ROUTINE.md')] };
      const { merged, changed } = mergeMeta(local, remote);
      expect(merged.documents ?? local.documents).toEqual([recreated]);
      expect(merged.deletedDocuments ?? []).toEqual([]);
      expect(changed).toBe(false);
      // …and the peer receiving the re-created doc accepts it, dropping its own tombstone.
      const onPeer = mergeMeta(remote, local);
      expect(onPeer.merged.documents).toEqual([recreated]);
      expect(onPeer.merged.deletedDocuments).toEqual([]);
      expect(onPeer.changed).toBe(true);
    });

    it('keeps the newer of two competing deletes and converges in both directions', () => {
      const a = { documents: [], deletedDocuments: [tomb('A.md', '2026-01-01T00:00:00.000Z')] };
      const b = { documents: [], deletedDocuments: [tomb('A.md', '2026-05-01T00:00:00.000Z'), tomb('B.md')] };
      expect(mergeMeta(a, b).merged.deletedDocuments)
        .toEqual(mergeMeta(b, a).merged.deletedDocuments ?? b.deletedDocuments);
      expect(mergeMeta(a, b).merged.deletedDocuments).toEqual([tomb('A.md', '2026-05-01T00:00:00.000Z'), tomb('B.md')]);
    });

    it('adopts the peer\'s newer creation stamp so a third peer\'s tombstone can\'t reap the re-created doc', () => {
      // This machine has the ORIGINAL entry; the peer re-created the document
      // after a delete. Without propagating the newer stamp, the stale local
      // entry would later be reaped by a third peer still holding the tombstone.
      const local = { documents: [doc('CUSTOM_ROUTINE.md', { createdAt: '2026-01-01T00:00:00.000Z', weight: 9 })] };
      const remote = { documents: [doc('CUSTOM_ROUTINE.md', { createdAt: '2026-03-01T00:00:00.000Z', weight: 1 })] };
      const { merged, changed } = mergeMeta(local, remote);
      expect(changed).toBe(true);
      expect(merged.documents[0].createdAt).toBe('2026-03-01T00:00:00.000Z');
      expect(merged.documents[0].weight).toBe(9); // the rest of the entry stays add-only

      // …and that refreshed entry now survives the stale tombstone.
      const third = { documents: [], deletedDocuments: [tomb('CUSTOM_ROUTINE.md')] };
      expect(mergeMeta(merged, third).merged.documents).toEqual(merged.documents);
    });

    it('does not reap a document edited after another machine deleted it', () => {
      const edited = doc('CUSTOM_ROUTINE.md', { createdAt: '2026-01-01T00:00:00.000Z', updatedAt: '2026-03-01T00:00:00.000Z' });
      const { merged } = mergeMeta({ documents: [edited] }, { documents: [], deletedDocuments: [tomb('CUSTOM_ROUTINE.md')] });
      expect(merged.documents ?? [edited]).toEqual([edited]);
      // …and the superseded tombstone is pruned rather than retried every cycle.
      expect(merged.deletedDocuments ?? []).toEqual([]);
    });

    it('still reaps a document whose last edit predates the delete', () => {
      const stale = doc('CUSTOM_ROUTINE.md', { createdAt: '2026-01-01T00:00:00.000Z', updatedAt: '2026-01-15T00:00:00.000Z' });
      const { merged } = mergeMeta({ documents: [stale] }, { documents: [], deletedDocuments: [tomb('CUSTOM_ROUTINE.md')] });
      expect(merged.documents).toEqual([]);
      expect(merged.deletedDocuments).toEqual([tomb('CUSTOM_ROUTINE.md')]);
    });

    it('leaves local tombstones untouched when an older peer sends none (key-presence guarded)', () => {
      const local = { documents: [doc('SOUL.md')], deletedDocuments: [tomb('GONE.md')] };
      const { merged, changed } = mergeMeta(local, { documents: [doc('SOUL.md')] });
      expect(merged.deletedDocuments ?? local.deletedDocuments).toEqual([tomb('GONE.md')]);
      expect(changed).toBe(false);
    });
  });

  it('leaves histories the peer did not send untouched (key-presence guarded)', () => {
    const local = { testHistory: [run('L1', '2026-01-01T00:00:00.000Z'), run('L2', '2026-01-02T00:00:00.000Z')] };
    const { merged, changed } = mergeMeta(local, { documents: [] });
    expect(merged.testHistory.map((x) => x.runId)).toEqual(['L1', 'L2']);
    expect(changed).toBe(false);
  });

  it('deep-unions enrichment (categories, max question counts, newest session)', () => {
    const local = { enrichment: { completedCategories: ['core'], lastSession: '2026-01-01', questionsAnswered: { core: 3 } } };
    const remote = { enrichment: { completedCategories: ['social'], lastSession: '2026-02-01', questionsAnswered: { core: 5, social: 2 } } };
    const { merged } = mergeMeta(local, remote);
    expect(merged.enrichment.completedCategories.sort()).toEqual(['core', 'social']);
    expect(merged.enrichment.lastSession).toBe('2026-02-01');
    expect(merged.enrichment.questionsAnswered).toEqual({ core: 5, social: 2 });
  });

  it('fills missing settings keys but keeps local values', () => {
    const local = { settings: { autoInjectToCoS: false } };
    const remote = { settings: { autoInjectToCoS: true, maxContextTokens: 4000 } };
    const { merged } = mergeMeta(local, remote);
    expect(merged.settings).toEqual({ autoInjectToCoS: false, maxContextTokens: 4000 });
  });

  it('takes remote wholesale when local meta is absent', () => {
    const remote = { documents: [{ id: '1', filename: 'SOUL.md' }] };
    expect(mergeMeta(null, remote)).toEqual({ merged: remote, changed: true });
  });
});

describe('mergeAutobiographyStories', () => {
  it('unions stories by id and unions usedPrompts', () => {
    const local = { stories: [{ id: 's1', content: 'L', createdAt: '2026-01-01' }], usedPrompts: ['childhood-0'] };
    const remote = { stories: [{ id: 's2', content: 'R', createdAt: '2026-01-02' }], usedPrompts: ['family-0'] };
    const { merged, changed } = mergeAutobiographyStories(local, remote);
    expect(merged.stories.map((s) => s.id).sort()).toEqual(['s1', 's2']);
    expect(merged.usedPrompts.sort()).toEqual(['childhood-0', 'family-0']);
    expect(changed).toBe(true);
  });

  it('LWW on a shared story by updatedAt||createdAt', () => {
    const local = { stories: [{ id: 's1', content: 'old', createdAt: '2026-01-01' }] };
    const remote = { stories: [{ id: 's1', content: 'new', createdAt: '2026-01-01', updatedAt: '2026-02-01' }] };
    const { merged } = mergeAutobiographyStories(local, remote);
    expect(merged.stories[0].content).toBe('new');
  });

  it('is a no-op when remote has nothing new', () => {
    const local = { stories: [{ id: 's1', createdAt: '2026-01-01' }], usedPrompts: ['a'] };
    expect(mergeAutobiographyStories(local, { stories: [{ id: 's1', createdAt: '2026-01-01' }], usedPrompts: ['a'] }).changed).toBe(false);
  });

  it('reports a change when the peer brings only a tombstone for a story we never held', () => {
    const local = { stories: [{ id: 's1', createdAt: '2026-01-01' }], usedPrompts: [] };
    const remote = { stories: [{ id: 's1', createdAt: '2026-01-01' }], usedPrompts: [], deletedStories: [{ id: 'gone', deletedAt: '2026-03-01T00:00:00.000Z' }] };
    const { merged, changed } = mergeAutobiographyStories(local, remote);
    expect(changed).toBe(true);
    expect(merged.deletedStories).toEqual([{ id: 'gone', deletedAt: '2026-03-01T00:00:00.000Z' }]);
  });

  it('sorts merged stories by id (stable on-disk order for checksum convergence)', () => {
    const local = { stories: [{ id: 's3', createdAt: '2026-01-03' }], usedPrompts: ['z'] };
    const remote = { stories: [{ id: 's1', createdAt: '2026-01-01' }, { id: 's2', createdAt: '2026-01-02' }], usedPrompts: ['a'] };
    const { merged } = mergeAutobiographyStories(local, remote);
    expect(merged.stories.map((s) => s.id)).toEqual(['s1', 's2', 's3']);
    expect(merged.usedPrompts).toEqual(['a', 'z']);
  });
});

describe('mergeConfidence (analyzed personality traits)', () => {
  it('takes remote when local is missing/invalid', () => {
    const remote = { dimensions: { openness: 0.6 }, overall: 0.6, gaps: [], lastCalculated: '2026-02-01' };
    expect(mergeConfidence(null, remote)).toEqual({ merged: remote, changed: true });
    expect(mergeConfidence(undefined, remote).changed).toBe(true);
  });

  it('keeps local and reports no change when remote is missing/empty', () => {
    const local = { dimensions: { openness: 0.6 }, overall: 0.6, gaps: [], lastCalculated: '2026-02-01' };
    expect(mergeConfidence(local, null).changed).toBe(false);
    expect(mergeConfidence(local, undefined).merged).toBe(local);
  });

  it('maxes each dimension so no machine\'s analysis is lost', () => {
    const local = { dimensions: { openness: 0.8, extraversion: 0.2 }, overall: 0.5, gaps: [], lastCalculated: '2026-01-01' };
    const remote = { dimensions: { openness: 0.4, conscientiousness: 0.9 }, overall: 0.65, gaps: [], lastCalculated: '2026-02-01' };
    const { merged, changed } = mergeConfidence(local, remote);
    expect(merged.dimensions).toEqual({ openness: 0.8, extraversion: 0.2, conscientiousness: 0.9 });
    expect(changed).toBe(true);
  });

  it('recomputes overall as the mean of merged dimensions (2dp)', () => {
    const local = { dimensions: { a: 0.2 }, overall: 0.2, lastCalculated: '2026-01-01' };
    const remote = { dimensions: { a: 0.6, b: 0.9 }, overall: 0.75, lastCalculated: '2026-02-01' };
    const { merged } = mergeConfidence(local, remote);
    // dims merge to { a: 0.6, b: 0.9 } → mean 0.75
    expect(merged.overall).toBe(0.75);
  });

  it('carries gaps + lastCalculated from the more-recently-calculated side', () => {
    const local = { dimensions: { a: 0.5 }, gaps: [{ dimension: 'a' }], lastCalculated: '2026-01-01' };
    const remote = { dimensions: { a: 0.5 }, gaps: [{ dimension: 'b' }], lastCalculated: '2026-02-01' };
    const { merged } = mergeConfidence(local, remote);
    expect(merged.gaps).toEqual([{ dimension: 'b' }]);
    expect(merged.lastCalculated).toBe('2026-02-01');
  });
});

describe('mergeMeta wires confidence', () => {
  it('brings over a peer\'s analyzed traits into a fresh local meta', () => {
    const local = { documents: [], confidence: { dimensions: {}, overall: 0, gaps: [], lastCalculated: '' } };
    const remote = { documents: [], confidence: { dimensions: { openness: 0.7 }, overall: 0.7, gaps: [], lastCalculated: '2026-03-01' } };
    const { merged, changed } = mergeMeta(local, remote);
    expect(changed).toBe(true);
    expect(merged.confidence.dimensions.openness).toBe(0.7);
    expect(merged.confidence.lastCalculated).toBe('2026-03-01');
  });

  it('does not blank local confidence when the peer sends none', () => {
    const local = { documents: [], confidence: { dimensions: { openness: 0.7 }, overall: 0.7, lastCalculated: '2026-03-01' } };
    const { merged } = mergeMeta(local, { documents: [] });
    expect(merged.confidence.dimensions.openness).toBe(0.7);
  });
});

describe('mergeSocialAccounts', () => {
  it('takes remote when local is missing/invalid', () => {
    const remote = { accounts: { a1: { platform: 'github', updatedAt: '2026-01-01' } } };
    expect(mergeSocialAccounts(null, remote)).toEqual({ merged: remote, changed: true });
  });

  it('keeps local and reports no change when remote is missing', () => {
    const local = { accounts: { a1: { platform: 'github' } } };
    expect(mergeSocialAccounts(local, null).changed).toBe(false);
  });

  it('unions accounts by id, keeping each side\'s unique entries', () => {
    const local = { accounts: { a1: { platform: 'github', updatedAt: '2026-01-01' } } };
    const remote = { accounts: { a2: { platform: 'x', updatedAt: '2026-01-02' } } };
    const { merged, changed } = mergeSocialAccounts(local, remote);
    expect(Object.keys(merged.accounts).sort()).toEqual(['a1', 'a2']);
    expect(changed).toBe(true);
  });

  it('reports a change when the peer brings only a tombstone for an account we never held', () => {
    const local = { accounts: { a1: { platform: 'github', updatedAt: '2026-01-01' } } };
    const remote = { accounts: { a1: { platform: 'github', updatedAt: '2026-01-01' } }, deletedAccounts: [{ id: 'gone', deletedAt: '2026-03-01T00:00:00.000Z' }] };
    const { merged, changed } = mergeSocialAccounts(local, remote);
    expect(changed).toBe(true);
    expect(merged.deletedAccounts).toEqual([{ id: 'gone', deletedAt: '2026-03-01T00:00:00.000Z' }]);
  });

  it('LWW on a shared account by updatedAt', () => {
    const local = { accounts: { a1: { username: 'old', updatedAt: '2026-01-01' } } };
    const remote = { accounts: { a1: { username: 'new', updatedAt: '2026-02-01' } } };
    expect(mergeSocialAccounts(local, remote).merged.accounts.a1.username).toBe('new');
    const older = { accounts: { a1: { username: 'older', updatedAt: '2025-12-01' } } };
    expect(mergeSocialAccounts(local, older).merged.accounts.a1.username).toBe('old');
    expect(mergeSocialAccounts(local, older).changed).toBe(false);
  });
});

describe('safeMdName (path-traversal guard)', () => {
  it('accepts a plain .md basename', () => {
    expect(safeMdName('SOUL.md')).toBe('SOUL.md');
    expect(safeMdName('My_Doc.MD')).toBe('My_Doc.MD');
  });
  it('rejects traversal, nested paths, dotfiles, and non-md', () => {
    expect(safeMdName('../evil.md')).toBeNull();
    expect(safeMdName('sub/dir/x.md')).toBeNull();
    expect(safeMdName('/abs/x.md')).toBeNull();
    expect(safeMdName('.hidden.md')).toBeNull();
    expect(safeMdName('notes.txt')).toBeNull();
    expect(safeMdName(42)).toBeNull();
  });
});