{% extends "base.html" %} {% block title %}Mesh{% endblock %} {% block topbar_main %}

Mesh

This device, and who it can sync with {% endblock %} {% block content %}
{% if not mesh.signed_in %}

This machine works on its own

Everything you have here — projects, versions, history, freshness, the MCP server — runs with no account and no network. Joining a mesh adds one thing: your other machines, and your colleagues' machines, can pull these plans directly from this one.

This device{{ mesh.device_id }}

The id is the hash of a key this machine generated. It was not assigned by anyone, and the private half has never left this disk.

Joining a mesh
Get an invitationan admin sends one from the console
Run flanner login <code>on this machine, not in the browser
Run flanner peer serveso others can pull from you
Run flanner peer pull <device-id>to take their work
{% else %}
{{ mesh.peers | length }}
Known peers
{{ mesh.grants | length if mesh.grants else mesh.workspaces | length }}
Workspaces you may enter
{{ mesh.status }}
Access
{# The zero is structural, not measured: no endpoint on the control plane accepts plan content, which an architecture test enforces. The figure beside it is measured, and is the point — a zero on its own says nothing, a zero next to what is actually here says everything. #}
0 B
Of your {{ mesh.local_bytes }} held by flanner
{% if mesh.reason %}
{{ mesh.reason }}
{% endif %}

This device

Device id{{ mesh.device_id }}
Signed in as{{ mesh.user_id }}
Team{{ mesh.organization_id }}
Control plane{{ mesh.endpoint }}
Relay {{ mesh.relay_url or "the transport's own defaults" }}
{% if mesh.plan %}
Plan{{ mesh.plan }}
{% endif %} {% if mesh.expires_at %}
Access renews{{ mesh.expires_at }}
{% endif %}

Entitlements are short on purpose, and this device checks them itself without asking anyone. That is what lets it keep working on a train. Run flanner whoami --refresh to pick up a new grant early.

Peers devices this machine can verify, and when their work last arrived
{% if mesh.peers %}
{% for peer in mesh.peers %}
{{ peer }} {# Last arrival, not last seen. Nothing here polls a peer, and an artifact can reach this machine relayed through a third one long after its author went offline — so this says when their work got here, which is true, rather than whether they are up, which we have no way to know. #} {%- if peer == mesh.device_id -%} this device {%- elif mesh.last_received.get(peer) -%} {{ mesh.last_received[peer] | relative_time }} {%- else -%} nothing yet {%- endif -%}
{% endfor %}
{% else %}
No other devices yet. They appear here once an admin enrols them and this device next renews its access.
{% endif %}
A peer is a device whose public key this machine holds. Without the key there is nothing to check a signature against, so the keyring is the honest answer to "who can I sync with".
{% if mesh.grants %}
Workspace access
{% for grant in mesh.grants %}
{{ grant.workspace_id }} {{ grant.role }}
{% endfor %}
{% endif %}

How syncing actually works

Nothing is uploaded. When you pull, this machine asks a peer for a list of what it holds, then fetches only the versions it is missing. Each version was signed by the device that wrote it, so this machine checks it against that device's public key rather than trusting the sender.

A teammate can also push work to you rather than wait for you to pull it. That sounds alarming and is not: receiving a version adds it to your history, it does not change what you are working on. Nothing is ever overwritten here, so what you have open stays open until you decide otherwise.

Pushes are still checked. The sender needs the right role for what they sent, every artifact is verified against the key of whoever wrote it rather than whoever handed it over, and a machine can decline pushes entirely with FLANNER_ACCEPT_PUSHES=0 while still serving every read.

You never edit on somebody else's computer, and there is no live cursor — this is closer to git than to a shared document.

Review works the same way. A proposal and a decision are records that sync like any other, which is why they survive being made offline.

flanner peer pull <device-id>
{% endif %}
{% endblock %}