diff --git a/memory/MEMORY.md b/memory/MEMORY.md
index dbd83ce9c..81f20e28b 100644
--- a/memory/MEMORY.md
+++ b/memory/MEMORY.md
@@ -2,6 +2,8 @@
 
 **📌 Fast path: read `CURRENT-aaron.md` and `CURRENT-amara.md` first.** These per-maintainer distillations show what's currently in force. Raw memories below are the history; CURRENT files are the projection. (`CURRENT-aaron.md` refreshed 2026-04-25 with the Otto-281..285 substrate cluster + factory-as-superfluid framing — sections 18-22; prior refresh 2026-04-24 covered sections 13-17.)
 
+- [**LFG=master, AceHack=0-divergence fork, double-hop AceHack→LFG (Aaron 2026-04-27 strategic reframe)**](feedback_lfg_master_acehack_zero_divergence_fork_double_hop_aaron_2026_04_27.md) — Aaron 2026-04-27: bidirectional content-sync too hard; LFG is master, AceHack is pure fork (0 ahead AND 0 behind), force-push AceHack to LFG state after every paired sync. Replaces Option C parallel-SHA-history. Done criterion: `git diff acehack/main..origin/main` empty AND `git rev-list --count` returns 0 both directions.
+- [**0-diff is "start" line — until then we're hobbling (Aaron 2026-04-27)**](feedback_zero_diff_is_start_line_until_then_hobbling_aaron_2026_04_27.md) — Aaron 2026-04-27 reframe: AceHack-LFG content-divergence (53 files / 6065 lines) isn't polish, it's the gate to factory operational status. #43's diff-minimization invariant DEFINES "started." Reverse-sync work moves to high priority. Distinguish commit-count (76/492, NEVER zero, structural) from content-diff (53 files / 6065 lines, CAN reach 0, the actual metric). Forward-action: Batch 1 workflow drift first (~80 lines, 1-2h) as concrete progress on the gate.
 - [Laptop-only-source integration HIGH PRIORITY — `../scratch` = future ACE PACKAGE MANAGER seed (22 files); `../SQLSharp` = pre-DBSP event-stream-processing with LINQ/SQL (14 files, predates Aaron's DBSP discovery, Zeta-progenitor); goal = either ship feature OR write detailed-enough design that we no longer need the reference; Aaron 2026-04-27 clarification: NOT literal copy-paste, self-contained-understanding floor; refined triage per directory identity — `../scratch` references absorb into canonical location or design-doc the Ace-package-manager intent; `../SQLSharp` references map to DBSP-rigorous Zeta equivalents or design-doc the gap; sequenced AFTER PR #26 sync](project_laptop_only_source_integration_scratch_sqlsharp_features_or_designs_high_priority_2026_04_27.md) — 2026-04-27 P1 backlog row; per-reference triage with three outcomes (ship / design-doc / delete-decorative); composes Otto-275 (log-but-don't-implement default to design when uncertain) + Otto-323/346 (NOT external deps, in-repo or eliminate) + Otto-340 (substrate IS identity); done = `git grep ../scratch` and `git grep ../SQLSharp` return zero matches; effort L (3+ days); closes with Aaron's "good job today!!" second positive validation; Aaron's third 2026-04-27 clarification reveals `../SQLSharp` features potentially subsumed by Zeta's DBSP-rigorous form (linq-expert + sql-expert + sql-engine-expert skills already track this class).
 - [Install-script language strategy — pre-install bash + PowerShell (where users are with nothing installed) / post-install TypeScript (declarative state, type-safe) / Python only for AI-ML eventually; Aaron 2026-04-27 confirms after PR #26 INSTALLED.md Python row update validation; `../scratch` is future-declarative-state hint surface; `.mise.toml` is canonical pin source-of-truth; Aaron 2026-04-27 fifth clarification: port-with-DST discipline (NOT replicate the no-DST bad-behavior from `../scratch`/`../SQLSharp`); Aaron 2026-04-27 sixth clarification: AceHack-LFG diff-minimization invariant (0-diff or rigorously-accounted-for + few); 2026-04-27 wording fix per Copilot LFG #643 P1: `docs/research/post-install-typescript-conventions.md` is a *proposed future location*, not a current reference](project_install_script_language_strategy_post_install_typescript_pre_install_bash_powershell_python_for_ai_ml_2026_04_27.md) — 2026-04-27: composes Otto-215 (bun-TS migration) + Otto-235 (4-shell bash compat for pre-install) + Otto-247 (version currency) + Otto-272/273/281/248 (port-with-DST: DST-everywhere + seed-lock + DST-exempt-is-deferred-bug + never-ignore-flakes) + Otto-323 (dependency symbiosis); pre-install structurally bash+PowerShell forever (no-runtime constraint); post-install migrates to TypeScript opportunistically; Python proposals AI/ML-test-gated; closes with Aaron's "Good job on everything" validation of the substrate-cluster Otto-354/355/356/357/358/359 + PR #26.
 - [Otto-358 LIVE-LOCK TOO BROAD — Aaron 2026-04-27 input that "live-lock" has been used as catch-all in substrate; narrow to CS-standard meaning (concurrent processes thrashing state without progress, Beacon-safe); other failures get their own labels — stuck-loop / decision-paralysis / busy-wait / infinite-loop / gated-wait / real-dependency-wait / manufactured-patience / wrong-identity-equation / cadence-mismatch / logic-error](feedback_otto_358_live_lock_too_broad_catch_all_narrow_to_cs_standard_concurrent_state_thrashing_2026_04_27.md) — 2026-04-27: live-lock IS Beacon-safe but my catch-all use was Mirror-overreach; misclassification → wrong-class fix → "stuck in loops like last night"; Otto-352 5-class taxonomy still uses live-lock as umbrella (perpetuates error); needs revision per Otto-358; live-lock conditions: 2+ concurrent agents, active state-change, response-to-each-other, no global progress — single-threaded "stuck" patterns are NOT live-lock.
diff --git a/memory/feedback_lfg_master_acehack_zero_divergence_fork_double_hop_aaron_2026_04_27.md b/memory/feedback_lfg_master_acehack_zero_divergence_fork_double_hop_aaron_2026_04_27.md
new file mode 100644
index 000000000..260eb3e0e
--- /dev/null
+++ b/memory/feedback_lfg_master_acehack_zero_divergence_fork_double_hop_aaron_2026_04_27.md
@@ -0,0 +1,69 @@
+---
+name: LFG=master, AceHack=0-divergence fork, double-hop AceHack→LFG (Aaron 2026-04-27 strategic reframe)
+description: Aaron 2026-04-27 strategic reframe of AceHack-LFG topology — bidirectional content-sync (53 files / 6065 lines) is too hard; instead make LFG the master and AceHack a pure fork with 0 commits ahead AND 0 commits behind. After every PR cycle, AceHack main is hard-reset to LFG main. Going forward: "double hop" workflow = work lands on AceHack first, syncs to LFG, AceHack absorbs LFG's squash-SHA. This is what "starting" actually means. Replaces Option C's "parallel-SHA-history-accepted" framing from task #284.
+type: feedback
+---
+
+# LFG=master, AceHack=0-divergence fork, double-hop AceHack→LFG
+
+## Verbatim quotes (Aaron 2026-04-27)
+
+After Otto reported AceHack-LFG state as 76 ahead / 492 behind / 53 file content-diff / 6065 lines:
+
+> "that's we we can finally 'start'
+> we are kind of hobbling along unitl then"
+
+> "Content-diff (53 files / 6065 lines) is too hard to keep in sync, we need to get to the point where lfg is the main master and acehack is just a fork with 0 divergence 0 commits ahead or behind. This is our 'starting' point. then everything goes double hop acehack>lfg"
+
+## Strategic reframe — what changed
+
+**Before (Option C, task #284):** parallel-SHA-history-accepted. Both forks had unique commits via squash-merge-different-SHA pattern. Bidirectional sync was the model. Commit-count divergence was structural and never zero. Content-diff was the only metric that mattered.
+
+**After (Aaron 2026-04-27):** AceHack is a pure fork. After every PR cycle, AceHack main = LFG main. Both **commit-count divergence (0 ahead, 0 behind) AND content-diff (0 files differ)** are zero. There is no parallel SHA history — AceHack absorbs LFG's squash-SHA after each round.
+
+This is a **stricter invariant**: 0 ahead AND 0 behind, not just "few content drifts rigorously accounted for."
+
+## Operational model — "double hop"
+
+The double-hop workflow:
+
+1. **Work lands on AceHack first** (homebase: feature-branch → PR → squash-merge to AceHack main → AceHack main now has commit X-ace).
+2. **Forward-sync to LFG** (sibling PR cherry-picking the content → squash-merge to LFG main → LFG main now has commit X-lfg).
+3. **AceHack absorbs LFG's SHA** (hard-reset AceHack main to LFG main → AceHack main now has X-lfg, dropping X-ace).
+
+Net effect: AceHack and LFG main always share identical SHAs. There is no AceHack-unique commit history. Force-push to AceHack main is part of the protocol (force-push to LFG main is forbidden).
+
+## Why this works
+
+LFG is the published canonical surface — external consumers (NuGet, README links, etc.) point at LFG. Making LFG the source of truth + ensuring AceHack matches eliminates the "which fork has the canonical X" ambiguity that surfaced today (e.g., Graph.fs Gershgorin shift fix existed on AceHack but not LFG; resume-diff.yml had AceHack-only improvements; today's 6065-line drift).
+
+AceHack as 0-divergence fork serves only one purpose: **a place to land in-flight feature branches before they sync to LFG**. AceHack main itself is just LFG main + maybe one in-flight feature.
+
+## Path from current state to "start"
+
+1. **Audit AceHack's 76 unique commits**: verify their CONTENT is already on LFG (likely yes — most via prior Option C cherry-pick-syncs that produced different SHAs but same content).
+2. **For any genuine AceHack-only content**: forward-sync to LFG first (paired PR, normal flow).
+3. **Hard-reset AceHack main = LFG main**: drops AceHack-unique SHAs. Any genuine new content already exists on LFG via step 2. Force-push to AceHack main.
+4. **Verify**: `git diff acehack/main..origin/main` returns empty AND `git rev-list --count acehack/main..origin/main` returns 0 AND `git rev-list --count origin/main..acehack/main` returns 0.
+5. **From this point: factory has "started."** Future work uses double-hop strictly.
+
+## Composes with
+
+- `memory/feedback_zero_diff_is_start_line_until_then_hobbling_aaron_2026_04_27.md` — earlier substrate from same conversation; this one extends with the LFG-as-master + double-hop topology.
+- Task #284 Option C (now superseded — parallel-SHA-history is no longer accepted; we collapse to 0).
+- Task #302 UPSTREAM-RHYTHM bidirectional drift — now resolved by the new model: drift can't accumulate because AceHack main = LFG main is the after-every-round invariant.
+- Otto-340 substrate-IS-identity — LFG IS the canonical published identity; AceHack is just dev surface.
+- Otto-238 retractability — force-push to AceHack is retractable (rollback to prior LFG snapshot); force-push to LFG is forbidden.
+
+## Done criterion
+
+`git diff acehack/main..origin/main` returns empty.
+`git rev-list --count acehack/main...origin/main` returns 0 in both directions.
+
+Once both are zero, factory has "started." Any subsequent divergence is a violation of the invariant and gets corrected immediately.
+
+## What this does NOT change
+
+- Aaron's `/btw` non-interrupting aside protocol still applies.
+- Otto-357 NO DIRECTIVES still applies (Aaron's input here is observation/reframe, not directive — Otto's judgment update is "shift priority and topology accordingly").
+- The `0-diff is start line` framing from the earlier 2026-04-27 memory is reinforced, not replaced — this memory describes HOW to operationalize that line.
diff --git a/memory/feedback_zero_diff_is_start_line_until_then_hobbling_aaron_2026_04_27.md b/memory/feedback_zero_diff_is_start_line_until_then_hobbling_aaron_2026_04_27.md
new file mode 100644
index 000000000..b3703eaa6
--- /dev/null
+++ b/memory/feedback_zero_diff_is_start_line_until_then_hobbling_aaron_2026_04_27.md
@@ -0,0 +1,58 @@
+---
+name: 0-diff is "start" line — until then we're hobbling (Aaron 2026-04-27)
+description: Aaron's reframe of the AceHack-LFG content-divergence work — until AceHack and LFG main reach 0-diff (53 files / 6065 lines as of 2026-04-27 16:33Z), the factory is "kind of hobbling along." 0-diff isn't polish; it's the gate to "starting." High-priority work, not optional cleanup.
+type: feedback
+---
+
+# 0-diff is "start" line — until then we're hobbling
+
+## Verbatim quote (Aaron 2026-04-27)
+
+After Otto reported the AceHack-LFG divergence as 53 files / 6065 lines / 76+492 commit-count split:
+
+> "that's we we can finally 'start'
+> we are kind of hobbling along unitl then"
+
+## What this means
+
+The AceHack-LFG content divergence isn't a polish/hygiene concern — it's the **gate to factory operational status**. Until 0-diff, the factory is in pre-start mode; everything else (substrate landings, sync rounds, review cycles) is "hobbling."
+
+This composes with #43's diff-minimization invariant: that invariant DEFINES "started." Without it, no claim that the factory has actually started carries weight — there's hidden divergence, ambiguous canonical truth, fixes that exist on one fork but not the other (e.g., Graph.fs Gershgorin spectral shift correction).
+
+## Why: high-priority reframe, not "polish"
+
+Before this input, Otto framed the reverse-sync work as a multi-week long-running project — "easy wins this week, source code next week, big substrate the week after." That framing was wrong. Aaron's "we can finally start" reframe makes it:
+
+- **Not optional**: until 0-diff, every claim about factory operability has a hidden caveat ("but only on one fork").
+- **Not polish**: it's the gate, not the trim.
+- **Not deferrable**: every sync round that doesn't reduce content-diff is a sync round that perpetuates pre-start.
+
+## How to apply: priority signal for reverse-sync work
+
+When triaging work, the reverse-sync project (LFG→AceHack content closure) goes near the top of the priority stack, not the bottom. Concrete:
+
+1. **Workflow drift first** (~80 lines, 1-2h, easy wins on AceHack-side): close 4 remaining workflow file diffs (`gate.yml` 4 lines, `backlog-index-integrity.yml` 17 lines, `memory-index-integrity.yml` 8 lines, `resume-diff.yml` 53 lines).
+2. **Source code reconcile** (~250 lines, 2-4h, real correctness): Graph.fs Gershgorin shift, TemporalCoordinationDetection.fs helper extraction, RobustStats.fs NaN guard — make sure both forks have all the algorithm fixes.
+3. **LFG-only substrate** (~5500 lines, 4-8h, biggest chunk): docs/BACKLOG.md per-row restructure (4113 lines), docs/GLOSSARY.md (292), docs/marketing/*, history docs, tools/hygiene/validate-agencysignature*.sh, tools/peer-call/grok.sh. This is the LFG→AceHack reverse-sync proper.
+4. **Memory file diffs** (~35 lines, 30min): the laptop-only-source-integration entry mostly.
+5. **0-diff verification check under `tools/sync/`** per #43's spec — automate the diff measurement so we never lose track of where we are.
+
+## Distinction: commit-count vs content-diff
+
+Two metrics, different goals:
+
+- **Commit-count (76 / 492 today)**: NEVER zero. This is parallel-SHA-history (per task #284's Option C decision). Every paired sync adds one commit to each side. Numbers grow forever even with perfect work. Not the metric to track.
+- **Content-diff (53 files / 6065 lines today)**: CAN reach 0. This is what #43's invariant targets. This is the metric for "started."
+
+Don't confuse them. Don't claim "we're at 0" by pointing at commit-count divergence stabilizing — that's irrelevant. Point at `git diff acehack/main..origin/main --stat` returning empty.
+
+## Composes with
+
+- `memory/feedback_natural_home_of_memories_is_in_repo_now_all_types_glass_halo_full_git_native_2026_04_24.md` — Glass Halo full git-native invariant. AceHack-LFG drift IS Glass Halo violation in flight.
+- Task #284 Option C decision (AceHack catches up via UPSTREAM-RHYTHM going forward).
+- Task #302 (UPSTREAM-RHYTHM bidirectional drift; this entry refines that task's framing — drift-closure is the "start" gate, not just routine hygiene).
+- Otto-357 NO DIRECTIVES — Aaron's input here is framing/observation, not directive. The judgment-update is mine: priority shifts based on Aaron's "start" framing.
+
+## Forward-action
+
+Today's tick (2026-04-27 16:35Z): kick off Batch 1 (workflow drift, ~80 lines, 1-2h) immediately rather than defer. Concrete progress on the gate.