@yemi33/minions 0.1.2046 → 0.1.2047

package/dashboard/js/render-prs.js

@@ -22,6 +22,16 @@ function _countPrFollowups(pr) {
   return n;
 }
 
+// W-mpmwxkzm0009ba0b — Parse a canonical PR id like `github:octo/repo#123`
+// or `ado:org/proj/repo#456` into the {host, slug, number} triple used by
+// POST /api/pull-requests/observe. Returns null when the id doesn't match.
+function _parseCanonicalPrId(id) {
+  if (!id || typeof id !== 'string') return null;
+  var m = id.match(/^(github|ado):(.+)#(\d+)$/);
+  if (!m) return null;
+  return { host: m[1], slug: m[2], number: parseInt(m[3], 10) };
+}
+
 function prRow(pr) {
   // Minions review (agent) state — separate from ADO human review
   const sq = pr.minionsReview || {};
@@ -61,6 +71,29 @@ function prRow(pr) {
         ? '<span class="pr-agent" title="' + escapeHtml(pr.reviewedBy.join(', ')) + '">' + escapeHtml(pr.reviewedBy.join(', ')) + '</span>'
         : '<span style="color:var(--muted);font-size:11px">—</span>';
   const createdLabel = (pr.created || '—').slice(0, 16).replace('T', ' ');
+  // Per-row auto-observe toggle (W-mpmwxkzm0009ba0b). _contextOnly === true
+  // means the engine polls status/comments but does NOT dispatch review/fix
+  // agents against this PR. Default (undefined / false) = observed.
+  var observe = pr._contextOnly !== true;
+  var observeClass = observe ? 'pr-observe-on' : 'pr-observe-off';
+  var observeLabel = observe ? 'observed' : 'context';
+  var observeTitle = observe
+    ? 'Auto-observe ON — engine reviews this PR and dispatches fix agents on review/build feedback. Click to switch to context-only.'
+    : 'Context only — engine polls status and comments but will not dispatch review/fix agents. Click to enable auto-observe.';
+  // pr.id is canonical: "<host>:<slug>#<number>" (engine/shared.js getCanonicalPrId).
+  // Parse here so the toggle handler can post {host, slug, number} without
+  // shipping additional fields per row.
+  var observeBtn = '';
+  var idMatch = typeof pr.id === 'string' ? pr.id.match(/^([^:]+):(.+)#(\d+)$/) : null;
+  if (idMatch) {
+    observeBtn = '<button class="pr-observe-toggle ' + observeClass + '" '
+      + 'data-pr-host="' + escapeHtml(idMatch[1]) + '" '
+      + 'data-pr-slug="' + escapeHtml(idMatch[2]) + '" '
+      + 'data-pr-number="' + escapeHtml(idMatch[3]) + '" '
+      + 'data-pr-observe="' + (observe ? '1' : '0') + '" '
+      + 'title="' + escapeHtml(observeTitle) + '" '
+      + 'onclick="event.stopPropagation();togglePrObserve(this)">' + observeLabel + '</button> ';
+  }
   // Title attrs live on the inner element (link/span/badge) so hovering the
   // ellipsis-truncated content reveals the full text. Cell tags stay bare so
   // the header-to-cell count assertion in test/unit.test.js continues to
@@ -74,6 +107,7 @@ function prRow(pr) {
     '<td>' + reviewerCell + '</td>' +
     '<td><span class="pr-badge ' + buildClass + '" title="' + escapeHtml(buildTitle || buildLabel) + '">' + escapeHtml(buildLabel) + '</span></td>' +
     '<td><span class="pr-badge ' + statusClass + '" title="' + escapeHtml(statusLabel) + '">' + escapeHtml(statusLabel) + '</span></td>' +
+    '<td>' + (observeBtn || '<span style="color:var(--muted);font-size:11px">—</span>') + '</td>' +
     '<td><span class="pr-date" title="' + escapeHtml(createdLabel) + '">' + escapeHtml(createdLabel) + '</span></td>' +
     '<td><button class="pr-pager-btn" style="font-size:9px;padding:1px 5px;color:var(--red);border-color:var(--red)" data-pr-id="' + escapeHtml(String(prId)) + '" onclick="event.stopPropagation();unlinkPr(this.dataset.prId)" title="Remove from tracking">x</button></td>' +
     '</tr>';
@@ -93,6 +127,7 @@ const PRS_COLGROUP =
     '<col style="width:140px">' +   // Signed Off By
     '<col style="width:130px">' +   // Build
     '<col style="width:110px">' +   // Status
+    '<col style="width:100px">' +   // Observe
     '<col style="width:130px">' +   // Created
     '<col style="width:50px">' +    // Actions
   '</colgroup>';
@@ -101,7 +136,7 @@ function prTableHtml(rows) {
   return '<div class="pr-table-wrap pr-table-wrap--prs"><table class="pr-table pr-table--prs">' +
     PRS_COLGROUP +
     '<thead><tr>' +
-    '<th>PR</th><th>Title</th><th>Agent</th><th>Branch</th><th>Review</th><th>Signed Off By</th><th>Build</th><th>Status</th><th>Created</th><th></th>' +
+    '<th>PR</th><th>Title</th><th>Agent</th><th>Branch</th><th>Review</th><th>Signed Off By</th><th>Build</th><th>Status</th><th>Observe</th><th>Created</th><th></th>' +
     '</tr></thead><tbody>' + rows + '</tbody></table></div>';
 }
 
@@ -249,4 +284,49 @@ async function unlinkPr(id) {
   } catch (e) { clearDeleted('pr:' + id); showToast('pr-toast', 'Error: ' + e.message, false); refresh(); }
 }
 
-window.MinionsPrs = { prRow, prTableHtml, renderPrs, prPrev, prNext, openAllPrs, openModal, openAddPrModal, unlinkPr };
+// Per-row auto-observe toggle (W-mpmwxkzm0009ba0b). Optimistic UI: flip
+// the button immediately, only revert on API error. The engine consumes
+// `_contextOnly` to gate review/fix dispatch (engine/shared.js
+// isAutoManagedPrRecord + discoverFromPrs).
+async function togglePrObserve(btn) {
+  if (!btn || btn.disabled) return;
+  const host = btn.dataset.prHost;
+  const slug = btn.dataset.prSlug;
+  const number = parseInt(btn.dataset.prNumber, 10);
+  if (!host || !slug || !Number.isFinite(number)) return;
+  const wasObserve = btn.dataset.prObserve === '1';
+  const next = !wasObserve;
+  // Optimistic flip
+  btn.dataset.prObserve = next ? '1' : '0';
+  btn.classList.toggle('pr-observe-on', next);
+  btn.classList.toggle('pr-observe-off', !next);
+  btn.textContent = next ? 'observed' : 'context';
+  btn.disabled = true;
+  try {
+    const res = await fetch('/api/pull-requests/observe', {
+      method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ host, slug, number, observe: next })
+    });
+    if (!res.ok) {
+      const d = await res.json().catch(() => ({}));
+      // Revert
+      btn.dataset.prObserve = wasObserve ? '1' : '0';
+      btn.classList.toggle('pr-observe-on', wasObserve);
+      btn.classList.toggle('pr-observe-off', !wasObserve);
+      btn.textContent = wasObserve ? 'observed' : 'context';
+      showToast('pr-toast', 'Failed: ' + (d.error || 'unknown'), false);
+      return;
+    }
+    showToast('pr-toast', next ? 'Auto-observe enabled' : 'Switched to context only', true);
+  } catch (e) {
+    btn.dataset.prObserve = wasObserve ? '1' : '0';
+    btn.classList.toggle('pr-observe-on', wasObserve);
+    btn.classList.toggle('pr-observe-off', !wasObserve);
+    btn.textContent = wasObserve ? 'observed' : 'context';
+    showToast('pr-toast', 'Error: ' + e.message, false);
+  } finally {
+    btn.disabled = false;
+  }
+}
+
+window.MinionsPrs = { prRow, prTableHtml, renderPrs, prPrev, prNext, openAllPrs, openModal, openAddPrModal, unlinkPr, togglePrObserve };

package/dashboard/styles.css

@@ -322,6 +322,17 @@
   .pr-page-info { font-size: var(--text-base); color: var(--muted); }
   .pr-date { font-size: var(--text-base); color: var(--muted); }
 
+  .pr-observe-toggle {
+    font-size: 9px; padding: 1px 6px; border-radius: var(--radius-sm); cursor: pointer;
+    text-transform: uppercase; letter-spacing: 0.5px; font-weight: 600;
+    background: var(--surface2); transition: all var(--transition-base);
+  }
+  .pr-observe-toggle:disabled { opacity: 0.6; cursor: wait; }
+  .pr-observe-toggle.pr-observe-on { color: var(--green); border: 1px solid var(--green); background: rgba(63,185,80,0.12); }
+  .pr-observe-toggle.pr-observe-on:hover:not(:disabled) { background: rgba(63,185,80,0.22); }
+  .pr-observe-toggle.pr-observe-off { color: var(--muted); border: 1px dashed var(--border); }
+  .pr-observe-toggle.pr-observe-off:hover:not(:disabled) { color: var(--text); border-color: var(--text); }
+
   .archive-btn {
     background: var(--surface2); border: 1px solid var(--border); color: var(--muted);
     font-size: var(--text-base); padding: var(--space-2) var(--space-5); border-radius: var(--radius-sm); cursor: pointer; transition: all var(--transition-base); margin-left: auto;

package/dashboard.js

@@ -855,6 +855,67 @@ function linkPullRequestForTracking({ url, title, project: projectName, autoObse
   return { ...result, prPath, targetProject, projectResolution, prNum };
 }
 
+// W-mpmwxkzm0009ba0b — Per-row auto-observe toggle backing helper for
+// POST /api/pull-requests/observe. Flips `_contextOnly` / `_autoObserve` on
+// an existing tracked PR record under a lock (per CLAUDE.md mutate convention).
+// Body shape: { host: 'github'|'ado', slug, number, observe: boolean }.
+// Returns the updated record + the PR path that was touched. Throws an
+// Error with `statusCode` for the route handler to map to an HTTP status.
+function updatePullRequestObserveFlag({ host, slug, number, observe } = {}, config = CONFIG, minionsDir = MINIONS_DIR) {
+  const hostStr = String(host || '').trim().toLowerCase();
+  const slugStr = String(slug || '').trim();
+  const numberInt = Number.parseInt(number, 10);
+  if (!hostStr || (hostStr !== 'github' && hostStr !== 'ado')) {
+    const err = new Error('host must be "github" or "ado"');
+    err.statusCode = 400;
+    throw err;
+  }
+  if (!slugStr) {
+    const err = new Error('slug required');
+    err.statusCode = 400;
+    throw err;
+  }
+  if (!Number.isFinite(numberInt) || numberInt <= 0) {
+    const err = new Error('number must be a positive integer');
+    err.statusCode = 400;
+    throw err;
+  }
+  if (typeof observe !== 'boolean') {
+    const err = new Error('observe must be a boolean');
+    err.statusCode = 400;
+    throw err;
+  }
+
+  const canonicalId = `${hostStr}:${slugStr}#${numberInt}`;
+  const projects = shared.getProjects(config);
+  const prPaths = [
+    ...projects.map(p => shared.projectPrPath(p)),
+    shared.centralPullRequestsPath(minionsDir),
+  ];
+
+  let updated = null;
+  let updatedPath = null;
+  for (const prPath of prPaths) {
+    if (updated) break;
+    shared.mutatePullRequests(prPath, (prs) => {
+      const pr = prs.find(p => p && p.id === canonicalId);
+      if (!pr) return prs;
+      pr._contextOnly = !observe;
+      pr._autoObserve = !!observe;
+      updated = { id: pr.id, _contextOnly: pr._contextOnly, _autoObserve: pr._autoObserve };
+      updatedPath = prPath;
+      return prs;
+    });
+  }
+
+  if (!updated) {
+    const err = new Error(`pull request ${canonicalId} not found`);
+    err.statusCode = 404;
+    throw err;
+  }
+  return { ...updated, prPath: updatedPath };
+}
+
 function _normalizeSkillDirForCompare(dir) {
   const resolved = path.resolve(String(dir || '').replace(/\//g, path.sep));
   return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
@@ -1173,48 +1234,13 @@ function _getDashboardBrowserPresence(now = Date.now()) {
   return { active: activeTabs.length > 0, activeTabs: activeTabs.length, maxAgeMs: DASHBOARD_BROWSER_PRESENCE_MAX_AGE_MS };
 }
 
-// Hot-reload: watch dashboard/ directory for changes, rebuild, and push reload to browsers
-const _hotReloadClients = new Set();
-
-function rebuildDashboardHtml() {
-  try {
-    const newRaw = buildDashboardHtml();
-    if (newRaw === HTML_RAW) return; // no changes
-    HTML_RAW = newRaw;
-    HTML = HTML_RAW;
-    HTML_GZ = zlib.gzipSync(HTML);
-    HTML_ETAG = '"' + require('crypto').createHash('md5').update(HTML).digest('hex') + '"';
-    // Bust the /api/status cache so the new dashboardBuildId propagates on the
-    // next poll — refresh.js compares it against its first-observed value and
-    // hard-reloads on mismatch (R3, W-mpgb0xgc000hf1d3).
-    try { invalidateStatusCache(); } catch { /* status cache may not be initialized yet */ }
-    console.log('  Dashboard hot-reloaded');
-    // Push reload to all connected browsers via status-stream (saves a connection)
-    for (const res of _statusStreamClients) {
-      try { res.write('event: reload\ndata: reload\n\n'); } catch { _removeSseClient(_statusStreamClients, res); }
-    }
-    // Legacy hot-reload clients
-    for (const res of _hotReloadClients) {
-      try { res.write('data: reload\n\n'); } catch { _removeSseClient(_hotReloadClients, res); }
-    }
-  } catch (e) { console.error('  Hot-reload error:', e.message); }
-}
-
-const dashDir = path.join(MINIONS_DIR, 'dashboard');
-if (fs.existsSync(dashDir)) {
-  let _reloadTimer = null;
-  const scheduleReload = () => {
-    if (_reloadTimer) clearTimeout(_reloadTimer);
-    _reloadTimer = setTimeout(rebuildDashboardHtml, 300); // debounce 300ms
-  };
-  // Watch top-level files (styles.css, layout.html)
-  try { fs.watch(dashDir, scheduleReload); } catch { /* optional */ }
-  // Watch subdirectories (pages/, js/)
-  for (const sub of ['pages', 'js']) {
-    const subDir = path.join(dashDir, sub);
-    if (fs.existsSync(subDir)) try { fs.watch(subDir, scheduleReload); } catch { /* optional */ }
-  }
-}
+// Hot-reload removed (2026-05-26): file-watch-driven rebuilds force-reloaded
+// every connected browser on any change under dashboard/, which surprised
+// users when parallel agent merges touched dashboard.js or dashboard/js/*.
+// The dashboard HTML is now assembled once at process boot. Code changes on
+// disk land in the running process only after an explicit `minions restart`;
+// the buildId/startedAt mismatch in refresh.js then triggers a one-shot
+// browser reload on that next poll — driven by user-initiated restart only.
 
 // -- Data Collectors (most moved to engine/queries.js) --
 
@@ -4095,7 +4121,13 @@ function _recoverPartialDocChatResponse(result, sessionKey) {
 
 function _shouldSuppressDocChatPostPatchError(ccError, finalize) {
   if (!finalize || finalize.edited !== true) return false;
-  if (!ccError || ccError.errorClass !== 'unknown-model') return false;
+  if (!ccError) return false;
+  // W-mpmwxni2000c25c7-a — accept both the legacy 'unknown-model' errorClass
+  // (still emitted by the dashboard preflight at _preflightModelCheck) and
+  // the new 'model-unavailable' code returned by copilot.parseError for
+  // invalid-model responses. Suppress in either case — the edit already
+  // landed, so the stale model error shouldn't surface to the user.
+  if (ccError.errorClass !== 'unknown-model' && ccError.errorClass !== 'model-unavailable') return false;
   return String(ccError.runtime || '').toLowerCase() === 'copilot';
 }
 
@@ -9994,12 +10026,6 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     { method: 'GET', path: '/api/qa/runs', desc: 'List QA validation runs (newest first). Optional ?limit=N and ?status=pending|running|passed|failed|errored filters.', handler: handleQaRunsList },
     { method: 'GET', path: /^\/api\/qa\/runs\/([^/?]+)$/, template: '/api/qa/runs/<id>', desc: 'Fetch a single QA run record by id.', handler: handleQaRunsById },
     { method: 'GET', path: /^\/api\/qa\/artifacts\/([^/?]+)\/([^?]+)$/, template: '/api/qa/artifacts/<runId>/<file>', desc: 'Serve a QA artifact file (image/video/log). Sandboxed to engine/qa-artifacts/; rejects path traversal with 403.', handler: handleQaArtifact },
-    { method: 'GET', path: '/api/hot-reload', desc: 'SSE stream for dashboard hot-reload notifications', handler: (req, res) => {
-      res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' });
-      res.write('data: connected\n\n');
-      _trackSseClient(_hotReloadClients, req, res);
-    }},
-
     // QA Runbooks (W-mpeiwz6k0005bf34-a) — per-project test plans stored at
     // <MINIONS_DIR>/projects/<name>/runbooks/<id>.json. Pure persistence —
     // dispatch + run records + UI live in follow-up plan items.
@@ -10222,6 +10248,18 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       })();
     }},
 
+    { method: 'POST', path: '/api/pull-requests/observe', desc: 'Toggle auto-observe (_contextOnly flag) on a tracked PR', params: 'host (github|ado), slug, number, observe (boolean)', handler: async (req, res) => {
+      const body = await readBody(req);
+      reloadConfig();
+      try {
+        const result = updatePullRequestObserveFlag(body, CONFIG);
+        invalidateStatusCache();
+        return jsonReply(res, 200, { ok: true, ...result, observe: !result._contextOnly });
+      } catch (e) {
+        return jsonReply(res, e.statusCode || 400, { error: e.message });
+      }
+    }},
+
     { method: 'POST', path: '/api/pull-requests/delete', desc: 'Remove a PR from tracking', params: 'id, project?', handler: async (req, res) => {
       const body = await readBody(req);
       const { id } = body;
@@ -10831,6 +10869,7 @@ module.exports = {
   _buildDocChatResponsePayload,
   _inferDocChatProject,
   _linkPullRequestForTracking: linkPullRequestForTracking,
+  _updatePullRequestObserveFlag: updatePullRequestObserveFlag,
   _resolveSkillReadPath,
   // Per-CC-turn correlation surface
   _ccTurnCreations,

package/docs/copilot-cli-schema.md

@@ -614,8 +614,9 @@ When implementing `engine/runtimes/copilot.js`:
    should still parse cleanly — let the consumer decide to ignore.
 9. `parseError(rawOutput)` patterns:
    - `auth-failure`: `/not authenticated|copilot login|401|403/i`
+   - `model-unavailable` (retriable=false): `/unknown model|model not found|invalid model|model_not_found|400.*model/i` — message includes the cached model catalog (`_warmModelCache` populates `_modelDiscoveryResults` from `listModels()` ahead of time so the error path stays sync). Falls back to "Configure a valid model in Settings → Engine." when the cache is empty.
+   - `model-unavailable` (retriable=true): `/overloaded_error|service_unavailable|503|temporarily unavailable/i` — engine retries with `engine.copilotFallbackModel`.
    - `rate-limit`: `/rate limit|too many requests|429/i`
-   - `unknown-model`: `/unknown model|model not found|model.*invalid/i`
    - `crash`: `/internal error|panic|uncaught/i`
 10. `listModels()` per §6 — return `null` on any failure (network, parse, auth).
     `modelsCache` path: `engine/copilot-models.json`.

package/docs/runtime-adapters.md

@@ -49,7 +49,7 @@ methods that genuinely differ.
 | `modelLooksFamiliar(model)` | boolean | Heuristic powering the preflight "stale model after CLI switch" warning. |
 | `parseOutput(raw)` | `{ text, usage, sessionId, model }` | Final-event parser. |
 | `parseStreamChunk(line)` | event object or null | Single JSONL line → typed event. |
-| `parseError(rawOutput)` | `{ message, code, retriable }` | Codes: `auth-failure`, `context-limit`, `budget-exceeded`, `crash`, null. |
+| `parseError(rawOutput)` | `{ message, code, retriable }` | Codes: `auth-failure`, `context-limit`, `budget-exceeded`, `model-unavailable` (retriable=true for upstream overload/503; retriable=false for invalid/typo'd model id — Copilot enriches the message via `_warmModelCache()` so it lists the available models), `crash`, null. |
 | `createStreamConsumer(ctx)` | consumer object | Stream accumulator used by `engine/llm.js`. |
 | `detectPermissionGate`, `getPromptDeliveryMode`, `usesSystemPromptFile`, `classifyFailure` | misc | Adapter-owned policy that engine code reads through accessors instead of branching on `runtime.name`. |
 

package/engine/queries.js

@@ -1930,14 +1930,25 @@ function getProjectGitStatus(localPath, configuredMainBranch = null) {
   // the pre-pull ahead/behind counts for up to 15s + one SPA poll (~19s
   // user-visible lag) because the rebuilt fast-state still hits this
   // cache and never schedules a refresh until the TTL itself expires.
-  if (cached && cached.ts && (now - cached.ts) < PROJECT_GIT_STATUS_TTL
+  // Revalidate a cached MISSING value via a cheap existsSync. The snapshot-
+  // based freshness check below can't detect "directory came back" because
+  // there was no `.git` to snapshot when we wrote MISSING — without this
+  // gate the cache pins MISSING for the full 15s TTL after the path is
+  // recreated.
+  const cachedIsMissing = cached && cached.value === PROJECT_GIT_STATUS_MISSING;
+  if (cachedIsMissing && fs.existsSync(localPath)) {
+    // Path came back — fall through to schedule a fresh probe.
+  } else if (cached && cached.ts && (now - cached.ts) < PROJECT_GIT_STATUS_TTL
       && !_projectGitRefsAdvancedSince(localPath, configuredMainBranch, cached.refMtimes)) {
     return cached.value;
   }
   // Cheap synchronous existsSync — short-circuits a path that just disappeared
-  // (project removed) without scheduling a useless git probe.
+  // (project removed) without scheduling a useless git probe. `refMtimes: null`
+  // keeps the entry shape uniform with entries produced by
+  // `_scheduleProjectGitStatusRefresh` so the freshness check above always
+  // sees a defined field.
   if (!fs.existsSync(localPath)) {
-    _projectGitStatusCache.set(key, { ts: now, value: PROJECT_GIT_STATUS_MISSING, promise: null });
+    _projectGitStatusCache.set(key, { ts: now, value: PROJECT_GIT_STATUS_MISSING, promise: null, refMtimes: null });
     return PROJECT_GIT_STATUS_MISSING;
   }
   // Stale or never-populated — kick off a background refresh and return the

package/engine/runtimes/claude.js

@@ -522,6 +522,27 @@ function parseStreamChunk(line) {
 
 // ── Error Normalization ──────────────────────────────────────────────────────
 
+// Pull a model id out of an Anthropic-style invalid-model error string. Claude
+// CLI surfaces these as either plain stderr ("Unknown model: claude-x") or as
+// the API's structured error body ({"type":"error","error":{"message":
+// "model: claude-x: not a valid model"}}). Returns null when no obvious model
+// token is present — parseError falls back to "unknown" in that case.
+function _extractInvalidModelName(text) {
+  if (!text) return null;
+  const patterns = [
+    /(?:unknown|invalid)\s+model(?:\s+id)?\s*[:=]?\s*['"`]?([A-Za-z0-9._\/-]+)['"`]?/i,
+    /model\s+['"`]([^'"`]+)['"`]\s+(?:not\s+found|is\s+invalid|is\s+unknown|invalid)/i,
+    /model\s*[:=]\s*['"`]?([A-Za-z0-9._\/-]+)['"`]?\s*[:,]\s*(?:not\s+a\s+valid\s+model|not\s+found|invalid)/i,
+    /model\s+(?:not\s+found|invalid|unknown)\s*[:=]?\s*['"`]?([A-Za-z0-9._\/-]+)['"`]?/i,
+    /"model"\s*:\s*"([^"]+)"/i,
+  ];
+  for (const re of patterns) {
+    const m = text.match(re);
+    if (m && m[1]) return m[1];
+  }
+  return null;
+}
+
 /**
  * Inspect raw agent output (stdout/stderr concatenated by the caller) and map
  * common Claude error patterns onto a normalized shape:
@@ -531,6 +552,11 @@ function parseStreamChunk(line) {
  *   - 'auth-failure'      — invalid API key / credit-card / org-blocked
  *   - 'context-limit'     — context window exhausted
  *   - 'budget-exceeded'   — `--max-budget-usd` ceiling hit
+ *   - 'model-unavailable' — model not available. Two flavors distinguished by
+ *                           `retriable`: retriable=true for transient upstream
+ *                           overload (503/overloaded_error — engine retries
+ *                           with `--fallback-model`); retriable=false for an
+ *                           invalid/typo'd model id (user must fix config).
  *   - 'crash'             — CLI crashed (segfault, panic, "Internal error")
  *   - null                — no recognised pattern
  *
@@ -553,6 +579,20 @@ function parseError(rawOutput) {
   if (/budget.*exceed|max.budget.usd.*reach|cost.*limit.*exceed/i.test(lower)) {
     return { message: 'Claude budget cap exceeded — check your Claude account spending limit.', code: 'budget-exceeded', retriable: false };
   }
+  // W-mpmwxni2000c25c7-a — Configured model isn't a valid Anthropic id (typo,
+  // deprecated id, invalid_request_error on `model:` field). Claude has no
+  // listModels() catalog (capabilities.modelDiscovery === false), so the
+  // message points the operator at Settings instead of enumerating ids.
+  // Match BEFORE the overload branch — the overload regex matches
+  // `model.*unavailable` and would otherwise swallow "model X is invalid".
+  if (/unknown\s+model|model\s+not\s+found|invalid\s+model|model_not_found|not\s+a\s+valid\s+model|400[^a-z]+(?:bad\s+request|invalid|model)/i.test(text)) {
+    const name = _extractInvalidModelName(text) || 'unknown';
+    return {
+      message: `Model "${name}" not available for runtime claude. Configure a valid model in Settings → Engine.`,
+      code: 'model-unavailable',
+      retriable: false,
+    };
+  }
   // W-mpg6isvy000xca4d — Anthropic overload / 503 / service-unavailable. Claude's
   // own `--fallback-model` only fires on 429 (rate-limit); these failure modes
   // hang the agent until the 5h timeout. Classify as MODEL_UNAVAILABLE so the
@@ -828,5 +868,6 @@ module.exports = {
   permissionBypassFlags: PERMISSION_BYPASS_FLAGS,
   // Exposed for unit tests — never imported by engine code
   _CLAUDE_SHORTHANDS,
+  _extractInvalidModelName,
   THINKING_BLOCK_TYPES,
 };

package/engine/runtimes/copilot.js

@@ -785,6 +785,58 @@ function parseStreamChunk(line) {
 
 // ── Error Normalization ─────────────────────────────────────────────────────
 
+// In-memory model-discovery cache used by parseError's invalid-model branch
+// (W-mpmwxni2000c25c7-a). parseError is synchronous — to enrich the error
+// message with the live model catalog without adding a per-error HTTP round
+// trip, the engine pre-warms this cache via `_warmModelCache()` (e.g. during
+// preflight or the first listModels() call from the dashboard). Concurrent
+// callers share the in-flight promise so the API is only hit once even when
+// multiple agents fail simultaneously. `_modelDiscoveryResults` stores the
+// resolved catalog (or `[]` on failure); parseError reads it synchronously.
+let _modelDiscoveryResults = null;
+let _modelDiscoveryPromise = null;
+
+async function _warmModelCache(opts = {}) {
+  if (_modelDiscoveryPromise) return _modelDiscoveryPromise;
+  if (Array.isArray(_modelDiscoveryResults)) return _modelDiscoveryResults;
+  _modelDiscoveryPromise = listModels(opts).then(
+    (models) => { _modelDiscoveryResults = Array.isArray(models) ? models : []; return _modelDiscoveryResults; },
+    () => { _modelDiscoveryResults = []; return _modelDiscoveryResults; },
+  );
+  try {
+    return await _modelDiscoveryPromise;
+  } finally {
+    _modelDiscoveryPromise = null;
+  }
+}
+
+function _resetModelCache({ models = null } = {}) {
+  _modelDiscoveryResults = Array.isArray(models) ? models : (models === null ? null : []);
+  _modelDiscoveryPromise = null;
+}
+
+// Pull a model id out of a Copilot/Anthropic-style invalid-model error string.
+// Handles the shapes observed in the wild:
+//   "Unknown model: banana"
+//   "model not found: gpt-5.4"
+//   "model 'gpt-x' is invalid"
+//   "Invalid model id: claude-sonnet"
+//   {"error":"model_not_found","model":"gpt-x"} / {"model":"gpt-x"}
+function _extractInvalidModelName(text) {
+  if (!text) return null;
+  const patterns = [
+    /(?:unknown|invalid)\s+model(?:\s+id)?\s*[:=]?\s*['"`]?([A-Za-z0-9._\/-]+)['"`]?/i,
+    /model\s+['"`]([^'"`]+)['"`]\s+(?:not\s+found|is\s+invalid|is\s+unknown|invalid)/i,
+    /model\s+(?:not\s+found|invalid|unknown)\s*[:=]?\s*['"`]?([A-Za-z0-9._\/-]+)['"`]?/i,
+    /"model"\s*:\s*"([^"]+)"/i,
+  ];
+  for (const re of patterns) {
+    const m = text.match(re);
+    if (m && m[1]) return m[1];
+  }
+  return null;
+}
+
 function _collectErrorSignal(rawOutput) {
   const text = rawOutput == null ? '' : String(rawOutput);
   if (!text) return '';
@@ -835,6 +887,27 @@ function _collectErrorSignal(rawOutput) {
   return sawJsonLine ? '' : text;
 }
 
+function _readModelIdsFromDiskCache() {
+  try {
+    const text = fs.readFileSync(MODELS_CACHE, 'utf8');
+    const obj = JSON.parse(text);
+    if (!obj || !Array.isArray(obj.models)) return null;
+    const ids = obj.models.map(m => m && m.id ? String(m.id) : null).filter(Boolean);
+    return ids.length > 0 ? ids : null;
+  } catch { return null; }
+}
+
+function _resolveCachedModelIds() {
+  // In-memory cache (seeded by `_warmModelCache()` or test `_resetModelCache`)
+  // wins over disk so unit tests stay hermetic. Production code that hasn't
+  // warmed the in-memory cache still gets the catalog via the disk file that
+  // `engine/model-discovery.js#getRuntimeModels` populates during preflight.
+  if (Array.isArray(_modelDiscoveryResults) && _modelDiscoveryResults.length > 0) {
+    return _modelDiscoveryResults.map(m => m && m.id ? String(m.id) : null).filter(Boolean);
+  }
+  return _readModelIdsFromDiskCache();
+}
+
 function parseError(rawOutput) {
   const text = _collectErrorSignal(rawOutput);
   if (!text) return { message: '', code: null, retriable: true };
@@ -845,6 +918,24 @@ function parseError(rawOutput) {
   if (hasExplicitAuthFailure || hasAuthStatusCode) {
     return { message: text, code: 'auth-failure', retriable: false };
   }
+  // W-mpmwxni2000c25c7-a — Configured model isn't in the Copilot catalog
+  // (typo, deprecated id, 400-style invalid-model response). Classify as
+  // MODEL_UNAVAILABLE with retriable: false so the engine surfaces an
+  // actionable error instead of looping the dispatch. Must match BEFORE the
+  // overload branch — the overload regex catches `model.*unavailable`,
+  // which would otherwise swallow legitimate "model not found" responses.
+  if (/unknown\s+model|model\s+not\s+found|invalid\s+model|model_not_found|400[^a-z]+(?:bad\s+request|invalid|model)|model.*\b400\b/i.test(text)) {
+    const name = _extractInvalidModelName(text) || 'unknown';
+    const ids = _resolveCachedModelIds();
+    const tail = (ids && ids.length > 0)
+      ? `Available models: ${ids.join(', ')}`
+      : 'Configure a valid model in Settings → Engine.';
+    return {
+      message: `Model "${name}" not available for runtime copilot. ${tail}`,
+      code: 'model-unavailable',
+      retriable: false,
+    };
+  }
   // W-mpg6isvy000xca4d — Copilot has no --fallback-model flag; classify
   // overloaded / 503 / service_unavailable as MODEL_UNAVAILABLE so the engine
   // retry can OVERRIDE --model with engine.copilotFallbackModel. Match before
@@ -856,9 +947,6 @@ function parseError(rawOutput) {
   if (/rate limit|too many requests|\b429\b/i.test(text)) {
     return { message: text, code: 'rate-limit', retriable: true };
   }
-  if (/unknown model|model not found|model.*invalid|invalid model/i.test(text)) {
-    return { message: text, code: 'unknown-model', retriable: false };
-  }
   if (/budget.*exceed|premium.*limit.*reach|quota.*exceed/i.test(lower)) {
     return { message: text, code: 'budget-exceeded', retriable: false };
   }
@@ -1198,6 +1286,12 @@ module.exports = {
   _pickStandaloneCopilotFromOutput,
   _resolveNpmCopilotJsEntry,
   _isCachedBinUsable,
+  // W-mpmwxni2000c25c7-a — invalid-model error-path helpers. `_warmModelCache`
+  // populates the in-memory model catalog so parseError can enrich its
+  // "Model X not available" message without a per-error HTTP round trip.
+  _warmModelCache,
+  _resetModelCache,
+  _extractInvalidModelName,
   CAPS_SCHEMA_VERSION,
   KNOWN_EVENT_TYPES,
 };

package/package.json

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