What is a memory file versus an instruction file?

A memory file is where an agent accumulates raw lessons as they happen - unsorted, repetitive, some of it still guesswork. An instruction file is the durable, curated set of rules the agent reads every time. Memo Merge is the promotion step between the two: what has matured moves across, what has not stays behind, and nothing gets said twice.

Do I have to sign in to use Memo Merge?

No. Parsing, the lesson inventory with maturity scores, contradiction detection, the applyTo glob merge, the deterministic merged file and residual memory file, and the whole checker all run in this tab with no account and no charge. Only the consolidation pass is metered, and the two bundled examples replay a saved run for free.

How does it decide a lesson is already covered?

Both files are parsed into atomic rules and every lesson is compared against every existing rule with one similarity function - the same one that later checks the model's merged file for redundancy. At or above 0.8 the lesson is a duplicate, from 0.34 it overlaps, below that it is new. Contradictions are read off the leading directive clause, so a rule that says do not force-push and a rule that says force-push freely are caught even though they share most of their words.

What stops the merge from losing something?

Every lesson the pass claims to have merged, and every rule the instruction file already had, is looked for again in the merged document by its own distinctive vocabulary. Anything that cannot be found is printed by name as a hard failure - whether the merged file came from the model, from the free engine, or from your own edits in the editor.

What does a run cost, and what happens if my balance is low?

A worst-case amount is reserved and only what the run uses is charged. The run button is disabled before you submit if the balance cannot cover the model's minimum, and a reply cut short by a low balance says so instead of presenting itself as a complete merge.

Where do the two output files go?

Back where they came from: the merged document replaces your instruction file, and the residual memory file replaces your memory file - which is what makes the next merge start from a shorter, already-settled memory. Both download as markdown, and the decisions download as JSON if you want to review the merge in a pull request.

Memo Merge — memory file in, a merged instruction file out

Domain — what these files are about

Promotion bar — how settled a lesson must be

Anything to steer the merge? — optional

The memory file — raw accumulated lessons. Paste it, or drop a .md file

The instruction file — where matured lessons belong. Leave empty to create it

Result

How it works

Nothing to hand? Load the — a real merge, with a lesson that contradicts a standing rule and two that are still guesswork — or the , where there is no instruction file yet and the run has to write one. Both replay a saved run for free. Or press to watch the checker name six findings — four hard failures and two warnings — with no model call at all.

A memory file is not a draft of the instruction file

It is a different kind of document: lessons land in it the moment they are learned, so it repeats itself, argues with itself, and keeps guesses next to conclusions. The promotion step is where that gets sorted — and doing it by hand is how a detail quietly disappears. Both files are parsed here into frontmatter, a heading tree and atomic rules, so the merge is a set of decisions about identifiable things rather than a wall of text a model rewrites wholesale.

Every lesson lands in exactly one bucket, and that is counted

Each lesson is measured against every existing rule with one similarity function: duplicate at 0.8 and above, overlap from 0.34, new below that — and conflict ahead of all of them when the two give opposite instructions. Maturity is scored from countable signals only: specificity, a settled-knowledge marker, a concrete example, restatement elsewhere in the file, minus hedging. The partition is then asserted by counting: a lesson in two buckets, or in none, is reported rather than passing because its id appeared somewhere.

The free engine writes both files, so the page is never inert

From that plan, this tab writes a complete merged instruction file — promoted lessons filed under the section they belong to, contradictions deliberately left unapplied, applyTo merged with subsumed globs removed — and the residual memory file, holding exactly what was not settled. No account, no model call, nothing charged. The checker then re-measures its own output the same way it measures the model's.

The metered pass is judgement, and it is held to the measurement

Rewriting an overlapping pair into one rule that keeps both specifics, deciding which side of a contradiction wins, making the file read well: that is what a model is for, and what this app pays for. It returns one decision per lesson and the app checks them by counting — decided twice or never decided is a failure. A section it claims to have filed under is checked against the merged file's real headings and printed as sent, never quietly reassigned. Every promoted lesson and every pre-existing rule is looked for again by its own vocabulary, and anything missing is named. Pricing is honest: a worst-case amount is reserved, only what the run uses is charged, and untouched examples replay a saved run for free.

A derived work of @github/memory-merger: its promotion process and its zero-knowledge-loss / minimal-redundancy / maximum-scannability quality bar are what this app measures and enforces. The skill is a slash command over files on disk; this is the same method with the measurement made explicit.