_handle_stage_movement_for_target(ats_application_id, flat_stage, flat_wf_step, label,
                                   routing_event=..., completion_rate=...)
    │
    ├─ if routing_event is not None:
    │     routed = await _move_application_for_routing_match(...)
    │     if routed: return   ← flat-field path is suppressed
    │
    └─ flat-field path: load app/job, move to flat_stage / flat_wf_step

handle_*_application(application_id, completion_rate=...)
    │
    ├─ if await _apply_disposition_routing_outcome(...):
    │     return   ← legacy flat-field path skipped
    │
    └─ legacy disposition or stage move from flat config

routing_enabled = await _is_ats_stage_routing_rules_enabled()
match = resolve_routing_match(org_config, event, completion_rate, routing_enabled)

if not routing_enabled or match is None:
    return False   ← caller falls through to flat-field path

# routing_enabled=True and match is resolved
target_stage = match.action.stage
target_step  = flat_workflow_step (if non-empty) else match.action.workflow_step_id

if not has_configured_transition_target(target_stage, target_step):
    log WARNING "No ATS routing target configured"
    return True   ← flat-field path is SUPPRESSED (candidate NOT moved)

app = await get_application_by_application_id(ats_application_id)
if not app:
    log ERROR
    return True   ← flat-field path suppressed

job = await get_job_by_job_id(app.job_id)
if not job:
    log ERROR
    return True   ← flat-field path suppressed

await move_application_for_org_transition_config(app, job, target_stage, target_step)
return True       ← flat-field path suppressed

resolve_routing_match(accessor, event, completion_rate, routing_rules_enabled)
    │
    ├─ routing_rules_enabled=False → return None
    │
    ├─ get_effective_stage_routing_rules(accessor)
    │     ├─ synthesize defaults from legacy flat fields (stage + disposition)
    │     ├─ accessor.stage_routing_rules is set and non-empty → merge persisted rule sets
    │     │     (persisted events win; synthesized fills gaps for other events)
    │     └─ otherwise → use synthesized rules only
    │
    ├─ rules_value.get_rule_set(event)  → None if event has no rule set
    │     └─ None → return None (caller: _move_application_for_routing_match returns False)
    │
    └─ evaluate_rule_set(rule_set, context)
          ├─ sort rules by priority (ascending)
          ├─ for each rule: evaluate ALL conditions (AND logic)
          │     condition: metric=completion_percentage, op in {gte,gt,lte,lt,eq}, value
          │     if completion_percentage is None → condition NEVER matches
          │
          ├─ first matching rule → RoutingMatchResult(used_default=False, ...)
          └─ no rule matched → default_rule → RoutingMatchResult(used_default=True, ...)

outreach_stage = "Outreach In Progress"
→ EventRoutingRuleSet(
      event=OUTREACH,
      default_rule=RoutingDefaultRule(action=RoutingAction(stage="Outreach In Progress")),
      rules=[]
  )

CALL_LIMIT_EXHAUSTED:
  default_rule.action.stage = call_limit_no_interview_stage  (or not_completed if former is None)
  rules = [
    RoutingRule(conditions=[completion_percentage > 0], action.stage = call_limit_not_completed_stage)
  ]

completion_rate=completion_rate if completion_rate is not None else 0.0