diff --git a/source/components/CDD.js b/source/components/CDD.js
index c1a00afd1..252303ba5 100644
--- a/source/components/CDD.js
+++ b/source/components/CDD.js
@@ -12,7 +12,7 @@ import Aide from './Aide'
 let situationSelector = formValueSelector('conversation')
 
 @reduxForm(
-	{form: 'conversation'}
+	{form: 'conversation', destroyOnUnmount: false}
 )
 @connect(state => ({
 	situation: variableName => situationSelector(state, variableName),
diff --git a/source/components/Results.js b/source/components/Results.js
index abe0c45de..41830d078 100644
--- a/source/components/Results.js
+++ b/source/components/Results.js
@@ -5,23 +5,26 @@ import {Link} from 'react-router'
 export default class Results extends Component {
 	render() {
 		let {analysedSituation} = this.props
+			// missingVariables = collectMissingVariables(analysedSituation, 'groupByResult')
 		return (
 			<section id="results">
 				<h2>Vos obligations</h2>
+				{console.log('analysedSituation', analysedSituation)}
 				<ul>
 					{analysedSituation.map(
-						({name, type, derived: {missingVariables, computedValue}}) =>
+						({name, type, 'non applicable si': {nodeValue: nonApplicable}, formule: {nodeValue: computedValue}}) =>
 						do {
 							let
-								unsatisfied = missingVariables && missingVariables.length,
-								irrelevant = !unsatisfied && computedValue == null;
+								unsatisfied = nonApplicable == null || computedValue == null,
+								irrelevant = nonApplicable === true;
+
 							<li key={name} className={classNames({unsatisfied, number: !unsatisfied && !irrelevant})}>
 								<h3>{type} {name}</h3>
 								<p>
-								{unsatisfied ?
-									'En attente de vos réponses...'
-									: irrelevant ?
-										"Vous n'êtes pas concernés"
+								{irrelevant ?
+									"Vous n'êtes pas concernés"
+									: unsatisfied ?
+										'En attente de vos réponses...'
 										:computedValue + '€'
 								}
 								</p>
diff --git a/source/components/Rule.js b/source/components/Rule.js
index fbe68861a..7a92422a9 100644
--- a/source/components/Rule.js
+++ b/source/components/Rule.js
@@ -5,27 +5,23 @@ import './Rule.css'
 import JSONTree from 'react-json-tree'
 import R from 'ramda'
 import PageTypeIcon from './PageTypeIcon'
+import {connect} from 'react-redux'
+import {formValueSelector} from 'redux-form'
 
+
+
+@connect(state => ({
+	situationGate: name => formValueSelector('conversation')(state, name)
+}))
 export default class Rule extends Component {
 	render() {
 		let {
-			name
-		} = this.props.params,
+			params: {name},
+			situationGate
+		} = this.props,
 			rule = analyseSituation(
-				v => R.path(v.split('.'))(
-					{
-						"Salariat ":{
-							" CDD ":{
-									" événements":"_",
-									" motif":"saisonnier",
-									" engagement employeur complément formation":"non",
-									" durée contrat":"2"
-								},
-							" contrat aidé":"non",
-							" salaire de base": 1481
-						}
-					})
-			)[0]
+				situationGate
+			).find(R.propEq('name', name))
 
 		return (
 			<div id="rule">
diff --git a/source/engine/rules.js b/source/engine/rules.js
index d48660e06..0a9db25af 100644
--- a/source/engine/rules.js
+++ b/source/engine/rules.js
@@ -5,6 +5,7 @@ import R from 'ramda'
 import possibleVariableTypes from './possibleVariableTypes.yaml'
 import marked from 'marked'
 
+
 let customMarked = new marked.Renderer()
 customMarked.link = ( href, title, text ) =>
 	`<a target="_blank" href="${ href }" title="${ title }">${ text }</a>`
@@ -85,3 +86,42 @@ export let findGroup = R.pipe(
 	// 	)
 	// )
 )
+
+/*********************************
+Autres */
+
+let collectNodeMissingVariables = target => (root, source=root, results=[]) => {
+	if (
+    source.nodeValue != null  ||
+    source.shortCircuit && source.shortCircuit(root)
+  ) return
+
+	if (source[target]) {
+		results.push(source[target])
+	}
+
+	for (var prop in source) {
+		if (R.is(Object)(source[prop]))
+			collectNodeMissingVariables(target)(root, source[prop], results)
+	}
+
+
+	return results
+}
+
+
+export let collectMissingVariables = (groupMethod='groupByMissingVariable', analysedSituation) =>
+	R.pipe(
+		R.chain( v =>
+			R.pipe(
+				collectNodeMissingVariables('missingVariables'),
+				R.flatten,
+				R.map(mv => [v.name, mv])
+			)(v)
+		),
+		//groupBy missing variable but remove mv from value, it's now in the key
+		R.groupBy(groupMethod == 'groupByMissingVariable' ? R.last : R.head),
+		R.map(R.map(groupMethod == 'groupByMissingVariable' ? R.head : R.last))
+		// below is a hand implementation of above... function composition can be nice sometimes :')
+		// R.reduce( (memo, [mv, dependencyOf]) => ({...memo, [mv]: [...(memo[mv] || []), dependencyOf] }), {})
+	)(analysedSituation)
diff --git a/source/engine/traverse.js b/source/engine/traverse.js
index 18447733c..456bde7ac 100644
--- a/source/engine/traverse.js
+++ b/source/engine/traverse.js
@@ -13,9 +13,9 @@ let selectedRules = rules.filter(rule =>
 			)
 		)
 
-let knownVariable = (situation, variableName) => R.or(
-	situation(variableName),
-	situation(parentName(variableName)) // pour 'usage', 'motif' ( le parent de 'usage') = 'usage'
+let knownVariable = (situationGate, variableName) => R.or(
+	situationGate(variableName),
+	situationGate(parentName(variableName)) // pour 'usage', 'motif' ( le parent de 'usage') = 'usage'
 ) != null
 
 let transformPercentage = s =>
@@ -54,10 +54,10 @@ par exemple ainsi : https://github.com/Engelberg/instaparse#transforming-the-tre
 
 let treat = (situationGate, rule) => rawNode => {
 
-
 	if (R.is(String)(rawNode)) {// it's an expression
 		let [variableName, evaluation] = recognizeExpression(rule, rawNode),
-			value = knownVariable(situationGate, variableName) ?
+			known = knownVariable(situationGate, variableName),
+			value = known ?
 				evaluation(situationGate)
 			: null
 
@@ -66,7 +66,8 @@ let treat = (situationGate, rule) => rawNode => {
 			nodeValue: value, // null, true or false
 			category: 'expression',
 			type: 'boolean',
-			explanation: null
+			explanation: null,
+			missingVariables: known ? [] : [variableName]
 		}
 	}
 
@@ -140,7 +141,8 @@ let treat = (situationGate, rule) => rawNode => {
 					// name: 'base', déduit de la propriété de l'objet
 					nodeValue: baseValue,
 					explanation: null,
-					variableName: baseVariableName
+					variableName: baseVariableName,
+					missingVariables: baseValue == null ? [baseVariableName] : []
 				},
 				rate: {
 					type: 'numeric',
@@ -189,7 +191,8 @@ let treatRuleRoot = (situationGate, rule) => R.evolve({ // -> Voilà les attribu
 			name: 'formule',
 			type: 'numeric',
 			nodeValue: child.nodeValue,
-			explanation: child
+			explanation: child,
+			shortCircuit: R.pathEq(['non applicable si', 'nodeValue'], true)
 		}
 	}
 	,
diff --git a/source/reducers.js b/source/reducers.js
index e63edb83c..ddd637626 100644
--- a/source/reducers.js
+++ b/source/reducers.js
@@ -12,7 +12,7 @@ import RhetoricalQuestion from './components/conversation/RhetoricalQuestion'
 import { STEP_ACTION, UNSUBMIT_ALL, START_CONVERSATION, EXPLAIN_VARIABLE} from './actions'
 import R from 'ramda'
 
-import {findGroup, findRuleByDottedName, dottedName, parentName} from './engine/rules'
+import {findGroup, findRuleByDottedName, dottedName, parentName, collectMissingVariables} from './engine/rules'
 import {constructStepMeta} from './engine/conversation'
 
 import computeThemeColours from './components/themeColours'
@@ -62,39 +62,33 @@ export default reduceReducers(
 	// cross-cutting concerns because here `state` is the whole state tree
 	(state, action) => {
 		if (action.type == STEP_ACTION || action.type == START_CONVERSATION) {
-			let {newState, name} = action
-			// une étape vient d'être validée : on va changer son état
-			let newSteps = R.pipe(
-				R.map(step => step.name == name ? {...step, state: newState} : step),
-				R.reject(R.whereEq({theEnd: true}))
-			)(state.steps)
 
+			// pour débugguer :
 			window.situationGate = situationGate(state)
 
 			// on calcule la prochaine étape, à ajouter sur la pile
 			let
+				// une liste des objectifs de la simulation (des 'rules' aussi nommées 'variables')
 				analysedSituation = analyseSituation(
 					situationGate(state)
 				),
 
-				y = console.log('analysedSituation', analysedSituation),
+				// y = console.log('analysedSituation', JSON.stringify(analysedSituation)),
+
+				// on collecte les variables manquantes : celles qui sont nécessaires pour
+				// remplir les objectifs de la simulation (calculer des cotisations) mais qui n'ont pas
+				// encore été renseignées
+				missingVariables = collectMissingVariables('groupByMissingVariable', analysedSituation),
 
-				missingVariables = R.pipe(
-					R.map( ({name, derived: {missingVariables}}) =>
-						(missingVariables || []).map(mv => [mv, name])
-					),
-					R.unnest,
-					//groupBy but remove mv from value, it's now in the key
-					R.reduce( (memo, [mv, dependencyOf]) => ({...memo, [mv]: [...(memo[mv] || []), dependencyOf] }), {})
-				)(analysedSituation),
 				missingVariablesList = R.keys(missingVariables),
 
+				ya = console.log('missingVariablesList', missingVariables),
 				groups = R.groupBy(
 					parentName
 				)(missingVariablesList),
 
 				// on va maintenant construire la liste des composants React correspondant aux questions pour obtenir les variables manquantes
-				yyoo = R.pipe(
+				steps = R.pipe(
 					R.mapObjIndexed((variables, group) =>
 						R.pipe(
 							findGroup,
@@ -140,16 +134,8 @@ export default reduceReducers(
 					R.unnest
 				)(groups)
 
-			// la question doit pouvoir stocker tout ça dans la situation (redux-form) correctement
+			return {...state, steps, analysedSituation}
 
-
-			return {...state, steps: yyoo, analysedSituation}
-
-
-
-
-			// return {...state, steps: [...newSteps, stepData], analysedSituation}
-			// ... do stuff
 		} else {
 			return state
 		}