ekms 9.8.0-beta.2 → 9.8.0-beta.4

package/common/properties.instance.json

@@ -829,7 +829,7 @@
         },
         {
           "match": "({context}) => context.isEd",
-          "apply": "async ({context, g}) => {\n        const chosen = chooseNumber(context[context.afterTag], 'is', 'are')\n        if (context[context.beforeTag].evalue && context[context.beforeTag].evalue.marker == 'answerNotKnown') {\n          return await g(context[context.beforeTag])\n        }\n        return `${await g(context[context.afterTag])} ${chosen} ${context.word} by ${await g(context[context.beforeTag])}`\n      }"
+          "apply": "async ({context, g}) => {\n        const chosen = chooseNumber(context[context.afterTag], 'is', 'are')\n        if (context[context.beforeTag].evalue && context[context.beforeTag].evalue.marker === 'undefined') {\n          return await g(context[context.beforeTag])\n        }\n        return `${await g(context[context.afterTag])} ${chosen} ${context.word} by ${await g(context[context.beforeTag])}`\n      }"
         },
         {
           "match": "({context}) => context.paraphrase && context.constrained",
@@ -880,25 +880,25 @@
           "apply": "async ({context, g, gs}) => {\n               const base = { ...context }\n               base.object = undefined;\n               if (context.object.marker == 'objectPrefix') {\n                 return `${await g(context.object)} ${await g(base)}`\n               } else {\n                 if (context.objects) {\n                   const gObjects = []\n                   for (const object of context.objects) {\n                     gObjects.push(await g({...object, paraphrase: true}))\n                   }\n                   return await gs(gObjects, ' of ')\n                 } else {\n                   // TODO make paraphrase be a default when paraphrasing?\n                   return `${await g(base)} of ${await g({...context.object, paraphrase: true})}`\n                 }\n               }\n             }"
         },
         {
-          "match": "({context, hierarchy}) => hierarchy.isA(context.marker, 'property') && context.object && !context.possession && !context.evaluate && !context.object.marker == 'objectPrefix'",
+          "match": "({context, hierarchy}) => hierarchy.isA(context.marker, 'property') && context.object && !context.possession && context.paraphrase && !context.object.marker == 'objectPrefix'",
           "apply": "async ({context, g}) => {\n        const property = Object.assign({}, context, { object: undefined })\n        return `${await g(property)} of ${await g({ ...context.object, paraphrase: true })}`\n      }"
         },
         {
           "match": "({context}) => !context.modifiers && (context.object || context.objects) && !context.interpolate",
-          "apply": "async ({context, g, gs}) => {\n        if (context.evalue) {\n          return await g(context.evalue)\n        } else if (context.objects) {\n          const objects = [ ...context.objects ]\n          objects.reverse()\n          let phrase = ''\n          let separator = ''\n          for (let i = 0; i < objects.length-1; ++i) {\n            phrase = phrase + separator + await g({...objects[i], paraphrase: context.paraphrase, possessive: true})\n            separator = ' '\n          }\n          phrase = phrase + separator + await g({...objects[objects.length-1], paraphrase: context.paraphrase})\n          return phrase\n        } else {\n          const base = { ...context }\n          base.object = undefined; // TODO make paraphrase be a default when paraphrasing?\n          if (context.object.marker == 'objectPrefix') {\n            return `${await g(context.object)} ${await g(base)}`\n          } else {\n            return `${await g({...context.object, paraphrase: context.paraphrase})}'s ${await g(base)}`\n          }\n        }  \n      }"
+          "apply": "async ({context, g, gs}) => {\n        if (context.evalue && !context.paraphrase) {\n          return await g(context.evalue)\n        } else if (context.objects) {\n          const objects = [ ...context.objects ]\n          objects.reverse()\n          let phrase = ''\n          let separator = ''\n          for (let i = 0; i < objects.length-1; ++i) {\n            phrase = phrase + separator + await g({...objects[i], paraphrase: context.paraphrase, possessive: true})\n            separator = ' '\n          }\n          phrase = phrase + separator + await g({...objects[objects.length-1], paraphrase: context.paraphrase})\n          return phrase\n        } else {\n          const base = { ...context }\n          base.object = undefined; // TODO make paraphrase be a default when paraphrasing?\n          if (context.object.marker == 'objectPrefix') {\n            return `${await g(context.object)} ${await g(base)}`\n          } else {\n            return `${await g({...context.object, paraphrase: context.paraphrase})}'s ${await g(base)}`\n          }\n        }  \n      }"
         }
       ],
       "semantics": [
         {
-          "match": "({context, isA}) => \n        context.evaluate && \n        context.marker == 'unify' && \n        context.terms?.some((term) => {\n          return term.objects && isA(term.objects[0], 'property') && term.query\n        })",
+          "match": "({context, isA}) => \n        context.marker == 'unify' && \n        context.terms?.some((term) => {\n          return term.objects && isA(term.objects[0], 'property') && term.query\n        })",
           "apply": "async (args) => {\n        const {context, km, callId, api, resolveEvaluate} = args\n        let value, property, object\n        if (context.terms[0].query) {\n          property = context.terms[0].objects[0]\n          object = context.terms[0].objects[1]\n          value = context.terms[1]\n        } else {\n          property = context.terms[1].objects[0]\n          object = context.terms[1].objects[1]\n          value = context.terms[0]\n        }\n        const pattern = {\n          marker: 'propertyRelation',\n          object,\n          property,\n          value,\n        }\n        const relations = await api.relation_unify(pattern, ['object', 'property', 'value'])\n        resolveEvaluate(context, relations)\n      }"
         },
         {
           "match": "({context}) => context.relationBacked && context.query",
-          "apply": "({context, km, callId}) => {\n        const api = km('properties').api\n        context.evalue = {\n          marker: 'list',\n          listable: true,\n          // value: unflatten(api.relation_get(context, before.concat(after).map( (arg) => arg.tag ) ))\n          value: unflatten(api.relation_get(context, context.relationArgs.map( (arg) => arg.tag ) ))\n        }\n        context.evalue.isResponse = true\n        context.isResponse = true\n        if (context.evalue.value.length == 0) {\n          context.evalue.marker = 'answerNotKnown';\n          context.evalue.listable = true\n          context.evalue.value = [];\n        } else {\n          // context.evalue.truthValue = true\n        }\n      }"
+          "apply": "({context, km, callId}) => {\n        const api = km('properties').api\n        context.evalue = {\n          marker: 'list',\n          listable: true,\n          // value: unflatten(api.relation_get(context, before.concat(after).map( (arg) => arg.tag ) ))\n          value: unflatten(api.relation_get(context, context.relationArgs.map( (arg) => arg.tag ) ))\n        }\n        context.evalue.isResponse = true\n        context.isResponse = true\n        if (context.evalue.value.length == 0) {\n          context.evalue.marker = 'undefined';\n          context.evalue.listable = true\n          context.evalue.value = [];\n        } else {\n          // context.evalue.truthValue = true\n        }\n      }"
         },
         {
-          "match": "({context}) => context.relationBacked && !context.toVoice && !context.evaluate",
+          "match": "({context}) => context.relationBacked && !context.toVoice && context.isVerb",
           "apply": "({context, km, hierarchy, config, stack}) => {\n        const api = km('properties').api\n        // add types for arguments\n        for (const argument of context.focusable || []) {\n          const value = api.toValue(context[argument])\n          if (value) {\n            const minimas = hierarchy.minima(context[argument].types)\n            for (const type of minimas) {\n              if (config.exists(value)) {\n                config.addHierarchy(value, type);\n              }\n            }\n          }\n        }\n        api.relation_add(context)\n      }"
         },
         {
@@ -910,12 +910,12 @@
           "apply": "({context, km, stack}) => {\n          const propertiesAPI = km('properties').api\n          context.ordering = context.orderingArgs.name\n          const fcontexts = flattens(['list'], [context])\n          for (const fcontext of fcontexts) {\n            fcontext.paraphrase = true\n            fcontext[context.orderingArgs.object].paraphrase = true\n            fcontext[context.orderingArgs.category].paraphrase = true\n          }\n          propertiesAPI.relation_add(fcontexts)\n        }"
         },
         {
-          "match": "({context, isA}) => context.evaluate && context.constraints",
-          "apply": "async ({km, context, e, log, isA}) => {\n        const constraint = context.constraints[0];\n        const value = constraint.constraint;\n        let property = constraint.property;\n        const properties = constraint.properties;\n        for (const p of properties) {\n          if (value[p].concept) {\n            property = p\n            // constraint.property = p; // set what is used\n            constraint.property = {...constraint.property, ...p}; // set what is used\n\n          }\n        }\n        // value.marker = 'owns'\n        // value.greg = true\n        // value.ownee.query = true\n        value.query = true\n        value.greg99 = 23\n        const instance = await e(value)\n        if (instance.verbatim) {\n          context.evalue = { verbatim: instance.verbatim }\n          return\n        }\n        if (instance.evalue.marker == 'answerNotKnown') {\n          context.evalue = instance.evalue\n          return\n        }\n        const selected = instance.evalue.value.map( (r) => r[property] )\n        context.constraints = undefined;\n        context.evalue = { marker: 'list', listable: true, value: selected }\n      }"
+          "match": "({context, isA}) => context.constraints",
+          "apply": "async ({km, context, e, log, isA}) => {\n        const constraint = context.constraints[0];\n        const value = constraint.constraint;\n        let property = constraint.property;\n        const properties = constraint.properties;\n        for (const p of properties) {\n          if (value[p].concept) {\n            property = p\n            // constraint.property = p; // set what is used\n            constraint.property = {...constraint.property, ...p}; // set what is used\n\n          }\n        }\n        // value.marker = 'owns'\n        // value.greg = true\n        // value.ownee.query = true\n        value.query = true\n        value.greg99 = 23\n        const instance = await e(value)\n        if (instance.verbatim) {\n          context.evalue = { verbatim: instance.verbatim }\n          return\n        }\n        if (instance.evalue.marker === 'undefined') {\n          context.evalue = instance.evalue\n          return\n        }\n        const selected = instance.evalue.value.map( (r) => r[property] )\n        context.constraints = undefined;\n        context.evalue = { marker: 'list', listable: true, value: selected }\n      }"
         },
         {
           "match": "({context}) => context.marker == 'is' && (context.one.how || context.two.how)",
-          "apply": "async ({ resolveResponse, g, context, toArray, toList, fragments, kms, e, toEValue }) => {\n        const propertyMarkerContext = context.one\n        let object = context.two\n        if (context.two.how) {\n          propertyMakerContext = context.two\n          object = context.one\n        }\n        const pmcs = toArray(propertyMarkerContext)\n        const properties = []\n        for (const pmc of pmcs) {\n          const property = pmc.markedProperty\n          properties.push({ marker: property, value: property, word: property })\n        }\n        const propertyOfObject = await fragments(\"the property of object\", { property: toList(properties, true), object })\n        const value = toEValue(await e(propertyOfObject))\n        value.focusableForPhrase = true\n        propertyOfObject.focusableForPhrase = false\n        const response = await fragments(\"the property is value\", { property: propertyOfObject, value })\n        response.isResponse = true\n        resolveResponse(context, response) \n      }"
+          "apply": "async ({ resolveEvaluate, g, context, toArray, toList, fragments, kms, e, toEValue }) => {\n        const propertyMarkerContext = context.one\n        let object = context.two\n        if (context.two.how) {\n          propertyMakerContext = context.two\n          object = context.one\n        }\n        const pmcs = toArray(propertyMarkerContext)\n        const properties = []\n        for (const pmc of pmcs) {\n          const property = pmc.markedProperty\n          properties.push({ marker: property, value: property, word: property })\n        }\n        const propertyOfObject = await fragments(\"the property of object\", { property: toList(properties, true), object })\n        const value = toEValue(await e(propertyOfObject))\n        value.focusableForPhrase = true\n        propertyOfObject.focusableForPhrase = false\n        const response = await fragments(\"the property is value\", { property: propertyOfObject, value })\n        response.isResponse = true\n        resolveEvaluate(context, response) \n      }"
         },
         {
           "match": "({context}) => context.marker == 'same' && context.one.marker == 'concept'",
@@ -930,8 +930,8 @@
           "apply": "({context, km, objects}) => {\n        km('properties').api.setReadOnly([context.one.value]) \n        context.sameWasProcessed = true\n      }"
         },
         {
-          "match": "({context, hierarchy, api, isA}) => \n                          hierarchy.isA(context.marker, 'concept') && ((!context.propertyOf && !context.isProperty) || isA(context.objects[context.objects.length-1], 'dimension')) &&\n                          (!context.pullFromContext || context.number == 'many') &&\n                          context.evaluate &&\n                          !(context.types || []).includes('property') &&\n                          // !context.value &&  // greghere\n                          !context.ordinal &&\n                          (!context.objects || context.objects.length !== 2 || !context.objects[1].isInstance) &&\n                          (api.objects && api.objects.children && api.objects.children[context.marker]) &&\n                          !context.evaluate.toConcept",
-          "apply": "({context, hierarchy, objects, api, km}) => {\n        const values = api.objects.children[context.marker]\n        const phrases = values.map( (value) => km('concept').api.getWordForValue(value) )\n        // context.focusableForPhrase = true\n        context.hierarchy = true\n        context.evalue = { \n          marker: 'list', \n          listable: true,\n          // value: api.objects.children[context.marker]\n          value: phrases,\n        }\n      }"
+          "match": "({context, hierarchy, api, isA}) => \n                          hierarchy.isA(context.marker, 'concept') && ((!context.propertyOf && !context.isProperty) || isA(context.objects[context.objects.length-1], 'dimension')) &&\n                          (!context.pullFromContext || context.number == 'many') &&\n                          (context.pullFromContext || isA(context, 'type') || context.metaDefinition) &&\n                          !(context.types || []).includes('property') &&\n                          // !context.value &&  // greghere\n                          !context.ordinal &&\n                          (!context.objects || context.objects.length !== 2 || !context.objects[1].isInstance) &&\n                          (api.objects && api.objects.children && api.objects.children[context.marker])",
+          "apply": "({context, stack, isA, contextHierarchy, hierarchy, objects, api, km}) => {\n        const values = api.objects.children[context.marker]\n        const phrases = values.map( (value) => km('concept').api.getWordForValue(value) )\n        // context.focusableForPhrase = true\n        context.hierarchy = true\n        context.evalue = { \n          marker: 'list', \n          listable: true,\n          // value: api.objects.children[context.marker]\n          value: phrases,\n        }\n      }"
         },
         {
           "match": "({context}) => context.marker == 'have' && !context.query",
@@ -946,8 +946,8 @@
           "apply": "async (args) => {\n        const {context, fragments, objects, km, api, log, s, uuid} = args\n        const objectContext = context.one.objects[context.one.objects.length-1];\n        const propertyContext = context.one.objects[0];\n        // const propertyContext = context.one;\n        if (objectContext.unknown) {\n          objectContext.value = pluralize.singular(objectContext.value)\n        }\n        const objectId = objectContext.value\n\n        await api.makeObject({ ...args, context: objectContext })\n        await api.makeObject({ ...args, context: propertyContext })\n        const propertyId = propertyContext.value\n        try {\n          api.setProperty(objectContext, propertyContext, context.two, true)\n          context.sameWasProcessed = true\n        } catch (e) {\n          log(`Error processing set property of an object: ${e}`)\n          const config = km('properties')\n          const value = await api.getProperty(objectId, propertyId)\n          if (value?.value == context.two?.value) {\n            context.evalue = [\n              { marker: 'yesno', value: true, paraphrase: true },\n            ]\n            context.isResponse = true\n            context.sameWasProcessed = true\n          } else {\n            const mappings = {\n              property1: { word: propertyContext.word, value: propertyContext.value, paraphrase: true },\n              object1: { word: objectContext.word, value: objectContext.value, paraphrase: true },\n              value1: value,\n            }\n            // run the query 'the property of object' then copy that here and template it\n            context.evalue = [\n              { marker: 'yesno', value: false, paraphrase: true },\n            ]\n            context.evalue = context.evalue.concat(await fragments(\"the property1 of object1 is value1\", mappings))\n            context.evalue.forEach( (r) => r.paraphrase = true )\n            context.isResponse = true\n            context.sameWasProcessed = true\n          }\n        }\n      }"
         },
         {
-          "match": "({context, hierarchy, toArray}) => {\n        return (toArray(context).every((value) => hierarchy.isA(value.marker, 'property')) || (hierarchy.isA(context.marker, 'list') && context.possession)) && context.evaluate && context.objects && !context.evaluate.toConcept\n      }",
-          "apply": "async ({debug, isA, hierarchy, getWordFromDictionary, flatten, asList, context, api, kms, objects, g, gp, s, log, recall}) => {\n        async function toValue(objectContext) {\n          debug.breakAt('kirk#call3')\n          if (!objectContext.value) {\n            return objectContext;\n          }\n          let objectValue = kms.stm.api.getVariable(objectContext);\n          if (!objectValue) {\n            objectValue = objectContext.value\n          }\n          if (!await api.knownObject(objectValue)) {\n            objectContext.verbatim = `There is no object named \"${await g({...objectContext, paraphrase: true})}\"`\n            return\n          }\n          return objectValue\n        }\n\n        async function processOne(toDo) {\n          let currentContext = toDo.pop()\n          let currentValue = await toValue(currentContext)\n          while (toDo.length > 0) {\n            const nextContext = toDo.pop()\n            const nextValue = await toValue(nextContext)\n            if (!nextValue) {\n              // TODO maybe this I aware so it can say \"I don't know about blah...\" and below\n              // if (currentContext.unknown || !currentContext.value) {\n              if (!api.conceptExists(currentContext.value)) {\n                // api.conceptExists(currentContext)\n                const objectPhrase = await g({...currentContext, paraphrase: true})\n                context.verbatim = `What \"${objectPhrase}\" means is unknown`\n                return\n              }\n\n              const propertyPhrase = await g({...nextContext, paraphrase: true})\n              const objectPhrase = await g({...currentContext, paraphrase: true})\n              context.verbatim = `There is no interpretation for \"${propertyPhrase} of ${objectPhrase}\"`\n              return\n            }\n\n            let fromMentions\n            if (!await api.knownProperty(currentContext, nextContext)) {\n              if (hierarchy.isA(nextValue, 'property_type')) {\n                const types = hierarchy.froms(nextValue)\n                for (const type of types) {\n                  if (isA(currentContext, type)) {\n                    fromMentions = getWordFromDictionary({ value: type })\n                  }\n                }\n              }\n              if (!fromMentions) {\n                fromMentions = await recall({ context: nextContext, all: nextContext.number == 'many', frameOfReference: currentContext })\n              }\n              if (!fromMentions) {\n                if (!currentValue && currentContext.unknown) {\n                  context.verbatim = `What \"${await gp(currentContext)}\" means is unknown`\n                } else {\n                  context.verbatim = `There is no property ${await g({...nextContext, paraphrase: true})} of ${await g({...currentContext, paraphrase: true})}`\n                }\n                return\n              }\n            }\n            if (fromMentions) {\n              currentContext = fromMentions\n              currentValue = fromMentions // TODO not sure what is right here so just do something and fix when actually needed SOP\n            } else {\n              currentContext = await api.getProperty(currentValue, nextValue)\n              currentValue = currentContext.value\n            }\n          }\n          return currentContext\n        }\n\n        // const toDo = [ ...context.objects ]\n        const toDos = flatten(['list'], context.objects)\n        const results = []\n        for (const toDo of toDos) {\n          const one = await processOne(toDo)\n          if (one) {\n            results.push(one)\n          }\n        }\n\n        if (results.length > 0) {\n          context.focusable = ['object[0]']\n          // context.evalue = currentContext\n          context.evalue = asList(results, true)\n          context.object = undefined;\n        } else {\n          context.evalue = { marker: 'answerNotKnown' }\n          context.object = undefined;\n        }\n      }"
+          "match": "({context, hierarchy, toArray}) => {\n        return (toArray(context).every((value) => hierarchy.isA(value.marker, 'property')) || (hierarchy.isA(context.marker, 'list') && context.possession)) && context.objects\n      }",
+          "apply": "async ({debug, isA, hierarchy, getWordFromDictionary, flatten, asList, context, api, kms, objects, g, gp, s, log, recall}) => {\n        async function toValue(objectContext) {\n          if (!objectContext.value) {\n            return objectContext;\n          }\n          let objectValue = kms.stm.api.getVariable(objectContext);\n          if (!objectValue) {\n            objectValue = objectContext.value\n          }\n          if (!await api.knownObject(objectValue)) {\n            objectContext.verbatim = `There is no object named \"${await g({...objectContext, paraphrase: true})}\"`\n            return\n          }\n          return objectValue\n        }\n\n        async function processOne(toDo) {\n          let currentContext = toDo.pop()\n          let currentValue = await toValue(currentContext)\n          while (toDo.length > 0) {\n            const nextContext = toDo.pop()\n            const nextValue = await toValue(nextContext)\n            if (!nextValue) {\n              // TODO maybe this I aware so it can say \"I don't know about blah...\" and below\n              // if (currentContext.unknown || !currentContext.value) {\n              if (!api.conceptExists(currentContext.value)) {\n                // api.conceptExists(currentContext)\n                const objectPhrase = await g({...currentContext, paraphrase: true})\n                context.verbatim = `What \"${objectPhrase}\" means is unknown`\n                return\n              }\n\n              const propertyPhrase = await g({...nextContext, paraphrase: true})\n              const objectPhrase = await g({...currentContext, paraphrase: true})\n              context.verbatim = `There is no interpretation for \"${propertyPhrase} of ${objectPhrase}\"`\n              return\n            }\n\n            let fromMentions\n            if (!await api.knownProperty(currentContext, nextContext)) {\n              if (hierarchy.isA(nextValue, 'property_type')) {\n                const types = hierarchy.froms(nextValue)\n                for (const type of types) {\n                  if (isA(currentContext, type)) {\n                    fromMentions = getWordFromDictionary({ value: type })\n                  }\n                }\n              }\n              if (!fromMentions) {\n                fromMentions = await recall({ context: nextContext, all: nextContext.number == 'many', frameOfReference: currentContext })\n              }\n              if (!fromMentions) {\n                if (!currentValue && currentContext.unknown) {\n                  context.verbatim = `What \"${await gp(currentContext)}\" means is unknown`\n                } else {\n                  context.verbatim = `There is no property ${await g({...nextContext, paraphrase: true})} of ${await g({...currentContext, paraphrase: true})}`\n                }\n                return\n              }\n            }\n            if (fromMentions) {\n              currentContext = fromMentions\n              currentValue = fromMentions // TODO not sure what is right here so just do something and fix when actually needed SOP\n            } else {\n              currentContext = await api.getProperty(currentValue, nextValue)\n              currentValue = currentContext.value\n            }\n          }\n          return currentContext\n        }\n\n        // const toDo = [ ...context.objects ]\n        const toDos = flatten(['list'], context.objects)\n        const results = []\n        for (const toDo of toDos) {\n          const one = await processOne(toDo)\n          if (one) {\n            results.push(one)\n          }\n        }\n\n        if (results.length > 0) {\n          context.focusable = ['object[0]']\n          // context.evalue = currentContext\n          context.evalue = asList(results, true)\n          context.object = undefined;\n        } else {\n          context.evalue = { marker: 'undefined' }\n          context.object = undefined;\n        }\n      }"
         }
       ]
     },
@@ -2483,17 +2483,17 @@
           "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:543"
         },
         {
-          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:567"
+          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:566"
         },
         {
           "notes": "object's property",
-          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:576"
+          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:575"
         }
       ],
       "semantics": [
         {
           "notes": "unify for properties",
-          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:608"
+          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:607"
         },
         {
           "notes": "getter for relation based verbs"
@@ -2511,41 +2511,41 @@
           "notes": "semantic for setting value with constraint"
         },
         {
-          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:779",
+          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:777",
           "notes": "how deep is the pool",
           "priority": -1
         },
         {
-          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:806"
+          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:804"
         },
         {
           "notes": "wants is xfx between wanter and wantee",
-          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:817",
+          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:815",
           "priority": -1
         },
         {
           "notes": "marking something as readonly",
-          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:832"
+          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:830"
         },
         {
           "notes": "crew members. evaluate a concepts to get instances",
-          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:856"
+          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:854"
         },
         {
           "notes": "greg has eyes",
-          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:882"
+          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:879"
         },
         {
           "notes": "greg has eyes?",
-          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:902"
+          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:899"
         },
         {
           "notes": "set the property of an object",
-          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:928"
+          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:925"
         },
         {
           "notes": "get/evaluate a property",
-          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:980"
+          "where": "/home/dev/code/theprogrammablemind/kms/common/properties.js:977"
         }
       ]
     },

package/common/properties.js

@@ -58,7 +58,7 @@ V2
 //        [
 //          ({objects, context, args, hierarchy}) => 
 //                hierarchy.isA(context.marker, 'property') && 
-//                args({ types: ['myObjectType'], properties: ['object'] }) && context.evaluate, 
+//                args({ types: ['myObjectType'], properties: ['object'] }),
 //          ({objects, context}) => {
 //          context.value = "value" // set the value here somehow
 //          }
@@ -425,7 +425,7 @@ const config = {
       match: ({context}) => context.isEd,
       apply: async ({context, g}) => {
         const chosen = chooseNumber(context[context.afterTag], 'is', 'are')
-        if (context[context.beforeTag].evalue && context[context.beforeTag].evalue.marker == 'answerNotKnown') {
+        if (context[context.beforeTag].evalue && context[context.beforeTag].evalue.marker === 'undefined') {
           return await g(context[context.beforeTag])
         }
         return `${await g(context[context.afterTag])} ${chosen} ${context.word} by ${await g(context[context.beforeTag])}`
@@ -563,9 +563,8 @@ const config = {
              },
     },
     {
-      // ({context, hierarchy}) => hierarchy.isA(context.marker, 'property') && context.object && !context.value && !context.evaluate,
       where: where(),
-      match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'property') && context.object && !context.possession && !context.evaluate && !context.object.marker == 'objectPrefix',
+      match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'property') && context.object && !context.possession && context.paraphrase && !context.object.marker == 'objectPrefix',
       apply: async ({context, g}) => {
         const property = Object.assign({}, context, { object: undefined })
         return `${await g(property)} of ${await g({ ...context.object, paraphrase: true })}`
@@ -577,7 +576,7 @@ const config = {
       // match: ({context}) => context.paraphrase && !context.modifiers && context.object, 
       match: ({context}) => !context.modifiers && (context.object || context.objects) && !context.interpolate, 
       apply: async ({context, g, gs}) => {
-        if (context.evalue) {
+        if (context.evalue && !context.paraphrase) {
           return await g(context.evalue)
         } else if (context.objects) {
           const objects = [ ...context.objects ]
@@ -607,7 +606,6 @@ const config = {
       notes: 'unify for properties',
       where: where(),
       match: ({context, isA}) => 
-        context.evaluate && 
         context.marker == 'unify' && 
         context.terms?.some((term) => {
           return term.objects && isA(term.objects[0], 'property') && term.query
@@ -648,7 +646,7 @@ const config = {
         context.evalue.isResponse = true
         context.isResponse = true
         if (context.evalue.value.length == 0) {
-          context.evalue.marker = 'answerNotKnown';
+          context.evalue.marker = 'undefined';
           context.evalue.listable = true
           context.evalue.value = [];
         } else {
@@ -659,7 +657,7 @@ const config = {
 
     {
       notes: `setter for relation based verbs`,
-      match: ({context}) => context.relationBacked && !context.toVoice && !context.evaluate,
+      match: ({context}) => context.relationBacked && !context.toVoice && context.isVerb,
       apply: ({context, km, hierarchy, config, stack}) => {
         const api = km('properties').api
         // add types for arguments
@@ -741,8 +739,8 @@ const config = {
     },
     {
       notes: 'semantic for setting value with constraint',
-      //match: ({context, isA}) => isA(context.marker, after[0].tag) && context.evaluate && context.constraints,
-      match: ({context, isA}) => context.evaluate && context.constraints,
+      //match: ({context, isA}) => isA(context.marker, after[0].tag) && context.constraints,
+      match: ({context, isA}) => context.constraints,
       apply: async ({km, context, e, log, isA}) => {
         const constraint = context.constraints[0];
         const value = constraint.constraint;
@@ -766,7 +764,7 @@ const config = {
           context.evalue = { verbatim: instance.verbatim }
           return
         }
-        if (instance.evalue.marker == 'answerNotKnown') {
+        if (instance.evalue.marker === 'undefined') {
           context.evalue = instance.evalue
           return
         }
@@ -780,7 +778,7 @@ const config = {
       notes: "how deep is the pool",
       priority: -1,
       match: ({context}) => context.marker == 'is' && (context.one.how || context.two.how),
-      apply: async ({ resolveResponse, g, context, toArray, toList, fragments, kms, e, toEValue }) => {
+      apply: async ({ resolveEvaluate, g, context, toArray, toList, fragments, kms, e, toEValue }) => {
         const propertyMarkerContext = context.one
         let object = context.two
         if (context.two.how) {
@@ -799,7 +797,7 @@ const config = {
         propertyOfObject.focusableForPhrase = false
         const response = await fragments("the property is value", { property: propertyOfObject, value })
         response.isResponse = true
-        resolveResponse(context, response) 
+        resolveEvaluate(context, response) 
       }
     },
     {
@@ -857,14 +855,13 @@ const config = {
       match: ({context, hierarchy, api, isA}) => 
                           hierarchy.isA(context.marker, 'concept') && ((!context.propertyOf && !context.isProperty) || isA(context.objects[context.objects.length-1], 'dimension')) &&
                           (!context.pullFromContext || context.number == 'many') &&
-                          context.evaluate &&
+                          (context.pullFromContext || isA(context, 'type') || context.metaDefinition) &&
                           !(context.types || []).includes('property') &&
                           // !context.value &&  // greghere
                           !context.ordinal &&
                           (!context.objects || context.objects.length !== 2 || !context.objects[1].isInstance) &&
-                          (api.objects && api.objects.children && api.objects.children[context.marker]) &&
-                          !context.evaluate.toConcept,
-      apply: ({context, hierarchy, objects, api, km}) => {
+                          (api.objects && api.objects.children && api.objects.children[context.marker]),
+      apply: ({context, stack, isA, contextHierarchy, hierarchy, objects, api, km}) => {
         const values = api.objects.children[context.marker]
         const phrases = values.map( (value) => km('concept').api.getWordForValue(value) )
         // context.focusableForPhrase = true
@@ -979,12 +976,10 @@ const config = {
       notes: 'get/evaluate a property',
       where: where(),
       match: ({context, hierarchy, toArray}) => {
-        return (toArray(context).every((value) => hierarchy.isA(value.marker, 'property')) || (hierarchy.isA(context.marker, 'list') && context.possession)) && context.evaluate && context.objects && !context.evaluate.toConcept
+        return (toArray(context).every((value) => hierarchy.isA(value.marker, 'property')) || (hierarchy.isA(context.marker, 'list') && context.possession)) && context.objects
       },
-      // match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'property') && context.evaluate,
       apply: async ({debug, isA, hierarchy, getWordFromDictionary, flatten, asList, context, api, kms, objects, g, gp, s, log, recall}) => {
         async function toValue(objectContext) {
-          debug.breakAt('kirk#call3')
           if (!objectContext.value) {
             return objectContext;
           }
@@ -1070,7 +1065,7 @@ const config = {
           context.evalue = asList(results, true)
           context.object = undefined;
         } else {
-          context.evalue = { marker: 'answerNotKnown' }
+          context.evalue = { marker: 'undefined' }
           context.object = undefined;
         }
       }

package/common/rates.instance.json

@@ -19,7 +19,7 @@
       ],
       "semantics": [
         {
-          "match": "({context}) => context.marker == 'convertToUnits' && context.evaluate && (context.from?.unit?.marker == 'unitPerUnit' || context.to.marker == 'unitPerUnit')",
+          "match": "({context}) => context.marker == 'convertToUnits' && (context.from?.unit?.marker == 'unitPerUnit' || context.to.marker == 'unitPerUnit')",
           "apply": "async ({remember, context, kms, e, callId, resolveEvaluate, toEValue, error}) => {\n\n            async function convert(fromUnits, fromAmount, toUnits) {\n              let evalue;\n              if (toUnits.value == fromUnits.value) {\n                evalue = fromAmount\n                // if (!fromAmount.value) {\n                //  debugger\n                //}\n                evalue.evalue = fromAmount.evalue || fromAmount.value\n              } else {\n                const formula = kms.formulas.api.get(toUnits, [fromUnits])\n                if (!formula) {\n                  const reason = { marker: 'reason', focusableForPhrase: true, evalue: { marker: 'noconversion', from: fromUnits, to: toUnits } }\n                  kms.stm.api.remember({ context: reason })\n                  error(reason)\n                }\n                kms.stm.api.setVariable(fromUnits.value, fromAmount)\n                evalue = await e(formula)\n              }\n              return evalue\n            }\n\n            if (!context.from.unit) {\n              resolveEvaluate(context.from, await e(context.from))\n            }\n\n\n            const from = toEValue(context.from)\n            remember(context.to)\n            const evalueNumerator = await convert(from.unit.numerator, from.amount, context.to.numerator)\n            const evalueDenominator = await convert(from.unit.denominator, 1, context.to.denominator)\n            const evalue = { evalue: (toFinalValue(evalueNumerator) || evalueNumerator.value) / (toFinalValue(evalueDenominator) || evalueDenominator.evalue) }\n            context.evalue = {\n              paraphrase: true,\n              marker: 'quantity',\n              level: 1,\n              unit: context.to,\n              amount: { evalue, paraphrase: undefined }\n            }\n          }"
         }
       ]

package/common/rates.js

@@ -36,7 +36,7 @@ const template = {
       semantics: [
         {
           where: where(),
-          match: ({context}) => context.marker == 'convertToUnits' && context.evaluate && (context.from?.unit?.marker == 'unitPerUnit' || context.to.marker == 'unitPerUnit'),
+          match: ({context}) => context.marker == 'convertToUnits' && (context.from?.unit?.marker == 'unitPerUnit' || context.to.marker == 'unitPerUnit'),
           apply: async ({remember, context, kms, e, callId, resolveEvaluate, toEValue, error}) => {
 
             async function convert(fromUnits, fromAmount, toUnits) {

package/common/reminders.js

@@ -64,7 +64,7 @@ function query(missing, reminder_id) {
     },
 
     matchr: async ({ isA, api, context }) => {
-      if (context.evaluate || context.isControl || context.isResponse) {
+      if (context.isControl || context.isResponse) {
         return false
       }
       const gotADate = ((isA(context.marker, 'onDateValue_dates') || isA(context.marker, 'dateTimeSelector')) && api.missing(missing, reminder_id))