@yemi33/minions 0.1.1651 → 0.1.1653

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.1653 (2026-05-01)
+
+### Fixes
+- exempt fix/test work items from PR contract when meta.pr is set
+
+## 0.1.1652 (2026-05-01)
+
+### Other
+- Harden agent steering reliability
+
 ## 0.1.1651 (2026-05-01)
 
 ### Other

package/dashboard/js/live-stream.js

@@ -136,12 +136,14 @@ async function sendSteering() {
           try {
             const liveRes = await fetch('/api/agent/' + encodeURIComponent(currentAgentId) + '/live-output');
             const text = await liveRes.text();
-            // Check if there's new output after the [human-steering] line
+            // Check if there's runtime output after the [human-steering] line.
+            // Claude emits "assistant"; Copilot emits "assistant.message_delta"
+            // / "assistant.message", and either one proves the resume turn ran.
             const steerIdx = text.lastIndexOf('[human-steering]');
             if (steerIdx >= 0) {
-              const afterSteer = text.slice(steerIdx + 100);
-              // Look for assistant response (JSON with type:assistant or readable text)
-              if (afterSteer.length > 200 && (afterSteer.includes('"type":"assistant"') || afterSteer.includes('"type":"text"'))) {
+              const afterSteer = text.slice(steerIdx + '[human-steering]'.length);
+              const sawRuntimeOutput = /"type"\s*:\s*"(assistant(?:\.|")|tool\.|session\.task_complete"|result")/.test(afterSteer);
+              if (afterSteer.length > 20 && sawRuntimeOutput) {
                 clearInterval(ackInterval);
                 pending.textContent = '\u2713 Agent acknowledged';
                 pending.style.color = 'var(--green)';

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-01T02:26:00.431Z"
+  "cachedAt": "2026-05-01T02:44:10.693Z"
 }

package/engine/lifecycle.js

@@ -924,6 +924,15 @@ function isPrAttachmentRequired(type, item, meta = {}) {
     || item.requiresPullRequest === true
     || item.itemType === 'pr';
   if (meta.branchStrategy === 'shared-branch' && item.itemType !== 'pr' && !explicit) return false;
+
+  // Fix/test work items dispatched against an existing PR don't produce a new
+  // PR — the agent updates meta.pr in place. Only require fresh PR attachment
+  // when there's NO existing PR to operate on (rare: standalone fix dispatched
+  // from CC without a PR target). The meta.pr short-circuit beats the
+  // explicit-flag fallthrough so a legacy requiresPr:true fix doesn't trigger
+  // the contract when there's already a PR attached.
+  if ((type === WORK_TYPE.FIX || type === WORK_TYPE.TEST) && meta?.pr) return false;
+
   return explicit
     || type === WORK_TYPE.IMPLEMENT
     || type === WORK_TYPE.IMPLEMENT_LARGE
@@ -2558,4 +2567,5 @@ module.exports = {
   diagnoseEmptyOutput,
   processPendingRebases,
   findDependentActivePrs,
+  isPrAttachmentRequired,
 };

package/engine/steering.js

@@ -162,6 +162,27 @@ function _processEvidenceTimes(rawOutput, observedAtMs) {
   return times;
 }
 
+function sessionIdFromEvent(obj) {
+  if (!obj || typeof obj !== 'object') return null;
+  const candidates = [
+    obj.session_id,
+    obj.sessionId,
+    obj.data?.session_id,
+    obj.data?.sessionId,
+  ];
+  for (const value of candidates) {
+    if (typeof value === 'string' && value.trim()) return value.trim();
+  }
+  if (obj.raw && obj.raw !== obj) return sessionIdFromEvent(obj.raw);
+  return null;
+}
+
+function sessionIdFromOutputLine(line) {
+  const trimmed = String(line || '').trim();
+  if (!trimmed.startsWith('{')) return null;
+  try { return sessionIdFromEvent(JSON.parse(trimmed)); } catch { return null; }
+}
+
 function ackProcessedSteeringMessages(agentId, pendingEntries, rawOutput, opts = {}) {
   const entries = Array.isArray(pendingEntries) ? pendingEntries : [];
   if (entries.length === 0) return [];
@@ -183,5 +204,7 @@ module.exports = {
   writeSteeringMessage,
   listUnreadSteeringMessages,
   buildPendingSteeringPrompt,
+  sessionIdFromEvent,
+  sessionIdFromOutputLine,
   ackProcessedSteeringMessages,
 };

package/engine.js

@@ -283,6 +283,7 @@ function _classifyAgentFailure(runtime, code, stdout, stderr) {
 
 function ackPendingSteeringFiles(agentId, procInfo, rawOutput, observedAtMs = Date.now()) {
   if (!procInfo?._pendingSteeringFiles?.length || !rawOutput) return;
+  if (procInfo._steeringMessage || procInfo._steeringNoSession) return;
   const acked = steering.ackProcessedSteeringMessages(agentId, procInfo._pendingSteeringFiles, rawOutput, { observedAtMs });
   if (acked.length === 0) return;
 
@@ -292,6 +293,45 @@ function ackPendingSteeringFiles(agentId, procInfo, rawOutput, observedAtMs = Da
   log('info', `Steering: ACKed ${acked.length} processed message(s) for ${agentId}`);
 }
 
+function captureSessionIdFromStdoutChunk(agentId, dispatchId, branchName, runtime, procInfo, chunk, state) {
+  if (!procInfo || procInfo.sessionId || !chunk) return;
+  const text = String(state.sessionLineBuffer || '') + String(chunk);
+  const lines = text.split('\n');
+  state.sessionLineBuffer = /[\r\n]$/.test(text) ? '' : (lines.pop() || '');
+  if (state.sessionLineBuffer.length > 65536) state.sessionLineBuffer = '';
+
+  for (const line of lines) {
+    const sessionId = steering.sessionIdFromOutputLine(line);
+    if (!sessionId) continue;
+    procInfo.sessionId = sessionId;
+    if (runtime && typeof runtime.saveSession === 'function') {
+      runtime.saveSession({
+        agentId,
+        dispatchId,
+        branch: branchName,
+        sessionId,
+        agentsDir: AGENTS_DIR,
+        logger: _runtimeLogger(),
+      });
+    }
+    return;
+  }
+}
+
+function mergePendingSteeringEntries(...groups) {
+  const merged = [];
+  const seen = new Set();
+  for (const group of groups) {
+    const entries = Array.isArray(group) ? group : (group ? [group] : []);
+    for (const entry of entries) {
+      if (!entry?.path || seen.has(entry.path)) continue;
+      seen.add(entry.path);
+      merged.push(entry);
+    }
+  }
+  return merged;
+}
+
 // Resolve dependency plan item IDs to their PR branches
 function resolveDependencyBranches(depIds, sourcePlan, project, config) {
   const results = []; // [{ branch, prId }]
@@ -1005,6 +1045,7 @@ async function spawnAgent(dispatchItem, config) {
   const MAX_OUTPUT = 1024 * 1024; // 1MB
   let stdout = '';
   let stderr = '';
+  const sessionCaptureState = { sessionLineBuffer: '' };
   let _trustCheckDone = false;
   const _spawnTime = Date.now();
 
@@ -1028,30 +1069,10 @@ async function spawnAgent(dispatchItem, config) {
       _trustCheckDone = true; // past 30s window
     }
 
-    // Capture sessionId early for mid-session steering
+    // Capture sessionId early for mid-session steering. Claude emits session_id;
+    // Copilot emits sessionId, so use the runtime-neutral steering helper.
     const procInfo = activeProcesses.get(id);
-    if (procInfo && !procInfo.sessionId && chunk.includes('session_id')) {
-      try {
-        for (const line of chunk.split('\n')) {
-          if (!line.trim() || !line.startsWith('{')) continue;
-          const obj = JSON.parse(line);
-          if (obj.session_id) {
-            procInfo.sessionId = obj.session_id;
-            if (runtime && typeof runtime.saveSession === 'function') {
-              runtime.saveSession({
-                agentId,
-                dispatchId: id,
-                branch: branchName,
-                sessionId: obj.session_id,
-                agentsDir: AGENTS_DIR,
-                logger: _runtimeLogger(),
-              });
-            }
-            break;
-          }
-        }
-      } catch { /* JSON parse — output may not be valid JSON */ }
-    }
+    captureSessionIdFromStdoutChunk(agentId, id, branchName, runtime, procInfo, chunk, sessionCaptureState);
 
     ackPendingSteeringFiles(agentId, procInfo, chunk);
   });
@@ -1112,8 +1133,12 @@ async function spawnAgent(dispatchItem, config) {
         }
       }
 
-      // Write new prompt with steering message
-      const steerPrompt = `Message from your human teammate:\n\n${steerMsg}\n\nRespond to this, then continue working on your current task.`;
+      // Write new prompt with all unACKed steering messages. This keeps delivery
+      // durable if the killed process had older pending messages that never
+      // produced processing evidence before the resume.
+      const pendingForResume = steering.buildPendingSteeringPrompt(agentId);
+      const steerPromptBody = pendingForResume.prompt || steerMsg;
+      const steerPrompt = `Message from your human teammate:\n\n${steerPromptBody}\n\nRespond to this, then continue working on your current task.`;
       const steerPromptPath = path.join(ENGINE_DIR, 'tmp', `prompt-steer-${safeId}.md`);
       try { safeWrite(steerPromptPath, steerPrompt); } catch (e) {
         log('warn', `Steering: failed to write prompt for ${agentId}: ${e.message}`);
@@ -1180,19 +1205,26 @@ async function spawnAgent(dispatchItem, config) {
         startedAt: procInfo.startedAt,
         sessionId: steerSessionId,
         lastRealOutputAt: Date.now(),
-        _pendingSteeringFiles: steerEntry ? [steerEntry] : (procInfo._pendingSteeringFiles || []),
+        _pendingSteeringFiles: mergePendingSteeringEntries(
+          procInfo._pendingSteeringFiles,
+          pendingForResume.entries,
+          steerEntry,
+        ),
       });
 
       // Reset output buffers so post-completion parsing only sees the resumed session
       stdout = '';
       stderr = '';
+      sessionCaptureState.sessionLineBuffer = '';
       // Re-wire stdout/stderr handlers (same as original)
       resumeProc.stdout.on('data', (data) => {
         const chunk = data.toString();
         realActivityMap.set(id, Date.now());
         if (stdout.length < MAX_OUTPUT) stdout += chunk.slice(0, MAX_OUTPUT - stdout.length);
         try { fs.appendFileSync(liveOutputPath, chunk); } catch { /* optional */ }
-        ackPendingSteeringFiles(agentId, activeProcesses.get(id), chunk);
+        const resumeInfo = activeProcesses.get(id);
+        captureSessionIdFromStdoutChunk(agentId, id, branchName, runtime, resumeInfo, chunk, sessionCaptureState);
+        ackPendingSteeringFiles(agentId, resumeInfo, chunk);
       });
       resumeProc.stderr.on('data', (data) => {
         const chunk = data.toString();

package/package.json

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