Metric Ripple

Deals change at the last minute. The purchase price drops, the loan proceeds get re-cut, an exit cap moves. When that happens the night before an investment-committee meeting, you do not want to regenerate the entire memo — that would wipe out hours of manual polish. But you also can’t leave the old number scattered across a dozen sections.

Metric Ripple is the surgical alternative. You change one key metric, and Memosa figures out every place that metric (and the prose around it) needs to update, shows you a preview, and applies the change across all affected sections only after you approve it. You can undo the whole thing in one step.

How a ripple works

When you trigger a metric change, Memosa scans the memo for every section the metric touches and classifies how material the change is — a rounding-level tweak is handled very differently from a number that reframes the deal’s thesis. Based on that materiality, each affected section is updated using the lightest tier that does the job correctly:

Tier	What it does	When
Tier 1	Format-preserving number swap, no LLM. Instant.	Trivial changes — the figure moves but the surrounding language still holds.
Tier 2	Targeted sentence rewrite via the model — only the affected sentences.	The number change makes the qualitative language (“a healthy spread,” “modest leverage”) wrong and the sentence needs adjusting.
Tier 3	Full section regeneration.	The change is significant enough that the whole section’s analysis should be rewritten.
Tier 4	Executive-summary cascade.	The change ripples up to the top-line summary, which is regenerated to stay consistent.

You don’t pick the tier — Memosa recommends one per section from the materiality of the change and the prose context around each occurrence, then escalates a tier when model-quality flags or qualitative language warrant it. Higher tiers are only used where a lighter touch would leave the memo internally inconsistent.

Note

A ripple is built to be conservative. Most sections in a typical change resolve at Tier 1 or Tier 2 — a number swap or a sentence rewrite — precisely so your manual edits survive. Tiers 3 and 4 are reserved for changes material enough that regenerating is the only honest option.

Preview, apply, undo

Metric Ripple is a three-step flow, and you stay in control at every step:

1. Preview — Memosa computes the full impact assessment without changing anything: which sections are affected, which tier each will use, and whether the executive summary needs to cascade. Progress streams to you live.
2. Apply — once you approve the preview, the changes are applied across all affected sections, again with live progress. Sections that get regenerated (Tier 3 / Tier 4) notify the editor when they finish.
3. Undo — every apply returns a rollback handle, so you can revert the entire ripple in one action if the result isn’t what you wanted.

Both preview and apply require the Editor role on the deal. A concurrency guard prevents two ripples from running on the same deal at once, so simultaneous edits can’t collide.

The whole apply runs under a time budget of 120 seconds , with a per-section cap of 30 seconds so one slow section can’t starve the rest. If a Tier 2 rewrite exceeds its budget, it falls back to a Tier 1 number swap rather than failing — the number still gets corrected even when the rewrite can’t finish in time.

The inline amber flash

When sections finish updating, Memosa flashes them in the editor with a soft amber highlight — the Memosa brand color — so you can see at a glance exactly which parts of the memo just changed. The highlight fades over about fifteen seconds and then disappears, leaving your text clean. It’s a visual diff: no hunting for what moved.

Coherence checking

After all the tiers run, Memosa validates the financial coherence of the updated memo and surfaces any high-severity inconsistencies it detects in the preview’s results panel (with severity badges). These checks are non-fatal — they inform you rather than block the apply — but they catch the cases where a fast propagation left two sections disagreeing.

Tracing a memo number back to the model

A ripple is only as trustworthy as its understanding of how one number drives another. That understanding comes from the FormulaGraph — Memosa’s dependency graph of your Excel model, which knows that changing the purchase price moves the loan amount, the debt service, the DSCR, the levered returns, and so on. Metric Ripple uses that graph to determine which metrics are downstream of the one you changed, which is why the propagation lands in the right sections rather than just blind-replacing a string.

For how the FormulaGraph is built and what it captures, see the FormulaGraph architecture.

Sources

• src/canvas/ripple/engine.py — the RippleConfig budgets (120 s total, 30 s per section, 180 s concurrency-lock TTL) and the apply pipeline.
• src/canvas/ripple/tier_executors.py — the four tier executors (Tier 1 regex swap, Tier 2 sentence rewrite, Tier 3 section regeneration, Tier 4 executive-summary cascade) and the Tier 2 → Tier 1 timeout fallback.
• src/canvas/ripple/materiality.py — the CRE materiality classifier and recommend_tier logic that maps a change’s materiality and prose context to a tier.
• src/canvas/routes/ripple_routes.py — the preview / apply / undo endpoints, their SSE progress streams, the Editor-role gate, and the WebSocket broadcasts.
• memory/metric_ripple_engine.md — the end-to-end design: four tiers, coherence validation, the Redis concurrency lock, the FormulaGraph serialization the engine consumes, and the ProseMirror inline-flash plugin.