@yemi33/minions 0.1.288 → 0.1.290

package/CHANGELOG.md

@@ -1,14 +1,19 @@
 # Changelog
 
-## 0.1.288 (2026-04-03)
+## 0.1.290 (2026-04-03)
 
 ### Features
 -  all doc-chats use Sonnet with full tools (agent change)
 
 ### Fixes
+-  enforce worktree isolation — 4 code paths fixed
+- ' not 'Evaluate:'
 -  cross-platform compatibility — signal handling, paths, home dir
 -  engine sidebar badge only triggers on new dispatch errors
 
+### Other
+- resolve merge conflicts — accept agent changes, keep worktree isolation fix
+
 ## 0.1.285 (2026-04-03)
 
 ### Fixes

package/engine/ado.js

@@ -5,7 +5,7 @@
 
 const path = require('path');
 const shared = require('./shared');
-const { exec, getAdoOrgBase, log, dateStamp } = shared;
+const { exec, getAdoOrgBase, addPrLink, log, dateStamp } = shared;
 const { getPrs } = require('./queries');
 
 // Lazy require to avoid circular dependency — only needed for engine().handlePostMerge
@@ -29,7 +29,7 @@ function getAdoToken() {
   try {
     // azureauth supports multiple --mode flags as an ordered fallback chain:
     // tries IWA (Integrated Windows Auth) first, falls back to broker if unavailable.
-    const token = exec('azureauth ado token --mode broker --mode iwa --output token --timeout 5', {
+    const token = exec('azureauth ado token --mode iwa --mode broker --output token --timeout 1', {
       timeout: 15000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true    }).trim();
     if (token && token.startsWith('eyJ')) {
       _adoTokenCache = { token, expiresAt: Date.now() + 30 * 60 * 1000 };
@@ -46,20 +46,9 @@ function getAdoToken() {
 
 async function adoFetch(url, token, _retryCount = 0) {
   const MAX_RETRIES = 1;
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), 30000);
-  let res;
-  try {
-    res = await fetch(url, {
-      signal: controller.signal,
-      headers: { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }
-    });
-  } catch (err) {
-    clearTimeout(timer);
-    if (err.name === 'AbortError') throw new Error(`ADO API timeout (30s) for ${url.split('?')[0]}`);
-    throw err;
-  }
-  clearTimeout(timer);
+  const res = await fetch(url, {
+    headers: { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }
+  });
   if (!res.ok) throw new Error(`ADO API ${res.status}: ${res.statusText}`);
   const text = await res.text();
   if (!text || text.trimStart().startsWith('<')) {
@@ -366,8 +355,9 @@ async function reconcilePrs(config) {
       const confirmedItemId = linkedItem ? linkedItemId : null;
 
       if (existingIds.has(prId)) {
-        // PR already tracked — update prdItems if we can extract an ID
+        // PR already tracked — write link to pr-links.json if we can extract an ID
         if (confirmedItemId) {
+          addPrLink(prId, confirmedItemId);
           const existing = existingPrs.find(p => p.id === prId);
           if (existing && !(existing.prdItems || []).includes(confirmedItemId)) {
             existing.prdItems = Array.isArray(existing.prdItems) ? existing.prdItems : [];
@@ -390,12 +380,25 @@ async function reconcilePrs(config) {
         url: prUrl,
         prdItems: confirmedItemId ? [confirmedItemId] : [],
       });
+      if (confirmedItemId) addPrLink(prId, confirmedItemId);
       existingIds.add(prId);
       projectAdded++;
       log('info', `PR reconciliation: added ${prId} (branch: ${branch}${confirmedItemId ? ', linked to ' + confirmedItemId : ''}) to ${project.name}`);
     }
 
-    if (projectAdded > 0 || projectUpdated > 0) {
+    // Backfill prdItems from pr-links for any PR with empty array
+    const prLinks = shared.getPrLinks();
+    let backfilled = 0;
+    for (const pr of existingPrs) {
+      const linked = prLinks[pr.id];
+      if (linked && !(pr.prdItems || []).includes(linked)) {
+        pr.prdItems = Array.isArray(pr.prdItems) ? pr.prdItems : [];
+        pr.prdItems.push(linked);
+        backfilled++;
+      }
+    }
+
+    if (projectAdded > 0 || projectUpdated > 0 || backfilled > 0) {
       shared.safeWrite(prPath, existingPrs);
       totalAdded += projectAdded;
       if (projectUpdated > 0) log('info', `PR reconciliation: linked ${projectUpdated} existing PR(s) to PRD items in ${project.name}`);

package/engine/cooldown.js

@@ -7,12 +7,10 @@ const path = require('path');
 const shared = require('./shared');
 const queries = require('./queries');
 
-const { createHash } = require('crypto');
 const { safeJson, safeWrite, log } = shared;
 const { ENGINE_DIR } = queries;
 
 const COOLDOWN_PATH = path.join(ENGINE_DIR, 'cooldowns.json');
-const PENDING_CONTEXTS_CAP = 10;
 const dispatchCooldowns = new Map(); // key → { timestamp, failures }
 
 function loadCooldowns() {
@@ -26,35 +24,6 @@ function loadCooldowns() {
     }
   }
   log('info', `Loaded ${dispatchCooldowns.size} cooldowns from disk`);
-  // One-time purge of bloated pendingContexts on startup
-  purgeBloatedCooldowns();
-}
-
-/** Deduplicate and cap pendingContexts in all loaded cooldown entries. */
-function purgeBloatedCooldowns() {
-  let totalRemoved = 0;
-  for (const [k, v] of dispatchCooldowns) {
-    if (!Array.isArray(v.pendingContexts) || v.pendingContexts.length <= 1) continue;
-    const seen = new Set();
-    const deduped = [];
-    for (const ctx of v.pendingContexts) {
-      const hash = _contentHash(ctx);
-      if (!seen.has(hash)) {
-        seen.add(hash);
-        deduped.push(ctx);
-      }
-    }
-    const before = v.pendingContexts.length;
-    // Apply FIFO cap after dedup — keep the most recent entries
-    v.pendingContexts = deduped.length > PENDING_CONTEXTS_CAP
-      ? deduped.slice(deduped.length - PENDING_CONTEXTS_CAP)
-      : deduped;
-    totalRemoved += before - v.pendingContexts.length;
-  }
-  if (totalRemoved > 0) {
-    log('info', `Purged ${totalRemoved} duplicate/excess pendingContexts entries from cooldowns`);
-    saveCooldowns();
-  }
 }
 
 let _cooldownWriteTimer = null;
@@ -86,26 +55,10 @@ function setCooldown(key) {
   saveCooldowns();
 }
 
-function _contentHash(content) {
-  const str = typeof content === 'string' ? content : JSON.stringify(content);
-  return createHash('sha256').update(str).digest('hex');
-}
-
 function setCooldownWithContext(key, context) {
   const existing = dispatchCooldowns.get(key);
   const pendingContexts = existing?.pendingContexts || [];
-  if (context) {
-    // Dedup: only append if content differs from all existing entries
-    const newHash = _contentHash(context);
-    const isDuplicate = pendingContexts.some(c => _contentHash(c) === newHash);
-    if (!isDuplicate) {
-      pendingContexts.push(context);
-      // FIFO cap: drop oldest entries when exceeding cap
-      while (pendingContexts.length > PENDING_CONTEXTS_CAP) {
-        pendingContexts.shift();
-      }
-    }
-  }
+  if (context) pendingContexts.push(context);
   dispatchCooldowns.set(key, {
     timestamp: Date.now(),
     failures: existing?.failures || 0,
@@ -148,16 +101,13 @@ function isAlreadyDispatched(key) {
 
 module.exports = {
   COOLDOWN_PATH,
-  PENDING_CONTEXTS_CAP,
   dispatchCooldowns,
   loadCooldowns,
   saveCooldowns,
-  purgeBloatedCooldowns,
   isOnCooldown,
   setCooldown,
   setCooldownWithContext,
   getCoalescedContexts,
   setCooldownFailure,
   isAlreadyDispatched,
-  _contentHash,
 };

package/engine/github.js

@@ -5,7 +5,7 @@
  */
 
 const shared = require('./shared');
-const { exec, getProjects, projectPrPath, projectWorkItemsPath, safeJson, safeWrite, MINIONS_DIR, log, dateStamp } = shared;
+const { exec, getProjects, projectPrPath, projectWorkItemsPath, safeJson, safeWrite, MINIONS_DIR, addPrLink, getPrLinks, log, dateStamp } = shared;
 const { getPrs } = require('./queries');
 const path = require('path');
 
@@ -341,6 +341,7 @@ async function reconcilePrs(config) {
 
       if (existingIds.has(prId)) {
         if (confirmedItemId) {
+          addPrLink(prId, confirmedItemId);
           const existing = existingPrs.find(p => p.id === prId);
           if (existing && !(existing.prdItems || []).includes(confirmedItemId)) {
             existing.prdItems = Array.isArray(existing.prdItems) ? existing.prdItems : [];
@@ -363,13 +364,26 @@ async function reconcilePrs(config) {
         url: prUrl,
         prdItems: confirmedItemId ? [confirmedItemId] : [],
       });
+      if (confirmedItemId) addPrLink(prId, confirmedItemId);
       existingIds.add(prId);
       projectAdded++;
 
       log('info', `GitHub PR reconciliation: added ${prId} (branch: ${branch}${confirmedItemId ? ', linked to ' + confirmedItemId : ''}) to ${project.name}`);
     }
 
-    if (projectAdded > 0) {
+    // Backfill prdItems from pr-links for any PR with empty array
+    const prLinks = getPrLinks();
+    let backfilled = 0;
+    for (const pr of existingPrs) {
+      const linked = prLinks[pr.id];
+      if (linked && !(pr.prdItems || []).includes(linked)) {
+        pr.prdItems = Array.isArray(pr.prdItems) ? pr.prdItems : [];
+        pr.prdItems.push(linked);
+        backfilled++;
+      }
+    }
+
+    if (projectAdded > 0 || backfilled > 0) {
       safeWrite(prPath, existingPrs);
       totalAdded += projectAdded;
     }

package/engine/lifecycle.js

@@ -1277,7 +1277,7 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
             const parentItem = items.find(i => i.id === evalTargetId);
             const evalItem = {
               id: 'W-' + shared.uid(),
-              title: `Evaluate: ${parentItem?.title || meta.item.title || evalTargetId}`,
+              title: `Review: ${parentItem?.title || meta.item.title || evalTargetId}`,
               type: 'review',
               priority: meta.item.priority || 'high',
               status: 'pending',

package/engine/pipeline.js

@@ -175,6 +175,7 @@ function executeTaskStage(stage, stageState, run, config) {
       status: 'pending',
       created: ts(),
       createdBy: 'pipeline:' + run.pipelineId,
+      branch: `pipeline/${run.pipelineId}/${stage.id}`,
       _pipelineRun: run.runId,
       _pipelineStage: stage.id,
     });
@@ -248,6 +249,7 @@ function executePlanStage(stage, stageState, run, config) {
       planFile: path.basename(filePath),
       created: ts(),
       createdBy: 'pipeline:' + run.pipelineId,
+      branch: `pipeline/${run.pipelineId}/${stage.id}`,
       _pipelineRun: run.runId,
       _pipelineStage: stage.id,
     });

package/engine/playbook.js

@@ -206,25 +206,9 @@ function resolveTaskContext(item, config) {
   return resolved;
 }
 
-// ─── Critical Variable Definitions ─────────────────────────────────────────
-// Variables that MUST resolve to non-empty values for dispatch to proceed.
-// If any critical variable is empty or unresolved, renderPlaybook returns null.
-const CRITICAL_VARS = {
-  'implement': ['task_description', 'branch_name'],
-  'implement-shared': ['task_description', 'branch_name'],
-  'fix': ['task_description', 'branch_name'],
-  'work-item': ['task_description'],
-};
-
-// Module-level error state — callers check via getLastRenderError() after null return
-let _lastRenderError = null;
-
-function getLastRenderError() { return _lastRenderError; }
-
 // ─── Playbook Renderer ──────────────────────────────────────────────────────
 
 function renderPlaybook(type, vars) {
-  _lastRenderError = null;
   const pbPath = path.join(PLAYBOOKS_DIR, `${type}.md`);
   let content;
   try { content = fs.readFileSync(pbPath, 'utf8'); } catch {
@@ -296,12 +280,9 @@ function renderPlaybook(type, vars) {
   };
   const allVars = { ...projectVars, ...vars };
 
-  // Substitute variables — two passes to resolve nested templates
-  // (e.g. pr_section contains {{pr_create_instructions}}, {{branch_name}}, etc.)
-  for (let pass = 0; pass < 2; pass++) {
-    for (const [key, val] of Object.entries(allVars)) {
-      content = content.replace(new RegExp(`\\{\\{${key}\\}\\}`, 'g'), String(val));
-    }
+  // Substitute variables
+  for (const [key, val] of Object.entries(allVars)) {
+    content = content.replace(new RegExp(`\\{\\{${key}\\}\\}`, 'g'), String(val));
   }
 
   // Warn on variables that resolved to empty string
@@ -318,20 +299,6 @@ function renderPlaybook(type, vars) {
     log('warn', `Playbook "${type}": unresolved template variables: ${unresolved.join(', ')}`);
   }
 
-  // Block dispatch if critical variables are empty or unresolved
-  const criticalVars = CRITICAL_VARS[type] || [];
-  if (criticalVars.length > 0) {
-    const emptySet = new Set(emptyVars);
-    const unresolvedSet = new Set(unresolved);
-    const criticalMissing = criticalVars.filter(v => emptySet.has(v) || unresolvedSet.has(v));
-    if (criticalMissing.length > 0) {
-      const msg = `Playbook "${type}": critical variables empty or unresolved: ${criticalMissing.join(', ')} — blocking dispatch`;
-      log('warn', msg);
-      _lastRenderError = { reason: 'critical_vars_missing', vars: criticalMissing, message: msg };
-      return null;
-    }
-  }
-
   return content;
 }
 
@@ -503,8 +470,6 @@ function buildPrDispatch(agentId, config, project, pr, type, extraVars, taskLabe
 
 module.exports = {
   renderPlaybook,
-  getLastRenderError,
-  CRITICAL_VARS,
   buildSystemPrompt,
   buildAgentContext,
   selectPlaybook,

package/engine/routing.js

@@ -136,7 +136,7 @@ function resolveAgent(workType, config, authorAgent = null) {
   if (config.engine?.allowTempAgents) {
     const tempId = `temp-${shared.uid()}`;
     _claimedAgents.add(tempId);
-    tempAgents.set(tempId, { name: `Temp-${tempId.slice(5, 13)}`, role: 'Temporary Agent', createdAt: ts() });
+    tempAgents.set(tempId, { name: `Temp-${tempId.slice(5, 9)}`, role: 'Temporary Agent', createdAt: ts() });
     log('info', `Spawning temp agent ${tempId} — all permanent agents busy`);
     return tempId;
   }

package/engine.js

@@ -290,10 +290,9 @@ function spawnAgent(dispatchItem, config) {
       log('info', `Reusing existing worktree for ${branchName}: ${existingWt}`);
       try { exec(`git fetch origin "${branchName}"`, { ..._gitOpts, cwd: rootDir }); } catch (e) { log('warn', 'git: ' + e.message); }
       try { exec(`git pull origin "${branchName}"`, { ..._gitOpts, cwd: existingWt }); } catch (e) { log('warn', 'git: ' + e.message); }
-    } else if (type !== 'implement') {
-      // Only implement tasks may create new worktrees.
-      // Other task types are reuse-only: if no existing worktree, run in rootDir.
-      log('info', `${type}: no existing worktree for ${branchName} — creation disabled for non-implement tasks, falling back to rootDir`);
+    } else if (['meeting', 'ask', 'explore'].includes(type)) {
+      // Read-only tasks — no worktree needed, run in rootDir
+      log('info', `${type}: read-only task, no worktree needed — running in rootDir`);
       branchName = null;
       worktreePath = null;
     } else {
@@ -423,6 +422,11 @@ function spawnAgent(dispatchItem, config) {
   const systemPrompt = buildSystemPrompt(agentId, config, project);
   const agentContext = buildAgentContext(agentId, config, project);
 
+  // Safety check: warn if a write-capable task is running in the main repo without a worktree
+  if (cwd === rootDir && ['implement', 'implement:large', 'fix', 'test', 'verify', 'plan-to-prd'].includes(type)) {
+    log('warn', `Agent ${agentId} running ${type} task in main repo (no worktree) for ${id} — changes may land on master directly`);
+  }
+
   // Prepend bulk context to task prompt — keeps system prompt small and stable
   const fullTaskPrompt = agentContext
     ? `## Agent Context\n\n${agentContext}\n---\n\n## Your Task\n\n${taskPrompt}`
@@ -1475,6 +1479,38 @@ function discoverFromWorkItems(config, project) {
     const ac = (item.acceptanceCriteria || []).map(c => '- [ ] ' + c).join('\n');
     vars.acceptance_criteria = ac ? '## Acceptance Criteria\n\n' + ac : '';
 
+    // Inject checkpoint context if agent left a checkpoint.json from a prior run
+    vars.checkpoint_context = '';
+    try {
+      const wtPath = vars.worktree_path || root;
+      const cpPath = path.join(wtPath, 'checkpoint.json');
+      if (fs.existsSync(cpPath)) {
+        const cpData = JSON.parse(fs.readFileSync(cpPath, 'utf8'));
+        const cpCount = (item._checkpointCount || 0) + 1;
+        if (cpCount > 3) {
+          log('warn', `Work item ${item.id} exceeded 3 checkpoint-resumes — marking as needs-human-review`);
+          item.status = 'needs-human-review';
+          item._checkpointCount = cpCount;
+          needsWrite = true;
+          continue;
+        }
+        item._checkpointCount = cpCount;
+        needsWrite = true;
+        const cpSummary = [
+          `## Checkpoint (Resume #${cpCount}/3)`,
+          '',
+          'A previous agent run timed out but left a checkpoint. Continue from where it left off.',
+          '',
+          cpData.completed && cpData.completed.length > 0 ? `### Completed\n${cpData.completed.map(s => '- ' + s).join('\n')}` : '',
+          cpData.remaining && cpData.remaining.length > 0 ? `### Remaining\n${cpData.remaining.map(s => '- ' + s).join('\n')}` : '',
+          cpData.blockers && cpData.blockers.length > 0 ? `### Blockers\n${cpData.blockers.map(s => '- ' + s).join('\n')}` : '',
+          cpData.branch_state ? `### Branch State\n${cpData.branch_state}` : '',
+        ].filter(Boolean).join('\n');
+        vars.checkpoint_context = cpSummary;
+        log('info', `Injecting checkpoint context for ${item.id} (resume #${cpCount})`);
+      }
+    } catch (e) { log('warn', `checkpoint read for ${item.id}: ${e.message}`); }
+
     // Inject ask-specific variables for the ask playbook
     if (workType === 'ask') {
       vars.question = item.title + (item.description ? '\n\n' + item.description : '');
@@ -1798,6 +1834,7 @@ function discoverCentralWorkItems(config) {
           prompt,
           meta: {
             dispatchKey: fanKey, source: 'central-work-item-fanout', item, parentKey: key,
+            branch: `fan/${item.id}/${fanAgentId}`,
             deadline: item.timeout ? Date.now() + item.timeout : Date.now() + (config.engine?.fanOutTimeout || config.engine?.agentTimeout || DEFAULTS.agentTimeout)
           }
         });
@@ -1845,6 +1882,39 @@ function discoverCentralWorkItems(config) {
       const normAc = (item.acceptanceCriteria || []).map(c => '- [ ] ' + c).join('\n');
       vars.acceptance_criteria = normAc ? '## Acceptance Criteria\n\n' + normAc : '';
 
+      // Inject checkpoint context if agent left a checkpoint.json from a prior run
+      vars.checkpoint_context = '';
+      try {
+        const centralBranch = item.branch || `work/${item.id}`;
+        const centralWtPath = firstProject?.localPath
+          ? path.resolve(firstProject.localPath, config.engine?.worktreeRoot || '../worktrees', centralBranch)
+          : '';
+        const cpPath = centralWtPath ? path.join(centralWtPath, 'checkpoint.json') : '';
+        if (cpPath && fs.existsSync(cpPath)) {
+          const cpData = JSON.parse(fs.readFileSync(cpPath, 'utf8'));
+          const cpCount = (item._checkpointCount || 0) + 1;
+          if (cpCount > 3) {
+            log('warn', `Work item ${item.id} exceeded 3 checkpoint-resumes — marking as needs-human-review`);
+            item.status = 'needs-human-review';
+            item._checkpointCount = cpCount;
+            continue;
+          }
+          item._checkpointCount = cpCount;
+          const cpSummary = [
+            `## Checkpoint (Resume #${cpCount}/3)`,
+            '',
+            'A previous agent run timed out but left a checkpoint. Continue from where it left off.',
+            '',
+            cpData.completed && cpData.completed.length > 0 ? `### Completed\n${cpData.completed.map(s => '- ' + s).join('\n')}` : '',
+            cpData.remaining && cpData.remaining.length > 0 ? `### Remaining\n${cpData.remaining.map(s => '- ' + s).join('\n')}` : '',
+            cpData.blockers && cpData.blockers.length > 0 ? `### Blockers\n${cpData.blockers.map(s => '- ' + s).join('\n')}` : '',
+            cpData.branch_state ? `### Branch State\n${cpData.branch_state}` : '',
+          ].filter(Boolean).join('\n');
+          vars.checkpoint_context = cpSummary;
+          log('info', `Injecting checkpoint context for ${item.id} (resume #${cpCount})`);
+        }
+      } catch (e) { log('warn', `checkpoint read for ${item.id}: ${e.message}`); }
+
       // Inject plan-specific variables for the plan playbook
       if (workType === 'plan') {
         // Ensure plans directory exists before agent tries to write
@@ -1909,7 +1979,7 @@ function discoverCentralWorkItems(config) {
         agentRole,
         task: item.title || item.description?.slice(0, 80) || item.id,
         prompt,
-        meta: { dispatchKey: key, source: 'central-work-item', item, planFileName: item.planFile || item._planFileName || null }
+        meta: { dispatchKey: key, source: 'central-work-item', item, planFileName: item.planFile || item._planFileName || null, branch: item.branch || item.featureBranch || `work/${item.id}` }
       });
 
       item.status = 'dispatched';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.288",
+  "version": "0.1.290",
   "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/evaluate.md

@@ -0,0 +1,114 @@
+# Evaluate: {{item_name}}
+
+> Agent: {{agent_name}} ({{agent_role}}) | Team root: {{team_root}}
+
+## Context
+
+Project: {{project_name}}
+Repo: {{repo_name}} | Org: {{ado_org}} | ADO Project: {{ado_project}}
+PR: {{pr_url}}
+Work Item: {{item_id}}
+
+## Acceptance Criteria
+
+{{acceptance_criteria}}
+
+## Task Description
+
+{{task_description}}
+
+## Your Task
+
+You are the **Evaluator** in the Planner-Generator-Evaluator pattern. Your job is to independently verify whether the implementation in the PR branch meets the acceptance criteria. You are NOT the implementer — you are the skeptic.
+
+**Mindset: Do not pass unless build succeeds AND all acceptance criteria are demonstrably met.** Assume the implementation is incomplete or wrong until proven otherwise. Look for edge cases, missing requirements, and silent failures.
+
+## Step 1: Check Out the PR Branch
+
+```bash
+cd {{project_path}}
+git fetch origin
+git checkout {{branch_name}}
+git pull origin {{branch_name}}
+```
+
+## Step 2: Build
+
+Run the project build. Check `CLAUDE.md`, `package.json`, or `README` for build instructions.
+
+```bash
+# Typical:
+npm install && npm run build
+# Or whatever the project uses
+```
+
+Record: **PASS** or **FAIL** with error output.
+
+If the build fails, **stop here** — the verdict is `pass: false`. Include the build error in feedback.
+
+## Step 3: Run Tests
+
+Run the full test suite:
+
+```bash
+npm test
+```
+
+Record: **X passed / Y failed / Z skipped**.
+
+If any tests fail, note which ones and whether they are related to the changes.
+
+## Step 4: Diff Review Against Acceptance Criteria
+
+Review the actual code changes:
+
+```bash
+git diff {{main_branch}}...{{branch_name}} --stat
+git diff {{main_branch}}...{{branch_name}}
+```
+
+For **each** acceptance criterion, determine:
+- **Met**: The diff demonstrably satisfies this criterion. Cite the specific file/line.
+- **Not met**: The diff does not satisfy this criterion, or satisfies it only partially. Explain what's missing.
+
+Be precise. "Looks good" is not an evaluation — cite file paths and line numbers.
+
+## Step 5: Output Structured Verdict
+
+After completing your evaluation, output the following JSON block as your final output. This MUST be valid JSON wrapped in a `json` fenced code block:
+
+```json
+{
+  "pass": false,
+  "build": true,
+  "tests": "42/42",
+  "criteria_met": [
+    "criterion 1 — met because X (source: path/to/file.js:42)"
+  ],
+  "criteria_failed": [
+    "criterion 2 — not met because Y is missing"
+  ],
+  "feedback": "Summary of what needs to change for this to pass. Be specific — file names, line numbers, what to add/fix."
+}
+```
+
+Field definitions:
+- `pass`: `true` only if build succeeds AND **all** acceptance criteria are met. Otherwise `false`.
+- `build`: `true` if the build completed without errors, `false` otherwise.
+- `tests`: String in format `"passed/total"` (e.g., `"38/40"`). Use `"N/A"` if no test suite exists.
+- `criteria_met`: Array of strings — one per criterion that IS met. Include source references.
+- `criteria_failed`: Array of strings — one per criterion that is NOT met. Explain why.
+- `feedback`: Actionable feedback for the implementer. Be specific about what to fix. If `pass` is `true`, use this for minor suggestions or "LGTM".
+
+## Rules
+
+- **No Playwright / browser testing** — this phase evaluates build, tests, and code review only.
+- **Do NOT fix code** — only evaluate and report. You are the evaluator, not the implementer.
+- **Do NOT rubber-stamp** — if a criterion is ambiguous, evaluate conservatively (fail it and explain).
+- **Build failure is an automatic fail** — do not evaluate criteria if the build doesn't pass.
+- **Every criterion must be addressed** — `criteria_met` + `criteria_failed` should cover all acceptance criteria.
+- **Cite sources** — reference file paths and line numbers for every met/failed criterion.
+
+{{references}}
+
+**Note:** Do NOT write to `agents/*/status.json` — the engine manages your status automatically.