C++: Class pointed to by unique_ptr holding a reference to owner, is this bad?

Is this a bad pattern, or could this result in a cycle that's actually harmful?

#include <iostream>
#include <memory>

class Foo;

class Bar {
    Foo& m_foo;

    public:
    Bar (Foo& _foo): m_foo(_foo) {};
};

class Foo {
    std::unique_ptr<Bar> m_bar;
    bool finished;
    
    void doStuffWithBar();
    
    public:
    Foo(): m_bar(std::make_unique<Bar>(*this)), finished(false) {}
    bool const& isFinished() { return finished; }
    void finish() { finished = true; }
};

int main() {
    Foo foo;
    while (!foo.isFinished()) {
         do {
             std::cout << '\n' << "Press a key to exit...";
         } while (std::cin.get() != '\n');
         foo.finish();
    }
    std::cout << '\n' << "Exiting now..." << std::endl;
    return 0;
}

For context, during normal functioning, Foo would only be destroyed when quitting the app.

1. Bar constructor is public so nothing prevents to use it with some irrelevant Foo. Where your idea to create Child within Parent on Parent reference only. If constructor of Bar is private Foo should be friend of Bar.
2. Since std::unique_ptr<Bar> m_bar is private to Foo how will you access it? What is the use for reference to Parent in Child that accessible from Parent only? If m_bar is public someone accidently can break this happy family.
3. Any change in Bar force change in Foo and vice versa.

What to you want to achieve in your specific case?