ekms 8.0.0 → 8.1.0

package/common/dialogues.js

@@ -1,13 +1,17 @@
-const { Config, knowledgeModule, where, stableId } = require('./runtime').theprogrammablemind
+const { knowledgeModule, where, stableId } = require('./runtime').theprogrammablemind
 const meta = require('./meta.js')
 const gdefaults = require('./gdefaults.js')
 const sdefaults = require('./sdefaults.js')
+const asking = require('./asking.js')
+const conjunction = require('./conjunction.js')
+const articles = require('./articles.js')
 const pos = require('./pos.js')
+const negation = require('./negation.js')
 const punctuation = require('./punctuation.js')
 const stm = require('./stm.js')
 const _ = require('lodash')
 const { API } = require('./helpers/dialogues')
-const { isMany } = require('./helpers')
+const { isMany, propertyToArray, words } = require('./helpers')
 const dialogues_tests = require('./dialogues.test.json')
 const { defaultContextCheck, indent, focus } = require('./helpers')
 const pluralize = require('pluralize')
@@ -33,29 +37,32 @@ const warningSameNotEvaluated = (log, one) => {
 }
 
 // TODO implement what / what did you say ...
-let configStruct = {
+let config = {
   name: 'dialogues',
   operators: [
+    "([makeObject] (word))",
+    "([setIdSuffix] (word))",
+    "([resetIdSuffix])",
+
     "(([queryable]) [is|] ([queryable|]))",
     "([is:queryBridge|] ([queryable]) ([queryable]))",
     // "(([queryable]) [is:isEdBridge|is,are] ([isEdAble|]))",
     "(([queryable]) [(<isEd|> ([isEdAble|]))])",
 
-    "([nevermind])",
-    { pattern: "([nevermindTestSetup] (allowed))", development: true },
+    // "([nevermind])",
+    // { pattern: "([nevermindTestSetup] (allowed))", development: true },
     "([why])",
     "([reason])",
-    "([thisitthat|])",
-    "([it])",
-    "([this])",
-    "([that])",
+    // "([thisitthat|])",
+    // "([it])",
+    // "([this])",
+    // "([that])",
 
     "(<what> ([whatAble|]))",
     "([what:optional])",
-    "(<the|> ([theAble|]))",
-    "(<a|a,an> ([theAble|]))",
+    // "(<the|> ([theAble|]))",
+    // "(<a|a,an> ([theAble|]))",
     // "([unknown])",
-    "([not] ([notAble|]))",
 
     "([be] ([briefOrWordy|]))",
 
@@ -70,7 +77,6 @@ let configStruct = {
     // joe is a person the age of joe ...
     //"arm them, what, the phasers"
     //greg is a first name
-    "(x [list|and] y)",
     "([yesno|])",
     "(([isEdee])^ <isEdAble|> ([by] ([isEder])?))",
     "([isEdee|])",
@@ -98,7 +104,31 @@ let configStruct = {
     ]
   },
   bridges: [
-    { id: "by", level: 0, bridge: "{ ...next(operator), object: after[0] }", optional: { 'isEder': "{ marker: 'unknown', implicit: true, concept: true }", }, },
+    {
+      id: 'makeObject',
+      bridge: "{ ...next(operator), object: after[0] }",
+      generatorp: async ({context, gp}) => `${context.word} ${await gp(context.object)}`,
+      semantic: ({config, context, api}) => {
+			  api.makeObject({ context: context.object, config, types: [] })
+      }
+    },
+    {
+      id: 'setIdSuffix',
+      bridge: "{ ...next(operator), suffix: after[0] }",
+      generatorp: async ({context, gp}) => `${context.word} ${await gp(context.suffix)}`,
+      semantic: ({context, api}) => {
+        api.setIdSuffix(context.suffix.text)
+      }
+    },
+    {
+      id: 'resetIdSuffix',
+      bridge: "{ ...next(operator) }",
+      semantic: ({context, api}) => {
+        api.setIdSuffix('')
+      }
+    },
+
+    { id: "by", level: 0, bridge: "{ ...next(operator), object: after[0] }", optional: { 1: "{ marker: 'unknown', implicit: true, concept: true }", }, },
 
     { id: "debug23", level: 0, bridge: "{ ...next(operator) }" },
     // { id: "what", level: 0, bridge: "{ ...next(operator), ...after[0], query: ['what'], determined: true }" },
@@ -106,37 +136,14 @@ let configStruct = {
     { id: "whatAble", level: 0, bridge: "{ ...next(operator) }" },
 
     // context.instance == variables.instance (unification)
-    {
-      id: "list", 
-      level: 0, 
-      selector: {
-          match: "same", 
-          left: [ { pattern: '($type && context.instance == variables.instance)' } ], 
-          right: [ { pattern: '($type && context.instance == variables.instance)' } ], 
-          left: [ { pattern: '($type)' } ], 
-          right: [ { pattern: '($type)' } ], 
-          passthrough: true
-      }, 
-      bridge: "{ ...next(operator), listable: true, isList: true, value: append(before, after) }"
-    },
-    {
-      id: "list", 
-      level: 1, 
-      selector: {
-          match: "same", 
-          left: [ { pattern: '($type && context.instance == variables.instance)' } ], 
-          passthrough: true
-     }, 
-      bridge: "{ ...operator, value: append(before, operator.value) }"
-    },
     {   
         where: where(),
         id: "to", 
         level: 0, 
         isA: ['preposition'],
         bridge: "{ ...next(operator), toObject: after[0] }",
-        generatorp: ({context, gp}) => {
-          return `to ${gp(context.toObject)}`
+        generatorp: async ({context, gp}) => {
+          return `to ${await gp(context.toObject)}`
         },
     },
     { id: "toAble", level: 0, bridge: "{ ...next(operator) }" },
@@ -144,15 +151,12 @@ let configStruct = {
     { id: "be", level: 0, bridge: "{ ...next(operator), type: after[0] }" },
     { id: "briefOrWordy", level: 0, bridge: "{ ...next(operator) }" },
 
-    { id: "notAble", level: 0, bridge: "{ ...next(operator) }" },
-    { id: "not", level: 0, bridge: "{ ...after, negated: true }" },
-
     { id: "yesno", level: 0, bridge: "{ ...next(operator) }" },
     { id: "canBeQuestion", level: 0, bridge: "{ ...next(operator) }" },
     { id: "canBeQuestion", level: 1, bridge: "{ ...next(operator) }" },
     // { id: "unknown", level: 0, bridge: "{ ...next(operator), unknown: true, dead: true }" },
     // { id: "unknown", level: 1, bridge: "{ ...next(operator) }" },
-    { id: "queryable", level: 0, bridge: "{ ...next(operator) }" },
+    // { id: "queryable", level: 0, bridge: "{ ...next(operator) }" },
     { id: "questionMark", level: 0, bridge: "{ ...before[0], query: [before.marker] }" },
     // { id: "isEd", level: 0, bridge: "{ ...context, query: true }" },
     // gregbug
@@ -169,7 +173,7 @@ let configStruct = {
     { id: "isEder", level: 0, bridge: "{ ...next(operator) }" },
     { id: "is", level: 0, 
             bridge: "{ ...next(operator), one: { number: operator.number, ...before[0] }, two: after[0] }", 
-            isA: ['verby'],
+            isA: ['verb'],
             queryBridge: "{ ...next(operator), one: after[0], two: after[1], query: true }" ,
     },
     { id: "is", level: 1, bridge: "{ ...next(operator) }" },
@@ -181,6 +185,7 @@ let configStruct = {
     { id: "doesAble", level: 1, bridge: "{ ...next(operator), before: before[0] }" },
     { id: "does", level: 0, bridge: "{ query: true, what: operator.marker, ...context, number: operator.number, object.number: operator.number }*" },
 
+    /*
     { 
       id: 'the', 
       level: 0, 
@@ -192,13 +197,17 @@ let configStruct = {
       // bridge: "{ ...after[0], pullFromContext: false, instance: true, concept: true, number: 'one', wantsValue: true, determiner: operator, modifiers: append(['determiner'], after[0].modifiers) }" 
       bridge: "{ ...after[0], pullFromContext: false, concept: true, number: 'one', wantsValue: true, determiner: operator, modifiers: append(['determiner'], after[0].modifiers) }" 
     },
+    */
+    /*
     { 
       id: "theAble", 
       children: ['noun'],
       bridge: "{ ...next(operator) }" 
     },
+    */
 
     // TODO make this hierarchy thing work
+    /*
     { 
       id: "thisitthat", 
       level: 0, 
@@ -206,6 +215,8 @@ let configStruct = {
       before: ['verby'],
       bridge: "{ ...next(operator) }" 
     },
+    */
+    /*
     { 
       id: "nevermind", 
       bridge: "{ ...next(operator) }",
@@ -225,6 +236,8 @@ let configStruct = {
         }
       }
     },
+    */
+    /*
     { 
       id: "nevermindTestSetup", 
       development: true,
@@ -235,7 +248,6 @@ let configStruct = {
           applyq: () => 'the test question?',
           onNevermind: ({objects, context}) => {
             objects.onNevermindWasCalled = true
-            debugger
             objects.nevermindType = nevermindType
             return nevermindType == 'accept'
           },
@@ -244,6 +256,7 @@ let configStruct = {
         })
       }
     },
+    */
     { 
       id: "why", 
       level: 0, 
@@ -255,6 +268,7 @@ let configStruct = {
       isA: ['theAble', 'queryable'], 
       bridge: "{ ...next(operator) }" 
     },
+    /*
     { 
       id: "it", 
       level: 0, 
@@ -273,11 +287,12 @@ let configStruct = {
       isA: ['thisitthat'], 
       bridge: "{ ...next(operator), unknown: true, pullFromContext: true }" 
     },
+    */
   ],
   words: {
     "literals": {
       "?": [{"id": "questionMark", "initial": "{}" }],
-      "the": [{"id": "the", "initial": "{ modifiers: [] }" }],
+      // "the": [{"id": "the", "initial": "{ modifiers: [] }" }],
       "who": [{"id": "what", "initial": "{ modifiers: [], query: true }" }],
       "yes": [{"id": "yesno", "initial": "{ value: true }" }],
       "no": [{"id": "yesno", "initial": "{ value: false }" }],
@@ -303,13 +318,13 @@ let configStruct = {
     { "context": [['isEdAble', 0], ['is', 1], ], "choose": [0] },
   ],
   hierarchy: [
+    ['doubleQuote', 'queryable'],
     ['it', 'pronoun'],
     ['this', 'pronoun'],
     ['questionMark', 'punctuation'],
     // ['questionMark', 'isEd'],
     ['a', 'articlePOS'],
     ['the', 'articlePOS'],
-    ['unknown', 'notAble'],
     ['unknown', 'theAble'],
     ['unknown', 'queryable'],
     ['it', 'queryable'],
@@ -326,10 +341,10 @@ let configStruct = {
       where: where(),
       notes: "handle making responses brief",
       match: ({context, objects}) => (context.topLevel || context.isResponse) && objects.brief && !context.briefWasRun,
-      apply: ({context, g}) => {
+      apply: async ({context, g}) => {
         const focussed = focus(context)
         context.briefWasRun = true
-        return g(focussed)
+        return await g(focussed)
       },
       priority: -2,
     },
@@ -384,66 +399,15 @@ let configStruct = {
       priority: -1,
     },
 
-    {
-      where: where(),
-      notes: 'handle lists with yes no',
-      // ({context, hierarchy}) => context.marker == 'list' && context.paraphrase && context.value,
-      // ({context, hierarchy}) => context.marker == 'list' && context.value,
-      match: ({context, hierarchy}) => context.marker == 'list' && context.paraphrase && context.value && context.value.length > 0 && context.value[0].marker == 'yesno',
-      apply: ({context, g, gs}) => {
-        return `${g(context.value[0])} ${gs(context.value.slice(1), ', ', ' and ')}`
-      }
-    },
-
-    {
-      where: where(),
-      notes: 'handle lists',
-      // ({context, hierarchy}) => context.marker == 'list' && context.paraphrase && context.value,
-      // ({context, hierarchy}) => context.marker == 'list' && context.value,
-      match: ({context, hierarchy}) => context.marker == 'list' && context.value,
-      apply: ({context, gs}) => {
-        if (context.newLinesOnly) {
-          return gs(context.value, '\n')
-        } else {
-          return gs(context.value, ', ', ' and ')
-        }
-      }
-    },
-
-    {
-      where: where(),
-      notes: 'paraphrase a negation',
-      match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'notAble') && context.negated, // && !context.isQuery && !context.paraphrase && context.value,
-      apply: ({context, g}) => {
-        context.negated = false
-        const result = g(context.value)
-        context.negated = true
-        return `not ${result}`
-      }
-    },
-
     {
       where: where(),
       notes: 'paraphrase a queryable response',
       // || context.evalue.paraphrase -> when the evalue acts as a paraphrase value
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'queryable') && !context.isQuery && context.evalue && (!context.paraphrase || context.evalue.paraphrase),
-      apply: ({context, g}) => {
-        return g(context.evalue)
-      }
-    },
-    /* dup of one above
-    {
-      where: where(),
-      notes: 'paraphrase a queryable',
-      match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'queryable') && !context.isQuery && !context.paraphrase && context.evalue,
-      apply: ({context, g}) => {
-        const oldValue = context.evalue.paraphrase
-        const result = g(context.evalue)
-        context.evalue.paraphrase = oldValue
-        return result
+      apply: async ({context, g}) => {
+        return await g(context.evalue)
       }
     },
-    */
     {
       where: where(),
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'queryable') && !context.isQuery && context.isSelf && context.subject == 'my',
@@ -452,7 +416,7 @@ let configStruct = {
     { 
       where: where(),
       match: ({context, hierarchy}) => ['it', 'what'].includes(context.marker) && context.paraphrase, 
-      apply: ({g, context}) => `${context.word}`
+      apply: ({context}) => `${context.word}`
     },
     {
       where: where(),
@@ -462,15 +426,8 @@ let configStruct = {
     { 
       where: where(),
       match: ({context, hierarchy}) => ['my', 'your'].includes(context.subject) && hierarchy.isA(context.marker, 'queryable') && context.paraphrase, 
-      apply: ({g, context}) => `${context.subject} ${context.marker}`
-    },
-    /*
-    { 
-      where: where(),
-      match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'theAble') && context.paraphrase && context.wantsValue && !context.pullFromContext, 
-      apply: ({g, context}) => `a ${context.word}`
+      apply: ({context}) => `${context.subject} ${context.marker}`
     },
-    */
     {
       where: where(),
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'queryable') && !context.isQuery && context.subject,
@@ -495,8 +452,8 @@ let configStruct = {
     { 
       where: where(),
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'canBeQuestion') && context.paraphrase && context.topLevel && context.query,
-      apply: ({context, gp}) => {
-        return `${gp({...context, topLevel: undefined})}?` 
+      apply: async ({context, gp}) => {
+        return `${await gp({...context, topLevel: undefined})}?` 
       },
       priority: -1,
     },
@@ -504,27 +461,27 @@ let configStruct = {
       where: where(),
       notes: "x is y",
       match: ({context, hierarchy}) => { return hierarchy.isA(context.marker, 'is') && context.paraphrase },
-      apply: ({context, g, gp}) => {
-        return `${g({ ...context.one, paraphrase: true })} ${context.word} ${gp(context.two)}` 
+      apply: async ({context, g, gp}) => {
+        return `${await g({ ...context.one, paraphrase: true })} ${context.word} ${await gp(context.two)}` 
       }
     },
     { 
       where: where(),
       notes: 'is with a response defined',
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'is') && context.evalue,
-      apply: ({context, g, gs}) => {
+      apply: async ({context, g, gs}) => {
         const response = context.evalue;
         const concept = response.concept;
         if (concept) {
           concept.paraphrase = true
           concept.isSelf = true
-          const instance = g(response.instance)
-          return `${g(concept)} ${context.word} ${instance}` 
+          const instance = await g(response.instance)
+          return `${await g(concept)} ${context.word} ${instance}` 
         } else {
           if (Array.isArray(response)) {
-            return `${gs(response)}` 
+            return `${await gs(response)}` 
           } else {
-            return `${g(response)}` 
+            return `${await g(response)}` 
           }
         }
       }
@@ -533,13 +490,13 @@ let configStruct = {
       where: where(),
       notes: 'x is y (not a response)',
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'is') && !context.evalue,
-      apply: ({context, g, gp, gr, callId}) => {
+      apply: async ({context, g, gp, gr, callId}) => {
         if ((context.two.evalue || {}).marker == 'answerNotKnown') {
-          return g(context.two.evalue)
+          return await g(context.two.evalue)
         }
 
         if (!context.isResponse) {
-          return `${gp(context.one)} ${isMany(context.one) || isMany(context.two) || isMany(context) ? "are" : "is"} ${g(context.two)}`
+          return `${await gp(context.one)} ${isMany(context.one) || isMany(context.two) || isMany(context) ? "are" : "is"} ${await g(context.two)}`
         }
 
         const hasFocus = (property) => {
@@ -564,17 +521,15 @@ let configStruct = {
         }
         // greg101
         if (focus == 'one') {
-          return `${g(context.two)} ${isMany(context.one) || isMany(context.two) || isMany(context) ? "are" : "is"} ${gp(context.one)}`
+          return `${await g(context.two)} ${isMany(context.one) || isMany(context.two) || isMany(context) ? "are" : "is"} ${await gp(context.one)}`
         } else {
           // TODO fix this using the assumed and that whole mess. change isResponse to useValue
           if (context.isResponse) {
-            return `${gp(context.one, { responding: true })} ${isMany(context.one) || isMany(context.two) || isMany(context) ? "are" : "is"} ${g(context.two)}`
+            return `${await gp(context.one, { responding: true })} ${isMany(context.one) || isMany(context.two) || isMany(context) ? "are" : "is"} ${await g(context.two)}`
           } else {
-            return `${gp(context.one)} ${isMany(context.one) || isMany(context.two) || isMany(context) ? "are" : "is"} ${gr(context.two)}`
+            return `${await gp(context.one)} ${isMany(context.one) || isMany(context.two) || isMany(context) ? "are" : "is"} ${await gr(context.two)}`
           }
-          // return `${gp(context.one)} ${isMany(context.one) || isMany(context.two) || isMany(context) ? "are" : "is"} ${g(context.two)}`
         }
-        // return `${g({...context.one})} ${isMany(context.one) || isMany(context.two) || isMany(context) ? "are" : "is"} ${g(context.two)}`
       },
     },
   ],
@@ -600,108 +555,62 @@ let configStruct = {
     {
       where: where(),
       match: ({context}) => context.marker === 'error',
-      apply: ({context, gp}) => {
+      apply: async ({context, gp}) => {
         context.evalue = "That is not known"
         if (context.reason) {
-          context.evalue += ` because ${gp(context.reason)}`
+          context.evalue += ` because ${await gp(context.reason)}`
         }
         context.isResponse = true
       }
     },
-    { 
-      where: where(),
-      notes: 'pull from context',
-      // match: ({context}) => context.marker == 'it' && context.pullFromContext, // && context.value,
-      match: ({context, callId}) => context.pullFromContext && !context.same, // && context.value,
-      apply: ({callId, context, s, kms, e, log, retry}) => {
-        if (true) {
-          /*
-                   {
-                      "marker": "unknown",
-                      "range": {
-                        "start": 65,
-                        "end": 73
-                      },
-                      "word": "worth",
-                      "text": "the worth",
-                      "value": "worth",
-                      "unknown": true,
-                      "types": [
-                        "unknown"
-                      ],
-                      "pullFromContext": true,
-                      "concept": true,
-                      "wantsValue": true,
-                      "determiner": "the",
-                      "modifiers": [
-                        "determiner"
-                      ],
-                      "evaluate": true
-                    }
-
-          */
-          context.value = kms.stm.api.mentions(context)
-          if (!context.value) {
-            // retry()
-            context.value = { marker: 'answerNotKnown' }
-            return
-          }
-          
-          const instance = e(context.value)
-          if (instance.evalue && !instance.edefault) {
-            context.value = instance.evalue
-          }
-          if (context.evaluate) {
-            context.evalue = context.value
-          }
-        } else {
-          /*
-                    {
-                      "marker": "unknown",
-                      "range": {
-                        "start": 24,
-                        "end": 32
-                      },
-                      "word": "price",
-                      "text": "the price",
-                      "value": "price",
-                      "unknown": true,
-                      "types": [
-                        "unknown"
-                      ],
-                      "pullFromContext": true,
-                      "concept": true,
-                      "wantsValue": true,
-                      "determiner": "the",
-                      "modifiers": [
-                        "determiner"
-                      ],
-                      "evaluate": true
-                    }
-
-          */
-          context.value = kms.stm.api.mentions(context)
-          // debugger;
-          if (!context.value) {
-            // retry()
-            context.value = { marker: 'answerNotKnown' }
-            return
-          }
-          // avoid loops
-          if (context.marker != 'unknown') {
-            if (context.value.marker != context.marker) {
-              const instance = e(context.value)
-              if (instance.evalue && !instance.edefault) {
-                context.value = instance.evalue
-              }
-            }
-          }
-          if (context.evaluate) {
-            context.evalue = context.value
-          }
-        }
-      },
-    },
+//  { 
+//    where: where(),
+//    notes: 'pull from context',
+//    // match: ({context}) => context.marker == 'it' && context.pullFromContext, // && context.value,
+//    match: ({context, callId}) => false && context.pullFromContext && !context.same, // && context.value,
+//    apply: async ({callId, context, kms, e, log, retry}) => {
+//      if (true) {
+//        /*
+//                 {
+//                    "marker": "unknown",
+//                    "range": {
+//                      "start": 65,
+//                      "end": 73
+//                    },
+//                    "word": "worth",
+//                    "text": "the worth",
+//                    "value": "worth",
+//                    "unknown": true,
+//                    "types": [
+//                      "unknown"
+//                    ],
+//                    "pullFromContext": true,
+//                    "concept": true,
+//                    "wantsValue": true,
+//                    "determiner": "the",
+//                    "modifiers": [
+//                      "determiner"
+//                    ],
+//                    "evaluate": true
+//                  }
+
+//        */
+//        context.value = kms.stm.api.mentions(context)
+//        if (!context.value) {
+//          // retry()
+//          context.value = { marker: 'answerNotKnown' }
+//          return
+//        }
+//        
+//        const instance = await e(context.value)
+//        if (instance.evalue && !instance.edefault) {
+//          context.value = instance.evalue
+//        }
+//        if (context.evaluate) {
+//          context.evalue = context.value
+//        }
+//    },
+//  },
     { 
       where: where(),
       notes: 'what x is y?',
@@ -712,7 +621,7 @@ let configStruct = {
       */
 
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'is') && context.query,
-      apply: ({context, s, log, km, objects, e}) => {
+      apply: async ({context, s, log, km, objects, e}) => {
         const one = context.one;
         const two = context.two;
         let concept, value;
@@ -726,9 +635,9 @@ let configStruct = {
         // km('dialogues').api.mentioned(concept)
         // TODO wtf is the next line?
         value = JSON.parse(JSON.stringify(value))
-        let instance = e(value)
+        let instance = await e(value)
         if (false && instance.evalue) {
-          km('stm').api.mentioned(value)
+          km('stm').api.mentioned({ context: value })
         }
         if (instance.verbatim) {
           context.evalue = { verbatim: instance.verbatim }
@@ -790,14 +699,14 @@ let configStruct = {
       where: where(),
       notes: 'x is y. handles x is a kind of y or x = y in the stm',
       match: ({context}) => context.marker == 'is' && !context.query && context.one && context.two,
-      apply: ({context, s, log, api, kms, config}) => {
+      apply: async ({context, s, log, api, kms, config}) => {
         // const oneZero = { ...context.one }
         // const twoZero = { ...context.two }
 
         const one = context.one;
         const two = context.two;
         one.same = two;
-        const onePrime = s(one)
+        const onePrime = await s(one)
         if (!onePrime.sameWasProcessed) {
           warningSameNotEvaluated(log, one)
         } else {
@@ -810,7 +719,7 @@ let configStruct = {
         let twoPrime;
         if (!onePrime.sameWasProcessed) {
           two.same = one
-          twoPrime = s(two)
+          twoPrime = await s(two)
           if (!twoPrime.sameWasProcessed) {
             warningSameNotEvaluated(log, two)
           } else {
@@ -823,26 +732,14 @@ let configStruct = {
 
         // if not isA add to stm
         if (!onePrime.sameWasProcessed && !twoPrime.sameWasProcessed) {
-					api.makeObject({ context: one, config, types: context.two.types || [] })
-					kms.stm.api.setVariable(one.value, two)
-					kms.stm.api.mentioned(one, two)
+          for (const child of propertyToArray(one)) {
+            api.makeObject({ context: child, config, types: context.two.types || [] })
+            kms.stm.api.setVariable(child.value, two)
+            kms.stm.api.mentioned({ context: child, value: two })
+          }
         }
       }
     },
-    /*
-    {
-      where: where(),
-      notes: 'x = y in the stm',
-      match: ({context}) => context.marker == 'is' && !context.query && context.one && context.two,
-      apply: ({context, s, log, api, kms, config}) => {
-        const one = context.one;
-        const two = context.two;
-        api.makeObject({ context: one, config, types: context.two.types || [] })
-        kms.stm.api.setVariable(one.value, two)
-        kms.stm.api.mentioned(one, two)
-      }
-    },
-    */
     {
       where: where(),
       notes: 'get variable from stm',
@@ -850,206 +747,60 @@ let configStruct = {
       match: ({context, kms}) => context.evaluate && kms.stm.api.getVariable(context.value) != context.value,
       // match: ({context, kms}) => context.evaluate,
       priority: -1,
-      apply: ({context, kms, e}) => {
+      apply: async ({context, kms, e}) => {
         const api = kms.stm.api
         context.value = api.getVariable(context.value)
-        /*
-        if (!context.value && context.marker !== 'unknown') {
-          context.value = api.getVariable(context.marker)
-        }
-        */
         if (context.value && context.value.marker) {
-          context.evalue = e(context.value)
+          context.evalue = await e(context.value)
         }
         context.focusableForPhrase = true
       }
     },
-/*
-    {
-      where: where(),
-      notes: 'default handle evaluate',
-      match: ({context, kms}) => context.evaluate && context.value,
-      // match: ({context, kms}) => context.evaluate,
-      // priority: -1,
-      apply: ({context, kms, e}) => {
-        if (context.value && context.value.marker) {
-          context.evalue = e(context.value)
-        }
-      }
-    },
-*/
-    /*
-    {
-      priority: 2,
-      notes: 'evaluate top level not already done',
-      match: ({context}) => false && context.topLevel && !context.evalue,
-      apply: ({context, e}) => {
-        const instance = e({ ...context, value: undefined, topLevel: undefined })
-        if (instance.evalue && !instance.edefault) {
-          context.evalue = instance
-          context.isResponse = true
-        }
-      }
-    },
-    */
   ],
 };
 
-// move ask to the KM's since verbatim is called probably in dialogues?
-const getAsk = (config) => (uuid) => {
-    // if (!uuid) {
-    //  debugger
-    //}
-    return (asks) => {
-    const ask = (ask) => {
-      let oneShot = true // default
-      if (ask.oneShot === false) {
-        oneShot = false
+const initializer = ({objects, config, isModule}) => {
+  /* TODO add this beck in. some stuff from config needs to be here
+  config.addArgs((args) => ({ 
+    e: (context) => config.api.getEvaluator(args.s, args.log, context),
+  }))
+  */
+  config.addArgs(({config, api, isA}) => ({ 
+    toScopedId: (context) => {
+      return api('dialogues').toScopedId(context)
+    },
+    addWords: (id, word, additional) => {
+      for (let props of words(word, { ...additional })) {
+        config.addWord(props.word, { id, initial: JSON.stringify(props) }) 
       }
-
-      const id_q = stableId('semantic')
-      const id_rs = []
-      let wasAsked = false
-      let wasApplied = false
-      const getWasAsked = () => {
-        return wasAsked
-      }
-      const setWasAsked = (value) => {
-        wasAsked = value
-      }
-      const getWasApplied = () => {
-        return wasApplied
-      }
-      const setWasApplied = (value) => {
-        wasApplied = value
-      }
-
-      const semanticsr = ask.semanticsr || []
-      if (semanticsr.length == 0) {
-        semanticsr.push({ match: ask.matchr, apply: ask.applyr })
-      }
-      for (const semantic of semanticsr) {
-        const id_r = stableId('semantic')
-        id_rs.push(id_r)
-        config.addSemantic({
-          uuid,
-          id: id_r,
-          tied_ids: [id_q],
-          oneShot,
-          where: semantic.where || ask.where || where(2),
-          source: 'response',
-          match: (args) => semantic.match(args),
-          apply: (args) => {
-            setWasApplied(true)
-            semantic.apply(args)
-          },
-        })
-      }
-
-      config.addSemantic({
-        uuid,
-        oneShot,
-        id: id_q,
-        tied_ids: id_rs,
-        where: ask.where,
-        isQuestion: true,  // do one question at a time
-        getWasAsked,
-        getWasApplied,
-        onNevermind: ask.onNevermind,
-        source: 'question',
-        match: ({ context }) => context.marker == 'controlEnd' || context.marker == 'controlBetween',
-        apply: (args) => {
-          let matchq = ask.matchq
-          let applyq = ask.applyq
-          if (!matchq) {
-            let wasAsked = false
-            matchq = () => !wasAsked,
-            applyq = (args) => {
-              wasAsked = true
-              return ask.applyq(args)
-            }
-          }
-          if (matchq(args)) {
-            setWasAsked(true)
-            setWasApplied(false)
-            // args.context.motivationKeep = true
-            args.verbatim(applyq(args))
-            /*
-              args.context.verbatim = applyq(args)
-              args.context.isResponse = true;
-              delete args.context.controlRemove;
-              */
-            args.context.controlKeepMotivation = true
-          }
-          args.context.cascade = true
-        }
-      })
-    }
-    if (!Array.isArray(asks)) {
-      asks = [asks]
-    }
-
-    [...asks].reverse().forEach( (a) => ask(a) )
+    },
+    values: propertyToArray,
+  }))
+  objects.mentioned = []
+  objects.variables = {
+  }
+  if (isModule) {
+  } else {
+    config.addWord("canbedoquestion", { id: "canBeDoQuestion", "initial": "{}" })
+    config.addWord("doesable", { id: "doesAble", "initial": "{}" })
   }
-}
-
-
-const createConfig = () => {
-  const config = new Config(configStruct, module)
-  config.stop_auto_rebuild()
-  config.api = api
-  config.add(gdefaults(), sdefaults(), pos(), stm(), meta(), punctuation())
-  config.initializer( ({objects, config, isModule}) => {
-    /* TODO add this beck in. some stuff from config needs to be here
-    config.addArgs((args) => ({ 
-      e: (context) => config.api.getEvaluator(args.s, args.log, context),
-    }))
-    */
-    config.addArgs(({config, isA}) => ({ 
-      isAListable: (context, type) => {
-        if (context.marker == 'list' || context.listable) {
-          return context.value.every( (element) => isA(element.marker, type) )
-        } else {
-          return isA(context.marker, type)
-        } 
-      },
-      toContext: (v) => {
-        if (Array.isArray(v)) {
-          return { marker: 'list', level: 1, value: v }
-        }
-        if (v.marker == 'list') {
-          return v
-        }
-        return v
-      },
-      getUUIDScoped: (uuid) => { return {
-          ask: getAsk(config)(uuid),
-        } 
-      },
-    }))
-    objects.mentioned = []
-    objects.variables = {
-    }
-    if (isModule) {
-    } else {
-      config.addWord("canbedoquestion", { id: "canBeDoQuestion", "initial": "{}" })
-      config.addWord("doesable", { id: "doesAble", "initial": "{}" })
-    }
-  })
-  config.restart_auto_rebuild()
-  return config
 }
 
 knowledgeModule( { 
+  config,
+  includes: [articles, gdefaults, sdefaults, conjunction, asking, pos, negation, stm, meta, punctuation],
+  initializer,
+  api: () => new API(),
+
   module,
   description: 'framework for dialogues',
-  createConfig, newWay: true,
+  newWay: true,
   test: {
     name: './dialogues.test.json',
     contents: dialogues_tests,
     checks: {
-            objects: ['onNevermindWasCalled', 'nevermindType'],
-            context: defaultContextCheck,
+            objects: ['idSuffix'],
+            context: defaultContextCheck(),
           },
 
   },