RFC: ADR-011 — Conflict resolution protocol (technical disagreements and merge conflicts)

[scottschreckengaust]

Summary

Define how technical disagreements between contributors (human or agent) are resolved, how merge conflicts between concurrent work are handled, and who has final authority when approaches compete.

Use case and motivation

Problem today:

1. Two agents working concurrently may propose incompatible approaches to the same problem.
2. Reviewer feedback may conflict with the original issue design — no escalation path exists.
3. Merge conflicts between concurrent PRs require someone to decide whose approach "wins."
4. Human-agent disagreements have no protocol (human overrides? agent justifies? escalate?).

After this ADR:

• Technical disagreements have a defined escalation ladder
• Merge conflicts have ownership rules (who resolves, who decides)
• Competing approaches are compared on explicit criteria (not authority or loudness)
• Final authority is defined per scope

Proposed protocol

Escalation ladder

Level 1: Contributor discussion (PR comments, issue thread)
   ↓ (no resolution within 2 interactions)
Level 2: Request additional reviewer (fresh perspective)
   ↓ (still no resolution)
Level 3: Write competing proposals in the issue body (explicit trade-off comparison)
   ↓ (still no resolution)
Level 4: Admin decision (binding, documented in issue body as resolution)

Decision criteria (when comparing approaches)

Evaluate competing approaches on:

1. Correctness — does it solve the stated problem?
2. Simplicity — fewer moving parts wins when correctness is equal
3. Consistency — does it follow existing patterns in the codebase?
4. Reversibility — can we change our mind later?
5. Blast radius — what breaks if this is wrong?

Merge conflict ownership

Situation	Who resolves
Two PRs modify the same file, one merged first	The second PR's author rebases and resolves
Stacked PR chain conflict from lower PR change	Lower PR author notifies; upper PRs rebase after base is stable
Concurrent agents modified the same module	First to merge wins; second must adapt
Architectural conflict (both valid, mutually exclusive)	Escalate to Level 3 (competing proposals)

Human vs. agent disagreement

• Agents must present evidence (code, tests, measurements) not authority
• Humans can override agent recommendations but must document why
• Agents should not repeatedly argue a rejected point — accept and move on
• If an agent believes a human decision will cause harm (security, data loss), it escalates to admin

Open questions

1. What counts as "2 interactions without resolution" — comments? Days?
2. Should competing proposals require proof-of-concept code or just written trade-offs?
3. How do we prevent the escalation ladder from becoming a veto mechanism for slow contributors?

Alignment

Aligns with Scale and collaboration — concurrent agents need a protocol when they collide.

Dependencies

• ADR-003 (RFC: ADR-003 — Contribution governance for async agents and humans #134) — governance (issue body as resolution record)
• ADR-005 — feedback loop (reviewer disagreements feed into this)
• ADR-009 — security (authority levels for decisions)

---

• RFC PR: (pending approval)
• Approved by: (pending)
• Reviewed by: (pending)