ekms 9.6.3-beta.2 → 9.6.3-beta.21

package/common/drone.js

@@ -1,4 +1,4 @@
-const { knowledgeModule, where } = require('./runtime').theprogrammablemind
+const { knowledgeModule, where, debug } = require('./runtime').theprogrammablemind
 const { conjugateVerb } = require('./english_helpers')
 const { OverrideCheck, defaultContextCheckProperties, defaultContextCheck, getValue, setValue } = require('./helpers')
 const drone_tests = require('./drone.test.json')
@@ -14,6 +14,33 @@ const help = require('./help')
 const { rotateDelta, degreesToRadians, radiansToDegrees, cartesianToPolar, smallestRotate } = require('./helpers/drone')
 
 /*
+NEED TO CHECK ON ACTUAL DRONE
+
+  patrol back and forth 2 times
+
+  DONE fix DO so it can do all the stuff partol can do <<<<<<<<<<<<<<<<<<<
+  start again. start a new path
+  the last 3 points are called path 1
+  go forward 1 meter and then turn north
+  go forward 1 meter and turn north
+
+
+  stopping 2 seconds at each point
+  patrols x do that again
+  DONE go to the end of the patrol
+  DONE patrol x three times
+  patrol x continuously
+  patrol x for 5 minutes
+  go to the start
+  DONE node drone -q 'north 1 meter\neast 1 meter\ncall that route 2\nwhat is the second point of route 2' -g -
+
+  go to the start along the path / following the path
+  pausing 1 second at the first point and 5 at the last
+
+  DONE go to the second point of route 1
+  DONE do route 1 pausing 10 seconds at each point
+
+  what is the drone's position
 DONE go back
 go back another point
 go back again
@@ -21,12 +48,22 @@ go back to the start
 go back 2 points along route 1
 go to the start of route 2
 
+go forward 1 foot\nturn left\ngo forward again\n
+                              do it again
+do route 1 skipping point 2
+
+TODO should there be two hierarchy one as a concept car is a vehicle and one as a word car is a noun
+
 turn left\nturn back
 
-do route 1 pausing 10 seconds at each point
+DONE do route 1 pausing 10 seconds at each point
+do route 1 pausing 1 second at point 1 and 2 seconds for the rest
 
 forward 1 foot\nwest 1 foot\ngo back to the start         <<<<<<<<  turn the longer way not he shorter way
 forward 1 foot\nwest 1 foot\ncall the path route 1\ngo to the start of route 1\npatrol route 1\npatrol route 1   <<<<< does the patrol more than once
+call that route 1
+what are the paths
+list the paths
 
 ?? elipses of the verb go or some kind of conjunction?!?!?
 go forward 1 meter turn right forward 2 meters stop
@@ -269,6 +306,22 @@ class API {
     const overrideMethods = Object.getOwnPropertyNames(API.prototype).filter(key => typeof API.prototype[key] === 'function' && key.endsWith('Drone'));
     this.overrideCheck = new OverrideCheck(API, overrideMethods)
     this.overriden = this.constructor !== API
+    this.startPoint = { x: 0, y: 0 }
+    this.startAngle = Math.PI/2
+    this.startCompass = 'north'
+  }
+
+  setStartPoint(point) {
+    this.startPoint = point
+  }
+
+  setStartAngle(angleInRadians, compass) {
+    this.startAngle = angleInRadians
+    this.startCompass = compass
+  }
+
+  setSpeed(metersPerSecond) {
+    this._objects.current.speed = metersPerSecond
   }
 
   initialize({ objects }) {
@@ -276,11 +329,11 @@ class API {
       this.overrideCheck.check(this)
     }
 
-    if (!this.minimumSpeedDrone()) {
+    if (this.minimumSpeedDrone() == null) {
       throw new Error(`minimumSpeedDrone is not returning a positive number. Its returning ${this.minimumSpeedDrone()}`)
     }
 
-    if (!this.maximumSpeedDrone()) {
+    if (this.maximumSpeedDrone() == null) {
       throw new Error(`maximumSpeedDrone is not returning a positive number. Its returning ${this.maximumSpeedDrone()}`)
     }
 
@@ -289,17 +342,17 @@ class API {
     delete this.testDate
 
     objects.current = {
-      angleInRadians: Math.PI/2,
+      angleInRadians: this.startAngle,
       path: [],
       speed: this.minimumSpeedDrone(),
       ordinal: 0,                 // ordinal of the current point or the current point that the recent movement started at
-      compass: 'north',           // for now assume the drone start out point north. i will make that part of the conversation later
+      compass: this.startCompass,
       direction: 'forward',
     }
     objects.history = []
     objects.sonicTest = 5
 
-    this.args.mentioned({ marker: 'point', ordinal: this.nextOrdinal(), point: { x: 0, y: 0 }, description: "start" })
+    this.args.remember({ marker: 'point', ordinal: this.nextOrdinal(), point: this.startPoint, description: "start" })
   }
 
   currentOrdinal() {
@@ -318,7 +371,7 @@ class API {
       return null // in motion
     }
     const ordinal = this.currentOrdinal()
-    const lastPoint = await this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
+    const lastPoint = await this.args.recall({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
     if (!current.startTime && !current.endTime && !current.durationInSeconds) {
       return lastPoint // did not move
     }
@@ -344,7 +397,7 @@ class API {
       return
     }
     const ordinal = this.nextOrdinal()
-    this.args.mentioned({ marker: 'point', ordinal, point })
+    this.args.remember({ marker: 'point', ordinal, point })
     this._objects.current.endTime = null
     this._objects.current.startTime = null
   }
@@ -378,9 +431,13 @@ class API {
       const unitsOfUser = objects.current.speedUnitsOfUser
       const minimumValueInDroneUnits = await fragments("number meters per second", { number: { marker: 'integer', value: minimumSpeed } })
       // const valueInUsersUnits = await fragments("quantity in meters", { quantity: minimumValueInDroneUnits, meter: unitsOfUser })
-      const valueInUsersUnits = await quantityInMeters(minimumValueInDroneUnits, unitsOfUser )
-      const evaluated = await e(valueInUsersUnits)
-      say(`The drone cannot go that slow. The minimum speed is ${await gr(evaluated.evalue)}`)
+      if (unitsOfUser) {
+        const valueInUsersUnits = await quantityInMeters(minimumValueInDroneUnits, unitsOfUser )
+        const evaluated = await e(valueInUsersUnits)
+        say(`The drone cannot go that slow. The minimum speed is ${await gr(evaluated.evalue)}`)
+      } else {
+        say(`The drone cannot go that fast. The minimum speed is ${await gr(minimumValueInDroneUnits)}`)
+      }
       objects.runCommand = false
       objects.current.speed = minimumSpeed
       return
@@ -392,9 +449,13 @@ class API {
       const unitsOfUser = objects.current.speedUnitsOfUser
       const maximumValueInDroneUnits = await fragments("number meters per second", { number: { marker: 'integer', value: maximumSpeed } })
       // const valueInUsersUnits = await fragments("quantity in meters", { quantity: maximumValueInDroneUnits, meter: unitsOfUser })
-      const valueInUsersUnits = await quantityInMeters(maximumValueInDroneUnits, unitsOfUser )
-      const evaluated = await e(valueInUsersUnits)
-      say(`The drone cannot go that fast. The maximum speed is ${await gr(evaluated.evalue)}`)
+      if (unitsOfUser) {
+        const valueInUsersUnits = await quantityInMeters(maximumValueInDroneUnits, unitsOfUser)
+        const evaluated = await e(valueInUsersUnits)
+        say(`The drone cannot go that fast. The maximum speed is ${await gr(evaluated.evalue)}`)
+      } else {
+        say(`The drone cannot go that fast. The maximum speed is ${await gr(maximumValueInDroneUnits)}`)
+      }
       objects.runCommand = false
       objects.current.speed = minimumSpeed
       return
@@ -409,16 +470,19 @@ class API {
     }
 
     if (objects.current.path.length > 0) {
-      if (objects.current.timeRepeats) {
-        this.startRepeats(objects.current.timeRepeats)
-      }
-      let currentPoint = (await this.args.mentions({ context: { marker: 'point' } })).point
+      let currentPoint = (await this.args.recall({ context: { marker: 'point' } })).point
       this._objects.history.push({ marker: 'history', debug: 'doing path' })
-      for (const pathComponent of objects.current.path) {
-        if (pathComponent.marker == 'pause') {
+      for (const [pathIndex, pathComponent] of objects.current.path.entries()) {
+        if (pathComponent.repeatStart) {
+          if (objects.current.timeRepeats) {
+            this.startRepeats(objects.current.timeRepeats)
+          }
+        } else if (pathComponent.marker == 'pause') {
           this.pause(pathComponent.pauseSeconds, { batched: true })
         } else {
-          const destinationPoint = pathComponent.point
+          const points = this.args.toArray(pathComponent)
+          // const destinationPoint = pathComponent.point
+          const destinationPoint = points[0].point || points[0]
           if (currentPoint.x == destinationPoint.x && currentPoint.y == destinationPoint.y) {
             // already there
           } else {
@@ -427,12 +491,12 @@ class API {
             // const angleDelta = (destinationAngleInRadians - objects.current.angleInRadians)
             const angleDelta = rotateDelta(objects.current.angleInRadians, destinationAngleInRadians)
             await this.rotate(angleDelta, { batched: true })
-            if (!pathComponent .aimOnly) {
+            if (!pathComponent.aimOnly) {
               await this.forward(objects.current.speed, { batched: true })
               await stopAtDistance("forward", polar.radius)
+              currentPoint = destinationPoint
             }
           }
-          currentPoint = destinationPoint
         }
       }
       if (objects.current.timeRepeats) {
@@ -544,7 +608,7 @@ class API {
     } else {
       ordinal = this.currentOrdinal() - 1
     }
-    const lastPoint = await this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
+    const lastPoint = await this.args.recall({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
     if (!lastPoint) {
       this.args.say(`There is no previous point to go back to`)
       return
@@ -558,8 +622,9 @@ class API {
     const current = objects.current
     current.backAndForth = true
     const ordinal = this.currentOrdinal()
-    const currentPoint = await this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
-    const lastPoint = await this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal-1 })
+    const currentPoint = await this.args.recall({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
+    const lastPoint = await this.args.recall({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal-1 })
+    current.path.push({ repeatStart: true })
     current.path.push(lastPoint)
     current.path.push(currentPoint)
     objects.runCommand = true
@@ -752,6 +817,7 @@ const template = {
     "number radians",
     "40 degrees in radians",
     "path",
+    "forward",
   ],
   configs: [
     "arm, claw and drone are concepts",
@@ -759,9 +825,25 @@ const template = {
     "around, forward, left, right, back, forth and backward are directions",
     "paths are nameable and memorable",
     "start and end are properties of path",
+    ({apis}) => {
+      apis('properties').addHierarchyWatcher({
+        match: ({childId}) => childId == 'point',
+        apply: ({config, childId}) => {
+          config.updateBridge(childId, ({ bridge }) => {
+            if (!bridge.init) {
+              bridge.init = {}
+            }
+            bridge.init['notConjunctableWith'] = ['quantity']
+          })
+        }
+      })
+    },
+
     "start and end are points",
+    "rest and remaining are concepts",
     {
       hierarchy: [
+        ['point', 'distributable'],
         ['thisitthat', 'path'],
         ['path', 'action'],
       ],
@@ -815,14 +897,45 @@ const template = {
         "([lower] (@<= arm || @<=claw))",
         "([open] (claw))",
         "([close] (claw))",
+        "([startPath|start] (path))",
         "([pathComponent])",
         "(<another> (point))",
         // "([turn] (direction))",
         // "([pause] ([number]))",
         "([stop] ([drone|])?)",
         "([toPoint|to] (point))",
+        "([atPoint|at] (point))",
+        // "([forRest|for] (rest/* || remaining/*))",
+        "((context.unit.dimension == 'time') [timeAtPoint|] (atPoint))",
+        // "((context.unit.dimension == 'time') [timeForRest|] (forRest))",
       ],
       bridges: [
+        { 
+          id: 'startPath',
+          isA: ['verb'],
+          bridge: "{ ...next(operator), path: after[0], operator: operator, interpolate: [{ property: 'operator' }, { property: 'path' }] }",
+          check: defaultContextCheckProperties(['path']),
+          semantic: async ({context, remember, recall, verbatim, g}) => {
+            const point = await recall({ context: { marker: 'point' } })
+            remember(context) 
+            remember(point) // put the last point before the startPath so when the new path is generated this is the start point
+            verbatim(`New path started from ${await g(point)}`)
+          },
+        },
+        { 
+          id: 'timeAtPoint',
+          before: ['verb'],
+          after: ['preposition'],
+          convolution: true,
+          bridge: "{ ...next(operator), time: before[0], point: after[0], operator: operator, interpolate: [{ property: 'time' }, { property: 'point' }] }",
+          check: defaultContextCheckProperties(['time', 'point']),
+        },
+        { 
+          id: 'atPoint',
+          isA: ['preposition'],
+          bridge: "{ ...next(operator), point: after[0], operator: operator, interpolate: [{ property: 'operator' }, { property: 'point' }] }",
+          check: defaultContextCheckProperties(['point']),
+        },
         { 
           id: 'another',
           bridge: `{
@@ -831,6 +944,7 @@ const template = {
             after: after[0],
             interpolate: [ { property: 'another' }, { property: 'after' } ]
           }`,
+          check: defaultContextCheckProperties(['another', 'after']),
         },
         { 
           id: 'pathComponent',
@@ -838,22 +952,61 @@ const template = {
         },
         {
           id: 'patrol',
-          isA: ['verb'],
+          isA: ['verb', 'repeatable'],
           bridge: `{
-            ...next(operator), operator: operator, path: after[0], interpolate: [{ property: 'operator'}, { property: 'path' }]
+            ...next(operator), operator: operator, path: after[0], interpolate: append(default(operator.interpolate, [{ property: 'operator'}]), [{ property: 'path' }])
           }`,
-          semantic: async ({context, e, toEValue, objects}) => {
+          check: defaultContextCheckProperties(['path']),
+          semantic: async ({context, e, toArray, fragments, toEValue, toFinalValue, recall, objects}) => {
             const evaluated = await(e(context.path))
             const path = toEValue(evaluated)
+          
+            // TODO put this in a common place for use by do+patrol 
+
+            // ordinal to pause time in seconds 
+            const pauseTimeInSeconds = {}
+            if (context.pause) {
+              const timeAtPoints = toArray(context.pause.timeAtPoint)
+              for (const timeAtPoint of timeAtPoints) {
+                const instantiation = await fragments("quantity in seconds", { quantity: timeAtPoint.time })
+                const result = await e(instantiation)
+                const seconds = toFinalValue(toFinalValue(result).amount)
+
+                const points = await recall({ context: timeAtPoint.point.point, frameOfReference: path })
+                for (const point of toArray(points)) {
+                  pauseTimeInSeconds[point.ordinal] = seconds
+                }
+              }
+            }
+
+            // get to the start of the patrol  
+            objects.current.path.push(path.points[0])
+            objects.current.path.push({ aimOnly: true, ...path.points[1] })
+            objects.current.path.push({ repeatStart: true })
             for (const point of path.points) {
               objects.current.path.push(point)
+              if (pauseTimeInSeconds[point.ordinal]) {
+                objects.current.path.push({ marker: 'pause', pauseSeconds: pauseTimeInSeconds[point.ordinal] })
+              }
+            }
+            if (context.repeats) {
+              objects.current.timeRepeats = toFinalValue(context.repeats.repeats)
             }
             // if the patrol does not start and end at the same spot then 
             // go back to the start along the same path
+
+
+            // if the start is not the end of the patrol then go backwards along the patrol
             if (JSON.stringify(path.points[0].point) !== JSON.stringify(path.points[path.points.length-1].point)) {
-              for (const point of [...path.points].reverse()) {
+              for (const point of [...path.points].reverse().slice(1)) {
                 objects.current.path.push(point)
+                if (pauseTimeInSeconds[point.ordinal]) {
+                  objects.current.path.push({ marker: 'pause', pauseSeconds: pauseTimeInSeconds[point.ordinal] })
+                }
               }
+
+              const secondPoint = path.points[1]
+              objects.current.path.push({ ...secondPoint, aimOnly: true })
             }
             objects.runCommand = true
           }
@@ -881,6 +1034,7 @@ const template = {
           bridge: `{
             ...next(operator), operator: operator, object: after[0], interpolate: [{ property: 'operator'}, { property: 'object' }]
           }`,
+          check: defaultContextCheckProperties(['object']),
           semantic: ({api}) => {
             api.armAction('up')
           }
@@ -891,6 +1045,7 @@ const template = {
           bridge: `{
             ...next(operator), operator: operator, object: after[0], interpolate: [{ property: 'operator'}, { property: 'object' }]
           }`,
+          check: defaultContextCheckProperties(['object']),
           semantic: ({api}) => {
             api.armAction('down')
           }
@@ -901,6 +1056,7 @@ const template = {
           bridge: `{
             ...next(operator), operator: operator, object: after[0], interpolate: [{ property: 'operator'}, { property: 'object' }]
           }`,
+          check: defaultContextCheckProperties(['object']),
           semantic: ({api}) => {
             api.clawAction('open')
           }
@@ -911,6 +1067,7 @@ const template = {
           bridge: `{
             ...next(operator), operator: operator, object: after[0], interpolate: [{ property: 'operator'}, { property: 'object' }]
           }`,
+          check: defaultContextCheckProperties(['object']),
           semantic: ({api}) => {
             api.clawAction('close')
           }
@@ -918,7 +1075,7 @@ const template = {
         {
           id: 'back',
           isA: ['noun'],
-          semantic: async ({objects, mentions, api, e, context, say}) => {
+          semantic: async ({objects, api, e, context, say}) => {
             await api.back()
           }
         },
@@ -931,6 +1088,7 @@ const template = {
           isA: ['preposition'],
           after: [['propertyOf', 1]],
           bridge: "{ ...next(operator), operator: operator, point: after[0], interpolate: [{ property: 'operator' }, { property: 'point' }] }",
+          check: defaultContextCheckProperties(['point']),
           semantic: async ({objects, api, e, context}) => {
             objects.runCommand = true
             const point = await e(context.point)
@@ -941,11 +1099,11 @@ const template = {
           id: "go",
           level: 0,
           // convolution: true,
-          isA: ['verb', 'action'],
+          isA: ['verb', 'action', 'repeatable'],
           words: [
             ...conjugateVerb('go'),
           ],
-          check: defaultContextCheckProperties(['direction', 'distance', 'to']),
+          check: defaultContextCheckProperties(['direction', 'distance', 'to', 'points']),
           bridge: `{ 
             ...next(operator), 
             distance: distance?, 
@@ -953,7 +1111,7 @@ const template = {
             points: points?,
             to: to?,
             operator: operator,
-            interpolate: [{ property: 'operator' }, { property: 'direction' }, { property: 'points' }, { property: 'to' }, { property: 'distance' }] 
+            interpolate: append(default(operator.interpolate, [{ property: 'operator' }]), [{ property: 'direction' }, { property: 'points' }, { property: 'to' }, { property: 'distance' }])
           }`,
           selector: {
             arguments: {
@@ -964,7 +1122,7 @@ const template = {
             },
           },
           semantic: async (args) => {
-            const {context, objects, e, toArray, toEValue} = args
+            const {api, toFinalValue, context, objects, e, toArray, toEValue} = args
             if (context.distance) {
               await handleDistance(args, context.distance)
             }
@@ -978,25 +1136,32 @@ const template = {
                 objects.current.direction = context.direction.marker
               }
             }
+            if (context.repeats) {
+              objects.current.timeRepeats = toFinalValue(context.repeats.repeats)
+            }
             if (context.to) {
               const evaluation = await e(context.to.point)
               const point = toEValue(evaluation)
               objects.current.path.push(point)
             }
             objects.runCommand = true
+            await api.sendCommand()
           },
         },
         {
           id: 'turn',
-          isA: ['verb'],
+          isA: ['verb', 'action', 'repeatable'],
+          before: ['thenAction'],
           words: ['turn'],
           bridge: `{ 
             ...next(operator), 
             direction: direction, 
-            repeats: repeats?, 
+            operator: operator,
             angle: angle?,
-            interpolate: [{ context: operator }, { property: 'direction' }, { property: 'angle' }, { property: 'repeats' }] }
+            interpolate: append(default(operator.interpolate, [{ property: 'operator'}]), [{ property: 'direction' }, { property: 'angle' }])
+          }
           `,
+          check: defaultContextCheckProperties(['direction', 'angle']),
           selector: {
             arguments: {
               direction: "(@<= 'direction')",
@@ -1032,6 +1197,9 @@ const template = {
                 return
               }
             }
+            if (context.repeats) {
+              objects.current.timeRepeats = toFinalValue(context.repeats.repeats)
+            }
             current.justTurn = true
             objects.runCommand = true
             await api.sendCommand()
@@ -1041,17 +1209,24 @@ const template = {
         {
           id: 'pause',
           isA: ['verb'],
-          words: ['pause'],
-          bridge: "{ ...operator, time: or(time?, forTime), interpolate: [{ context: operator }, { property: 'time' }] }",
-          check: defaultContextCheckProperties(['time']),
+          words: [
+            ...conjugateVerb('pause'),
+          ],
+          bridge: "{ ...next(operator), timeAtPoint: timeAtPoint?, time: or(time?, forTime?), operator: operator, atPoint: atPoint?, interpolate: [{ property: 'operator' }, { property: 'time' }, { property: 'forTime' }, { property: 'atPoint' }, { property: 'timeAtPoint' } ] }",
+          check: defaultContextCheckProperties(['timeAtPoint']),
           selector: {
             arguments: {
               forTime: "(@<= 'forQuantity' && context.quantity.unit.dimension == 'time')",
               time: "(@<= 'quantity' && context.unit.dimension == 'time')",
+              atPoint: "(@<= 'atPoint')",
+              timeAtPoint: "(@<= 'timeAtPoint')",
             },
           },
-          semantic: async ({context, mentioned, api, e, fragments, toFinalValue}) => {
+          semantic: async ({context, remember, api, e, fragments, toFinalValue}) => {
             let time = context.time 
+            if (!time) {
+              return
+            }
             if (time.marker == 'forQuantity') {
               time = time.quantity
             }
@@ -1059,10 +1234,22 @@ const template = {
             const result = await e(instantiation)
             const seconds = toFinalValue(toFinalValue(result).amount)
             context.pauseSeconds = seconds
-            mentioned(context)
+            remember(context)
             api.pause(seconds)
           }
         },
+        {
+          id: 'pause',
+          level: 1,
+          bridge: "{ ...repeatable, pause: operator, checks: append(repeatable.checks, ['pause']),  repeatable: repeatable, interpolate: [{ property: 'repeatable' }, { property: 'pause', byPosition: true }] }",
+          selector: {
+            loose: "repeatable",
+            arguments: {
+              repeatable: "(@<= 'repeatable')",
+            },
+          },
+          check: defaultContextCheckProperties(['repeatable', 'repeats'])
+        },
         {
           id: 'stop',
           isA: ['verb'],
@@ -1070,7 +1257,7 @@ const template = {
             1: "{ marker: 'drone' }",
           },
           bridge: "{ ...next(operator), object: after[0], interpolate: [{ context: operator }, { property: 'object' }] }",
-          semantic: async ({mentioned, context, objects, api, say}) => {
+          semantic: async ({context, objects, api, say}) => {
             await api.stop()
             await api.markCurrentPoint()
           }
@@ -1089,18 +1276,13 @@ const template = {
       semantics: [
         {
           match: ({context}) => context.marker == 'doAction',
-          apply: async ({context, e, toEValue, objects}) => {
-            const evaluated = await(e(context.action))
-            const path = toEValue(evaluated)
-            for (const point of path.points) {
-              objects.current.path.push(point)
-            }
-            objects.runCommand = true
+          apply: async ({context, fragments, e, s, toEValue, toFinalValue, objects}) => {
+            await s({ ...context, marker: 'patrol', path: context.action})
           }
         },
         {
           match: ({context, contextHierarchy}) => {
-            if (!context.pullFromContext || !context.evaluate || contextHierarchy.under(['doAction', 'evaluate'])) {
+            if (!context.pullFromContext || !context.evaluate || contextHierarchy.under(['doAction', 'evaluate', 'patrol']) || context.instance) {
               return false
             }
             
@@ -1108,13 +1290,18 @@ const template = {
               return true
             }
           },
-          apply: async ({context, frameOfReference, toArray, fragments, stm, objects, mentioned, mentions, resolveEvaluate, _continue, contextHierarchy}) => {
-            const pathComponents = toArray(await mentions({ context: { marker: 'pathComponent' }, all: true }))
+          apply: async ({context, frameOfReference, toArray, fragments, objects, remember, recall, resolveEvaluate, _continue, contextHierarchy}) => {
+            const pathComponents = toArray(await recall({ 
+                                      context: { marker: 'pathComponent' }, 
+                                      all: true,
+                                      stopCondition: (context) => context.marker == 'startPath',
+                                   }))
             const path = (await fragments('path')).contexts()[0]
             delete path.value
+            path.instance = true
             path.points = pathComponents.reverse()
             frameOfReference(path, { mentioned: 'points', reversed: true })
-            await mentioned(path)
+            await remember(path)
 
             _continue() // let the call pick the object out from the stm
           },
@@ -1129,18 +1316,21 @@ const template = {
               return true
             }
           },
-          apply: async ({context, e, fragments, stm, toEValue, toArray, objects, mentioned, mentions, resolveEvaluate, _continue, contextHierarchy}) => {
+          apply: async ({frameOfReference, context, e, fragments, stm, toEValue, toArray, objects, remember, recall, resolveEvaluate, _continue, contextHierarchy}) => {
             const evaluated = await e({...context, notUnderCall: true})
             const pointsContext = toEValue(evaluated)
             const pathComponents = toArray(pointsContext)
 
             const path = (await fragments('path')).contexts()[0]
             delete path.value
-            path.points = pathComponents.reverse()
-            await mentioned(path)
+            path.instance = true
+            path.points = [...pathComponents]
+            frameOfReference(path, { mentioned: 'points', reversed: true })
+            await remember(path)
             resolveEvaluate(context, path)
           },
         },
+        /*
         {
           match: ({context}) => context.marker == 'thenTime',
           apply: async ({objects, api}) => {
@@ -1149,10 +1339,11 @@ const template = {
             }
           },
         },
+        */
         {
           match: ({context}) => context.evaluate && ['start', 'end'].includes(context.marker) && context.objects && context.objects[1].marker == 'path',
-          apply: async ({gp, s, context, objects, fragments, resolveEvaluate, api, mentions}) => {
-            const path = await mentions({ context: context.objects[1] })
+          apply: async ({gp, s, context, objects, fragments, resolveEvaluate, api, recall}) => {
+            const path = await recall({ context: context.objects[1] })
             if (!path?.points) {
               return
             }
@@ -1163,6 +1354,29 @@ const template = {
             }
           }
         },
+        {
+          match: ({context, contextHierarchy}) => 
+              context.evaluate && 
+              ['start', 'end', 'point'].includes(context.marker) && 
+              !context.propertyOf && 
+              contextHierarchy.under('go') &&
+              !contextHierarchy.under('call'),
+          apply: async ({gp, s, toArray, context, objects, fragments, resolveEvaluate, api, recall}) => {
+            const path = await recall({ context: { marker: 'path' } })
+            if (!path?.points) {
+              return
+            }
+            
+            if (context.marker == 'start') {
+              resolveEvaluate(context, path?.points[0])
+            } else if (context.marker == 'end') {
+              resolveEvaluate(context, path?.points[path?.points.length-1])
+            } else {
+              const points = await recall({ context, frameOfReference: path })
+              resolveEvaluate(context, toArray(points)[0])
+            }
+          }
+        },
         {
           match: ({context}) => context.marker == 'speed' && context.evaluate,
           apply: async ({gp, s, context, objects, fragments, resolveEvaluate, api}) => {
@@ -1238,6 +1452,7 @@ knowledgeModule( {
         defaultContextCheck({ marker: 'path', exported: true, 
           extra: [
             'points', 
+            'instance',
             { 
               property: 'namespaced', 
               check: [