Wire relationship directionality and dualpath controls propagation

Symmetric relationship types (isdirectional flag, migration 7d19) show
one entry per peer on the relationships card - a Dualpath pair no
longer lists its partner twice - and directional types read naturally
instead of Outgoing/Incoming. Deleting a collapsed entry removes every
underlying direction row.

Propagation is now real (migration 7d20): relationship types declare
propagation-through pairs in relationshiptypepropagations (M:N,
replacing the never-consumed single column); creating a controls link
on either bay of a Dualpath pair auto-creates it on the partner,
mirrored across both endpoints because live data stores controls as
bay -> PC. flask relationships propagate backfills existing data (29
rows fanned out on the WJ dataset, idempotent).

This also completes the tree that commit 1d21bf0 accidentally split
(core/models/__init__ imported RelationshipTypePropagation ahead of the
file that defines it), returning CI to green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

shopdb/core/models/relationship.py

@@ -21,30 +21,78 @@ class RelationshipType(BaseModel):
     description = db.Column(db.Text)
     color = db.Column(db.String(20), comment='CSS color for relationship badges')
 
-    # Sibling propagation (ADR-001): when a relationship of this type is
-    # created/deleted, the framework finds all assets related to the source
-    # via the type at propagatesthroughid and mirrors the change. Null means
-    # no propagation. Seeded values:
-    #   partof       -> null (propagation rail itself)
-    #   controls     -> partof (controls propagates across siblings)
-    #   connectedto  -> null (network paths don't propagate)
-    propagatesthroughid = db.Column(
-        db.Integer,
-        db.ForeignKey('relationshiptypes.relationshiptypeid'),
-        nullable=True,
-        comment='Sibling-propagation rail per ADR-001'
+    # True: edge has a source->target meaning (controls, partof, Backup For).
+    # False: symmetric link (Dualpath, connectedto, USB...) shown on the card
+    # once per peer with no direction, both stored direction rows collapsed.
+    isdirectional = db.Column(
+        db.Boolean,
+        default=True,
+        nullable=False,
+        server_default='1',
+        comment='False = symmetric connection, shown direction-blind'
     )
 
+    # Sibling propagation (ADR-001), WIRED. When a relationship of this type is
+    # created, the create path fans it out across every through-type in this
+    # type's propagation set (relationshiptypepropagations rows). For each
+    # SYMMETRIC through-type P, the source's edge to the target is mirrored to
+    # every asset linked to the target via P. This is M:N so one type can
+    # propagate through several rails at once. Seeded rows on this DB:
+    #   controls -> partof   (declared; directional rail, NOT consumed yet -
+    #                         parent/child fan-out direction is ambiguous)
+    #   controls -> Dualpath (consumed; a dual-bay pair is one physical machine
+    #                         with one controller, so both bays carry controls)
+    # A dual-bay Dualpath pair thus gets the PC's controls link on both bays.
+    # propagatesthrough is the list of through-type RelationshipType rows.
     propagatesthrough = db.relationship(
         'RelationshipType',
-        remote_side=[relationshiptypeid],
-        foreign_keys=[propagatesthroughid],
+        secondary='relationshiptypepropagations',
+        primaryjoin='RelationshipType.relationshiptypeid'
+                    ' == RelationshipTypePropagation.relationshiptypeid',
+        secondaryjoin='RelationshipType.relationshiptypeid'
+                      ' == RelationshipTypePropagation.throughtypeid',
+        viewonly=True,
     )
 
     def __repr__(self):
         return f"<RelationshipType {self.relationshiptype}>"
 
 
+class RelationshipTypePropagation(db.Model):
+    """
+    M:N propagation rails (ADR-001). One row means: a relationship of type
+    relationshiptypeid propagates through the connections of type throughtypeid.
+
+    Replaces the old single-valued relationshiptypes.propagatesthroughid so a
+    type (controls) can propagate through several through-types (partof AND
+    Dualpath) at once. Seed/CLI-managed; no management UI.
+    """
+    __tablename__ = 'relationshiptypepropagations'
+
+    propagationid = db.Column(db.Integer, primary_key=True)
+    relationshiptypeid = db.Column(
+        db.Integer,
+        db.ForeignKey('relationshiptypes.relationshiptypeid'),
+        nullable=False
+    )
+    throughtypeid = db.Column(
+        db.Integer,
+        db.ForeignKey('relationshiptypes.relationshiptypeid'),
+        nullable=False
+    )
+
+    __table_args__ = (
+        db.UniqueConstraint(
+            'relationshiptypeid',
+            'throughtypeid',
+            name='uq_reltype_propagation'
+        ),
+    )
+
+    def __repr__(self):
+        return f"<RelationshipTypePropagation {self.relationshiptypeid} through {self.throughtypeid}>"
+
+
 class AssetRelationship(BaseModel):
     """
     Relationships between assets.