@yemi33/minions 0.1.1649 → 0.1.1651

package/engine/runtimes/copilot.js

@@ -31,6 +31,7 @@ const fs = require('fs');
 const https = require('https');
 const path = require('path');
 const { execSync } = require('child_process');
+const { FAILURE_CLASS, safeWrite, ts } = require('../shared');
 
 const ENGINE_DIR = __dirname.replace(/[\\/]runtimes$/, '');
 const isWin = process.platform === 'win32';
@@ -254,6 +255,88 @@ function buildArgs(opts = {}) {
   return args;
 }
 
+function buildSpawnFlags(opts = {}) {
+  const flags = ['--runtime', 'copilot'];
+  if (opts.maxTurns != null) flags.push('--max-turns', String(opts.maxTurns));
+  if (opts.model) flags.push('--model', String(opts.model));
+  if (opts.allowedTools) flags.push('--allowedTools', String(opts.allowedTools));
+  if (module.exports.capabilities.effortLevels && opts.effort) flags.push('--effort', String(opts.effort));
+  if (module.exports.capabilities.sessionResume && opts.sessionId) flags.push('--resume', String(opts.sessionId));
+  if (module.exports.capabilities.budgetCap && opts.maxBudget != null) flags.push('--max-budget-usd', String(opts.maxBudget));
+  if (module.exports.capabilities.bareMode && opts.bare === true) flags.push('--bare');
+  if (module.exports.capabilities.fallbackModel && opts.fallbackModel) flags.push('--fallback-model', String(opts.fallbackModel));
+  if (opts.stream != null && opts.stream !== '') flags.push('--stream', String(opts.stream));
+  if (opts.disableBuiltinMcps === true) flags.push('--disable-builtin-mcps');
+  if (opts.suppressAgentsMd === true) flags.push('--no-custom-instructions');
+  if (opts.reasoningSummaries === true) flags.push('--enable-reasoning-summaries');
+  return flags;
+}
+
+function getResumeSessionId({ agentId, branchName, agentsDir, maxAgeMs = 2 * 60 * 60 * 1000, logger = console } = {}) {
+  if (!agentId || agentId.startsWith('temp-') || !agentsDir) return null;
+  try {
+    const sessionPath = path.join(agentsDir, agentId, 'session.json');
+    const sessionFile = _safeJson(sessionPath);
+    if (!sessionFile?.sessionId || !sessionFile.savedAt) return null;
+    const sessionAge = Date.now() - new Date(sessionFile.savedAt).getTime();
+    const sameBranch = branchName && sessionFile.branch && sessionFile.branch === branchName;
+    if (sessionAge < maxAgeMs && sameBranch) {
+      if (logger && typeof logger.info === 'function') {
+        logger.info(`Resuming session ${sessionFile.sessionId} for ${agentId} on branch ${branchName} (age: ${Math.round(sessionAge / 60000)}min)`);
+      }
+      return sessionFile.sessionId;
+    }
+  } catch (e) {
+    if (logger && typeof logger.warn === 'function') logger.warn('session resume lookup: ' + e.message);
+  }
+  return null;
+}
+
+function saveSession({ agentId, dispatchId, branch, sessionId, agentsDir, now = ts, writeJson = safeWrite, logger = console } = {}) {
+  if (!sessionId || !agentId || agentId.startsWith('temp-') || !agentsDir) return false;
+  try {
+    writeJson(path.join(agentsDir, agentId, 'session.json'), {
+      sessionId,
+      dispatchId,
+      savedAt: typeof now === 'function' ? now() : new Date().toISOString(),
+      branch: branch || null,
+    });
+    return true;
+  } catch (err) {
+    if (logger && typeof logger.warn === 'function') logger.warn(`Session save: ${err.message}`);
+    return false;
+  }
+}
+
+function detectPermissionGate() {
+  return false;
+}
+
+function getPromptDeliveryMode() {
+  return 'stdin';
+}
+
+function usesSystemPromptFile() {
+  return false;
+}
+
+function _runtimeFailureClass(code) {
+  if (code === 'auth-failure' || code === 'budget-exceeded') return FAILURE_CLASS.PERMISSION_BLOCKED;
+  if (code === 'unknown-model') return FAILURE_CLASS.CONFIG_ERROR;
+  if (code === 'rate-limit') return FAILURE_CLASS.NETWORK_ERROR;
+  if (code === 'crash') return FAILURE_CLASS.SPAWN_ERROR;
+  return null;
+}
+
+function classifyFailure({ code, stdout = '', stderr = '', fallback } = {}) {
+  if (code === 78) return { failureClass: FAILURE_CLASS.CONFIG_ERROR, retryable: false, message: 'Copilot configuration error' };
+  const parsed = parseError(`${stdout || ''}\n${stderr || ''}`);
+  const runtimeClass = parsed.code ? _runtimeFailureClass(parsed.code) : null;
+  if (runtimeClass) return { failureClass: runtimeClass, retryable: parsed.retriable !== false, message: parsed.message || '' };
+  const fallbackClass = typeof fallback === 'function' ? fallback(code, stdout, stderr) : FAILURE_CLASS.UNKNOWN;
+  return { failureClass: fallbackClass, retryable: parsed.retriable !== false, message: parsed.message || '' };
+}
+
 // ── Prompt Construction ─────────────────────────────────────────────────────
 //
 // Copilot has no --system-prompt-file flag, so we deliver the system prompt
@@ -681,8 +764,15 @@ module.exports = {
   // Use the same wrapper as Claude — spawn-agent.js is runtime-agnostic per P-9c4f2d6a
   spawnScript: path.join(ENGINE_DIR, 'spawn-agent.js'),
   installHint: INSTALL_HINT,
+  buildSpawnFlags,
   buildArgs,
   buildPrompt,
+  getResumeSessionId,
+  saveSession,
+  detectPermissionGate,
+  getPromptDeliveryMode,
+  usesSystemPromptFile,
+  classifyFailure,
   resolveModel,
   parseOutput,
   parseStreamChunk,

package/engine/shared.js

@@ -230,6 +230,12 @@ function dispatchPromptSidecarPath(dispatchId) {
   return path.join(_promptContextsDir(), `${safeId}.md`);
 }
 
+function dispatchCompletionReportPath(dispatchId) {
+  if (!dispatchId) return null;
+  const safeId = String(dispatchId).replace(/[^a-zA-Z0-9._-]/g, '-');
+  return path.join(MINIONS_DIR, 'engine', 'completions', `${safeId}.json`);
+}
+
 /**
  * If the dispatch item's prompt exceeds thresholdBytes, write the full prompt
  * to engine/contexts/<id>.md and replace `item.prompt` with a short stub
@@ -716,7 +722,7 @@ const ENGINE_DEFAULTS = {
   autoFixBuilds: true, // auto-dispatch fix agents when a PR build fails
   meetingRoundTimeout: 900000, // 15min per meeting round before auto-advance
   evalLoop: true, // enable review→fix loop after implementation completes
-  evalMaxIterations: 3, // max review→fix cycles before escalating to human
+  evalMaxIterations: 3, // legacy UI/config field; engine discovery no longer enforces review→fix cycle caps
   evalMaxCost: null, // USD ceiling per work item across all eval iterations; null = no limit (gather baseline data first)
   maxRetries: 3, // max dispatch retries before marking work item as failed
   minRetryGapMs: 120000, // 2min — minimum gap between retry dispatches for the same work item; prevents tight retry loops when an idempotent agent (e.g. review bailing out on a duplicate) cannot produce the expected output (#1770)
@@ -727,7 +733,7 @@ const ENGINE_DEFAULTS = {
   logBufferSize: 50, // flush immediately when buffer exceeds this many entries
   lockRetries: 0, // no retries — single 5s timeout window with 25ms polling (200 attempts) is sufficient; stale lock recovery at 60s handles crashes
   lockRetryBackoffMs: 500, // base backoff between lock retries (doubles each attempt: 500ms, 1s, 2s, ...)
-  maxBuildFixAttempts: 3, // max consecutive auto-fix dispatch cycles per PR before escalation to human
+  maxBuildFixAttempts: 3, // legacy UI/config field; engine discovery no longer enforces build-fix attempt caps
   buildFixGracePeriod: 600000, // 10min — wait for CI to run after build fix before re-dispatching
   adoPollEnabled: true, // poll ADO PR status, comments, and reconciliation on each tick cycle
   ghPollEnabled: true, // poll GitHub PR status, comments, and reconciliation on each tick cycle
@@ -1171,7 +1177,7 @@ const ESCALATION_POLICY = {
 };
 
 // Structured completion protocol — fields agents must produce in ```completion blocks
-const COMPLETION_FIELDS = ['status', 'files_changed', 'tests', 'pr', 'pending', 'failure_class'];
+const COMPLETION_FIELDS = ['status', 'summary', 'files_changed', 'tests', 'pr', 'pending', 'failure_class', 'retryable', 'needs_rerun', 'verdict'];
 
 const DEFAULT_AGENT_METRICS = {
   tasksCompleted: 0, tasksErrored: 0,
@@ -1778,6 +1784,39 @@ function findPrRecord(prs, prRef, project = null) {
   return numberMatches.length === 1 ? numberMatches[0] : null;
 }
 
+function snapshotPrRecord(pr) {
+  if (pr === undefined) return undefined;
+  return JSON.parse(JSON.stringify(pr));
+}
+
+function _jsonEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+function _isPlainObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function applyPrFieldDelta(target, before, after) {
+  if (!target || typeof target !== 'object' || !after || typeof after !== 'object') return target;
+  before = before && typeof before === 'object' ? before : {};
+  const keys = new Set([...Object.keys(before), ...Object.keys(after)]);
+  for (const key of keys) {
+    const beforeValue = before[key];
+    const afterHas = Object.prototype.hasOwnProperty.call(after, key);
+    const afterValue = after[key];
+    if (_jsonEqual(beforeValue, afterValue)) continue;
+    if (!afterHas) {
+      delete target[key];
+    } else if (_isPlainObject(beforeValue) && _isPlainObject(afterValue) && _isPlainObject(target[key])) {
+      applyPrFieldDelta(target[key], beforeValue, afterValue);
+    } else {
+      target[key] = snapshotPrRecord(afterValue);
+    }
+  }
+  return target;
+}
+
 function normalizePrRecord(pr, project = null) {
   if (!pr || typeof pr !== 'object') return false;
   let changed = false;
@@ -2271,6 +2310,7 @@ module.exports = {
   safeUnlink,
   PROMPT_CONTEXTS_DIR,
   dispatchPromptSidecarPath,
+  dispatchCompletionReportPath,
   sidecarDispatchPrompt,
   resolveDispatchPrompt,
   deleteDispatchPromptSidecar,
@@ -2325,6 +2365,8 @@ module.exports = {
   isPrCompatibleWithProject,
   getCanonicalPrId,
   findPrRecord,
+  snapshotPrRecord,
+  applyPrFieldDelta,
   normalizePrRecord,
   normalizePrRecords,
   upsertPullRequestRecord,

package/engine/spawn-agent.js

@@ -94,7 +94,7 @@ function parseSpawnArgs(argv) {
  * Returns:
  *   {
  *     bin, leadingArgs, args,         // → spawn(execPath OR bin, [bin?, ...leadingArgs, ...args])
- *     deliveryMode,                   // 'stdin' | 'arg' (per runtime.capabilities.promptViaArg)
+ *     deliveryMode,                   // 'stdin' | 'arg' (runtime adapter decision)
  *     finalPrompt,                    // adapter-built prompt text (may include sysprompt for some runtimes)
  *     usingNodeShim,                  // true → runtime returned a non-native binary (Claude cli.js)
  *   }
@@ -103,9 +103,10 @@ function buildSpawnInvocation({ runtime, resolved, promptText, sysPromptText, op
   const finalPrompt = runtime.buildPrompt(promptText, sysPromptText);
   const adapterOpts = { ...opts };
   if (Array.isArray(addDirs) && addDirs.length) adapterOpts.addDirs = addDirs;
-  // When the adapter delivers the prompt via argv, hand it the prompt so it
-  // can splice `--prompt <text>` into its args.
-  if (runtime.capabilities && runtime.capabilities.promptViaArg) {
+  const deliveryMode = typeof runtime.getPromptDeliveryMode === 'function'
+    ? runtime.getPromptDeliveryMode(adapterOpts)
+    : (runtime.capabilities && runtime.capabilities.promptViaArg ? 'arg' : 'stdin');
+  if (deliveryMode === 'arg') {
     adapterOpts.prompt = finalPrompt;
   }
   const adapterArgs = runtime.buildArgs(adapterOpts);
@@ -115,7 +116,7 @@ function buildSpawnInvocation({ runtime, resolved, promptText, sysPromptText, op
     native,
     leadingArgs,
     args: [...adapterArgs, ...(passthrough || [])],
-    deliveryMode: runtime.capabilities && runtime.capabilities.promptViaArg ? 'arg' : 'stdin',
+    deliveryMode,
     finalPrompt,
     usingNodeShim: !native,
   };
@@ -159,7 +160,9 @@ function main() {
   // already merged inside `runtime.buildPrompt(prompt, sys)`.
   const isResume = opts.sessionId != null;
   const sysTmpPath = sysPromptFile + '.tmp';
-  const wantsSystemPromptFile = !isResume && runtime.capabilities && runtime.capabilities.systemPromptFile;
+  const wantsSystemPromptFile = typeof runtime.usesSystemPromptFile === 'function'
+    ? runtime.usesSystemPromptFile({ isResume, opts })
+    : (!isResume && runtime.capabilities && runtime.capabilities.systemPromptFile);
   if (wantsSystemPromptFile) {
     fs.writeFileSync(sysTmpPath, sysPromptText);
     opts.sysPromptFile = sysTmpPath;

package/engine/timeout.js

@@ -147,7 +147,7 @@ function checkTimeouts(config) {
   const engineRestartGraceUntil = engine().engineRestartGraceUntil;
   const engineRestartGraceExempt = engine().engineRestartGraceExempt;
   const { completeDispatch } = dispatch();
-  const { runPostCompletionHooks } = require('./lifecycle');
+  const { runPostCompletionHooks, parseAgentOutput, parseStructuredCompletion, detectNonTerminalResultSummary } = require('./lifecycle');
 
   const timeout = config.engine?.agentTimeout || ENGINE_DEFAULTS.agentTimeout;
   const defaultStaleOrphanTimeout = config.engine?.heartbeatTimeout || ENGINE_DEFAULTS.heartbeatTimeout;
@@ -257,12 +257,25 @@ function checkTimeouts(config) {
           safeWrite(outputLogPath, `# Output for dispatch ${item.id}\n# Exit code: ${processExitCode}\n# Completed: ${ts()}\n# Detected via output scan\n\n## Result\n${text || '(no text)'}\n`);
         } catch (e) { log('warn', 'parse output result: ' + e.message); }
 
-        completeDispatch(item.id, isSuccess ? DISPATCH_RESULT.SUCCESS : DISPATCH_RESULT.ERROR,
-          isSuccess ? 'Completed (detected from output)' : `Exited with code ${processExitCode} (detected from output)`);
+        const fullLogForHooks = safeRead(liveLogPath) || liveLogTail;
+        let completionDetection = null;
+        let outputResultSummary = '';
+        try {
+          const runtimeName = item.meta?.runtimeName || item.runtimeName || 'claude';
+          outputResultSummary = parseAgentOutput(fullLogForHooks, runtimeName).resultSummary || '';
+          const gateSummary = outputResultSummary || (!fullLogForHooks.includes('"type":') ? fullLogForHooks : '');
+          completionDetection = isSuccess
+            ? detectNonTerminalResultSummary(gateSummary, parseStructuredCompletion(fullLogForHooks, runtimeName))
+            : null;
+        } catch (e) { log('warn', 'completion summary gate: ' + e.message); }
+
+        completeDispatch(item.id, completionDetection ? DISPATCH_RESULT.ERROR : (isSuccess ? DISPATCH_RESULT.SUCCESS : DISPATCH_RESULT.ERROR),
+          completionDetection ? completionDetection.reason : (isSuccess ? 'Completed (detected from output)' : `Exited with code ${processExitCode} (detected from output)`),
+          outputResultSummary,
+          completionDetection ? { processWorkItemFailure: false } : {});
 
         // Run post-completion hooks via shared helper (async — fire and forget in timeout context).
         // Pass the actual exit code so autoRecovery (PR-created-but-failed) still works correctly.
-        const fullLogForHooks = safeRead(liveLogPath) || liveLogTail;
         runPostCompletionHooks(item, item.agent, processExitCode, fullLogForHooks, config).catch(e => log('warn', 'post-completion hooks: ' + e.message));
 
         if (hasProcess) {