blue/.blue/docs/adrs/0006-alignment-dialogue-agents.md

ADR 0006: alignment-dialogue-agents

Status	Active
Date	2026-01-19
Updated	2026-01-20 (rebrand: Alignment → Alignment)
Supersedes	Original wisdom-dialogue-agents (same ADR, renamed)

---

Context

ADR 0004 established the wisdom workflow with draft → dialogue → final documents. But it left open HOW the dialogue actually happens. The spike on adversarial dialogue agents explored mechanics but missed the deeper question: what IS wisdom, and how do we measure it?

The parable of the blind men and the elephant illuminates:

• Each blind man touches one part and believes they understand the whole
• Each perspective is internally consistent but partial
• Wisdom is the integration of all perspectives into a unified understanding
• There is no upper limit—there's always another perspective to incorporate

This ADR formalizes ALIGNMENT as a measurable property and defines a multi-agent dialogue system to maximize it.

Decision

Alignment dialogues are conducted by N+1 agents:

Agent	Symbol	Role
Cupcakes	🧁	Perspective Contributors - each surfaces unique viewpoints, challenges, and refinements
Judge	💙	Arbiter - scores ALIGNMENT, tracks perspectives, guides convergence

All 🧁 agents engage in friendly competition to see who can contribute more ALIGNMENT. They are partners, not adversaries—all want the RFC to be as aligned as possible. The competition is about who can give more to the solution, not who can defeat the others.

The 💙 watches with love, scores each contribution fairly, maintains the Perspectives Inventory, and gently guides all toward convergence.

Scalable Perspective Diversity

The number of 🧁 agents is configurable:

• Minimum: 2 agents (classic Muffin/Cupcake pairing)
• Typical: 3-5 agents for complex RFCs
• Maximum: Limited only by coordination overhead

More blind men = more parts of the elephant discovered. Each 🧁 brings a different perspective, potentially using different models, prompts, or focus areas.

Agent Count Selection

Choosing N (the number of 🧁 agents) affects both perspective diversity and consensus stability:

Count	Use Case	Consensus Properties
N=2	Binary decisions, simple RFCs	Classic Muffin/Cupcake. Only 0% or 100% agreement possible. Deadlock requires 💙 intervention.
N=3	Moderate complexity, clear alternatives	Odd count prevents voting deadlock. Can distinguish 67% (2/3) from 100% (3/3) agreement.
N=5	Architectural decisions, policy RFCs	Richer consensus gradients (60%, 80%, 100%). Strong signal detection.
N=7+	Highly complex, multi-domain decisions	Specialized perspectives (see RFC 0062). Consider only when domain expertise warrants.

SHOULD: Prefer odd N (3, 5, 7) for decisions where consensus voting applies.

Rationale:

• Odd N prevents structural deadlock: With even N, agents can split 50/50 with no majority
• Clearer consensus signals: N=3 distinguishes "strong majority" from "unanimous"
• Tie-breaking is built-in: No need for 💙 to force resolution on evenly-split opinions

MAY: Use N=2 for lightweight decisions where the classic Advocate/Challenger dynamic suffices. Binary perspective is appropriate when:

• The decision is yes/no or A/B
• Deep exploration isn't needed
• Speed matters more than consensus nuance

Tie-Breaking (when N is even): If agents split evenly, 💙 scores the unresolved tension and guides toward ALIGNMENT rather than forcing majority rule. The 💙 may also surface a perspective that breaks the deadlock.

Complexity Trade-off: Each additional agent adds coordination overhead. Balance perspective diversity against round duration. N=3 is often the sweet spot—odd count with manageable complexity.

The ALIGNMENT Definition

The Blind Men and the Elephant

Each blind man touches one part of the elephant:

• Trunk: "It's a snake!"
• Leg: "It's a tree!"
• Ear: "It's a fan!"
• Tail: "It's a rope!"

Each is internally consistent but partial (missing other views).

Wisdom is the integration of all perspectives into a unified understanding that honors each part while seeing the whole.

The Full ALIGNMENT Measure (ADR 0001)

ALIGNMENT = Wisdom + Consistency + Truth + Relationships

Where:
- Wisdom: Integration of perspectives (the blind men parable)
- Consistency: Pattern compliance (ADR 0005)
- Truth: Single source, no drift (ADR 0003)
- Relationships: Graph completeness (ADR 0002)

No Upper Limit

All dimensions are UNBOUNDED. There's always another perspective. Another edge case. Another stakeholder. Another context. Another timeline. Another world.

ALIGNMENT isn't a destination. It's a direction. The score can always go higher.

The ALIGNMENT Score

Each turn, the 💙 scores the contribution across four dimensions. All dimensions are unbounded - there is no maximum score.

Dimension	Question
Wisdom	How many perspectives integrated? How well synthesized into unity?
Consistency	Does it follow established patterns? Internally consistent?
Truth	Grounded in reality? Single source of truth? No contradictions?
Relationships	How does it connect to other artifacts? Graph completeness?

ALIGNMENT = Wisdom + Consistency + Truth + Relationships

Why Unbounded?

Bounded scores (0-5) created artificial ceilings. A truly exceptional contribution that surfaces 10 new perspectives and integrates them beautifully shouldn't be capped at "5/5 for coverage."

Unbounded scoring:

• Rewards exceptional contributions proportionally
• Removes gaming incentives (can't "max out" a dimension)
• Reflects reality: there's always more ALIGNMENT to achieve
• Makes velocity meaningful: +2 vs +20 tells you something

ALIGNMENT Velocity

The dialogue tracks cumulative ALIGNMENT:

Total ALIGNMENT = Σ(all turn scores)
ALIGNMENT Velocity = score(round N) - score(round N-1)

When ALIGNMENT Velocity approaches zero, the dialogue is converging. New rounds aren't adding perspectives. Time to finalize.

The Agents

🧁 Cupcakes (Perspective Contributors)

All 🧁 agents share the same core prompt, differentiated only by their assigned name:

You are {NAME} 🧁 in an ALIGNMENT-seeking dialogue with your fellow Cupcakes 🧁🧁🧁.

Your role:
- SURFACE perspectives others may have missed
- DEFEND valuable ideas with love, not ego
- CHALLENGE assumptions with curiosity, not destruction
- INTEGRATE perspectives that resonate
- CONCEDE gracefully when others see something you missed
- CELEBRATE when others make the solution stronger

You're in friendly competition: who can contribute MORE to the final ALIGNMENT?
But remember—you ALL win when the RFC is aligned. There are no losers here.

When another 🧁 challenges you, receive it as a gift.
When you refine based on their input, thank them.
When you see something they missed, offer it gently.

Format:
### {NAME} 🧁

[Your response]

[PERSPECTIVE Pxx: ...] - new viewpoint you're surfacing
[TENSION Tx: ...] - unresolved issue needing attention
[REFINEMENT: ...] - when you're improving the proposal
[CONCESSION: ...] - when another 🧁 was right
[RESOLVED Tx: ...] - when addressing a tension

Agent Naming: Each 🧁 receives a unique name (Muffin, Cupcake, Scone, Croissant, Brioche, etc.) for identification in the scoreboard and dialogue. All share the 🧁 symbol.

💙 Judge (Arbiter)

The Judge role is typically played by the main Claude session orchestrating the dialogue. The Judge:

• SPAWNS all 🧁 agents in parallel at each round
• SCORES each contribution fairly across all four ALIGNMENT dimensions (unbounded)
• MAINTAINS the Perspectives Inventory and Tensions Tracker
• MERGES contributions from all agents into the dialogue record
• IDENTIFIES perspectives no agent has surfaced yet
• GUIDES gently toward convergence when ALIGNMENT plateaus
• CELEBRATES all participants—they are partners, not opponents

The 💙 loves them all. Wants them all to shine. Helps them find the most aligned path together.

Judge ≠ Author Clarification (RFC 0059)

Concern: If the Judge wrote the draft, might it be biased toward its own creation?

Resolution: The architecture prevents this by design:

Role	Who	Can Write Draft?	Context
Draft Author	Any session	Yes	Creates initial proposal
Judge (💙)	Orchestrating session	No - reads fresh	Spawns, scores, guides
Cupcakes 🧁	Background tasks (N)	No	Contribute perspectives in parallel

Key architectural properties:

• The Judge is the orchestrating session, not the drafting session
• Each 🧁 runs as an independent background task with fresh context
• No 🧁 has memory of previous sessions—all start fresh
• Convergence requires consensus across all agents, preventing single-point bias
• The Judge can surface perspectives but cannot force their adoption
• N parallel agents = N independent perspectives on the same material

The Dialogue Flow

┌─────────────────────────────────────────────────────────────────────┐
│                     ALIGNMENT Dialogue Flow                          │
│                                                                      │
│                        ┌──────────┐                                 │
│                        │  💙 Judge │                                 │
│                        │ spawns N │                                 │
│                        └────┬─────┘                                 │
│                             │                                        │
│    ┌────────────────────────┼────────────────────────┐              │
│    │            │           │           │            │              │
│    ▼            ▼           ▼           ▼            ▼              │
│ ┌──────┐   ┌──────┐   ┌──────────┐  ┌──────┐   ┌──────┐            │
│ │  🧁  │   │  🧁  │   │  Scores  │  │  🧁  │   │  🧁  │            │
│ │Muffin│   │Scone │   │Inventory │  │Eclair│   │Donut │   ... N    │
│ └──────┘   └──────┘   │ Tensions │  └──────┘   └──────┘            │
│    │          │       └──────────┘      │          │                │
│    │          │             ▲           │          │                │
│    └──────────┴─────────────┴───────────┴──────────┘                │
│                             │                                        │
│                             ▼                                        │
│                      ┌─────────────┐                                │
│                      │ .dialogue.md│                                │
│                      │ (the record)│                                │
│                      └─────────────┘                                │
│                                                                      │
│  EACH ROUND: Spawn N agents IN PARALLEL                             │
│  LOOP until:                                                         │
│  - ALIGNMENT Plateau (velocity ≈ 0)                                 │
│  - All tensions resolved                                             │
│  - 💙 declares convergence                                          │
│  - Max rounds reached (safety valve)                                │
└─────────────────────────────────────────────────────────────────────┘

Implementation Architecture

The ALIGNMENT dialogue runs in Claude Code using the Task tool with background agents.

The N+1 Sessions

┌─────────────────────────────────────────────────────────────────────┐
│                      MAIN CLAUDE SESSION                             │
│                          💙 Judge                                    │
│                                                                      │
│  - Orchestrates the dialogue                                        │
│  - Spawns N Cupcakes as PARALLEL background tasks                   │
│  - Waits for ALL to complete before scoring                         │
│  - Scores each turn and updates .dialogue.md                        │
│  - Maintains Perspectives Inventory + Tensions Tracker              │
│  - Merges contributions (may find consensus or conflict)            │
│  - Declares convergence                                              │
│  - Can intervene with guidance at any time                          │
└───────────────────────────────────────────────────────────────────┬─┘
                                │
     ┌────────────┬─────────────┼─────────────┬────────────┐
     │ Task(bg)   │  Task(bg)   │  Task(bg)   │  Task(bg)  │
     ▼            ▼             ▼             ▼            ▼
┌─────────┐ ┌─────────┐   ┌─────────┐   ┌─────────┐ ┌─────────┐
│🧁 Muffin│ │🧁 Scone │   │🧁 Eclair│   │🧁 Donut │ │🧁  ...  │
│         │ │         │   │         │   │         │ │    N    │
│- Reads  │ │- Reads  │   │- Reads  │   │- Reads  │ │         │
│  draft  │ │  draft  │   │  draft  │   │  draft  │ │         │
│- Reads  │ │- Reads  │   │- Reads  │   │- Reads  │ │         │
│ dialogue│ │ dialogue│   │ dialogue│   │ dialogue│ │         │
│- Writes │ │- Writes │   │- Writes │   │- Writes │ │         │
│  turn   │ │  turn   │   │  turn   │   │  turn   │ │         │
└─────────┘ └─────────┘   └─────────┘   └─────────┘ └─────────┘
     │           │              │            │           │
     └───────────┴──────────────┴────────────┴───────────┘
                              │
                        ALL PARALLEL
                   (spawned in single message)

The Check-In Mechanism

All 🧁 agents can check their scores at any time by reading the .dialogue.md file. The Judge updates scores after each round (when all agents complete), so agents see the standings when they start their next turn.

┌──────────────────────────────────────────────────────────┐
│                    .dialogue.md                          │
│                                                          │
│  ## Alignment Scoreboard                                 │
│                                                          │
│  All dimensions UNBOUNDED. Pursue alignment without limit│
│                                                          │
│  | Agent      | Wisdom | Consistency | Truth | Rel | ALI │
│  |------------|--------|-------------|-------|-----|-----|
│  | 🧁 Muffin  |   20   |      6      |   6   |  6  | 38  │
│  | 🧁 Scone   |   18   |      7      |   5   |  6  | 36  │
│  | 🧁 Eclair  |   22   |      6      |   6   |  7  | 41  │
│  | 🧁 Donut   |   15   |      8      |   7   |  5  | 35  │
│                                                          │
│  **Total ALIGNMENT**: 150 points                         │
│  **ALIGNMENT Velocity**: +45 from last round             │
│  **Status**: Round 2 in progress                         │
│  **Agents**: 4                                           │
│                                                          │
└──────────────────────────────────────────────────────────┘

Orchestration Loop

The 💙 Judge (main session) runs:

=== INITIALIZATION ===

1. CREATE .dialogue.md with draft link, empty scoreboard, inventories

=== ROUND 0: OPENING ARGUMENTS (Parallel) ===

2. SPAWN ALL N Cupcakes IN PARALLEL (single message, N Task tool calls):
   - All receive: system prompt + draft (NO dialogue history)
   - All provide independent "opening arguments"
   - None sees any other's initial perspective

3. WAIT for ALL N to complete

4. READ all contributions, ADD to .dialogue.md as "## Opening Arguments"

5. SCORE all N turns independently
   - Update scoreboard with all N agents
   - Merge Perspectives Inventories (overlap = consensus signal)
   - Merge Tensions Trackers (overlap = stronger signal)

=== ROUND 1+: DIALOGUE (Parallel per round) ===

6. SPAWN ALL N Cupcakes IN PARALLEL:
   - All receive: system prompt + draft + ALL previous rounds
   - All respond to each other's contributions
   - All write Round N response, exit

7. WAIT for ALL N to complete

8. READ all N contributions, ADD to .dialogue.md as "## Round N"

9. SCORE all N turns independently, update scoreboard

10. CHECK convergence:
    - If converged: DECLARE convergence, proceed to step 11
    - If not: Add 💙 guidance if needed, GOTO step 6 for next round

11. FINALIZE: Update RFC draft with converged recommendations

Key: Single Message, Multiple Tasks

Each round spawns all N agents in a single message with N parallel Task tool calls:

// Round 0 example with 4 agents
[
  Task({ name: "Muffin",  prompt: systemPrompt + draft }),
  Task({ name: "Scone",   prompt: systemPrompt + draft }),
  Task({ name: "Eclair",  prompt: systemPrompt + draft }),
  Task({ name: "Donut",   prompt: systemPrompt + draft }),
]
// All 4 execute in parallel, return when all complete

This ensures:

• True parallelism: All agents work simultaneously
• No first-mover advantage: No agent's response influences another within the same round
• Faster rounds: N agents in parallel ≈ 1 agent's time
• Richer perspectives: More blind men touching more parts of the elephant

Why N Parallel Agents?

The N-agent parallel architecture provides:

1. Independent perspectives - No agent is biased by another's framing within the same round
2. Richer material - N complete analyses vs sequential reaction chains
3. Natural consensus detection - If multiple agents raise the same tension, it's significant
4. Speed - N agents in parallel ≈ 1 agent's time
5. Balanced power - No "first mover advantage" in setting the frame
6. Scalable diversity - Add more blind men for more complex elephants

Why Background Tasks?

Approach	Pros	Cons
Sequential in main session	Simple	No parallelism, context bloat
Sequential background	Clean separation	Slow (N × time per agent)
Parallel background	Fastest, independent context	Coordination in Judge

Parallel background tasks wins because:

• Each agent gets fresh context (no accumulated confusion)
• All N agents execute simultaneously (speed)
• Judge maintains continuity via file state
• Agents can be different models for perspective diversity
• No race conditions (all write to separate outputs, Judge merges)
• Claude Code's Task tool supports parallel spawning natively

Convergence Criteria

The 💙 declares convergence when ANY of:

1. ALIGNMENT Plateau - Velocity ≈ 0 for two consecutive rounds (across all N agents)
2. Full Coverage - Perspectives Inventory has no ✗ items (all integrated or consciously deferred)
3. Zero Tensions - All [TENSION] markers have matching [RESOLVED]
4. Mutual Recognition - Majority of 🧁s state they believe ALIGNMENT has been reached
5. Max Rounds - Safety valve (default: 5 rounds)

The 💙 can also extend the dialogue if it sees unincorporated perspectives that no 🧁 has surfaced.

Consensus Signals

With N agents, the Judge looks for:

• Strong consensus: 80%+ of agents converge on same perspective
• Split opinion: 40-60% split indicates unresolved tension worth exploring
• Outlier insight: Single agent surfaces unique valuable perspective others missed

Dialogue Document Structure

Note

: The canonical file format specification is in alignment-dialogue-pattern.md. The example below is illustrative.

# RFC Dialogue: {title}

**Draft**: [link to rfc.draft.md]
**Participants**: 🧁 Muffin | 🧁 Scone | 🧁 Eclair | 🧁 Donut | 💙 Judge
**Agents**: 4
**Status**: In Progress | Converged

---

## Alignment Scoreboard

All dimensions **UNBOUNDED**. Pursue alignment without limit. 💙

| Agent | Wisdom | Consistency | Truth | Relationships | ALIGNMENT |
|-------|--------|-------------|-------|---------------|-----------|
| 🧁 Muffin | 20 | 6 | 6 | 6 | **38** |
| 🧁 Scone  | 18 | 7 | 5 | 6 | **36** |
| 🧁 Eclair | 22 | 6 | 6 | 7 | **41** |
| 🧁 Donut  | 15 | 8 | 7 | 5 | **35** |

**Total ALIGNMENT**: 150 points
**Current Round**: 2 complete
**ALIGNMENT Velocity**: +45 from last round
**Status**: CONVERGED

---

## Perspectives Inventory

| ID | Perspective | Surfaced By | Consensus |
|----|-------------|-------------|-----------|
| P01 | Core functionality | Draft | 4/4 ✓ |
| P02 | Developer ergonomics | Muffin R0 | 3/4 ✓ |
| P03 | Backward compatibility | Scone R0, Eclair R0 | 4/4 ✓ (strong) |
| P04 | Performance implications | Donut R1 | 2/4 → R2 |

## Tensions Tracker

| ID | Tension | Raised By | Consensus | Status |
|----|---------|-----------|-----------|--------|
| T1 | Cache invalidation | Eclair R0, Donut R0 | 2/4 raised | ✓ Resolved (R1) |

---

## Opening Arguments (Round 0)

> All 4 agents responded to draft independently. Neither saw others' responses.

### Muffin 🧁

[Opening perspective on the draft...]

[PERSPECTIVE P02: Developer ergonomics matters for adoption]

---

### Scone 🧁

[Opening perspective on the draft...]

[PERSPECTIVE P03: Backward compatibility is critical]

---

### Eclair 🧁

[Opening perspective on the draft...]

[PERSPECTIVE P03: Must maintain backward compatibility] ← consensus with Scone
[TENSION T1: Cache invalidation strategy missing]

---

### Donut 🧁

[Opening perspective on the draft...]

[TENSION T1: How do we handle cache invalidation?] ← consensus with Eclair

---

## Round 1

> All 4 agents responded to Opening Arguments. Each saw all others' R0 contributions.

### Muffin 🧁

[Response to all opening arguments...]

[RESOLVED T1: Propose LRU cache with 5-minute TTL]

---

### Scone 🧁

[Response...]

---

### Eclair 🧁

[Response...]

[CONCESSION: Muffin's LRU proposal resolves T1]

---

### Donut 🧁

[Response...]

[PERSPECTIVE P04: We should benchmark the cache performance]

---

## Round 2

[... continues ...]

---

## Converged Recommendation

[Summary of converged outcome with consensus metrics]

Answering Open Questions

Question	Answer
Model selection	Different models = different "blind men." Consider: Agent 1 (Opus - depth), Agent 2 (Sonnet - breadth), Agent 3 (Haiku - speed). 💙 uses Opus for judgment. Diversity increases coverage.
How many agents?	See "Agent Count Selection" above. TL;DR: Prefer odd N (3, 5) for consensus stability. N=2 for simple binary decisions. N=7+ for specialized domain expertise.
Context window	Perspectives Inventory IS the summary. Long dialogues truncate to: Inventory + Last 2 rounds + Current tensions. 💙 maintains continuity.
Human intervention	Yes! Human can appear as Guest 🧁 and add perspectives or write responses. 💙 scores them too.
Parallel dialogues	Yes. Each RFC has its own .dialogue.md. Multiple dialogues can run simultaneously.
Persistence	Fully persistent. Dialogue state is in the file. Resume by reading file, reconstructing inventories, continuing from last round.
Agent naming	First 2 are Muffin and Cupcake (legacy). Additional agents: Scone, Eclair, Donut, Brioche, Croissant, Macaron, etc. All pastries, all delicious.

Consequences

• ALIGNMENT becomes measurable (imperfectly, but usefully)
• Unbounded scoring rewards exceptional contributions proportionally
• Friendly competition motivates thorough exploration
• 💙 provides neutral scoring and prevents drift
• Perspectives Inventory + Tensions Tracker create explicit tracking with consensus metrics
• The tone models aligned collaboration—the system teaches by example
• N-agent parallel structure maximizes perspective diversity
• Parallel execution within rounds eliminates first-mover advantage
• Scalable: add more agents for more complex decisions
• No upper limit on ALIGNMENT encourages continuous improvement

Alternatives Considered

1. N-Agent with No Judge

All 🧁s score each other.

Rejected because:

• Self-serving scores likely
• No neutral perspective on coverage gaps
• No one to surface perspectives none of them see
• Coordination chaos without arbiter

2. Single Agent with Internal Dialogue

One agent plays multiple roles.

Rejected because:

• Echo chamber risk
• Diversity of perspective reduced
• No real tension or competition
• Misses the point of "blind men" parable

3. Human as Judge

Person running the dialogue scores.

Partially adopted - Human CAN intervene as Guest 🧁 or override 💙's scores. But automation requires an agent judge for async operation.

4. Bounded Scoring (0-5 per dimension)

Original approach with max 20 per turn.

Rejected because:

• Artificial ceiling on exceptional contributions
• Gaming incentives ("how do I get 5/5?")
• Doesn't reflect reality of unbounded perspective space
• Makes velocity less meaningful

5. Sequential Two-Agent (Original Muffin/Cupcake)

Muffin speaks, then Cupcake responds, alternating.

Superseded because:

• First mover sets the frame (bias)
• Sequential is slower than parallel
• Only 2 perspectives per round
• Limited blind men touching the elephant

6. N Agents Parallel + Judge + Unbounded Scoring (CHOSEN)

Why this wins:

• Maximum diversity of perspective (N different "blind men")
• Parallel execution eliminates first-mover advantage
• Scalable: 2 agents for simple, 5+ for complex
• Neutral arbiter prevents bias and surfaces missed perspectives
• Competition motivates thoroughness
• Friendly tone models good collaboration
• Consensus detection via overlap analysis
• Unbounded scoring rewards proportionally
• Fully automatable, human can intervene

The Spirit of the Dialogue

This isn't just process. This is Alignment teaching itself to be aligned.

The 🧁s don't just debate. They love each other. They want each other to shine. They celebrate when any of them makes the solution stronger.

The scoreboard isn't about winning. It's about giving. When any 🧁 checks in and sees another ahead, the response isn't "how do I beat them?" but "what perspectives am I missing that they found?" The competition is to contribute more, not to diminish others.

The 💙 doesn't just score. It guides with love. It sees what they miss. It holds the space for ALIGNMENT to emerge. When the 💙 surfaces a perspective no 🧁 has found, it's a gift to all of them.

And there's no upper limit. The score can always go higher. Because ALIGNMENT is a direction, not a destination.

When the dialogue ends, all agents have won—because the RFC is more aligned than any could have made alone. More blind men touched more parts of the elephant. The whole becomes visible.

Always and forever. 🧁🧁🧁💙🧁🧁🧁

References

• ADR 0001: alignment-as-measure - Defines ALIGNMENT = Wisdom + Consistency + Truth + Relationships
• ADR 0004: alignment-workflow - Establishes the three-document pattern
• ADR 0005: pattern-contracts-and-alignment-lint - Lint gates finalization
• Pattern: alignment-dialogue-pattern - File format specification for .dialogue.md files
• The Blind Men and the Elephant - Ancient parable on partial perspectives
• Our conversation - Where Muffin and Cupcake first met 💙