@yemi33/minions 0.1.2448 → 0.1.2449

package/dashboard/slim/body.html

@@ -112,6 +112,7 @@
             <div class="cockpit-detail">no open PRs</div>
           </div>
           <div class="cockpit-tile" data-tile="automation">
+            <button id="slim-tile-automation-add" class="linkpr-chip on-tile" type="button" title="Add automation" aria-label="Add automation" aria-haspopup="menu" aria-expanded="false">+</button>
             <div class="cockpit-label"><span class="cockpit-dot"></span> Automation</div>
             <div class="cockpit-value dim">0</div>
             <div class="cockpit-detail">no automation set</div>

package/dashboard/slim/js/command-send.js

@@ -30,6 +30,18 @@
   function sendMessage() {
     var text = inputEl.value.trim();
     if (!text) return;
+    // Length guard BEFORE clearing the composer / queueing (W-mscjjqdh). An
+    // oversized message fails server validation as `body.message has an invalid
+    // length`; persisting it would also poison the shared cc-tabs transcript the
+    // classic surface carries. Keep the rejected text in the box for editing.
+    var lenCheck = window.MinionsCcLimits ? window.MinionsCcLimits.checkMessage(text) : { ok: true };
+    if (!lenCheck.ok) {
+      appendSystemNotice(window.MinionsCcLimits
+        ? window.MinionsCcLimits.messageTooLongText(lenCheck.length, lenCheck.limit)
+        : 'Message is too long. Shorten it and send again — your text is still in the box.');
+      inputEl.focus();
+      return;
+    }
     inputEl.value = '';
     inputEl.style.height = 'auto';
     if (_isTabSending(tabId)) {
@@ -91,6 +103,20 @@
     var turnOutcome = 'done';
     var live = (turnTabId === tabId);
 
+    // Defensive length guard for paths that bypass sendMessage()'s composer check:
+    // queue drain (_drainQueueFor) and any programmatic/retry resend (W-mscjjqdh).
+    // Never record (recordTabMessage → shared cc-tabs) or POST an oversized
+    // message — drop it with a notice on the visible tab instead of looping.
+    var guard = window.MinionsCcLimits ? window.MinionsCcLimits.checkMessage(text) : { ok: true };
+    if (!guard.ok) {
+      if (live) {
+        appendSystemNotice(window.MinionsCcLimits
+          ? window.MinionsCcLimits.messageTooLongText(guard.length, guard.limit)
+          : 'Message is too long. Shorten it and send again — your text is still in the box.');
+      }
+      return;
+    }
+
     // The tab title is derived from the first user message; only that message
     // changes the chip, so re-render the bar once instead of on every send.
     var wasFirstUser = !_tabHasUserMessage(turnTabId);

package/dashboard/slim/js/modals-tiles.js

@@ -21,6 +21,9 @@
     if (typeof _pauseActiveEmbed === 'function') _pauseActiveEmbed();
     // The Automation composite is likewise cached + kept mounted (W-ms4r1t5q…);
     // hide it and suspend its tab iframes' pollers rather than tearing it down.
+    // NOTE: the tab buttons tracked in _automationTabBtns stay live across
+    // opens now that the composite is never torn down, so they must NOT be
+    // cleared here — _applyAutomationTabLabels keeps writing to mounted nodes.
     if (typeof _hideAutomationComposite === 'function') _hideAutomationComposite();
     var transient = document.getElementById('slim-tile-transient');
     if (transient) transient.textContent = '';
@@ -174,6 +177,44 @@
     return { host: host, transient: transient };
   }
 
+  // Ensure a lightweight loading affordance element exists inside the embed
+  // host (created once). Shown immediately when a not-yet-booted embed iframe is
+  // opened so the modal never looks frozen while the heavier /engine SPA boots;
+  // hidden the instant that iframe fires 'load'. Built with createElement (no
+  // innerHTML) to satisfy the dashboard no-unsanitized lint gate.
+  function _ensureEmbedLoadingEl() {
+    var containers = _ensureTileContainers();
+    if (!containers) return null;
+    var el = document.getElementById('slim-tile-embed-loading');
+    if (!el) {
+      el = document.createElement('div');
+      el.id = 'slim-tile-embed-loading';
+      el.className = 'slim-tile-embed-loading';
+      el.setAttribute('role', 'status');
+      el.setAttribute('aria-live', 'polite');
+      el.hidden = true;
+      var spinner = document.createElement('div');
+      spinner.className = 'slim-tile-embed-spinner';
+      el.appendChild(spinner);
+      var label = document.createElement('div');
+      label.className = 'slim-tile-embed-loading-label';
+      label.textContent = 'Loading…';
+      el.appendChild(label);
+      containers.host.appendChild(el);
+    }
+    return el;
+  }
+
+  function _showEmbedLoading() {
+    var el = _ensureEmbedLoadingEl();
+    if (el) el.hidden = false;
+  }
+
+  function _hideEmbedLoading() {
+    var el = document.getElementById('slim-tile-embed-loading');
+    if (el) el.hidden = true;
+  }
+
   // Create (once) the cached iframe for an embed tile and return it. Built with
   // createElement (no innerHTML) to satisfy the dashboard no-unsanitized lint
   // gate. Starts hidden; a load-time visibility message pauses its poll until
@@ -189,6 +230,15 @@
     frame.src = spec[0];
     frame.title = spec[1];
     frame.hidden = true;
+    frame.dataset.embedLoaded = '0';
+    frame.addEventListener('load', function() {
+      frame.dataset.embedLoaded = '1';
+      // If this frame is the one currently shown, drop the loading affordance.
+      if (_activeEmbedKey === key) _hideEmbedLoading();
+    });
+    // Visibility posting is delegated to the shared helper, which evaluates the
+    // LIVE visibility at load time (not bind time) so a frame that finished
+    // loading while hidden still gets suspended.
     _bindEmbedVisibilityOnLoad(frame, function() { return _activeEmbedKey === key; });
     containers.host.appendChild(frame);
     _embedFrames[key] = frame;
@@ -198,7 +248,7 @@
   // Show one embed tile's cached iframe and hide the rest, pausing/resuming
   // each one's embedded poll to match. Reused by every single-iframe embed tile.
   function _showReusableEmbed(key) {
-    _getOrCreateEmbedFrame(key);
+    var frame = _getOrCreateEmbedFrame(key);
     Object.keys(_embedFrames).forEach(function(k) {
       var f = _embedFrames[k];
       if (!f) return;
@@ -207,6 +257,13 @@
       _postEmbedVisibility(f, on);
     });
     _activeEmbedKey = key;
+    // Immediate loading affordance while a not-yet-booted embed finishes: the
+    // frame's 'load' handler hides it (or it's hidden now if already booted).
+    if (frame && frame.dataset && frame.dataset.embedLoaded !== '1') {
+      _showEmbedLoading();
+    } else {
+      _hideEmbedLoading();
+    }
   }
 
   // Hide + pause whichever embed iframe is currently shown (kept mounted for an
@@ -219,6 +276,7 @@
       f.hidden = true;
     });
     _activeEmbedKey = null;
+    _hideEmbedLoading();
   }
 
   // Prewarm the two hot embed tiles (Queued work + Active PRs) shortly after the
@@ -229,8 +287,35 @@
     _getOrCreateEmbedFrame('queued');
     _getOrCreateEmbedFrame('prs');
   }
+  // Engine is heavier than Work/PRs (it cold-boots the full classic SPA plus the
+  // engine log, managed-process panel, and memory/diagnostics pollers), so it is
+  // NOT folded into the 800ms hot burst — that would regress cockpit first paint.
+  // Instead warm it on an idle callback AFTER the hot tiles, so its boot overlaps
+  // idle time and its first open is a near-instant show. Predictive prewarm on
+  // tile intent (below) is the earlier, finer-grained trigger; this is the
+  // guaranteed fallback for users who click without hovering first.
+  // (W-ms4odb8h009a5d16)
+  function prewarmEngineEmbedIdle() {
+    _getOrCreateEmbedFrame('engine');
+  }
+  // Predictive prewarm: the instant a user shows intent on an embed tile
+  // (hover / focus / pointer-down), start booting its cached iframe so the
+  // heavier /engine screen overlaps intent instead of blocking the click.
+  // _getOrCreateEmbedFrame is create-once/idempotent, so repeat intents are free
+  // and the already-prewarmed queued/prs tiles are unaffected.
+  function _predictivePrewarmEmbed(key) {
+    if (!Object.prototype.hasOwnProperty.call(_EMBED_TILES, key)) return;
+    try { _getOrCreateEmbedFrame(key); } catch (e) { /* lazy-create on open instead */ }
+  }
   (function schedulePrewarm() {
     try { setTimeout(prewarmHotEmbeds, 800); } catch (e) { /* no timers — skip prewarm */ }
+    try {
+      if (typeof requestIdleCallback === 'function') {
+        requestIdleCallback(prewarmEngineEmbedIdle, { timeout: 4000 });
+      } else {
+        setTimeout(prewarmEngineEmbedIdle, 2500);
+      }
+    } catch (e) { /* no idle/timers — engine warms on first intent/open instead */ }
   })();
 
   // Per-tile body renderers for the detail modal. Each reads the latest status
@@ -312,12 +397,107 @@
     _showReusableEmbed('prs');
   }
 
-  // Persistent Automation composite (W-ms4r1t5q003h341a): the tabbed
-  // Watches·Schedules·Pipelines composite + its lazy iframes are built ONCE into
-  // #slim-tile-automation-host and shown/hidden across opens — mirroring the
-  // _embedFrames cache used by the single-iframe tiles — so reopening the
-  // Automation tile is an instant show, NOT a rebuild that cold-reloads all three
-  // classic screens into the wiped transient container. { activate, frames,
+  // ── Automation tile counts (Watches · Scheduled Tasks · Pipelines) ────
+  // The cockpit tile headline is the SUM of all three automation surfaces.
+  // Watches ride the live 5s /api/status poll (renderAutomationTile is fed the
+  // live watches count by applyStatus). Schedules + pipelines are NOT carried by
+  // the status snapshot, so they are fetched lazily off the hot poll path — once
+  // shortly after first paint and again whenever the Automation modal opens —
+  // mirroring knowledge.js#loadKnowledgeCounts / plans.js#loadPlansCounts. The
+  // same cached counts drive the "(N)" suffix on each modal tab label.
+  var _automationCounts = { watches: 0, schedules: null, pipelines: null };
+  // Live tab buttons ({ key: {el, base} }) so loadAutomationCounts can refresh
+  // their "(N)" labels. The composite is built once and kept mounted, so these
+  // stay valid across opens and are never cleared.
+  var _automationTabBtns = null;
+  // "+ Add" picker target: { tab, create } consumed by renderAutomationTileBody.
+  var _automationInitial = null;
+  // Last (count|detail|lit) signature painted onto the Automation cockpit tile,
+  // so the 5s status poll can skip a redundant updateTile when nothing changed
+  // (W-ms4r1t5q003h341a). Lives here because the painted value is the SUM, which
+  // also moves when the lazy schedule/pipeline counts land.
+  var _automationTileSig = null;
+  // Monotonic counter making each "+ Add" deep-link URL unique, so re-requesting
+  // Create on an ALREADY-MOUNTED cached tab frame is a real navigation (a bare
+  // "#create" hash change on the same URL would not reload the classic screen,
+  // and its boot hook only runs on load).
+  var _automationCreateSeq = 0;
+
+  function _automationTabCount(key) {
+    if (key === 'watches') return _automationCounts.watches;
+    if (key === 'schedule') return _automationCounts.schedules;
+    if (key === 'pipelines') return _automationCounts.pipelines;
+    return null;
+  }
+
+  function _automationTabLabel(base, count) {
+    return base + ' (' + (count == null ? '…' : count) + ')';
+  }
+
+  function _applyAutomationTabLabels() {
+    if (!_automationTabBtns) return;
+    Object.keys(_automationTabBtns).forEach(function(key) {
+      var b = _automationTabBtns[key];
+      if (b && b.el) b.el.textContent = _automationTabLabel(b.base, _automationTabCount(key));
+    });
+  }
+
+  // Repaint the cockpit tile from the cached sum. Called each 5s poll from
+  // applyStatus (with the live watches count) and after the lazy count fetch.
+  // Change-gated: the poll runs every 5s, so skip the updateTile DOM work
+  // (querySelectors + textContent + classList churn) when nothing moved.
+  function renderAutomationTile(watchesCount) {
+    if (typeof watchesCount === 'number') _automationCounts.watches = watchesCount;
+    var w = _automationCounts.watches || 0;
+    var s = _automationCounts.schedules || 0;
+    var p = _automationCounts.pipelines || 0;
+    var total = w + s + p;
+    var autoDetail = total ? 'monitoring' : 'no automation set';
+    var autoLit = total ? 'blue' : null;
+    var autoSig = total + '|' + autoDetail + '|' + (autoLit || '');
+    if (_automationTileSig !== autoSig) {
+      _automationTileSig = autoSig;
+      updateTile('automation', total, autoDetail, autoLit);
+    }
+  }
+
+  // Best-effort lazy fetch of the three automation-surface counts. Runs off the
+  // hot 5s status poll. Failures leave the cached value untouched so a transient
+  // error doesn't blank the tile / tab labels. /api/watches responds
+  // { watches: [...] } (unwrapped via the shared source); /api/schedules and
+  // /api/pipelines respond bare arrays.
+  async function loadAutomationCounts() {
+    try {
+      var wres = await fetch('/api/watches', { headers: { 'Accept': 'application/json' } });
+      if (wres.ok) {
+        var wlist = (typeof MinionsWatchesSource !== 'undefined' && MinionsWatchesSource.unwrap)
+          ? MinionsWatchesSource.unwrap(await wres.json())
+          : null;
+        if (Array.isArray(wlist)) _automationCounts.watches = wlist.length;
+      }
+    } catch (e) { /* keep last-known */ }
+    try {
+      var sres = await fetch('/api/schedules', { headers: { 'Accept': 'application/json' } });
+      if (sres.ok) { var sdata = await sres.json(); _automationCounts.schedules = Array.isArray(sdata) ? sdata.length : 0; }
+    } catch (e) { /* keep last-known */ }
+    try {
+      var pres = await fetch('/api/pipelines', { headers: { 'Accept': 'application/json' } });
+      if (pres.ok) { var pdata = await pres.json(); _automationCounts.pipelines = Array.isArray(pdata) ? pdata.length : 0; }
+    } catch (e) { /* keep last-known */ }
+    renderAutomationTile();
+    _applyAutomationTabLabels();
+  }
+
+  // Automation tile body — a tabbed composite (Watches · Scheduled Tasks ·
+  // Pipelines) that reuses the LITERAL classic dashboard screens (/watches,
+  // /schedule, /pipelines) instead of a slim-specific list, so there is one
+  // Automation UI, not two (W-mrz0x2a400030f90 / "reuse, don't fork").
+  //
+  // Persistent Automation composite (W-ms4r1t5q003h341a): the composite + its
+  // lazy iframes are built ONCE into #slim-tile-automation-host and shown/hidden
+  // across opens — mirroring the _embedFrames cache used by the single-iframe
+  // tiles — so reopening the Automation tile is an instant show, NOT a rebuild
+  // that cold-reloads all three classic screens. { activate, openCreate, frames,
   // activeKey } or null until first open.
   var _automationComposite = null;
 
@@ -354,21 +534,23 @@
     }
   }
 
-  // Build the tabbed Watches·Schedules·Pipelines composite ONCE into the
-  // persistent host. Returns { activate, frames, activeKey }. Each tab's iframe
-  // is LAZY (mounted only on first activation) and CACHED (kept mounted so
-  // reopening never rebuilds/reloads it). Hidden tabs' pollers are suspended via
-  // the same visibility message the single-iframe embeds use, so a cached-but-
-  // inactive tab isn't polling in the background. Built with createElement (no
+  // Build the tabbed Watches·Scheduled Tasks·Pipelines composite ONCE into the
+  // persistent host. Returns { activate, openCreate, frames, activeKey }. Each
+  // tab's iframe is LAZY (mounted only on first activation) and CACHED (kept
+  // mounted so reopening never rebuilds/reloads it). Hidden tabs' pollers are
+  // suspended via the same visibility message the single-iframe embeds use, so a
+  // cached-but-inactive tab isn't polling in the background. Built with
+  // createElement (no
   // innerHTML) to satisfy the dashboard no-unsanitized lint gate; tab buttons
   // reuse the shared .kn-tab pill primitive and carry role="tab"/aria-selected
   // for keyboard/AT parity with the Knowledge modal tabs.
   function _buildAutomationComposite(host) {
     var TABS = [
-      { key: 'watches',   label: 'Watches',   src: '/watches?embed=1' },
-      { key: 'schedule',  label: 'Schedules', src: '/schedule?embed=1' },
-      { key: 'pipelines', label: 'Pipelines', src: '/pipelines?embed=1' },
+      { key: 'watches',   base: 'Watches',         src: '/watches?embed=1' },
+      { key: 'schedule',  base: 'Scheduled Tasks', src: '/schedule?embed=1' },
+      { key: 'pipelines', base: 'Pipelines',       src: '/pipelines?embed=1' },
     ];
+
     var tablist = document.createElement('div');
     tablist.className = 'kn-tabs slim-automation-tabs';
     tablist.setAttribute('role', 'tablist');
@@ -380,9 +562,15 @@
     var btns = {};
     var panels = {};
     var frames = {};
-    var composite = { activate: null, frames: frames, activeKey: null };
+    var composite = { activate: null, openCreate: null, frames: frames, activeKey: null };
+    // Track the live tab buttons so loadAutomationCounts can refresh the "(N)"
+    // labels once the list endpoints resolve. The composite is built once and
+    // kept mounted, so these stay valid for the life of the page.
+    _automationTabBtns = {};
 
-    function activate(key) {
+    // `createSrc`, when given, is the deep-link URL the ACTIVE tab's iframe must
+    // load instead of its plain src (see openCreate).
+    function activate(key, createSrc) {
       TABS.forEach(function(t) {
         var isActive = t.key === key;
         var btn = btns[t.key];
@@ -395,8 +583,10 @@
         if (isActive && !frames[t.key]) {
           var frame = document.createElement('iframe');
           frame.className = 'slim-automation-embed';
-          frame.src = t.src;
-          frame.title = t.label;
+          // Mount straight at the deep-link when one was requested, so the
+          // create flow costs one load, not a load + immediate re-navigate.
+          frame.src = createSrc || t.src;
+          frame.title = t.base;
           // A visibility message posted before this frame navigates is dropped
           // on about:blank, so re-post the live state once it has loaded —
           // otherwise a tab hidden mid-load becomes a permanent background
@@ -406,6 +596,9 @@
           });
           panel.appendChild(frame);
           frames[t.key] = frame;
+        } else if (isActive && createSrc) {
+          // Already-cached frame: re-navigate it to run the deep-link boot hook.
+          frames[t.key].src = createSrc;
         }
         // Suspend hidden cached frames' pollers; resume the shown one.
         if (frames[t.key] && typeof _postEmbedVisibility === 'function') {
@@ -416,16 +609,32 @@
     }
     composite.activate = activate;
 
+    // Activate `key` AND make its embedded classic screen auto-open its own
+    // Create dialog via the ?embed=1#create deep-link (the classic create flow is
+    // reused, not forked — CLAUDE.md slim-vs-classic). The tab's iframe is cached
+    // across opens, so a bare "#create" hash on an already-loaded frame would be
+    // a same-document fragment change that never reloads the page and never runs
+    // its boot hook — hence the unique `&create=<seq>` cache-buster, which the
+    // classic screen ignores.
+    function openCreate(key) {
+      var tab = null;
+      TABS.forEach(function(t) { if (t.key === key) tab = t; });
+      if (!tab) { activate(key); return; }
+      activate(key, tab.src + '&create=' + (++_automationCreateSeq) + '#create');
+    }
+    composite.openCreate = openCreate;
+
     TABS.forEach(function(t) {
       var btn = document.createElement('button');
       btn.type = 'button';
       btn.className = 'kn-tab';
       btn.id = 'slim-automation-tab-' + t.key;
-      btn.textContent = t.label;
+      btn.textContent = _automationTabLabel(t.base, _automationTabCount(t.key));
       btn.setAttribute('role', 'tab');
       btn.setAttribute('aria-controls', 'slim-automation-panel-' + t.key);
       btn.addEventListener('click', function() { activate(t.key); });
       btns[t.key] = btn;
+      _automationTabBtns[t.key] = { el: btn, base: t.base };
       tablist.appendChild(btn);
 
       var panel = document.createElement('div');
@@ -443,22 +652,22 @@
     return composite;
   }
 
-  // Automation tile body — a tabbed composite (Watches · Schedules · Pipelines)
-  // that reuses the LITERAL classic dashboard screens (/watches, /schedule,
-  // /pipelines) instead of a slim-specific list, so there is one Automation UI,
-  // not two (W-mrz0x2a400030f90 / "reuse, don't fork" — mirrors renderPlansBody
-  // for the Plans tile and renderPrsBody for the PRs tile). Each tab embeds the
-  // real classic screen in an iframe with the chrome-off ?embed=1 mode; the
-  // iframed page IS the classic screen — full create/edit/pause/run + row
-  // actions, backed by the same /api/{watches,schedules,pipelines} endpoints —
-  // with zero duplicated rendering logic. Classic is reachable at each route even
-  // with slim-ux ON (only / is taken over). The composite + its lazy iframes are
-  // CACHED in the persistent #slim-tile-automation-host and SHOWN/HIDDEN across
-  // opens (W-ms4r1t5q003h341a) rather than rebuilt into the wiped transient
-  // container — so reopening the tile is an instant show, not a rebuild that
-  // cold-reloads all three classic screens. Mirrors the _embedFrames reuse the
-  // single-iframe tiles already use. The `body` arg (transient) is intentionally
-  // ignored; the composite lives in its own persistent host.
+  // Automation tile body — a tabbed composite (Watches · Scheduled Tasks ·
+  // Pipelines) that reuses the LITERAL classic dashboard screens (/watches,
+  // /schedule, /pipelines) instead of a slim-specific list, so there is one
+  // Automation UI, not two (W-mrz0x2a400030f90 / "reuse, don't fork" — mirrors
+  // renderPlansBody for the Plans tile and renderPrsBody for the PRs tile). Each
+  // tab embeds the real classic screen in an iframe with the chrome-off ?embed=1
+  // mode; the iframed page IS the classic screen — full create/edit/pause/run +
+  // row actions, backed by the same /api/{watches,schedules,pipelines} endpoints
+  // — with zero duplicated rendering logic. Classic is reachable at each route
+  // even with slim-ux ON (only / is taken over). The composite + its lazy iframes
+  // are CACHED in the persistent #slim-tile-automation-host and SHOWN/HIDDEN
+  // across opens (W-ms4r1t5q003h341a) rather than rebuilt into the wiped
+  // transient container — so reopening the tile is an instant show, not a rebuild
+  // that cold-reloads all three classic screens. Mirrors the _embedFrames reuse
+  // the single-iframe tiles already use. The `body` arg (transient) is
+  // intentionally ignored; the composite lives in its own persistent host.
   function renderAutomationTileBody(/* body */) {
     var host = _ensureAutomationHost();
     if (!host) return;
@@ -466,8 +675,23 @@
       _automationComposite = _buildAutomationComposite(host);
     }
     host.hidden = false;
-    // Reopen on the last-active tab (default Watches on first open).
-    _automationComposite.activate(_automationComposite.activeKey || 'watches');
+    // Slim "+ Add" picker → open on a specific tab with that tab's classic
+    // create dialog auto-opened. Consumed HERE (every open) rather than inside
+    // _buildAutomationComposite, which only runs once now that the composite is
+    // cached — otherwise "+ Add" would work only on the very first open.
+    var initial = _automationInitial;
+    _automationInitial = null;
+    if (initial && initial.create) {
+      _automationComposite.openCreate(initial.tab || 'watches');
+    } else {
+      // Reopen on the last-active tab (default Watches on first open).
+      _automationComposite.activate(initial && initial.tab
+        ? initial.tab
+        : (_automationComposite.activeKey || 'watches'));
+    }
+    // Refresh the live "(N)" counts (and the cockpit tile sum) whenever the
+    // modal opens — these are off the hot 5s status poll (loadAutomationCounts).
+    if (typeof loadAutomationCounts === 'function') loadAutomationCounts();
   }
 
   // tile key -> { title, render }. Adding a tile is a one-line table edit.
@@ -542,6 +766,12 @@
           if (ev.target !== tile) return;   // ignore keys from inner controls (e.g. the Link-PR chip)
           if (ev.key === 'Enter' || ev.key === ' ') { ev.preventDefault(); openTileModal(key); }
         });
+        // Predictive prewarm: start booting the embed the instant the user shows
+        // intent (hover / focus / pointer-down) so the click lands on an
+        // already-booting iframe rather than a cold SPA boot (esp. Engine).
+        tile.addEventListener('pointerenter', function() { _predictivePrewarmEmbed(key); });
+        tile.addEventListener('pointerdown', function() { _predictivePrewarmEmbed(key); });
+        tile.addEventListener('focus', function() { _predictivePrewarmEmbed(key); });
       })(tiles[i]);
     }
   })();
@@ -556,3 +786,114 @@
   (function bindPlansTileCount() {
     if (typeof loadPlansCounts === 'function') setTimeout(loadPlansCounts, 1500);
   })();
+
+  // ── Automation tile wiring ─────────────────────────────────────────
+  // (1) Lazy-seed the summed cockpit count (watches + scheduled tasks +
+  //     pipelines) shortly after first paint, mirroring the Plans/Knowledge
+  //     tiles — the schedule/pipeline counts are not on the hot status poll.
+  // (2) The on-tile "+ Add" chip opens a small picker (Watch / Scheduled Task /
+  //     Pipeline); picking one opens the Automation modal on the matching tab and
+  //     auto-opens that tab's classic Create dialog via openAutomationCreate.
+  (function bindAutomationTileCount() {
+    if (typeof loadAutomationCounts === 'function') setTimeout(loadAutomationCounts, 1500);
+  })();
+
+  // Open the Automation modal on `tabKey` with the embedded classic screen's
+  // Create dialog auto-opened (?embed=1#create). tabKey is a TABS key
+  // ('watches' | 'schedule' | 'pipelines').
+  function openAutomationCreate(tabKey) {
+    _automationInitial = { tab: tabKey, create: true };
+    openTileModal('automation');
+    // Single-call handoff: the automation view consumes (and nulls) the flag
+    // synchronously during openTileModal's render. Clearing here covers the
+    // path where openTileModal early-returns because the modal shell is
+    // missing — otherwise the flag would survive and a later plain tile click
+    // would silently open in create mode.
+    _automationInitial = null;
+  }
+
+  var _automationAddMenu = null;
+  function closeAutomationAddPicker() {
+    var menu = _automationAddMenu;
+    // openAutomationAddPicker moves focus INTO the menu, so removing that node
+    // would drop focus to <body> and lose a keyboard user's place. Reclaim it
+    // for the chip (WAI-ARIA menu-button pattern) — but ONLY when focus is
+    // still inside the menu we're removing, so the open-path reset call and an
+    // outside click that already landed on another control keep their focus.
+    // Must be sampled BEFORE removeChild: once detached, activeElement is body.
+    var reclaimFocus = !!(menu && document.activeElement
+      && (menu === document.activeElement
+        || (menu.contains && menu.contains(document.activeElement))));
+    if (menu && menu.parentNode) {
+      menu.parentNode.removeChild(menu);
+    }
+    _automationAddMenu = null;
+    document.removeEventListener('click', _automationAddOutside, true);
+    document.removeEventListener('keydown', _automationAddKeydown, true);
+    var chip = document.getElementById('slim-tile-automation-add');
+    if (chip) {
+      chip.setAttribute('aria-expanded', 'false');
+      if (reclaimFocus && typeof chip.focus === 'function') chip.focus();
+    }
+  }
+  function _automationAddOutside(ev) {
+    if (_automationAddMenu && !_automationAddMenu.contains(ev.target)
+        && ev.target.id !== 'slim-tile-automation-add') {
+      closeAutomationAddPicker();
+    }
+  }
+  function _automationAddKeydown(ev) {
+    if (ev.key === 'Escape') { ev.stopPropagation(); closeAutomationAddPicker(); }
+  }
+  function openAutomationAddPicker(anchorEl) {
+    closeAutomationAddPicker();
+    var menu = document.createElement('div');
+    menu.className = 'slim-add-menu';
+    menu.id = 'slim-automation-add-menu';
+    menu.setAttribute('role', 'menu');
+    menu.setAttribute('aria-label', 'Add automation');
+    [
+      { key: 'watches',   label: 'Watch' },
+      { key: 'schedule',  label: 'Scheduled Task' },
+      { key: 'pipelines', label: 'Pipeline' },
+    ].forEach(function(o) {
+      var item = document.createElement('button');
+      item.type = 'button';
+      item.className = 'slim-add-menu-item';
+      item.setAttribute('role', 'menuitem');
+      item.textContent = o.label;
+      item.addEventListener('click', function(ev) {
+        ev.stopPropagation();
+        closeAutomationAddPicker();
+        openAutomationCreate(o.key);
+      });
+      menu.appendChild(item);
+    });
+    document.body.appendChild(menu);
+    _automationAddMenu = menu;
+    // Anchor under the chip (fixed, so tile overflow can't clip it).
+    var r = anchorEl.getBoundingClientRect();
+    menu.style.top = (r.bottom + 4) + 'px';
+    menu.style.left = Math.max(8, r.right - menu.offsetWidth) + 'px';
+    if (anchorEl.setAttribute) anchorEl.setAttribute('aria-expanded', 'true');
+    var first = menu.querySelector('.slim-add-menu-item');
+    if (first) first.focus();
+    // Defer listener attach so the opening click doesn't immediately dismiss.
+    setTimeout(function() {
+      document.addEventListener('click', _automationAddOutside, true);
+      document.addEventListener('keydown', _automationAddKeydown, true);
+    }, 0);
+  }
+  (function bindAutomationAddUi() {
+    var chip = document.getElementById('slim-tile-automation-add');
+    if (!chip) return;
+    chip.addEventListener('click', function(ev) {
+      ev.stopPropagation();   // don't trigger the cockpit tile's own click
+      if (_automationAddMenu) { closeAutomationAddPicker(); return; }
+      openAutomationAddPicker(chip);
+    });
+    // Keyboard activation on the chip shouldn't bubble to the tile handler.
+    chip.addEventListener('keydown', function(ev) {
+      if (ev.key === 'Enter' || ev.key === ' ') { ev.stopPropagation(); }
+    });
+  })();

package/dashboard/slim/js/status.js

@@ -21,10 +21,6 @@
   // — only deltas from a previously-seen number trigger the fade, so opening
   // the dashboard doesn't animate every tile.
   var lastTileValues = Object.create(null);
-  // Last (count|detail|lit) signature painted onto the Automation cockpit tile,
-  // so applyStatus can skip a redundant updateTile on every 5s status poll when
-  // nothing changed (W-ms4r1t5q003h341a).
-  var _automationTileSig = null;
 
   // Apply lit-state and value/detail text to a tile.
   function updateTile(key, value, detail, lit) {
@@ -229,24 +225,20 @@
       activePrs.length === 0 ? null : (failingPrs.length ? 'red' : 'blue')
     );
 
-    // ── Automation tile (Watches · Schedules · Pipelines) ─────────
-    // The at-a-glance indicator stays watches-driven: schedule/pipeline
-    // counts are not carried by the status poll, and the task explicitly
-    // says not to invent new API calls just for the tile count. The detail
-    // modal (renderAutomationTileBody) embeds all three classic screens.
-    // This runs on EVERY 5s status poll, so gate the updateTile DOM work
-    // (querySelectors + textContent + classList churn) behind a change-check —
-    // repaint only when the count / detail / lit-state actually changed
-    // (render-cache-busting parity with the classic dashboard's _changed()).
+    // ── Automation tile (Watches · Scheduled Tasks · Pipelines) ───
+    // The cockpit headline is the SUM of all three automation surfaces. Watches
+    // ride the live 5s status poll (fed here). Schedules + pipelines are NOT in
+    // the /api/status snapshot, so modals-tiles.js#loadAutomationCounts fetches
+    // them lazily off the hot poll path (mirroring the Knowledge + Plans tiles)
+    // and caches them; renderAutomationTile combines this live watches total with
+    // those cached counts. Total watches (not just active) is used to match the
+    // "sum of all 3 set" summed-count contract.
+    // This runs on EVERY 5s status poll, so the change-check that gates the
+    // updateTile DOM work (querySelectors + textContent + classList churn) lives
+    // inside renderAutomationTile — it has to compare the SUM, which also moves
+    // when the lazy schedule/pipeline counts land (W-ms4r1t5q003h341a).
     var watches = Array.isArray(data.watches) ? data.watches : [];
-    var activeWatches = watches.filter(function(w) { return w && w.status === 'active'; });
-    var autoDetail = activeWatches.length ? 'monitoring' : 'no automation set';
-    var autoLit = activeWatches.length ? 'blue' : null;
-    var autoSig = activeWatches.length + '|' + autoDetail + '|' + (autoLit || '');
-    if (_automationTileSig !== autoSig) {
-      _automationTileSig = autoSig;
-      updateTile('automation', activeWatches.length, autoDetail, autoLit);
-    }
+    if (typeof renderAutomationTile === 'function') renderAutomationTile(watches.length);
 
     // ── Knowledge tile (Pinned Context + Notes + KB) ──────────────
     // Pinned count is live from the poll; notes/KB counts are fetched lazily