@yemi33/minions 0.1.2424 → 0.1.2425

package/engine/cli.js

@@ -23,6 +23,17 @@ function engine() {
 let _dispatchModule = null;
 function dispatchModule() { if (!_dispatchModule) _dispatchModule = require('./dispatch'); return _dispatchModule; }
 
+function spawnPendingDispatch(e, item, config) {
+  return e._withSpawnAttemptLease(
+    item.id,
+    e.tickGeneration,
+    (lease) => e.spawnAgent(item, config, lease),
+  ).catch((err) => {
+    e.log('error', `Immediate spawn failed for ${item.id}: ${err.message}`);
+    return null;
+  });
+}
+
 function normalizeSessionBranch(branch) {
   if (!branch) return null;
   return String(branch).replace(/^refs\/heads\//, '');
@@ -635,7 +646,33 @@ const commands = {
           continue;
         }
 
-        let agentPid = readDispatchPid(item.id);
+        let agentPid = null;
+        let hadPid = false;
+        if (item.runtimePid) {
+          let persistedRuntimePid = null;
+          try { persistedRuntimePid = shared.validatePid(item.runtimePid); } catch { persistedRuntimePid = null; }
+          if (persistedRuntimePid) {
+            hadPid = true;
+            if (isPidAlive(persistedRuntimePid)) agentPid = persistedRuntimePid;
+          }
+        }
+        if (!agentPid) {
+          const filePid = readDispatchPid(item.id);
+          if (filePid) {
+            agentPid = filePid;
+            hadPid = true;
+          }
+        }
+        if (!agentPid && item._spawnPhase === 'launching') {
+          e.engineRestartGraceExempt.add(item.id);
+          e.log('info', `Restart: ${agentId} (${item.id}) stopped during pre-launch handoff — marking for retry`);
+          continue;
+        }
+        if (!agentPid && hadPid) {
+          e.engineRestartGraceExempt.add(item.id);
+          e.log('info', `Restart: ${agentId} (${item.id}) had no live runtime PID — marking for retry`);
+          continue;
+        }
 
         if (!agentPid) {
           const status = getAgentStatus(agentId);
@@ -651,7 +688,6 @@ const commands = {
           }
         }
 
-        const hadPid = agentPid && agentPid > 0; // track before liveness check
         if (agentPid && agentPid > 0 && !isPidAlive(agentPid)) agentPid = null;
         if (agentPid && !shared.isDispatchExecutionPathSafe(item, config)) {
           e.log('warn', `Reattach: refusing ${item.id} — persisted execution path is not safe under current checkout config`);
@@ -999,8 +1035,12 @@ const commands = {
         const cfg = require('./queries').getConfig();
         const projects = sharedMod.getProjects(cfg);
         if (projects.length === 0) return;
+        const worktreeProjects = projects.filter((project) => {
+          try { return !sharedMod.isLiveCheckoutProject(project); }
+          catch { return false; }
+        });
         const worktreeRootRel = cfg?.engine?.worktreeRoot || sharedMod.ENGINE_DEFAULTS.worktreeRoot;
-        const result = worktreeGc.pruneOrphanWorktrees({
+        const reconcileResult = worktreeGc.reconcileStaleWorktreeDirectories({
           projects,
           dispatchSnap,
           worktreeRootRel,
@@ -1008,6 +1048,19 @@ const commands = {
           config: cfg,
           writeToInbox: (a, s, c) => { try { return sharedMod.writeToInbox(a, s, c); } catch (_e) { return false; } },
         });
+        if (reconcileResult.removed > 0 || reconcileResult.failed > 0) {
+          console.log(`  Worktree filesystem reconcile: removed ${reconcileResult.removed} stale director${reconcileResult.removed === 1 ? 'y' : 'ies'}, kept ${reconcileResult.kept}, failed ${reconcileResult.failed} (scanned ${reconcileResult.scanned})`);
+        }
+        const result = worktreeGc.pruneOrphanWorktrees({
+          projects: worktreeProjects,
+          dispatchSnap,
+          worktreeRootRel,
+          log: (lvl, msg) => e.log(lvl, msg),
+          config: cfg,
+          writeToInbox: (a, s, c) => { try { return sharedMod.writeToInbox(a, s, c); } catch (_e) { return false; } },
+          protectedPaths: reconcileResult.protectedPaths,
+          failedRoots: reconcileResult.failedRoots,
+        });
         if (result.evicted > 0 || result.failed > 0) {
           console.log(`  Worktree boot reconcile: evicted ${result.evicted} orphan worktree(s)${result.failed ? `, ${result.failed} failed` : ''} (scanned ${result.scanned}, kept ${result.kept})`);
         }
@@ -1018,7 +1071,7 @@ const commands = {
         // consistent. Also runs `git worktree prune --expire=now` per project
         // so manually-removed dirs drop out of the registry immediately.
         const regResult = worktreeGc.pruneOrphanWorktreesFromGitRegistry({
-          projects,
+          projects: worktreeProjects,
           dispatchSnap,
           worktreeRootRel,
           log: (lvl, msg) => e.log(lvl, msg),
@@ -1400,8 +1453,13 @@ const commands = {
     const eng = config.engine || {};
     const defaultCli = shared.resolveAgentCli(null, eng);
     const defaultModelResolved = shared.resolveAgentModel(null, eng);
+    const defaultModelDisplay = queries.resolveRuntimeModelDisplay({
+      runtime: defaultCli,
+      configuredModel: defaultModelResolved,
+      dispatch: getDispatch(),
+    });
     console.log(`Default CLI: ${defaultCli}${eng.defaultCli ? '' : ' (default)'}`);
-    console.log(`Default model: ${defaultModelResolved || '(runtime default)'}`);
+    console.log(`Default model: ${defaultModelDisplay.model || '(runtime model not observed yet)'}`);
     const ccCliOverride = (eng.ccCli !== undefined && eng.ccCli !== null && eng.ccCli !== '') ? String(eng.ccCli) : null;
     const ccModelOverride = (eng.ccModel !== undefined && eng.ccModel !== null && eng.ccModel !== '') ? String(eng.ccModel) : null;
     if (ccCliOverride || ccModelOverride) {
@@ -1556,7 +1614,7 @@ const commands = {
     const dispatch = getDispatch();
     const item = dispatch.pending.find(d => d.id === id);
     if (item) {
-      e.spawnAgent(item, config);
+      spawnPendingDispatch(e, item, config);
     }
   },
 
@@ -1764,7 +1822,7 @@ const commands = {
       const dispatch = getDispatch();
       const item = dispatch.pending.find(d => d.id === id);
       if (item) {
-        e.spawnAgent(item, config);
+        spawnPendingDispatch(e, item, config);
         console.log('Agent spawned immediately.');
       }
     } else {

package/engine/comment-classifier.js

@@ -8,8 +8,8 @@
  *     signatures + Coverage/Build/Test/Deploy/Pipeline report headings +
  *     shields.io-style badge images. Ported from engine/github.js
  *     `_isPreviewStatusComment` body checks. ADO has no `user.type === 'bot'`
- *     equivalent, so the GH-side bot-author gate stays in github.js — this
- *     module's body match is what both pollers consume.
+ *     equivalent, so only the narrower `_isPreviewStatusComment` helper keeps
+ *     a GH-side bot-author gate; both pollers consume this body match directly.
  *
  *   hasMinionsMarker(body) — structural `<!-- minions:agent=… kind=… -->`
  *     check using gh-comment.MINIONS_COMMENT_MARKER_RE. Strict: marker must
@@ -29,9 +29,14 @@
  *     mid-paragraph mentions are rejected (line-start anchor + only `**`,
  *     `__`, `#+` allowed before `VERDICT:`).
  *
- * IMPORTANT — author identity is intentionally NOT consulted here. These are
- * body-only predicates. Callers MUST combine them with their own identity
- * gates before treating a comment as agent-authored:
+ * The reason-returning `classifyNonActionableAutomationComment()` composes
+ * `isPreviewStatusBody()` with exact host-specific automation envelopes.
+ * Unlike the body predicates, it also receives trusted host author metadata
+ * so a copied marker cannot suppress actionable feedback.
+ *
+ * IMPORTANT — author identity is intentionally NOT consulted by the three
+ * body-only predicates above. Callers MUST combine Minions marker matches with
+ * their own identity gates before treating a comment as agent-authored:
  *
  *   GitHub: `comment.viewerDidAuthor === true`, backfilled via `gh api user`
  *           by engine/github.js `_backfillViewerDidAuthor`. The combined
@@ -80,6 +85,29 @@ const _FIREBASE_HOSTING_LEAD_RE = /^Firebase\s+Hosting\b/im;
 const _DEPLOY_READY_RE =
   /\b(?:deploy|deployment|preview)\s+(?:ready|available|succeeded|complete|completed)\b/i;
 
+const NON_ACTIONABLE_AUTOMATION_REASONS = Object.freeze({
+  PREVIEW_STATUS: 'preview-status',
+  GITHUB_VISUAL_EVIDENCE: 'github-visual-evidence',
+  ADO_PR_ASSISTANT_STATUS: 'ado-pr-assistant-status',
+});
+
+// GitHub's global Actions bot identity. All fields are API-controlled.
+const _GITHUB_ACTIONS_BOT = Object.freeze({
+  login: 'github-actions[bot]',
+  type: 'bot',
+  id: 41898282,
+});
+
+const _VISUAL_EVIDENCE_ENVELOPE_RE =
+  /^<!-- minions:visual-evidence -->\r?\n<!-- visual-evidence-head:[0-9a-f]{40} -->\r?\n<!-- visual-evidence-run:[1-9]\d* -->\r?\n\r?\n### (?:Visual evidence capture failed|Visual evidence is stale|Visual evidence)(?:\r?\n|$)/;
+
+const _ADO_GITOPS_AUTHOR = 'gitops (git lowpriv)';
+const _ADO_PR_ASSISTANT_HEADER =
+  `<span style="font-family:'Segoe UI',SegoeUI,Segoe,'Helvetica Neue',Arial,sans-serif; font-size:14px; font-weight:600;">PR Assistant</span>`;
+const _ADO_PR_ASSISTANT_STATUS = 'Pull request description has been updated with summary.';
+const _ADO_CONFIG_LEVEL_PREFIX = '<small class="secondary-text">Config Level:';
+const _ADO_GITOPS_USER_AGENT = '<!-- GitOpsUserAgent=GitOps.Apps.Server.pullrequestcopilot -->';
+
 function isPreviewStatusBody(body) {
   const text = String(body || '');
   if (!text) return false;
@@ -94,6 +122,41 @@ function isPreviewStatusBody(body) {
   return false;
 }
 
+function _isGitHubVisualEvidenceStatus(body, author) {
+  if (String(author?.login || '').toLowerCase() !== _GITHUB_ACTIONS_BOT.login) return false;
+  if (String(author?.type || '').toLowerCase() !== _GITHUB_ACTIONS_BOT.type) return false;
+  if (Number(author?.id) !== _GITHUB_ACTIONS_BOT.id) return false;
+  return _VISUAL_EVIDENCE_ENVELOPE_RE.test(String(body || ''));
+}
+
+function _isAdoPrAssistantStatus(body, author) {
+  if (String(author?.displayName || '').trim().toLowerCase() !== _ADO_GITOPS_AUTHOR) return false;
+
+  const text = String(body || '');
+  if (!text.startsWith(_ADO_PR_ASSISTANT_HEADER)) return false;
+  if (!text.trimEnd().endsWith(_ADO_GITOPS_USER_AGENT)) return false;
+
+  const afterHeader = text.slice(_ADO_PR_ASSISTANT_HEADER.length);
+  const configIndex = afterHeader.indexOf(_ADO_CONFIG_LEVEL_PREFIX);
+  if (configIndex === -1) return false;
+  return afterHeader.slice(0, configIndex).trim() === _ADO_PR_ASSISTANT_STATUS;
+}
+
+function classifyNonActionableAutomationComment({ host, body, author } = {}) {
+  if (isPreviewStatusBody(body)) {
+    return NON_ACTIONABLE_AUTOMATION_REASONS.PREVIEW_STATUS;
+  }
+
+  const normalizedHost = String(host || '').toLowerCase();
+  if (normalizedHost === 'github' && _isGitHubVisualEvidenceStatus(body, author)) {
+    return NON_ACTIONABLE_AUTOMATION_REASONS.GITHUB_VISUAL_EVIDENCE;
+  }
+  if (normalizedHost === 'ado' && _isAdoPrAssistantStatus(body, author)) {
+    return NON_ACTIONABLE_AUTOMATION_REASONS.ADO_PR_ASSISTANT_STATUS;
+  }
+  return null;
+}
+
 // ── Structural Minions marker ──────────────────────────────────────────────
 //
 // MINIONS_COMMENT_MARKER_RE uses the /m flag so its `^` anchor matches the
@@ -151,4 +214,6 @@ module.exports = {
   isPreviewStatusBody,
   hasMinionsMarker,
   hasVerdictPrefix,
+  classifyNonActionableAutomationComment,
+  NON_ACTIONABLE_AUTOMATION_REASONS,
 };

package/engine/consolidation.js

@@ -15,6 +15,8 @@ const queries = require('./queries');
 const { getInboxFiles, getNotes, INBOX_DIR, ENGINE_DIR,
   NOTES_PATH, KNOWLEDGE_DIR, ARCHIVE_DIR } = queries;
 const { wrapUntrusted, buildSource } = require('./untrusted-fence');
+const reviewLearning = require('./review-learning');
+const memoryStore = require('./memory-store');
 
 // notes.md size cap. Consolidation appends to notes.md every cycle; without a
 // cap it grows unbounded.
@@ -836,13 +838,114 @@ let _consolidationStartedAt = 0;
 let _forceResetTimeout = null; // force-reset handle; cancelled by _clearProcessingState
 const _processingFiles = new Set(); // files currently being consolidated (race guard)
 
+const LEGACY_REVIEW_FEEDBACK_FILE_RE =
+  /^feedback-.+-from-.+-\d{4}-\d{2}-\d{2}\.md$/;
+
+function _flatFrontmatter(content) {
+  const match = String(content || '').match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return {};
+  const fields = {};
+  for (const line of match[1].split(/\r?\n/)) {
+    const field = line.match(/^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/);
+    if (field) fields[field[1].toLowerCase()] = field[2].trim();
+  }
+  return fields;
+}
+
+function _legacyReviewProject(config, projectName, prId) {
+  const projects = shared.getProjects(config);
+  const named = projects.find(project => String(project?.name || '').toLowerCase() === projectName);
+  if (named) return named;
+  const prScope = String(prId || '').replace(/#[1-9]\d*$/, '').toLowerCase();
+  return projects.find(project => String(shared.getProjectPrScope(project) || '').toLowerCase() === prScope) || null;
+}
+
+function _captureLegacyReviewFeedback(item, config) {
+  const fields = _flatFrontmatter(item.content);
+  const author = String(fields.author || '').toLowerCase();
+  const reviewer = String(fields.reviewer || '').toLowerCase();
+  if (fields.agent && String(fields.agent).toLowerCase() !== 'feedback') {
+    throw new TypeError(`legacy review feedback ${item.name} has non-feedback provenance`);
+  }
+  if (!/^[a-z][a-z0-9-]{1,63}$/.test(author) || !/^[a-z][a-z0-9-]{1,63}$/.test(reviewer)
+      || !item.name.startsWith(`feedback-${author}-from-${reviewer}-`)) {
+    throw new TypeError(`legacy review feedback ${item.name} author/reviewer does not match its filename`);
+  }
+  const prId = reviewLearning.normalizeCanonicalPrId(fields.sourcepr);
+  const project = _legacyReviewProject(config, String(fields.project || '').toLowerCase(), prId);
+  const projectName = project?.name || fields.project;
+  if (!projectName) throw new TypeError(`legacy review feedback ${item.name} has no project scope`);
+  const host = prId.slice(0, prId.indexOf(':'));
+  const sourceHash = reviewLearning.hashReviewCommentContent(item.content);
+  const sourceIdentity = crypto.createHash('sha256').update(item.name).digest('hex').slice(0, 24);
+  const findingKey = reviewLearning.buildFindingKey({
+    project: projectName,
+    prId,
+    sourceKey: `${host}:legacy-feedback:${sourceIdentity}`,
+  });
+  const candidate = reviewLearning.upsertReviewLearningCandidate({
+    findingKey,
+    project: projectName,
+    prId,
+    authorAgent: author,
+    reviewerAgent: reviewer,
+    sourceHash,
+    workItemId: fields.sourceitem || null,
+    dispatchId: fields.dispatchid || null,
+    metadata: {
+      legacyUnverified: true,
+      legacySourceRef: item.name,
+      backfilledBy: 'inbox-consolidation',
+    },
+  });
+  memoryStore.recordMemoryLifecycleEvent({
+    eventType: 'candidate-created',
+    memoryId: candidate.id,
+    findingKey,
+    project: projectName,
+    agent: author,
+    workItemId: fields.sourceitem || null,
+    dispatchId: fields.dispatchid || null,
+    metadata: {
+      legacyUnverified: true,
+      legacySourceRef: item.name,
+      sourceHash,
+    },
+  });
+}
+
+function divertLegacyReviewFeedback(items, config) {
+  const remaining = [];
+  const diverted = [];
+  for (const item of Array.isArray(items) ? items : []) {
+    if (!LEGACY_REVIEW_FEEDBACK_FILE_RE.test(String(item?.name || ''))) {
+      remaining.push(item);
+      continue;
+    }
+    try {
+      _captureLegacyReviewFeedback(item, config);
+    } catch (err) {
+      if (!(err instanceof TypeError)) {
+        log('warn', `Legacy review feedback backfill deferred for ${item.name}: ${err.message}`);
+        continue;
+      }
+      log('warn', `Legacy review feedback has invalid provenance and will be archived (${item.name}): ${err.message}`);
+    }
+    diverted.push(item.name);
+  }
+  if (diverted.length > 0) {
+    archiveInboxFiles(diverted);
+    log('info', `Diverted ${diverted.length} legacy review feedback file(s) from broad memory`);
+  }
+  return remaining;
+}
+
 function consolidateInbox(config) {
 
   const { ENGINE_DEFAULTS } = shared;
   const threshold = config.engine?.inboxConsolidateThreshold || ENGINE_DEFAULTS.inboxConsolidateThreshold;
   const pinnedInboxKeys = new Set(shared.getPinnedItems().filter(k => k.startsWith('notes/inbox/')));
-  const files = getInboxFiles().filter(f => !_processingFiles.has(f) && !pinnedInboxKeys.has('notes/inbox/' + f));
-  if (files.length < threshold) return;
+  const candidateFiles = getInboxFiles().filter(f => !_processingFiles.has(f) && !pinnedInboxKeys.has('notes/inbox/' + f));
   // Auto-reset stale flag if consolidation has been running for >5 minutes (process died without cleanup)
   if (_consolidationInFlight && (Date.now() - _consolidationStartedAt) > 300000) {
     log('warn', 'Consolidation flag was stale (>5m) — resetting');
@@ -851,12 +954,15 @@ function consolidateInbox(config) {
   }
   if (_consolidationInFlight) return;
 
-  log('info', `Consolidating ${files.length} inbox items into notes.md`);
-
-  const items = files.map(f => ({
+  const candidateItems = candidateFiles.map(f => ({
     name: f,
     content: safeRead(path.join(INBOX_DIR, f)) || ''
   }));
+  const items = divertLegacyReviewFeedback(candidateItems, config);
+  const files = items.map(item => item.name);
+  if (files.length < threshold) return;
+
+  log('info', `Consolidating ${files.length} inbox items into notes.md`);
 
   const existingNotes = getNotes() || '';
   consolidateWithLLM(items, existingNotes, files, config);
@@ -942,6 +1048,11 @@ Use today's date: ${dateStamp()}`;
 
 function consolidateWithLLM(items, existingNotes, files, config) {
 
+  items = divertLegacyReviewFeedback(items, config);
+  const allowedFiles = new Set(items.map(item => item.name));
+  files = files.filter(file => allowedFiles.has(file));
+  if (files.length === 0) return;
+
   // Cancel any stale force-reset from a prior run before starting fresh
   clearTimeout(_forceResetTimeout);
   _forceResetTimeout = null;
@@ -1103,6 +1214,11 @@ function consolidateWithLLM(items, existingNotes, files, config) {
 
 function consolidateWithRegex(items, files, config) {
 
+  items = divertLegacyReviewFeedback(items, config);
+  const allowedFiles = new Set(items.map(item => item.name));
+  files = files.filter(file => allowedFiles.has(file));
+  if (files.length === 0) return;
+
   const allInsights = [];
   for (const item of items) {
     const content = item.content || '';
@@ -1327,6 +1443,7 @@ function buildCondensedKbBody(content, titleLine, archiveRelPath) {
 
 async function classifyToKnowledgeBase(items, config) {
 
+  items = divertLegacyReviewFeedback(items, config);
   if (!fs.existsSync(KNOWLEDGE_DIR)) fs.mkdirSync(KNOWLEDGE_DIR, { recursive: true });
 
   const knownAgents = config && config.agents
@@ -1571,6 +1688,7 @@ module.exports = {
   NOTES_MAX_BYTES,
   hasReusableSignal,
   buildCondensedKbBody,
+  divertLegacyReviewFeedback, // exported for testing
   _alertContentHash,
   _alertHashExists,
   _writeNotesOrDefer,