maestro-flow 0.4.20 → 0.4.21

package/workflows/swarm/wf-analyze.js

@@ -1,11 +1,12 @@
 export const meta = {
   name: 'wf-analyze',
-  description: 'Multi-dimensional parallel analysis aligned with maestro-analyze 6-dimension scoring',
-  whenToUse: 'Accelerate maestro-analyze with parallel codebase exploration + dimension scoring + synthesis',
+  description: 'Multi-dimensional analysis with adversarial score verification and 3-way advocacy synthesis',
+  whenToUse: 'Accelerate maestro-analyze with parallel exploration + scoring + adversarial cross-verify + judge panel Go/No-Go',
   phases: [
     { title: 'Explore', detail: '3-layer codebase exploration via cli-explore-agent' },
     { title: 'Score', detail: 'Parallel 6-dimension scoring via workflow-analyzer' },
-    { title: 'Synthesize', detail: 'Cross-dimension synthesis with Go/No-Go recommendation' },
+    { title: 'CrossVerify', detail: 'Adversarial skeptic challenges each dimension score' },
+    { title: 'Synthesize', detail: '3-way adversarial advocacy (go/no-go/conditional) + referee verdict' },
   ],
 }
 
@@ -43,6 +44,32 @@ const DIMENSION_SCHEMA = {
   required: ['dimension', 'score', 'confidence', 'evidence', 'summary'],
 }
 
+const SCORE_CHALLENGE_SCHEMA = {
+  type: 'object',
+  properties: {
+    dimension: { type: 'string' },
+    original_score: { type: 'number' },
+    challenge_result: { type: 'string', enum: ['confirmed', 'inflated', 'deflated'] },
+    adjusted_score: { type: 'number', minimum: 1, maximum: 5 },
+    counter_evidence: { type: 'array', items: { type: 'object', properties: { claim: { type: 'string' }, source: { type: 'string' } }, required: ['claim', 'source'] } },
+    reasoning: { type: 'string' },
+  },
+  required: ['dimension', 'original_score', 'challenge_result', 'adjusted_score', 'reasoning'],
+}
+
+const ADVOCACY_SCHEMA = {
+  type: 'object',
+  properties: {
+    stance: { type: 'string', enum: ['go', 'conditional-go', 'no-go'] },
+    argument: { type: 'string' },
+    key_evidence: { type: 'array', items: { type: 'object', properties: { point: { type: 'string' }, source: { type: 'string' }, strength: { type: 'string', enum: ['strong', 'moderate', 'weak'] } }, required: ['point', 'source'] } },
+    weaknesses_acknowledged: { type: 'array', items: { type: 'string' } },
+    conditions: { type: 'array', items: { type: 'string' } },
+    confidence: { type: 'number', minimum: 0, maximum: 100 },
+  },
+  required: ['stance', 'argument', 'key_evidence', 'confidence'],
+}
+
 const SYNTHESIS_SCHEMA = {
   type: 'object',
   properties: {
@@ -50,18 +77,19 @@ const SYNTHESIS_SCHEMA = {
     overall_confidence: { type: 'number', minimum: 0, maximum: 100 },
     recommendation: { type: 'string', enum: ['go', 'conditional-go', 'no-go'] },
     scope_verdict: { type: 'string', enum: ['large', 'medium', 'small'] },
+    adversarial_outcome: { type: 'object', properties: { winning_stance: { type: 'string' }, go_confidence: { type: 'number' }, nogo_confidence: { type: 'number' }, conditional_confidence: { type: 'number' }, decisive_factor: { type: 'string' } }, required: ['winning_stance', 'decisive_factor'] },
     risk_matrix: { type: 'array', items: { type: 'object', properties: { risk: { type: 'string' }, probability: { type: 'string' }, impact: { type: 'string' }, dimension: { type: 'string' } }, required: ['risk', 'probability', 'impact', 'dimension'] } },
     decisions: { type: 'array', items: { type: 'object', properties: { id: { type: 'string' }, decision: { type: 'string' }, status: { type: 'string', enum: ['locked', 'free', 'deferred'] }, rationale: { type: 'string' }, options_considered: { type: 'array', items: { type: 'string' } } }, required: ['id', 'decision', 'status', 'rationale'] } },
     implementation_scope: { type: 'array', items: { type: 'object', properties: { objective: { type: 'string' }, acceptance_criteria: { type: 'string' }, priority: { type: 'string', enum: ['high', 'medium', 'low'] }, target_files: { type: 'array', items: { type: 'string' } } }, required: ['objective', 'priority'] } },
     executive_summary: { type: 'string' },
   },
-  required: ['overall_score', 'overall_confidence', 'recommendation', 'scope_verdict', 'risk_matrix', 'decisions', 'executive_summary'],
+  required: ['overall_score', 'overall_confidence', 'recommendation', 'scope_verdict', 'adversarial_outcome', 'risk_matrix', 'decisions', 'executive_summary'],
 }
 
 const target = args?.target || 'the current codebase'
 const scope = args?.scope || ''
 const context = args?.context || ''
-const phase = args?.phase || null
+const phaseArg = args?.phase || null
 const selectedDimensions = args?.dimensions
   ? DIMENSIONS.filter(d => args.dimensions.includes(d.key))
   : DIMENSIONS
@@ -74,7 +102,7 @@ const exploration = await agent(
   `Perform 3-layer codebase exploration for: ${target}
 ${scope ? 'File scope: ' + scope : 'Explore the full project structure.'}
 ${context ? 'Additional context: ' + context : ''}
-${phase ? 'Phase context: ' + phase : ''}
+${phaseArg ? 'Phase context: ' + phaseArg : ''}
 
 Layer 1 — Module Discovery (Breadth):
   Search by topic keywords, identify ALL relevant files, map module boundaries.
@@ -107,7 +135,7 @@ const scores = await parallel(
       `Evaluate dimension: ${dim.key}
 Focus areas: ${dim.focus}
 Target: ${target}
-${phase ? 'Phase: ' + phase : ''}
+${phaseArg ? 'Phase: ' + phaseArg : ''}
 
 Codebase exploration context:
 ${explorationContext}
@@ -130,57 +158,190 @@ For Risk dimension: include probability × impact matrix entries.`,
 const validScores = scores.filter(Boolean)
 log(`${validScores.length}/${selectedDimensions.length} dimensions scored`)
 
-// Phase 3: Cross-Dimension Synthesis
+// Phase 3: Adversarial CrossVerify — skeptic challenges each dimension score
+phase('CrossVerify')
+log(`Adversarial challenge of ${validScores.length} dimension scores...`)
+
+const challenges = await pipeline(
+  validScores,
+  (score) => agent(
+    `You are an adversarial SKEPTIC. Your job is to REFUTE this dimension score.
+
+Dimension: ${score.dimension}
+Original Score: ${score.score}/5 (confidence: ${score.confidence}%)
+Evidence cited:
+${score.evidence.map(e => '- ' + e.claim + ' [' + e.strength + '] @ ' + e.source).join('\n')}
+Risks identified: ${(score.risks || []).map(r => r.risk + ' (' + r.probability + '/' + r.impact + ')').join('; ') || 'none'}
+Summary: ${score.summary}
+
+Target: ${target}
+${explorationContext}
+
+CHALLENGE the score by:
+1. Read the ACTUAL source files cited as evidence — does the code actually support the claim?
+2. Search for counter-evidence the scorer missed (contradictory patterns, hidden complexity)
+3. Check for cognitive biases: anchoring to first impression, confirmation bias, optimism bias
+4. Evaluate if the confidence level is justified by evidence quantity and strength
+
+Challenge result:
+- "confirmed": evidence holds, score is fair (only if you genuinely cannot find counter-evidence)
+- "inflated": score should be LOWER — evidence is weak, cherry-picked, or missing key risks
+- "deflated": score should be HIGHER — scorer was too pessimistic, missed positive signals
+
+DEFAULT to "inflated" if uncertain — skeptics err on the side of caution.
+Provide your adjusted_score and specific counter_evidence.`,
+    { label: `challenge:${score.dimension}`, phase: 'CrossVerify', schema: SCORE_CHALLENGE_SCHEMA, agentType: 'workflow-analyzer' }
+  )
+)
+
+const adjustedScores = validScores.map((score, i) => {
+  const challenge = challenges[i]
+  if (!challenge) return score
+  return {
+    ...score,
+    original_score: score.score,
+    score: challenge.adjusted_score,
+    challenge_result: challenge.challenge_result,
+    challenge_reasoning: challenge.reasoning,
+    counter_evidence: challenge.counter_evidence,
+  }
+})
+
+const challengedCount = challenges.filter(Boolean).filter(c => c.challenge_result !== 'confirmed').length
+log(`${challengedCount}/${validScores.length} scores adjusted by adversarial challenge`)
+
+// Phase 4: 3-way Adversarial Advocacy Panel + Referee
 phase('Synthesize')
 
-const scoreDigest = validScores.map(s =>
-  `${s.dimension}: ${s.score}/5 (confidence: ${s.confidence}%)\n  ${s.summary}\n  Evidence: ${s.evidence.slice(0, 3).map(e => e.claim + ' [' + e.strength + ']').join('; ')}\n  Risks: ${(s.risks || []).map(r => r.risk + ' (' + r.probability + '/' + r.impact + ')').join('; ') || 'none identified'}`
+const scoreDigest = adjustedScores.map(s =>
+  `${s.dimension}: ${s.score}/5${s.original_score !== undefined && s.original_score !== s.score ? ' (was ' + s.original_score + '/5, ' + s.challenge_result + ')' : ''} (confidence: ${s.confidence}%)\n  ${s.summary}${s.challenge_reasoning ? '\n  Skeptic: ' + s.challenge_reasoning : ''}\n  Evidence: ${s.evidence.slice(0, 3).map(e => e.claim + ' [' + e.strength + ']').join('; ')}\n  Risks: ${(s.risks || []).map(r => r.risk + ' (' + r.probability + '/' + r.impact + ')').join('; ') || 'none identified'}`
+).join('\n\n')
+
+log('Launching 3-way adversarial advocacy panel (go / no-go / conditional)...')
+
+const advocacies = await parallel([
+  () => agent(
+    `You are the GO ADVOCATE. Argue that this project SHOULD proceed immediately.
+
+Target: ${target}
+${phaseArg ? 'Phase: ' + phaseArg : ''}
+
+Dimension Scores (after adversarial challenge):
+${scoreDigest}
+
+Codebase: ${explorationContext}
+
+Make the STRONGEST possible case for GO:
+- Highlight favorable scores and strong evidence
+- Reframe manageable risks with concrete mitigation strategies
+- Emphasize opportunity cost of NOT proceeding (market window, tech debt accumulation)
+- Acknowledge weaknesses honestly — admitted weaknesses strengthen credibility
+
+You MUST argue for "go". Your confidence reflects how strong your case actually is, not how much you want it to succeed.`,
+    { label: 'advocate:go', phase: 'Synthesize', schema: ADVOCACY_SCHEMA }
+  ),
+  () => agent(
+    `You are the NO-GO ADVOCATE. Argue that this project should NOT proceed.
+
+Target: ${target}
+${phaseArg ? 'Phase: ' + phaseArg : ''}
+
+Dimension Scores (after adversarial challenge):
+${scoreDigest}
+
+Codebase: ${explorationContext}
+
+Make the STRONGEST possible case for NO-GO:
+- Highlight unfavorable scores, especially where skeptics adjusted downward
+- Emphasize cascading failure risks and evidence gaps
+- Point out where confidence is low but implications are high
+- Acknowledge strengths honestly — admitted strengths strengthen credibility
+
+You MUST argue for "no-go". Your confidence reflects how strong your case actually is.`,
+    { label: 'advocate:no-go', phase: 'Synthesize', schema: ADVOCACY_SCHEMA }
+  ),
+  () => agent(
+    `You are the CONDITIONAL-GO ADVOCATE. Argue this should proceed ONLY under specific conditions.
+
+Target: ${target}
+${phaseArg ? 'Phase: ' + phaseArg : ''}
+
+Dimension Scores (after adversarial challenge):
+${scoreDigest}
+
+Codebase: ${explorationContext}
+
+Make the case for CONDITIONAL-GO:
+- Identify which risks are blocking vs manageable with mitigation
+- Define SPECIFIC, MEASURABLE conditions that must be met before proceeding
+- Propose staged approach that limits downside (MVP → iterate)
+- Specify non-negotiable prerequisites vs nice-to-haves
+
+You MUST argue for "conditional-go". List concrete conditions in the conditions[] field.`,
+    { label: 'advocate:conditional', phase: 'Synthesize', schema: ADVOCACY_SCHEMA }
+  ),
+])
+
+const validAdvocacies = advocacies.filter(Boolean)
+const advocacyDigest = validAdvocacies.map(a =>
+  `### ${a.stance.toUpperCase()} ADVOCATE (confidence: ${a.confidence}%)\n${a.argument}\nKey evidence: ${a.key_evidence.map(e => e.point + ' [' + e.strength + ']').join('; ')}\nWeaknesses admitted: ${(a.weaknesses_acknowledged || []).join('; ') || 'none'}\nConditions: ${(a.conditions || []).join('; ') || 'n/a'}`
 ).join('\n\n')
 
+log('Referee resolving adversarial debate...')
+
 const synthesis = await agent(
-  `Synthesize multi-dimensional analysis results into a Go/No-Go recommendation.
+  `You are the REFEREE. Three advocates have argued their positions on this project.
 
 Target: ${target}
-${phase ? 'Phase: ' + phase : ''}
+${phaseArg ? 'Phase: ' + phaseArg : ''}
 
-Dimension Scores:
+=== ADVERSARIAL DEBATE ===
+${advocacyDigest}
+
+=== ADJUSTED DIMENSION SCORES ===
 ${scoreDigest}
 
-Codebase Exploration:
+=== CODEBASE EXPLORATION ===
 ${explorationContext}
 
-Tasks:
-1. Calculate weighted overall score (Feasibility .25, Impact .20, Risk .20, Complexity .15, Dependencies .15, Alternatives .05)
-2. Build probability-impact risk matrix from all dimension risks
-3. Determine scope_verdict:
-   - "large": 3+ independent subsystems or hard serial dependencies
-   - "medium": 1-2 subsystems, parallelizable
-   - "small": single-file or few-file change
-4. Extract decisions (locked/free/deferred) based on findings
-5. Define implementation_scope with objectives, acceptance criteria, and target files
-6. Make Go/No-Go/Conditional-Go recommendation with confidence level
-7. Write executive summary (2-3 paragraphs)
-
-Recommendation rules:
-- Any dimension at 1/5 with high confidence → no-go (unless mitigated)
-- Average < 2.5 → no-go
-- Average 2.5-3.5 with risks → conditional-go (list conditions)
-- Average > 3.5 → go`,
-  { label: 'synthesize', phase: 'Synthesize', schema: SYNTHESIS_SCHEMA, agentType: 'workflow-analyzer' }
+RESOLVE the debate:
+1. Evaluate each advocate's argument strength + acknowledged weaknesses
+2. Cross-reference evidence claims against actual dimension scores
+3. Higher confidence + stronger evidence = more weight
+4. Record the adversarial_outcome: which stance won and the decisive factor
+
+Decision rules:
+- Any adjusted dimension at 1/5 with confirmed evidence → no-go
+- Average adjusted score < 2.5 → no-go
+- No-go confidence > 80% AND go confidence < 50% → no-go
+- Go confidence > 80% AND no-go confidence < 40% → go
+- If go and no-go are BOTH high-confidence (>60%) → conditional-go (genuine controversy)
+- Otherwise → weigh by evidence strength
+
+Then:
+5. Calculate weighted overall score (Feasibility .25, Impact .20, Risk .20, Complexity .15, Dependencies .15, Alternatives .05)
+6. Build risk_matrix from all dimensions
+7. Extract decisions (locked/free/deferred)
+8. Define implementation_scope
+9. Write executive summary including adversarial debate outcome`,
+  { label: 'referee', phase: 'Synthesize', schema: SYNTHESIS_SCHEMA, agentType: 'workflow-analyzer' }
 )
 
 return {
   exploration: exploration,
-  dimensions: validScores,
+  dimensions: adjustedScores,
+  advocacies: validAdvocacies,
   synthesis: synthesis,
   metadata: {
     target: target,
     scope: scope,
-    phase: phase,
+    phase: phaseArg,
     dimension_count: selectedDimensions.length,
     completed_count: validScores.length,
+    scores_challenged: challengedCount,
     overall_score: synthesis ? synthesis.overall_score : null,
     recommendation: synthesis ? synthesis.recommendation : null,
     scope_verdict: synthesis ? synthesis.scope_verdict : null,
+    adversarial_outcome: synthesis ? synthesis.adversarial_outcome : null,
   },
 }