maestro-flow 0.4.18 → 0.4.20

package/workflows/swarm/wf-grill.js

@@ -0,0 +1,198 @@
+export const meta = {
+  name: 'wf-grill',
+  description: 'Parallel adversarial stress-testing across decision branches',
+  whenToUse: 'Accelerate maestro-grill auto mode with parallel branch exploration and contradiction detection',
+  phases: [
+    { title: 'Explore', detail: 'Codebase evidence gathering via cli-explore-agent' },
+    { title: 'Stress', detail: 'Parallel adversarial branch probing' },
+    { title: 'Synthesize', detail: 'Contradiction detection and terminology crystallization' },
+  ],
+}
+
+const BRANCHES = [
+  { key: 'scope', focus: 'Scope & Boundaries — What is explicitly in/out? Where are the edges? Challenge vague boundaries with concrete code symbols.' },
+  { key: 'data-model', focus: 'Data Model & State — How does data flow? What state transitions exist? Challenge naming conflicts with codebase terminology.' },
+  { key: 'edge-cases', focus: 'Edge Cases & Failure Modes — What breaks at scale? What happens on invalid input? What if dependent services fail?' },
+  { key: 'integration', focus: 'Integration & Dependencies — What existing systems are touched? What contracts must be honored? What breaks if we change X?' },
+  { key: 'scale', focus: 'Scale & Performance — At 10x/100x current load, what breaks first? Which queries degrade? Where are the O(n^2) risks?' },
+  { key: 'security', focus: 'Security & Access Control — What is the attack surface? Who can access what? Where is trust assumed but not verified?' },
+  { key: 'operations', focus: 'Observability & Operations — How do we know it is working? What alerts fire? How do we debug production issues?' },
+  { key: 'migration', focus: 'Migration & Rollback — What is the rollback path? Can we do a zero-downtime deploy? What data migration is needed?' },
+]
+
+const EXPLORATION_SCHEMA = {
+  type: 'object',
+  properties: {
+    relevant_symbols: { type: 'array', items: { type: 'object', properties: { symbol: { type: 'string' }, file: { type: 'string' }, line: { type: 'number' }, type: { type: 'string' } }, required: ['symbol', 'file'] } },
+    existing_terminology: { type: 'array', items: { type: 'object', properties: { term: { type: 'string' }, usage_location: { type: 'string' }, context: { type: 'string' } }, required: ['term', 'usage_location'] } },
+    data_flows: { type: 'array', items: { type: 'object', properties: { from: { type: 'string' }, to: { type: 'string' }, data_shape: { type: 'string' } }, required: ['from', 'to'] } },
+    integration_points: { type: 'array', items: { type: 'object', properties: { system: { type: 'string' }, interface: { type: 'string' }, contract: { type: 'string' } }, required: ['system', 'interface'] } },
+  },
+  required: ['relevant_symbols', 'existing_terminology'],
+}
+
+const BRANCH_SCHEMA = {
+  type: 'object',
+  properties: {
+    branch: { type: 'string' },
+    challenges: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          question: { type: 'string' },
+          code_evidence: { type: 'string' },
+          contradiction: { type: 'string' },
+          severity: { type: 'string', enum: ['blocking', 'significant', 'minor'] },
+          proposed_resolution: { type: 'string' },
+        },
+        required: ['question', 'severity'],
+      },
+    },
+    terminology_conflicts: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          proposed_term: { type: 'string' },
+          codebase_term: { type: 'string' },
+          location: { type: 'string' },
+          recommendation: { type: 'string' },
+        },
+        required: ['proposed_term', 'codebase_term', 'recommendation'],
+      },
+    },
+    assumptions_challenged: { type: 'array', items: { type: 'string' } },
+    verdict: { type: 'string', enum: ['sound', 'needs-clarification', 'fundamentally-flawed'] },
+  },
+  required: ['branch', 'challenges', 'terminology_conflicts', 'assumptions_challenged', 'verdict'],
+}
+
+const SYNTHESIS_SCHEMA = {
+  type: 'object',
+  properties: {
+    overall_verdict: { type: 'string', enum: ['ready-for-brainstorm', 'needs-refinement', 'back-to-drawing-board'] },
+    blocking_issues: { type: 'array', items: { type: 'object', properties: { branch: { type: 'string' }, issue: { type: 'string' }, must_resolve_before: { type: 'string' } }, required: ['branch', 'issue'] } },
+    terminology: { type: 'array', items: { type: 'object', properties: { term: { type: 'string' }, definition: { type: 'string' }, code_alignment: { type: 'string' } }, required: ['term', 'definition'] } },
+    contradictions: { type: 'array', items: { type: 'object', properties: { between_branches: { type: 'array', items: { type: 'string' } }, description: { type: 'string' }, resolution: { type: 'string' } }, required: ['between_branches', 'description'] } },
+    constraints_discovered: { type: 'array', items: { type: 'object', properties: { constraint: { type: 'string' }, source: { type: 'string' }, impact: { type: 'string' }, status: { type: 'string', enum: ['locked', 'free', 'deferred'] } }, required: ['constraint', 'source', 'status'] } },
+    executive_summary: { type: 'string' },
+  },
+  required: ['overall_verdict', 'blocking_issues', 'terminology', 'contradictions', 'constraints_discovered', 'executive_summary'],
+}
+
+const topic = args?.topic || ''
+const context = args?.context || ''
+const depth = args?.depth || 'standard'
+const branchCount = depth === 'shallow' ? 3 : depth === 'deep' ? 8 : 5
+const selectedBranches = BRANCHES.slice(0, branchCount)
+
+// Phase 1: Codebase evidence gathering
+phase('Explore')
+log('Gathering codebase evidence for stress-testing...')
+
+const exploration = await agent(
+  `Explore the codebase to gather evidence for stress-testing this proposal:
+Topic: ${topic}
+${context ? 'Context: ' + context : ''}
+
+Find:
+1. Relevant symbols — functions, classes, types, variables related to this topic
+2. Existing terminology — how the codebase names things in this domain (for conflict detection)
+3. Data flows — how data moves through the system in this area
+4. Integration points — external systems, internal modules, APIs touched
+
+This evidence will be used to challenge assumptions and detect contradictions.`,
+  { label: 'explore:evidence', phase: 'Explore', schema: EXPLORATION_SCHEMA, agentType: 'cli-explore-agent' }
+)
+
+const evidenceContext = exploration
+  ? `Codebase evidence:
+Symbols: ${exploration.relevant_symbols.map(s => s.symbol + ' @ ' + s.file).join(', ')}
+Terminology: ${exploration.existing_terminology.map(t => t.term + ' (' + t.usage_location + ')').join(', ')}
+Data flows: ${(exploration.data_flows || []).map(d => d.from + ' → ' + d.to).join(', ')}
+Integration: ${(exploration.integration_points || []).map(i => i.system + ':' + i.interface).join(', ')}`
+  : ''
+
+// Phase 2: Parallel adversarial branch probing
+phase('Stress')
+log(`Stress-testing ${selectedBranches.length} branches in parallel...`)
+
+const branchResults = await parallel(
+  selectedBranches.map(branch => () =>
+    agent(
+      `You are an adversarial stress-tester for the "${branch.key}" branch.
+
+Proposal being tested: ${topic}
+${context ? 'Proposal context: ' + context : ''}
+${evidenceContext}
+
+Your focus: ${branch.focus}
+
+Your job is to BREAK this proposal by:
+1. Finding contradictions with existing code (cite file:line)
+2. Detecting terminology conflicts (proposed names vs codebase names)
+3. Challenging unstated assumptions with concrete counter-scenarios
+4. Probing for cases the proposal hasn't considered
+
+For each challenge:
+- Ground it in code evidence (file paths, symbol names, data shapes)
+- Classify severity: blocking (must fix before proceeding), significant (should address), minor (nice to clarify)
+- Propose a resolution direction
+
+Be adversarial but fair — only raise real issues backed by evidence.`,
+      { label: `stress:${branch.key}`, phase: 'Stress', schema: BRANCH_SCHEMA }
+    )
+  )
+)
+
+const validBranches = branchResults.filter(Boolean)
+log(`${validBranches.length}/${selectedBranches.length} branches probed`)
+
+// Phase 3: Cross-branch synthesis
+phase('Synthesize')
+
+const branchDigest = validBranches.map(b => {
+  const blocking = b.challenges.filter(c => c.severity === 'blocking')
+  return `## ${b.branch} [${b.verdict}]
+Challenges: ${b.challenges.length} (${blocking.length} blocking)
+${blocking.map(c => `  ⚠ ${c.question}${c.contradiction ? ' — ' + c.contradiction : ''}`).join('\n')}
+Terminology conflicts: ${b.terminology_conflicts.map(t => t.proposed_term + ' vs ' + t.codebase_term).join(', ') || 'none'}
+Assumptions challenged: ${b.assumptions_challenged.join('; ') || 'none'}`
+}).join('\n\n')
+
+const synthesis = await agent(
+  `Synthesize stress-test results across all branches.
+
+Proposal: ${topic}
+
+Branch Results:
+${branchDigest}
+
+Tasks:
+1. Identify cross-branch CONTRADICTIONS — where one branch's finding conflicts with another's
+2. Compile unified TERMINOLOGY list (proposed term → aligned codebase term → definition)
+3. Extract CONSTRAINTS discovered (things that MUST be true based on evidence) — classify as locked/free/deferred
+4. List all BLOCKING issues that must resolve before brainstorm/planning
+5. Determine overall verdict:
+   - "ready-for-brainstorm": no blocking issues, well-scoped
+   - "needs-refinement": some blocking issues but fixable
+   - "back-to-drawing-board": fundamental flaws detected
+6. Write executive summary`,
+  { label: 'synthesize', phase: 'Synthesize', schema: SYNTHESIS_SCHEMA }
+)
+
+return {
+  exploration: exploration,
+  branches: validBranches,
+  synthesis: synthesis,
+  metadata: {
+    topic: topic,
+    depth: depth,
+    branch_count: selectedBranches.length,
+    completed_count: validBranches.length,
+    blocking_count: synthesis ? synthesis.blocking_issues.length : 0,
+    contradiction_count: synthesis ? synthesis.contradictions.length : 0,
+    overall_verdict: synthesis ? synthesis.overall_verdict : 'unknown',
+  },
+}

package/workflows/swarm/wf-milestone-audit.js

@@ -0,0 +1,236 @@
+export const meta = {
+  name: 'wf-milestone-audit',
+  description: 'Parallel cross-phase integration audit via workflow-integration-checker',
+  whenToUse: 'Accelerate maestro-milestone-audit with parallel phase coverage, execution completeness, and integration checks',
+  phases: [
+    { title: 'Audit', detail: 'Parallel 4-dimension milestone audit' },
+    { title: 'Report', detail: 'Consolidated audit verdict' },
+  ],
+}
+
+const COVERAGE_SCHEMA = {
+  type: 'object',
+  properties: {
+    check_type: { type: 'string' },
+    passed: { type: 'boolean' },
+    phases: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          phase: { type: 'string' },
+          has_plan: { type: 'boolean' },
+          has_execute: { type: 'boolean' },
+          has_verify: { type: 'boolean' },
+          plan_artifact_id: { type: 'string' },
+          execute_artifact_id: { type: 'string' },
+          status: { type: 'string', enum: ['complete', 'partial', 'missing'] },
+        },
+        required: ['phase', 'has_plan', 'has_execute', 'status'],
+      },
+    },
+    summary: { type: 'string' },
+  },
+  required: ['check_type', 'passed', 'phases', 'summary'],
+}
+
+const EXECUTION_SCHEMA = {
+  type: 'object',
+  properties: {
+    check_type: { type: 'string' },
+    passed: { type: 'boolean' },
+    plans: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          plan_id: { type: 'string' },
+          plan_dir: { type: 'string' },
+          total_tasks: { type: 'number' },
+          completed_tasks: { type: 'number' },
+          failed_tasks: { type: 'number' },
+          pending_tasks: { type: 'number' },
+          incomplete_task_ids: { type: 'array', items: { type: 'string' } },
+        },
+        required: ['plan_id', 'total_tasks', 'completed_tasks'],
+      },
+    },
+    summary: { type: 'string' },
+  },
+  required: ['check_type', 'passed', 'plans', 'summary'],
+}
+
+const INTEGRATION_SCHEMA = {
+  type: 'object',
+  properties: {
+    check_type: { type: 'string' },
+    passed: { type: 'boolean' },
+    interfaces: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          interface_name: { type: 'string' },
+          producer_phase: { type: 'string' },
+          consumer_phase: { type: 'string' },
+          status: { type: 'string', enum: ['pass', 'fail', 'warning'] },
+          issue: { type: 'string' },
+        },
+        required: ['interface_name', 'producer_phase', 'consumer_phase', 'status'],
+      },
+    },
+    data_contract_issues: { type: 'array', items: { type: 'object', properties: { contract: { type: 'string' }, mismatch: { type: 'string' }, affected_phases: { type: 'array', items: { type: 'string' } } }, required: ['contract', 'mismatch'] } },
+    circular_dependencies: { type: 'array', items: { type: 'string' } },
+    summary: { type: 'string' },
+  },
+  required: ['check_type', 'passed', 'interfaces', 'summary'],
+}
+
+const REPORT_SCHEMA = {
+  type: 'object',
+  properties: {
+    verdict: { type: 'string', enum: ['PASS', 'FAIL'] },
+    confidence: { type: 'number', minimum: 0, maximum: 100 },
+    dimension_results: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          dimension: { type: 'string' },
+          passed: { type: 'boolean' },
+          issue_count: { type: 'number' },
+        },
+        required: ['dimension', 'passed'],
+      },
+    },
+    blocking_issues: { type: 'array', items: { type: 'object', properties: { dimension: { type: 'string' }, description: { type: 'string' }, remediation: { type: 'string' } }, required: ['dimension', 'description', 'remediation'] } },
+    next_step: { type: 'string', enum: ['milestone-complete', 'plan-gaps', 'execute', 'verify'] },
+    summary: { type: 'string' },
+  },
+  required: ['verdict', 'confidence', 'dimension_results', 'blocking_issues', 'next_step', 'summary'],
+}
+
+const milestone = args?.milestone || ''
+const isAdhoc = args?.is_adhoc || false
+
+// Phase 1: Parallel 4-dimension audit
+phase('Audit')
+
+const checks = [
+  // Dimension 1: Phase coverage (skip for adhoc milestones)
+  () => agent(
+    `Phase Coverage Audit${isAdhoc ? ' (ADHOC — skip roadmap phase checks, only verify artifact chain PLN→EXC exists)' : ''}.
+${milestone ? 'Milestone: ' + milestone : 'Use current_milestone from .workflow/state.json'}
+
+${isAdhoc ? `Adhoc milestone: skip roadmap.md parsing. Only check:
+1. At least one PLN artifact exists for this milestone
+2. Each PLN has a corresponding EXC artifact
+3. All are status=completed` : `Standard milestone:
+1. Read .workflow/roadmap.md to get milestone → phase mapping
+2. Read .workflow/state.json artifacts[] filtered by this milestone
+3. For each phase in the milestone:
+   - Check: has plan artifact (type=plan, status=completed)?
+   - Check: has execute artifact (type=execute, status=completed)?
+   - Check: has verify artifact (type=verify)? (optional but noted)
+4. Report each phase as complete/partial/missing`}
+
+Set check_type="phase-coverage" in output.`,
+    { label: 'audit:coverage', phase: 'Audit', schema: COVERAGE_SCHEMA }
+  ),
+
+  // Dimension 2: Execution completeness
+  () => agent(
+    `Execution Completeness Audit.
+${milestone ? 'Milestone: ' + milestone : 'Use current_milestone from .workflow/state.json'}
+
+1. Read .workflow/state.json — find all execute artifacts for this milestone
+2. For each execute artifact:
+   - Resolve its plan directory (artifact.path)
+   - Read all .task/TASK-*.json files in that directory
+   - Count: total, completed, failed, pending
+   - List any incomplete task IDs
+3. Passed only if ALL tasks across ALL plans are completed (no pending/failed)
+
+Set check_type="execution-completeness" in output.`,
+    { label: 'audit:execution', phase: 'Audit', schema: EXECUTION_SCHEMA }
+  ),
+
+  // Dimension 3: Cross-phase integration
+  () => agent(
+    `Cross-Phase Integration Audit.
+${milestone ? 'Milestone: ' + milestone : 'Use current_milestone from .workflow/state.json'}
+
+Check that phases compose correctly:
+1. Scan for shared interfaces, types, APIs across phase boundaries
+2. Verify contract compliance:
+   - Type definitions match usage across phases
+   - API request/response schemas are consistent
+   - Event names and payloads align between producer and consumer
+3. Check dependency health:
+   - Cross-phase imports resolve correctly
+   - No circular dependencies across phase boundaries
+   - Shared dependency versions are compatible
+4. Trace data flow across boundaries:
+   - Input/output formats match
+   - Error propagation is handled at boundaries
+
+Report each interface check as pass/fail/warning with specific issues.
+Set check_type="integration" in output.`,
+    { label: 'audit:integration', phase: 'Audit', schema: INTEGRATION_SCHEMA, agentType: 'workflow-integration-checker' }
+  ),
+]
+
+log(`Running ${checks.length} audit dimensions in parallel...`)
+const results = await parallel(checks)
+const validResults = results.filter(Boolean)
+
+// Phase 2: Consolidated report
+phase('Report')
+
+const coverage = validResults.find(r => r.check_type === 'phase-coverage')
+const execution = validResults.find(r => r.check_type === 'execution-completeness')
+const integration = validResults.find(r => r.check_type === 'integration')
+
+const auditDigest = `Phase Coverage: ${coverage ? (coverage.passed ? 'PASS' : 'FAIL') + ' — ' + coverage.summary : 'NOT RUN'}
+
+Execution Completeness: ${execution ? (execution.passed ? 'PASS' : 'FAIL') + ' — ' + execution.summary : 'NOT RUN'}
+${execution && !execution.passed ? 'Incomplete plans: ' + execution.plans.filter(p => p.pending_tasks > 0 || p.failed_tasks > 0).map(p => p.plan_id + ' (' + p.pending_tasks + ' pending, ' + p.failed_tasks + ' failed)').join('; ') : ''}
+
+Integration: ${integration ? (integration.passed ? 'PASS' : 'FAIL') + ' — ' + integration.summary : 'NOT RUN'}
+${integration && !integration.passed ? 'Failed interfaces: ' + integration.interfaces.filter(i => i.status === 'fail').map(i => i.interface_name + ': ' + i.issue).join('; ') : ''}
+${integration && integration.data_contract_issues.length > 0 ? 'Data contract issues: ' + integration.data_contract_issues.map(d => d.contract + ' — ' + d.mismatch).join('; ') : ''}`
+
+const report = await agent(
+  `Generate consolidated milestone audit report.
+
+${auditDigest}
+
+Determine:
+1. Overall verdict: PASS only if ALL dimensions pass
+2. Confidence score (0-100)
+3. List blocking issues with specific remediation
+4. Determine next step:
+   - "milestone-complete": all pass → ready to close milestone
+   - "plan-gaps": integration issues need new plan
+   - "execute": incomplete execution
+   - "verify": missing verification artifacts
+5. Write summary`,
+  { label: 'report', phase: 'Report', schema: REPORT_SCHEMA }
+)
+
+return {
+  coverage: coverage,
+  execution: execution,
+  integration: integration,
+  report: report,
+  metadata: {
+    milestone: milestone,
+    is_adhoc: isAdhoc,
+    dimensions_checked: validResults.length,
+    coverage_passed: coverage ? coverage.passed : null,
+    execution_passed: execution ? execution.passed : null,
+    integration_passed: integration ? integration.passed : null,
+    verdict: report ? report.verdict : 'UNKNOWN',
+    next_step: report ? report.next_step : null,
+  },
+}

package/workflows/swarm/wf-plan.js

@@ -0,0 +1,233 @@
+export const meta = {
+  name: 'wf-plan',
+  description: 'Parallel context exploration + task decomposition via workflow-planner',
+  whenToUse: 'Accelerate maestro-plan with parallel context gathering and plan generation',
+  phases: [
+    { title: 'Context', detail: 'Parallel context exploration from multiple sources' },
+    { title: 'Plan', detail: 'Task decomposition and wave assignment via workflow-planner' },
+    { title: 'Check', detail: 'Plan quality verification via workflow-plan-checker' },
+  ],
+}
+
+const CONTEXT_SCHEMA = {
+  type: 'object',
+  properties: {
+    source: { type: 'string' },
+    decisions: { type: 'array', items: { type: 'object', properties: { id: { type: 'string' }, decision: { type: 'string' }, status: { type: 'string', enum: ['locked', 'free', 'deferred'] }, rationale: { type: 'string' } }, required: ['decision', 'status'] } },
+    requirements: { type: 'array', items: { type: 'object', properties: { id: { type: 'string' }, objective: { type: 'string' }, acceptance_criteria: { type: 'string' }, priority: { type: 'string' }, target_files: { type: 'array', items: { type: 'string' } } }, required: ['objective'] } },
+    constraints: { type: 'array', items: { type: 'string' } },
+    existing_patterns: { type: 'array', items: { type: 'object', properties: { pattern: { type: 'string' }, file: { type: 'string' }, usage: { type: 'string' } }, required: ['pattern', 'file'] } },
+    dependencies: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['source', 'decisions', 'requirements'],
+}
+
+const PLAN_SCHEMA = {
+  type: 'object',
+  properties: {
+    summary: { type: 'string' },
+    approach: { type: 'string' },
+    complexity: { type: 'string', enum: ['low', 'medium', 'high'] },
+    waves: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          wave_index: { type: 'number' },
+          rationale: { type: 'string' },
+          tasks: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                task_id: { type: 'string' },
+                title: { type: 'string' },
+                description: { type: 'string' },
+                scope: { type: 'string' },
+                focus_paths: { type: 'array', items: { type: 'string' } },
+                depends_on: { type: 'array', items: { type: 'string' } },
+                convergence_criteria: { type: 'array', items: { type: 'string' } },
+                files: { type: 'array', items: { type: 'object', properties: { path: { type: 'string' }, action: { type: 'string', enum: ['create', 'modify', 'delete'] }, change: { type: 'string' } }, required: ['path', 'action'] } },
+                issue_id: { type: 'string' },
+              },
+              required: ['task_id', 'title', 'description', 'convergence_criteria'],
+            },
+          },
+        },
+        required: ['wave_index', 'tasks'],
+      },
+    },
+    total_tasks: { type: 'number' },
+  },
+  required: ['summary', 'approach', 'waves', 'total_tasks'],
+}
+
+const CHECK_SCHEMA = {
+  type: 'object',
+  properties: {
+    verdict: { type: 'string', enum: ['pass', 'pass-with-notes', 'needs-revision'] },
+    issues: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          severity: { type: 'string', enum: ['critical', 'warning', 'note'] },
+          category: { type: 'string' },
+          description: { type: 'string' },
+          affected_tasks: { type: 'array', items: { type: 'string' } },
+          suggestion: { type: 'string' },
+        },
+        required: ['severity', 'category', 'description'],
+      },
+    },
+    metrics: {
+      type: 'object',
+      properties: {
+        task_count: { type: 'number' },
+        wave_count: { type: 'number' },
+        avg_convergence_criteria: { type: 'number' },
+        dependency_depth: { type: 'number' },
+        estimated_parallelism: { type: 'number' },
+      },
+    },
+    summary: { type: 'string' },
+  },
+  required: ['verdict', 'issues', 'summary'],
+}
+
+const contextDir = args?.context_dir || ''
+const fromSource = args?.from || ''
+const phase_num = args?.phase || null
+const scope = args?.scope || ''
+const specs = args?.specs || ''
+const gaps = args?.gaps || false
+const quick = args?.quick || false
+
+// Phase 1: Parallel context exploration
+phase('Context')
+log('Gathering context from multiple sources in parallel...')
+
+const contextSources = [
+  () => agent(
+    `Load analysis context for planning.
+${contextDir ? 'Context directory: ' + contextDir + ' — read context.md and context-package.json' : ''}
+${fromSource ? 'Upstream source: ' + fromSource + ' — resolve and load context-package.json' : ''}
+${phase_num ? 'Phase: ' + phase_num + ' — read roadmap.md for phase definition' : ''}
+${gaps ? 'Gap-fix mode: load issues from .workflow/issues/issues.jsonl with analysis records' : ''}
+
+Extract:
+1. Locked/Free/Deferred decisions from context.md
+2. Requirements with acceptance criteria from context-package.json or conclusions.json
+3. Constraints from upstream analysis
+4. Dependencies identified`,
+    { label: 'ctx:analysis', phase: 'Context', schema: CONTEXT_SCHEMA }
+  ),
+  () => agent(
+    `Explore existing codebase patterns relevant to the planned work.
+${scope ? 'Scope: ' + scope : phase_num ? 'Phase ' + phase_num + ' scope from roadmap' : 'Full project'}
+${specs ? 'Specs to respect: ' + specs : 'Load via: maestro spec load --category arch'}
+
+Find:
+1. Existing patterns in the target area (how similar features are implemented)
+2. File organization conventions
+3. Test patterns used
+4. Import/export conventions
+5. Error handling patterns
+
+Report as existing_patterns[] with file references.`,
+    { label: 'ctx:patterns', phase: 'Context', schema: CONTEXT_SCHEMA, agentType: 'cli-explore-agent' }
+  ),
+]
+
+const contexts = await parallel(contextSources)
+const validContexts = contexts.filter(Boolean)
+
+const mergedDecisions = validContexts.flatMap(c => c.decisions || [])
+const mergedRequirements = validContexts.flatMap(c => c.requirements || [])
+const mergedPatterns = validContexts.flatMap(c => c.existing_patterns || [])
+const mergedConstraints = validContexts.flatMap(c => c.constraints || [])
+
+log(`Context gathered: ${mergedDecisions.length} decisions, ${mergedRequirements.length} requirements, ${mergedPatterns.length} patterns`)
+
+// Phase 2: Plan generation via workflow-planner
+phase('Plan')
+log('Generating execution plan with task decomposition...')
+
+const contextDigest = `Decisions (${mergedDecisions.length}):
+${mergedDecisions.map(d => `- [${d.status}] ${d.decision}${d.rationale ? ' — ' + d.rationale : ''}`).join('\n')}
+
+Requirements (${mergedRequirements.length}):
+${mergedRequirements.map(r => `- ${r.objective}${r.acceptance_criteria ? ' (done when: ' + r.acceptance_criteria + ')' : ''}${r.target_files ? ' [' + r.target_files.join(', ') + ']' : ''}`).join('\n')}
+
+Constraints: ${mergedConstraints.join('; ') || 'none'}
+
+Existing patterns:
+${mergedPatterns.map(p => `- ${p.pattern} @ ${p.file}`).join('\n') || 'none found'}`
+
+const plan = await agent(
+  `Create an execution plan from the following context.
+${phase_num ? 'Phase: ' + phase_num : ''}
+${scope ? 'Scope: ' + scope : ''}
+${quick ? 'MODE: QUICK — one task per feature, minimal waves, fast execution' : 'MODE: STANDARD — full decomposition with convergence criteria'}
+${gaps ? 'MODE: GAP-FIX — tasks fix identified issues, link via issue_id' : ''}
+
+Context:
+${contextDigest}
+
+Rules:
+1. Group work into FEATURE-LEVEL tasks (one feature = one task, even if 3-5 files)
+2. Assign independent tasks to same wave (parallel execution)
+3. Dependent tasks in later waves — only add depends_on when truly needed
+4. Each task needs ≥2 testable convergence criteria (grep-verifiable or command-runnable)
+5. Include focus_paths and files[] with specific paths and actions
+6. Respect all Locked decisions — they are non-negotiable
+7. Free decisions are implementer's choice — don't over-specify
+8. Task IDs: TASK-001, TASK-002, etc.
+
+${quick ? 'Quick mode: single wave unless genuine dependency. Batch unrelated small changes into one task.' : ''}`,
+  { label: 'plan:generate', phase: 'Plan', schema: PLAN_SCHEMA, agentType: 'workflow-planner' }
+)
+
+log(`Plan generated: ${plan ? plan.total_tasks : 0} tasks across ${plan ? plan.waves.length : 0} waves`)
+
+// Phase 3: Plan quality check
+phase('Check')
+log('Verifying plan quality...')
+
+const check = await agent(
+  `Verify this execution plan for quality and completeness.
+
+Plan:
+${plan ? `Summary: ${plan.summary}\nApproach: ${plan.approach}\nComplexity: ${plan.complexity}\nTasks: ${plan.total_tasks} across ${plan.waves.length} waves` : 'No plan generated'}
+
+Task details:
+${plan ? plan.waves.map(w => `Wave ${w.wave_index}: ${w.tasks.map(t => t.task_id + ': ' + t.title + ' [' + (t.convergence_criteria || []).length + ' criteria]').join(', ')}`).join('\n') : 'none'}
+
+Check:
+1. DEPENDENCY CORRECTNESS: Are depends_on relationships correct? Any missing?
+2. WAVE EFFICIENCY: Could more tasks be parallelized? Are waves minimized?
+3. CONVERGENCE QUALITY: Are criteria specific and testable (not vague)?
+4. SCOPE COMPLETENESS: Do tasks cover all requirements?
+5. FILE CONFLICTS: Do parallel tasks modify the same files?
+6. MISSING TASKS: Are there requirements without corresponding tasks?
+
+Requirements to cover:
+${mergedRequirements.map(r => r.objective).join('\n')}`,
+  { label: 'check:quality', phase: 'Check', schema: CHECK_SCHEMA, agentType: 'workflow-plan-checker' }
+)
+
+return {
+  contexts: validContexts,
+  plan: plan,
+  check: check,
+  metadata: {
+    phase: phase_num,
+    scope: scope,
+    decision_count: mergedDecisions.length,
+    requirement_count: mergedRequirements.length,
+    total_tasks: plan ? plan.total_tasks : 0,
+    wave_count: plan ? plan.waves.length : 0,
+    check_verdict: check ? check.verdict : 'unknown',
+    critical_issues: check ? check.issues.filter(i => i.severity === 'critical').length : 0,
+  },
+}