def __init__(self, family_id: str = DEFAULT_FAMILY_ID):
    """Load family configuration from YAML.

    Args:
        family_id: Must be "hoffmann". Single-tenant constraint.
    """
    if family_id != DEFAULT_FAMILY_ID:
        raise ValueError(f"Single-tenant only. Family must be '{DEFAULT_FAMILY_ID}'.")

    self.family_id = family_id
    self._config = self._load_config()
    self._compiled_rules = self._compile_rules()

def _load_config(self) -> dict:
    """Load and parse YAML configuration."""
    if not FAMILY_CONFIG_PATH.exists():
        raise FileNotFoundError(f"Family config not found: {FAMILY_CONFIG_PATH}")

    with open(FAMILY_CONFIG_PATH) as f:
        return yaml.safe_load(f)

def _compile_rules(self) -> list:
    """Pre-compile regex patterns for fast matching."""
    compiled = []
    for rule in self.inference_rules:
        try:
            compiled.append({
                **rule,
                "_regex": re.compile(rule["pattern"], re.IGNORECASE)
            })
        except re.error as e:
            print(f"Warning: Invalid regex in rule {rule['id']}: {e}")
    return compiled

@property
def members(self) -> list[dict]:
    """Return all family members."""
    return self._config.get("members", [])

@property
def inference_rules(self) -> list[dict]:
    """Return pattern matching rules."""
    return self._config.get("inference_rules", [])

@property
def fallback_threshold(self) -> float:
    """Confidence threshold for asking user."""
    return self._config.get("telemetry", {}).get("fallback_threshold", 0.70)

def get_member(self, member_id: str) -> Optional[dict]:
    """Get member by ID."""
    for member in self.members:
        if member.get("id") == member_id:
            return member
    return None

def infer_recipients(self, text: str) -> list[dict]:
    """Infer which family members a document concerns.

    Uses deterministic pattern matching (no LLM).
    Returns: [{member_id, confidence, rule_id, description}]
    """
    text_lower = text.lower()
    matches = []
    matched_ids = set()

    for rule in self._compiled_rules:
        if rule["_regex"].search(text):
            for member_id in rule["assign_to"]:
                if member_id not in matched_ids:
                    matches.append({
                        "member_id": member_id,
                        "member": self.get_member(member_id),
                        "confidence": rule["confidence"],
                        "rule_id": rule["id"],
                        "description": rule["description"]
                    })
                    matched_ids.add(member_id)

    return matches

def build_context_prompt(self) -> str:
    """Build family context string for LLM prompts."""
    lines = ["FAMILY MEMBERS:"]

    for member in self.members:
        if member.get("current_grade"):  # Kids for school docs
            lines.append(f"- {member['name']} ({member.get('nickname', 'no nickname')}) Grade {member['current_grade']}, Teacher: {member.get('teacher', 'unknown')}")
        elif member.get("is_parent"):
            lines.append(f"- {member['name']} (parent)")

    lines.append("")
    lines.append("INFERENCE RULES:")
    for rule in self.inference_rules:
        lines.append(f"- {rule['description']} → {', '.join(rule['assign_to'])} (confidence: {rule['confidence']})")

    return "\n".join(lines)

def get_telemetry_config(self) -> dict:
    """Get telemetry/logging configuration."""
    return self._config.get("telemetry", {})

Single-tenant: Always returns Hoffmann family config.
"""
global _family_config
if _family_config is None:
    _family_config = FamilyConfig()
return _family_config