tpmkms_4wp 8.0.0-beta.7 → 8.0.0-beta.71

package/common/dialogues.js

@@ -1,8 +1,10 @@
-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 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')
@@ -33,7 +35,7 @@ const warningSameNotEvaluated = (log, one) => {
 }
 
 // TODO implement what / what did you say ...
-let configStruct = {
+let config = {
   name: 'dialogues',
   operators: [
     "([makeObject] (word))",
@@ -49,17 +51,16 @@ let configStruct = {
     { 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|]))",
 
@@ -105,7 +106,7 @@ let configStruct = {
     {
       id: 'makeObject',
       bridge: "{ ...next(operator), object: after[0] }",
-      generatorp: ({context, gp}) => `${context.word} ${gp(context.object)}`,
+      generatorp: async ({context, gp}) => `${context.word} ${await gp(context.object)}`,
       semantic: ({config, context, api}) => {
 			  api.makeObject({ context: context.object, config, types: [] })
       }
@@ -113,7 +114,7 @@ let configStruct = {
     {
       id: 'setIdSuffix',
       bridge: "{ ...next(operator), suffix: after[0] }",
-      generatorp: ({context, gp}) => `${context.word} ${gp(context.suffix)}`,
+      generatorp: async ({context, gp}) => `${context.word} ${await gp(context.suffix)}`,
       semantic: ({context, api}) => {
         api.setIdSuffix(context.suffix.text)
       }
@@ -141,8 +142,8 @@ let configStruct = {
           match: "same", 
           left: [ { pattern: '($type && context.instance == variables.instance)' } ], 
           right: [ { pattern: '($type && context.instance == variables.instance)' } ], 
-          left: [ { pattern: '($type)' } ], 
-          right: [ { pattern: '($type)' } ], 
+          // left: [ { pattern: '($type)' } ], 
+          // right: [ { pattern: '($type)' } ], 
           passthrough: true
       }, 
       bridge: "{ ...next(operator), listable: true, isList: true, value: append(before, after) }"
@@ -163,8 +164,8 @@ let configStruct = {
         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) }" },
@@ -172,15 +173,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
@@ -197,7 +195,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) }" },
@@ -209,6 +207,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, 
@@ -220,13 +219,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, 
@@ -234,6 +237,7 @@ let configStruct = {
       before: ['verby'],
       bridge: "{ ...next(operator) }" 
     },
+    */
     { 
       id: "nevermind", 
       bridge: "{ ...next(operator) }",
@@ -282,6 +286,7 @@ let configStruct = {
       isA: ['theAble', 'queryable'], 
       bridge: "{ ...next(operator) }" 
     },
+    /*
     { 
       id: "it", 
       level: 0, 
@@ -300,11 +305,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 }" }],
@@ -337,7 +343,6 @@ let configStruct = {
     // ['questionMark', 'isEd'],
     ['a', 'articlePOS'],
     ['the', 'articlePOS'],
-    ['unknown', 'notAble'],
     ['unknown', 'theAble'],
     ['unknown', 'queryable'],
     ['it', 'queryable'],
@@ -354,10 +359,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,
     },
@@ -418,8 +423,8 @@ let configStruct = {
       // ({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 ')}`
+      apply: async ({context, g, gs}) => {
+        return `${await g(context.value[0])} ${await gs(context.value.slice(1), ', ', ' and ')}`
       }
     },
 
@@ -429,49 +434,24 @@ let configStruct = {
       // ({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}) => {
+      apply: async ({context, gs}) => {
         if (context.newLinesOnly) {
-          return gs(context.value, '\n')
+          return await gs(context.value, '\n')
         } else {
-          return gs(context.value, ', ', ' and ')
+          return await 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',
@@ -480,7 +460,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(),
@@ -490,15 +470,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}`
+      apply: ({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}`
-    },
-    */
     {
       where: where(),
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'queryable') && !context.isQuery && context.subject,
@@ -523,8 +496,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,
     },
@@ -532,27 +505,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)}` 
           }
         }
       }
@@ -561,13 +534,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) => {
@@ -592,17 +565,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)}`
       },
     },
   ],
@@ -628,107 +599,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)
-          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?',
@@ -739,7 +665,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;
@@ -753,9 +679,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 }
@@ -817,14 +743,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 {
@@ -837,7 +763,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 {
@@ -852,24 +778,10 @@ let configStruct = {
         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)
+					kms.stm.api.mentioned({ context: one, 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',
@@ -877,48 +789,15 @@ 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
-        }
-      }
-    },
-    */
   ],
 };
 
@@ -963,9 +842,9 @@ const getAsk = (config) => (uuid) => {
           where: semantic.where || ask.where || where(2),
           source: 'response',
           match: (args) => semantic.match(args),
-          apply: (args) => {
+          apply: async (args) => {
             setWasApplied(true)
-            semantic.apply(args)
+            await semantic.apply(args)
           },
         })
       }
@@ -982,7 +861,7 @@ const getAsk = (config) => (uuid) => {
         onNevermind: ask.onNevermind,
         source: 'question',
         match: ({ context }) => context.marker == 'controlEnd' || context.marker == 'controlBetween',
-        apply: (args) => {
+        apply: async (args) => {
           let matchq = ask.matchq
           let applyq = ask.applyq
           if (!matchq) {
@@ -993,11 +872,11 @@ const getAsk = (config) => (uuid) => {
               return ask.applyq(args)
             }
           }
-          if (matchq(args)) {
+          if (await matchq(args)) {
             setWasAsked(true)
             setWasApplied(false)
             // args.context.motivationKeep = true
-            args.verbatim(applyq(args))
+            args.verbatim(await applyq(args))
             /*
               args.context.verbatim = applyq(args)
               args.context.isResponse = true;
@@ -1018,59 +897,56 @@ const getAsk = (config) => (uuid) => {
 }
 
 
-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, api, 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
-        }
+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}) => ({ 
+    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
-      },
-      getUUIDScoped: (uuid) => { return {
-          ask: getAsk(config)(uuid),
-        } 
-      },
-      toScopedId: (context) => {
-        return api('dialogues').toScopedId(context)
-      },
-    }))
-    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
+      }
+      return v
+    },
+    getUUIDScoped: (uuid) => { return {
+        ask: getAsk(config)(uuid),
+      } 
+    },
+    toScopedId: (context) => {
+      return api('dialogues').toScopedId(context)
+    },
+  }))
+  objects.mentioned = []
+  objects.variables = {
+  }
+  if (isModule) {
+  } else {
+    config.addWord("canbedoquestion", { id: "canBeDoQuestion", "initial": "{}" })
+    config.addWord("doesable", { id: "doesAble", "initial": "{}" })
+  }
 }
 
 knowledgeModule( { 
+  config,
+  includes: [articles, gdefaults, sdefaults, 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,