Files
skills/orchestrator/templates/page-home.js
T
Kevin Veen-BirkenbachandClaude Opus 5.5 7adb6d63a3 feat(orchestrator): redesign the radio set into device, speak and history cards
The radio shows the device card on the left and the speak and history cards on the right from 45 to 61 rem of height, stacking below that; only the history scrolls. History rows get stable keys (sent-row id, else time, sender and occurrence), and focus moves to the nearest row when the focused one disappears. Tests run once on unify/skills-20261114 after the merge (operator order 2026-11-14).

🎯 Fix: 85 %
💥 Break: 12 %
💸 Tokens: 60 %
⏱️ Velocity: 45 %
🛡️ Security: 100 %
🏆 Score: 100
🚦 Gate: ⛔ fix 85 % < 90, break 12 % > 5

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 21:28:25 +00:00

404 lines
16 KiB
JavaScript

const HOME_PATH = "home.pins";
const HOME_FETCH = 3000;
const HOME_MESSAGE = 30000;
const HOME_MARKS = [['section[aria-label="Recently sent"]', "radio-log"]];
const homeView = {dom: null, pins: [], tiles: new Map(), hosts: new Map(), messages: new Map(), drag: null, mark: () => null, touched: false, fetched: {}};
const homeStore = Panels.store(typeof ViewStore === "object" && ViewStore ? ViewStore : Panels.memory(), HOME_PATH);
const homePins = () => homeView.pins;
const homeIndex = (key) => homePins().findIndex((pin) => Panels.keyOf(pin) === key);
const homeWait = (title) => emptyState(title, "The tile fills in on the next poll.");
function homeFetch(name, work) {
if (Date.now() - (homeView.fetched[name] || 0) > HOME_FETCH) {
homeView.fetched[name] = Date.now();
Promise.resolve(work()).then(() => drawHome());
}
}
function homeStream(size) {
homeFetch("events", fetchEvents);
const rows = [...stream.events, ...stream.entries].sort((a, b) => b.ts - a.ts).slice(0, Math.max(3, size.h * 2));
return rows.length ? h("ol", {class: "feed"}, rows.map(eventRow)) : homeWait(stream.key ? "No entries" : "Loading …");
}
async function homeLoadMessage(key, ts, id) {
const known = homeView.messages.get(key) || {entry: undefined};
homeView.messages.set(key, {...known, busy: true, at: Date.now()});
let entry = known.entry;
try {
const response = await fetch(`/api/events?from=${Math.floor(ts) - 1}&to=${Math.ceil(ts) + 1}&after=0`, {cache: "no-store"});
if (response.ok) {
const data = await response.json();
entry = [...data.events, ...data.entries].find((row) => String(row.id) === id) || null;
}
} catch {
ui.offline = true;
}
homeView.messages.set(key, {entry, busy: false, at: Date.now()});
drawHome();
}
function homeMessage(key) {
const cut = key.indexOf("/");
const ts = Number(key.slice(0, cut));
const id = key.slice(cut + 1);
if (cut < 1 || !Number.isFinite(ts)) {
return null;
}
const shown = [...stream.events, ...stream.entries].find((row) => String(row.id) === id);
const known = homeView.messages.get(key);
if (!shown && (!known || (!known.busy && Date.now() - known.at > HOME_MESSAGE))) {
homeLoadMessage(key, ts, id);
}
const entry = shown || (known ? known.entry : undefined);
if (entry === undefined) {
return homeWait("Loading …");
}
return entry ? h("ol", {class: "feed"}, eventRow(entry)) : null;
}
function homeRadio(id) {
const host = homeView.hosts.get(id) || radioPart(id);
homeView.hosts.set(id, host);
return host;
}
function homeTree(draw) {
if (!tree.data) {
homeFetch("tree", fetchTree);
return homeWait("Reading repositories …");
}
return tree.data.error ? emptyState("No tree", tree.data.error) : draw();
}
function homeArt(view) {
return homeTree(() => {
const repo = chosenRepo();
return repo ? {orbit: artOrbit, chord: artChord, swimlane: artSwimlane}[view](repo, tree.model) : emptyState("No repository", "pkgmgr names no repository.");
});
}
function homeArtifact(id) {
return homeTree(() => {
const node = tree.model.byId.get(id);
return node ? h("div", {class: "home-popup"}, artPopup(node)) : null;
});
}
function homeAncestry(path) {
return homeTree(() => {
const repo = tree.data.repos.find((entry) => entry.path === path);
return repo ? branchAncestry(repo) : null;
});
}
function homeOrbit() {
const kept = [graphDom, positions];
graphDom = {pulses: null};
try {
return orbit();
} finally {
[graphDom, positions] = kept;
}
}
function home3d(tab) {
const id = `${tab}/3d`;
const pin = homePins().find((entry) => entry.kind === Panels.PANEL && entry.id === id);
if (pin && !Panels.firstOfGroup(homePins(), pin)) {
return emptyState("One 3D tile at a time", "Another 3D tile already runs live on Home; unpin it to bring this one to life.");
}
const host = homeView.hosts.get(id) || h("div", {class: "stage home-stage"});
homeView.hosts.set(id, host);
window.setTimeout(() => host.isConnected && stage3d(tab, host), 0);
return host;
}
function agentTile(key) {
const node = state.graph.nodes.find((entry) => entry.id === key);
if (!node && !Object.hasOwn(people(), key)) {
return null;
}
const tasks = node ? node.tasks : [];
const claims = node ? node.claims : [];
return h("div", {class: "home-agent"},
h("div", {class: "who"}, face(key, true), person(nameOf(key)), presenceMark(key, true)),
h("p", {class: "muted"}, claims.length ? `Offices: ${claims.map((claim) => claim.office).join(", ")}` : "No office"),
tasks.length ? h("ul", {class: "mini"}, tasks.map((task) => h("li", {}, h("div", {class: "row"}, h("code", {}, task.task), status(task.status)), h("span", {}, dash(task.title)))))
: h("p", {class: "muted"}, "No open tasks."));
}
function homeTask(id) {
const row = state.tasks.find((entry) => entry.task === id);
return row ? h("ol", {class: "task-list"}, taskItem(row, etaOf().get(row.task))) : null;
}
function homeTaskList() {
const etas = etaOf();
return h("ol", {class: "task-list"}, Plan.sortRows(shownTasks(), taskView.sort, taskView.descending).map((row) => taskItem(row, etas.get(row.task))));
}
Panels.panel("stream", "Stream", homeStream);
Panels.panel("radio-log", "Radio log", () => homeRadio("radio-log"), "", [6, 5]);
Panels.panel("radio", "Radio", () => homeRadio("radio"), "", [12, 7]);
Panels.panel("radio-device", "Radio: device", () => homeRadio("radio-device"), "", [6, 6]);
Panels.panel("radio-speak", "Radio: speak", () => homeRadio("radio-speak"), "", [6, 5]);
Panels.panel("agents/orbit", "Agents: Orbit", homeOrbit);
Panels.panel("agents/chord", "Agents: Chord", () => chord());
Panels.panel("agents/swimlane", "Agents: Swimlane", () => swimlane());
Panels.panel("agents/3d", "Agents: 3D", () => home3d("agents"), "3d");
Panels.panel("agents/tree", "Agents: spawn tree", () => h("ul", {class: "spawn-tree root"}, spawnItem(spawnTree())));
Panels.panel("agents/hierarchy", "Agents: hierarchy", () => chartTree());
Panels.panel("artifacts/orbit", "Artifacts: Orbit", () => homeArt("orbit"));
Panels.panel("artifacts/chord", "Artifacts: Chord", () => homeArt("chord"));
Panels.panel("artifacts/swimlane", "Artifacts: Swimlane", () => homeArt("swimlane"));
Panels.panel("artifacts/3d", "Artifacts: 3D", () => homeTree(() => home3d("artifacts")), "3d");
Panels.panel("tasks/list", "Tasks: list", homeTaskList);
Panels.panel("tasks/board", "Tasks: kanban", () => kanbanBoard(shownTasks()));
Panels.panel("tasks/rasci", "Tasks: RASCI", () => taskMatrix(shownTasks()));
Panels.panel("tasks/gantt", "Tasks: Gantt", () => ganttChart(shownTasks()));
Panels.panel("tasks/burn", "Tasks: burndown and burnup", () => burnChart(state.tasks, shownTasks()));
Panels.panel("tasks/3d", "Tasks: 3D", () => home3d("tasks"), "3d");
Panels.item("task", (id) => `Task ${id}`, (size, id) => homeTask(id));
Panels.item("message", "Message", (size, id) => homeMessage(id));
Panels.item("artifact", (id) => `Artifact ${id.replace(/\u0000/g, " ")}`, (size, id) => homeArtifact(id));
Panels.item("agent", (id) => `Agent ${labelOf(id)}`, (size, id) => agentTile(id));
Panels.item("ancestry", (id) => `Ancestry ${id}`, (size, id) => homeAncestry(id));
function homeRefused(why) {
homeView.pins = homeStore.read();
drawHome();
homeView.mark();
toast("Home not saved", [why], false);
}
function homeSave(change) {
const done = homeStore.change(change);
homeView.pins = homeStore.read();
drawHome();
homeView.mark();
return done.then((stored) => {
if (stored === false) {
homeRefused(homeStore.error() || "The view store refused the layout.");
}
return stored !== false;
}, (error) => {
homeRefused(String(error.message || error));
return false;
});
}
function homeRefusal(refused, holder, title) {
if (refused === "full") {
toast("Home is full", [`At most ${Panels.MAX} pins: unpin one before you pin ${title}.`], false);
} else if (refused === "group") {
const other = Panels.lookup(holder.kind, holder.id);
toast("One 3D tile at a time", [`Home already holds ${other ? other.title : holder.id}: unpin it before you pin ${title}.`], false);
}
}
function homePress(kind, id, title) {
homeView.touched = true;
if (Panels.has(homePins(), kind, id)) {
homeSave((pins) => Panels.remove(pins, kind, id));
return;
}
const {refused, holder} = Panels.add(homePins(), kind, id);
if (refused) {
homeRefusal(refused, holder, title);
return;
}
homeSave((pins) => Panels.add(pins, kind, id).pins).then((stored) => {
const now = homeStore.read();
if (stored && !Panels.has(now, kind, id)) {
const late = Panels.add(now, kind, id);
homeRefusal(late.refused, late.holder, title);
}
});
}
function homeUnpin(key) {
homeView.touched = true;
homeSave((pins) => pins.filter((pin) => Panels.keyOf(pin) !== key));
}
function homeSpan(tile, size) {
tile.style.setProperty("--w", String(size.w));
tile.style.setProperty("--h", String(size.h));
tile.dataset.w = String(size.w);
tile.dataset.h = String(size.h);
}
function homeGrab(event, key, mode) {
if (event.button !== 0 || homeIndex(key) < 0) {
return;
}
event.preventDefault();
const pin = homePins()[homeIndex(key)];
const grid = homeView.dom.grid;
const look = getComputedStyle(grid);
const gap = parseFloat(look.columnGap) || 0;
const column = (grid.clientWidth - gap * (Panels.SPAN - 1)) / Panels.SPAN + gap;
const row = (parseFloat(look.gridAutoRows) || 1) + (parseFloat(look.rowGap) || 0);
homeView.drag = {mode, key, x: event.clientX, y: event.clientY, start: {w: pin.w, h: pin.h}, next: {w: pin.w, h: pin.h}, column, row, over: null};
homeView.tiles.get(key).classList.add("dragging");
}
function homeDragMove(event) {
const drag = homeView.drag;
if (!drag) {
return;
}
const tile = homeView.tiles.get(drag.key);
if (drag.mode === "size") {
drag.next = Panels.stretch(drag.start, event.clientX - drag.x, event.clientY - drag.y, drag.column, drag.row);
homeSpan(tile, drag.next);
return;
}
const under = document.elementFromPoint(event.clientX, event.clientY);
const into = under ? under.closest(".home-tile") : null;
drag.over = into && into !== tile ? into.dataset.pin : null;
homeView.tiles.forEach((other) => other.classList.toggle("drop", other.dataset.pin === drag.over));
}
function homeDragEnd() {
const drag = homeView.drag;
if (!drag) {
return;
}
homeView.drag = null;
homeView.tiles.forEach((tile) => tile.classList.remove("drop", "dragging"));
const {key, next, over} = drag;
if (drag.mode === "size" && (next.w !== drag.start.w || next.h !== drag.start.h)) {
homeSave((pins) => Panels.resizeKey(pins, key, next.w, next.h));
} else if (drag.mode === "move" && over) {
homeSave((pins) => Panels.placeKey(pins, key, over));
} else {
drawHome();
}
}
function homeKeys(event, key) {
const steps = {ArrowLeft: -1, ArrowUp: -1, ArrowRight: 1, ArrowDown: 1};
if (event.target !== event.currentTarget || !Object.hasOwn(steps, event.key) || event.altKey || event.ctrlKey || event.metaKey) {
return;
}
event.preventDefault();
homeSave((pins) => Panels.moveKey(pins, key, steps[event.key]));
}
function homeSizeKeys(event, key) {
const steps = {ArrowLeft: [-1, 0], ArrowRight: [1, 0], ArrowUp: [0, -1], ArrowDown: [0, 1]};
if (!Object.hasOwn(steps, event.key)) {
return;
}
event.preventDefault();
event.stopPropagation();
const [dw, dh] = steps[event.key];
homeSave((pins) => Panels.resizeBy(pins, key, dw, dh));
}
function homeGone(pin, key) {
return h("div", {class: "home-gone"}, h("strong", {class: "home-gone-word"}, "gone"),
h("p", {class: "muted"}, `This ${pin.kind} no longer exists: ${Panels.raw(pin.id).replace(/\u0000/g, " ")}`),
btn("Unpin", "btn small danger home-gone-unpin", () => homeUnpin(key)));
}
function homeTile(key) {
const title = h("h3", {class: "home-title"});
const body = h("div", {class: "home-body"});
const grip = iconBtn("bi-grip-vertical", "Move", "btn small ghost home-grip", null, "Move: drag to another tile, or focus the tile and press the arrow keys");
const handle = iconBtn("bi-arrow-down-right", "Resize", "btn small ghost home-resize", null, "Resize: drag, or the arrow keys, 1 to 12 columns wide and rows high");
const tile = h("article", {class: "home-tile", tabindex: 0, role: "listitem", "data-pin": key, on: {keydown: (event) => homeKeys(event, key)}},
h("header", {class: "home-head"}, grip, title, iconBtn("bi-x-lg", "Unpin", "btn small ghost home-unpin", () => homeUnpin(key), "Unpin: remove the tile from Home")), body, handle);
grip.addEventListener("pointerdown", (event) => homeGrab(event, key, "move"));
handle.addEventListener("pointerdown", (event) => homeGrab(event, key, "size"));
handle.addEventListener("keydown", (event) => homeSizeKeys(event, key));
homeView.tiles.set(key, tile);
return tile;
}
function homeContent(entry, pin) {
try {
return entry.render({w: pin.w, h: pin.h});
} catch (error) {
return h("p", {class: "muted home-error"}, `Not drawable: ${error.message || error}`);
}
}
function homeFill(tile, pin, index, count) {
const key = Panels.keyOf(pin);
const entry = Panels.lookup(pin.kind, pin.id);
const content = entry ? homeContent(entry, pin) : null;
const name = entry ? entry.title : `${pin.kind} ${pin.id}`;
tile.classList.toggle("gone", !content);
tile.dataset.kind = pin.kind;
tile.dataset.id = pin.id;
tile.setAttribute("aria-label", `${name}, ${pin.w} by ${pin.h}, tile ${index + 1} of ${count}`);
homeSpan(tile, pin);
tile.querySelector(".home-title").textContent = name;
const body = tile.querySelector(".home-body");
const shown = content || homeGone(pin, key);
if (body.childNodes.length !== 1 || body.firstChild !== shown) {
body.replaceChildren(shown);
}
}
function drawHome() {
const dom = homeView.dom;
if (!dom || !dom.grid.isConnected) {
homeView.dom = null;
return;
}
if (homeView.drag) {
return;
}
const pins = homePins();
const keys = new Set(pins.map(Panels.keyOf));
for (const [key, tile] of homeView.tiles) {
if (!keys.has(key)) {
tile.remove();
homeView.tiles.delete(key);
}
}
const focused = document.activeElement;
pins.forEach((pin, index) => {
const key = Panels.keyOf(pin);
const tile = homeView.tiles.get(key) || homeTile(key);
homeFill(tile, pin, index, pins.length);
if (dom.grid.children[index] !== tile) {
dom.grid.insertBefore(tile, dom.grid.children[index] || null);
}
});
if (focused instanceof HTMLElement && focused.isConnected && document.activeElement !== focused) {
focused.focus();
}
dom.empty.hidden = pins.length > 0;
}
function homeScreen() {
const grid = h("div", {class: "home-grid", role: "list", "aria-label": "Pinned panels and items"});
const empty = emptyState("Nothing pinned yet", "Press the star on any panel or item to pin it here; pins, sizes and order are kept for every browser.");
homeView.dom = {grid, empty};
homeView.tiles = new Map();
return h("div", {class: "home"}, empty, grid);
}
function homeBoot() {
homeView.pins = homeStore.read();
const opened = homePins().length;
homeStore.watch((pins) => {
homeView.pins = pins;
if (!homeView.touched && !opened && pins.length && ui.screen === "stream" && !window.location.hash.replace(/^#/, "")) {
apply();
return;
}
drawHome();
homeView.mark();
});
homeView.mark = Panels.decorate(document.body, {pinned: (kind, id) => Panels.has(homePins(), kind, id), press: homePress, marks: HOME_MARKS});
window.addEventListener("pointermove", homeDragMove);
window.addEventListener("pointerup", homeDragEnd);
window.addEventListener("pointercancel", homeDragEnd);
}