maestro-flow 0.4.20 → 0.4.21

package/workflows/swarm/wf-brainstorm.js

@@ -1,11 +1,12 @@
 export const meta = {
   name: 'wf-brainstorm',
-  description: 'Multi-role parallel brainstorm with cross-role reviewer synthesis, aligned with maestro-brainstorm',
-  whenToUse: 'Accelerate maestro-brainstorm with parallel role analysis and cross-role conflict/synergy detection',
+  description: 'Multi-role brainstorm with 3-specialist cross-review and adversarial guidance arbitration',
+  whenToUse: 'Accelerate maestro-brainstorm with parallel roles + 3-specialist cross-review + adversarial guidance synthesis',
   phases: [
     { title: 'Analyze', detail: 'Parallel multi-role analysis via role-design-author' },
-    { title: 'CrossReview', detail: 'Cross-role conflict detection via cross-role-reviewer' },
-    { title: 'Synthesize', detail: 'Resolution synthesis into guidance specification' },
+    { title: 'CrossReview', detail: '3 specialized reviewers (conflict-hunter, synergy-finder, gap-detector) in parallel' },
+    { title: 'Compete', detail: '3 independent guidance proposals from competing philosophies' },
+    { title: 'Arbitrate', detail: 'Adversarial arbitrator resolves competing proposals into unified guidance' },
   ],
 }
 
@@ -83,6 +84,7 @@ const ROLE_ANALYSIS_SCHEMA = {
 const CROSS_REVIEW_SCHEMA = {
   type: 'object',
   properties: {
+    reviewer_type: { type: 'string' },
     conflicts: {
       type: 'array',
       items: {
@@ -123,7 +125,45 @@ const CROSS_REVIEW_SCHEMA = {
       },
     },
   },
-  required: ['conflicts', 'synergies', 'gaps'],
+  required: ['reviewer_type', 'conflicts', 'synergies', 'gaps'],
+}
+
+const GUIDANCE_PROPOSAL_SCHEMA = {
+  type: 'object',
+  properties: {
+    philosophy: { type: 'string' },
+    guidelines: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          id: { type: 'string' },
+          guideline: { type: 'string' },
+          category: { type: 'string', enum: ['must', 'must-not', 'should', 'should-not', 'may'] },
+          source_roles: { type: 'array', items: { type: 'string' } },
+          rationale: { type: 'string' },
+          resolved_conflict: { type: 'string' },
+        },
+        required: ['id', 'guideline', 'category', 'rationale'],
+      },
+    },
+    conflict_resolutions: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          conflict_id: { type: 'string' },
+          resolution: { type: 'string' },
+          rationale: { type: 'string' },
+          winner_role: { type: 'string' },
+        },
+        required: ['conflict_id', 'resolution', 'rationale'],
+      },
+    },
+    trade_off_summary: { type: 'string' },
+    confidence: { type: 'number', minimum: 0, maximum: 100 },
+  },
+  required: ['philosophy', 'guidelines', 'conflict_resolutions', 'confidence'],
 }
 
 const GUIDANCE_SCHEMA = {
@@ -140,6 +180,7 @@ const GUIDANCE_SCHEMA = {
           source_roles: { type: 'array', items: { type: 'string' } },
           rationale: { type: 'string' },
           resolved_conflict: { type: 'string' },
+          source_proposal: { type: 'string' },
         },
         required: ['id', 'guideline', 'category', 'source_roles', 'rationale'],
       },
@@ -153,14 +194,16 @@ const GUIDANCE_SCHEMA = {
           resolution: { type: 'string' },
           rationale: { type: 'string' },
           winner_role: { type: 'string' },
+          dissenting_proposal: { type: 'string' },
         },
         required: ['conflict_id', 'resolution', 'rationale'],
       },
     },
+    arbitration_notes: { type: 'string' },
     open_questions: { type: 'array', items: { type: 'string' } },
     executive_summary: { type: 'string' },
   },
-  required: ['guidelines', 'resolved_conflicts', 'executive_summary'],
+  required: ['guidelines', 'resolved_conflicts', 'arbitration_notes', 'executive_summary'],
 }
 
 const topic = args?.topic || 'the proposed system'
@@ -199,10 +242,6 @@ Be specific and opinionated — take clear stances with rationale.`,
 const validAnalyses = analyses.filter(Boolean)
 log(`${validAnalyses.length}/${selectedRoles.length} role analyses completed`)
 
-// Phase 2: Cross-role review via cross-role-reviewer
-phase('CrossReview')
-log('Cross-role conflict and synergy detection...')
-
 const analysesDigest = validAnalyses.map(a => {
   const decisions = a.decision_digest.map(d => `  ${d.id}: [${d.priority}] ${d.feature} — ${d.stance}`).join('\n')
   const positions = a.cross_cutting_positions.map(p => `  ${p.topic}: ${p.position} [${p.strength}]`).join('\n')
@@ -210,75 +249,208 @@ const analysesDigest = validAnalyses.map(a => {
   return `## ${a.role}\nKey insight: ${a.key_insight}\n\nDecisions:\n${decisions}\n\nPositions:\n${positions}\n\nFindings:\n${findings}`
 }).join('\n\n---\n\n')
 
-const crossReview = await agent(
-  `Compare these ${validAnalyses.length} role analyses for conflicts, gaps, and synergies.
+// Phase 2: 3 specialized cross-reviewers in parallel
+phase('CrossReview')
+log('Launching 3 specialized cross-reviewers in parallel...')
+
+const crossReviews = await parallel([
+  () => agent(
+    `You are the CONFLICT HUNTER. Your sole mission is to find contradictions between roles.
 
+${validAnalyses.length} role analyses:
 ${analysesDigest}
 
-Identify:
-1. CONFLICTS: Same feature/topic with contradictory stances between roles. Include severity (blocking/significant/minor).
-2. SYNERGIES: Compatible positions that reinforce each other when combined.
-3. GAPS: Areas where an important perspective is missing — a topic addressed by one role but not by another that should.
+Focus EXCLUSIVELY on:
+1. Same feature/topic with CONTRADICTORY stances between roles
+2. Incompatible priorities (one role says must-have, another says not needed)
+3. Conflicting cross-cutting positions
+4. Interface mismatches (one produces X, another expects Y)
 
-For each conflict, suggest a resolution direction.`,
-  { label: 'cross-review', phase: 'CrossReview', schema: CROSS_REVIEW_SCHEMA, agentType: 'cross-role-reviewer' }
-)
+Classify each conflict:
+- blocking: fundamental disagreement that prevents progress
+- significant: meaningful disagreement but can be resolved
+- minor: style/preference difference
 
-// Phase 3: Synthesis into guidance specification
-phase('Synthesize')
-log('Synthesizing guidance specification...')
+For each conflict, suggest a resolution direction.
+Set reviewer_type="conflict-hunter".
+Be AGGRESSIVE — surface every possible contradiction, even subtle ones.`,
+    { label: 'review:conflicts', phase: 'CrossReview', schema: CROSS_REVIEW_SCHEMA, agentType: 'cross-role-reviewer' }
+  ),
+  () => agent(
+    `You are the SYNERGY FINDER. Your sole mission is to find reinforcing alignments between roles.
 
-const conflictDigest = crossReview.conflicts.map(c =>
-  `[${c.severity}] ${c.topic}: ${c.stances.map(s => s.role + '→' + s.stance).join(' vs ')}\n  Suggestion: ${c.resolution_suggestion}`
-).join('\n')
+${validAnalyses.length} role analyses:
+${analysesDigest}
 
-const synergyDigest = crossReview.synergies.map(s =>
-  `${s.roles.join(' + ')}: ${s.topic} — ${s.combined_value}`
-).join('\n')
+Focus EXCLUSIVELY on:
+1. Compatible positions that create MORE value when combined
+2. Shared priorities that validate importance
+3. Complementary interfaces (one provides exactly what another needs)
+4. Cross-cutting alignments that reveal strong consensus
 
-const guidance = await agent(
-  `Synthesize a unified guidance specification from multi-role brainstorm results.
+For each synergy, explain the combined value — how the combination is more than the sum.
+Set reviewer_type="synergy-finder".
+Be GENEROUS — surface every alignment, including implicit ones.`,
+    { label: 'review:synergies', phase: 'CrossReview', schema: CROSS_REVIEW_SCHEMA, agentType: 'cross-role-reviewer' }
+  ),
+  () => agent(
+    `You are the GAP DETECTOR. Your sole mission is to find MISSING perspectives and blind spots.
+
+${validAnalyses.length} role analyses:
+${analysesDigest}
+
+Focus EXCLUSIVELY on:
+1. Topics addressed by one role but IGNORED by others who should care
+2. Missing role perspectives entirely (security not represented? operations?)
+3. Unstated assumptions that no role challenged
+4. Edge cases and failure modes no one considered
+5. Integration points that fall between role responsibilities
+
+For each gap, identify what perspective is missing and the impact of that blindspot.
+Set reviewer_type="gap-detector".
+Be THOROUGH — missing perspectives are the most dangerous type of oversight.`,
+    { label: 'review:gaps', phase: 'CrossReview', schema: CROSS_REVIEW_SCHEMA, agentType: 'cross-role-reviewer' }
+  ),
+])
+
+const validReviews = crossReviews.filter(Boolean)
+const allConflicts = validReviews.flatMap(r => r.conflicts)
+const allSynergies = validReviews.flatMap(r => r.synergies)
+const allGaps = validReviews.flatMap(r => r.gaps)
+
+log(`Cross-review: ${allConflicts.length} conflicts, ${allSynergies.length} synergies, ${allGaps.length} gaps`)
+
+const crossReviewDigest = `Conflicts (${allConflicts.length}):
+${allConflicts.map(c => `[${c.severity}] ${c.topic}: ${c.stances.map(s => s.role + '→' + s.stance).join(' vs ')}\n  Suggestion: ${c.resolution_suggestion || 'none'}`).join('\n')}
+
+Synergies (${allSynergies.length}):
+${allSynergies.map(s => `${s.roles.join(' + ')}: ${s.topic} — ${s.combined_value}`).join('\n')}
+
+Gaps (${allGaps.length}):
+${allGaps.map(g => `${g.area} — missing: ${g.missing_perspective}${g.impact ? ' (impact: ' + g.impact + ')' : ''}`).join('\n')}`
+
+// Phase 3: 3 competing guidance proposals from different philosophies
+phase('Compete')
+log('Launching 3 competing guidance proposals...')
+
+const proposals = await parallel([
+  () => agent(
+    `You are the CONSERVATIVE proposal author. Generate guidance that MINIMIZES RISK.
 
 Topic: ${topic}
+Role Analyses:\n${analysesDigest}
 
-Role Analyses:
-${analysesDigest}
+Cross-Review:\n${crossReviewDigest}
+
+Your philosophy: SAFETY FIRST
+- Resolve conflicts in favor of stability and backward compatibility
+- MUST/MUST-NOT for anything with risk, SHOULD for everything else
+- Prefer proven patterns over innovative approaches
+- When in doubt, require explicit approval (deferred decision)
+- Gaps should be addressed before proceeding
+
+Generate guidelines using RFC-2119 (MUST, MUST NOT, SHOULD, SHOULD NOT, MAY).
+Resolve each conflict with your conservative lens.
+Report trade_off_summary: what you sacrifice for safety.`,
+    { label: 'proposal:conservative', phase: 'Compete', schema: GUIDANCE_PROPOSAL_SCHEMA }
+  ),
+  () => agent(
+    `You are the PROGRESSIVE proposal author. Generate guidance that MAXIMIZES VELOCITY.
 
-Cross-Review Findings:
-Conflicts (${crossReview.conflicts.length}):
-${conflictDigest || 'None'}
+Topic: ${topic}
+Role Analyses:\n${analysesDigest}
+
+Cross-Review:\n${crossReviewDigest}
 
-Synergies (${crossReview.synergies.length}):
-${synergyDigest || 'None'}
+Your philosophy: SHIP FAST, ITERATE
+- Resolve conflicts in favor of speed and user value
+- Use MAY/SHOULD liberally, reserve MUST only for safety-critical items
+- Prefer pragmatic solutions, accept tech debt if it unblocks progress
+- Gaps can be addressed incrementally post-launch
+- Favor the role closest to the user (PM, UX) in conflict resolution
 
-Gaps: ${crossReview.gaps.map(g => g.area + ' — missing ' + g.missing_perspective).join('; ') || 'None'}
+Generate guidelines using RFC-2119 (MUST, MUST NOT, SHOULD, SHOULD NOT, MAY).
+Resolve each conflict with your progressive lens.
+Report trade_off_summary: what risks you accept for velocity.`,
+    { label: 'proposal:progressive', phase: 'Compete', schema: GUIDANCE_PROPOSAL_SCHEMA }
+  ),
+  () => agent(
+    `You are the BALANCED proposal author. Generate guidance that OPTIMIZES FOR SUSTAINABILITY.
 
-Produce:
-1. Unified guidelines using RFC-2119 categories (MUST, MUST NOT, SHOULD, SHOULD NOT, MAY)
-2. For each conflict: resolve by weighing evidence strength, severity, and downstream impact
-3. Attribute each guideline to source roles
-4. List remaining open questions that need user input
-5. Executive summary (2-3 paragraphs)
+Topic: ${topic}
+Role Analyses:\n${analysesDigest}
 
-Priority rules for conflict resolution:
-- Security > correctness > user experience > performance > convenience
+Cross-Review:\n${crossReviewDigest}
+
+Your philosophy: SUSTAINABLE EXCELLENCE
+- Resolve conflicts by weighing evidence strength from all perspectives
+- Priority: security > correctness > user experience > performance > convenience
 - "must-have" from multiple roles > "must-have" from single role
-- Stances with strong evidence > moderate > weak`,
-  { label: 'guidance', phase: 'Synthesize', schema: GUIDANCE_SCHEMA }
+- Strong evidence > moderate > weak, regardless of role seniority
+- Address critical gaps, defer minor ones
+- Balance speed and quality based on risk level
+
+Generate guidelines using RFC-2119 (MUST, MUST NOT, SHOULD, SHOULD NOT, MAY).
+Resolve each conflict with your balanced lens.
+Report trade_off_summary: what you optimize for and what you deprioritize.`,
+    { label: 'proposal:balanced', phase: 'Compete', schema: GUIDANCE_PROPOSAL_SCHEMA }
+  ),
+])
+
+const validProposals = proposals.filter(Boolean)
+const proposalDigest = validProposals.map(p =>
+  `### ${p.philosophy} (confidence: ${p.confidence}%)\nGuidelines: ${p.guidelines.length}\nConflict resolutions: ${p.conflict_resolutions.length}\nTrade-offs: ${p.trade_off_summary}\nKey guidelines:\n${p.guidelines.slice(0, 5).map(g => `  [${g.category.toUpperCase()}] ${g.guideline}`).join('\n')}`
+).join('\n\n')
+
+log(`${validProposals.length} competing proposals generated`)
+
+// Phase 4: Adversarial Arbitration
+phase('Arbitrate')
+log('Adversarial arbitrator resolving competing proposals...')
+
+const guidance = await agent(
+  `You are the ARBITRATOR. Three competing guidance proposals approach the same problem differently.
+
+Topic: ${topic}
+
+=== COMPETING PROPOSALS ===
+${proposalDigest}
+
+=== FULL PROPOSALS ===
+${validProposals.map(p => `## ${p.philosophy}\n${p.guidelines.map(g => `[${g.category}] ${g.id}: ${g.guideline} — ${g.rationale}`).join('\n')}\n\nConflict resolutions:\n${p.conflict_resolutions.map(r => `${r.conflict_id}: ${r.resolution} (winner: ${r.winner_role || 'compromise'})`).join('\n')}`).join('\n\n---\n\n')}
+
+=== CROSS-REVIEW DATA ===
+${crossReviewDigest}
+
+ARBITRATE:
+1. For each guideline topic, compare how all 3 proposals handle it
+2. Select the BEST resolution for each conflict — not always the same philosophy
+3. Cherry-pick the strongest guidelines from each proposal
+4. When proposals agree → high-confidence MUST/MUST-NOT
+5. When proposals split 2-1 → go with the 2, note the dissent
+6. When all 3 disagree → evaluate evidence depth and pick the best-argued position
+7. List remaining open_questions that genuinely need user input
+8. Write arbitration_notes explaining your meta-reasoning
+9. Write executive_summary (2-3 paragraphs)
+
+Tag each output guideline with source_proposal to trace its origin.`,
+  { label: 'arbitrate', phase: 'Arbitrate', schema: GUIDANCE_SCHEMA }
 )
 
 return {
   analyses: validAnalyses,
-  crossReview: crossReview,
+  crossReviews: validReviews,
+  proposals: validProposals,
   guidance: guidance,
   metadata: {
     topic: topic,
     role_count: selectedRoles.length,
     completed_count: validAnalyses.length,
-    conflict_count: crossReview.conflicts.length,
-    blocking_conflicts: crossReview.conflicts.filter(c => c.severity === 'blocking').length,
-    synergy_count: crossReview.synergies.length,
-    gap_count: crossReview.gaps.length,
+    conflict_count: allConflicts.length,
+    blocking_conflicts: allConflicts.filter(c => c.severity === 'blocking').length,
+    synergy_count: allSynergies.length,
+    gap_count: allGaps.length,
+    proposal_count: validProposals.length,
     guideline_count: guidance ? guidance.guidelines.length : 0,
   },
 }

package/workflows/swarm/wf-execute.js

@@ -1,11 +1,12 @@
 export const meta = {
   name: 'wf-execute',
-  description: 'Wave-based parallel task execution via workflow-executor agents',
-  whenToUse: 'Accelerate maestro-execute with parallel task implementation within waves',
+  description: 'Wave-based parallel execution with adversarial convergence verification and 3-vote status determination',
+  whenToUse: 'Accelerate maestro-execute with parallel task implementation + adversarial convergence checks + 3-vote report',
   phases: [
     { title: 'Load', detail: 'Load plan and resolve task dependencies' },
     { title: 'Execute', detail: 'Wave-based parallel task execution via workflow-executor' },
-    { title: 'Report', detail: 'Execution summary and status collection' },
+    { title: 'VerifyConvergence', detail: 'Adversarial spot-check of convergence claims' },
+    { title: 'Report', detail: '3-vote status determination (optimist/pessimist/realist)' },
   ],
 }
 
@@ -24,6 +25,44 @@ const TASK_RESULT_SCHEMA = {
   required: ['task_id', 'status', 'summary'],
 }
 
+const CONVERGENCE_CHECK_SCHEMA = {
+  type: 'object',
+  properties: {
+    task_id: { type: 'string' },
+    claimed_complete: { type: 'boolean' },
+    actually_complete: { type: 'boolean' },
+    checks: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          criterion: { type: 'string' },
+          claimed: { type: 'boolean' },
+          verified: { type: 'boolean' },
+          evidence: { type: 'string' },
+          discrepancy: { type: 'string' },
+        },
+        required: ['criterion', 'claimed', 'verified', 'evidence'],
+      },
+    },
+    trust_score: { type: 'number', minimum: 0, maximum: 100 },
+    assessment: { type: 'string' },
+  },
+  required: ['task_id', 'claimed_complete', 'actually_complete', 'checks', 'trust_score'],
+}
+
+const STATUS_VOTE_SCHEMA = {
+  type: 'object',
+  properties: {
+    perspective: { type: 'string' },
+    status: { type: 'string', enum: ['DONE', 'DONE_WITH_CONCERNS', 'NEEDS_RETRY'] },
+    rationale: { type: 'string' },
+    confidence: { type: 'number', minimum: 0, maximum: 100 },
+    blocking_concerns: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['perspective', 'status', 'rationale', 'confidence'],
+}
+
 const REPORT_SCHEMA = {
   type: 'object',
   properties: {
@@ -34,10 +73,22 @@ const REPORT_SCHEMA = {
     blocked: { type: 'number' },
     waves_executed: { type: 'number' },
     files_changed: { type: 'array', items: { type: 'string' } },
+    adversarial_outcome: {
+      type: 'object',
+      properties: {
+        optimist: { type: 'string' },
+        pessimist: { type: 'string' },
+        realist: { type: 'string' },
+        convergence_trust: { type: 'number' },
+        decisive_factor: { type: 'string' },
+      },
+      required: ['optimist', 'pessimist', 'realist', 'decisive_factor'],
+    },
+    convergence_discrepancies: { type: 'array', items: { type: 'object', properties: { task_id: { type: 'string' }, criterion: { type: 'string' }, discrepancy: { type: 'string' } }, required: ['task_id', 'criterion'] } },
     failed_tasks: { type: 'array', items: { type: 'object', properties: { task_id: { type: 'string' }, error: { type: 'string' }, unmet_criteria: { type: 'array', items: { type: 'string' } } }, required: ['task_id'] } },
     summary: { type: 'string' },
   },
-  required: ['status', 'total_tasks', 'completed', 'failed', 'summary'],
+  required: ['status', 'total_tasks', 'completed', 'failed', 'adversarial_outcome', 'summary'],
 }
 
 const planDir = args?.plan_dir || ''
@@ -46,7 +97,7 @@ const codebaseContext = args?.codebase_context || ''
 const wikiContext = args?.wiki_context || ''
 const autoCommit = args?.auto_commit !== false
 
-// Phase 1: Load plan and resolve waves
+// Phase 1: Load plan
 phase('Load')
 log('Loading plan and resolving task dependency waves...')
 
@@ -58,11 +109,9 @@ Plan directory: ${planDir || 'Find the most recent pending plan in .workflow/scr
 Steps:
 1. Read plan.json to get task_ids[], waves[], approach
 2. Read each .task/TASK-{NNN}.json to get: description, scope, focus_paths, depends_on, convergence.criteria, files[], implementation[], read_first[], test.commands
-3. Verify dependency order: tasks in wave N must have all depends_on satisfied by waves < N
-4. Filter: only include tasks with status="pending" (skip completed/blocked)
-5. Return the wave structure with full task context for each pending task
-
-Return the complete wave plan as structured data.`,
+3. Verify dependency order
+4. Filter: only tasks with status="pending"
+5. Return the wave structure with full task context`,
   {
     label: 'load:plan',
     phase: 'Load',
@@ -113,7 +162,7 @@ if (!planLoad || !planLoad.waves || planLoad.waves.length === 0) {
 
 log(`Plan loaded: ${planLoad.total_pending} pending tasks across ${planLoad.waves.length} waves`)
 
-// Phase 2: Execute waves sequentially, tasks within each wave in parallel
+// Phase 2: Execute waves
 phase('Execute')
 
 const allResults = []
@@ -147,7 +196,7 @@ ${autoCommit ? '7. Create atomic git commit with message referencing ' + task.ta
 8. Write summary to ${planLoad.plan_dir}/.summaries/${task.task_id}-summary.md
 9. Update task status to "completed" in the task JSON
 
-Stay within scope. Do not modify files outside focus_paths unless explicitly required by the task.`,
+Stay within scope.`,
         { label: `exec:${task.task_id}`, phase: 'Execute', schema: TASK_RESULT_SCHEMA, agentType: 'workflow-executor', isolation: 'worktree' }
       )
     )
@@ -161,17 +210,73 @@ Stay within scope. Do not modify files outside focus_paths unless explicitly req
   }
 }
 
-// Phase 3: Execution report
-phase('Report')
-
 const completed = allResults.filter(r => r.status === 'completed')
 const failed = allResults.filter(r => r.status === 'failed')
 const blocked = allResults.filter(r => r.status === 'blocked')
 
-const report = await agent(
-  `Generate execution report.
+// Phase 3: Adversarial convergence verification
+phase('VerifyConvergence')
+
+const tasksToVerify = completed.slice(0, Math.min(completed.length, 5))
+
+if (tasksToVerify.length > 0) {
+  log(`Adversarial convergence spot-check of ${tasksToVerify.length} completed tasks...`)
+
+  const convergenceChecks = await parallel(
+    tasksToVerify.map(task => () => {
+      const waveTask = planLoad.waves.flatMap(w => w.tasks).find(t => t.task_id === task.task_id)
+      return agent(
+        `ADVERSARIAL convergence verification for: ${task.task_id}
+
+The executor claims this task is COMPLETED.
+Claimed summary: ${task.summary}
+Files changed: ${(task.files_changed || []).join(', ')}
+
+Convergence criteria to verify:
+${(waveTask ? waveTask.convergence_criteria : []).map((c, i) => `${i + 1}. ${c}`).join('\n')}
 
-Results: ${completed.length} completed, ${failed.length} failed, ${blocked.length} blocked out of ${planLoad.total_pending} total.
+Your job: VERIFY each criterion independently.
+- Read the actual files that were supposedly changed
+- Run any grep/search commands to verify claims
+- Check if the implementation actually satisfies the criterion
+- Do NOT trust the executor's self-assessment
+
+For each criterion:
+- claimed: what the executor says (true/false)
+- verified: what YOU find after checking (true/false)
+- evidence: your proof
+- discrepancy: if claimed != verified, explain what's wrong
+
+Set actually_complete=true ONLY if ALL criteria are genuinely met.
+trust_score: 100 = perfect match, 0 = complete fabrication.`,
+        { label: `verify:${task.task_id}`, phase: 'VerifyConvergence', schema: CONVERGENCE_CHECK_SCHEMA, agentType: 'workflow-verifier' }
+      )
+    })
+  )
+
+  var validConvergenceChecks = convergenceChecks.filter(Boolean)
+  var discrepancies = validConvergenceChecks.flatMap(c =>
+    c.checks.filter(ch => ch.claimed !== ch.verified).map(ch => ({
+      task_id: c.task_id,
+      criterion: ch.criterion,
+      discrepancy: ch.discrepancy || 'claimed ' + ch.claimed + ' but verified ' + ch.verified,
+    }))
+  )
+  var avgTrust = validConvergenceChecks.length > 0
+    ? Math.round(validConvergenceChecks.reduce((s, c) => s + c.trust_score, 0) / validConvergenceChecks.length)
+    : 100
+
+  log(`Convergence verification: ${discrepancies.length} discrepancies found, avg trust: ${avgTrust}%`)
+} else {
+  var validConvergenceChecks = []
+  var discrepancies = []
+  var avgTrust = 100
+}
+
+// Phase 4: 3-vote status determination
+phase('Report')
+
+const executionSummary = `Results: ${completed.length} completed, ${failed.length} failed, ${blocked.length} blocked out of ${planLoad.total_pending} total.
 
 Completed tasks:
 ${completed.map(r => `- ${r.task_id}: ${r.summary} (${(r.files_changed || []).length} files)`).join('\n') || 'None'}
@@ -179,18 +284,86 @@ ${completed.map(r => `- ${r.task_id}: ${r.summary} (${(r.files_changed || []).le
 Failed tasks:
 ${failed.map(r => `- ${r.task_id}: ${r.error || r.summary}\n  Unmet: ${(r.unmet_criteria || []).join(', ') || 'unknown'}`).join('\n') || 'None'}
 
-Determine:
-- DONE: all tasks completed, no failures
-- DONE_WITH_CONCERNS: some failures but majority succeeded
-- NEEDS_RETRY: critical failures blocking downstream work
+Convergence verification:
+- Tasks spot-checked: ${validConvergenceChecks.length}
+- Discrepancies: ${discrepancies.length}
+- Average trust score: ${avgTrust}%
+${discrepancies.map(d => `- ${d.task_id}: ${d.criterion} — ${d.discrepancy}`).join('\n')}`
+
+log('3-vote status determination (optimist / pessimist / realist)...')
+
+const statusVotes = await parallel([
+  () => agent(
+    `OPTIMIST: Vote on execution status.
+
+${executionSummary}
+
+Your lens: Focus on progress made. Discount minor convergence discrepancies. Trust high trust scores.
+- DONE: if majority completed, failures are minor, trust is >70%
+- DONE_WITH_CONCERNS: if some failures but not blocking
+- NEEDS_RETRY: only if critical failures make the whole execution invalid`,
+    { label: 'vote:optimist', phase: 'Report', schema: STATUS_VOTE_SCHEMA }
+  ),
+  () => agent(
+    `PESSIMIST: Vote on execution status.
+
+${executionSummary}
+
+Your lens: Focus on failures and convergence discrepancies. Low trust = unreliable results.
+- NEEDS_RETRY: if any failures exist or trust < 80%
+- DONE_WITH_CONCERNS: if all tasks completed but trust < 90%
+- DONE: only if zero failures AND zero discrepancies AND trust > 95%`,
+    { label: 'vote:pessimist', phase: 'Report', schema: STATUS_VOTE_SCHEMA }
+  ),
+  () => agent(
+    `REALIST: Vote on execution status.
+
+${executionSummary}
+
+Your lens: Evidence-based judgment. No bias.
+- DONE: all tasks completed, convergence verified, no critical discrepancies
+- DONE_WITH_CONCERNS: completed with minor issues that don't block downstream
+- NEEDS_RETRY: critical failures or convergence trust below 60%`,
+    { label: 'vote:realist', phase: 'Report', schema: STATUS_VOTE_SCHEMA }
+  ),
+])
+
+const validVotes = statusVotes.filter(Boolean)
+const voteCounts = {}
+validVotes.forEach(v => { voteCounts[v.status] = (voteCounts[v.status] || 0) + 1 })
+
+const voteDigest = validVotes.map(v =>
+  `${v.perspective}: ${v.status} (confidence: ${v.confidence}%)\n  ${v.rationale}`
+).join('\n\n')
+
+log(`Status votes: ${Object.entries(voteCounts).map(([k, v]) => k + '=' + v).join(', ')}`)
+
+const report = await agent(
+  `Generate execution report from 3-vote adversarial determination.
+
+=== VOTES ===
+${voteDigest}
+
+Vote tally: ${Object.entries(voteCounts).map(([k, v]) => k + '=' + v).join(', ')}
+
+=== EXECUTION DATA ===
+${executionSummary}
 
-Summarize what was accomplished and what needs attention.`,
+RESOLVE:
+1. Majority vote wins. Tie-break: go with REALIST.
+2. Record adversarial_outcome with each vote and convergence_trust
+3. Include convergence_discrepancies in report
+4. List failed_tasks with errors and unmet criteria
+5. Compile all files_changed across completed tasks
+6. Summarize execution including adversarial deliberation outcome`,
   { label: 'report', phase: 'Report', schema: REPORT_SCHEMA }
 )
 
 return {
   report: report,
   results: allResults,
+  convergence_checks: validConvergenceChecks,
+  status_votes: validVotes,
   metadata: {
     plan_dir: planLoad.plan_dir,
     waves_executed: waveIndex,
@@ -198,6 +371,9 @@ return {
     completed: completed.length,
     failed: failed.length,
     blocked: blocked.length,
+    convergence_trust: avgTrust,
+    discrepancy_count: discrepancies.length,
+    vote_counts: voteCounts,
     all_files_changed: completed.flatMap(r => r.files_changed || []),
   },
 }