@yemi33/minions 0.1.2382 → 0.1.2383

package/engine/agent-worker-pool.js

@@ -18,6 +18,7 @@
  *       worker exists and the pool is already at its configured size.
  *       WorkerHandle: {
  *         dispatchId,
+ *         currentModel,                       // ACP-selected session model
  *         stream(promptText, opts) → Promise,  // ACP session/prompt turn
  *         cancel(),                            // ACP session/cancel
  *         release(),                           // return the worker to the
@@ -133,7 +134,8 @@ function _pump() {
     const req = _queue[0];
 
     const matchIdx = _free.findIndex((w) =>
-      w.mcpServersHash === req.mcpServersHash
+      w.runtime === req.runtime
+      && w.mcpServersHash === req.mcpServersHash
       && w.processContextHash === req.processContextHash
     );
     if (matchIdx >= 0) {
@@ -230,6 +232,7 @@ async function _spawnFreshWorker(req) {
 // queued request can spawn its replacement.
 async function _bootWorker(req) {
   const worker = new Worker({
+    runtime: req.runtime,
     id: `agent-pool-${_nextWorkerId++}`,
     model: req.model,
     effort: req.effort,
@@ -312,7 +315,7 @@ function _clearLeaseContext(dispatchId) {
 }
 
 async function acquireWorker({
-  dispatchId, cwd, model, effort, mcpServers, hermeticDirs, processEnv, sessionContext,
+  runtime, dispatchId, cwd, model, effort, mcpServers, hermeticDirs, processEnv, sessionContext,
 } = {}) {
   if (!dispatchId) throw new Error('agent-worker-pool.acquireWorker: dispatchId is required');
   if (_draining) throw new Error('agent-worker-pool: draining');
@@ -324,6 +327,7 @@ async function acquireWorker({
   }
 
   const mcpServersHash = hashMcpServers(mcpServers);
+  const runtimeAdapter = transport.resolveWorkerRuntime(runtime);
   const workerProcessEnv = processEnv && typeof processEnv === 'object'
     ? Object.freeze({ ...processEnv })
     : undefined;
@@ -332,6 +336,7 @@ async function acquireWorker({
     ? { ...sessionContext }
     : {};
   const req = {
+    runtime: runtimeAdapter,
     dispatchId, cwd, model, effort, mcpServers, mcpServersHash,
     processEnv: workerProcessEnv, processContextHash,
   };
@@ -365,12 +370,14 @@ async function acquireWorker({
     dispatchId,
     // P-1d8f0b93 — exposed so engine.js's PooledAgentProcess facade (the
     // spawnAgent integration) can write the same PID-file/log identity a
-    // cold-spawned child_process would, and stamp the ACP sessionId into the
-    // synthesized `result` event for parseOutput parity. Both are read-time
+    // cold-spawned child_process would, stamp the ACP sessionId into the
+    // synthesized `result` event, and expose the model selected by session/new.
+    // All are read-time
     // snapshots of the underlying worker's current values (a getter, not a
     // captured copy), since sessionId can rotate under a reused worker.
     get pid() { return (worker.proc && worker.proc.pid) || null; },
     get sessionId() { return worker.sessionId || null; },
+    get currentModel() { return worker.currentModel || null; },
     stream: async (promptText, opts = {}) => {
       try {
         return await worker.stream(promptText, {

package/engine/cc-worker-pool.js

@@ -151,8 +151,9 @@ function _trace(...parts) {
 
 // ── Public API ────────────────────────────────────────────────────────────
 
-async function getSession({ tabId, model, effort, mcpServers, systemPromptHash, cwd } = {}) {
+async function getSession({ runtime, tabId, model, effort, mcpServers, systemPromptHash, cwd } = {}) {
   if (!tabId) throw new Error('cc-worker-pool.getSession: tabId is required');
+  const runtimeAdapter = transport.resolveWorkerRuntime(runtime);
   const mcpServersHash = _hashMcpServers(mcpServers);
   let worker = _tabs.get(tabId);
   // Track which lifecycle path we took so the dashboard's [cc-timing] log can
@@ -195,7 +196,7 @@ async function getSession({ tabId, model, effort, mcpServers, systemPromptHash,
     if (worker.killed) {
       _tabs.delete(tabId);
       worker = null;
-    } else if (worker.mcpServersHash !== mcpServersHash) {
+    } else if (worker.runtime !== runtimeAdapter || worker.mcpServersHash !== mcpServersHash) {
       // mcpServers shape changed → must respawn the proc; the daemon
       // resolves MCP server config at process boot, not per session.
       _tabs.delete(tabId);
@@ -222,6 +223,7 @@ async function getSession({ tabId, model, effort, mcpServers, systemPromptHash,
 
   if (!worker) {
     worker = new Worker({
+      runtime: runtimeAdapter,
       id: tabId, model, effort, mcpServers, mcpServersHash, systemPromptHash, cwd,
       internals: _internals, trace: _trace,
     });

package/engine/cli.js

@@ -9,6 +9,7 @@ const shared = require('./shared');
 const { safeRead, safeJson, safeJsonArr, safeWrite, readWorkItems, readPullRequests, mutateControl, mutateWorkItems, ts, WI_STATUS, WORK_TYPE, PLAN_STATUS, PR_STATUS, REVIEW_STATUS, DISPATCH_RESULT, FAILURE_CLASS } = shared;
 const queries = require('./queries');
 const agentWorkerPool = require('./agent-worker-pool');
+const { resolveCommentExecutionModel } = require('./execution-model');
 const { getConfig, getControl, getDispatch, getAgentStatus,
   MINIONS_DIR, ENGINE_DIR, AGENTS_DIR, PLANS_DIR, PRD_DIR, CONTROL_PATH } = queries;
 
@@ -2076,6 +2077,11 @@ const commands = {
       console.error('error: must supply either --body-file <path> or --body <text>');
       process.exit(2);
     }
+    const executionModel = resolveCommentExecutionModel({
+      dispatch: getDispatch(),
+      agentId,
+      workItemId,
+    });
 
     // ── Azure DevOps: <prNumber> --host ado --ado-org --ado-project --repo-id ──
     if (isAdo) {
@@ -2097,6 +2103,7 @@ const commands = {
       const adoComment = require('./ado-comment');
       adoComment.postAdoPrComment({
         orgBase, project, repositoryId, prNumber, body, agentId, kind, workItemId,
+        model: executionModel.model,
         resolved: flags.resolved === true,
       }).then((result) => {
         if (result && result.threadId) {
@@ -2135,7 +2142,7 @@ const commands = {
 
     try {
       const result = ghComment.postPrComment({
-        repo, prNumber, body, agentId, kind, workItemId,
+        repo, prNumber, body, agentId, kind, workItemId, model: executionModel.model,
       });
       if (result.output) console.log(result.output);
     } catch (e) {
@@ -2274,6 +2281,7 @@ module.exports = {
   _readDispatchPid: readDispatchPid,
   _normalizeSessionBranch: normalizeSessionBranch,
   _dispatchSessionBranch: dispatchSessionBranch,
+  _resolveCommentExecutionModel: resolveCommentExecutionModel, // exported for testing
   // W-mpcyvff6000pf828 (#2653) — heartbeat writer + factory exported for tests
   _writeHeartbeatNow: writeHeartbeatNow,
   _createHeartbeatInterval: createHeartbeatInterval,

package/engine/comment-format.js

@@ -48,14 +48,17 @@ function linkifyBrandTrailer(text) {
 // org/project/repoId).
 //
 // Marker format (single line, ASCII):
-//   <!-- minions:agent=<agentId> kind=<kind> wi=<workItemId> -->
+//   <!-- minions:agent=<agentId> kind=<kind> wi=<workItemId> model=<modelId> -->
 //
 // Validation (enforced before the marker is built):
 //   - agentId    /^[a-z][a-z0-9-]{0,30}$/
 //   - kind       /^[a-z][a-z0-9-]{0,30}$/
 //   - workItemId /^[A-Z]-[a-z0-9]+$/   (optional)
+//   - model       concrete runtime execution model (optional)
 //   - no field may contain `--` (would close the HTML comment early)
 
+const { normalizeExecutionModel } = require('./execution-model');
+
 const AGENT_ID_RE = /^[a-z][a-z0-9-]{0,30}$/;
 const KIND_RE = /^[a-z][a-z0-9-]{0,30}$/;
 const WORK_ITEM_ID_RE = /^[A-Z]-[a-z0-9]+$/;
@@ -63,7 +66,7 @@ const WORK_ITEM_ID_RE = /^[A-Z]-[a-z0-9]+$/;
 // Marker line (single-line HTML comment). Multiline flag so it matches at the
 // start of any line — required for round-trip detection of the builder output.
 const MINIONS_COMMENT_MARKER_RE =
-  /^<!--\s*minions:agent=([^\s]+)\s+kind=([^\s]+)(?:\s+wi=([^\s]+))?\s*-->/m;
+  /^<!--\s*minions:agent=([^\s]+)\s+kind=([^\s]+)(?:\s+wi=([^\s]+))?(?:\s+model=([^\s]+))?\s*-->/m;
 
 // Canonical-format sample marker for tests/fixtures that need a marked body but
 // don't care about the specific fields.
@@ -85,18 +88,44 @@ function _validateField(name, value, re) {
   }
 }
 
-function _validateMarkerInputs({ agentId, kind, workItemId }) {
+function _validateMarkerInputs({ agentId, kind, workItemId, model }) {
   _validateField('agentId', agentId, AGENT_ID_RE);
   _validateField('kind', kind, KIND_RE);
   if (workItemId !== undefined && workItemId !== null) {
     _validateField('workItemId', workItemId, WORK_ITEM_ID_RE);
   }
+  if (model !== undefined && model !== null && !normalizeExecutionModel(model)) {
+    throw new Error(`invalid model: ${JSON.stringify(model)}`);
+  }
+}
+
+function _encodeMarkerModel(model) {
+  const encoded = encodeURIComponent(model);
+  return encoded.includes('--') ? encoded.replace(/-/g, '%2D') : encoded;
 }
 
-function _buildMarker({ agentId, kind, workItemId }) {
-  _validateMarkerInputs({ agentId, kind, workItemId });
+function _buildMarker({ agentId, kind, workItemId, model }) {
+  _validateMarkerInputs({ agentId, kind, workItemId, model });
   const wi = (workItemId !== undefined && workItemId !== null) ? ` wi=${workItemId}` : '';
-  return `<!-- minions:agent=${agentId} kind=${kind}${wi} -->`;
+  const modelPart = model ? ` model=${_encodeMarkerModel(model)}` : '';
+  return `<!-- minions:agent=${agentId} kind=${kind}${wi}${modelPart} -->`;
+}
+
+const MODEL_SIGNOFF_RE =
+  /(\b(?:Review|Reviewed|Fixed|Verified|Rebased) by (?:Minions|\[Minions\]\([^)]+\)) \([^\r\n)]*? · )[^)\r\n]+(\))/g;
+
+function stampExecutionModel(text, model) {
+  const normalized = normalizeExecutionModel(model);
+  if (!normalized || typeof text !== 'string') return text;
+  return text.replace(MODEL_SIGNOFF_RE, (_match, prefix, suffix) => `${prefix}${normalized}${suffix}`);
+}
+
+function _stampLeadingMarkerModel(text, model) {
+  if (!model || typeof text !== 'string') return text;
+  return text.replace(MINIONS_COMMENT_MARKER_RE, (marker, agentId, kind, workItemId) => {
+    if (marker !== text.slice(0, marker.length)) return marker;
+    return _buildMarker({ agentId, kind, workItemId, model });
+  });
 }
 
 /**
@@ -106,41 +135,49 @@ function _buildMarker({ agentId, kind, workItemId }) {
  * Idempotency: if `body` already starts with a minions marker it is returned
  * with the brand transform applied but no second marker prepended.
  *
- * @param {{agentId:string, kind:string, workItemId?:string, body?:string}} args
+ * @param {{agentId:string, kind:string, workItemId?:string, model?:string, body?:string}} args
  * @returns {string} the final comment body
  */
-function buildMinionsCommentBody({ agentId, kind, workItemId, body }) {
+function buildMinionsCommentBody({ agentId, kind, workItemId, model, body }) {
   // Validate the inputs even when the body is pre-marked, so callers can't
   // silently bypass validation by pre-marking their body.
-  _validateMarkerInputs({ agentId, kind, workItemId });
+  _validateMarkerInputs({ agentId, kind, workItemId, model });
   let safeBody = body == null ? '' : String(body);
 
+  safeBody = stampExecutionModel(safeBody, model);
+
   // Brand-link safety net: deterministically hyperlink the first bare
   // "… by Minions" signature trailer (no-op when the agent already linked it).
   safeBody = linkifyBrandTrailer(safeBody);
 
-  if (_LEADING_MARKER_RE.test(safeBody)) return safeBody;
-  const marker = _buildMarker({ agentId, kind, workItemId });
+  if (_LEADING_MARKER_RE.test(safeBody)) return _stampLeadingMarkerModel(safeBody, model);
+  const marker = _buildMarker({ agentId, kind, workItemId, model });
   return `${marker}\n\n${safeBody}`;
 }
 
 /**
- * Inverse of the marker builder: parse `{agentId, kind, workItemId}` out of a
- * marked body, or null when no marker is present.
+ * Inverse of the marker builder: parse `{agentId, kind, workItemId, model?}`
+ * out of a marked body, or null when no marker is present.
  */
 function parseMinionsMarker(body) {
   if (typeof body !== 'string' || body.length === 0) return null;
   const m = body.match(MINIONS_COMMENT_MARKER_RE);
   if (!m) return null;
-  return {
+  const parsed = {
     agentId: m[1],
     kind: m[2],
     workItemId: m[3] === undefined ? undefined : m[3],
   };
+  if (m[4] !== undefined) {
+    try { parsed.model = decodeURIComponent(m[4]); }
+    catch { return null; }
+  }
+  return parsed;
 }
 
 module.exports = {
   linkifyBrandTrailer,
+  stampExecutionModel,
   MINIONS_BRAND_URL,
   // Neutral marker + body builder (consumed by gh-comment.js and ado-comment.js).
   buildMinionsCommentBody,

package/engine/dispatch.js

@@ -978,7 +978,12 @@ function markCompletedSourceWorkItem(item) {
 // ─── Complete Dispatch ───────────────────────────────────────────────────────
 
 function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', resultSummary = '', opts = {}) {
-  const { processWorkItemFailure = true, processWorkItemSuccess = false, failureClass } = opts;
+  const {
+    processWorkItemFailure = true,
+    processWorkItemSuccess = false,
+    countAgentRetryFailure = true,
+    failureClass,
+  } = opts;
   const agentRetryable = normalizeRetryableDecision(opts.agentRetryable ?? opts.retryable);
   let item = null;
   let completedSourceWorkItem = false;
@@ -1185,7 +1190,7 @@ function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', res
                   // agent hits the threshold. Skip when no agent is resolvable
                   // (anonymous failures shouldn't corrupt the map shape).
                   const failedAgent = item.agent || wi.dispatched_to;
-                  if (failedAgent) shared.bumpAgentRetryCount(wi, failedAgent);
+                  if (failedAgent && countAgentRetryFailure) shared.bumpAgentRetryCount(wi, failedAgent);
                   delete wi.failReason;
                   delete wi.failedAt;
                   delete wi.dispatched_at;

package/engine/execution-model.js

@@ -0,0 +1,68 @@
+/**
+ * Runtime-model evidence shared by dispatch, PR-comment, and review persistence.
+ *
+ * Priority is deliberate: runtime completion output is authoritative, an
+ * earlier stream/session capture is next, and the requested model is only a
+ * fallback when Minions explicitly sent one to the runtime. No catalog-based
+ * default inference belongs here.
+ */
+
+const UNKNOWN_MODEL = 'unknown';
+const MODEL_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/;
+
+function normalizeExecutionModel(value) {
+  if (typeof value !== 'string') return null;
+  const model = value.trim();
+  return MODEL_ID_RE.test(model) ? model : null;
+}
+
+function resolveExecutionModel({
+  reportedModel,
+  capturedModel,
+  requestedModel,
+} = {}) {
+  for (const [source, value] of [
+    ['reported', reportedModel],
+    ['captured', capturedModel],
+    ['requested', requestedModel],
+  ]) {
+    const model = normalizeExecutionModel(value);
+    if (model) return { model, source };
+  }
+  return { model: UNKNOWN_MODEL, source: 'unknown' };
+}
+
+function _dispatchWorkItemId(item) {
+  return item?.meta?.item?.id
+    || item?.meta?.workItemId
+    || item?.workItemId
+    || null;
+}
+
+function resolveCommentExecutionModel({
+  dispatch,
+  agentId,
+  workItemId,
+} = {}) {
+  const active = Array.isArray(dispatch?.active) ? dispatch.active : [];
+  const candidates = active.filter((item) => {
+    if (String(item?.agent || '').toLowerCase() !== String(agentId || '').toLowerCase()) return false;
+    if (!workItemId) return true;
+    return item.id === workItemId || _dispatchWorkItemId(item) === workItemId;
+  });
+  candidates.sort((a, b) => String(b.started_at || '').localeCompare(String(a.started_at || '')));
+  const item = candidates[0] || null;
+  if (!item) return { model: null, source: 'none' };
+  return resolveExecutionModel({
+    capturedModel: item?.executionModel,
+    requestedModel: item?.requestedModel,
+  });
+}
+
+module.exports = {
+  UNKNOWN_MODEL,
+  MODEL_ID_RE,
+  normalizeExecutionModel,
+  resolveExecutionModel,
+  resolveCommentExecutionModel,
+};

package/engine/gh-comment.js

@@ -4,7 +4,7 @@
  * minions-authored PR comments by structure rather than by body shape.
  *
  * Marker format (single line, ASCII):
- *   <!-- minions:agent=<agentId> kind=<kind> wi=<workItemId> -->
+ *   <!-- minions:agent=<agentId> kind=<kind> wi=<workItemId> model=<modelId> -->
  *
  * Followed by `\n\n` and then the caller-provided body. `wi=` is omitted when
  * no workItemId is supplied. The marker is intentionally minimal so it round-
@@ -14,6 +14,7 @@
  *   - agentId    /^[a-z][a-z0-9-]{0,30}$/  (lowercase, hyphenated, ≤31 chars)
  *   - kind       /^[a-z][a-z0-9-]{0,30}$/  (same shape — categorical tag)
  *   - workItemId /^[A-Z]-[a-z0-9]+$/       (e.g. W-mp3bp0ha000997ab, P-d5a8c9b6)
+ *   - model      concrete runtime model, when active-dispatch evidence exists
  *   - no field may contain `--` (would close the HTML comment early)
  *   - no field may contain `=` `<` `>` `\n` `"` `'` `` ` ``  ` `  (whitespace)
  *
@@ -153,13 +154,14 @@ function postPrComment({
   agentId,
   kind,
   workItemId,
+  model,
   timeoutMs = 30000,
   execFileSync = _execFileSync,
   resolveTokenForSlug,
 } = {}) {
   _validateRepo(repo);
   _validatePrNumber(prNumber);
-  const finalBody = buildMinionsCommentBody({ agentId, kind, workItemId, body });
+  const finalBody = buildMinionsCommentBody({ agentId, kind, workItemId, model, body });
   const file = _writeTempBodyFile(finalBody);
   const env = _resolveTokenEnvForRepo(repo, resolveTokenForSlug);
   try {
@@ -182,13 +184,14 @@ function postPrReviewComment({
   agentId,
   kind,
   workItemId,
+  model,
   timeoutMs = 30000,
   execFileSync = _execFileSync,
   resolveTokenForSlug,
 } = {}) {
   _validateRepo(repo);
   _validatePrNumber(prNumber);
-  const finalBody = buildMinionsCommentBody({ agentId, kind, workItemId, body });
+  const finalBody = buildMinionsCommentBody({ agentId, kind, workItemId, model, body });
   const file = _writeTempBodyFile(finalBody);
   const env = _resolveTokenEnvForRepo(repo, resolveTokenForSlug);
   try {

package/engine/github.js

@@ -282,10 +282,10 @@ async function _resolveViewerLogin(slug) {
 // `_isMinionsAuthoredComment` cannot tell minions posts apart from human
 // posts (the `viewerDidAuthor` gate stays false for everything), so the
 // comment classifier reclassifies every minions comment as human and
-// queues a spurious fix dispatch on every poll cycle. The downstream
-// `check-self-authored-review-comment` skill no-ops the dispatch, so this
-// is a slot/token tax rather than state corruption — but the frequency
-// data is worth tracking so future audits can prioritize a deeper fix
+// queues a spurious fix dispatch on every poll cycle. Review-fix completion
+// now rejects shared-identity-only no-ops, so failing closed here prevents
+// both duplicate traffic and false completion retries. The frequency
+// data is still worth tracking so future audits can prioritize a deeper fix
 // (e.g. a credentialed re-probe of the gh CLI). Global counter under
 // `_engine.viewerLoginResolutionFailures`; surfaced through the existing
 // engine metrics aggregation (`getMetrics()` in `engine/queries.js`).
@@ -1241,9 +1241,8 @@ async function pollPrHumanComments(config) {
     // `c.viewerDidAuthor === true`, and `_backfillViewerDidAuthor` is a
     // no-op when viewerLogin is null. Running the classifier without a
     // login mass-misclassifies every minions comment as human and queues
-    // a redundant fix dispatch on every poll cycle (the downstream
-    // `check-self-authored-review-comment` skill no-ops them, so this is
-    // a slot/token tax — see audit OQ-Y, HIGH not CRITICAL). Skip the
+    // a redundant fix dispatch on every poll cycle. Shared identity is not
+    // valid review-fix no-op evidence, so skip the
     // entire round instead. One log + one counter increment per affected
     // PR per cycle (no per-comment fanout).
     if (!viewerLogin) {