@yemi33/minions 0.1.2174 → 0.1.2176

package/dashboard/slim/js/chat.js

@@ -29,6 +29,12 @@
   var messages = [];
   var sending = false;
   var abortController = null;
+  // Per-tab queue of follow-up messages submitted while a turn is streaming
+  // (W-mqayw3x6). Keyed by tabId so each chat tab keeps its own queue across
+  // tab switches. In-memory only — a hard refresh drops the queue by design.
+  var queues = {};
+  var queueSuspended = {};   // tabId -> true after an abort/error suspends auto-drain
+  var queueEl = null;        // bottom-pinned container that holds the queued bubbles
   var currentProject = null;
   try { currentProject = localStorage.getItem(SLIM_PROJECT_KEY) || null; } catch (_e) { /* private mode */ }
 
@@ -241,7 +247,7 @@
     } else {
       div.textContent = text;
     }
-    msgsEl.appendChild(div);
+    _appendMsgEl(div);
     scrollToBottom();
     return div;
   }
@@ -249,11 +255,85 @@
     var div = document.createElement('div');
     div.className = 'chat-action ' + (severity || '');
     div.textContent = label;
-    msgsEl.appendChild(div);
+    _appendMsgEl(div);
     scrollToBottom();
     return div;
   }
 
+  // ── Queued-message rendering (W-mqayw3x6) ──────────────────────────
+  function _getQueue() {
+    return queues[tabId] || (queues[tabId] = []);
+  }
+  // Keep a single bottom-pinned container so queued bubbles always sit below
+  // the live transcript (newest content nearest the composer). appendChild on
+  // an already-attached node moves it, so this re-pins the container to the end.
+  function _ensureQueueEl() {
+    if (!queueEl || queueEl.parentNode !== msgsEl) {
+      queueEl = document.createElement('div');
+      queueEl.className = 'chat-queue';
+    }
+    msgsEl.appendChild(queueEl);
+    return queueEl;
+  }
+  // Insert a real/stream bubble above the queue container so the pending
+  // queued bubbles stay pinned at the bottom of the transcript.
+  function _appendMsgEl(el) {
+    if (queueEl && queueEl.parentNode === msgsEl) msgsEl.insertBefore(el, queueEl);
+    else msgsEl.appendChild(el);
+  }
+  // Rebuild the queued-message bubbles for the active tab: greyed-out user
+  // bubbles with a per-message dismiss. When auto-drain is suspended (after an
+  // abort/error) a "Send queued (N)" control lets the user resume explicitly.
+  function renderQueue() {
+    var q = _getQueue();
+    if (!q.length) {
+      if (queueEl && queueEl.parentNode) queueEl.parentNode.removeChild(queueEl);
+      queueEl = null;
+      queueSuspended[tabId] = false;
+      return;
+    }
+    _ensureQueueEl();
+    queueEl.textContent = '';
+    if (queueSuspended[tabId]) {
+      var resume = document.createElement('button');
+      resume.className = 'chat-queue-resume';
+      resume.type = 'button';
+      resume.textContent = 'Send queued (' + q.length + ')';
+      resume.title = 'Send the queued messages now';
+      resume.addEventListener('click', function() {
+        queueSuspended[tabId] = false;
+        renderQueue();
+        _drainQueue();
+      });
+      queueEl.appendChild(resume);
+    }
+    q.forEach(function(text, i) {
+      var row = document.createElement('div');
+      row.className = 'chat-msg user queued';
+      var span = document.createElement('span');
+      span.className = 'chat-queue-text';
+      span.textContent = text;
+      row.appendChild(span);
+      var badge = document.createElement('span');
+      badge.className = 'chat-queue-badge';
+      badge.textContent = 'queued';
+      row.appendChild(badge);
+      var dismiss = document.createElement('button');
+      dismiss.className = 'chat-queue-dismiss';
+      dismiss.type = 'button';
+      dismiss.textContent = '×';
+      dismiss.title = 'Remove from queue';
+      dismiss.addEventListener('click', function() {
+        var qq = _getQueue();
+        qq.splice(i, 1);
+        renderQueue();
+      });
+      row.appendChild(dismiss);
+      queueEl.appendChild(row);
+    });
+    scrollToBottom();
+  }
+
   // Render a tool invocation as a one-line string. `full` keeps the complete
   // command/args (used by the tool-calls modal); otherwise long values are
   // clipped for the collapsed 3-line panel.
@@ -370,7 +450,7 @@
     tp.panel.style.display = 'none';
     toolbar.appendChild(tp.panel);
 
-    msgsEl.appendChild(div);
+    _appendMsgEl(div);
     scrollToBottom();
 
     return {
@@ -411,26 +491,32 @@
 
   function setSending(on) {
     sending = on;
-    sendBtn.disabled = on;
-    sendBtn.textContent = on ? 'Sending…' : 'Send';
+    // Composer stays interactive while a turn streams so the user can keep
+    // typing and queue follow-up messages (W-mqayw3x6 #1). The Send button
+    // stays enabled — submitting mid-turn enqueues — and only its label
+    // reflects the in-flight state.
+    sendBtn.disabled = false;
+    sendBtn.textContent = on ? 'Queue' : 'Send';
     stopBtn.style.display = on ? 'block' : 'none';
-    inputEl.disabled = on;
+    inputEl.disabled = false;
   }
 
   function rerenderHistory() {
     msgsEl.innerHTML = '';
+    queueEl = null;   // detached by the innerHTML reset; renderQueue rebuilds it
     if (!messages.length) {
       var empty = document.createElement('div');
       empty.className = 'chat-empty';
       empty.textContent = 'No messages yet — say hi to Command Center.';
       msgsEl.appendChild(empty);
-      return;
-    }
-    for (var i = 0; i < messages.length; i++) {
-      var m = messages[i];
-      if (m.role === 'action') appendActionStatus(m.severity || '', m.text || '');
-      else appendBubble(m.role, m.text || '', m.toolCalls);
+    } else {
+      for (var i = 0; i < messages.length; i++) {
+        var m = messages[i];
+        if (m.role === 'action') appendActionStatus(m.severity || '', m.text || '');
+        else appendBubble(m.role, m.text || '', m.toolCalls);
+      }
     }
+    renderQueue();
   }
   // ── Command Center tab bar (shared with the classic dashboard) ──
   // One chip per shared cc-tabs entry, so the same conversations are visible

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

@@ -23,10 +23,60 @@
     saveState();
   }
 
-  async function sendMessage() {
-    if (sending) return;
+  // Public entry point for the Send button / Enter key. While a turn is in
+  // flight the composer stays interactive (setSending no longer disables it),
+  // so a second submit QUEUES the message instead of dropping it or racing the
+  // active stream. The queue drains FIFO, one turn at a time (W-mqayw3x6).
+  function sendMessage() {
     var text = inputEl.value.trim();
     if (!text) return;
+    inputEl.value = '';
+    inputEl.style.height = 'auto';
+    if (sending) {
+      _enqueue(text);
+      inputEl.focus();
+      return;
+    }
+    _performSend(text);
+  }
+
+  // Append to the active tab's pending queue and render the greyed bubbles.
+  function _enqueue(text) {
+    _getQueue().push(text);
+    renderQueue();
+  }
+
+  // Promote the next queued message for the active tab, one at a time. No-op
+  // while a turn is in flight or the queue is suspended (after abort/error).
+  function _drainQueue() {
+    if (sending || queueSuspended[tabId]) return;
+    var q = _getQueue();
+    if (!q.length) return;
+    var next = q.shift();
+    renderQueue();
+    _performSend(next);
+  }
+
+  // Called from a finished turn's `finally`. On clean completion auto-fire the
+  // next queued message; on abort or error suspend auto-drain and leave the
+  // queue visible so the user can resend or dismiss explicitly (W-mqayw3x6 #5/#6).
+  function _afterTurn(turnTabId, outcome) {
+    var q = queues[turnTabId];
+    if (!q || !q.length) return;
+    if (outcome === 'done' && turnTabId === tabId) {
+      _drainQueue();
+    } else {
+      queueSuspended[turnTabId] = true;
+      if (turnTabId === tabId) renderQueue();
+    }
+  }
+
+  async function _performSend(text) {
+    // Bind this turn to the tab it started on so a mid-turn tab switch (which
+    // aborts the stream) settles the queue against the right tab, not the one
+    // the user navigated to.
+    var turnTabId = tabId;
+    var turnOutcome = 'done';
 
     // 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.
@@ -36,8 +86,6 @@
     saveState();
     if (wasFirstUser) renderTabBar();
 
-    inputEl.value = '';
-    inputEl.style.height = 'auto';
     setSending(true);
 
     var stream = buildStreamBubble();
@@ -101,6 +149,7 @@
         stream.replaceWithError(errorEvt.error || 'Error');
         messages.push({ role: 'error', text: errorEvt.error || 'Error' });
         saveState();
+        turnOutcome = 'error';
         return;
       }
 
@@ -130,6 +179,7 @@
     } catch (e) {
       if (e && (e.name === 'AbortError' || /aborted/i.test(String(e.message || '')))) {
         userAborted = true;
+        turnOutcome = 'aborted';
         if (streamedText) {
           stream.finalize(streamedText);
           messages.push({ role: 'assistant', text: streamedText, toolCalls: stream.getToolList() });
@@ -139,6 +189,7 @@
         }
         saveState();
       } else {
+        turnOutcome = 'error';
         var msg = 'Send failed: ' + (e && e.message ? e.message : e);
         stream.replaceWithError(msg);
         messages.push({ role: 'error', text: msg });
@@ -147,7 +198,8 @@
     } finally {
       setSending(false);
       abortController = null;
-      if (!userAborted) inputEl.focus();
+      if (turnTabId === tabId && !userAborted) inputEl.focus();
+      _afterTurn(turnTabId, turnOutcome);
     }
   }
 
@@ -165,6 +217,10 @@
 
   async function slimChatNew() {
     if (sending) abortInFlight();
+    // New chat = fresh session: drop the leaving tab's pending queue (#7). The
+    // aborted in-flight turn's _afterTurn then finds an empty queue and no-ops.
+    delete queues[tabId];
+    queueSuspended[tabId] = false;
     // Register a fresh tab in the shared cc-tabs store and switch slim onto
     // it — classic's other tabs are left intact, and the previous session
     // keeps its own server-side cc-sessions.json entry (no DELETE).

package/dashboard/slim/styles.css

@@ -360,6 +360,59 @@
       border: 1px solid var(--red);
       font-size: var(--text-lg);
     }
+    /* Queued messages (W-mqayw3x6): follow-ups submitted while a turn is still
+       streaming. The container is pinned to the bottom of the transcript; each
+       item is a greyed-out user bubble that fires FIFO on turn completion. */
+    .chat-queue {
+      display: flex;
+      flex-direction: column;
+      gap: 8px;
+      align-self: stretch;
+    }
+    .chat-msg.user.queued {
+      align-self: flex-end;
+      background: var(--surface2);
+      color: var(--muted);
+      border: 1px dashed var(--border);
+      opacity: 0.8;
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+    .chat-queue-text { white-space: pre-wrap; word-wrap: break-word; }
+    .chat-queue-badge {
+      font-size: var(--text-base);
+      text-transform: uppercase;
+      letter-spacing: 0.5px;
+      color: var(--muted);
+      border: 1px solid var(--border);
+      border-radius: var(--radius);
+      padding: 1px 6px;
+      flex-shrink: 0;
+    }
+    .chat-queue-dismiss {
+      background: none;
+      border: none;
+      color: var(--muted);
+      cursor: pointer;
+      font-size: var(--text-lg);
+      line-height: 1;
+      padding: 0 2px;
+      flex-shrink: 0;
+    }
+    .chat-queue-dismiss:hover { color: var(--red); }
+    .chat-queue-resume {
+      align-self: center;
+      background: var(--blue);
+      color: #fff;
+      border: none;
+      border-radius: var(--radius);
+      padding: 6px 14px;
+      font-size: var(--text-md);
+      font-weight: 600;
+      cursor: pointer;
+    }
+    .chat-queue-resume:hover { filter: brightness(1.1); }
     .chat-input-wrap {
       display: flex;
       gap: 8px;

package/engine/watches.js

@@ -150,7 +150,14 @@ function registerTargetType(type, spec) {
       throw new Error(`registerTargetType(${type}): absoluteConditions entry '${c}' is not in conditions[]`);
     }
   }
-  TARGET_TYPES[type] = { ...spec, absoluteConditions: absoluteSet };
+  // W-mqa63opd000ha836 — optional hook: returns true when the target has
+  // reached a state from which `condition` can never fire again (e.g. a
+  // PR's status is `merged` and we're watching `build-fail`). Default
+  // returns false (back-compat — current target types unchanged).
+  const terminalFn = typeof spec.isTerminalForCondition === 'function'
+    ? spec.isTerminalForCondition
+    : () => false;
+  TARGET_TYPES[type] = { ...spec, absoluteConditions: absoluteSet, isTerminalForCondition: terminalFn };
 }
 
 /** Returns the registered spec for a target type, or null. */
@@ -517,6 +524,40 @@ function checkWatches(config, state) {
           });
         }
 
+        // W-mqa63opd000ha836 — auto-expire watches whose target has reached a
+        // terminal state from which the watched condition can never fire again.
+        // Independent of the absolute-condition fire-once path above: covers the
+        // long-tail case where a `build-fail` (or similar) watch was armed on an
+        // active PR that subsequently merged without ever tripping its condition.
+        // Without this, the watch sits `active` forever, polling every interval.
+        //
+        // Guardrail: do NOT auto-expire until the watch has had a chance to fire
+        // on its first real check — `triggerCount > 0` covers post-fire watches;
+        // `prevState.status === entity.status` covers second-and-later checks
+        // (initial _captureState on tick-1 makes these equal, so a watch armed
+        // on an already-terminal target with `condition: merged` still fires
+        // once via the absolute-condition path before this branch expires it).
+        if (watch.status === WATCH_STATUS.ACTIVE) {
+          const _ttForTerm = TARGET_TYPES[watch.targetType];
+          if (_ttForTerm && typeof _ttForTerm.isTerminalForCondition === 'function') {
+            try {
+              const _entityForTerm = _ttForTerm.fetchEntity(watch.target, state || {});
+              if (_entityForTerm) {
+                const _hadShot = (watch.triggerCount || 0) > 0
+                  || (previousState && previousState.status !== undefined
+                      && previousState.status === _entityForTerm.status);
+                if (_hadShot && _ttForTerm.isTerminalForCondition(watch.condition, _entityForTerm, previousState)) {
+                  watch.status = WATCH_STATUS.EXPIRED;
+                  const _termStatus = _entityForTerm.status;
+                  log('info', `Watch auto-expired (terminal target state): ${watch.id} — ${watch.targetType} ${watch.target} is ${_termStatus}, condition ${watch.condition} cannot fire again`);
+                }
+              }
+            } catch (termErr) {
+              log('warn', `Watch terminal-state check error (${watch.id}): ${termErr.message}`);
+            }
+          }
+        }
+
         // Capture state for change detection on next check
         watch._lastState = _captureState(watch, state);
 
@@ -704,6 +745,36 @@ registerTargetType(WATCH_TARGET_TYPE.PR, {
     WATCH_CONDITION.MERGED, WATCH_CONDITION.BUILD_FAIL, WATCH_CONDITION.BUILD_PASS,
     WATCH_CONDITION.READY_FOR_MERGE,
   ],
+  // W-mqa63opd000ha836 — zombie-watch janitor: once a PR reaches a terminal
+  // status (merged / closed / abandoned), most PR conditions can never fire
+  // again so the watch should auto-expire instead of polling forever.
+  //
+  // Excluded from terminal-expire:
+  //   - merged          — already handled by the absoluteConditions fire-once
+  //                       path; including it here is redundant and risks
+  //                       expiring before the watch's one shot to fire.
+  //   - status-change   — could theoretically still fire on a status flip
+  //                       (e.g. closed→reopened on GitHub), even though rare.
+  //   - any             — same rationale as status-change.
+  //
+  // Build-fail / build-pass / vote-change / new-comments / head-commit-change /
+  // mergeable-flipped / behind-master / ready-for-merge / draft-flipped all
+  // mutate fields that are frozen the moment the PR is merged/closed/abandoned,
+  // so a fresh fire is impossible.
+  isTerminalForCondition: (condition, pr) => {
+    if (!pr || !pr.status) return false;
+    const status = pr.status;
+    const isTerminal = status === shared.PR_STATUS.MERGED
+      || status === shared.PR_STATUS.CLOSED
+      || status === shared.PR_STATUS.ABANDONED;
+    if (!isTerminal) return false;
+    if (condition === WATCH_CONDITION.MERGED
+        || condition === WATCH_CONDITION.STATUS_CHANGE
+        || condition === WATCH_CONDITION.ANY) {
+      return false;
+    }
+    return true;
+  },
   fetchEntity: (target, state) => findPrByTarget(state.pullRequests, target),
   captureState: (pr) => ({
     status: pr.status, buildStatus: pr.buildStatus, reviewStatus: pr.reviewStatus,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2174",
+  "version": "0.1.2176",
   "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"