@yemi33/minions 0.1.2376 → 0.1.2378

package/dashboard/js/refresh.js

@@ -130,7 +130,8 @@ function _detectPageChanges(data) {
 // for the same input. Cross-restart safety lives in the dashboardBuildId
 // reload path below — RENDER_VERSIONS handles the within-process case.
 const RENDER_VERSIONS = {
-  agents: 2,
+  // Bumped 2→3 for client-ticked relative last-action timestamps.
+  agents: 3,
   prdProgress: 2,
   prdPrs: 1,
   inbox: 2,
@@ -516,17 +517,19 @@ function _processStatusUpdate(data, opts) {
   // the /api/work-items + /api/pull-requests .then handlers
   // (_fireCrossSliceRender) where the FRESH fetched lists are available.
   // Agents now come from /api/agents — a dedicated fresh-JSON endpoint with
-  // input-mtime ETag (issue #2949). No /api/status outer cache in the path.
+  // input-mtime ETag (issue #2949). Conditional requests keep unchanged polls
+  // from reparsing the roster and rebuilding every card/timer.
   // cmdUpdateAgentList consumes the same slice but renders the command-line
   // chip pop-up so we feed it the fresh array too.
   _safeRender('agents', function() {
     const seq = (window._refreshSeq = (window._refreshSeq || 0) + 1);
     window._lastRequestedSeq = window._lastRequestedSeq || {};
     window._lastRequestedSeq.agents = seq;
-    fetch('/api/agents')
-      .then(function (r) { return r.ok ? r.json() : Promise.reject(); })
-      .then(function (fresh) {
+    _condFetchJson('/api/agents')
+      .then(function (resp) {
         if (seq < (window._lastRequestedSeq.agents || 0)) return;
+        if (resp.notModified) return;
+        const fresh = resp.data;
         const list = Array.isArray(fresh) ? fresh : window._lastAgents;
         if (list) window._lastAgents = list;
         _safeRender('agents', function() { renderAgents(list); });

package/dashboard/js/render-agents.js

@@ -44,6 +44,34 @@ function _modelChipHtml(model) {
   return '<span class="agent-model-tag" title="Model: ' + escapeHtml(model) + '" style="font-size:var(--text-xs);font-weight:600;letter-spacing:0.4px;padding:1px 5px;margin-left:4px;border:1px solid var(--muted);border-radius:3px;color:var(--muted);background:transparent">' + escapeHtml(model) + '</span>';
 }
 
+function _agentHasTimedAction(agent) {
+  return !!(agent && agent.lastActionPrefix && Number.isFinite(Number(agent.lastActionAt)));
+}
+
+function _formatAgentAction(prefix, actionAt, fallback) {
+  var actionAtMs = Number(actionAt);
+  var text = prefix && Number.isFinite(actionAtMs)
+    ? String(prefix) + ' (' + timeAgo(actionAtMs) + ')'
+    : String(fallback || '');
+  return text.length > 120 ? text.slice(0, 120) + '...' : text;
+}
+
+function _agentLastActionText(agent) {
+  return _formatAgentAction(agent.lastActionPrefix, agent.lastActionAt, agent.lastAction);
+}
+
+function _agentTimedActionAttrs(agent) {
+  return _agentHasTimedAction(agent)
+    ? ' data-action-prefix="' + escapeHtml(agent.lastActionPrefix) + '" data-action-at="' + Number(agent.lastActionAt) + '"'
+    : '';
+}
+
+function _agentActionHtml(agent) {
+  var text = _agentLastActionText(agent);
+  var attrs = _agentTimedActionAttrs(agent);
+  return '<div class="agent-action"' + attrs + ' title="' + escapeHtml(text) + '">' + escapeHtml(text) + '</div>';
+}
+
 function renderAgents(agents) {
   agentData = agents;
   const grid = document.getElementById('agents-grid');
@@ -56,7 +84,7 @@ function renderAgents(agents) {
         <span class="status-badge ${escapeHtml(a.status)}">${escapeHtml(a.status)}</span>
       </div>
       <div class="agent-role">${escapeHtml(a.role)}</div>
-      <div class="agent-action" title="${escapeHtml(a.lastAction)}">${escapeHtml(a.lastAction)}</div>
+      ${_agentActionHtml(a)}
       ${(function() {
         var s = a.started_at, c = a.completed_at;
         if (s && c) { var d = new Date(c) - new Date(s); if (d > 0) { var sec = Math.floor(d/1000)%60, min = Math.floor(d/60000)%60, hr = Math.floor(d/3600000); return '<div style="font-size:var(--text-xs);color:var(--muted)">Last run: ' + (hr > 0 ? hr + 'h ' : '') + min + 'm ' + sec + 's</div>'; } }
@@ -144,7 +172,7 @@ async function openAgentDetail(id) {
   // eslint-disable-next-line no-unsanitized/property -- reason: structural HTML is a string literal; status is an internal bounded enum and all user data is wrapped in escapeHtml()/renderMd() (fields: lastAction, blocking tool, resultSummary)
   document.getElementById('detail-status-line').innerHTML =
     '<span class="status-badge ' + badgeClass + '">' + agent.status.toUpperCase() + '</span> ' +
-    '<span style="color:var(--muted)">' + escapeHtml(agent.lastAction) + '</span>' +
+    '<span class="agent-detail-action"' + _agentTimedActionAttrs(agent) + ' style="color:var(--muted)">' + escapeHtml(_agentLastActionText(agent)) + '</span>' +
     (agent._blockingToolCall ? '<div style="margin-top:4px;padding:4px 8px;background:rgba(130,160,210,0.13);border:1px solid rgba(130,160,210,0.3);border-radius:4px;font-size:var(--text-base);color:var(--muted)">&#x23F3; Blocking tool call (' + escapeHtml(agent._blockingToolCall.tool) + ') &mdash; silent ' + Math.round(agent._blockingToolCall.silentMs/60000) + 'min, timeout in ' + Math.round(agent._blockingToolCall.remainingMs/60000) + 'min</div>' : '') +
     (agent.resultSummary ? '<div style="margin-top:4px;font-size:var(--text-base);color:var(--text);line-height:1.4">' + renderMd(agent.resultSummary.slice(0, 300)) + '</div>' : '');
 
@@ -168,11 +196,19 @@ async function openAgentDetail(id) {
 
 }
 
-// Tick running agent timers on cards every second
+// Tick wall-clock-derived card text every second.
 var _agentRuntimeTimer = null;
 function _tickAgentRuntimes() {
-  var els = document.querySelectorAll('.agent-runtime-tick');
-  if (els.length === 0) { if (_agentRuntimeTimer) { clearInterval(_agentRuntimeTimer); _agentRuntimeTimer = null; } return; }
+  var grid = document.getElementById('agents-grid');
+  var els = grid ? grid.querySelectorAll('.agent-runtime-tick') : [];
+  var actionEls = grid ? Array.from(grid.querySelectorAll('.agent-action[data-action-at]')) : [];
+  var detailStatus = document.getElementById('detail-status-line');
+  var detailAction = detailStatus && detailStatus.querySelector('.agent-detail-action[data-action-at]');
+  if (detailAction) actionEls.push(detailAction);
+  if (els.length === 0 && actionEls.length === 0) {
+    if (_agentRuntimeTimer) { clearInterval(_agentRuntimeTimer); _agentRuntimeTimer = null; }
+    return;
+  }
   var now = Date.now();
   els.forEach(function(el) {
     var ms = now - new Date(el.dataset.started).getTime();
@@ -180,13 +216,20 @@ function _tickAgentRuntimes() {
     var sec = Math.floor(ms / 1000) % 60, min = Math.floor(ms / 60000) % 60, hr = Math.floor(ms / 3600000);
     el.textContent = 'Running: ' + (hr > 0 ? hr + 'h ' : '') + min + 'm ' + sec + 's';
   });
+  actionEls.forEach(function(el) {
+    var text = _formatAgentAction(el.dataset.actionPrefix, Number(el.dataset.actionAt), el.textContent);
+    el.textContent = text;
+    el.title = text;
+  });
 }
-// Start ticker after each render if working agents exist
+// Start ticker after each render if any card has wall-clock-derived text.
 var _origRenderAgents = renderAgents;
 renderAgents = function(agents) {
   _origRenderAgents(agents);
   if (_agentRuntimeTimer) { clearInterval(_agentRuntimeTimer); _agentRuntimeTimer = null; }
-  if (agents.some(function(a) { return a.status === 'working' && a.started_at; })) {
+  if (agents.some(function(a) {
+    return (a.status === 'working' && a.started_at) || _agentHasTimedAction(a);
+  })) {
     _tickAgentRuntimes();
     _agentRuntimeTimer = setInterval(_tickAgentRuntimes, 1000);
   }

package/dashboard/js/settings.js

@@ -890,13 +890,11 @@ async function initRuntimeFleetUI(engineCfg, agentsCfg) {
 }
 
 /**
- * Replace the input/select at `inputId` with a dropdown when the runtime
- * exposes a model list, or a free-text input when `{ models: null }` (e.g.
- * Claude or model-discovery disabled). The "Default (CLI chooses)" option is
- * always present and submits empty string.
+ * Render an editable model field backed by discovered-model suggestions.
+ * Discovery is advisory: staged/future/custom model IDs must remain typeable.
  */
-async function loadModelsForRuntime(runtimeName, inputId, currentValue) {
-  const wrap = document.getElementById(inputId)?.parentElement;
+async function loadModelsForRuntime(runtimeName, inputId, currentValue, forceRefresh) {
+  const wrap = document.getElementById(inputId + '-wrap') || document.getElementById(inputId)?.parentElement;
   if (!wrap) return;
   const token = _nextModelLoadToken('runtime', inputId);
   if (!runtimeName) {
@@ -906,42 +904,37 @@ async function loadModelsForRuntime(runtimeName, inputId, currentValue) {
   }
   let payload = { models: null };
   try {
-    const res = await fetch('/api/runtimes/' + encodeURIComponent(runtimeName) + '/models');
+    const suffix = forceRefresh ? '/models/refresh' : '/models';
+    const res = await fetch('/api/runtimes/' + encodeURIComponent(runtimeName) + suffix, forceRefresh ? { method: 'POST' } : undefined);
     if (res.ok) payload = await res.json();
   } catch { /* fall through to free-text */ }
 
   if (!_isCurrentModelLoad('runtime', inputId, token)) return;
   const models = Array.isArray(payload.models) ? payload.models : null;
-  if (!models || models.length === 0) {
-    // Free-text fallback — let the user type anything (custom Anthropic /
-    // OpenAI model IDs, future models, etc.).
-    // eslint-disable-next-line no-unsanitized/property -- reason: structural HTML is a string literal; all user data wrapped in escHtml() (fields: currentValue; inputId is an internal fixed DOM id)
-    wrap.innerHTML = '<input id="' + inputId + '" value="' + escHtml(currentValue || '') + '" placeholder="Default (CLI chooses)" style="width:100%;padding:4px 6px;background:var(--surface);border:1px solid var(--border);border-radius:4px;color:var(--text);font-size:var(--text-md)">';
-    return;
-  }
-  // Dropdown. The first option submits empty string → "Default (CLI chooses)".
-  let opts = '<option value=""' + (!currentValue ? ' selected' : '') + '>Default (CLI chooses)</option>';
-  for (const m of models) {
+  const listId = inputId + '-options';
+  let opts = '';
+  for (const m of (models || [])) {
     const id = m.id || m.name || '';
     if (!id) continue;
-    const label = m.name && m.name !== id ? (id + ' — ' + m.name) : id;
-    opts += '<option value="' + escHtml(id) + '"' + (id === currentValue ? ' selected' : '') + '>' + escHtml(label) + '</option>';
+    const label = m.name && m.name !== id ? m.name : '';
+    opts += '<option value="' + escHtml(id) + '"' + (label ? ' label="' + escHtml(label) + '"' : '') + '></option>';
   }
-  // If the current value isn't in the model list (custom / older choice),
-  // surface it as a selectable option so the user doesn't lose it on next save.
-  if (currentValue && !models.some(m => (m.id || m.name) === currentValue)) {
-    opts += '<option value="' + escHtml(currentValue) + '" selected>' + escHtml(currentValue) + ' (custom)</option>';
+  const title = forceRefresh ? 'Model list refreshed' : 'Refresh models from the selected CLI';
+  // eslint-disable-next-line no-unsanitized/property -- reason: structural HTML is a string literal; all user data wrapped in escHtml()
+  wrap.innerHTML = '<div style="display:flex;gap:4px"><input id="' + inputId + '" list="' + listId + '" value="' + escHtml(currentValue || '') + '" placeholder="Default (CLI chooses)" autocomplete="off" style="min-width:0;flex:1;padding:4px 6px;background:var(--surface);border:1px solid var(--border);border-radius:4px;color:var(--text);font-size:var(--text-md)"><button type="button" data-model-refresh title="' + escHtml(title) + '" aria-label="Refresh model list" style="padding:3px 8px;background:var(--surface2);border:1px solid var(--border);border-radius:4px;color:var(--muted);cursor:pointer">↻</button></div><datalist id="' + listId + '">' + opts + '</datalist>';
+  const refresh = wrap.querySelector('[data-model-refresh]');
+  if (refresh) {
+    refresh.addEventListener('click', async function() {
+      const liveValue = document.getElementById(inputId)?.value || '';
+      refresh.disabled = true;
+      await loadModelsForRuntime(runtimeName, inputId, liveValue, true);
+    });
   }
-  // eslint-disable-next-line no-unsanitized/property -- reason: structural HTML is a string literal; all user data wrapped in escHtml() (fields: model id, model label, currentValue; inputId is an internal fixed DOM id)
-  wrap.innerHTML = '<select id="' + inputId + '" style="width:100%;padding:4px 6px;background:var(--surface);border:1px solid var(--border);border-radius:4px;color:var(--text);font-size:var(--text-md)">' + opts + '</select>';
 }
 
 /**
- * Per-agent model hydrator. Replaces the placeholder input in the cell
- * `[data-runtime-model="<agentId>"]` with a <select> of valid models for the
- * given runtime. Output element keeps `data-agent` + `data-field="model"` so
- * the existing save flow picks it up unchanged. Free-text input fallback
- * when the runtime returns no model list (Claude / discovery disabled).
+ * Per-agent model hydrator. The catalog is a datalist rather than a closed
+ * select so newly released and custom IDs stay available.
  */
 async function loadModelsForAgent(agentId, runtimeName, currentValue) {
   const cell = document.querySelector('[data-runtime-model="' + agentId + '"]');

package/dashboard.js

@@ -2996,68 +2996,56 @@ function _stateReadContentType(ext) {
 // issue #2949 documented. This pattern bypasses both:
 //
 //   1. Caller supplies an array of input file paths.
-//   2. We statSync each one and take MAX(mtimeMs). That's the ETag.
+//   2. We asynchronously stat each one and take MAX(mtimeMs). That's the ETag.
 //   3. If the client's If-None-Match matches → 304 with no body.
 //   4. Otherwise call `builder()` to assemble the response from scratch
 //      (no outer cache layer to go stale).
 //   5. Stamp ETag + Content-Type and send.
 //
-// Cost per request when ETag matches: N statSync calls (microseconds).
-// Cost on a miss: same N statSync + the builder, which is exactly the
+// Cost per request when ETag matches: N asynchronous stat calls.
+// Cost on a miss: the same stat walk + the builder, which is exactly the
 // existing queries.getAgents() / getMetrics() / etc. that /api/status
 // already pays. Net change: same compute, no caching, always-fresh.
-function _maxInputMtimeMs(inputs) {
-  let max = 0;
-  for (const fp of inputs) {
-    try {
-      // Use lstatSync so a broken Windows junction (common after DevBox
-      // swap) or a circular symlink doesn't block the event loop on a
-      // ~30 s OS timeout trying to follow the link. Engine never writes
-      // symlinks into state dirs in normal operation, so an lstat that
-      // detects a symlink is treated as "skip" — the input is effectively
-      // not tracked. (Round-2 review finding #7.)
-      const s = fs.lstatSync(fp);
-      if (s.isSymbolicLink()) continue;
-      if (s.mtimeMs > max) max = s.mtimeMs;
-      // Directory inputs: dir mtime only advances on add/remove of
-      // immediate entries, not on in-place file edits. Walk two levels
-      // down so editing prd/<plan>.json in place (depth 1) and
-      // agents/<id>/live-output.log (depth 2) both bust the ETag.
-      // Steering edits at agents/<id>/inbox/steering-*.md (depth 3)
-      // currently rely on add/remove cadence rather than per-file content
-      // mtime — accept this lag rather than walking unbounded.
-      // (Review finding #6.)
-      if (s.isDirectory()) {
-        let level1;
-        try { level1 = fs.readdirSync(fp); } catch { level1 = []; }
-        for (const name of level1) {
-          const child = path.join(fp, name);
-          let cs;
-          try { cs = fs.lstatSync(child); } catch { continue; }
-          if (cs.isSymbolicLink()) continue;
-          if (cs.mtimeMs > max) max = cs.mtimeMs;
-          if (cs.isDirectory()) {
-            let level2;
-            try { level2 = fs.readdirSync(child); } catch { level2 = []; }
-            for (const inner of level2) {
-              try {
-                const is = fs.lstatSync(path.join(child, inner));
-                if (is.isSymbolicLink()) continue;
-                if (is.mtimeMs > max) max = is.mtimeMs;
-              } catch { /* skip unreadable */ }
-            }
-          }
-        }
-      }
-    } catch {
-      // Missing input = not yet on disk. Don't bust the ETag — a builder
-      // that legitimately depends on the file will surface its own empty
-      // state, and the ETag will move once the file appears.
-    }
+async function _freshnessEntryMtimeMs(fp, depth) {
+  let stat;
+  try {
+    // lstat avoids following broken Windows junctions or circular symlinks,
+    // which can incur long OS timeouts. State inputs never require symlinks.
+    stat = await fs.promises.lstat(fp);
+  } catch {
+    return 0;
+  }
+  if (stat.isSymbolicLink()) return 0;
+
+  let max = stat.mtimeMs;
+  if (!stat.isDirectory() || depth <= 0) return max;
+
+  let names;
+  try {
+    names = await fs.promises.readdir(fp);
+  } catch {
+    return max;
   }
-  return Math.floor(max);
+  const childMtimes = await Promise.all(
+    names.map(name => _freshnessEntryMtimeMs(path.join(fp, name), depth - 1)),
+  );
+  for (const childMtime of childMtimes) {
+    if (childMtime > max) max = childMtime;
+  }
+  return max;
+}
+
+async function _maxInputMtimeMs(inputs) {
+  // Directory mtime only advances on add/remove, not in-place edits. Walk two
+  // levels so prd/<plan>.json and agents/<id>/live-output.log both bust ETags.
+  // Deeper steering edits still rely on add/remove cadence, matching the prior
+  // bounded walk.
+  const mtimes = await Promise.all(
+    inputs.map(fp => _freshnessEntryMtimeMs(fp, 2)),
+  );
+  return Math.floor(mtimes.reduce((max, mtime) => Math.max(max, mtime), 0));
 }
-function serveFreshJson(req, res, opts) {
+async function serveFreshJson(req, res, opts) {
   const inputs = Array.isArray(opts && opts.inputs) ? opts.inputs : [];
   const builder = opts && typeof opts.builder === 'function' ? opts.builder : null;
   const tag = opts && opts.tag ? String(opts.tag) : 'v';
@@ -3067,7 +3055,7 @@ function serveFreshJson(req, res, opts) {
     res.end(JSON.stringify({ error: 'serveFreshJson: builder is required' }));
     return;
   }
-  const mtime = _maxInputMtimeMs(inputs);
+  const mtime = await _maxInputMtimeMs(inputs);
   const eventVersion = _getCurrentEventVersion();
   const etag = '"' + tag + '-' + mtime + '-' + eventVersion + '"';
   res.setHeader('ETag', etag);
@@ -4502,6 +4490,7 @@ async function _preflightModelCheck({ runtime: cliOverride, model: modelOverride
   const resolvedModel = llm._resolveModelForRuntime(adapter, { model: modelOverride, engineConfig });
   if (!resolvedModel) return null;
   if (!adapter.capabilities || adapter.capabilities.modelDiscovery !== true) return null;
+  if (adapter.capabilities.strictModelCatalog === false) return null;
 
   let list;
   try {
@@ -7676,7 +7665,7 @@ const server = http.createServer(async (req, res) => {
       h = Math.imul(h ^ ((e.size || 0) >>> 0), 16777619);
       h = Math.imul(h ^ Math.floor(e.sortTs || 0), 16777619);
     }
-    const sweepMtime = _maxInputMtimeMs([
+    const sweepMtime = await _maxInputMtimeMs([
       path.join(ENGINE_DIR, 'kb-swept.json'),
       path.join(ENGINE_DIR, 'kb-sweep-state.json'),
     ]);
@@ -10572,8 +10561,8 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           });
           writeCcEvent(envelope);
           liveState.donePayload = envelope;
-          _ccStreamEnded = true;
           if (liveState.endResponse) liveState.endResponse();
+          _ccStreamEnded = true;
           _scheduleCcLiveCleanup(tabId);
           _logCcStreamEnd(_ccTelemetry, 'error-preflight-model-unavailable', { runtime: preflightFailure.runtime });
           return;
@@ -10621,8 +10610,9 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           if (initial.missingRuntime) return initial;
 
           // Handle failure — non-zero exit with text = max_turns or partial success, still usable
-          if (!initial.text && wasResume && initial.code !== 0 && !req.destroyed) {
-            // Resume failed (stale/expired session) — auto-retry as fresh session (skip if client already disconnected)
+          if (!initial.text && wasResume && initial.code !== 0) {
+            // Resume failed (stale/expired session) — auto-retry as fresh. A
+            // briefly disconnected client can reattach to the live turn.
             console.log(`[CC-stream] Resume failed (code=${initial.code}) — retrying fresh`);
             const freshPreamble = buildCCStatePreamble();
             const freshCarryover = _buildTranscriptCarryover(body.transcript, { currentMessage: body.message });
@@ -10672,11 +10662,6 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         // treating an empty `text` as a failure. A genuinely empty turn has
         // both text and raw empty.
         if ((!result.text && !result.raw) || result.error) {
-          if (req.destroyed) {
-            _ccStreamEnded = true;
-            _logCcStreamEnd(_ccTelemetry, 'llm-empty-client-gone', { code: result.code });
-            return;
-          }
           // W-mpmwxni2000c25c7-b — surface the typed error envelope as a
           // distinct SSE `event: error` frame so the client renders a real
           // error UI (with a retry hint derived from `retriable`) instead of
@@ -11316,20 +11301,18 @@ What would you like to discuss or change? When you're happy, say "approve" and I
               knownForResolved = new Set(list.models.map(m => m.id || m.name).filter(Boolean));
             }
           } catch { /* unknown runtime */ }
-          if (knownForResolved && !knownForResolved.has(runtimeModelStr)) {
-            return `not a valid model for runtime "${resolvedRuntime}" (known: ${[...knownForResolved].slice(0, 4).join(', ')}${knownForResolved.size > 4 ? '…' : ''})`;
-          }
-          if (!knownForResolved) {
-            // Free-text runtime (Claude). Reject only if the raw model belongs to a different runtime's published list.
-            for (const rt of _engineRuntimes.listRuntimes()) {
-              if (rt === resolvedRuntime) continue;
-              try {
-                const otherList = await _engineModelDiscovery.getRuntimeModels(rt, { config });
-                if (Array.isArray(otherList?.models) && otherList.models.some(m => (m.id || m.name) === modelStr)) {
-                  return `belongs to runtime "${rt}" but resolved runtime is "${resolvedRuntime}" — incompatible combination`;
-                }
-              } catch { /* skip */ }
-            }
+          if (knownForResolved && knownForResolved.has(runtimeModelStr)) return null;
+          // Catalogs lag staged releases and local/custom providers. Unknown is
+          // therefore allowed, but a model positively published by a different
+          // runtime remains an actionable incompatible-combination error.
+          for (const rt of _engineRuntimes.listRuntimes()) {
+            if (rt === resolvedRuntime) continue;
+            try {
+              const otherList = await _engineModelDiscovery.getRuntimeModels(rt, { config });
+              if (Array.isArray(otherList?.models) && otherList.models.some(m => (m.id || m.name) === modelStr)) {
+                return `belongs to runtime "${rt}" but resolved runtime is "${resolvedRuntime}" — incompatible combination`;
+              }
+            } catch { /* skip */ }
           }
           return null;
         }
@@ -11486,15 +11469,11 @@ What would you like to discuss or change? When you're happy, say "approve" and I
               const resolvedCli = config.agents[id].cli || config.engine.defaultCli || 'copilot';
               const runtimeModelStr = _resolveModelForRuntime(candidate, resolvedCli);
               const knownModels = await _modelsFor(resolvedCli);
-              // Two validation paths:
-              //   1. If the runtime publishes a model list, enforce membership.
-              //   2. If the runtime doesn't (Claude), still reject when the
-              //      model belongs to a DIFFERENT runtime's list — that's how
-              //      we catch claude+gpt-5.5 (gpt-5.5 is in Copilot's list).
+              // Published membership is a positive signal, not a closed enum:
+              // staged releases/custom providers can legitimately be absent.
+              // Still reject IDs positively owned by a different runtime.
               let rejection = null;
-              if (knownModels && !knownModels.has(runtimeModelStr)) {
-                rejection = `not a valid model for runtime "${resolvedCli}" (known: ${[...knownModels].slice(0, 4).join(', ')}${knownModels.size > 4 ? '…' : ''})`;
-              } else if (!knownModels) {
+              if (!knownModels || !knownModels.has(runtimeModelStr)) {
                 const owner = await _ownerOfModel(candidate);
                 if (owner && owner !== resolvedCli) {
                   rejection = `belongs to runtime "${owner}" but agent uses "${resolvedCli}" — incompatible combination`;

package/engine/llm.js

@@ -591,8 +591,9 @@ function _createStreamAccumulator({
       if (!id || !onToolUpdate) return;
       onToolUpdate(id, status);
     },
-    toolUseAlreadySeen(name, input) {
+    toolUseAlreadySeen(name, input, id = null) {
       if (!name) return false;
+      if (id) return toolUses.some(t => t.id === id);
       const stringified = JSON.stringify(input || {});
       return toolUses.some(t => t.name === name && JSON.stringify(t.input) === stringified);
     },

package/engine/model-discovery.js

@@ -99,6 +99,13 @@ async function getRuntimeModels(runtimeName, { force = false, ttlMs = MODEL_CACH
   }
 
   const cachePath = adapter.modelsCache || null;
+  // Runtime catalogs are versioned with the CLI that produced them. Codex in
+  // particular ships new bundled model IDs with CLI releases, so a one-hour
+  // time-only cache otherwise hides new models immediately after an upgrade.
+  let modelCacheKey = null;
+  if (typeof adapter.getModelCacheKey === 'function') {
+    try { modelCacheKey = await adapter.getModelCacheKey(); } catch { /* optional hint */ }
+  }
 
   // Cache hit path — only on non-forced reads. We accept any cached payload
   // whose `cachedAt` parses to a valid timestamp within the TTL window;
@@ -110,7 +117,8 @@ async function getRuntimeModels(runtimeName, { force = false, ttlMs = MODEL_CACH
       const ts = Date.parse(cached.cachedAt);
       if (Number.isFinite(ts)) {
         const age = Date.now() - ts;
-        if (age >= 0 && age < ttlMs) {
+        const versionMatches = !modelCacheKey || cached.modelCacheKey === modelCacheKey;
+        if (age >= 0 && age < ttlMs && versionMatches) {
           const models = Array.isArray(cached.models) ? cached.models : null;
           return { runtime: runtimeName, models, cachedAt: cached.cachedAt };
         }
@@ -134,7 +142,12 @@ async function getRuntimeModels(runtimeName, { force = false, ttlMs = MODEL_CACH
 
   const cachedAt = new Date().toISOString();
   if (cachePath) {
-    _writeCacheFile(cachePath, { runtime: runtimeName, models, cachedAt });
+    _writeCacheFile(cachePath, {
+      runtime: runtimeName,
+      models,
+      cachedAt,
+      ...(modelCacheKey ? { modelCacheKey } : {}),
+    });
   }
   return { runtime: runtimeName, models, cachedAt };
 }

package/engine/queries.js

@@ -758,6 +758,8 @@ function getAgents(config) {
     const s = getAgentStatus(a.id); // derives from dispatch.json
 
     let lastAction = 'Waiting for assignment';
+    let lastActionPrefix = null;
+    let lastActionAt = null;
     // Show the dispatch task as a stable label for the whole run — don't swap
     // in the transient per-tool-call `_runningToolDescription`, which reads like
     // a task change to operators (e.g. an agent's own "Wait until temp dirs
@@ -768,17 +770,23 @@ function getAgents(config) {
     else if (s.status === 'error') lastAction = `Error: ${s.task}`;
     else if (steeringInboxFiles.length > 0) {
       const lastSteer = steeringInboxFiles[steeringInboxFiles.length - 1];
-      lastAction = `Pending steering: ${lastSteer.file} (${timeSince(lastSteer.createdAtMs)})`;
+      lastActionPrefix = `Pending steering: ${lastSteer.file}`;
+      lastActionAt = lastSteer.createdAtMs;
+      lastAction = `${lastActionPrefix} (${timeSince(lastActionAt)})`;
     }
     else if (inboxFiles.length > 0) {
       const lastOutput = path.join(INBOX_DIR, inboxFiles[inboxFiles.length - 1]);
-      try { lastAction = `Output: ${path.basename(lastOutput)} (${timeSince(fs.statSync(lastOutput).mtimeMs)})`; } catch { /* optional */ }
+      try {
+        lastActionPrefix = `Output: ${path.basename(lastOutput)}`;
+        lastActionAt = fs.statSync(lastOutput).mtimeMs;
+        lastAction = `${lastActionPrefix} (${timeSince(lastActionAt)})`;
+      } catch { /* optional */ }
     }
 
     const chartered = fs.existsSync(path.join(AGENTS_DIR, a.id, 'charter.md'));
     if (lastAction.length > 120) lastAction = lastAction.slice(0, 120) + '...';
     return {
-      ...a, runtime, model, status: s.status, lastAction,
+      ...a, runtime, model, status: s.status, lastAction, lastActionPrefix, lastActionAt,
       // Descriptive capability tags; tolerate legacy `skills` configs by
       // normalizing to `expertise` for the dashboard/settings UI.
       expertise: a.expertise ?? a.skills ?? [],

package/engine/runtimes/codex.js

@@ -320,6 +320,17 @@ function _normalizeConfigOverrides(configOverrides) {
   return [];
 }
 
+const _MIME_EXT = {
+  'image/png': 'png',
+  'image/jpeg': 'jpg',
+  'image/gif': 'gif',
+  'image/webp': 'webp',
+};
+
+function _mimeToExt(mimeType) {
+  return _MIME_EXT[String(mimeType || '').toLowerCase()] || 'bin';
+}
+
 function buildArgs(opts = {}) {
   const {
     model,
@@ -329,11 +340,13 @@ function buildArgs(opts = {}) {
     sandbox = 'workspace-write',
     skipGitRepoCheck = true,
     configOverrides,
+    images,
+    tmpDir,
   } = opts;
 
   const args = ['exec'];
-  if (sessionId) args.push('resume', String(sessionId));
-
+  // These are `exec` options, not `exec resume` options. Codex's resume
+  // parser rejects flags such as --color and --sandbox after the subcommand.
   args.push('--json', '--color', 'never');
   if (model) args.push('--model', String(model));
   if (sandbox) args.push('--sandbox', String(sandbox));
@@ -347,6 +360,20 @@ function buildArgs(opts = {}) {
     args.push('--config', override);
   }
 
+  if (sessionId) args.push('resume', String(sessionId));
+
+  // Codex accepts repeatable --image paths on fresh and resumed turns. The
+  // call-scoped tmpDir is removed by engine/llm.js after the process exits.
+  if (Array.isArray(images) && images.length && tmpDir) {
+    for (let i = 0; i < images.length; i++) {
+      const img = images[i];
+      if (!img || !img.dataBase64) continue;
+      const filePath = path.join(tmpDir, `img-${i}.${_mimeToExt(img.mimeType)}`);
+      fs.writeFileSync(filePath, Buffer.from(img.dataBase64, 'base64'));
+      args.push('--image', filePath);
+    }
+  }
+
   args.push('-');
   return args;
 }
@@ -544,6 +571,21 @@ function _extractToolUse(obj) {
   const itemType = String(item?.type || '');
   if (!/tool|function|command|web_search/i.test(type) && !/tool|command|web_search/i.test(itemType)) return null;
   const data = item || obj.data || obj;
+  const id = _pickString(data.id, obj?.item_id, obj?.itemId, obj?.data?.item_id);
+  const rawStatus = String(data.status || obj?.status || '').toLowerCase();
+  const status = /fail|error|cancel/.test(rawStatus) ? 'failed'
+    : /complete|success/.test(rawStatus) ? 'completed'
+      : null;
+
+  if (/command_execution/i.test(itemType)) {
+    const command = _pickString(data.command, data.input);
+    if (!command) return null;
+    return { name: 'Bash', input: { command }, id: id || null, status };
+  }
+  if (/web_search/i.test(itemType)) {
+    const query = _pickString(data.query, data.input, data.arguments);
+    return { name: 'WebSearch', input: query ? { query } : {}, id: id || null, status };
+  }
   const name = _pickString(
     data.tool_name,
     data.toolName,
@@ -555,7 +597,7 @@ function _extractToolUse(obj) {
   );
   if (!name) return null;
   const input = data.arguments || data.args || data.input || data.function?.arguments || {};
-  return { name, input };
+  return { name, input, id: id || null, status };
 }
 
 function _usageFrom(obj) {
@@ -675,6 +717,17 @@ function parseError(rawOutput) {
   if (!text) return { message: '', code: null, retriable: true };
   const lower = text.toLowerCase();
 
+  if (/requires a newer version of codex|upgrade to the latest (?:app or )?cli|codex (?:cli )?is (?:too old|out of date)/i.test(text)) {
+    const name = _extractInvalidModelName(text)
+      || (text.match(/['"`]([A-Za-z0-9._\/-]+)['"`]/)?.[1])
+      || 'configured model';
+    return {
+      message: `The installed Codex CLI is too old for model "${name}". Upgrade Codex, refresh the model list, and try again.`,
+      code: 'config-error',
+      retriable: false,
+    };
+  }
+
   const hasAuth = /not authenticated|login required|please.*log.*in|api key.*invalid|invalid api key|\bunauthorized\b|\b401\b|\b403\b/i.test(text);
   if (hasAuth) {
     return { message: 'Codex authentication failed - run `codex login` or configure an OpenAI API key, then try again.', code: 'auth-failure', retriable: false };
@@ -773,6 +826,20 @@ async function listModels({ env = process.env, timeoutMs = 10000 } = {}) {
   }
 }
 
+function getModelCacheKey({ env = process.env, timeoutMs = 10000 } = {}) {
+  const resolved = resolveBinary({ env });
+  if (!resolved) return null;
+  try {
+    return _execFileCapture(resolved.bin, [...(resolved.leadingArgs || []), '--version'], {
+      env,
+      timeoutMs,
+      native: resolved.native,
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
 function createStreamConsumer(ctx) {
   let deltaText = '';
   let terminalText = '';
@@ -789,7 +856,11 @@ function createStreamConsumer(ctx) {
     if (/reasoning|thinking/i.test(type)) ctx.notifyThinking();
 
     const toolUse = _extractToolUse(obj);
-    if (toolUse) ctx.pushToolUse(toolUse.name, toolUse.input);
+    if (toolUse) {
+      const seen = ctx.toolUseAlreadySeen(toolUse.name, toolUse.input, toolUse.id);
+      if (!seen) ctx.pushToolUse(toolUse.name, toolUse.input, toolUse.id);
+      if (toolUse.id && toolUse.status) ctx.updateToolUse(toolUse.id, toolUse.status);
+    }
 
     const delta = _extractDelta(obj);
     if (delta) {
@@ -823,6 +894,9 @@ const capabilities = {
   costTracking: false,
   modelShorthands: false,
   modelDiscovery: true,
+  // Bundled catalogs can lag staged/custom model availability. Let Codex
+  // validate unknown IDs so it can return its precise version/provider error.
+  strictModelCatalog: false,
   promptViaArg: false,
   budgetCap: false,
   bareMode: false,
@@ -830,9 +904,7 @@ const capabilities = {
   sessionPersistenceControl: false,
   resumePromptCarryover: true,
   streamConsumer: true,
-  // P-7b2e4d01: no image-input mechanism (CLI not installed during spike
-  // P-3f8a1c92). Engine code gates on this flag, never on runtime.name.
-  imageInput: false,
+  imageInput: true,
 };
 
 const INSTALL_HINT = 'install Codex CLI with `npm install -g @openai/codex` or `brew install --cask codex`, then run `codex login`.';
@@ -844,6 +916,7 @@ module.exports = {
   resolveBinary,
   capsFile: CAPS_FILE,
   listModels,
+  getModelCacheKey,
   modelsCache: MODELS_CACHE,
   spawnScript: path.join(ENGINE_DIR, 'spawn-agent.js'),
   installHint: INSTALL_HINT,
@@ -878,5 +951,6 @@ module.exports = {
   _extractModelsFromCatalog,
   _readCatalogIds,
   _extractInvalidModelName,
+  _extractToolUse,
   CAPS_SCHEMA_VERSION,
 };

package/package.json

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