@yemi33/minions 0.1.1670 → 0.1.1672

package/.claudeignore

@@ -0,0 +1,5 @@
+agents/
+engine/tmp/
+engine/contexts/
+prd/*.backup
+plans/archive/

package/CHANGELOG.md

@@ -1,9 +1,26 @@
 # Changelog
 
-## 0.1.1670 (2026-05-02)
+## 0.1.1672 (2026-05-02)
+
+### Features
+-  fleet model validation + Copilot alias map + simplify pass
+
+## 0.1.1671 (2026-05-02)
+
+### Features
+- durable meeting artifact ingestion (#1972)
+
+### Fixes
+-  shared-rules.md — declare done after push, do not wait for remote pipelines (#1970)
+-  sync pipeline card with modal after retrigger/abort/continue
+-  harden maxConcurrent parsing, routing case, and runtime exit codes
+
+### Other
+- docs: condense CLAUDE.md
+
+## 0.1.1669 (2026-05-02)
 
 ### Features
-- make ADO PR titles authoritative (#1965)
 - gate pendingFix clear (#1964)
 
 ## 0.1.1668 (2026-05-01)

package/dashboard/js/render-pipelines.js

@@ -434,6 +434,7 @@ async function _refreshPipelineDetail(id) {
     if (fresh) {
       _pipelinesData = _pipelinesData.map(function(x) { return x.id === id ? fresh : x; });
       _pipelinePollHash = JSON.stringify({ runs: fresh.runs || [], enabled: fresh.enabled, _stoppedBy: fresh._stoppedBy, _stopReason: fresh._stopReason });
+      renderPipelines(_pipelinesData);
       openPipelineDetail(id);
     }
   } catch (e) { /* silent — next poll will catch up */ }

package/dashboard.js

@@ -3357,7 +3357,7 @@ const server = http.createServer(async (req, res) => {
   async function _runKbSweepBackground(body, sweepToken) {
     try {
       const { runKbSweep } = require('./engine/kb-sweep');
-      const result = await runKbSweep({ pinnedKeys: body.pinnedKeys });
+      const result = await runKbSweep({ pinnedKeys: body.pinnedKeys, engineConfig: CONFIG.engine });
       global._kbSweepLastResult = result;
       global._kbSweepLastCompletedAt = Date.now();
     } catch (e) {
@@ -5286,7 +5286,10 @@ What would you like to discuss or change? When you're happy, say "approve" and I
 
     const prompt = `Convert this schedule description to a 3-field cron expression (minute hour dayOfWeek, where dayOfWeek is 0=Sun..6=Sat or ranges like 1-5). Return JSON only: {"cron": "...", "description": "..."}. Input: ${text.trim()}`;
     try {
-      const result = await llm.callLLM(prompt, '', { model: 'haiku', maxTurns: 1, timeout: 30000, label: 'schedule-parse', direct: true });
+      const result = await llm.callLLM(prompt, '', {
+        model: 'haiku', maxTurns: 1, timeout: 30000, label: 'schedule-parse', direct: true,
+        engineConfig: CONFIG.engine,
+      });
       const parsed = JSON.parse(result.text.trim());
       if (!parsed.cron) return jsonReply(res, 422, { error: 'Could not parse schedule' });
       return jsonReply(res, 200, { cron: parsed.cron, description: parsed.description || '' });
@@ -5379,6 +5382,17 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       if (!config.agents) config.agents = {};
 
       const _clamped = [];
+      const _engineModelDiscovery = require('./engine/model-discovery');
+      const _engineRuntimes = require('./engine/runtimes');
+      function _resolveModelForRuntime(modelStr, runtimeName) {
+        try {
+          const adapter = _engineRuntimes.resolveRuntime(runtimeName);
+          if (adapter && typeof adapter.resolveModel === 'function') {
+            return adapter.resolveModel(modelStr) || modelStr;
+          }
+        } catch { /* unknown/free-text runtime */ }
+        return modelStr;
+      }
       if (body.engine) {
         const e = body.engine;
         const D = shared.ENGINE_DEFAULTS;
@@ -5440,10 +5454,9 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         // (where gpt-5.5 doesn't actually exist) cascaded into every agent
         // that didn't pin its own model. Reject when the model is known to
         // belong to a different runtime than the one it'll spawn against.
-        const _engineModelDiscovery = require('./engine/model-discovery');
-        const _engineRuntimes = require('./engine/runtimes');
         async function _validateFleetModel(modelStr, resolvedRuntime) {
           if (!modelStr) return null;
+          const runtimeModelStr = _resolveModelForRuntime(modelStr, resolvedRuntime);
           let knownForResolved = null;
           try {
             const list = await _engineModelDiscovery.getRuntimeModels(resolvedRuntime, { config });
@@ -5451,11 +5464,11 @@ 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(modelStr)) {
+          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 model belongs to a different runtime's published list.
+            // 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 {
@@ -5548,13 +5561,12 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         // claude+gpt-* / copilot+claude-* combinations before they crash a
         // dispatch (see #model-validation: a stray engine.defaultModel='gpt-5.5'
         // pinned every Claude agent into a 404 spawn loop).
-        const _modelDiscovery = require('./engine/model-discovery');
         const _runtimeModelsCache = new Map(); // runtimeName → Set<modelId> (or null when unknown / Claude)
         async function _modelsFor(runtimeName) {
           if (_runtimeModelsCache.has(runtimeName)) return _runtimeModelsCache.get(runtimeName);
           let set = null;
           try {
-            const list = await _modelDiscovery.getRuntimeModels(runtimeName, { config });
+            const list = await _engineModelDiscovery.getRuntimeModels(runtimeName, { config });
             if (Array.isArray(list?.models) && list.models.length > 0) {
               set = new Set(list.models.map(m => m.id || m.name).filter(Boolean));
             }
@@ -5562,11 +5574,11 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           _runtimeModelsCache.set(runtimeName, set);
           return set;
         }
-        // Returns the runtime that "owns" this model, or null if no other
+        // Returns the runtime that "owns" this raw model, or null if no other
         // runtime claims it. Catches "claude + gpt-5.5" by spotting that
         // gpt-5.5 belongs to copilot's list.
         async function _ownerOfModel(modelId) {
-          for (const rt of require('./engine/runtimes').listRuntimes()) {
+          for (const rt of _engineRuntimes.listRuntimes()) {
             const set = await _modelsFor(rt);
             if (set && set.has(modelId)) return rt;
           }
@@ -5594,6 +5606,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
             else {
               const candidate = String(updates.model);
               const resolvedCli = config.agents[id].cli || config.engine.defaultCli || 'claude';
+              const runtimeModelStr = _resolveModelForRuntime(candidate, resolvedCli);
               const knownModels = await _modelsFor(resolvedCli);
               // Two validation paths:
               //   1. If the runtime publishes a model list, enforce membership.
@@ -5601,7 +5614,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
               //      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).
               let rejection = null;
-              if (knownModels && !knownModels.has(candidate)) {
+              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) {
                 const owner = await _ownerOfModel(candidate);

package/docs/copilot-cli-schema.md

@@ -20,7 +20,7 @@
 | `capabilities.systemPromptFile` | **`false`** | No `--system-prompt-file` flag exists. Inject system prompt via a `<system>` block prepended to stdin. |
 | `capabilities.effortLevels` | **`true`** | `--effort` accepts `low|medium|high|xhigh` (no `max`). Adapter must map `'max' → 'xhigh'`. |
 | `capabilities.costTracking` | **`false`** | `result.usage` contains `premiumRequests` (count, not USD), no token counts, no cost. |
-| `capabilities.modelShorthands` | **`false`** | Models are full IDs (`claude-sonnet-4.5`, `gpt-5.4`). No `sonnet`/`opus`/`haiku` aliasing on the Copilot side. |
+| `capabilities.modelShorthands` | **`false`** | The Copilot CLI requires full model IDs (`claude-sonnet-4.5`, `gpt-5.4`). Minions may accept internal aliases (`haiku`, `sonnet`, `opus`), but the adapter translates them to Copilot model IDs before invoking the CLI. |
 | `capabilities.budgetCap` | **`false`** | No `--max-budget-usd` flag. |
 | `capabilities.bareMode` | **`false`** | No `--bare`. Closest equivalent is `--no-custom-instructions` (suppresses AGENTS.md only, not all auto-discovery). |
 | `capabilities.fallbackModel` | **`false`** | No `--fallback-model` flag. |
@@ -594,9 +594,11 @@ When implementing `engine/runtimes/copilot.js`:
    **Never** emit `--verbose`.
 4. `buildPrompt()` injects `<system>...</system>\n\n` block when sysprompt is
    non-empty; passthrough otherwise (§2).
-5. `resolveModel()` is verbatim passthrough; emit a one-time `console.warn`
-   when input is `'sonnet' | 'opus' | 'haiku'` (Claude shorthand the user
-   probably meant to set on the Claude adapter).
+5. `resolveModel()` translates Minions internal aliases before the CLI boundary:
+   `'haiku'` → `'claude-haiku-4.5'`, `'sonnet'` → `'claude-sonnet-4.5'`, and
+   `'opus'` → `'claude-opus-4.5'`. All other model IDs pass through unchanged.
+   Keep `capabilities.modelShorthands` false because aliases are never passed
+   to the Copilot CLI.
 6. `_mapEffort()` private helper does `'max' → 'xhigh'`; pass through otherwise.
 7. `parseOutput(raw)` produces:
    - `text`: concatenation of all `assistant.message.data.content` (multi-turn

package/engine/cleanup.js

@@ -39,6 +39,30 @@ function worktreeDirMatchesBranch(dirLower, branch) {
   return dirLower === branchSlug || dirLower.includes(branchSlug + '-') || dirLower.endsWith('-' + branchSlug);
 }
 
+let _orphanPidProcessNamesCache = null;
+function _orphanPidProcessNames() {
+  if (_orphanPidProcessNamesCache) return _orphanPidProcessNamesCache;
+  const names = new Set(['node']);
+  try {
+    for (const name of require('./runtimes').listRuntimes()) names.add(String(name).toLowerCase());
+    // Copilot can run through the GitHub CLI fallback (`gh copilot`), so allow
+    // gh only when the copilot runtime is registered.
+    if (names.has('copilot')) names.add('gh');
+  } catch {
+    names.add('claude');
+  }
+  _orphanPidProcessNamesCache = names;
+  return names;
+}
+
+function _processNameAllowedForOrphanKill(processText) {
+  const firstLine = String(processText || '').trim().split(/\r?\n/).find(Boolean) || '';
+  const imageName = path.basename(firstLine.trim().split(/\s+/)[0] || '').toLowerCase().replace(/\.exe$/, '');
+  if (!imageName) return false;
+  return _orphanPidProcessNames().has(imageName);
+}
+
+
 /**
  * Kill orphaned processes whose dispatch ID appears in the worktree dir name.
  * Only kills processes NOT in the active dispatch queue — never kills live agents.
@@ -68,18 +92,18 @@ function _killProcessInWorktree(dir, activeProcesses, activeIds) {
       if (isActive) continue; // still active — do not kill
       const pid = parseInt(fs.readFileSync(path.join(tmpDir, f), 'utf8').trim(), 10);
       if (pid > 0) {
-        // Verify the process is actually a node/claude process before killing
+        // Verify the PID still belongs to a Minions runtime process before killing
         try {
           if (process.platform === 'win32') {
             const taskInfo = exec(`tasklist /FI "PID eq ${pid}" /NH`, { encoding: 'utf8', timeout: 3000, windowsHide: true });
             const taskLower = taskInfo.toLowerCase();
-            if (!taskLower.includes('node') && !taskLower.includes('claude')) continue;
+            if (!_processNameAllowedForOrphanKill(taskLower)) continue;
             exec(`taskkill /F /T /PID ${pid}`, { stdio: 'pipe', timeout: 5000, windowsHide: true });
           } else {
-            // Verify it's a node process before killing (prevent recycled PID kill)
+            // Verify the process name before killing (prevent recycled PID kill)
             try {
               const psOut = exec(`ps -p ${pid} -o comm=`, { encoding: 'utf8', timeout: 3000 }).trim();
-              if (!psOut.includes('node') && !psOut.includes('claude')) continue;
+              if (!_processNameAllowedForOrphanKill(psOut)) continue;
             } catch { continue; } // process dead or ps failed
             try { process.kill(-pid, 'SIGKILL'); } catch { process.kill(pid, 'SIGKILL'); }
           }
@@ -331,7 +355,7 @@ function runCleanup(config, verbose = false) {
     } // end worktreeRoots loop
   }
 
-  // 4. Kill zombie claude processes not tracked by the engine
+  // 4. Kill zombie agent processes not tracked by the engine
   // List all node processes, check if any are running spawn-agent.js for our minions
   try {
     const dispatch = getDispatch();

package/engine/cli.js

@@ -157,8 +157,8 @@ function _modelLooksIncompatible(runtime, model) {
     return true; // gpt-*, o3-*, codex, etc. — wrong CLI for these
   }
   if (runtime === 'copilot') {
-    // Copilot accepts the full catalog by ID; only Claude shorthands are wrong.
-    return m === 'sonnet' || m === 'opus' || m === 'haiku';
+    // Copilot adapter maps Minions' family aliases before spawning.
+    return false;
   }
   return false;
 }

package/engine/consolidation.js

@@ -8,11 +8,11 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const shared = require('./shared');
-const { safeRead, safeWrite, safeUnlink, runFile, cleanChildEnv,
-  parseStreamJsonOutput, classifyInboxItem, KB_CATEGORIES, log, ts, dateStamp } = shared;
-const { trackEngineUsage } = require('./llm');
+const { safeRead, safeWrite,
+  classifyInboxItem, KB_CATEGORIES, log, ts, dateStamp } = shared;
+const { callLLM, trackEngineUsage } = require('./llm');
 const queries = require('./queries');
-const { getInboxFiles, getNotes, INBOX_DIR, ENGINE_DIR, MINIONS_DIR,
+const { getInboxFiles, getNotes, INBOX_DIR, ENGINE_DIR,
   NOTES_PATH, KNOWLEDGE_DIR, ARCHIVE_DIR } = queries;
 
 // Track in-flight LLM consolidation to prevent concurrent runs
@@ -150,51 +150,18 @@ function consolidateWithLLM(items, existingNotes, files, config) {
   });
 
   const prompt = buildConsolidationPrompt(items, existingNotes, kbPaths);
-
-  const tmpDir = path.join(ENGINE_DIR, 'tmp');
-  if (!fs.existsSync(tmpDir)) fs.mkdirSync(tmpDir, { recursive: true });
-  const promptPath = path.join(tmpDir, 'consolidate-prompt.md');
-  safeWrite(promptPath, prompt);
-
   const sysPrompt = 'You are a concise knowledge manager. Output only markdown. No preamble. No code fences around your output.';
-  const sysPromptPath = path.join(tmpDir, 'consolidate-sysprompt.md');
-  safeWrite(sysPromptPath, sysPrompt);
-
-  const spawnScript = path.join(ENGINE_DIR, 'spawn-agent.js');
-  const args = [
-    '--output-format', 'stream-json',
-    '--max-turns', '1',
-    '--model', 'haiku',
-    '--permission-mode', 'bypassPermissions',
-    '--verbose',
-  ];
-
-  log('info', 'Spawning Haiku for LLM consolidation...');
-
-  const proc = runFile(process.execPath, [spawnScript, promptPath, sysPromptPath, ...args], {
-    cwd: MINIONS_DIR,
-    stdio: ['pipe', 'pipe', 'pipe'],
-    env: cleanChildEnv()
-  });
 
-  let stdout = '';
-  let stderr = '';
-  proc.stdout.on('data', d => { stdout += d.toString(); if (stdout.length > 100000) stdout = stdout.slice(-50000); });
-  proc.stderr.on('data', d => { stderr += d.toString(); if (stderr.length > 50000) stderr = stderr.slice(-25000); });
+  log('info', 'Starting LLM consolidation...');
 
-  const timeout = setTimeout(() => {
-    log('warn', 'LLM consolidation timed out after 3m — killing and falling back to regex');
-    shared.killGracefully(proc, 10000);
-    _forceResetTimeout = setTimeout(() => {
-      if (!_cleared) log('warn', 'Consolidation flag force-reset after SIGKILL');
-      _clearProcessingState();
-    }, 10000);
-  }, 180000);
+  let _cleared = false; // idempotency guard — timeout and promise resolution can race
+  let timeoutHandle = null;
+  let fallbackDone = false;
 
-  let _cleared = false; // idempotency guard — both 'error' and 'close' can fire for the same process
   function _clearProcessingState() {
     if (_cleared) return;
     _cleared = true;
+    clearTimeout(timeoutHandle);
     clearTimeout(_forceResetTimeout);
     _forceResetTimeout = null;
     for (const f of files) _processingFiles.delete(f);
@@ -202,17 +169,43 @@ function consolidateWithLLM(items, existingNotes, files, config) {
     _consolidationStartedAt = 0;
   }
 
-  proc.on('close', (code) => {
-    clearTimeout(timeout);
-    try { safeUnlink(promptPath); } catch (err) { log('warn', `Temp file cleanup failed: ${promptPath} — ${err.message}`); }
-    try { safeUnlink(sysPromptPath); } catch (err) { log('warn', `Temp file cleanup failed: ${sysPromptPath} — ${err.message}`); }
+  function _fallback(message, err) {
+    if (_cleared || fallbackDone) return;
+    fallbackDone = true;
+    if (message) log('warn', message);
+    if (err?.message) log('debug', `LLM error: ${err.message}`);
+    consolidateWithRegex(items, files);
+  }
 
-    const parsed = parseStreamJsonOutput(stdout);
-    const extractedText = parsed.text;
-    trackEngineUsage('consolidation', parsed.usage);
+  const llmCall = callLLM(prompt, sysPrompt, {
+    timeout: 180000,
+    label: 'consolidation',
+    model: 'haiku',
+    maxTurns: 1,
+    direct: true,
+    engineConfig: config.engine,
+  });
 
-    if (code === 0 && (extractedText || stdout).trim().length > 50) {
-      let digest = (extractedText || stdout).trim();
+  timeoutHandle = setTimeout(() => {
+    if (_cleared) return;
+    log('warn', 'LLM consolidation timed out after 3m — aborting and falling back to regex');
+    try { if (llmCall && typeof llmCall.abort === 'function') llmCall.abort(); } catch { /* ignore */ }
+    _forceResetTimeout = setTimeout(() => {
+      if (!_cleared) log('warn', 'Consolidation flag force-reset after timeout');
+      _fallback();
+      _clearProcessingState();
+    }, 10000);
+  }, 180000);
+
+  llmCall.then((result) => {
+    if (_cleared) return;
+    clearTimeout(timeoutHandle);
+    trackEngineUsage('consolidation', result.usage);
+
+    const extractedText = result.text || '';
+    const rawText = result.raw || '';
+    if (result.code === 0 && (extractedText || rawText).trim().length > 50) {
+      let digest = (extractedText || rawText).trim();
       digest = digest.replace(/^\`\`\`\w*\n?/gm, '').replace(/\n?\`\`\`$/gm, '').trim();
 
       if (!digest.startsWith('### ')) {
@@ -220,9 +213,7 @@ function consolidateWithLLM(items, existingNotes, files, config) {
         if (sectionIdx >= 0) {
           digest = digest.slice(sectionIdx);
         } else {
-          log('warn', 'LLM consolidation output missing expected format — falling back to regex');
-          consolidateWithRegex(items, files);
-          _clearProcessingState();
+          _fallback('LLM consolidation output missing expected format — falling back to regex');
           return;
         }
       }
@@ -257,21 +248,15 @@ function consolidateWithLLM(items, existingNotes, files, config) {
       });
       classifyToKnowledgeBase(items);
       archiveInboxFiles(files);
-      log('info', `LLM consolidation complete: ${files.length} notes processed by Haiku`);
+      log('info', `LLM consolidation complete: ${files.length} notes processed`);
     } else {
-      log('warn', `LLM consolidation failed (code=${code}) — falling back to regex`);
-      if (stderr) log('debug', `LLM stderr: ${stderr.slice(0, 500)}`);
-      consolidateWithRegex(items, files);
+      _fallback(`LLM consolidation failed (code=${result.code}) — falling back to regex`, result.stderr ? { message: result.stderr.slice(0, 500) } : null);
     }
-    _clearProcessingState();
-  });
-
-  proc.on('error', (err) => {
-    clearTimeout(timeout);
-    log('warn', `LLM consolidation spawn error: ${err.message} — falling back to regex`);
-    try { safeUnlink(promptPath); } catch (unlinkErr) { log('warn', `Temp file cleanup failed: ${promptPath} — ${unlinkErr.message}`); }
-    try { safeUnlink(sysPromptPath); } catch (unlinkErr) { log('warn', `Temp file cleanup failed: ${sysPromptPath} — ${unlinkErr.message}`); }
-    consolidateWithRegex(items, files);
+  }).catch((err) => {
+    if (_cleared) return;
+    clearTimeout(timeoutHandle);
+    _fallback(`LLM consolidation error: ${err.message} — falling back to regex`, err);
+  }).finally(() => {
     _clearProcessingState();
   });
 }

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-02T00:03:38.474Z"
+  "cachedAt": "2026-05-02T03:35:46.216Z"
 }

package/engine/kb-sweep.js

@@ -104,7 +104,7 @@ function _hashDedup(manifest, opts = {}) {
 }
 
 /** Batched LLM sweep — finds within-batch dupes, reclassifies, removes stale. */
-async function _llmBatchSweep(manifest, callLLM, trackEngineUsage) {
+async function _llmBatchSweep(manifest, callLLM, trackEngineUsage, opts = {}) {
   const plan = { duplicates: [], reclassify: [], remove: [] };
   const batches = [];
   for (let i = 0; i < manifest.length; i += LLM_BATCH_SIZE) {
@@ -130,7 +130,10 @@ If nothing to do: { "duplicates": [], "reclassify": [], "remove": [] }`;
 
     let result;
     try {
-      result = await callLLM(prompt, 'Output only JSON.', { timeout: 120000, label: 'kb-sweep', model: 'haiku', maxTurns: 1, direct: true });
+      result = await callLLM(prompt, 'Output only JSON.', {
+        timeout: 120000, label: 'kb-sweep', model: 'haiku', maxTurns: 1, direct: true,
+        engineConfig: opts.engineConfig,
+      });
       trackEngineUsage('kb-sweep', result.usage);
     } catch (e) { log('warn', `[kb-sweep] batch ${b + 1} LLM error: ${e.message}`); continue; }
 
@@ -206,6 +209,7 @@ ${body}`;
       try {
         const result = await callLLM(REWRITE_PROMPT(c.entry, c.body), 'Output ONLY the template body.', {
           timeout: 120000, label: 'kb-rewrite', model: 'haiku', maxTurns: 1, direct: true,
+          engineConfig: opts.engineConfig,
         });
         trackEngineUsage('kb-sweep', result.usage);
         let newBody = (result.text || '').trim();
@@ -326,7 +330,7 @@ async function runKbSweep(opts = {}) {
   // 2. LLM batch sweep — within-batch dupes + reclassify + remove stale
   // Only runs against survivors, but we need indices that match the LIST sent to the LLM
   const llmManifest = afterHash;
-  const plan = await _llmBatchSweep(llmManifest, callLLM, trackEngineUsage);
+  const plan = await _llmBatchSweep(llmManifest, callLLM, trackEngineUsage, opts);
   const llmActions = _applyLlmPlan(plan, llmManifest, opts);
   summary.llmDuplicatesArchived = llmActions.merged;
   summary.staleRemoved = llmActions.removed;

package/engine/lifecycle.js

@@ -2529,7 +2529,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   if (type === WORK_TYPE.MEETING && meta?.meetingId) {
     try {
       const { collectMeetingFindings } = require('./meeting');
-      collectMeetingFindings(meta.meetingId, agentId, meta.roundName, stdout);
+      collectMeetingFindings(meta.meetingId, agentId, meta.roundName, stdout, structuredCompletion);
     } catch (err) { log('warn', `Meeting collect: ${err.message}`); }
   }
 

package/engine/llm.js

@@ -403,6 +403,12 @@ function _resolveModelFor(callOpts) {
   return undefined;
 }
 
+function _resolveModelForRuntime(runtime, callOpts) {
+  const selected = _resolveModelFor(callOpts || {});
+  if (!runtime || typeof runtime.resolveModel !== 'function') return selected;
+  return runtime.resolveModel(selected);
+}
+
 function _resolveRuntimeFeatureOpts({
   stream, disableBuiltinMcps, suppressAgentsMd, reasoningSummaries, engineConfig,
 } = {}) {
@@ -431,7 +437,7 @@ function callLLM(promptText, sysPromptText, opts = {}) {
   } = opts;
 
   const runtime = _resolveRuntimeFor({ cli: cliOverride, engineConfig });
-  const model = _resolveModelFor({ model: modelOverride, engineConfig });
+  const model = _resolveModelForRuntime(runtime, { model: modelOverride, engineConfig });
   const runtimeFeatureOpts = _resolveRuntimeFeatureOpts({
     stream, disableBuiltinMcps, suppressAgentsMd, reasoningSummaries, engineConfig,
   });
@@ -528,7 +534,7 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
   } = opts;
 
   const runtime = _resolveRuntimeFor({ cli: cliOverride, engineConfig });
-  const model = _resolveModelFor({ model: modelOverride, engineConfig });
+  const model = _resolveModelForRuntime(runtime, { model: modelOverride, engineConfig });
   const runtimeFeatureOpts = _resolveRuntimeFeatureOpts({
     stream, disableBuiltinMcps, suppressAgentsMd, reasoningSummaries, engineConfig,
   });
@@ -619,5 +625,6 @@ module.exports = {
   _resetBinCache,
   _resolveRuntimeFor,
   _resolveModelFor,
+  _resolveModelForRuntime,
   _resolveRuntimeFeatureOpts,
 };

package/engine/meeting.js

@@ -19,6 +19,86 @@ const EMPTY_OUTPUT_PATTERNS = ['(no output)', '(no findings)', '(no response)'];
 // Derive from shared.MINIONS_DIR so createTestMinionsDir()/MINIONS_TEST_DIR
 // tests can redirect the meetings directory without patching module internals.
 const MEETINGS_DIR = path.join(shared.MINIONS_DIR, 'meetings');
+const MEETING_NOTE_ARTIFACT_ROOT = path.join(shared.MINIONS_DIR, 'notes', 'inbox');
+
+function isEmptyMeetingContent(text) {
+  const value = String(text || '').trim();
+  return !value || EMPTY_OUTPUT_PATTERNS.includes(value);
+}
+
+function isSuccessfulStructuredCompletion(completion) {
+  const status = String(completion?.status || completion?.outcome || '').trim().toLowerCase();
+  return ['success', 'succeeded', 'complete', 'completed', 'done', 'ok', 'passed'].includes(status);
+}
+
+function getStructuredNoteArtifacts(structuredCompletion) {
+  const artifacts = structuredCompletion?.artifacts;
+  if (!Array.isArray(artifacts)) return [];
+  return artifacts.filter(artifact =>
+    artifact &&
+    typeof artifact === 'object' &&
+    String(artifact.type || '').toLowerCase() === 'note' &&
+    typeof artifact.path === 'string' &&
+    artifact.path.trim()
+  );
+}
+
+function isPathInside(parent, child) {
+  const rel = path.relative(parent, child);
+  return rel && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
+function resolveMeetingNoteArtifactPath(artifactPath) {
+  const raw = String(artifactPath || '').trim();
+  if (!raw || raw.includes('\0')) return null;
+  const resolved = path.resolve(path.isAbsolute(raw) ? raw : path.join(shared.MINIONS_DIR, raw));
+  const root = path.resolve(MEETING_NOTE_ARTIFACT_ROOT);
+  if (!isPathInside(root, resolved)) return null;
+  if (path.extname(resolved).toLowerCase() !== '.md') return null;
+  return resolved;
+}
+
+function readMeetingNoteArtifact(artifactPath) {
+  const resolved = resolveMeetingNoteArtifactPath(artifactPath);
+  if (!resolved) {
+    log('warn', `Ignoring unsafe meeting note artifact path: ${artifactPath || '(empty)'}`);
+    return '';
+  }
+  try {
+    const realRoot = fs.realpathSync(MEETING_NOTE_ARTIFACT_ROOT);
+    const realPath = fs.realpathSync(resolved);
+    if (!isPathInside(realRoot, realPath)) {
+      log('warn', `Ignoring meeting note artifact outside notes/inbox: ${artifactPath}`);
+      return '';
+    }
+    const content = fs.readFileSync(realPath, 'utf8');
+    return isEmptyMeetingContent(content) ? '' : content;
+  } catch (err) {
+    log('warn', `Meeting note artifact unreadable (${artifactPath}): ${err.message}`);
+    return '';
+  }
+}
+
+function resolveStructuredMeetingContent(structuredCompletion) {
+  if (!isSuccessfulStructuredCompletion(structuredCompletion)) return '';
+  const noteArtifacts = getStructuredNoteArtifacts(structuredCompletion);
+  if (noteArtifacts.length === 0) return '';
+
+  for (const artifact of noteArtifacts) {
+    const content = readMeetingNoteArtifact(artifact.path);
+    if (content) return content;
+  }
+
+  const summary = String(structuredCompletion.summary || '').trim();
+  return isEmptyMeetingContent(summary) ? '' : summary;
+}
+
+function resolveMeetingContributionContent(output, structuredCompletion) {
+  const { text } = shared.parseStreamJsonOutput(output, { maxTextLength: 50000 });
+  const rawContent = (text || '').trim();
+  if (!isEmptyMeetingContent(rawContent)) return rawContent;
+  return resolveStructuredMeetingContent(structuredCompletion);
+}
 
 function truncateMeetingContext(text, maxBytes, label) {
   return shared.truncateTextBytes(text, maxBytes, `\n\n_...${label} truncated — review the meeting transcript if needed._`);
@@ -323,7 +403,7 @@ function discoverMeetingWork(config) {
  * Collect findings from a completed meeting agent.
  * Called from runPostCompletionHooks when type === 'meeting'.
  */
-function collectMeetingFindings(meetingId, agentId, roundName, output) {
+function collectMeetingFindings(meetingId, agentId, roundName, output, structuredCompletion = null) {
   const meeting = getMeeting(meetingId);
   if (!meeting) return;
   if (meeting.status === 'completed' || meeting.status === 'archived') {
@@ -331,17 +411,15 @@ function collectMeetingFindings(meetingId, agentId, roundName, output) {
     return;
   }
 
-  const { text } = shared.parseStreamJsonOutput(output, { maxTextLength: 50000 });
-  const rawContent = (text || '').trim();
+  const content = resolveMeetingContributionContent(output, structuredCompletion);
 
   // Validate output — reject empty or placeholder responses
-  if (!rawContent || EMPTY_OUTPUT_PATTERNS.includes(rawContent)) {
+  if (isEmptyMeetingContent(content)) {
     log('warn', `Meeting ${meetingId}: agent ${agentId} returned empty output for ${roundName} — rejecting`);
     // Don't record it — agent will be re-dispatched on next tick
     saveMeeting(meeting);
     return;
   }
-  const content = rawContent;
 
   if (roundName === 'investigate') {
     meeting.findings[agentId] = { content, submittedAt: ts() };

package/engine/pipeline.js

@@ -486,6 +486,7 @@ async function executePlanStage(stage, stageState, run, config) {
     const fullPrompt = meetingContext + '\n\n---\n\n' + planPrompt;
     const result = await llm.callLLM(fullPrompt, '', {
       timeout: 120000, label: 'pipeline-plan', model: 'sonnet', maxTurns: 1,
+      engineConfig: config.engine,
     });
     if (result.text) {
       content = result.text;

package/engine/routing.js

@@ -125,7 +125,8 @@ function normalizeWorkType(workType, fallback = WORK_TYPE.IMPLEMENT) {
 
 function routeForWorkType(workType) {
   const routes = getRoutingTableCached();
-  return routes[normalizeWorkType(workType)] || routes[WORK_TYPE.IMPLEMENT] || { preferred: ANY_AGENT, fallback: ANY_AGENT };
+  const routeKey = normalizeWorkType(workType).toLowerCase();
+  return routes[routeKey] || routes[WORK_TYPE.IMPLEMENT] || { preferred: ANY_AGENT, fallback: ANY_AGENT };
 }
 
 function isAgentHardPinned(item) {

package/engine/runtimes/copilot.js

@@ -15,10 +15,10 @@
  *                                    buildPrompt() prepends a <system> block.
  *   - costTracking: false           — result.usage has premiumRequests count
  *                                    and durations only; no USD or per-token.
- *   - modelShorthands: false        — full model IDs like "claude-sonnet-4.5",
- *                                    "gpt-5.4". Bare "sonnet" / "opus" / "haiku"
- *                                    is a Claude-ism — log a one-time warning
- *                                    when seen so the user notices the mistake.
+ *   - modelShorthands: false        — Copilot itself expects full model IDs like
+ *                                    "claude-sonnet-4.5" or "gpt-5.4". The
+ *                                    adapter translates Minions' internal family
+ *                                    aliases before argv construction.
  *   - modelDiscovery: true          — GET https://api.githubcopilot.com/models
  *                                    with `gh auth token` Bearer returns the
  *                                    catalog (24 models on the test account).
@@ -152,26 +152,23 @@ function resolveBinary({ env = process.env } = {}) {
 
 // ── Model Resolution ────────────────────────────────────────────────────────
 //
-// Copilot models are full IDs (`claude-sonnet-4.5`, `gpt-5.4`, ...). The
-// adapter passes them through verbatim. When we see a Claude shorthand
-// ('sonnet', 'opus', 'haiku') we log ONCE — a stronger signal than silently
-// passing it to Copilot, which would respond with an unknown-model error.
-
-const _CLAUDE_SHORTHANDS = new Set(['sonnet', 'opus', 'haiku']);
-let _shorthandWarningLogged = false;
-
-function _resetShorthandWarning() { _shorthandWarningLogged = false; }
+// Copilot models are full IDs (`claude-sonnet-4.5`, `gpt-5.4`, ...). Minions
+// still uses the family aliases `haiku` / `sonnet` / `opus` internally, so this
+// adapter maps those aliases to Copilot model IDs while passing all other input
+// through verbatim. The capability remains false: Copilot CLI does not accept
+// these aliases directly.
+
+const _MINIONS_MODEL_ALIASES = {
+  haiku: 'claude-haiku-4.5',
+  sonnet: 'claude-sonnet-4.5',
+  opus: 'claude-opus-4.5',
+};
 
-function resolveModel(input, { logger = console } = {}) {
+function resolveModel(input) {
   if (input == null || input === '') return undefined;
   const s = String(input);
-  if (_CLAUDE_SHORTHANDS.has(s.toLowerCase()) && !_shorthandWarningLogged) {
-    _shorthandWarningLogged = true;
-    try {
-      const warn = (logger && typeof logger.warn === 'function') ? logger.warn.bind(logger) : null;
-      if (warn) warn(`[copilot] "${s}" is a Claude family shorthand; Copilot expects a full model id (e.g. claude-sonnet-4.5). Passing through verbatim — Copilot will likely reject it.`);
-    } catch { /* logger may be unwired during tests */ }
-  }
+  const mapped = _MINIONS_MODEL_ALIASES[s.toLowerCase()];
+  if (mapped) return mapped;
   return s;
 }
 
@@ -783,8 +780,7 @@ module.exports = {
   createStreamConsumer,
   // Exposed for unit tests — engine code MUST go through resolveRuntime + the
   // adapter contract; never reach into these helpers directly.
-  _CLAUDE_SHORTHANDS,
-  _resetShorthandWarning,
+  _MINIONS_MODEL_ALIASES,
   _mapEffort,
   _copilotAssistantMessageHasTools,
   KNOWN_EVENT_TYPES,

package/engine/shared.js

@@ -445,12 +445,15 @@ function mutateCooldowns(mutator) {
   }, { defaultValue: {}, skipWriteIfUnchanged: true });
 }
 
+let _uidCounter = 0;
+
 /**
- * Generate a unique ID suffix: timestamp + 4 random chars.
+ * Generate a unique ID suffix: timestamp + monotonic counter + random chars.
  * Use for filenames that could collide (dispatch IDs, temp files, etc.)
  */
 function uid() {
-  return Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+  _uidCounter = (_uidCounter + 1) % 0x1000000;
+  return Date.now().toString(36) + _uidCounter.toString(36).padStart(4, '0') + crypto.randomBytes(2).toString('hex');
 }
 
 /**

package/engine/spawn-agent.js

@@ -122,6 +122,12 @@ function buildSpawnInvocation({ runtime, resolved, promptText, sysPromptText, op
   };
 }
 
+function normalizeRuntimeExit(code, signal) {
+  if (Number.isInteger(code)) return code;
+  if (signal) return 128;
+  return 1;
+}
+
 // ─── Main script execution ──────────────────────────────────────────────────
 
 function _installHint(name, runtime) {
@@ -278,12 +284,13 @@ function main() {
   }, MCP_STARTUP_TIMEOUT);
   proc.stdout.once('data', () => { gotFirstOutput = true; clearTimeout(startupTimer); });
 
-  proc.on('close', (code) => {
+  proc.on('close', (code, signal) => {
     clearTimeout(startupTimer);
+    const exitCode = normalizeRuntimeExit(code, signal);
     // Write process-exit sentinel to stdout so the engine can detect completion (#716).
-    try { process.stdout.write(`\n[process-exit] code=${code}\n`); } catch { /* stdout may be closed */ }
-    fs.appendFileSync(debugPath, `EXIT: code=${code}\nSTDERR: ${stderrBuf.slice(0, 500)}\n`);
-    process.exit(code || 0);
+    try { process.stdout.write(`\n[process-exit] code=${exitCode}${signal ? ` signal=${signal}` : ''}\n`); } catch { /* stdout may be closed */ }
+    fs.appendFileSync(debugPath, `EXIT: code=${exitCode}${signal ? ` signal=${signal}` : ''}\nSTDERR: ${stderrBuf.slice(0, 500)}\n`);
+    process.exit(exitCode);
   });
   proc.on('error', (err) => {
     fs.appendFileSync(debugPath, `ERROR: ${err.message}\n`);
@@ -291,6 +298,6 @@ function main() {
   });
 }
 
-module.exports = { parseSpawnArgs, buildSpawnInvocation };
+module.exports = { parseSpawnArgs, buildSpawnInvocation, normalizeRuntimeExit };
 
 if (require.main === module) main();

package/engine.js

@@ -3543,7 +3543,7 @@ async function discoverWork(config) {
   );
   if (hasIncompleteImplements) {
     const activeCount = (getDispatch().active || []).length;
-    const maxConcurrent = config.engine?.maxConcurrent ?? ENGINE_DEFAULTS.maxConcurrent;
+    const maxConcurrent = resolveMaxConcurrent(config);
     const freeSlots = Math.max(0, maxConcurrent - activeCount);
     if (freeSlots === 0) {
       if (allReviews.length > 0) {
@@ -3630,6 +3630,13 @@ function isSoftFixDispatch(item) {
   return item?.type === WORK_TYPE.FIX && !routing.isAgentHardPinned(item.meta?.item);
 }
 
+function resolveMaxConcurrent(config) {
+  const raw = config?.engine?.maxConcurrent;
+  if (raw === undefined || raw === null || raw === '') return ENGINE_DEFAULTS.maxConcurrent;
+  const value = Number(raw);
+  return Number.isFinite(value) && value >= 0 ? value : ENGINE_DEFAULTS.maxConcurrent;
+}
+
 // ─── Main Tick ──────────────────────────────────────────────────────────────
 
 let tickCount = 0;
@@ -3936,7 +3943,7 @@ async function tickInner() {
   {
     const dispatchPre = getDispatch();
     const activeCountPre = (dispatchPre.active || []).length;
-    const maxC = config.engine?.maxConcurrent ?? ENGINE_DEFAULTS.maxConcurrent;
+    const maxC = resolveMaxConcurrent(config);
     setTempBudget(Math.max(0, maxC - activeCountPre));
   }
   try { pruneStalePrDispatches(config); } catch (e) { log('warn', 'prune stale PR dispatches: ' + e.message); }
@@ -3954,7 +3961,7 @@ async function tickInner() {
   // 5. Process pending dispatches — auto-spawn agents
   const dispatch = getDispatch();
   const activeCount = (dispatch.active || []).length;
-  const maxConcurrent = config.engine?.maxConcurrent || 5;
+  const maxConcurrent = resolveMaxConcurrent(config);
 
   const slotsAvailable = Math.max(0, maxConcurrent - activeCount);
 
@@ -4254,7 +4261,7 @@ module.exports = {
 
   // Tick
   tick,
-  _pollIntervalMsFromTicks, _shouldRunPeriodicPhase, // exported for testing
+  resolveMaxConcurrent, _pollIntervalMsFromTicks, _shouldRunPeriodicPhase, // exported for testing
 };
 
 // ─── Entrypoint ─────────────────────────────────────────────────────────────

package/package.json

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

package/playbooks/shared-rules.md

@@ -64,6 +64,18 @@ Use `status: "failed"` plus an accurate `failure_class`, `retryable`, and `needs
 
 Builds, dependency installs, tests, and local servers can be quiet for long periods. Run the repo's normal CLI commands and let them finish; do not add artificial progress output, heartbeat loops, or command-specific workarounds just to keep Minions active.
 
+## Done = pushed + local validation. Do NOT wait for remote pipelines.
+
+Your dispatch is **done** the moment (1) your fix is pushed to the branch and (2) any local validation you ran has finished. Write the completion JSON and exit immediately. **Do not** wait for the remote PR pipeline (Android OCM PR build, Espresso CloudTest, GitHub Actions, etc.) to finish before declaring done.
+
+This applies to **every** fix dispatch, including `build-fix` tasks. Pipeline failures route back through separate engine paths (a new `build-fix` dispatch will be queued if the remote build fails); your job ends at push.
+
+Concretely:
+- After `git push`, write the completion report and exit. Do not start a `monitor`/`read_powershell`/`watch` loop on the pipeline.
+- Do not sleep or busy-wait for `mergeStatus`, `buildStatus`, or any ADO/GitHub API to flip from `running` to `passing`.
+- If you skipped local validation, say so in the completion JSON (e.g. `tests: skipped — relying on PR pipeline`) and still exit.
+- Holding a slot to watch a pipeline is wasted capacity; the engine has its own pipeline-monitoring path.
+
 ## Checking PR and Build Status
 
 When asked to check build status, CI results, or review state for a PR: