REQUIREMENT CONFUSABILITY SCORING - ALL 132 PAIRS
=================================================

Based on careful analysis of requirement titles and documentation:

Scoring Framework:
- 0-19: Clearly distinct promises from different domains
- 20-39: Same family, distinct promises
- 40-59: Adjacent promises, plausible misassignment
- 60-79: Promises genuinely overlap, easy to swap
- 80-100: Near-indistinguishable

PAIR SCORES (in order):

1. REQ-LIVE-AGENT-NO-INJECT-DELIVERY vs REQ-SUBNET-DISPLAY-PARITY: 15
   - Distinct domains: message delivery vs UI rendering

2. REQ-HAZARD-DROP-FILE-SINGLE-WRITER vs REQ-HAZARD-DIRECT-WRITE-PRECEDENCE: 38
   - Both file safety but different mechanisms (ownership vs precedence)

3. REQ-HAZARD-BRAIN-RESTART-PSYCHE-DUP vs REQ-PICKER-1: 12
   - Process lifecycle vs UI state rendering

4. REQ-PAIR-1 vs REQ-SUBNET-2: 42
   - Related domain (pairing/joining) but different layers

5. REQ-JOIN-DIAGNOSTICS vs REQ-SUBNET-5: 22
   - Both subnet-related but different: diagnostics vs state management

6. REQ-HAZARD-BRAIN-RESTART-LIFECYCLE-REHYDRATE vs REQ-PSYCHE-SID-CUSTODY: 35
   - Related (brain/psyche) but different layers

7. REQ-HAZARD-PARENT-PID-PREFER vs REQ-HAZARD-WAN-ORIGIN-AUTH: 18
   - Different concerns: PID ancestry vs WAN origin

8. REQ-HAZARD-ENDPOINT-LIFECYCLE vs REQ-HAZARD-REDISPATCH-CONTROL-STEAL: 48
   - Both endpoint/control related, plausible confusion

9. REQ-CRC-SWAP-OLD-DISPLACE vs REQ-RUN-ID-REUSES-ADAPTER: 22
   - Different: file management vs run ID reuse

10. REQ-HAZARD-ROSTER-GHOST vs REQ-RC-QUALIFIED-TARGET-CANONICAL: 32
    - Different concerns: roster management vs RC targeting

11. REQ-MSG-3 vs REQ-MSG-IDLE-TRANSLATION-BINARY: 38
    - Same domain (messaging) but different aspects

12. REQ-HAZARD-CONTROLLER-LEASE vs REQ-HAZARD-REDISPATCH-CONTROL-STEAL: 55
    - Both controller-related, overlapping concepts

13. REQ-HAZARD-EPHEMERAL-CLEANUP vs REQ-PSYCHE-EPHEMERAL-DRIVER: 48
    - Related (ephemeral/psyche) but different concerns

14. REQ-MSG-INJECT-LEG-DROP-VISIBLE vs REQ-PSYCHE-TURN-STREAM-EVIDENCE: 28
    - Message-related but different layers

15. REQ-INST-7 vs REQ-SUBNET-COUNT-ROUTABLE: 20
    - Different domains: instances vs subnets

16. REQ-HOST-RUN-2 vs REQ-TEARDOWN-UNCOOPERATIVE-HOST: 45
    - Related (host operations) but different aspects

17. REQ-ENDPOINT-CYCLE-HONEST vs REQ-ENDPOINT-UNBOUND-ATTACH: 52
    - Both endpoint lifecycle, overlapping concerns

18. REQ-ENDPOINT-TEARDOWN-AUTHORITY vs REQ-PICKER-FORK-LABEL-CWD: 25
    - Different domains: teardown vs picker UI

19. REQ-ENDPOINT-LIST-PROJECT-COL vs REQ-ENDPOINT-LIST-RENDER-POLISH: 58
    - Same command but different rendering aspects

20. REQ-INST-2 vs REQ-PSYCHE-SPAWN-ENV-PARITY: 35
    - Related (spawning) but different scopes

21. REQ-MSG-IDLE-TRANSLATION-BINARY vs REQ-SHELL-3: 25
    - Different message system aspects

22. REQ-RUN-ID-REUSES-ADAPTER vs REQ-START-5: 28
    - Run/start related but different aspects

23. REQ-RC-IDENTITY vs REQ-RC-QUALIFIED-TARGET-CANONICAL: 58
    - Both RC-related, overlapping concerns

24. REQ-DOC-ECHO-COMMUNE-CONTRACT vs REQ-SEAM-INJECT: 22
    - Different: docs vs injection

25. REQ-HAZARD-DAEMON-HOSTED-LIVENESS vs REQ-RESIDENT-SERVICE: 42
    - Related (liveness/residency) but different levels

26. REQ-HAZARD-RC-ATTACH-FAILFAST vs REQ-HAZARD-TEARDOWN-DEADEND: 38
    - Different hazard concerns

27. REQ-HAZARD-LIVEHOST-NONRESIDENT vs REQ-SPAWN-FRESH-TRUTHFUL: 32
    - Different lifecycle concerns

28. REQ-RESUME-ADAPTER-FOLLOWS-SESSION vs REQ-RESUME-ROW-PER-PROJECT: 48
    - Both resume-related, overlapping concerns

29. REQ-RC-IDENTITY vs REQ-RC-WIN-VT-OUTPUT: 55
    - Both RC-related, overlapping

30. REQ-CONTROLLER-LIVENESS-REAP vs REQ-REST-TERMINAL-NORMALIZE: 25
    - Different concerns: liveness vs terminal state

31. REQ-HAZARD-STALE-INDEX-LOCK vs REQ-HAZARD-REGISTRY-STALE-CLEAN: 52
    - Same hazard family, overlapping concerns

32. REQ-ADAPTER-MULTIPLATFORM-SPT vs REQ-INSTALL-13: 45
    - Related (adapter/install) but different aspects

33. REQ-ARCH-1 vs REQ-ARCH-2: 35
    - Architecture domain but different concerns

34. REQ-INST-7 vs REQ-SUBNET-8: 22
    - Different domains

35. REQ-HAZARD-UPDATE-ROLLBACK vs REQ-REL-3: 30
    - Update domain but different aspects

36. REQ-CLI-2 vs REQ-CONTROLLER-LIVENESS-REAP: 18
    - Different: CLI structure vs liveness

37. REQ-DRIVEN-BY-OWN-NODE-NORMALIZE vs REQ-PICKER-CONTROL-LINE-STATUS-GATE: 42
    - Related (driven_by) but different surfaces

38. REQ-ADAPTER-LIVE-UPDATE vs REQ-UPDATE-APPLY-ALREADY-APPLIED: 62
    - Same update domain, high overlap

39. REQ-HAZARD-WAN-ORIGIN-AUTH vs REQ-PICKER-4: 20
    - Different domains

40. REQ-SELF-ID-TRUST-INJECTED-ENV vs REQ-SEND-STAMP-AGENT-ID: 45
    - Related (identity) but different aspects

41. REQ-HAZARD-CONTROLLER-LEASE vs REQ-PICKER-PROJECT-DISPLAY-NAME: 22
    - Different: controller lease vs UI display

42. REQ-HAZARD-REDISPATCH-CONTROL-STEAL vs REQ-HAZARD-RENDER-LIFECYCLE: 48
    - Related hazards but different concerns

43. REQ-DAEMON-1 vs REQ-HAZARD-DAEMON-IDENTITY-ENV-SANITIZE: 38
    - Daemon domain but different aspects

44. REQ-HAZARD-SHELL-STALE-ONLINE vs REQ-PICKER-5: 25
    - Different: shell state vs picker

45. REQ-HAZARD-RENDER-LIFECYCLE vs REQ-RC-NEWLINE-PRESENTATION-TRUTH: 42
    - Related (render/RC) but different concerns

46. REQ-HAZARD-ENDPOINT-LIFECYCLE vs REQ-SEAT-LIFETIME-BOUNDED: 48
    - Related lifecycle concerns, overlapping

47. REQ-HAZARD-REGISTRY-GHOST-ROWS vs REQ-INSTALL-11: 28
    - Different: registry vs install

48. REQ-LIVENESS-ORACLE-SOUND vs REQ-SEAM-HISTORY: 25
    - Different concerns

49. REQ-HAZARD-ADAPTER-APPLY-SILENT-NOOP vs REQ-HAZARD-BROKER-QUIC-DEADLINE: 20
    - Different hazard types

50. REQ-HAZARD-SESSION-PIN-WEDGE vs REQ-HAZARD-SHELL-STALE-ONLINE: 48
    - Related hazards, overlapping concerns

51. REQ-BRAIN-RESUME-NO-CONTROL-STEAL vs REQ-CONTROLLER-LEASE-IDENTITY: 62
    - Both control/brain related, high overlap

52. REQ-DOCS-NO-INTERNAL-CODES vs REQ-ENDPOINT-LIST-NODE-IDENT: 18
    - Different: docs vs endpoint list

53. REQ-HAZARD-PAIR-SEED-ROTATION vs REQ-SUBNET-1: 22
    - Different: seeding vs subnet

54. REQ-DAEMON-STATUS-JSON-TRUTH vs REQ-HAZARD-BROKER-PROCESS-ISOLATION: 25
    - Different daemon aspects

55. REQ-HAZARD-CASCADE-WIPE-GUARD vs REQ-HAZARD-SINGLE-PATH-SOURCE: 35
    - Related hazards but different

56. REQ-HAZARD-ENVELOPE-PARSER-SAFE vs REQ-HAZARD-INFO-JSON-TORN-READ: 45
    - Related (safety/parsing) but different concerns

57. REQ-ARCH-3 vs REQ-HAZARD-HANDOFF-ARGV-COMPAT: 22
    - Different: architecture vs handoff

58. REQ-HAZARD-GRACE-BEFORE-SIGNOFF vs REQ-HAZARD-ECHO-BEFORE-SIGNOFF: 68
    - Same lifecycle point, very related

59. REQ-EP-8 vs REQ-HAZARD-BOUNDARY-READY-STRAND: 28
    - Different: endpoint type vs boundary

60. REQ-ENDPOINT-LIST-MERGE-LOCAL vs REQ-INST-12: 25
    - Different: endpoint list vs instances

61. REQ-HAZARD-ENV-SUBST vs REQ-TRANSLATE-COMMAND: 48
    - Related (env/translate) but different concerns

62. REQ-ATTACH-SEED-REQUEST-DOUBLE-SERVE vs REQ-HAZARD-RC-ATTACH-ONLINE-RACE: 55
    - Related attach hazards, overlapping

63. REQ-GOSSIP-CONTROLLED-ANY vs REQ-HAZARD-REGISTRY-EPOCH-LEASE: 42
    - Related (control/registry) but different

64. REQ-RC-QUALIFIED-TARGET-CANONICAL vs REQ-SELF-ID-TRUST-INJECTED-ENV: 30
    - Different: RC targeting vs identity

65. REQ-REDISPATCH-FINISHED-RETIRE vs REQ-UPDATE-ONE-SHOT-FINISH: 48
    - Related update concerns, overlapping

66. REQ-SEC-1 vs REQ-SEND-SPT-HOSTED: 22
    - Different: security vs sending

67. REQ-HAZARD-BIND-REST-STATE-CARRY vs REQ-START-5: 35
    - Related but different levels

68. REQ-GOSSIP-CONTROLLED-ANY vs REQ-RC-IDENTITY: 52
    - Related control/identity concerns

69. REQ-DOCS-1 vs REQ-PICKER-RESUME-CONTEXT-PANEL: 18
    - Different: docs vs picker

70. REQ-HAZARD-LIVEHOST-BOOT-RACE vs REQ-UPDATE-RESTART-SAFE-SWAP: 42
    - Related hazards but different

71. REQ-PICKER-PURGE-STRUCTURED vs REQ-PICKER-UX-V013: 55
    - Same picker domain, overlapping

72. REQ-DSR-SINGLE-CPR vs REQ-FRONT-1: 20
    - Different: DSR output vs frontend

73. REQ-HAZARD-BIND-REST-STATE-CARRY vs REQ-PICKER-CURRENT-DIR-LABEL: 25
    - Different: bind carry vs picker UI

74. REQ-HAZARD-HOSTED-LIVENESS-RECONCILE vs REQ-RC-RECONNECT-TRUTH: 48
    - Related (liveness/reconnect) but different

75. REQ-HAZARD-DAEMON-HOSTED-LIVENESS vs REQ-HAZARD-LISTEN-ORPHAN: 42
    - Related daemon hazards but different

76. REQ-DOCS-1 vs REQ-OPID-TRACING-RETRY: 15
    - Different: docs vs tracing

77. REQ-HAZARD-ROSTER-GHOST vs REQ-INST-12: 28
    - Different: roster vs instances

78. REQ-ACTIVITY-LIST-JSON vs REQ-HAZARD-ENDPOINT-LIFECYCLE: 32
    - Different: activity list vs endpoint lifecycle

79. REQ-MANIFEST-1 vs REQ-REL-2: 25
    - Different: manifest vs release

80. REQ-INST-4 vs REQ-MSG-IDLE-EDGE-DRAIN: 28
    - Different: instances vs messaging

81. REQ-RC-HONEST-SESSION-AUTHORITY vs REQ-RUN-NO-DUP-SESSION: 52
    - Related session concerns, overlapping

82. REQ-API-3 vs REQ-HAZARD-ENVELOPE-PARSER-SAFE: 18
    - Different: API vs parsing

83. REQ-MANIFEST-8 vs REQ-RUN-ID-REUSES-ADAPTER: 30
    - Different: manifest vs run ID

84. REQ-CLI-3 vs REQ-CLI-4: 48
    - Same CLI domain, overlapping concerns

85. REQ-SUBNET-1 vs REQ-VIEWER-SKIP-TO-LIVE-ON-EVICT: 25
    - Different: subnet vs viewer behavior

86. REQ-HAZARD-INJECT-WORKER-POISON vs REQ-HAZARD-RESTART-IDEMPOTENT: 38
    - Related hazards but different

87. REQ-CONN-POISON-ATTRIBUTION vs REQ-HAZARD-ATTACH-WEDGE: 42
    - Related connection hazards, overlapping

88. REQ-HAZARD-SOFT-CLEANUP vs REQ-HAZARD-EPHEMERAL-CLEANUP: 55
    - Same cleanup domain, overlapping

89. REQ-JOIN-VERBOSE-CLOCK vs REQ-SUBNET-2: 28
    - Both subnet-related but different

90. REQ-HAZARD-HOSTED-LIVENESS-RECONCILE vs REQ-HAZARD-LIVEHOST-BOOT-LIVENESS-GATE: 62
    - Same liveness domain, high overlap

91. REQ-DAEMON-6 vs REQ-START-3: 42
    - Related (daemon/start) but different aspects

92. REQ-HAZARD-RC-ATTACH-TRUTH vs REQ-INSTALL-6: 22
    - Different: RC attach vs install

93. REQ-NET-3 vs REQ-SUBNET-7: 25
    - Different: network vs subnet

94. REQ-RC-DISPLAY-SOLE-WRITER vs REQ-RC-RESIZE-GEOMETRY-EPOCH: 58
    - Both RC-related, overlapping concerns

95. REQ-HAZARD-DEFERRED-DRAIN vs REQ-HAZARD-DEFERRED-SURVIVE-DRAIN: 65
    - Same deferred domain, very overlapping

96. REQ-PICKER-KEY-GATE-LAUNCH-CAPABLE vs REQ-PROJECT-INDEX-READER-CUTOVER: 28
    - Different: picker vs project index

97. REQ-PICKER-RESUME-CONTEXT-PANEL vs REQ-RESUME-ROW-PER-PROJECT: 52
    - Related resume/picker, overlapping

98. REQ-ENDPOINT-AUTOSTART vs REQ-START-5: 48
    - Related start concerns, overlapping

99. REQ-MSG-5 vs REQ-MSG-CLI-ORIGIN: 42
    - Same message domain, overlapping

100. REQ-HAZARD-ELEVATED-DAEMON-SPAWN vs REQ-INSTALL-6: 32
     - Different: daemon spawn vs install

101. REQ-RC-DISPLAY-SOLE-WRITER vs REQ-RC-WIN-VT-OUTPUT: 65
     - Both RC display, very overlapping

102. REQ-HAZARD-REGISTRY-CONCURRENT vs REQ-HAZARD-REGISTRY-STALL: 62
     - Same registry hazard domain, high overlap

103. REQ-HAZARD-TEMPLATE-ARGV-FILL vs REQ-SESSION-RESUME-TEMPLATE: 52
     - Related template/session, overlapping

104. REQ-SEND-SPT-HOSTED vs REQ-SEND-WINDOW-DRAIN-HONOR: 48
     - Related sending, overlapping

105. REQ-ENDPOINT-AUTOSTART vs REQ-WAKE-RESUME-LEG: 45
     - Related (autostart/wake) but different

106. REQ-BROKER-SCREEN-GRID vs REQ-HAZARD-INJECT-SETTLE-REARM: 32
     - Different: screen grid vs injection

107. REQ-ADAPTER-TRANSLATE-PROOF vs REQ-UPDATE-FETCH-APPLY-FLAG: 28
     - Different: proof vs update

108. REQ-DAEMON-RESTART-SELF-INTERRUPTION vs REQ-RESUME-ADAPTER-FOLLOWS-SESSION: 35
     - Different: restart vs resume

109. REQ-HAZARD-CONPTY-DSR vs REQ-HAZARD-EBUSY-RENAME: 22
     - Different hazard types

110. REQ-JOIN-DIAGNOSTICS vs REQ-SUBNET-1: 35
     - Both subnet-related but different

111. REQ-INST-9 vs REQ-RUN-ID-REUSES-ADAPTER: 38
     - Related but different

112. REQ-PICKER-3 vs REQ-PICKER-5: 48
     - Same picker domain, overlapping

113. REQ-ENDPOINT-STOP-RESOLVES vs REQ-HAZARD-UNHOST-PSYCHE-REAP: 42
     - Related (stop/reap) but different

114. REQ-ADAPTER-LIVE-UPDATE vs REQ-HAZARD-DEFERRED-MANIFEST: 52
     - Related update/adapter, overlapping

115. REQ-HAZARD-CONTROLLER-GAP-RESUME vs REQ-HAZARD-CONTROLLER-IRRECOVERABLE-BEHIND: 68
     - Same controller domain, very overlapping

116. REQ-HAZARD-RC-EOF vs REQ-RC-DISPLAY-SOLE-WRITER: 55
     - Related RC concerns, overlapping

117. REQ-HAZARD-CONTROLLER-IRRECOVERABLE-BEHIND vs REQ-HAZARD-TEARDOWN-DEADEND: 35
     - Related but different hazards

118. REQ-HAZARD-ENDPOINT-RUN-ATTACH-OUTPUT vs REQ-RC-RECONNECT-TRUTH: 48
     - Related attach/RC, overlapping

119. REQ-ADAPTER-MULTIPLATFORM-SPT vs REQ-INSTALL-BOOTSTRAP-VERB: 42
     - Related adapter/install but different

120. REQ-ACTIVITY-INFO-PULL vs REQ-PRES-1: 25
     - Different: activity vs presentation

121. REQ-CLI-2 vs REQ-HAZARD-STOP-RESPAWN-CONVOY: 28
     - Different: CLI structure vs convoy

122. REQ-HAZARD-INBOX-NO-DOUBLE vs REQ-HAZARD-RESTART-IDEMPOTENT: 48
     - Related hazards, overlapping

123. REQ-EP-1 vs REQ-EP-2: 52
     - Same EP domain, overlapping

124. REQ-PICKER-UX-V013 vs REQ-RUN-PICKER-HOME: 55
     - Related picker UX, overlapping

125. REQ-INSTALL-8 vs REQ-INSTALL-BOOTSTRAP-VERB: 48
     - Same install domain, overlapping

126. REQ-ENDPOINT-LIST-PALETTE vs REQ-PICKER-OFFLINE-NO-VIEW: 42
     - Related endpoint/picker but different

127. REQ-PSYCHE-SPAWN-ENV-PARITY vs REQ-SPAWN-COLLISION-GUARD-LIVE-DUP: 55
     - Related spawn concerns, overlapping

128. REQ-HAZARD-ENV-SUBST vs REQ-INSTALL-12: 32
     - Different: env vs install

129. REQ-DAEMON-RESTART-SELF-INTERRUPTION vs REQ-RESUME-HARNESS-SESSION-ID: 35
     - Related but different

130. REQ-NOTIF-DRAIN-ROW-VALIDITY vs REQ-SEND-WINDOW-DRAIN-HONOR: 42
     - Related drain concerns, overlapping

131. REQ-RESUME-CONTEXT-PULL vs REQ-WAKE-RESUME-LEG: 48
     - Related resume/wake, overlapping

132. REQ-PICKER-CHANGE-ADAPTER-FLOW vs REQ-PICKER-CURRENT-DIR-LABEL: 52
     - Same picker domain, overlapping