reflow2

A hub, or project brain.

One design that stands over several designs and holds what spans them. Each design underneath stays its own. New here? See what reflow2 is first, or set it up.

What a hub is With reflow2 alone On flo2.io A system of systems

What a hub is

A hub is a reflow2 design like any other, with one job: it stands over several designs and holds what spans them. Who is in the effort. How the work is done. Decisions about process that every member has to honour. Links between members: which one depends on which, and across which interfaces. Ideas nobody has placed in one design yet.

Every member design stays its own. It keeps its own owner, its own history and its own repository or server. The hub holds no copy of any of it: when a hub note needs a member's detail, it points at the member's record rather than restating it. A fact has one home, the lowest design that owns all of it, and the hub is the home only for what no single member owns.

People also call this a project brain: the place you type into, which works out which of the projects is affected.

Make one with reflow2 alone

On your own computer, or against a server your team runs. Nothing but reflow2 and the designs you already have. The setup page gets reflow2 installed first.

1 Start a design for the hub

In a folder of its own, start a design the way you would any other: say /genesis to your agent, with a paragraph about the effort. That calls genesis, and the design it makes is the hub. Give it the effort's name, not a member's.

2 Record each member, and how it stands to the hub

The hub's list of members is the set of designs it declares with external_dependency, one call per member. Each call names the member's design by its graph_id and says where the hub watches it: at the server that holds it (design_address, such as https://api.flo2.io/g/<id>/mcp), or through the export it commits beside its repository (design_export). One or the other, never both.

The same call records how the member stands to the hub, in its relation:

Both may hold. The relation is never guessed: your agent asks you when a member joins. upstream_status reads the list back with each member's relation, and names any member linked by nothing a change could follow (relation_not_stated, or no_interface_to_follow for a peer with no mirrored interface).

3 Work it with the hub skill

Say /hub, or just work in the hub's folder with the member designs reachable from the same session. The hub skill is served by reflow2, so your agent has the current one. It does three things for you:

Before every write the skill says which design it is writing to, and why. At the end it lists where everything went.

With reflow2 alone, one search reaches the hub and every member it pins by a committed export: search_design with tracked_designs: true reads each member's export, read-only, and ranks the hits together, each naming its design. A hit opens with get_node and its <member>:<id>. compose_and_analyse with tracked_designs: true runs reflow2's checks once over the hub and those members together, and shows where they already touch (the same file in both, or a pin naming the other) before anyone declares it. Both work through --call too. A member pinned only by its address is named as not searched; reading it live needs a server that holds it (below).

Make one on flo2.io

For a team whose designs are hosted on flo2.io. The host keeps the hub's list of designs and who may read them; there is nothing to declare by hand.

  1. Make the hub from chat. Say make a hub called X with A, B and C. The designs you name are its members.
  2. Give it a design. A new one, or one you already have. That design holds what spans the members: process, people, decisions of the whole, ideas not yet routed.
  3. Share that design once. Everyone in it reads, through the hub, every design the hub names that you can still open. A member who cannot write to a design can still drop an idea or feedback into the hub's design, where it waits until someone who works on the right design routes it there.

The same hub skill does the routing: it records the idea in the hub in the author's words, proposes a destination, writes it there when you agree, and leaves a pointer behind rather than a copy. A write into a design you are not a member of is refused, and the idea stays in the hub.

The flo2.io details, including sharing and what each member sees, are at flo2.io/hub.

A system of systems: two tiers

When the members are the parts of one thing, an engine over its component designs or a product over its sub-systems, two designs stand over them, with different jobs.

The rule of thumb: engineering of the whole goes to the design for the whole; process goes to the hub. A hub over peer products that assemble into nothing has no second tier, and holds none of the engineering.

Across the members, on flo2.io

At a hub's own address on flo2.io, the ordinary tools work across the hub and every member you can read. A read runs on each design and answers design by design. search_design ranks every design's hits together and applies your one limit to the merged list; the reply says how many hits each design found (found_by_design) and how many fell outside the limit (hits_withheld). An id written as <member>:<id> sends the call to that member alone, and member, a member's graph id, does the same for any tool, including the ones that take no id, such as loop_status, detect_gaps and get_skill. Every id in a member's reply carries its prefix, so it can be passed straight back.

Reasoning and change cross the members too. A step whose premise is a record in another member reads that record's truth and proof status there, at the moment you ask. A premise whose record is gone reads stale, and one in a design you cannot read reads unreachable; neither counts as holding. A change walk (propagate_from, from seed ids or a recorded change) carries on into every member that cites what it reached, names each crossing (boundary_crossings), and gives each design's radius under across_designs.

compare_designs and compose_and_analyse take the other design by its graph id. A long diff fits the budget_chars you set, names each list it shortened, and list with offset reads one list a page at a time.

This needs a server that holds the members: flo2.io, or your own --registry-root server behind a gateway that names each caller and the hub's members. reflow2 read and --call on your own machine open one design, and reach a hub's members only through the exports it pins (above), as committed, never live.