@yemi33/minions 0.1.2051 → 0.1.2052

package/dashboard/js/refresh.js

@@ -73,7 +73,7 @@ const RENDER_VERSIONS = {
   prd: 1,
   prs: 2,
   archivedPrds: 1,
-  engine: 2,
+  engine: 3,
   version: 1,
   adoThrottle: 1,
   ghThrottle: 1,
@@ -147,6 +147,47 @@ function _formatCcDrawerLabel(autoMode) {
   return runtimeLabel + (model ? ' (' + model + ')' : '') + '-powered. Full minions context. Enter to send, Shift+Enter for newline.';
 }
 
+// W-mpnc4u8c001d9d6c — #engine-quick-stats "Next tick in Xs" countdown.
+//
+// Origin is engine.lastTickAt (stamped by tickInner at the start of every
+// tick, see engine.js) plus engine.tickInterval (server-side config, surfaced
+// via _buildStatusFastState). The chip updates every 1s without re-rendering
+// the surrounding row — mirrors the _tickAgentRuntimes pattern in
+// dashboard/js/render-agents.js. The countdown clamps at 0 and shows "due"
+// when the engine is mid-tick (PR polls etc. can push tick-to-tick wall time
+// past the nominal interval). When the engine isn't running, show "—" so a
+// stale lastTickAt doesn't render a ticking countdown the engine can't honor.
+var _engineCountdown = { lastTickAt: 0, tickInterval: 0, engineState: 'stopped' };
+var _engineNextTickTimer = null;
+
+function _formatNextTickText() {
+  var state = _engineCountdown.engineState;
+  if (state !== 'running' && state !== 'stopping') return '—';
+  var last = _engineCountdown.lastTickAt;
+  var interval = _engineCountdown.tickInterval;
+  if (!last || !interval) return '—';
+  var remainingMs = last + interval - Date.now();
+  if (remainingMs <= 0) return 'due';
+  return Math.ceil(remainingMs / 1000) + 's';
+}
+
+function _updateNextTickChip() {
+  var el = document.getElementById('engine-next-tick');
+  if (!el) {
+    if (_engineNextTickTimer) { clearInterval(_engineNextTickTimer); _engineNextTickTimer = null; }
+    return;
+  }
+  var next = _formatNextTickText();
+  if (el.textContent !== next) el.textContent = next;
+}
+
+function _startNextTickTicker() {
+  // Idempotent — refresh.js re-runs every 4s and reseats the data on the
+  // shared _engineCountdown; we don't want compounding intervals.
+  if (_engineNextTickTimer) return;
+  _engineNextTickTimer = setInterval(_updateNextTickChip, 1000);
+}
+
 function _processStatusUpdate(data) {
   // Detect fresh install — clear stale browser state AND reload so module-scoped
   // JS caches (_sectionCache, _prevCounts, _managedProcessesLastItems,
@@ -246,10 +287,21 @@ function _processStatusUpdate(data) {
     var qs = document.getElementById('engine-quick-stats');
     if (qs && data.engine) {
       var wt = data.engine.worktreeCount != null ? data.engine.worktreeCount : '-';
-      var tick = data.engine.tick || '-';
       var pid = data.engine.pid || '-';
-      // eslint-disable-next-line no-unsanitized/property -- reason: composed from internal engine metrics (pid, tick, worktreeCount; no user data flows in)
-      qs.innerHTML = '<span>PID: <b>' + pid + '</b></span><span>Tick: <b>' + tick + '</b></span><span>Worktrees: <b>' + wt + '</b></span>';
+      // W-mpnc4u8c001d9d6c — replace the dead "Tick: -" chip (control.json
+      // never carried a `tick` field) with a live "Next tick in Xs" countdown
+      // driven by engine.lastTickAt (stamped at the start of every tickInner)
+      // and engine.tickInterval (config, surfaced in the status payload).
+      // _updateNextTickChip below ticks the inner span every 1s without
+      // re-rendering this whole row.
+      _engineCountdown.lastTickAt = Number(data.engine.lastTickAt) || 0;
+      _engineCountdown.tickInterval = Number(data.engine.tickInterval) || 0;
+      _engineCountdown.engineState = data.engine.state || 'stopped';
+      // eslint-disable-next-line no-unsanitized/property -- reason: composed from internal engine metrics (pid, lastTickAt/tickInterval, worktreeCount) and a literal id; no user data flows in
+      qs.innerHTML = '<span>PID: <b>' + pid + '</b></span>' +
+        '<span>Next tick in: <b id="engine-next-tick">' + _formatNextTickText() + '</b></span>' +
+        '<span>Worktrees: <b>' + wt + '</b></span>';
+      _startNextTickTicker();
     }
   }
   if (_changed('version', data.version)) renderVersionBanner(data.version);

package/dashboard.js

@@ -1730,6 +1730,11 @@ function _buildStatusFastState() {
       // possibly-cached payload (false-positive banner regression #2754).
       heartbeatAgeMs: engineState.heartbeat ? hbAge : null,
       heartbeatStale: !!(engineState.heartbeat && hbAge > ENGINE_HEARTBEAT_STALE_MS),
+      // W-mpnc4u8c001d9d6c — Surface the tick cadence so the client's
+      // #engine-quick-stats "Next tick in Xs" countdown reads the SAME value
+      // the engine actually uses (Settings parity rule). Paired with
+      // control.lastTickAt (above) stamped at the start of every tickInner.
+      tickInterval: Number(CONFIG?.engine?.tickInterval) || shared.ENGINE_DEFAULTS.tickInterval,
     },
     adoThrottle: ado.getAdoThrottleState(),
     ghThrottle: gh.getGhThrottleState(),

package/engine.js

@@ -6522,6 +6522,17 @@ async function tickInner() {
   // Per-phase guards inside the rest of tickInner are sub-task -b's scope.
   if (_isTickStale(myGeneration)) return;
 
+  // W-mpnc4u8c001d9d6c — Stamp `lastTickAt` on every tickInner entry so the
+  // dashboard's #engine-quick-stats "Next tick in Xs" countdown has a reliable
+  // anchor (control.json carries no separate tick-counter field). Synchronous
+  // mutator, no awaits inside the lock — mirrors the writer contract used by
+  // engine/cli.js#writeHeartbeatNow. Distinct from control.heartbeat: this
+  // advances once per tick cadence, not on the 15s heartbeat cadence, so the
+  // client can render an accurate "next tick" countdown without coupling to
+  // the staleness signal.
+  try { shared.mutateControl(c => { c.lastTickAt = Date.now(); return c; }); }
+  catch (e) { log('warn', `lastTickAt write: ${e.message}`); }
+
   const config = getConfig();
   tickCount++;
   const now = Date.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2051",
+  "version": "0.1.2052",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"