@bongos/core 1.24.77 → 1.24.79

package/modules/hall-ui/public/settings-autobongos.js

@@ -1,22 +1,39 @@
 // modules/hall-ui/public/settings-autobongos.js — the "Your Autobongos runner"
-// panel on /builders/settings (task 1004501).
+// panel on /builders/settings (tasks 1004501, 1005094).
 //
-// WHY THE PANEL EXISTS. The fence used to be one switch and one goal list for
-// every runner on the instance. Owner ruling, 2026-10-01: each builder says which
-// work THEIR runner takes, and a builder who has said nothing gets no autonomous
-// work. This is where they say it.
+// WHY THE PANEL EXISTS. Each builder runs their own runner on their own devices,
+// and says which work it takes. Owner direction, 2026-11-09: that must be as
+// simple as one button — add a device with one copied command, press Run on its
+// card, and it goes. So the panel is three things, top to bottom:
 //
-// WHAT IT READS. GET /autonomy/fence answers with the caller's EFFECTIVE fence: the
-// project allowlist narrowed to their picks, plus `scope` (what they picked, whether
-// they may run a runner, whether the owner paused them) and `project` (the
-// unnarrowed allowlist they choose from). One read, so the panel cannot disagree
-// with what the builder's runner is told. The server decides every one of those
-// facts; this page only draws them.
+//   1. YOUR DEVICES — one card per device that has checked in, each with ONE
+//      button whose face is the device's state (Run, Starting, Running, Resting
+//      until a time, Stopping, Device is off). What the face says is decided by
+//      runner-button.js, which is pure and tested; this file only draws it. A
+//      device that is switched on also carries the stay-on note: keep it on and
+//      plugged in.
+//   2. ADD A DEVICE — one command to copy, Windows or Mac, with a one-time code
+//      built in. The card appears by itself when the device first checks in.
+//   3. WHAT IT WORKS ON — the goal picks (task 1004501), unchanged.
 //
-// WHAT IT WRITES. PUT /autonomy/me/goals with the whole list, on Save. The route
-// refuses a goal that is not allowlisted (409), and it is behind `autonomy.run`, so
-// a builder who may not run a runner is told so here instead of shown a form that
-// would fail.
+// WHAT IT READS. GET /autonomy/fence (the caller's own fence, the project's
+// allowlist riding along as `project`) and GET /autonomy/runners (their devices,
+// each with the server's health verdict and the device's switch). Both are read
+// again on a timer while the page is visible, so a card moves from Starting to
+// Running without a reload. The server decides every fact; this page draws them.
+//
+// WHAT IT WRITES. POST /autonomy/runners/:host/run for the button, PUT
+// /autonomy/me/goals for the picks, POST /auth/runner-code/issue for a setup
+// code, and Remove: POST /me/sessions/revoke for the device's own login, then
+// DELETE /autonomy/runners/:host for its card.
+//
+// THE FOUR SLOTS ARE IN THE PAGE (settings.html: #ab-notices, #ab-devices,
+// #ab-add, #ab-goals), and this file only ever fills one of them. That keeps the
+// redraws apart, and lets tests/hall_runner_button.mjs run this file for real
+// against stand-in elements instead of reading it.
+//
+// THE GOAL FORM IS DRAWN ONCE, NOT ON THE TIMER. The devices redraw every few
+// seconds; a form redrawn under someone ticking boxes would untick them.
 //
 // Its own file on the settings-interaction.js precedent: settings.js sits against
 // the 1500-line ratchet, and this panel shares nothing with the rest of the page.
@@ -27,27 +44,41 @@
   const API = '/api/bongos';
   const { escapeHtml, $ } = window.OTB;
   const { emptyStateHtml } = window.OTBKit;
+  const RB = window.OTBRunnerButton;
   const toast = (msg) => window.OTB.toast(msg);
   const api = window.BongosClient.createClient({ baseUrl: '', credentials: 'same-origin', throwOnError: false });
 
   const toAuth = () => window.location.assign(`${API}/auth/web/start`);
 
-  // The lines above the form: each one says why the runner might be idle, in the
-  // order the server checks them, so the first line a builder reads is the reason.
+  // How often the devices are read again: quickly while a press is in flight or
+  // a new device is being added, slowly otherwise.
+  const POLL_FAST_MS = 3000;
+  const POLL_SLOW_MS = 15000;
+
+  const view = {
+    fence: null,
+    runners: [],
+    busyHost: null,     // a press whose request has not answered yet
+    add: null,          // { commands, platform, known:Set<host> } | { error } | null
+    timer: null,
+  };
+
+  // The server's own sentence when it sent one; otherwise `fallback`, which is a
+  // whole sentence in the page's one wording for a failed action ("Could not …").
+  const errorText = (res, fallback) => {
+    const env = res && res.data && res.data.error;
+    return (env && typeof env === 'object' && typeof env.message === 'string' && env.message) || fallback;
+  };
+
+  // ── the lines above everything ────────────────────────────────────────────
+  // Why NO device of yours can work, when that is the project's or the owner's
+  // doing. A device that is merely idle on one of these says so on its own card.
   function noticesHtml(fence) {
     const project = fence.project || {};
     const scope = fence.scope || {};
     const out = [];
-    // First, because it is the one that has already cost time: a runner of yours
-    // that has been idle on a setting past its grace (task 1004539). The verdict
-    // and the fix are the server's (runner-health.js); this only draws them.
-    for (const r of myRunners) {
-      const h = r.health || {};
-      if (h.state !== 'idle_config') continue;
-      out.push(`<strong>Your runner${h.host ? ` on ${escapeHtml(h.host)}` : ''} is idle</strong> because ${escapeHtml(h.why || 'of a setting')}. ${escapeHtml(h.remedy || '')}`);
-    }
     if (project.enabled !== true) {
-      out.push(`The project's runner switch is off right now${project.paused_reason ? `: ${escapeHtml(project.paused_reason)}` : ''}. Your choices are kept and apply when it is back on.`);
+      out.push(`The project's runner switch is off right now${project.paused_reason ? `: ${escapeHtml(project.paused_reason)}` : ''}. Your devices and choices are kept and apply when it is back on.`);
     }
     if (scope.owner_paused) {
       out.push(`The owner paused your runner${scope.owner_paused_reason ? `: ${escapeHtml(scope.owner_paused_reason)}` : ''}. Only the owner can resume it.`);
@@ -70,31 +101,204 @@
   }
   const goalLabel = (id) => goalNames.get(Number(id)) || `Goal ${id}`;
 
-  // The caller's own runners, with the server's health verdict attached. Best-
-  // effort like the names: a failed read just means no runner warning is drawn.
-  let myRunners = [];
-  async function loadMyRunners() {
+  // ── your devices ──────────────────────────────────────────────────────────
+
+  function deviceCardHtml(runner, nowMs) {
+    const host = String(runner.host || '');
+    const h = runner.health || {};
+    const b = RB.buttonState({ runner, fence: view.fence, nowMs });
+    const pressing = view.busyHost === host;
+    // The accent door when a press starts it; the quiet button otherwise.
+    const look = b.act === 'run' ? 'btn rb-button' : `settings-btn rb-button${b.busy || !b.act ? ' rb-button--busy' : ''}`;
+    const face = [
+      b.status ? `<span class="rb-button__status">${escapeHtml(b.status)}</span>` : '',
+      b.countdown ? `<span class="rb-button__count">${escapeHtml(b.countdown)}</span>` : '',
+      b.label ? `<span class="rb-button__act">${escapeHtml(b.label)}</span>` : '',
+    ].join('');
+    return `
+      <li class="rb-card" data-host="${escapeHtml(host)}">
+        <div class="rb-card__head">
+          <span class="rb-dot rb-dot--${escapeHtml(b.tone)}" aria-hidden="true"></span>
+          <strong class="rb-card__name">${escapeHtml(h.host || host)}</strong>
+          ${h.account ? `<span class="rb-card__meta">Claude: ${escapeHtml(h.account)}</span>` : ''}
+          <button type="button" class="settings-btn settings-btn--quiet rb-card__remove" data-focus="remove:${escapeHtml(host)}" data-remove="${escapeHtml(host)}">Remove</button>
+        </div>
+        <button type="button" class="${look}" data-focus="press:${escapeHtml(host)}"
+          ${b.act ? `data-press="${escapeHtml(b.act)}"` : ''} data-host="${escapeHtml(host)}"${!b.act || pressing ? ' disabled' : ''}>${face}</button>
+        <p class="rb-card__sub">${escapeHtml(b.sub)}</p>
+        ${b.stayOn ? '<p class="rb-card__note">Keep this device on and plugged in while it runs. If it sleeps, the runner pauses and picks up when it wakes.</p>' : ''}
+        ${b.alt ? `<button type="button" class="settings-btn settings-btn--quiet" data-focus="alt:${escapeHtml(host)}" data-press="${escapeHtml(b.alt.act)}" data-host="${escapeHtml(host)}">${escapeHtml(b.alt.label)}</button>` : ''}
+      </li>`;
+  }
+
+  function renderDevices() {
+    const el = $('#ab-devices');
+    if (!el) return;
+    const active = document.activeElement;
+    const focusKey = active && typeof el.contains === 'function' && el.contains(active) && typeof active.getAttribute === 'function'
+      ? active.getAttribute('data-focus') : null;
+    const now = Date.now();
+    el.innerHTML = `
+      <h3 class="rb-h">Your devices</h3>
+      ${view.runners.length
+        ? `<ul class="rb-cards">${view.runners.map((r) => deviceCardHtml(r, now)).join('')}</ul>`
+        : emptyStateHtml('No device is connected yet. Add this one, or any Windows PC or Mac you can leave on.')}`;
+    // A redraw replaces the buttons, so put the keyboard back where it was.
+    if (focusKey) {
+      const again = [...el.querySelectorAll('[data-focus]')].find((n) => n.getAttribute('data-focus') === focusKey);
+      if (again && !again.disabled) again.focus();
+    }
+  }
+
+  async function press(host, act) {
+    const run = act === 'run';
+    view.busyHost = host;
+    renderDevices();
     try {
-      const res = await api.request('GET', `${API}/autonomy/runners`);
-      if (res.ok && res.data && Array.isArray(res.data.runners)) myRunners = res.data.runners;
-    } catch (_) { /* the picker works without it */ }
+      const res = await api.request('POST', `${API}/autonomy/runners/${encodeURIComponent(host)}/run`, { body: { run } });
+      if (res.status === 401) { toAuth(); return; }
+      if (!res.ok) throw new Error(errorText(res, `Could not ${run ? 'start' : 'stop'} it on that device. Try again.`));
+      // Draw the press at once from the server's own answer, then read the rest.
+      const mine = view.runners.find((r) => r.host === host);
+      if (mine) { mine.run_requested = res.data.run_requested; mine.run_changed_at = res.data.run_changed_at; }
+      toast(run ? 'Starting it on that device.' : 'Stopping it on that device.');
+    } catch (err) {
+      console.error('[settings] runner press failed', err);
+      toast(err.message || `Could not ${run ? 'start' : 'stop'} it on that device. Try again.`);
+    } finally {
+      view.busyHost = null;
+      renderDevices();
+      refresh();
+    }
   }
 
-  function render(fence) {
-    const body = $('#autobongos-body');
-    if (!body) return;
-    const scope = fence.scope || {};
-    if (scope.may_run !== true) {
-      body.innerHTML = emptyStateHtml('Your rank cannot run an Autobongos runner on this project. Ask the owner if you need one.');
-      return;
+  async function removeDevice(host, trigger) {
+    const runner = view.runners.find((r) => r.host === host);
+    if (!runner) return;
+    const own = !!runner.session_id;
+    const ok = await window.OTBDialog.confirm({
+      title: `Remove ${host}?`,
+      body: own
+        ? 'Its runner is signed out at once and stops working for you. Anything it was building is handed back. To use this device again, add it again.'
+        : 'This device runs on your own command-line sign-in, not a login of its own, so removing it here only clears its card. If its runner is still running it will come back; stop it on the device.',
+      confirmLabel: 'Remove',
+      danger: true,
+      trigger,
+    });
+    if (!ok) return;
+    try {
+      if (own) {
+        // The login first: a card that is gone while its login still works would
+        // be a runner nobody can see.
+        const rev = await api.request('POST', `${API}/me/sessions/revoke`, { body: { session_id: runner.session_id } });
+        if (rev.status === 401) { toAuth(); return; }
+        if (!rev.ok) throw new Error(errorText(rev, 'Could not sign that device out. Try again.'));
+      }
+      const del = await api.request('DELETE', `${API}/autonomy/runners/${encodeURIComponent(host)}`);
+      if (!del.ok && del.status !== 404) throw new Error(errorText(del, 'Could not remove that device. Try again.'));
+      toast(`${host} removed.`);
+    } catch (err) {
+      console.error('[settings] remove device failed', err);
+      toast(err.message || 'Could not remove that device. Try again.');
+    }
+    refresh();
+  }
+
+  // ── add a device ──────────────────────────────────────────────────────────
+
+  function addPanelHtml() {
+    const a = view.add;
+    if (!a) return '<button type="button" class="settings-btn" id="ab-add-open">Add a device</button>';
+    if (a.error) {
+      return `<p class="prow__hint">${escapeHtml(a.error)}</p>
+        <button type="button" class="settings-btn" id="ab-add-open">Try again</button>`;
+    }
+    const cmd = a.commands[a.platform];
+    const where = a.platform === 'mac' ? 'Terminal' : 'PowerShell (not as administrator)';
+    return `
+      <div class="rb-add">
+        <div class="rb-add__tabs" role="group" aria-label="Which kind of device">
+          <button type="button" class="settings-btn${a.platform === 'windows' ? '' : ' settings-btn--quiet'}" data-platform="windows" aria-pressed="${a.platform === 'windows'}">Windows</button>
+          <button type="button" class="settings-btn${a.platform === 'mac' ? '' : ' settings-btn--quiet'}" data-platform="mac" aria-pressed="${a.platform === 'mac'}">Mac</button>
+        </div>
+        <ol class="rb-add__steps">
+          <li>On the device, open ${escapeHtml(where)}.</li>
+          <li>Paste this line and press Enter.</li>
+          <li>Sign in to Claude and to GitHub if it asks. Nothing else needs you.</li>
+        </ol>
+        <div class="quote">
+          <p class="quote__eyebrow">setup command</p>
+          <pre class="quote__pre" id="ab-add-cmd">${escapeHtml(cmd)}</pre>
+          <div class="quote__foot">
+            <button type="button" class="settings-btn settings-btn--quiet" id="ab-add-copy">Copy</button>
+            <span class="settings-card__hint">The code in it works once, for 15 minutes.</span>
+          </div>
+        </div>
+        <p class="rb-add__wait" role="status">Waiting for the device to check in. Its card appears above by itself.</p>
+        <button type="button" class="settings-btn settings-btn--quiet" id="ab-add-close">Done</button>
+      </div>`;
+  }
+
+  function renderAdd() {
+    const el = $('#ab-add');
+    if (!el) return;
+    el.innerHTML = addPanelHtml();
+  }
+
+  // The project's repository address, from the same public read the Primer uses.
+  async function repoUrl() {
+    try {
+      const res = await api.request('GET', `${API}/public/repo-info`);
+      const base = res.ok && res.data && typeof res.data.blob_base === 'string' ? res.data.blob_base : '';
+      const cut = base.indexOf('/blob/');
+      return cut > 0 ? base.slice(0, cut) : null;
+    } catch (_) { return null; }
+  }
+
+  async function openAdd() {
+    view.add = null;
+    try {
+      const [issued, repo] = await Promise.all([
+        api.request('POST', `${API}/auth/runner-code/issue`, { body: {} }),
+        repoUrl(),
+      ]);
+      if (issued.status === 401) { toAuth(); return; }
+      if (!issued.ok) throw new Error(errorText(issued, 'Could not make a setup code. Try again.'));
+      const commands = RB.setupCommands({
+        apiBase: issued.data.api_base || window.location.origin,
+        code: issued.data.code,
+        repoUrl: repo,
+      });
+      if (!commands) throw new Error('This project has no repository address set, so the setup command cannot be built. Tell the project owner.');
+      view.add = {
+        commands,
+        platform: RB.guessPlatform(window.navigator.userAgent),
+        // The devices as last read (the timer keeps that fresh). A device that is
+        // not in this set when it next appears is the one just added.
+        known: new Set(view.runners.map((r) => r.host)),
+      };
+    } catch (err) {
+      console.error('[settings] add device failed', err);
+      view.add = { error: err.message || 'Could not start adding a device. Try again.' };
     }
+    renderAdd();
+    schedule();
+  }
+
+  // ── what it works on ──────────────────────────────────────────────────────
+
+  function renderGoals(fence) {
+    const el = $('#ab-goals');
+    if (!el) return;
+    const scope = fence.scope || {};
     const goals = (fence.project && Array.isArray(fence.project.goals)) ? fence.project.goals : [];
     if (!goals.length) {
-      body.innerHTML = noticesHtml(fence) + emptyStateHtml('The project has not allowed any goals for runners yet, so there is nothing to choose from.');
+      el.innerHTML = `<h3 class="rb-h">What it works on</h3>${emptyStateHtml('The project has not allowed any goals for runners yet, so there is nothing to choose from.')}`;
       return;
     }
     const picked = new Set((scope.goals || []).map(Number));
-    body.innerHTML = `${noticesHtml(fence)}
+    el.innerHTML = `
+      <h3 class="rb-h">What it works on</h3>
       <form id="autobongos-form">
         <div class="prows">
           ${goals.map((g) => {
@@ -113,18 +317,6 @@
           <span class="settings-card__hint">${picked.size ? `Your runner works ${picked.size} goal${picked.size === 1 ? '' : 's'}.` : 'Your runner takes no work until you choose at least one goal.'}</span>
         </div>
       </form>`;
-    $('#autobongos-form').addEventListener('submit', (e) => {
-      e.preventDefault();
-      const ids = [...e.target.querySelectorAll('input[name="autobongos-goal"]:checked')].map((i) => Number(i.value));
-      save(ids);
-    });
-  }
-
-  async function load() {
-    const res = await api.request('GET', `${API}/autonomy/fence`);
-    if (res.status === 401) { toAuth(); return null; }
-    if (!res.ok) throw new Error(`fence GET → ${res.status}`);
-    return res.data;
   }
 
   async function save(goalIds) {
@@ -135,15 +327,12 @@
     try {
       const res = await api.request('PUT', `${API}/autonomy/me/goals`, { body: { goal_ids: goalIds } });
       if (res.status === 401) { toAuth(); return; }
-      if (!res.ok) {
-        const env = res.data && res.data.error;
-        throw new Error((env && env.message) || `could not save (${res.status})`);
-      }
+      if (!res.ok) throw new Error(errorText(res, 'Could not save your runner’s goals. Try again.'));
       const msg = goalIds.length ? `Saved — your runner works ${goalIds.length} goal${goalIds.length === 1 ? '' : 's'}.` : 'Saved — your runner takes no work.';
       if (status) status.textContent = msg;
       toast(msg);
-      const fence = await load();
-      if (fence) render(fence);
+      const fence = await loadFence();
+      if (fence) { view.fence = fence; renderGoals(fence); renderNotices(); renderDevices(); }
     } catch (err) {
       console.error('[settings] save autobongos goals failed', err);
       if (status) status.textContent = `Could not save: ${err.message}`;
@@ -152,20 +341,117 @@
     }
   }
 
+  // ── reads, and the timer ──────────────────────────────────────────────────
+
+  async function loadFence() {
+    const res = await api.request('GET', `${API}/autonomy/fence`);
+    if (res.status === 401) { toAuth(); return null; }
+    if (!res.ok) throw new Error(`fence GET → ${res.status}`);
+    return res.data;
+  }
+
+  // The caller's own devices, with the server's health verdict attached. Null
+  // when the read failed: the last answer stays on screen rather than every card
+  // vanishing over one bad request.
+  async function loadRunners() {
+    try {
+      const res = await api.request('GET', `${API}/autonomy/runners`);
+      if (res.ok && res.data && Array.isArray(res.data.runners)) return res.data.runners;
+    } catch (_) { /* keep the last answer */ }
+    return null;
+  }
+
+  function renderNotices() {
+    const el = $('#ab-notices');
+    if (el && view.fence) el.innerHTML = noticesHtml(view.fence);
+  }
+
+  async function refresh() {
+    const [runners, fence] = await Promise.all([loadRunners(), loadFence().catch(() => null)]);
+    if (runners) view.runners = runners;
+    if (fence) view.fence = fence;
+    // A device that was not there when the command was copied has checked in.
+    if (view.add && view.add.known && view.runners.some((r) => !view.add.known.has(r.host))) {
+      view.add = null;
+      renderAdd();
+      toast('Device connected. Press Run on its card.');
+    }
+    renderNotices();
+    renderDevices();
+    schedule();
+  }
+
+  function wantsFastPoll() {
+    if (view.add && view.add.commands) return true;
+    const now = Date.now();
+    return view.runners.some((r) => RB.buttonState({ runner: r, fence: view.fence, nowMs: now }).busy);
+  }
+
+  function schedule() {
+    if (view.timer) window.clearTimeout(view.timer);
+    if (document.hidden) return;   // a hidden tab reads nothing; it catches up when shown
+    view.timer = window.setTimeout(refresh, wantsFastPoll() ? POLL_FAST_MS : POLL_SLOW_MS);
+  }
+
+  function wire(body) {
+    // One listener for the whole panel: the devices redraw on a timer, and a
+    // listener per button would be re-attached every few seconds.
+    body.addEventListener('click', (e) => {
+      const t = e.target.closest('button');
+      if (!t || t.disabled || !body.contains(t)) return;
+      if (t.dataset.press) { press(t.dataset.host, t.dataset.press); return; }
+      if (t.dataset.remove) { removeDevice(t.dataset.remove, t); return; }
+      if (t.id === 'ab-add-open') { openAdd(); return; }
+      if (t.id === 'ab-add-close') { view.add = null; renderAdd(); schedule(); return; }
+      if (t.dataset.platform && view.add && view.add.commands) { view.add.platform = t.dataset.platform; renderAdd(); return; }
+      if (t.id === 'ab-add-copy' && view.add && view.add.commands) {
+        const text = view.add.commands[view.add.platform];
+        window.navigator.clipboard.writeText(text).then(
+          () => toast('Setup command copied.'),
+          // The same words the CLI token panel on this page uses for the same thing.
+          () => toast('Could not copy automatically — select and copy manually.'),
+        );
+      }
+    });
+    body.addEventListener('submit', (e) => {
+      const form = e.target;
+      if (!form || form.id !== 'autobongos-form') return;
+      e.preventDefault();
+      save([...form.querySelectorAll('input[name="autobongos-goal"]:checked')].map((i) => Number(i.value)));
+    });
+    document.addEventListener('visibilitychange', () => { if (!document.hidden) refresh(); });
+  }
+
   async function setup() {
     const section = $('#autobongos-scroll');
     if (!section) return;
+    const body = $('#autobongos-body');
     try {
-      const [fence] = await Promise.all([load(), loadGoalNames(), loadMyRunners()]);
+      const [fence, , runners] = await Promise.all([loadFence(), loadGoalNames(), loadRunners()]);
       if (!fence) return;
-      render(fence);
+      view.fence = fence;
+      view.runners = runners || [];
+      const scope = fence.scope || {};
+      if (scope.may_run !== true) {
+        // No devices, no Add a device, no picks: one line, in the devices slot.
+        $('#ab-devices').innerHTML = emptyStateHtml('Your rank cannot run an Autobongos runner on this project. Ask the owner if you need one.');
+        section.hidden = false;
+        return;
+      }
+      wire(body);
+      renderNotices();
+      renderDevices();
+      renderAdd();
+      renderGoals(fence);
       section.hidden = false;
+      schedule();
     } catch (err) {
       // Its own try/catch, like every other panel: a failing read shows this
       // panel's own error rather than taking the settings page down with it.
       console.error('[settings] failed to load autobongos scope', err);
       section.hidden = false;
-      $('#autobongos-body').innerHTML =
+      const slot = $('#ab-devices') || body;
+      slot.innerHTML =
         '<p class="voices-empty">Your runner settings could not be loaded. Reload the page to try again.</p>';
     }
   }

package/modules/hall-ui/public/settings.html

@@ -18,6 +18,8 @@
        has — the rail layout, the group head, the token ladder, the voices grid. -->
   <link rel="stylesheet" href="/builders/panel.css">
   <link rel="stylesheet" href="/builders/settings.css">
+  <!-- task 1005094: the device cards and their Run button in Your Autobongos runner. -->
+  <link rel="stylesheet" href="/builders/runner-button.css">
 </head>
 <body data-page="settings" data-page-title="Settings">
 
@@ -217,20 +219,29 @@
               <p class="section-note">Hold the card to your reader or touch it when your browser asks. Keep more than one registered in case one is lost.</p>
             </section>
 
-            <!-- YOUR AUTOBONGOS RUNNER — which goals your own unattended runner
+            <!-- YOUR AUTOBONGOS RUNNER — your devices, each with ONE Run button
+                 (task 1005094), a way to add one, and which goals your runner
                  works (task 1004501). Rendered by settings-autobongos.js against
-                 GET /autonomy/fence (your effective fence) and PUT
-                 /autonomy/me/goals. Picking nothing means your runner takes no
-                 work. The project allowlist and the master switch stay the
-                 owner's, on the Gate page. -->
+                 GET /autonomy/runners + GET /autonomy/fence; what each button
+                 says is decided by runner-button.js. Picking no goals means your
+                 runner takes no work. The project allowlist and the master
+                 switch stay the owner's, on Watch > Autobongos. -->
             <section class="scroll" id="autobongos-scroll" aria-labelledby="autobongos-h" data-group="access" hidden>
               <h2 id="autobongos-h" class="scroll__h">Your Autobongos runner</h2>
               <p class="scroll__lede">
-                Choose which goals your own runner works while you are away. You can
-                only choose from the goals the project allows. If you choose none, your
-                runner takes no work.
+                Add a device, press Run on its card, and it builds the goals you
+                choose below while you are away. Any Windows PC or Mac works, as
+                long as it is on and you are signed in to it.
               </p>
-              <div id="autobongos-body" aria-live="polite"></div>
+              <!-- Four slots, each filled on its own (settings-autobongos.js). Not a
+                   live region: the devices redraw on a timer, and a region that
+                   re-announced every redraw would talk over the reader. -->
+              <div id="autobongos-body">
+                <div id="ab-notices"></div>
+                <div id="ab-devices"></div>
+                <div id="ab-add" class="rb-addwrap"></div>
+                <div id="ab-goals"></div>
+              </div>
               <p class="settings-status" id="autobongos-status" role="status" aria-live="polite"></p>
             </section>
 
@@ -418,7 +429,9 @@
 <script src="/builders/update-pill.js?v=2026-11-03-pill"></script>
 <script src="/builders/settings-software-update.js?v=2026-11-03-pill"></script>
 <!-- task 1004501: Settings → Your Autobongos runner. Own file on the same precedent. -->
-<script src="/builders/settings-autobongos.js?v=2026-10-01-autobongos"></script>
+<!-- task 1005094: what a device's Run button says (pure; loaded before the panel). -->
+<script src="/builders/runner-button.js"></script>
+<script src="/builders/settings-autobongos.js?v=2026-11-09-run-button"></script>
 <!-- task 1003793: Settings → Module install reports. Own file on the same precedent. -->
 <script src="/builders/settings-usage-reports.js?v=2026-10-08-usage-reports"></script>
 </body>

package/modules/hall-ui/records/runner-button.md

@@ -0,0 +1,16 @@
+# The runner panel — Settings > Your Autobongos runner: a card per device, one Run button each (task 1005094)
+
+**Goal 1000139, [ADR 0307](../../../docs/adr/0307-autobongos-a-deterministic-supervisor-and-agentic-workers.md) §6.** Owner direction, 2026-11-09: running Autobongos on a device is ONE button, on whatever goals it is configured for, and any cooldown is built into the button itself. The panel on `/settings#autobongos` is three things, top to bottom: your devices, Add a device, and what the runner works on (the goal picks of task 1004501, unchanged). Six things it settled:
+
+- **The button's face IS the device's state.** Run · Starting… · Running · Resting until a time (with a countdown) · Stopping… · Updating… · Device is off or asleep · Ready (on, but held, with the reason on the line below). There is no second status line to hunt for. What the face says is decided by `public/runner-button.js` `buttonState`, which is **pure** (the `roadmap-timeline.js` precedent: no document, no fetch, `nowMs` is an argument), so `tests/hall_runner_button.mjs` asks it one face at a time. `settings-autobongos.js` draws what it returns and nothing else.
+- **It is one of the hall's shared buttons, made larger.** `.btn` (the accent door) when a press starts the runner, `.settings-btn` when the device is on and a press would stop it; `runner-button.css` adds only size and the three spans inside the face. No colour of its own; type and corners are scale tokens.
+- **A press is drawn from the server's own answer, then the devices are read again.** The page never decides a press took. "Starting" is `run_changed_at` being newer than the device's last check-in, capped at two minutes, so a device that never picks the press up goes on to read as off instead of starting forever.
+- **The devices redraw on a timer; the goal form does not.** Four fixed slots in `settings.html` (`#ab-notices`, `#ab-devices`, `#ab-add`, `#ab-goals`), each filled on its own: 3 seconds while a card is busy or a device is being added, 15 otherwise, nothing while the tab is hidden. A form redrawn under someone ticking boxes would untick them. The panel is **not** a live region for the same reason: it would re-announce every redraw.
+- **The stay-on note is on the card of a device that is switched on** ("Keep this device on and plugged in while it runs…"), and not on one its builder stopped: a stopped device has nothing to stay awake for. `buttonState` says which (`stayOn`).
+- **Remove signs the device's own login out FIRST, then clears its card** (`POST /me/sessions/revoke`, then `DELETE /autonomy/runners/:host`). A card gone while its login still works would be a runner nobody can see. A device with no login of its own (a runner still on its builder's command-line sign-in) says so in the dialog and revokes nothing.
+
+Add a device shows ONE command per platform (`setupCommands`), built from the one-time code, the project's own address and its repository (`GET /public/repo-info`); it refuses to build a command from any part that is not the exact shape it expects, because the line ends up in a shell, and from any project address that is not https (a project on this very machine excepted), because the line downloads a script and runs it. The card appears by itself when the device first checks in, and starts **stopped**, so the first press of Run is the person's.
+
+The owner's own panel (Watch > Autobongos, `gate.js`) learned the `stopped` state and nothing else.
+
+**Verifying it:** `node scripts/hall-preview/server.js --fixture-me`, then `/settings#autobongos`. The fixture carries four devices, one per face that needs no wall-clock time (running, stopped, held, off); a resting device is covered by the tests, not the fixture, because a clock time in the page's visible text would change the page reading on every read.

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.24.77",
+  "version": "1.24.79",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.24.77",
+      "version": "1.24.79",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.24.77",
+  "version": "1.24.79",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/release-notes.json

@@ -11493,5 +11493,25 @@
       "id": "1005095",
       "text": "The Autobongos runner can now be set up on any Windows PC or Mac, including a laptop, with no administrator step. One program installs it, starts it whenever you sign in to the device, keeps it running, updates it by itself, a"
     }
+  ],
+  "1.24.78": [
+    {
+      "id": "1005097",
+      "text": "There is now a plain guide for putting Autobongos on your own Windows PC or Mac, and a /autobongos-setup command in Claude Code that walks you through it: paste one line from Settings, press Run, and read the button to see wha"
+    },
+    {
+      "id": "1005187",
+      "text": "Fixed the automatic check that had turned red for everyone and was blocking all new work from landing. A safety tool that spots finished work still listed as to-do only understood an older way of labelling changes; most change"
+    },
+    {
+      "id": "1005094",
+      "text": "Running Autobongos on a device is now one button. In Settings, Add a device gives you one line to paste on any Windows PC or Mac; its card then appears by itself with a Run button. The button's face tells you what the device i"
+    }
+  ],
+  "1.24.79": [
+    {
+      "id": "1005186",
+      "text": "Closed a gap opened by letting Autobongos run on any device. The runner now keeps its own sign-in in its own folder, and the rule that stops an AI session from opening sign-in files did not yet cover that folder. It does now,"
+    }
   ]
 }