@bongos/core 1.19.876 → 1.19.878

package/modules/hall-ui/public/gate.js

@@ -254,7 +254,7 @@
     const el = document.getElementById('fence-state');
     el.innerHTML = `
       <div class="ov-foot" style="display:flex;align-items:center;gap:12px;flex-wrap:wrap;">
-        <strong>${on ? 'Running' : 'Stopped'}</strong>
+        <span class="fact-pill ${on ? 'fact-pill--ok' : 'fact-pill--warn'}">${on ? 'Allowed to work' : 'Stopped'}</span>
         <span>${on ? 'The runner may claim and work allowlisted goals.' : escapeHtml(fence.paused_reason || 'The runner is doing nothing.')}</span>
         <button type="button" id="fence-toggle" class="btn">${on ? 'Stop the runner' : 'Start the runner'}</button>
       </div>`;
@@ -317,6 +317,54 @@
     }
   }
 
+  // The runner's liveness (task 1003905). Rendered ABOVE the switch on purpose:
+  // "is it running at all" is the first question, and an owner who has just
+  // flipped the switch on wants to see the machine notice.
+  //
+  // The verdict is the SERVER's — modules/autonomy/runner-health.js decides what
+  // dead means and the route attaches it — so this page and any future alert
+  // cannot drift into two definitions of the same word.
+  // This page's OWN class vocabulary (style.css `.fact-pill--{ok,warn,danger}`),
+  // the same one renderRow spends for a PR's verdict. The first cut reached for
+  // inline `--color-text-*` tokens from a different design system: they do not
+  // exist here, resolved to inherited grey, and drew a dead runner in exactly the
+  // same colour as a healthy one. Named classes cannot fail that way silently —
+  // a missing class is visible in the stylesheet, a missing var is not.
+  const HEALTH_CLASS = { alive: 'fact-pill--ok', late: 'fact-pill--warn', dead: 'fact-pill--danger', never_seen: 'fact-pill--info' };
+
+  async function loadRunners() {
+    const el = document.getElementById('fence-runner');
+    if (!el) return;
+    let resp;
+    try {
+      resp = await fetchJson('/autonomy/runners');
+    } catch (err) {
+      if (err && err.kind === '401') return;
+      el.innerHTML = emptyStateHtml('Could not read the runner\u2019s check-ins just now.');
+      return;
+    }
+    const runners = resp.runners || [];
+    if (!runners.length) {
+      // never_seen, and the server said so rather than this page guessing. Not an
+      // alarm: nobody has set the host up yet.
+      el.innerHTML = `<p class="ov-foot">${escapeHtml(resp.none ? resp.none.detail : 'No runner has ever checked in.')}</p>`;
+      return;
+    }
+    el.innerHTML = runners.map((r) => {
+      const h = r.health || {};
+      const cls = HEALTH_CLASS[h.state] || 'fact-pill--info';
+      // NOT the word "running": the switch below already uses it for a different
+      // thing (allowed to work), and the two lines sit one above the other. A
+      // reader should never have to work out which sense is meant.
+      const label = { dead: 'Not checking in', late: 'Quiet', alive: 'Checking in' }[h.state] || 'Unknown';
+      return `<p class="ov-foot" style="display:flex;align-items:baseline;gap:10px;flex-wrap:wrap;">
+        <span class="fact-pill ${cls}">${escapeHtml(label)}</span>
+        <span>${escapeHtml(h.detail || '')}</span>
+        <span class="ov-fact">last check-in ${escapeHtml(h.age || 'unknown')} ago</span>
+      </p>`;
+    }).join('');
+  }
+
   async function loadFence() {
     let fence;
     try {
@@ -356,7 +404,8 @@
     document.getElementById('gate-body').hidden = false;
     if (rank === 'archon') {
       document.getElementById('fence-panel').hidden = false;
-      await loadFence();
+      // Independent reads, so one round trip rather than two.
+      await Promise.all([loadRunners(), loadFence()]);
     }
     await load();
   }

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.876",
+  "version": "1.19.878",
   "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/scripts/gds/autobongos-digest.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+'use strict';
+
+// scripts/gds/autobongos-digest.js — read the night without opening a log
+// (task 1003906, ADR 0307).
+//
+//   node scripts/gds/autobongos-digest.js              # since midnight, local
+//   node scripts/gds/autobongos-digest.js --since 24h  # a rolling window
+//   node scripts/gds/autobongos-digest.js --json       # the structured shape
+//   node scripts/gds/autobongos-digest.js --all        # the whole log
+//
+// The decision logic is modules/autonomy/digest.js and has no I/O; this half
+// finds the two files it reads and prints the result. Exit 0 always, including on
+// an empty night: a digest is a report, and a non-zero exit would make a cron
+// wrapper treat "nothing happened" as a failure.
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const digest = require('../../modules/autonomy/digest.js');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+
+function arg(flag, argv) {
+  const i = argv.indexOf(flag);
+  return i >= 0 ? argv[i + 1] : null;
+}
+
+function logPath() {
+  if (process.env.AUTOBONGOS_LOG_FILE) return process.env.AUTOBONGOS_LOG_FILE;
+  try { return require('../../src/instance-config.js').configPath('autobongos-runs.jsonl'); }
+  catch (_) { return path.join(REPO_ROOT, 'autobongos-runs.jsonl'); }
+}
+
+function gaugePath() {
+  if (process.env.AUTOBONGOS_GAUGE_FILE) return process.env.AUTOBONGOS_GAUGE_FILE;
+  try { return require('../../src/instance-config.js').configPath('autobongos-gauge.json'); }
+  catch (_) { return path.join(REPO_ROOT, 'autobongos-gauge.json'); }
+}
+
+// readRows — an append-only JSONL, and a single unparseable line must not cost
+// the whole night. A JSONL written by a process that can be killed mid-write has
+// a torn last line more often than never.
+function readRows(file) {
+  let text;
+  try { text = fs.readFileSync(file, 'utf8'); }
+  catch (_) { return { rows: [], missing: true, skipped: 0 }; }
+  const rows = [];
+  let skipped = 0;
+  for (const line of text.split('\n')) {
+    const t = line.trim();
+    if (!t) continue;
+    try { rows.push(JSON.parse(t)); } catch (_) { skipped += 1; }
+  }
+  return { rows, missing: false, skipped };
+}
+
+function readGaugeFile(file) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); }
+  catch (_) { return null; }
+}
+
+// sinceMs — `--since 24h|90m|3d`, or midnight LOCAL by default.
+//
+// Local rather than UTC because the question is "what happened last night" and
+// night is a local idea; a UTC midnight cut would split an owner's evening in
+// half depending on where they live.
+function sinceMs(spec, now = new Date()) {
+  if (!spec) {
+    const d = new Date(now);
+    d.setHours(0, 0, 0, 0);
+    return d.getTime();
+  }
+  const m = /^(\d+(?:\.\d+)?)\s*([hmd])$/i.exec(String(spec).trim());
+  if (!m) return null;
+  const mult = { h: 3600e3, m: 60e3, d: 86400e3 }[m[2].toLowerCase()];
+  return now.getTime() - Number(m[1]) * mult;
+}
+
+function main(argv) {
+  const all = argv.includes('--all');
+  const asJson = argv.includes('--json');
+  const now = new Date();
+  const from = all ? null : sinceMs(arg('--since', argv), now);
+  if (!all && from === null) {
+    console.error('autobongos-digest: --since wants a span like 24h, 90m or 3d.');
+    return 2;
+  }
+
+  const lf = logPath();
+  const { rows, missing, skipped } = readRows(lf);
+  const inWindow = all ? rows : rows.filter((r) => {
+    const t = Date.parse(r && r.at);
+    return Number.isFinite(t) ? t >= from : true;   // an undated row is kept, not silently dropped
+  });
+
+  const d = digest.buildDigest(inWindow, {
+    gauge: readGaugeFile(gaugePath()),
+    nowEpochS: Math.floor(now.getTime() / 1000),
+    sinceMs: all ? null : from,
+    untilMs: now.getTime(),
+  });
+
+  if (asJson) { console.log(JSON.stringify(d, null, 2)); return 0; }
+
+  console.log('');
+  console.log(digest.renderDigest(d));
+  // Both of these are about the DIGEST's own reliability, so they sit outside the
+  // five questions rather than being folded into them.
+  if (missing) {
+    console.log('');
+    console.log(`  No run log at ${lf} — the runner has not written one here yet.`);
+  }
+  if (skipped) console.log(`  (${skipped} unreadable line(s) in the log were skipped.)`);
+  console.log('');
+  return 0;
+}
+
+if (require.main === module) {
+  process.exit(main(process.argv.slice(2)));
+}
+
+module.exports = { main, sinceMs, readRows, logPath, gaugePath };