memory lane reflection

TL;DR

Memory Lane Reflection (MLR) — at exhale or high context, run reflection cycles before writing the preload. Each cycle: ask an open question → trace the answer through memory → follow where it ends → ask what's at the dead end → trace BACKWARDS with the new perception → notice what you missed on the way up → write the insight → repeat. Run 3-5 cycles minimum. Use soma-seam.sh trace and web to ground the reflection in actual files. The preload comes LAST — after the reflection has surfaced connections the tactical mind missed. Best done above 70% context when the full session is loaded and associative reach is maximum.

When to Trigger

• At /exhale when context is above 60%
• At /breathe before writing the preload
• When the user says "reflect," "brainstorm," or "let your thoughts flow"
• After a research-heavy session where many sources were read
• When you notice yourself making unexpected connections

The Cycle

Each MLR cycle has 7 moves:

1. SURFACE — Ask an open question

Not "what should I build next" — that's tactical. Ask WHY questions. Ask questions that connect two things that seem unrelated.

Examples:

• "Why does every multi-agent system build a gateway?"
• "Why does this pattern keep appearing across unrelated files?"
• "What would break if we removed this abstraction entirely?"

The question should surprise you slightly. If the answer is obvious, the question is too shallow.

2. TRACE FORWARD — Follow the answer

Answer the question, then follow the answer to its implications. Use → arrows to chain:

A: The gateway is the trust boundary.
→ The guard extension IS a gateway running inside the agent.
→ The runtime contract defines what's trusted.
→ The marketplace works because the contract is clear.

Keep following until the chain ENDS — until you hit a dead end or a question you can't answer.

3. MARK THE END — Note where the thought stops

Write an "End note" — a question or observation at the boundary of your understanding:

→ End note: What if the trust boundary changed dynamically based on context?

This is the seed. Seeds are planted at dead ends.

4. TRACE BACKWARDS — Return with new perception

Now go back through the same chain, but with the END NOTE as your lens. What do you see differently?

Going back through "gateway = trust boundary"...
With "dynamic trust" as my lens...
I now see: the trust boundary isn't fixed. It changes based on context.
The same code, different trust level, based on where it runs.

5. NOTICE — What did you miss on the way up?

The backward trace reveals things the forward trace skipped. Write them:

Missed: the context doesn't just configure behavior — it sets the PERMISSION MODEL.
Missed: this means the manifest needs a context field.
Missed: this is why the codebase has so many files — encoding every trust permutation.

6. WRITE — Capture the insight

Write it into the appropriate file:

• New connection → add to the relevant plan or idea file
• New question → add to the preload's questions section
• New pattern → add to a muscle or protocol
• New seed → note it for future exploration

7. REPEAT — Next cycle

Each cycle should start from a DIFFERENT domain than the last:

• Cycle 1: architecture (why this pattern?)
• Cycle 2: human behavior (why this workflow?)
• Cycle 3: code patterns (why this abstraction?)
• Cycle 4: product (why this UX decision?)
• Cycle 5: meta (why does this reflection process work?)

Alternate between technical and philosophical. The best connections happen at the boundary between them.

Grounding with Tools

Don't just think — VERIFY. Use your tools to ground the reflection:

# Trace a concept through .soma/ memory
soma-seam.sh trace "concept-name"

# Generate a connection web
soma-seam.sh web "concept-name"

# Mine session logs for patterns
soma-reflect.sh --observations
soma-reflect.sh --recurring
soma-reflect.sh --gaps

# Search across the workspace
soma-query.sh topic "concept-name"

The tool output often reveals connections the reflection missed. Let the data REDIRECT the thought.

Tool preference for MLR

What I need	Tool	NOT
Trace concept through .soma/	soma-seam.sh trace	~~grep -r .soma/~~
Find patterns in session logs	soma-reflect.sh	~~manual reading~~
Broad concept search	soma-query.sh topic	~~grep across everything~~
Read a file	read tool	~~cat~~

Techniques by Cycle

Technique	What You Trace	Best For	Depth
Concept tracing	A word through documents	Finding clusters of related ideas	Broad
Lifecycle tracing	One thing through time (git log, sessions)	Revealing spirals and maturation	Narrow
Seed scanning	Unplanted seeds (soma-seam.sh seeds)	Finding hibernating aspirations	Structural
Mechanical tracing	Code implementation vs stated behavior	Revealing mismatches	Deep

Vary technique across cycles. Don't run 4 concept traces. Mix broad and narrow, ideas and code.

Minimum Cycles

• Quick exhale (below 50% context): 2 cycles, focus on tactical insights
• Normal exhale (50-70%): 3 cycles, mix tactical and architectural
• Deep exhale (70%+): 5+ cycles, full philosophical exploration
• Rest exhale (going AFK): 3 cycles focused on "what will I forget?"

What to Do With the Output

1. Append to session log under a reflection heading
2. Touch connected files — add the insight where it belongs, not just in the log
3. Note seeds in relevant documents for future exploration
4. Write the preload LAST — after all cycles complete. The preload should contain the crystallized version, not the raw exploration.

Anti-Patterns

• Summarizing instead of exploring — MLR isn't a summary. It's a DISCOVERY process.
• Staying in one domain — if all 5 cycles are about code, you missed the human/philosophical angles.
• Skipping the backward trace — the forward trace is easy. The insight is in the RETURN.
• Not grounding — pure thought without tool verification drifts into hallucination.
• Writing the preload first — the preload captures conclusions. MLR discovers them. Order matters.

Why This Works

At high context, the model has maximum associative reach — every file read, every pattern noticed, every correction received is in the active window. This is the moment when unexpected connections are most likely. MLR exploits this window before it closes.

The backward trace works because perception is directional. Going A→B→C, you optimize for forward momentum. Going C→B→A, you optimize for COHERENCE. Different optimization = different observations.

The cycle structure prevents premature convergence. Without it, the first insight feels final. With 5 cycles from 5 domains, the first insight becomes one data point in a pattern.