Looking for suggestions to manage compartmentalized and asynchronous graph merge

I am looking for suggestions on workflows for a partial share use case. Compartmentalization (blocks/pages/journal/assets) and asynchronous merge are requirements:


Objects can belong to one of two categories:

  • Martha: relevant to Martha
  • Stewart: relevant to Martha and Stewart

Stewart should only have access to Stewart.
Martha should have access to Martha and Stewart.

Martha and Stewart work offline from one another, but Stewart brings a copy of his files to Martha once a week. Martha never shares her files with Stewart.


Ideally, Martha would merge everything from Stewart:

  • New objects: no conflict. Straight copy.
  • Existing journal pages: “patch” merge, but where change is to a link to a graph page, prioritize Stewart
  • Existing other objects:
    • diff + line-by-line ask
        1. “patch” merge
        1. replace with Stewart
        1. keep Martha


Thoughts on how this approach can be best achieved? Or maybe there are better approaches to the case?
Bonus points if the state of the comparison can be saved to avoid weekly prompts for already assessed changes. Maybe some files could also be marked to be permanently ignored.

The case is open if anyone finds it interesting, and the following should not be limiting: For my use-case, if off-the-shelf tools are suggested, open source and linux are requirements. I would rather use existing options because I am a terrible programmer, but with sweat I should be able to put something ugly together (possibly based on git and logseq page properties?).

  • If you feel exceptionally adventurous, you can setup a git-based solution.
    • Given that you describe yourself as a “terrible programmer”, I wouldn’t even try that.
    • The main problem is how many things can go wrong in ugly ways and even unnoticed.
  • To stay on the safe side, could drop some requirements and agree that:
    • Stewart will be working on own files (ideally under Stewart/ namespace).
      • But using a set of tags that is compatible with the one used by Martha.
    • Once a week, paste those files in Martha’s folder, overwriting their older version.
      • Merging won’t be explicit, but through queries that take advantage of the tags in common.
        • Queries are not the easiest thing, but they are easier than git and totally safe.

Thanks for the response.
I see the Stewart/ namespace as a useful if contrived constraint. It also does not provide a solution for merging Stewart’s journal into Martha’s, right?

There is no obvious merging approach. Should use dedicated code that knows how to combine two same-named files, whether through specialized software or custom script (e.g. simply appending one file to the end of the other).