@caddis/cli 0.4.60 → 0.4.62

package/bundles/antigravity-plugin/scripts/caddis_roadmap_page.py

@@ -28,6 +28,8 @@ import html
 import json
 import os
 import re
+import shutil
+import stat
 import subprocess
 import sys
 import time
@@ -217,8 +219,8 @@ def build(root: Path, slug: str, roadmap_mod, now: datetime.datetime | None = No
 
 # One colour set for every page: light = slate + blue, dark = Dracula (owner, 17 Oct): https://draculatheme.com/contribute
 # Dark applies when the OS asks for it, unless the reader picked light; the toggle sets data-theme on <html>.
-_PALETTE_LIGHT = '--bg:#f4f6f9;--panel:#fff;--panel2:#f8fafc;--fg:#0f172a;--muted:#475569;--line:#e2e8f0;--line2:#cbd5e1;--accent:#2563eb;--todo-bg:#f1f5f9;--todo-fg:#334155;--prog:#2563eb;--prog-bg:#dbeafe;--prog-fg:#1d4ed8;--done:#16a34a;--done-bg:#dcfce7;--done-fg:#15803d;--block:#d97706;--block-bg:#fef3c7;--block-fg:#92400e;--high:#dc2626;--wait-bg:#fee2e2;--wait-fg:#b91c1c;--nav:#f8fafc;--nav-fg:#0f172a;--on-accent:#fff;--shadow:0 1px 3px rgba(15,23,42,.06);--title:var(--fg);--summary:var(--fg);--code:var(--fg);--sans:"Maple Mono","Segoe UI Variable","Segoe UI",system-ui,sans-serif;--mono:"JetBrains Mono","Cascadia Mono",Consolas,ui-monospace,monospace;color-scheme:light;'
-_PALETTE_DARK = '--bg:#282a36;--panel:#21222c;--panel2:#343746;--fg:#f8f8f2;--muted:#6272a4;--line:#44475a;--line2:#6272a4;--accent:#8be9fd;--todo-bg:#44475a;--todo-fg:#f8f8f2;--prog:#bd93f9;--prog-bg:#3c3352;--prog-fg:#bd93f9;--done:#50fa7b;--done-bg:#2b4a36;--done-fg:#50fa7b;--block:#ffb86c;--block-bg:#4a3a2b;--block-fg:#ffb86c;--high:#ff5555;--wait-bg:#4a2b33;--wait-fg:#ff5555;--nav:#21222c;--nav-fg:#f8f8f2;--on-accent:#282a36;--shadow:none;--title:#bd93f9;--summary:#ff79c6;--code:#f1fa8c;color-scheme:dark;'
+_PALETTE_LIGHT = '--bg:#f4f6f9;--panel:#fff;--panel2:#f8fafc;--fg:#0f172a;--muted:#475569;--line:#e2e8f0;--line2:#cbd5e1;--accent:#2563eb;--todo-bg:#f1f5f9;--todo-fg:#334155;--prog:#2563eb;--prog-bg:#dbeafe;--prog-fg:#1d4ed8;--done:#16a34a;--done-bg:#dcfce7;--done-fg:#15803d;--block:#d97706;--block-bg:#fef3c7;--block-fg:#92400e;--high:#dc2626;--wait-bg:#fee2e2;--wait-fg:#b91c1c;--nav:#f8fafc;--nav-fg:#0f172a;--on-accent:#fff;--shadow:0 1px 3px rgba(15,23,42,.06);--title:var(--fg);--summary:var(--fg);--code:var(--fg);--c0:#2563eb;--c1:#7c3aed;--c2:#0d9488;--c3:#ea580c;--c4:#db2777;--c5:#475569;--sans:"Maple Mono","Segoe UI Variable","Segoe UI",system-ui,sans-serif;--mono:"JetBrains Mono","Cascadia Mono",Consolas,ui-monospace,monospace;color-scheme:light;'
+_PALETTE_DARK = '--bg:#282a36;--panel:#21222c;--panel2:#343746;--fg:#f8f8f2;--muted:#6272a4;--line:#44475a;--line2:#6272a4;--accent:#8be9fd;--todo-bg:#44475a;--todo-fg:#f8f8f2;--prog:#bd93f9;--prog-bg:#3c3352;--prog-fg:#bd93f9;--done:#50fa7b;--done-bg:#2b4a36;--done-fg:#50fa7b;--block:#ffb86c;--block-bg:#4a3a2b;--block-fg:#ffb86c;--high:#ff5555;--wait-bg:#4a2b33;--wait-fg:#ff5555;--nav:#21222c;--nav-fg:#f8f8f2;--on-accent:#282a36;--shadow:none;--title:#bd93f9;--summary:#ff79c6;--code:#f1fa8c;--c0:#8be9fd;--c1:#bd93f9;--c2:#50fa7b;--c3:#ffb86c;--c4:#ff79c6;--c5:#6272a4;color-scheme:dark;'
 _THEME_CSS = (":root{" + _PALETTE_LIGHT + "}" + '@media (prefers-color-scheme:dark){:root:not([data-theme="light"]){'
               + _PALETTE_DARK + "}}" + ':root[data-theme="dark"]{' + _PALETTE_DARK + "}")
 
@@ -230,7 +232,7 @@ h1{font-size:24px;margin:0;color:var(--title)}h2{font-size:16px;margin:0}.sub{co
 .card{background:var(--panel);border:1px solid var(--line);border-radius:12px;padding:14px 16px}
 details.card>summary{cursor:pointer;font-weight:700;font-size:16px;list-style:none;color:var(--summary)}
 details.card>summary::-webkit-details-marker{display:none}details.card>summary::before{content:"\\25B8 ";color:var(--muted)}
-details.card[open]>summary::before{content:"\\25BE "}details.card>summary span{color:var(--muted);font-weight:400;font-size:13px}
+details.card[open]>summary::before{content:"\\25BE "}details.card+details.card{margin-top:8px}
 .wait{border-color:var(--high)}.wait h2{color:var(--wait-fg)}.empty{color:var(--muted)}
 table{border-collapse:collapse;width:100%}th,td{text-align:left;padding:7px 9px;border-top:1px solid var(--line);
 vertical-align:top}th{font-size:11px;letter-spacing:.06em;text-transform:uppercase;color:var(--muted);border-top:0}
@@ -239,15 +241,21 @@ padding:1px 8px;border-radius:999px;white-space:nowrap}
 .s-todo{background:var(--todo-bg);color:var(--todo-fg)}.s-in-progress{background:var(--prog-bg);color:var(--prog-fg)}
 .s-done,.s-moved,.s-not-needed{background:var(--done-bg);color:var(--done-fg)}.s-blocked{background:var(--block-bg);color:var(--block-fg)}
 .s-code-done\\/data-pending{background:var(--block-bg);color:var(--block-fg)}
-.lanes{display:grid;width:max-content}.lanes>div{border-top:1px solid var(--line);border-left:1px dashed var(--line);
+.lanes{display:grid}.lanes>div{border-top:1px solid var(--line);border-left:1px dashed var(--line);
 padding:6px}.lanes .hd{background:var(--panel2);border-top:0;font-weight:700}.lanes .ln{position:sticky;left:0;z-index:1;
-background:var(--panel);border-left:0;border-right:1px solid var(--line2);font-weight:600;min-width:170px}
-.tile{display:flex;gap:6px;align-items:center;font-size:12px;padding:3px 6px;margin:0 0 4px;border-radius:5px;
+background:var(--panel);border-left:4px solid var(--lc,var(--line2));border-right:1px solid var(--line2);font-weight:600;overflow-wrap:anywhere}
+.tile{display:flex;gap:5px;align-items:center;font-size:12px;padding:3px 5px;position:relative;margin:0 0 4px;border-radius:5px;
 border:1px solid var(--line2);background:var(--panel);max-width:100%}.tile b{font:600 11px var(--mono)}
-.tile span{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.tile.in-progress{background:var(--prog-bg);
+.tile span{display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;overflow:hidden;white-space:normal;overflow-wrap:anywhere}.tile.in-progress{background:var(--prog-bg);
 border-color:var(--prog);color:var(--prog-fg)}.tile.done{background:var(--done-bg);border-color:var(--done);
 color:var(--done-fg)}.tile.moved{background:repeating-linear-gradient(135deg,var(--done-bg) 0 5px,var(--panel) 5px 10px);
 border-color:var(--done)}.tile.blocked{background:var(--block-bg);border-color:var(--block);color:var(--block-fg)}
+.tile.hi::after{position:absolute;top:3px;right:3px;margin:0}
+.ltile{display:flex;gap:8px;align-items:baseline;font-size:13px;padding:5px 8px;margin:0 0 4px;border-radius:6px;border:1px solid var(--line2);background:var(--panel)}.ltile b{font:600 11px var(--mono);white-space:nowrap}
+.ltile.in-progress{background:var(--prog-bg);border-color:var(--prog);color:var(--prog-fg)}.ltile.done{background:var(--done-bg);border-color:var(--done);color:var(--done-fg)}
+.ltile.moved{background:repeating-linear-gradient(135deg,var(--done-bg) 0 5px,var(--panel) 5px 10px);border-color:var(--done)}.ltile.blocked{background:var(--block-bg);border-color:var(--block);color:var(--block-fg)}
+.bcount{display:inline-block;font-size:11px;font-weight:700;color:var(--block-fg);background:var(--block-bg);border:1px dashed var(--block);border-radius:6px;padding:0 6px;margin-top:3px}
+.lane-list{display:none}.lane-list h3{margin:10px 0 6px}@media (max-width:900px){.timeline .scroll{display:none}.lane-list{display:block}}
 .hi::after{content:"";width:7px;height:7px;border-radius:50%;background:var(--high);flex:none;margin-left:auto}
 .gate{font-size:11px;color:var(--block-fg);background:var(--block-bg);border:1px dashed var(--block);border-radius:6px;
 padding:3px 6px;margin:2px 0;white-space:normal;overflow-wrap:anywhere}.legend{display:flex;flex-wrap:wrap;gap:12px;font-size:12px;color:var(--muted);margin-top:8px}
@@ -257,6 +265,11 @@ padding:3px 6px;margin:2px 0;white-space:normal;overflow-wrap:anywhere}.legend{d
 .bar i{display:block;height:100%;background:var(--done)}a{color:var(--accent)}td.num{white-space:nowrap}
 .theme-btn{font:600 12px var(--sans);padding:6px 11px;border-radius:999px;border:1px solid var(--line);background:var(--panel2);color:var(--fg);cursor:pointer}
 .hdr{display:flex;justify-content:space-between;align-items:flex-start;gap:12px}
+.chips{display:flex;flex-wrap:wrap;gap:8px;margin-top:10px}.chip{border:1px solid var(--line);border-left:4px solid var(--lc);border-radius:8px;padding:5px 10px;background:var(--panel2);font-size:12.5px}.chip span{color:var(--muted);font-family:var(--mono)}
+.flow{display:flex;gap:6px;align-items:stretch;min-width:max-content}.fnode{display:grid;gap:3px;padding:8px 10px;border:1px solid var(--line);border-radius:9px;background:var(--panel2);text-decoration:none;color:inherit;min-width:120px}.fnode span{font:11px var(--mono);color:var(--muted)}.fnode span.pill{font:700 11px var(--sans);justify-self:start}.arrow{align-self:center;color:var(--muted)}
+.kind{font-size:10.5px;font-weight:700;text-transform:uppercase;padding:2px 8px;border-radius:6px;background:var(--block-bg);color:var(--block-fg)}.k-owner-gate{background:var(--wait-bg);color:var(--wait-fg)}
+.note{color:var(--muted);font-weight:400;font-size:13px}.sec-h{display:flex;flex-wrap:wrap;gap:4px 10px;align-items:baseline;margin-bottom:8px}h3{font-size:14px;margin:0 0 8px}
+.cols .rcard{margin-bottom:8px}.cols .rcard .bar{margin:0}
 """
 
 _CSS = _THEME_CSS + _BASE_CSS
@@ -265,6 +278,8 @@ _CSS = _THEME_CSS + _BASE_CSS
 # (an open roadmap view is never reset); the phone menu closes when the view changes; and the nav item of the
 # shown view gets aria-current. No network.
 _THEME_SCRIPT = ('<script id="theme-toggle">(function(){var k="caddis-roadmap-theme",d=document.documentElement;try{var t=localStorage.getItem(k);if(t==="light"||t==="dark")d.dataset.theme=t}catch(e){}window.caddisTheme=function(){var c=d.dataset.theme||(matchMedia("(prefers-color-scheme: dark)").matches?"dark":"light"),n=c==="dark"?"light":"dark";d.dataset.theme=n;try{localStorage.setItem(k,n)}catch(e){}};function shown(){var h=location.hash.slice(1),e=h&&document.getElementById(h),v=e&&e.closest(".view");return v?v.id:"inbox"}function cur(){var a=document.querySelectorAll(".nav a.nav-i");for(var i=0;i<a.length;i++){if(a[i].getAttribute("href")==="#"+shown())a[i].setAttribute("aria-current","page");else a[i].removeAttribute("aria-current")}}addEventListener("DOMContentLoaded",cur);setInterval(function(){if(document.getElementById("inbox")&&document.visibilityState==="visible"&&shown()==="inbox")location.reload()},60000);addEventListener("hashchange",function(){var b=document.getElementById("nav-cb");if(b)b.checked=false;cur()})})();</script>')
+# The shared copy is a static page: the inbox reload would only re-request it every minute, so it has no timer.
+_SITE_THEME_SCRIPT = re.sub(r"setInterval\(function\(\)\{.*?\},60000\);", "", _THEME_SCRIPT)
 _THEME_BUTTON = '<button type="button" class="theme-btn" onclick="caddisTheme()" aria-label="Switch between light and dark theme">◐ Theme</button>'
 
 
@@ -285,7 +300,7 @@ _SHELL_CSS = """
 .main{min-width:0}.top{display:flex;align-items:center;gap:12px;padding:10px 20px;border-bottom:1px solid var(--line);background:var(--panel);position:sticky;top:0;z-index:5}
 .crumbs{flex:1;min-width:0;font-size:13px;color:var(--muted)}.crumbs a{color:var(--accent);text-decoration:none}
 main [id]{scroll-margin-top:60px}main>.view{scroll-margin-top:200px}
-.view{display:none}.view:target,.view:has(:target){display:block}main:not(:has(.view:target,.view :target))>#inbox{display:block}
+.view>*+*{margin-top:16px}.view{display:none}.view:target,.view:has(:target){display:block}main:not(:has(.view:target,.view :target))>#inbox{display:block}
 .nav-sub{display:none}.view-crumbs{font-size:13px;color:var(--muted);margin:0 0 8px}
 .nav-cb{display:none}.nav-btn,.nav-close,.nav-scrim{display:none}
 .nav-cb:focus-visible~.app .nav-btn{outline:2px solid var(--accent);outline-offset:2px}
@@ -307,13 +322,14 @@ def _pill(status: str) -> str:
     return f'<span class="pill s-{_e(status)}">{_e(_LABEL.get(status, status))}</span>'
 
 
-def _shell(*, title: str, base: str, nav: str, crumbs: str, body: str, css: str = "") -> str:
+def _shell(*, title: str, base: str, nav: str, crumbs: str, body: str, css: str = "",
+           script: str | None = None) -> str:
     """The app frame around every page: head, left nav, top bar (crumbs and the theme button) and the body.
     `nav`, `crumbs`, `body` and `css` are text the caller has already made safe; `title` is plain text."""
     return "".join([
         '<!doctype html><html lang="en"><head><meta charset="utf-8">',
         '<meta name="viewport" content="width=device-width,initial-scale=1">',
-        f"<title>{_e(title)}</title>{_fonts_link(base)}<style>{_CSS}{_SHELL_CSS}{css}</style>{_THEME_SCRIPT}</head>",
+        f"<title>{_e(title)}</title>{_fonts_link(base)}<style>{_CSS}{_SHELL_CSS}{css}</style>{script or _THEME_SCRIPT}</head>",
         f'<body><input type="checkbox" id="nav-cb" class="nav-cb" aria-label="Toggle the navigation menu"><div class="app">{nav}<label for="nav-cb" class="nav-scrim" aria-hidden="true"></label><div class="main">',
         '<header class="top"><label for="nav-cb" class="nav-btn" aria-label="Open the menu">☰</label>',
         f'<div class="crumbs">{crumbs}</div>{_THEME_BUTTON}</header>',
@@ -349,10 +365,12 @@ def _group_rows(rows: list[dict]) -> tuple[list[tuple[str, list[dict]]], list[tu
     return order, need, count
 
 
-def _nav(rows: list[dict], base: str) -> str:
+def _nav(rows: list[dict], base: str, site: bool = False) -> str:
     """The left nav: Needs you (inbox, gates, sessions, runners), then every repo with its roadmaps. Every link opens a
     view of `index.html` (`#inbox`, `#<rid>`, ...); on the hub itself (`base` "") the link is the bare `#view`. The
-    active item and its sub-links are shown by `_view_css`, so the nav needs no per-page copy."""
+    active item and its sub-links are shown by `_view_css`, so the nav needs no per-page copy. A `site` (shared copy)
+    nav has no Sessions or Runners item, no idle-session note and no Runner sub-link: those show only on the owner's
+    machine."""
     order, _need, count = _group_rows(rows)
     counts = {"inbox": count, "gates": sum(len(r.get("blockers") or r.get("owner_gates") or []) for r in rows),
               "sessions": sum(len(_sessions_of(group)) for _f, group in order),
@@ -361,11 +379,13 @@ def _nav(rows: list[dict], base: str) -> str:
     out = ['<nav class="nav" aria-label="Roadmaps">'
            '<label for="nav-cb" class="nav-close" aria-label="Close the menu">✕</label>',
            f'<a class="brand" href="{_e(hub or "#inbox")}">caddis · Roadmaps</a>', '<p class="nav-h">Needs you</p>']
-    for key, label in (("inbox", "Inbox"), ("gates", "Gates"), ("sessions", "Sessions"), ("runners", "Runners")):
+    for key, label in _NAV_ITEMS:
+        if site and key in _LOCAL_VIEWS:
+            continue
         out.append(f'<a class="nav-i" href="{_e(hub)}#{key}">{_e(label)}<span class="n">{_e(counts[key])}</span></a>')
     out.append('<p class="nav-h">Repos</p>')
     for folder, group in order:
-        idle = sum(1 for s in _sessions_of(group) if not s.get("asking"))
+        idle = 0 if site else sum(1 for s in _sessions_of(group) if not s.get("asking"))
         idle_txt = f" · {idle} idle session(s)" if idle else ""
         out.append(f'<p class="nav-repo">{_e(group[0].get("repo"))}{_e(idle_txt)}</p>')
         for r in sorted(group, key=lambda r: str(r["slug"])):
@@ -376,22 +396,29 @@ def _nav(rows: list[dict], base: str) -> str:
             pct = int(round(100 * _int(r.get("phases_done")) / total)) if total else 0
             out.append(f'<a class="nav-i nav-rm" href="{_e(hub)}#{rid}">{_e(r["slug"])}<span class="n">{pct}%</span></a>'
                        f'<div class="nav-sub" data-rid="{rid}">'
-                       + "".join(f'<a href="{_e(hub)}#{rid}-{anchor}">{_e(label)}</a>' for anchor, label in _PAGE_ANCHORS)
+                       + "".join(f'<a href="{_e(hub)}#{rid}-{anchor}">{_e(label)}</a>' for anchor, label in _PAGE_ANCHORS
+                                 if not (site and anchor in _LOCAL_ANCHORS))
                        + "</div>")
     out.append("</nav>")
     return "".join(out)
 
 
+_NAV_ITEMS = (("inbox", "Inbox"), ("gates", "Gates"), ("sessions", "Sessions"), ("runners", "Runners"))
+_LOCAL_VIEWS = ("sessions", "runners")  # views of this machine's live state: a shared copy has neither
+_LOCAL_ANCHORS = ("runner",)  # the section of a roadmap view that shows this machine's runner
+
 _ON = "{background:var(--prog-bg);color:var(--prog-fg);font-weight:600}"
 
 
-def _view_css(rids: list[str]) -> str:
+def _view_css(rids: list[str], site: bool = False) -> str:
     """Marks the nav item of the view that shows, and opens its sub-links. One rule per roadmap: CSS cannot take
     the target's id into a selector. Every rid comes from `_rid` (hex and slug characters only), so it is safe
     in a selector."""
     shown = ".view:target,.view :target"
     out = [f'body:not(:has({shown})) .nav a[href="#inbox"]{_ON}']
-    for key in ("inbox", "gates", "sessions", "runners"):
+    for key, _label in _NAV_ITEMS:
+        if site and key in _LOCAL_VIEWS:
+            continue
         out.append(f'body:has(#{key}:target,#{key} :target) .nav a[href="#{key}"]{_ON}')
     for rid in rids:
         on = f"body:has(#{rid}:target,#{rid} :target)"
@@ -399,11 +426,14 @@ def _view_css(rids: list[str]) -> str:
     return "".join(out)
 
 
-def _waiting_section(model: dict) -> str:
+def _waiting_section(model: dict, site: bool = False) -> str:
+    """Sessions that wait for input, then the open owner gates. A shared copy (`site`) has the owner gates only: its
+    sessions are not on the reader's machine, so a table of them would be empty for a wrong reason."""
     out = ['<section id="waiting" class="card wait"><h2>Waiting for you</h2>']
-    sessions, gates = model["sessions"], model["waiting"]
+    sessions, gates = ([] if site else model["sessions"]), model["waiting"]
     if not sessions and not gates:
-        out.append('<p class="empty">Nothing is waiting for you.</p></section>')
+        out.append('<p class="empty">' + ("No owner gate is waiting." if site else "Nothing is waiting for you.")
+                   + "</p></section>")
         return "".join(out)
     # A question or a permission first; a session that only finished its turn and sits idle comes after it.
     asking = [s for s in sessions if not str(s.get("kind", "")).startswith("idle")]
@@ -430,20 +460,24 @@ def _waiting_section(model: dict) -> str:
 def _swimlane(model: dict) -> str:
     milestones, lanes = model["milestones"], model["lanes"]
     cols = len(milestones)
-    out = ['<details class="card" id="timeline" open><summary>Plan on a page <span>plans as lanes, milestones as columns in '
-           'roadmap order, one tile per phase</span></summary><div class="scroll">',
-           f'<div class="lanes" style="grid-template-columns:170px repeat({cols},190px)">',
+    # The section has the class `timeline` as well as the id: the hub prefixes every id, so the phone CSS selects by class.
+    out = ['<section class="card timeline" id="timeline"><div class="sec-h"><h2>Timeline</h2><span class="note">plans as '
+           'lanes, milestones as columns in roadmap order, one tile per phase</span></div><div class="scroll">',
+           f'<div class="lanes" style="grid-template-columns:150px repeat({cols},minmax(110px,1fr));width:100%;'
+           f'min-width:{150 + cols * 110}px">',
            '<div class="hd ln">Plan / milestone</div>']
     for ms in milestones:
         dep = f"after {', '.join(ms['depends'])}" if ms["depends"] else "starts first"
-        gates = "".join(f'<div class="gate">{_e(b["type"])}: {_e(b["reason"])}</div>' for b in ms["blockers"])
+        n = len(ms["blockers"])
+        count = f' <span class="bcount">{n} gate(s)</span>' if n else ""
         out.append(f'<div class="hd">{_e(ms["id"])} {_pill(ms["status"])}<div class="empty" style="font-weight:400;'
-                   f'font-size:11px">{_e(dep)} · {_e(ms["owner"])}</div>{gates}</div>')
-    for lane in lanes or ["-"]:
+                   f'font-size:11px">{_e(dep)}</div>{count}</div>')
+    plan_lanes = lanes or ["-"]
+    for i, lane in enumerate(plan_lanes):
         done = sum(1 for ms in milestones for ph in ms["phases"] if ph["plan"] == lane and ph["tile"] in ("done", "moved"))
         total = sum(1 for ms in milestones for ph in ms["phases"] if ph["plan"] == lane)
-        out.append(f'<div class="ln">{_e(lane)}<div class="empty" style="font-weight:400;font-size:11px">'
-                   f'{done}/{total} done</div></div>')
+        out.append(f'<div class="ln" style="--lc:var(--c{i % 6})">{_e(lane)}<div class="empty" '
+                   f'style="font-weight:400;font-size:11px">{done}/{total} done</div></div>')
         for ms in milestones:
             tiles = []
             for ph in ms["phases"]:
@@ -454,8 +488,24 @@ def _swimlane(model: dict) -> str:
                 tiles.append(f'<div class="tile {_e(ph["tile"])}{hi}" title="{_e(title)}"><b>{_e(ph["num"])}</b>'
                              f'<span>{_e(ph["name"] or ph["ref"])}</span></div>')
             out.append(f"<div>{''.join(tiles)}</div>")
-    out.append('</div></div><div class="legend"><span>colour: to do · <b>in progress</b> · done · striped = moved · '
-               'amber = blocked</span><span>red dot = Risk high (stops for review)</span></div></details>')
+    if any(ms["blockers"] for ms in milestones):  # the blockers get their own lane, so the column headers stay short
+        out.append('<div class="ln">Owner and outside</div>')
+        for ms in milestones:
+            cells = []
+            for b in ms["blockers"]:
+                reason = str(b["reason"])
+                short = reason if len(reason) <= 60 else reason[:60] + "…"
+                cells.append(f'<div class="gate" title="{_e(reason)}">{_e(b["type"])}: {_e(short)}</div>')
+            out.append(f"<div>{''.join(cells)}</div>")
+    out.append('</div></div><div class="lane-list">')
+    for ms in milestones:  # the phone list: the grid is hidden on a narrow screen
+        out.append(f'<h3>{_e(ms["id"])} {_pill(ms["status"])}</h3>')
+        for ph in ms["phases"]:
+            hi = " hi" if "high" in ph.get("risk", "").lower() else ""
+            out.append(f'<div class="ltile {_e(ph["tile"])}{hi}"><b>{_e(ph["plan"])} {_e(ph["num"])}</b>'
+                       f'<span>{_e(ph["name"] or ph["ref"])}</span></div>')
+    out.append('</div><div class="legend"><span>colour: to do · <b>in progress</b> · done · striped = moved · '
+               'amber = blocked</span><span>red dot = Risk high (stops for review)</span></div></section>')
     return "".join(out)
 
 
@@ -466,14 +516,29 @@ def _summary(model: dict) -> str:
     high = sum(1 for ph in phases if "high" in ph.get("risk", "").lower())
     nxt = model.get("next") or {}
     nxt_txt = f"{nxt.get('milestone', '')} {nxt.get('plan', '')}#{nxt.get('phase', '')}" if nxt else "none ready"
-    return ('<details class="card" id="overview"><summary>Summary <span>progress, current work, next batch</span></summary>'
-            '<div class="kpis">'
+    return ('<section class="kpis" id="overview" aria-label="Summary">'
             f'<div class="kpi"><b>{_e(done)} / {_e(len(phases))}</b>phases done</div>'
             f'<div class="kpi"><b>{_e(model["done"])} / {_e(model["total"])}</b>milestones done</div>'
             f'<div class="kpi"><b>{_e(len(building))}</b>in progress: {_e(", ".join(building) or "none")}</div>'
             f'<div class="kpi"><b>{_e(high)}</b>high-risk phases</div>'
             f'<div class="kpi"><b>{_e(nxt_txt)}</b>next batch for the runner</div>'
-            "</div></details>")
+            "</section>")
+
+
+def _done_phases(ms: dict) -> int:
+    return sum(1 for ph in ms["phases"] if ph["tile"] in ("done", "moved"))
+
+
+def _flow(model: dict) -> str:
+    """The milestones as a left-to-right chain in roadmap order; each node links to its milestone below."""
+    nodes = []
+    for ms in model["milestones"]:
+        dep = f"after {', '.join(ms['depends'])}" if ms["depends"] else "starts first"
+        nodes.append(f'<a class="fnode s-{_e(ms["status"])}" href="#ms-{_e(ms["id"])}"><b>{_e(ms["id"])}</b> '
+                     f'{_pill(ms["status"])}<span>{_e(dep)} · {_e(_done_phases(ms))}/{_e(len(ms["phases"]))} ph</span></a>')
+    chain = '<span class="arrow" aria-hidden="true">→</span>'.join(nodes)
+    return (f'<section id="flow"><div class="sec-h"><h2>Flow</h2><span class="note">milestones in roadmap order</span></div>'
+            f'<div class="card scroll"><div class="flow">{chain}</div></div></section>')
 
 
 def _now_next_later(model: dict) -> str:
@@ -492,26 +557,30 @@ def _now_next_later(model: dict) -> str:
             groups["Later"].append(ms)
     cols = []
     for title, items in groups.items():
-        body = "".join(f'<p><strong>{_e(m["id"])}</strong> {_pill(m["status"])} '
-                       f'{_e(sum(1 for p in m["phases"] if p["tile"] in ("done", "moved")))}/{_e(len(m["phases"]))}'
-                       f' phases{"".join(" · " + _e(b["type"]) for b in m["blockers"])}</p>' for m in items)
-        cols.append(f'<div><h2>{_e(title)}</h2>{body or "<p class=empty>none</p>"}</div>')
-    return ('<details class="card"><summary>Now, next, later <span>which milestones can start</span></summary>'
-            f'<div class="cols">{"".join(cols)}</div></details>')
+        body = "".join(f'<a class="rcard" href="#ms-{_e(m["id"])}"><span><strong>{_e(m["id"])}</strong> {_pill(m["status"])}</span>'
+                       f'{_bar(_done_phases(m), len(m["phases"]))}'
+                       + "".join(f'<span class="note">{_e(b["type"])}</span>' for b in m["blockers"])
+                       + "</a>" for m in items)
+        cols.append(f'<div><h3>{_e(title)}</h3>{body or "<p class=empty>none</p>"}</div>')
+    return ('<section id="board"><div class="sec-h"><h2>Now, next, later</h2>'
+            '<span class="note">which milestones can start</span></div>'
+            f'<div class="cols">{"".join(cols)}</div></section>')
 
 
 def _gates(model: dict) -> str:
     rows = [(ms["id"], b) for ms in model["milestones"] for b in ms["blockers"]]
-    body = "".join(f"<tr><td><strong>{_e(mid)}</strong></td><td>{_e(b['type'])}</td><td>{_e(b['reason'])}</td>"
+    body = "".join(f"<tr><td><strong>{_e(mid)}</strong></td>"
+                   f"<td><span class=\"kind k-{_e(b['type'])}\">{_e(b['type'])}</span></td><td>{_e(b['reason'])}</td>"
                    f"<td><code>{_e(b['check'])}</code></td></tr>" for mid, b in rows)
-    return (f'<details class="card" id="gates"><summary>Gates and blockers <span>{_e(len(rows))} open</span></summary>'
+    return (f'<section class="card" id="gates"><div class="sec-h"><h2>Gates and blockers</h2>'
+            f'<span class="note">{_e(len(rows))} open</span></div>'
             + (f'<div class="scroll"><table><tr><th>Milestone</th><th>Type</th><th>Reason</th><th>Check</th></tr>{body}'
-               "</table></div>" if rows else '<p class="empty">No blockers.</p>') + "</details>")
+               "</table></div>" if rows else '<p class="empty">No blockers.</p>') + "</section>")
 
 
 def _milestones(model: dict) -> str:
-    out = ['<details class="card" id="milestones"><summary>Milestones and phases <span>every phase with model, lane, risk and '
-           'Tracker status</span></summary>']
+    out = ['<section id="milestones"><div class="sec-h"><h2>Milestones and phases</h2><span class="note">every phase with '
+           'model, lane, risk and Tracker status</span></div>']
     for ms in model["milestones"]:
         rows = "".join(
             f"<tr><td><code>{_e(ph['ref'])}</code></td><td>{_e(ph['name'])}</td><td>{_e(_short_model(ph['model']))}</td>"
@@ -519,13 +588,13 @@ def _milestones(model: dict) -> str:
             f"<td>{_e(ph['risk'] or '-')}</td><td>{_pill(ph['tile'])} {_e(ph['tracker'])}</td></tr>"
             for ph in ms["phases"])
         target = f" · target {_e(ms['target'])}" if ms.get("target") else ""
-        out.append(f"<h2 style=\"margin-top:12px\">{_e(ms['id'])} {_pill(ms['status'])} "
-                   f"<span class=\"empty\" style=\"font-weight:400;font-size:13px\">owner {_e(ms['owner'])}{target} · "
-                   f"after {_e(', '.join(ms['depends']) or '-')}</span></h2>")
-        out.append('<div class="scroll"><table><tr><th>Phase</th><th>Name</th><th>Model</th><th>Lane</th><th>Risk</th>'
+        out.append(f'<details class="card" id="ms-{_e(ms["id"])}"><summary>{_e(ms["id"])} '
+                   f'{_pill(ms["status"])} <span class="note">owner {_e(ms["owner"])}{target} · '
+                   f'after {_e(", ".join(ms["depends"]) or "-")}</span></summary>'
+                   '<div class="scroll"><table><tr><th>Phase</th><th>Name</th><th>Model</th><th>Lane</th><th>Risk</th>'
                    f'<th>Tracker</th></tr>{rows or "<tr><td colspan=6 class=empty>no build phases</td></tr>"}'
-                   "</table></div>")
-    out.append("</details>")
+                   "</table></div></details>")
+    out.append("</section>")
     return "".join(out)
 
 
@@ -554,13 +623,13 @@ def _runner(model: dict) -> str:
     if nxt:
         parts.append(f"<p>Next batch: <code>{_e(nxt.get('milestone'))} {_e(nxt.get('plan'))}#{_e(nxt.get('phase'))}"
                      "</code></p>")
-    return ('<details class="card" id="runner"><summary>Runner <span>roadmap-run state on this machine</span></summary>'
-            + "".join(parts) + "</details>")
+    return ('<section class="card" id="runner"><div class="sec-h"><h2>Runner</h2>'
+            '<span class="note">roadmap-run state on this machine</span></div>' + "".join(parts) + "</section>")
 
 
-# In page order (Phase 4 moves the overview above the timeline and updates this list).
-_PAGE_ANCHORS = [("waiting", "Waiting"), ("timeline", "Timeline"), ("overview", "Overview"), ("gates", "Gates"),
-                 ("milestones", "Milestones"), ("runner", "Runner")]
+# The sections of a roadmap view, in page order: the nav sub-links. `render_body` writes them in this order.
+_PAGE_ANCHORS = [("waiting", "Waiting"), ("overview", "Overview"), ("flow", "Flow"), ("board", "Board"),
+                 ("timeline", "Timeline"), ("gates", "Gates"), ("milestones", "Milestones"), ("runner", "Runner")]
 
 def _rid(folder, slug) -> str | None:
     """The view id of a roadmap in `index.html`: `rm-<the folder's 6 hex>-<slug>` (the 6 hex keep two clones with
@@ -595,46 +664,59 @@ def render_html(model: dict) -> str:
                   body=render_body(model))
 
 
-def render_body(model: dict) -> str:
+def render_body(model: dict, site: bool = False) -> str:
     """Everything inside `<main>`: the header and the sections. `write_page` keeps it as `<slug>.body.html`; the
-    hub puts it, with its ids prefixed, in `index.html` as the roadmap's view."""
+    hub puts it, with its ids prefixed, in `index.html` as the roadmap's view. A shared copy (`site`) leaves out the
+    session tables and the Runner section."""
     title = f"Roadmap {model['roadmap']}"
     phases = [ph for ms in model["milestones"] for ph in ms["phases"]]
     done = sum(1 for ph in phases if ph["tile"] in ("done", "moved"))
     commit = f" · origin <code>{_e(model.get('origin_commit'))}</code>" if model.get("origin_commit") else ""
+    chips = "".join(
+        f'<span class="chip" style="--lc:var(--c{i % 6})"><b>{_e(plan)}</b> <span>'
+        f'{_e(sum(1 for ph in phases if ph["plan"] == plan and ph["tile"] in ("done", "moved")))}/'
+        f'{_e(sum(1 for ph in phases if ph["plan"] == plan))} phases</span></span>'
+        for i, plan in enumerate(model["lanes"]))
     return "".join([
         f'<header class="hdr"><div><h1>{_e(title)}</h1><p class="sub">{_e(model["done"])} of {_e(model["total"])} '
         f'milestones · {_e(done)} of {_e(len(phases))} phases done · branch <code>{_e(model["branch"])}</code>'
-        f"{commit} · generated {_e(model['generated'])}</p></div></header>",
-        _waiting_section(model), _swimlane(model), _summary(model), _now_next_later(model), _gates(model),
-        _milestones(model), _runner(model),
+        f'{commit} · generated {_e(model["generated"])}</p>'
+        + (f'<div class="chips">{chips}</div>' if chips else "") + "</div></header>",
+        _waiting_section(model, site), _summary(model), _flow(model), _now_next_later(model), _swimlane(model),
+        _gates(model), _milestones(model), "" if site else _runner(model),
+        '<p class="empty">Built from roadmap.md and the plan Trackers and headers on origin.</p>' if site else
         '<p class="empty">Built from roadmap.md, the plan Trackers and headers on origin, the runner state and the '
         "session-state folder. Re-rendered by the runner, /handoff, /pr-merge, /catchup and the waiting hooks.</p>"])
 
 
-def default_page_path(root: Path, slug: str, home: Path | None = None) -> Path:
+def default_page_path(root: Path, slug: str, home: Path | None = None, base: Path | None = None) -> Path:
     """`~/.caddis/roadmap-pages/<repo folder>-<6 hex>/<slug>.html`: outside every checkout, so a render never makes a
     repo dirty (17 Oct: the in-repo `.local/` folder is not gitignored in every repo). The folder is the MAIN
-    checkout (a worktree shares its page); the 6 hex of its path keep two clones with one name apart."""
+    checkout (a worktree shares its page); the 6 hex of its path keep two clones with one name apart. `base` (the
+    shared copy's build folder) stands in for the pages root."""
     main = main_checkout(root)
     tag = hashlib.sha1(str(main).lower().encode("utf-8")).hexdigest()[:6]
-    return pages_root(home) / f"{main.name}-{tag}" / f"{slug}.html"
+    return (base if base is not None else pages_root(home)) / f"{main.name}-{tag}" / f"{slug}.html"
 
 
-def write_page(root: Path, slug: str, out: Path | None, roadmap_mod) -> Path | None:
+def write_page(root: Path, slug: str, out: Path | None, roadmap_mod, *, site_dir: Path | None = None) -> Path | None:
     """At the default path: `<slug>.body.html` (the page body, which the hub shows as a view of `index.html`), a
     one-line `<slug>.html` that opens that view, and `<slug>.json` (the one-row summary the hub is built from). An
     `--out` page is a one-off self-contained copy and stays out of the hub. None: a newer caddis wrote this page,
-    so it is kept."""
-    path = Path(out) if out else default_page_path(root, slug)
-    if out is None and _owned_by_newer(slug, path.with_suffix(".json")):  # before build: a skip does no work
+    so it is kept. `site_dir` (the shared copy's build folder) writes there instead, with no version gate, and
+    leaves this machine's waiting sessions and runner out of the model before anything is rendered."""
+    path = Path(out) if out else default_page_path(root, slug, base=site_dir)
+    if out is None and site_dir is None and _owned_by_newer(slug, path.with_suffix(".json")):  # a skip does no work
         return None
     model = build(root, slug, roadmap_mod)
+    if site_dir is not None:  # a CI run has no session marks and no runner: hide them, never show them as empty
+        model["sessions"] = []
+        model["runner"] = {"lock": None, "stale_lock": None, "last_stop": None, "errors": []}
     path.parent.mkdir(parents=True, exist_ok=True)
     if out is not None:
         _write_atomic(path, render_html(model))
         return path
-    _write_atomic(path.with_suffix(".body.html"), render_body(model))
+    _write_atomic(path.with_suffix(".body.html"), render_body(model, site=site_dir is not None))
     rid = _rid(path.parent.name, model["roadmap"])
     _write_atomic(path, _stub(rid, model["roadmap"]) if rid else render_html(model))
     try:  # the summary feeds the hub only: the page is written, so a failure here never fails the render
@@ -677,17 +759,45 @@ def is_newer(theirs, mine) -> bool:
 
 
 GENERATOR_OWNERSHIP_S = 1800  # a newer caddis owns a page only while it keeps writing it (review of #71)
+# While the newer version is still INSTALLED on this machine, it owns the page much longer: an older session that is
+# still open must not undo a release (20 Oct 2026: a 1.3.145 session re-rendered the 1.3.147 hub in the old layout
+# 30 minutes after the release). A real downgrade removes the newer version, and the 30 minutes apply again.
+INSTALLED_OWNERSHIP_S = 24 * 3600
+
+
+def installed_versions(home: Path | None = None) -> set[str]:
+    """The caddis versions installed on this machine: the Claude Code plugin cache folders and agy's plugin
+    manifest. Empty when none can be read."""
+    base = Path(home or Path.home())
+    found: set[str] = set()
+    try:
+        for d in (base / ".claude" / "plugins" / "cache" / "caddis" / "caddis").iterdir():
+            if d.is_dir() and _version_key(d.name) is not None:
+                found.add(d.name)
+    except OSError:
+        pass
+    data, _ = _read_json(base / ".gemini" / "config" / "plugins" / "caddis" / "plugin.json")
+    if isinstance(data, dict) and _version_key(data.get("version")) is not None:
+        found.add(str(data["version"]))
+    return found
+
+
+def _ownership_s(theirs: str, home: Path | None = None) -> int:
+    """How long a newer caddis owns what it wrote: a day while it is installed under `home`, else
+    GENERATOR_OWNERSHIP_S."""
+    return INSTALLED_OWNERSHIP_S if theirs in installed_versions(home) else GENERATOR_OWNERSHIP_S
 
 
 def _newer_owner(summary: Path) -> tuple[str, bool]:
-    """(version, live): the newer caddis that wrote `summary` ("" when it is not newer), and whether it wrote it in
-    the last GENERATOR_OWNERSHIP_S. An unreadable time is not live: a downgrade must never freeze a page."""
+    """(version, live): the newer caddis that wrote `summary` ("" when it is not newer), and whether it wrote it
+    within its ownership window (`_ownership_s`). An unreadable time is not live: a downgrade must never freeze a
+    page."""
     data, _ = _read_json(summary)
     theirs = str((data or {}).get("generator") or "")
     if not is_newer(theirs, generator_version()):
         return "", False
     age_h = _age_h(str((data or {}).get("generated_utc") or ""), datetime.datetime.now(datetime.timezone.utc))
-    return theirs, age_h is not None and age_h * 3600 <= GENERATOR_OWNERSHIP_S
+    return theirs, age_h is not None and age_h * 3600 <= _ownership_s(theirs)
 
 
 def _gate(label: str, theirs: str, live: bool) -> bool:
@@ -697,7 +807,7 @@ def _gate(label: str, theirs: str, live: bool) -> bool:
         return True
     if theirs:
         print(f"[ROADMAP] {label}: taking over from caddis {theirs} (it has not written for "
-              f"{GENERATOR_OWNERSHIP_S // 60} min)")
+              f"{_ownership_s(theirs) // 60} min)")
     return False
 
 
@@ -887,26 +997,121 @@ def _int(value) -> int:
         return 0
 
 
+def _roadmap_link(r: dict, label=None) -> str:
+    """The roadmap's name linked to its view; plain text for a row that has no view."""
+    rid = _rid(r.get("folder"), r.get("slug"))
+    text = _e(r.get("slug") if label is None else label)
+    return f'<a href="#{rid}">{text}</a>' if rid else text
+
+
+def _repo_slug_key(r: dict) -> tuple[str, str, str]:
+    return (str(r.get("repo", "")).lower(), str(r.get("folder", "")), str(r.get("slug", "")))
+
+
+def _table(head: list[str], body: list[str]) -> str:
+    return ('<div class="scroll"><table><tr>' + "".join(f"<th>{_e(h)}</th>" for h in head) + "</tr>"
+            + "".join(body) + "</table></div>")
+
+
+def _gates_view(rows: list[dict]) -> str:
+    items = []
+    for r in rows:
+        for b in r.get("blockers") or r.get("owner_gates") or []:  # a v1 summary has owner_gates only
+            items.append((r, b))
+    items.sort(key=lambda rb: (str(rb[1].get("type") or "owner-gate") != "owner-gate", *_repo_slug_key(rb[0]),
+                               str(rb[1].get("milestone", ""))))
+    body = []
+    for r, b in items:
+        rid, ms = _rid(r.get("folder"), r.get("slug")), str(b.get("milestone", ""))
+        ms_text = _e(ms)
+        if rid and re.fullmatch(r"[A-Za-z][\w-]*", ms):  # the id is prefixed by `_prefix_ids` only when it is plain
+            ms_text = f'<a href="#{rid}-ms-{ms_text}">{ms_text}</a>'
+        kind = str(b.get("type") or "owner-gate")
+        body.append(f'<tr><td><strong>{_e(r.get("repo"))}</strong></td><td>{_roadmap_link(r)}</td><td>{ms_text}</td>'
+                    f'<td><span class="kind k-{_e(kind)}">{_e(kind)}</span></td><td>{_e(b.get("reason"))}</td>'
+                    f'<td><code>{_e(b.get("check") or "-")}</code></td></tr>')
+    if not body:
+        return '<p class="empty">No open gates or blockers.</p>'
+    return _table(["Repo", "Roadmap", "Milestone", "Type", "Reason", "Check"], body)
+
+
+def _sessions_view(rows: list[dict]) -> str:
+    out = []
+    for _folder, group in _group_rows(rows)[0]:
+        sessions = sorted(_sessions_of(group), key=lambda s: not s.get("asking"))  # asking first, then by mark order
+        if not sessions:
+            continue
+        body = []
+        for s in sessions:
+            stale = " (stale?)" if s.get("stale") else ""
+            body.append(f'<tr><td><code>{_e(s.get("session"))}</code></td>'
+                        f'<td>{"asking" if s.get("asking") else "idle"}</td><td>{_e(s.get("message"))}</td>'
+                        f'<td>{_e(s.get("since"))}{_e(stale)}</td></tr>')
+        out.append(f'<div class="card"><h3>{_e(group[0].get("repo"))}</h3>'
+                   + _table(["Session", "Asking or idle", "Message", "Since"], body) + "</div>")
+    return "".join(out) or '<p class="empty">No session is waiting.</p>'
+
+
+def _runners_view(rows: list[dict]) -> str:
+    body = []
+    for r in sorted(rows, key=lambda r: (r.get("runner") != "running", *_repo_slug_key(r))):
+        detail = r.get("runner_detail") if isinstance(r.get("runner_detail"), dict) else {}
+        lock, stop = detail.get("lock"), detail.get("last_stop")
+        batch = lock.get("batch") if isinstance(lock, dict) else None
+        stop_text = " · ".join(str(v) for v in ((stop or {}).get("reason"), (stop or {}).get("utc")) if v)             if isinstance(stop, dict) else ""
+        runner = str(r.get("runner") or "")
+        pill = ("s-in-progress" if runner == "running" else "s-blocked" if runner else "s-todo")
+        body.append(f'<tr><td><strong>{_e(r.get("repo"))}</strong></td><td>{_roadmap_link(r)}</td>'
+                    f'<td><span class="pill {pill}">{_e(runner or "idle")}</span></td><td>{_e(batch or "-")}</td>'
+                    f'<td>{_e(stop_text or "-")}</td><td>{_e(r.get("next") or "-")}</td></tr>')
+    if not body:
+        return '<p class="empty">No roadmap pages yet.</p>'
+    return _table(["Repo", "Roadmap", "Runner", "Batch", "Last stop", "Next"], body)
+
+
+_VIEWS = {"gates": ("Gates", "Every open owner gate and blocker, across all repos. Owner gates come first.", _gates_view),
+          "sessions": ("Sessions", "The newest session marks of each repo.", _sessions_view),
+          "runners": ("Runners", "The roadmap runner of every roadmap on this machine.", _runners_view)}
+
+
+def render_view(kind: str, rows: list[dict]) -> str:
+    """`<section class="view" id="gates|sessions|runners">`: a cross-repo table over the page summaries. These sections
+    sit outside any roadmap body, so their ids are not prefixed; links into a roadmap use its prefixed ids."""
+    title, note, fn = _VIEWS[kind]
+    return f'<section class="view" id="{kind}"><h2>{_e(title)}</h2><p class="sub">{_e(note)}</p>{fn(rows)}</section>'
+
+
+_SITE_NOTE = "Shared copy — built by CI. Live sessions and runners show only on the owner's machine."
+_SITE_CSS = (".site-banner{margin:0 0 12px;padding:8px 12px;border:1px solid var(--line);border-radius:8px;"
+             "border-left:4px solid var(--accent);background:var(--panel2);color:var(--fg);font-size:13px}")
+
+
 def render_hub(rows: list[dict], errors: list[str], now: datetime.datetime,
-               bodies: dict[str, str] | None = None) -> str:
+               bodies: dict[str, str] | None = None, *, site: bool = False, banner: str = "") -> str:
     """The whole app in one file: the inbox and overview view, then one view per roadmap (its body from `bodies`,
     ids prefixed). CSS shows one view at a time, so the nav is the same for every view and is never stale. While the
-    inbox shows, the page reloads itself every 60 s (the script), so an open tab follows the renders."""
+    inbox shows, the page reloads itself every 60 s (the script), so an open tab follows the renders. A shared copy
+    (`site`, built by CI) shows `banner` and leaves out everything of this machine: the sessions and the runners,
+    in the nav, the inbox and the views. Owner gates stay: they come from git."""
     bodies = bodies or {}
     errors = list(errors)
+    if site:  # whatever a summary holds of live state is dropped here too, not only at the writer
+        rows = [{**r, "sessions": [], "runner": "", "runner_detail": {}} for r in rows]
     order, need, count = _group_rows(rows)
     phases_done = sum(_int(r.get("phases_done")) for r in rows)
     phases_total = sum(_int(r.get("phases_total")) for r in rows)
     live = sum(1 for r in rows if r.get("runner") == "running")
     blocked = sum(_int(r.get("blocked")) for r in rows)
-    out = ['<section class="view" id="inbox"><section class="kpis">',
+    out = [f'<p class="site-banner" role="note">{_e(banner or _SITE_NOTE)}</p>' if site else "",
+           '<section class="view" id="inbox"><section class="kpis">',
            f'<div class="kpi"><b>{_e(count)}</b>Needs you</div>',
            f'<div class="kpi"><b>{_e(phases_done)} / {_e(phases_total)}</b>Phases done'
            f'{_bar(phases_done, phases_total)}</div>',
            f'<div class="kpi"><b>{_e(blocked)}</b>Blocked phases</div>',
-           f'<div class="kpi"><b>{_e(live)}</b>Runners live</div></section>',
+           "" if site else f'<div class="kpi"><b>{_e(live)}</b>Runners live</div>', "</section>",
            f'<p class="sub">{_e(len(order))} repos · {_e(len(rows))} roadmaps · {_e(count)} item(s) need you · '
-           f'generated {_e(now.strftime("%Y-%m-%d %H:%M UTC"))} · the inbox reloads every minute</p>',
+           f'generated {_e(now.strftime("%Y-%m-%d %H:%M UTC"))}'
+           + ("" if site else " · the inbox reloads every minute") + "</p>",
            '<section id="needs" class="card wait"><h2>Needs you</h2>']
     if not need:
         out.append('<p class="empty">Nothing is waiting for you.</p>')
@@ -941,13 +1146,13 @@ def render_hub(rows: list[dict], errors: list[str], now: datetime.datetime,
                    f'<div>{_bar(_int(r.get("phases_done")), _int(r.get("phases_total")))} '
                    f'{_e(r.get("milestones_done"))}/{_e(r.get("milestones_total"))} milestones</div>'
                    f'<div class="dots">{dots}</div>'
-                   f'<div class="empty">next: {_e(r.get("next") or "-")} · runner: {_e(r.get("runner") or "idle")}'
-                   f'{_e(old)}</div></a>')
+                   f'<div class="empty">next: {_e(r.get("next") or "-")}'
+                   + ("" if site else f' · runner: {_e(r.get("runner") or "idle")}') + f'{_e(old)}</div></a>')
     out.append("</div>")
     for err in errors:
         out.append(f'<p class="empty">Could not read {_e(err)}.</p>')
-    out.append('<p class="empty">Built from the page summaries in this folder. Every roadmap page render rebuilds it.'
-               "</p></section>")
+    out.append('<p class="empty">' + ("Built by CI from the roadmaps on origin." if site else
+               "Built from the page summaries in this folder. Every roadmap page render rebuilds it.") + "</p></section>")
     rids = []
     for r in sorted(rows, key=lambda r: (str(r.get("repo", "")).lower(), str(r["folder"]), str(r["slug"]))):
         rid = _rid(r.get("folder"), r.get("slug"))
@@ -960,27 +1165,33 @@ def render_hub(rows: list[dict], errors: list[str], now: datetime.datetime,
                  "in its repo.</p>")
         out.append(f'<section class="view" id="{rid}"><p class="view-crumbs"><a href="#inbox">Roadmaps</a> › '
                    f'{_e(r.get("repo"))} › <strong>{_e(r["slug"])}</strong></p>{inner}</section>')
-    for key, label in (("gates", "Gates"), ("sessions", "Sessions"), ("runners", "Runners")):  # Phase 6 fills these
-        out.append(f'<section class="view" id="{key}"><h2>{label}</h2><p class="card empty">The cross-repo {key} '
-                   'view comes in a later update. For now, see <a href="#needs">Needs you</a> on the inbox and each '
-                   "roadmap's own page.</p></section>")
-    return _shell(title="Roadmaps", base="", nav=_nav(rows, ""), crumbs="Roadmaps", body="".join(out),
-                  css=_view_css(rids))
+    for kind in _VIEWS:
+        if not (site and kind in _LOCAL_VIEWS):
+            out.append(render_view(kind, rows))
+    return _shell(title="Roadmaps", base="", nav=_nav(rows, "", site), crumbs="Roadmaps", body="".join(out),
+                  css=_view_css(rids, site) + (_SITE_CSS if site else ""),
+                  script=_SITE_THEME_SCRIPT if site else None)
 
 
-def write_hub(home: Path | None = None, now: datetime.datetime | None = None) -> Path | None:
+def write_hub(home: Path | None = None, now: datetime.datetime | None = None, *,
+              site_dir: Path | None = None, banner: str = "") -> Path | None:
     """`~/.caddis/roadmap-pages/index.html`: every roadmap page on this machine, grouped per repo. None: a newer
-    caddis wrote the hub (its version is in `.hub-generator`), so it is kept."""
-    root_dir = pages_root(home)
+    caddis wrote the hub (its version is in `.hub-generator`), so it is kept. `site_dir` (the shared copy's build
+    folder) is written instead, with `banner`, with no live sessions or runners, and with no version gate and no
+    stamp: CI is the only writer of that folder."""
+    root_dir = pages_root(home) if site_dir is None else Path(site_dir)
     root_dir.mkdir(parents=True, exist_ok=True)
     stamp = root_dir / ".hub-generator"
-    try:
-        theirs = stamp.read_text(encoding="utf-8").strip()
-        live = time.time() - stamp.stat().st_mtime <= GENERATOR_OWNERSHIP_S
-    except (OSError, UnicodeDecodeError):
-        theirs, live = "", False
-    if _gate("hub", theirs if is_newer(theirs, generator_version()) else "", live):
-        return None
+    if site_dir is None:
+        try:
+            theirs = stamp.read_text(encoding="utf-8").strip()
+            if not is_newer(theirs, generator_version()):
+                theirs = ""
+            live = bool(theirs) and time.time() - stamp.stat().st_mtime <= _ownership_s(theirs, home)
+        except (OSError, UnicodeDecodeError):
+            theirs, live = "", False
+        if _gate("hub", theirs, live):
+            return None
     try:
         install_assets(root_dir)
     except Exception as exc:  # a missing font file must never stop the hub
@@ -992,6 +1203,103 @@ def write_hub(home: Path | None = None, now: datetime.datetime | None = None) ->
         print(f"[ROADMAP] page bodies not read: {exc}", file=sys.stderr)
         bodies = {}
     path = root_dir / "index.html"
-    _write_atomic(path, render_hub(rows, errors, now or datetime.datetime.now(datetime.timezone.utc), bodies))
+    now = now or datetime.datetime.now(datetime.timezone.utc)
+    if site_dir is not None:
+        _write_atomic(path, render_hub(rows, errors, now, bodies, site=True, banner=banner))
+        return path
+    _write_atomic(path, render_hub(rows, errors, now, bodies))
     _write_atomic(stamp, generator_version() + "\n")
     return path
+
+
+# ---- the shared copy: `render --site <dir>` builds in <dir>/build and publishes an allow-list to <dir>/public -----
+
+def _short_sha(root: Path) -> str:
+    try:
+        done = subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=root, capture_output=True, text=True,
+                              stdin=subprocess.DEVNULL, timeout=15,
+                              creationflags=0x08000000 if os.name == "nt" else 0)
+    except (OSError, subprocess.SubprocessError):
+        return "unknown"
+    return done.stdout.strip() or "unknown" if done.returncode == 0 else "unknown"
+
+
+def site_banner(root: Path, now: datetime.datetime | None = None, env=None) -> str:
+    """The shared copy's banner (plain text; `render_hub` escapes it). CI names the repo and commit in
+    `GITHUB_REPOSITORY` and `GITHUB_SHA`; on a local run they are the checkout's folder name and `git rev-parse`."""
+    env = os.environ if env is None else env
+    repo = (env.get("GITHUB_REPOSITORY") or "").strip() or main_checkout(Path(root)).name
+    sha = (env.get("GITHUB_SHA") or "").strip()[:7] or _short_sha(Path(root))
+    when = (now or datetime.datetime.now(datetime.timezone.utc)).strftime("%Y-%m-%d %H:%M UTC")
+    return (f"Shared copy — built by CI from {repo} at {sha}, {when}. "
+            "Live sessions and runners show only on the owner's machine.")
+
+
+def _is_link(path: Path) -> bool:
+    """A symlink or a Windows junction: never followed by the export."""
+    if path.is_symlink():
+        return True
+    try:
+        return bool(os.lstat(path).st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT)  # Windows only
+    except (AttributeError, OSError):
+        return False
+
+
+def _plain_file(path: Path) -> bool:
+    return path.is_file() and not _is_link(path)
+
+
+def export_site(build: Path, public: Path) -> list[str]:
+    """Copy the allow-list of `build` to a fresh `public` and return the published paths (sorted, `/` separated):
+    `index.html`, every file under `_assets/` except `*.json`, `*.body.html` and dot files, and each
+    `<folder>/<slug>.html` whose `<slug>.json` sits beside it and whose slug passes the slug rule. Nothing else is
+    published: not a `*.json` (the local checkout path and session data), not a `*.body.html`, not `.locks/`, not
+    `.hub-generator`, not a dot file or folder, and not a link. `public` is wiped first, but only a folder this
+    function made (a marker beside it says so), or an empty one; a link, a file, `build` itself and a folder that
+    holds `build` or sits in it are refused (ValueError)."""
+    build, public = Path(build), Path(public)
+    if public.name in ("", ".", ".."):
+        raise ValueError(f"the public folder needs a plain folder name, not {str(public)!r}")
+    if not build.is_dir() or _is_link(build):
+        raise ValueError(f"the build folder is not a plain folder: {build}")
+    b = build.resolve()
+    p = public.parent.resolve() / public.name
+    if _is_link(public) or (public.exists() and not public.is_dir()):
+        raise ValueError(f"the public folder is a link or a file: {public}")
+    if p == b or b in p.parents or p in b.parents:
+        raise ValueError(f"the public folder and the build folder overlap: {public}")
+    marker = public.parent / f".{public.name}.created-by-caddis"
+    if public.exists():
+        if not marker.exists() and any(public.iterdir()):
+            raise ValueError(f"{public} exists and was not made by this command; remove it or choose another folder")
+        shutil.rmtree(public)
+    public.mkdir(parents=True)
+    marker.write_text("made by caddis_roadmap.py render --site; wiped on each run\n", encoding="utf-8")
+    out: list[str] = []
+
+    def put(src: Path, rel: str) -> None:
+        dst = public / rel
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(src, dst)
+        out.append(rel)
+
+    if _plain_file(build / "index.html"):
+        put(build / "index.html", "index.html")
+    assets = build / "_assets"
+    if assets.is_dir() and not _is_link(assets):
+        for dirpath, dirnames, filenames in os.walk(assets, followlinks=False):
+            here = Path(dirpath)
+            dirnames[:] = sorted(d for d in dirnames if not d.startswith(".") and not _is_link(here / d))
+            for name in sorted(filenames):
+                if name.startswith(".") or name.endswith((".json", ".body.html")) or not _plain_file(here / name):
+                    continue
+                put(here / name, (here / name).relative_to(build).as_posix())
+    for folder in sorted(build.iterdir()):
+        if folder.name.startswith(".") or folder.name == "_assets" or not folder.is_dir() or _is_link(folder):
+            continue
+        for page_file in sorted(folder.glob("*.html")):
+            slug = page_file.stem
+            if (page_file.suffix == ".html" and _SLUG_RE.fullmatch(slug) and _plain_file(page_file)
+                    and _plain_file(folder / f"{slug}.json")):
+                put(page_file, f"{folder.name}/{page_file.name}")
+    return sorted(out)