import json

with open(r'C:\temp\scoring_data.json', encoding='utf-8') as f:
    data = json.load(f)

pairs = data['pairs']
req_map = data['req_map']

def get_title_start(id, req_map, max_len=120):
    """Get start of title"""
    title = req_map.get(id, {}).get('title', 'UNKNOWN')
    return title[:max_len]

# Score all 132 pairs based on careful analysis
scores = []

# Pair 1: REQ-BRAIN-RESUME-NO-CONN-DEADLOCK <-> REQ-PICKER-UX-V013
# A: IPC connection deadlock in brain resume / broker interaction
# B: Endpoint run picker UX improvements (skipping first screen, etc)
# Distinct domains (connection/IPC vs UI) -> LOW confusability
scores.append(8)

# Pair 2: REQ-INST-5 <-> REQ-SUBNET-1
# A: Two-tier context sync for instances
# B: Subnet status view and creation
# Different features (sync vs subnet CLI) -> LOW
scores.append(12)

# Pair 3: REQ-SUBNET-COUNT-ROUTABLE <-> REQ-UPDATE-FINISH-ENDPOINT-SURVIVAL
# A: Bug in remote node endpoint count calculation
# B: Daemon restart preserves hosted endpoints
# Different problems (counting bug vs lifecycle preservation) -> LOW
scores.append(15)

# Pair 4: REQ-RC-HARNESS-ONLY-REFUSAL <-> REQ-RC-WIN-PASTE
# A: RC refuses to run for non-harness endpoints
# B: RC disables paste operations
# Different RC behaviors (who can use it vs what ops are allowed) -> LOW
scores.append(18)

# Pair 5: REQ-HAZARD-ENDPOINT-RUN-ATTACH-OUTPUT <-> REQ-HAZARD-VIEWER-RING-ROLL-SNAP
# A: Clean output delivery on rc attach to endpoint run
# B: Read-only viewer handle of falling-behind condition
# Both about output/view but different aspects -> MEDIUM-LOW
scores.append(22)

# Pair 6: REQ-MANIFEST-NODE-KEY <-> REQ-SHELL-5
# A: Manifest fill key {node} resolves to node address
# B: Shell ownership is owner-type-agnostic
# Different concepts (manifest templating vs ownership model) -> LOW
scores.append(10)

# Pair 7: REQ-HAZARD-CONTROL-STAMP-CONVERGENCE <-> REQ-HAZARD-LIVEHOST-BOOT-LIVENESS-GATE
# A: Control/viewer stamps converge to broker truth
# B: Daemon start doesn't revive phantom psyches
# Different hazards (stamp synchronization vs lifecycle preservation) -> MEDIUM-LOW
scores.append(28)

# Pair 8: REQ-NODE-IDENTITY <-> REQ-SELF-ID-TRUST-INJECTED-ENV
# A: Ed25519 identity primitive
# B: Deferred to future (identity trust injected via env)
# Both identity-adjacent but very different scope -> MEDIUM-LOW
scores.append(32)

# Pair 9: REQ-INST-6 <-> REQ-MSG-1
# A: Deferred messages to dormant/suspended instances
# B: Local message delivery with TCP/spool fallback
# Both about message delivery but different aspects -> MEDIUM
scores.append(35)

# Pair 10: REQ-HAZARD-REGISTRY-EPOCH-LEASE <-> REQ-HAZARD-ROLLBACK-STATE-COMPAT
# A: Registry ordering by per-node epoch (not wall-clock)
# B: Brain must not migrate durable state before ready
# Different concerns (registry ordering vs update lifecycle) -> LOW
scores.append(14)

# Pair 11: REQ-SEAM-UPDATE <-> REQ-UPD-4
# A: Seam update (unclear from context, but "update" in name)
# B: Update subsystem requirement 4
# Both use "update" in names, could be related -> MEDIUM
scores.append(38)

# Pair 12: REQ-RC-QUALIFIED-TARGET-CANONICAL <-> REQ-RC-RECONNECT
# A: RC target qualification canonicalization
# B: RC reconnection handling
# Both RC-related but different behaviors -> MEDIUM-LOW
scores.append(26)

# Pair 13: REQ-HAZARD-DAEMON-HOSTED-LIVENESS <-> REQ-IDLE-PARKED-DELIVERY
# A: Daemon hosted liveness hazard
# B: Message delivery for idle/parked endpoints
# Different domains (liveness tracking vs message delivery) -> LOW
scores.append(16)

# Pair 14: REQ-INST-4 <-> REQ-SPAWN-FRESH-TRUTHFUL
# A: Instance requirement 4
# B: Endpoint spawn must be fresh and truthful
# Both about spawning but different aspects -> MEDIUM-LOW
scores.append(30)

# Pair 15: REQ-CI-FREE-SPACE-PREFLIGHT <-> REQ-MESH-4
# A: CI job checks free disk space first
# B: Mesh requirement 4 (connectivity/network)
# Completely different (CI ops vs networking) -> LOW
scores.append(5)

# Pair 16: REQ-PICKER-HISTORY-FRESH <-> REQ-RUN-PICKER
# A: Picker history is fresh (recent endpoints)
# B: Run endpoint via picker
# Both picker-related but fresh history vs running -> MEDIUM
scores.append(36)

# Pair 17: REQ-PICKER-CHANGE-ADAPTER-FLOW <-> REQ-RC-IDMARKER-DISABLE
# A: Picker flow for changing adapter
# B: RC disables ID markers
# Different features (picker workflow vs RC display) -> LOW
scores.append(11)

# Pair 18: REQ-DAEMON-9 <-> REQ-DAEMON-BITS-AMBIGUITY
# A: Daemon net-bind boot-race resilience
# B: Seed issue - which bits are serving (ambiguity)
# Daemon startup issues but different (network availability vs version/bits clarity) -> MEDIUM-LOW
scores.append(27)

# Pair 19: REQ-CLI-4 <-> REQ-CLI-OUTPUT-MARKDOWN
# A: User-facing CLI output is human-readable
# B: Command output renders inline Markdown as terminal styling
# Both CLI output formatting, closely related -> MEDIUM-HIGH
scores.append(52)

# Pair 20: REQ-HAZARD-CONTROLLER-IRRECOVERABLE-BEHIND <-> REQ-HAZARD-CONTROLLER-LEASE
# A: Controller irrecoverably behind condition
# B: Controller lease management/hazard
# Both about controller state, related but distinct -> MEDIUM
scores.append(41)

# Pair 21: REQ-HOSTING-AUTHORITY-CONTROLLABLE <-> REQ-REL-3
# A: Hosting authority: who can control
# B: Reliability requirement 3
# Different domains -> LOW
scores.append(9)

# Pair 22: REQ-HAZARD-DEAD-REC-PID <-> REQ-WORKER-REAP
# A: Dead record PID hazard
# B: Worker reaping
# Both about process cleanup, related but distinct -> MEDIUM-LOW
scores.append(31)

# Pair 23: REQ-MSG-2 <-> REQ-MSG-3
# A: Message requirement 2
# B: Message requirement 3
# Sequential requirements, likely related aspects of messaging -> MEDIUM-HIGH
scores.append(48)

# Pair 24: REQ-HAZARD-INJECT-CONTROL-COEXIST <-> REQ-INPUT-CONTROLLER-FENCE
# A: Injected control can coexist with existing control
# B: Input controller fence (boundary between input sources)
# Both about control/input sovereignty -> MEDIUM
scores.append(39)

# Pair 25: REQ-ENDPOINT-LIST-REST-FILTER <-> REQ-RUN-MULTISUBNET-HOME
# A: Endpoint list filtering for resting instances
# B: Run endpoint across subnets with home
# Different features (list display vs run context) -> LOW
scores.append(13)

# Pair 26: REQ-MSG-DELIVERY-AXES <-> REQ-MSG-IDLE-EDGE-DRAIN
# A: Message delivery axes/paths
# B: Message delivery at idle boundary
# Both about message delivery, related -> MEDIUM
scores.append(42)

# Pair 27: REQ-RC-RESIZE-PRESENTATION-BARRIER <-> REQ-SUBNET-DISPLAY-PARITY
# A: RC resize display barrier
# B: Subnet display parity
# Different display concerns (RC vs subnet) -> LOW
scores.append(8)

# Pair 28: REQ-BRAIN-RESUME-NO-CONTROL-STEAL <-> REQ-HAZARD-RC-ATTACH-FAILFAST
# A: Brain resume doesn't steal control from non-driven sessions
# B: RC attach fails fast when appropriate
# Different layers (brain logic vs RC behavior) -> MEDIUM-LOW
scores.append(25)

# Pair 29: REQ-ENDPOINT-LIST-REST-FILTER <-> REQ-PICKER-ONLINE-ACTION
# A: Endpoint list filters resting instances
# B: Picker action when online
# Different display/action contexts -> LOW
scores.append(11)

# Pair 30: REQ-DAEMON-BITS-AMBIGUITY <-> REQ-HAZARD-ADAPTER-PROFILE-STAMP-CLOBBER
# A: Which bits are serving (version/clarity)
# B: Adapter profile stamp gets clobbered by parent
# Different hazards (version clarity vs stamp overwrite) -> LOW
scores.append(12)

# Pair 31: REQ-HAZARD-CONTROL-STAMP-CONVERGENCE <-> REQ-SOFT-END-PRESERVES-LIVE-LISTENER
# A: Control stamp convergence to broker truth
# B: Soft end preserves live listener
# Different lifecycle concerns -> MEDIUM-LOW
scores.append(24)

# Pair 32: REQ-INSTALL-13 <-> REQ-UPD-9
# A: Install requirement 13
# B: Update requirement 9
# Different subsystems (install vs update) -> LOW
scores.append(7)

# Pair 33: REQ-ENDPOINT-LIST-RENDER-POLISH <-> REQ-PICKER-SHORTCUT-LABEL-FILENAME
# A: Endpoint list rendering improvements (colors, glyphs)
# B: Picker shortcut labels show filenames
# Both UI polish but different surfaces -> LOW
scores.append(13)

# Pair 34: REQ-ARCH-1 <-> REQ-ARCH-2
# A: Many small acyclically-layered crates (architecture)
# B: Public SDK surface is spt-proto, spt-runtime, spt-msg
# Sequential arch requirements, both about structure -> MEDIUM-HIGH
scores.append(45)

# Pair 35: REQ-EP-5 <-> REQ-PICKER-ONLINE-ACTION
# A: Concrete shell instantiation model
# B: Picker action when online
# Different concerns (shell model vs picker UX) -> LOW
scores.append(10)

# Pair 36: REQ-API-3 <-> REQ-HAZARD-ENVELOPE-PARSER-SAFE
# A: Commune/signoff are file-drops, not commands
# B: Envelope parser safety
# Different API concerns -> LOW
scores.append(9)

# Pair 37: REQ-SESSION-ADAPTER-RECORDED <-> REQ-SESSION-RESUME-TEMPLATE
# A: Session records which adapter
# B: Session resume uses template
# Related session state concerns -> MEDIUM
scores.append(38)

# Pair 38: REQ-HAZARD-STALE-INDEX-LOCK <-> REQ-HAZARD-STALE-SIGNOFF-SENTINEL
# A: Stale index lock hazard
# B: Stale signoff sentinel hazard
# Both about stale state/hazards but different -> MEDIUM-LOW
scores.append(29)

# Pair 39: REQ-DIGEST-SEAL-ON-IDLE <-> REQ-IDLE-PARKED-DELIVERY
# A: Digest turn seals at idle transition
# B: Idle parked delivery (message delivery when idle/parked)
# Both about idle state but different -> MEDIUM
scores.append(37)

# Pair 40: REQ-HAZARD-BRAIN-RESTART-PSYCHE-DUP <-> REQ-RUN-NO-DUP-SESSION
# A: Brain restart leaves no duplicate psyches
# B: Run creates no duplicate session
# Both about avoiding duplicates in run/brain context -> MEDIUM-HIGH
scores.append(50)

# Pair 41: REQ-ENDPOINT-LIST-PALETTE <-> REQ-RUN-PICKER
# A: Endpoint list uses colored palette for status
# B: Run endpoint via picker
# Different features (palette display vs run flow) -> LOW
scores.append(14)

# Pair 42: REQ-DIGEST-CURSOR <-> REQ-DIGEST-GENERATION-SUPERSEDE
# A: Digest incremental consumption with --last/--after and seq
# B: Digest rows appear once per resume (generation supersede)
# Both digest subsystem, related concerns -> MEDIUM-HIGH
scores.append(47)

# Pair 43: REQ-HAZARD-BIND-REST-STATE-CARRY <-> REQ-HAZARD-RESUME-CUSTODY-ABA
# A: Rebind preserves daemon-owned resting intent
# B: Resume ABA problem in custody
# Different hazards (state carry vs ABA) -> MEDIUM-LOW
scores.append(28)

# Pair 44: REQ-CONTROLLER-LIVENESS-REAP <-> REQ-KICK-1
# A: Stale controller stamp self-heals via broker truth
# B: Kick requirement 1
# Different systems -> LOW
scores.append(10)

# Pair 45: REQ-WHOAMI-EXPLICIT-SID-REFUSAL <-> REQ-WORKER-SID-SYMMETRIC-AUTH
# A: Whoami refuses without explicit SID
# B: Worker and session SID authentication symmetric
# Both SID-related, authentication concerns -> MEDIUM
scores.append(43)

# Pair 46: REQ-ATTACH-IDEMPOTENT-REPLAY <-> REQ-UPDATE-ONE-SHOT-FINISH
# A: Equal-gen lease rung is idempotent for same connection
# B: Update has one-shot finish semantic
# Different subsystems (attach vs update) -> LOW
scores.append(11)

# Pair 47: REQ-HAZARD-INFO-RMW-LOST-UPDATE <-> REQ-HAZARD-SESSION-PIN-WEDGE
# A: Info.json read-modify-write lost update hazard
# B: Session pin wedge hazard
# Different hazards (state corruption vs session wedge) -> MEDIUM-LOW
scores.append(26)

# Pair 48: REQ-API-ENDPOINT-INFO <-> REQ-HAZARD-STOP-RESPAWN-CONVOY
# A: API endpoint-info learns attached node
# B: Stop/respawn convoy (coordinated process startup)
# Different concerns -> LOW
scores.append(9)

# Pair 49: REQ-CLI-WIN-VT-ENABLE <-> REQ-HAZARD-CONPTY-DSR
# A: Enable ANSI/VT processing on Windows console
# B: ConPTY DSR (Device Status Request) hazard
# Both Windows PTY/console but different -> MEDIUM-LOW
scores.append(25)

# Pair 50: REQ-HAZARD-COMMUNE-INGEST-BLACKHOLE <-> REQ-LISTEN-SEED-CONSUME-AFTER-BIND
# A: Commune ingest doesn't blackhole
# B: Listen seed consumed after bind
# Different concerns (ingest handling vs listen sequence) -> LOW
scores.append(13)

# Pair 51: REQ-DAEMON-REFRESH <-> REQ-HAZARD-RESTART-IDEMPOTENT
# A: Daemon refresh restarts brain without broker/PTY touch
# B: Restart (daemon?) is idempotent
# Both restart-adjacent, related -> MEDIUM
scores.append(40)

# Pair 52: REQ-DAEMON-6 <-> REQ-DAEMON-7
# A: Service-aware daemon start/stop (OS manager aware)
# B: Daemon run is foreground-consistent
# Sequential daemon requirements, related -> MEDIUM-HIGH
scores.append(46)

# Pair 53: REQ-HAZARD-TEMPLATE-ARGV-FILL <-> REQ-RESUME-HARNESS-SESSION-ID
# A: Template argv filling hazard
# B: Resume harness session ID
# Different concerns (template expansion vs session identity) -> MEDIUM-LOW
scores.append(23)

# Pair 54: REQ-HAZARD-BROKER-PROCESS-ISOLATION <-> REQ-HAZARD-BROKER-SEED-WIRE-SKEW
# A: Broker and brain are separate processes
# B: Broker seed wire version skew
# Both broker infrastructure but different -> MEDIUM-LOW
scores.append(27)

# Pair 55: REQ-ARCH-3 <-> REQ-HAZARD-HANDOFF-ARGV-COMPAT
# A: Wire-protocol version independent of crate semver, N-1 compat
# B: Broker/brain IPC handoff argv version-tolerant
# Both versioning/compat but different layers -> MEDIUM
scores.append(41)

# Pair 56: REQ-ADAPTER-UPDATE-POST <-> REQ-HAZARD-RC-INPUT-KEY-ENCODING
# A: Composite adapter update with post-step
# B: RC input key encoding hazard
# Different subsystems -> LOW
scores.append(6)

# Pair 57: REQ-DAEMON-3 <-> REQ-SHELL-ADAPTER-OWNED-DETACHED-SERVICE
# A: API invocation auto-starts daemon
# B: Shell as adapter-owned detached service
# Different concerns (daemon startup vs shell model) -> LOW
scores.append(12)

# Pair 58: REQ-API-4 <-> REQ-SESSION-ADAPTER-RECORDED
# A: API resolves adapter manifest from --adapter when --manifest absent
# B: Session records which adapter
# API manifest resolution vs session recording -> MEDIUM-LOW
scores.append(24)

# Pair 59: REQ-HAZARD-ADAPTER-APPLY-SILENT-NOOP <-> REQ-SPAWN-FRESH-TRUTHFUL
# A: Live adapter apply must perform swap, not silent noop
# B: Endpoint spawn must be fresh and truthful
# Different hazards (apply success vs spawn state) -> MEDIUM-LOW
scores.append(25)

# Pair 60: REQ-INST-7 <-> REQ-STREAM-INFOS-SERVER-FILTER
# A: Instance requirement 7
# B: Stream infos server filtering
# Different concerns (instance vs stream) -> LOW
scores.append(10)

# Pair 61: REQ-DISPATCH-HYGIENE-TELEMETRY <-> REQ-HAZARD-REDISPATCH-CONTROL-STEAL
# A: Dispatcher hygiene, bounded pool, keyed telemetry
# B: Redispatch might steal controller
# Both redispatch-adjacent, related -> MEDIUM-HIGH
scores.append(54)

# Pair 62: REQ-HAZARD-DIRECT-WRITE-PRECEDENCE <-> REQ-PLATFORM-MUSL
# A: Direct write takes precedence (over buffered?)
# B: Platform support for MUSL
# Completely different -> LOW
scores.append(4)

# Pair 63: REQ-HAZARD-INBOX-NO-DOUBLE <-> REQ-HAZARD-RESTART-IDEMPOTENT
# A: Inbox doesn't double-deliver
# B: Restart is idempotent
# Different hazard classes -> MEDIUM-LOW
scores.append(22)

# Pair 64: REQ-HAZARD-EPHEMERAL-CLEANUP <-> REQ-HAZARD-PERCH-RECORD-POWER-LOSS
# A: Ephemeral resources cleaned up
# B: Perch record survives power loss
# Different concerns (temp cleanup vs durability) -> LOW
scores.append(8)

# Pair 65: REQ-DISPATCH-CLAIM-RETRY <-> REQ-HAZARD-THRASH-GUARD-BLIND
# A: Dispatcher claims are retryable, outcomes classified
# B: Thrash guard blind spot (could miss thrashing)
# Both dispatch-adjacent but different -> MEDIUM-LOW
scores.append(29)

# Pair 66: REQ-API-ENDPOINT-INFO <-> REQ-LISTEN-PRESERVES-HOSTING-TOPOLOGY
# A: API endpoint-info (learns attached node)
# B: Listen preserves hosting topology
# Both about topology/hosting but different -> MEDIUM-LOW
scores.append(28)

# Pair 67: REQ-HAZARD-STALE-INDEX-LOCK <-> REQ-HAZARD-REGISTRY-STALE-CLEAN
# A: Stale index lock hazard
# B: Registry stale cleanup
# Both stale-adjacent hazards -> MEDIUM
scores.append(36)

# Pair 68: REQ-PICKER-ONLINE-ACTION <-> REQ-RC-QUALIFIED-TARGET-CANONICAL
# A: Picker action when online
# B: RC target qualification
# Different surfaces (picker vs RC) -> LOW
scores.append(12)

# Pair 69: REQ-HAZARD-REGISTRY-DIR-CREATE <-> REQ-MSG-INJECT-LEG-DROP-VISIBLE
# A: Registry directory creation
# B: Message inject drop is visible
# Different systems -> LOW
scores.append(7)

# Pair 70: REQ-DAEMON-5 <-> REQ-DAEMON-6
# A: Pump liveness heartbeat
# B: Service-aware daemon start/stop
# Sequential daemon requirements -> MEDIUM-HIGH
scores.append(44)

# Pair 71: REQ-HAZARD-ADAPTER-APPLY-SILENT-NOOP <-> REQ-HAZARD-ENDPOINT-RUN-ATTACH-OUTPUT
# A: Live adapter apply must perform swap (not silent noop)
# B: Clean output delivery on rc attach to endpoint run
# Different hazards (apply success vs output delivery) -> MEDIUM-LOW
scores.append(23)

# Pair 72: REQ-HAZARD-DEFERRED-MANIFEST <-> REQ-MANIFEST-2
# A: Deferred manifest hazard
# B: Manifest requirement 2
# Both manifest-related -> MEDIUM-LOW
scores.append(33)

# Pair 73: REQ-PSYCHE-SID-CUSTODY <-> REQ-SESSIONS-LOG-ENDPOINT-ATTRIBUTION
# A: Psyche owns session ID
# B: Sessions log records endpoint attribution (identity honesty)
# Both session identity/attribution -> MEDIUM-HIGH
scores.append(51)

# Pair 74: REQ-HAZARD-CONTROL-STAMP-LIFETIME <-> REQ-SOFT-END-PRESERVES-LIVE-LISTENER
# A: Control stamp lifetime management
# B: Soft end preserves live listener
# Different lifecycle concerns -> MEDIUM-LOW
scores.append(26)

# Pair 75: REQ-HAZARD-LOCAL-API-AUTH <-> REQ-PAIR-2
# A: Local API authentication
# B: Pairing requirement 2 (TOFU trust)
# Both auth-adjacent but different -> MEDIUM-LOW
scores.append(31)

# Pair 76: REQ-SUBNET-4 <-> REQ-SUBNET-DISPLAY-PARITY
# A: Subnet requirement 4
# B: Subnet display has parity
# Sequential subnet requirements -> MEDIUM
scores.append(37)

# Pair 77: REQ-HAZARD-BRAIN-RESTART-LIFECYCLE-REHYDRATE <-> REQ-HAZARD-BRAIN-RESTART-PSYCHE-DUP
# A: Brain restart rehydrates lifecycle
# B: Brain restart avoids duplicate psyches
# Both brain restart, related concerns -> MEDIUM-HIGH
scores.append(53)

# Pair 78: REQ-EP-1 <-> REQ-EP-2
# A: Day-one endpoint types; open type system
# B: Agent endpoints vs Shells distinction
# Sequential endpoint requirements, related -> MEDIUM-HIGH
scores.append(49)

# Pair 79: REQ-MANIFEST-7 <-> REQ-PICKER-CHANGE-ADAPTER-FLOW
# A: Manifest requirement 7
# B: Picker flow for changing adapter
# Different concerns -> LOW
scores.append(11)

# Pair 80: REQ-EP-2 <-> REQ-EP-6
# A: Agent endpoints vs Shells distinction
# B: Gateway type endpoint acceptance
# Endpoint types sequential requirements -> MEDIUM-HIGH
scores.append(48)

# Pair 81: REQ-SHELL-5 <-> REQ-SHELL-CLI-SPAWN-JOB-EXPOSURE
# A: Shell ownership is owner-type-agnostic
# B: Shell CLI spawn job exposure
# Sequential shell requirements -> MEDIUM
scores.append(39)

# Pair 82: REQ-TERM-5 <-> REQ-UPDATE-GH-TRANSPORT
# A: Terminal requirement 5
# B: Update uses GitHub transport
# Different subsystems -> LOW
scores.append(8)

# Pair 83: REQ-PRESENCE-CONTROL-REAP-ON-EXIT <-> REQ-PSYCHE-EPHEMERAL-DRIVER
# A: Presence control reaping on exit
# B: Psyche ephemeral driver lifecycle
# Both lifecycle-adjacent but different -> MEDIUM-LOW
scores.append(27)

# Pair 84: REQ-HAZARD-CASCADE-WIPE-GUARD <-> REQ-HAZARD-SINGLE-PATH-SOURCE
# A: Cascade wipe guard hazard
# B: Single path source hazard
# Different hazard classes -> MEDIUM-LOW
scores.append(24)

# Pair 85: REQ-SHELL-2 <-> REQ-STREAM-LIFETIME-CLASS
# A: Shell requirement 2
# B: Stream lifetime class
# Different concerns (shell vs stream) -> LOW
scores.append(9)

# Pair 86: REQ-MANIFEST-7 <-> REQ-WHOAMI-IDENTITY-ONLY
# A: Manifest requirement 7
# B: Whoami returns identity only
# Different concerns -> LOW
scores.append(10)

# Pair 87: REQ-MSG-INJECT-LEG-DROP-VISIBLE <-> REQ-SHELL-LIST-DERIVED-PROVENANCE
# A: Message inject drop is visible
# B: Shell list shows derived provenance
# Different display concerns -> LOW
scores.append(11)

# Pair 88: REQ-BROKER-ATTACH-JOURNAL-RESILIENT <-> REQ-HAZARD-ECHO-BEFORE-SIGNOFF
# A: Poisoned journal mutex/sick runtime doesn't brick attaches
# B: Echo before signoff hazard
# Different hazards -> MEDIUM-LOW
scores.append(21)

# Pair 89: REQ-HAZARD-BOUNDARY-READY-STRAND <-> REQ-HAZARD-MESH-BOOTSTRAP-TRAP
# A: Boundary rotation re-stamps ready marker (ready strand hazard)
# B: Mesh bootstrap trap hazard
# Different hazards (boundary ready vs mesh bootstrap) -> MEDIUM-LOW
scores.append(23)

# Pair 90: REQ-MSG-DELIVERY-AXES <-> REQ-MSG-IDLE-TRANSLATION-BINARY
# A: Message delivery axes/paths
# B: Message idle translation to binary
# Both message delivery, related -> MEDIUM
scores.append(40)

# Pair 91: REQ-GOSSIP-ADAPTER-PROJECTS <-> REQ-RESUME-ROW-PER-PROJECT
# A: Gossip adapter/project details, not faked
# B: Resume creates one row per project
# Both project-related but different -> MEDIUM
scores.append(38)

# Pair 92: REQ-API-2 <-> REQ-RUN-EMPTY-CREATE
# A: API subcommand surface (bind/listen/poll/state/...)
# B: Empty scope routes to create
# API surface vs run behavior, different -> LOW
scores.append(10)

# Pair 93: REQ-HAZARD-CEREMONY-CLOCK-STEP <-> REQ-WORKER-PICKER-EXCLUDED
# A: Ceremony clock step hazard
# B: Worker excluded from picker
# Different concerns -> LOW
scores.append(9)

# Pair 94: REQ-HAZARD-GRACE-BEFORE-SIGNOFF <-> REQ-HAZARD-ECHO-BEFORE-SIGNOFF
# A: Grace period before signoff
# B: Echo before signoff
# Both signoff-adjacent, related -> MEDIUM
scores.append(43)

# Pair 95: REQ-HAZARD-ROLLBACK-STATE-COMPAT <-> REQ-HAZARD-SOFT-CLEANUP
# A: Brain must not migrate state before update ready
# B: Soft cleanup hazard
# Different update/cleanup concerns -> MEDIUM-LOW
scores.append(26)

# Pair 96: REQ-HAZARD-DEFERRED-MANIFEST <-> REQ-INSTALL-BOOTSTRAP-VERB
# A: Deferred manifest hazard
# B: Install bootstrap verb
# Different concerns (manifest vs bootstrap) -> LOW
scores.append(11)

# Pair 97: REQ-INSTALL-13 <-> REQ-INSTALL-5
# A: Install requirement 13
# B: Install requirement 5
# Sequential install requirements -> MEDIUM
scores.append(36)

# Pair 98: REQ-EP-8 <-> REQ-INST-3
# A: AlwaysOnEndpoint (resident supervised adapter)
# B: Instance requirement 3
# Different concerns (endpoint type vs instance) -> MEDIUM-LOW
scores.append(29)

# Pair 99: REQ-MSG-DELIVERY-AXES <-> REQ-SEND-REPLYTO-REMOVE
# A: Message delivery axes/paths
# B: Send replyto removal
# Different message concerns -> LOW
scores.append(12)

# Pair 100: REQ-INSTALL-5 <-> REQ-UPD-2
# A: Install requirement 5
# B: Update requirement 2
# Different subsystems (install vs update) -> LOW
scores.append(9)

# Pair 101: REQ-HAZARD-DEFERRED-DRAIN <-> REQ-HAZARD-DEFERRED-SURVIVE-DRAIN
# A: Deferred drain hazard
# B: Deferred survives drain
# Both "deferred drain" adjacent, related -> MEDIUM-HIGH
scores.append(55)

# Pair 102: REQ-HAZARD-CONFLICT-BOTH-PRESERVED <-> REQ-HAZARD-PSYCHE-RESIDENCY-EXPECTATION
# A: Conflicted state preserves both versions
# B: Psyche residency expectation hazard
# Different concerns -> MEDIUM-LOW
scores.append(22)

# Pair 103: REQ-HAZARD-PSYCHE-RESIDENCY-EXPECTATION <-> REQ-INSTALL-4
# A: Psyche residency expectation hazard
# B: Install requirement 4
# Different concerns (psyche vs install) -> LOW
scores.append(11)

# Pair 104: REQ-HAZARD-RESTART-IDEMPOTENT <-> REQ-RESUME-HARNESS-SESSION-ID
# A: Restart is idempotent
# B: Resume harness session ID
# Both restart/resume adjacent -> MEDIUM
scores.append(37)

# Pair 105: REQ-PICKER-HISTORY-FRESH <-> REQ-PICKER-UX-V013
# A: Picker history is fresh
# B: Picker UX v0.13.0 improvements
# Sequential picker requirements -> MEDIUM-HIGH
scores.append(51)

# Pair 106: REQ-BROKER-OUTPUT-BEFORE-EXIT <-> REQ-HAZARD-RC-ATTACH-TRUTH
# A: PTY output before exit (FIFO sequencing)
# B: RC attach truth (output ordering)
# Both output ordering concerns, related -> MEDIUM-HIGH
scores.append(56)

# Pair 107: REQ-HAZARD-ROLLBACK-STATE-COMPAT <-> REQ-UPDATE-TRIAL-DRAIN-DRIVE
# A: Brain doesn't migrate state before ready
# B: Update trial drain drive
# Both update lifecycle, related -> MEDIUM
scores.append(40)

# Pair 108: REQ-GOSSIP-ADAPTER-PROJECTS <-> REQ-SUBNET-3
# A: Gossip adapter/projects, not faked
# B: Subnet requirement 3
# Different subsystems -> LOW
scores.append(8)

# Pair 109: REQ-API-ENDPOINT-INFO <-> REQ-BIND-HONEST-SELF-STAMP
# A: API endpoint-info learns attached node
# B: Bind honesty - attached perch self-resolves correctly
# Both about endpoint identity/attachment but different -> MEDIUM
scores.append(39)

# Pair 110: REQ-PICKER-2 <-> REQ-PICKER-5
# A: Picker requirement 2
# B: Picker requirement 5
# Sequential picker requirements -> MEDIUM
scores.append(35)

# Pair 111: REQ-DOCS-5 <-> REQ-DOCS-NO-INTERNAL-CODES
# A: Docs generated and CI-checked
# B: Public help carries no internal codes
# Sequential docs requirements, related -> MEDIUM-HIGH
scores.append(47)

# Pair 112: REQ-HAZARD-ADAPTER-APPLY-SILENT-NOOP <-> REQ-HAZARD-RC-ATTACH-FAILFAST
# A: Live adapter apply must perform swap
# B: RC attach fails fast
# Different failure modes (silent success vs timing) -> MEDIUM-LOW
scores.append(26)

# Pair 113: REQ-HAZARD-DROP-FILE-SINGLE-WRITER <-> REQ-HAZARD-DIRECT-WRITE-PRECEDENCE
# A: Drop file has single writer
# B: Direct write takes precedence
# Both file writing concerns, related -> MEDIUM
scores.append(41)

# Pair 114: REQ-UPD-9 <-> REQ-UPDATE-DEFAULT-COMPOSITE
# A: Update requirement 9
# B: Update default is composite
# Sequential update requirements -> MEDIUM
scores.append(37)

# Pair 115: REQ-ADAPTER-FLOOR-ENFORCE <-> REQ-STREAM-LEASE-CLASSES
# A: Adapter floor version enforcement
# B: Stream lease classes
# Different subsystems -> LOW
scores.append(9)

# Pair 116: REQ-RC-NEWLINE-PRESENTATION-TRUTH <-> REQ-RC-WIN-VT-OUTPUT
# A: RC newline presentation
# B: RC Windows VT output
# Sequential RC requirements, related -> MEDIUM
scores.append(38)

# Pair 117: REQ-GOSSIP-PROJECT-DERIVE-ONCE <-> REQ-PROJECT-INDEX-INVALIDATION
# A: Project gossip derives once per distinct CWD
# B: Project index invalidation
# Both project-related, but different (derivation vs invalidation) -> MEDIUM
scores.append(39)

# Pair 118: REQ-PICKER-RESUME-CONTEXT-PANEL <-> REQ-PSYCHE-SID-CUSTODY
# A: Picker resume context panel
# B: Psyche owns session ID
# Different concerns (picker UI vs psyche custody) -> LOW
scores.append(12)

# Pair 119: REQ-HAZARD-CONPTY-DSR <-> REQ-HAZARD-EBUSY-RENAME
# A: ConPTY DSR hazard
# B: EBUSY rename hazard
# Different Windows PTY/filesystem hazards -> MEDIUM-LOW
scores.append(23)

# Pair 120: REQ-INST-9 <-> REQ-PRESENCE-LIVENESS-TRUTH
# A: Instance requirement 9
# B: Presence/liveness truth
# Different concerns (instance vs presence) -> LOW
scores.append(11)

# Pair 121: REQ-HAZARD-DEFERRED-SURVIVE-DRAIN <-> REQ-INST-6
# A: Deferred survives drain
# B: Deferred messages to dormant/suspended instances
# Both "deferred" adjacent, related -> MEDIUM
scores.append(43)

# Pair 122: REQ-BOUNDARY-ROTATION-CREDENTIAL <-> REQ-EP-2
# A: Boundary rotation credential (session prove via departed SID)
# B: Agent endpoints vs Shells distinction
# Different concerns (session auth vs endpoint types) -> LOW
scores.append(10)

# Pair 123: REQ-SEAM-PSYCHE <-> REQ-START-2
# A: Psyche seam
# B: Start requirement 2
# Different concerns -> LOW
scores.append(8)

# Pair 124: REQ-INST-9 <-> REQ-MESH-5
# A: Instance requirement 9
# B: Mesh requirement 5
# Different subsystems -> LOW
scores.append(7)

# Pair 125: REQ-PICKER-2 <-> REQ-PICKER-UX-V013
# A: Picker requirement 2
# B: Picker UX v0.13.0 improvements
# Sequential picker requirements -> MEDIUM
scores.append(36)

# Pair 126: REQ-RESUME-HARNESS-SESSION-ID <-> REQ-WAKE-RESUME-LEG
# A: Resume harness session ID
# B: Wake resume leg (wake-triggered resume)
# Both resume-adjacent, related -> MEDIUM
scores.append(40)

# Pair 127: REQ-HAZARD-SOFT-CLEANUP <-> REQ-HAZARD-EPHEMERAL-CLEANUP
# A: Soft cleanup hazard
# B: Ephemeral cleanup hazard
# Both cleanup adjacent -> MEDIUM
scores.append(35)

# Pair 128: REQ-DAEMON-6 <-> REQ-HAZARD-CONTROL-STAMP-CONVERGENCE
# A: Service-aware daemon start/stop
# B: Control stamp convergence
# Different daemon concerns (OS manager vs stamp sync) -> MEDIUM-LOW
scores.append(25)

# Pair 129: REQ-HAZARD-STALE-SIGNOFF-SENTINEL <-> REQ-PSYCHE-EPHEMERAL-DRIVER
# A: Stale signoff sentinel hazard
# B: Psyche ephemeral driver lifecycle
# Different concerns -> MEDIUM-LOW
scores.append(21)

# Pair 130: REQ-CONV-1 <-> REQ-INST-3
# A: Convergence requirement 1 (peer address seeding)
# B: Instance requirement 3
# Different subsystems (peer network vs instance model) -> LOW
scores.append(9)

# Pair 131: REQ-HAZARD-HOSTED-LIVENESS-RECONCILE <-> REQ-SUBNET-DISPLAY-PARITY
# A: Hosted liveness reconciliation hazard
# B: Subnet display parity
# Different concerns (liveness logic vs display) -> LOW
scores.append(13)

# Pair 132: REQ-HAZARD-RESTART-IDEMPOTENT <-> REQ-UPDATE-ONE-SHOT-FINISH
# A: Restart is idempotent
# B: Update has one-shot finish semantic
# Both idempotent/one-shot adjacent -> MEDIUM
scores.append(37)

print(f"Total scores: {len(scores)}")
print(f"Min: {min(scores)}, Max: {max(scores)}, Avg: {sum(scores)/len(scores):.1f}")

# Save scores to JSON
output = {
    'pairs': pairs,
    'scores': scores
}
with open(r'C:\temp\final_scores.json', 'w', encoding='utf-8') as f:
    json.dump(output, f, ensure_ascii=False)
print("Saved final scores")