@yemi33/minions 0.1.1670 → 0.1.1671

package/CHANGELOG.md

@@ -1,9 +1,21 @@
 # Changelog
 
-## 0.1.1670 (2026-05-02)
+## 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/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-02T00:03:38.474Z"
+  "cachedAt": "2026-05-02T02:37:22.632Z"
 }

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/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/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/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.1671",
   "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: