diff --git a/libs/permissions/permissionLogic/src/lib/permission-logic.spec.ts b/libs/permissions/permissionLogic/src/lib/permission-logic.spec.ts
index 9030f08..95bb08a 100644
--- a/libs/permissions/permissionLogic/src/lib/permission-logic.spec.ts
+++ b/libs/permissions/permissionLogic/src/lib/permission-logic.spec.ts
@@ -29,19 +29,130 @@ import {
   permissionMonitoringMachine,
 } from './permissionMonitor.machine';
 
+const permissionReportingMachine = setup({
+  types: {
+    input: {} as {
+      permissions: Array<Permission>;
+      parent: AnyActorRef;
+    },
+    context: {} as {
+      permissions: Array<Permission>;
+      parent: AnyActorRef;
+    },
+  },
+  actions: {
+    sendSubscriptionRequestForStatusUpdates: sendTo(
+      ({ system }) => {
+        const actorRef: AnyActorRef = system.get(
+          ActorSystemIds.permissionMonitoring
+        );
+        return actorRef;
+      },
+      ({ self, context }) => ({
+        type: 'subscribeToPermissionStatuses',
+        permissions: context.permissions,
+        self,
+      })
+    ),
+    // satisfies /*TODO type these events to the receiving machine event type*/ AnyEventObject);
+    checkedSendParent: enqueueActions(
+      ({ context, enqueue }, event: AnyEventObject) => {
+        if (!context.parent) {
+          console.log(
+            'WARN: an attempt to send an event to a non-existent parent'
+          );
+          return;
+        }
+
+        enqueue.sendTo(context.parent, event);
+      }
+    ),
+  },
+}).createMachine({
+  description:
+    "This actor's job is to report permission statuses to the actors that have invoked it. We abstract away this functionality so that it is reusable by any actor that needs it and so they don't need to know how permissions are checked. This keeps control centralized and easy to modify the behavior of.",
+  context: ({ input }) => ({
+    permissions: input.permissions,
+    parent: input.parent,
+  }),
+  entry: [
+    'sendSubscriptionRequestForStatusUpdates',
+    log('subscribe to status updates'),
+  ],
+  on: {
+    requestPermission: {
+      actions: [
+        sendTo(
+          ({ system }) => {
+            return system.get(ActorSystemIds.permissionCheckerAndRequester);
+          },
+          ({ event }) => ({
+            type: 'triggerPermissionRequest',
+            permission: event.permission,
+          })
+        ),
+      ],
+    },
+    permissionStatusChanged: {
+      description:
+        'Whenever the Permission Monitoring machine reports that a permission status has changed, we receive this event and can process and share with our siblings.',
+      // We eventually want to communicate this to the actors that have invoked us
+      actions: [
+        log(
+          ({ event }) =>
+            event.permission + ' status <<<changed' + ' to ' + event.status
+        ),
+
+        {
+          /**
+           * I tried putting this action in the actions in setup as reportPermissionRequestResult
+           * as an action, but it requied
+           * use of checkedSendParent and ran into this error when attempting to use that
+           *
+           * in onDone, but it didn't work
+           *
+           * error: Type '"checkedSendParent"' is not assignable to type '"triggerPermissionRequest"'.ts(2322)
+           */
+          type: 'checkedSendParent',
+          params({ event }) {
+            const { permission, status } = event;
+            if (permission === Permissions.bluetooth && status === 'granted') {
+              console.log('its granted yaya');
+              return {
+                // TODO make these type safe
+                // dynamic
+                type: 'permission.granted.bluetooth',
+              };
+            } else {
+              return {
+                type: 'permission.denied.bluetooth',
+              };
+            }
+          },
+        },
+      ],
+    },
+  },
+});
+
 const forever = 2 ^ (28 - 1);
 const countingMachineThatNeedsPermissionAt3 = setup({
+  actors: {
+    permissionReportingMachine,
+  },
   types: {
     context: {} as { count: number; permissionStatus: PermissionStatus },
     events: { type: 'count.inc' },
   },
 }).createMachine({
+  /** @xstate-layout N4IgpgJg5mDOIC5QGMD2BXAdgFwJaagEFMIAFMAJwFtdZZdVNYA6NLPA5sTAQwCMANpADEbHM3zIA2gAYAuolAAHVPTyNFIAB6IA7ACYANCACeiAIwBWc8xl27AZhm6rDpw4C+H42I5ES5NS09IwsvvhQXLyCIr4SmNLmCkggKmoMmJo6CPoAHA7M1pYAbM4AnLoOLpZGpoj61sxllg7mVZbN5gYALLle3iCYqBBwmuEExGSUNHQZ8ClpuOqZKdkAtPrdzMWWuboyZeZlZd1lDsUOxmYIG1v2Mm0uus1l+vpePhg4EZOBMyFMVhfPyaRbLLL1bpXRAXZinY4nCoOMoPGTdYofEDjfxTIKzUJA9gRKL8IQQUGqJYZCEIcz6GyWXTdfQHBo7GrQnI1OEtR4daw9PoDbG-abBOaE76cCC0UmQCnpDSrRA1XLMLplYq5Rn6E7o4qchr6HmtGTWc7dbqtTEigJi-GAgAWPBIAgif3FoQVVKVoGy+gKDm6dJRuTslhkF10nIcuTVEZkbhkuU1Vt0uW6NuBPzteIBLGdrvd9vzEggQm94OVCHT23ZZv2lUeBrqCG6umKtjs+mKums7e6JUzwuzE1z-wlhfLxbzEp4yDwADcwJXqdWXMwgyHk+HI1VOS0tgm8marMdzEKvEA */
   type: 'parallel',
   id: 'countingAndPermissions',
   context: {
     count: 0,
     permissionStatus: PermissionStatuses.unasked,
   },
+
   states: {
     counting: {
       initial: 'enabled',
@@ -55,51 +166,61 @@ const countingMachineThatNeedsPermissionAt3 = setup({
               },
 
               {
-                target: ['disabled', '#permissionHandler.active'],
+                target: ['disabled'],
               },
             ],
           },
         },
-        disabled: { id: 'countingDisabled' },
+        disabled: {
+          id: 'countingDisabled',
+          on: {
+            'permission.granted.bluetooth': { target: 'enabled' },
+            'permission.denied.bluetooth': { target: 'bluetoothDenied' },
+            'user.didTapBluetoothRequestPermission': {
+              actions: raise({
+                type: 'permissionWasRequested',
+                // @ts-expect-error TODO make this type safe
+                permission: Permissions.bluetooth,
+              }),
+            },
+          },
+        },
+        bluetoothDenied: {
+          on: {
+            'permission.granted.bluetooth': { target: 'enabled' },
+            'user.didTapBluetoothRequestPermission': {
+              actions: raise({
+                type: 'permissionWasRequested',
+                // @ts-expect-error TODO make this type safe
+                permission: Permissions.bluetooth,
+              }),
+            },
+          },
+        },
       },
     },
 
     handlingPermissions: {
-      description:
-        'This state is a placeholder for designing' +
-        'how we will allow feature machines to handle their ' +
-        "permissions. Right now we're doing everything inline" +
-        'but this will be extracted to something that is ' +
-        'straightforward for the end developer to use and test',
-      id: 'permissionHandler',
-      /**
-       * what should go here....
-       *
-       * 1) This might need to be a parallel state machine if we want to
-       * have a functionality for handling revoked permissions
-       *
-       * - we need to handle
-       * permission granted,
-       * permission denied,
-       * permission revoked (optional) if not you have a bug [EXCLUDE for iteration 1]
-       *
-       * 🤔 Thoughts:
-       * This could just be an actor we invoke that communicates
-       * up to the permission monitoring machine...
-       *  input: [permission]
-       *
-       *
-       */
-      // invoke: {
-      //   src: 'permissionReportingMAchine'
-      //   input: {
-      //     permissions: [Permissions.bluetooth]
-      // }
-
-      initial: 'idle',
-      states: {
-        idle: {},
-        active: {},
+      on: {
+        permissionWasRequested: {
+          actions: [
+            sendTo('permissionHandler', ({ event }) => {
+              return {
+                type: 'requestPermission',
+                // @ts-expect-error TODO make this type safe
+                permission: event.permission,
+              };
+            }),
+          ],
+        },
+      },
+      invoke: {
+        id: 'permissionHandler',
+        src: 'permissionReportingMachine',
+        input: ({ self }) => ({
+          permissions: [Permissions.bluetooth],
+          parent: self,
+        }),
       },
     },
   },
@@ -118,13 +239,13 @@ describe('Counting Machine That Needs Permission At 3', () => {
     expect(countingActor.getSnapshot().context.count).toBe(3);
     expect(countingActor.getSnapshot().value).toStrictEqual({
       counting: 'enabled',
-      handlingPermissions: 'idle',
+      handlingPermissions: {},
     });
 
     countingActor.send({ type: 'count.inc' });
     expect(countingActor.getSnapshot().value).toStrictEqual({
       counting: 'disabled',
-      handlingPermissions: 'active',
+      handlingPermissions: {},
     });
     expect(countingActor.getSnapshot().context.count).toBe(3);
 
@@ -140,7 +261,7 @@ describe('Counting Machine That Needs Permission At 3', () => {
     ).start();
     expect(countingActor.getSnapshot().value).toStrictEqual({
       counting: 'enabled',
-      handlingPermissions: 'idle',
+      handlingPermissions: {},
     });
   });
 
@@ -345,134 +466,15 @@ describe('Permission Monitoring Machine', () => {
       );
     });
 
-    const permissionReportingMachine = setup({
-      types: {
-        input: {} as {
-          permissions: Array<Permission>;
-          parent: AnyActorRef;
-        },
-        context: {} as {
-          permissions: Array<Permission>;
-          parent: AnyActorRef;
-        },
-      },
-      actions: {
-        sendSubscriptionRequestForStatusUpdates: sendTo(
-          ({ system }) => {
-            const actorRef: AnyActorRef = system.get(
-              ActorSystemIds.permissionMonitoring
-            );
-            return actorRef;
-          },
-          ({ self, context }) => ({
-            type: 'subscribeToPermissionStatuses',
-            permissions: context.permissions,
-            self,
-          })
-        ),
-        // satisfies /*TODO type these events to the receiving machine event type*/ AnyEventObject);
-        checkedSendParent: enqueueActions(
-          ({ context, enqueue }, event: AnyEventObject) => {
-            if (!context.parent) {
-              console.log(
-                'WARN: an attempt to send an event to a non-existent parent'
-              );
-              return;
-            }
-
-            enqueue.sendTo(context.parent, event);
-          }
-        ),
-      },
-    }).createMachine({
-      description:
-        "This actor's job is to report permission statuses to the actors that have invoked it. We abstract away this functionality so that it is reusable by any actor that needs it and so they don't need to know how permissions are checked. This keeps control centralized and easy to modify the behavior of.",
-      id: ActorSystemIds.permissionReporting,
-      context: ({ input }) => ({
-        permissions: input.permissions,
-        parent: input.parent,
-      }),
-      entry: [
-        'sendSubscriptionRequestForStatusUpdates',
-        log('subscribe to status updates'),
-      ],
-      on: {
-        requestPermission: {
-          actions: [
-            sendTo(
-              ({ system }) => {
-                return system.get(ActorSystemIds.permissionCheckerAndRequester);
-              },
-              ({ event }) => ({
-                type: 'triggerPermissionRequest',
-                permission: event.permission,
-              })
-            ),
-          ],
-        },
-        permissionStatusChanged: {
-          description:
-            'Whenever the Permission Monitoring machine reports that a permission status has changed, we receive this event and can process and share with our siblings.',
-          // We eventually want to communicate this to the actors that have invoked us
-          actions: [
-            log(
-              ({ event }) =>
-                event.permission + ' status <<<changed' + ' to ' + event.status
-            ),
-
-            {
-              /**
-               * I tried putting this action in the actions in setup as reportPermissionRequestResult
-               * as an action, but it requied
-               * use of checkedSendParent and ran into this error when attempting to use that
-               *
-               * in onDone, but it didn't work
-               *
-               * error: Type '"checkedSendParent"' is not assignable to type '"triggerPermissionRequest"'.ts(2322)
-               */
-              type: 'checkedSendParent',
-              params({ event }) {
-                const { permission, status } = event;
-                if (
-                  permission === Permissions.bluetooth &&
-                  status === 'granted'
-                ) {
-                  console.log('its granted yaya');
-                  return {
-                    // dynamic
-                    type: 'permission.granted.bluetooth',
-                  };
-                } else {
-                  return {
-                    type: 'permission.denied.bluetooth',
-                  };
-                }
-              },
-            },
-          ],
-        },
-      },
-    });
-
     const someFeatureMachine = setup({
       actors: {
         permissionReportingMachine,
       },
     }).createMachine({
+      /** @xstate-layout N4IgpgJg5mDOIC5SwPYFswDEwEMAuArgE5gCyOAxgBYCWAdmAJIQB0ANilFPVAMQBUAbQAMAXUSgADilg08NFHQkgAHogCcANgAsLbZuHqAzAA4TAdm2GArEYA0IAJ6Ijw83vOv1AJmEBGa28THwBfEIdUDGx8YjJKWgZmFgAzFBQWWDwcIjxeKBQAFRQAdRw5HkwUIgAFMCI0GlhZRRFxJBBpWXlFZTUEb1cWdVs-XyNjYWtrP20HZwRNb3dF41MjJe9fPzCI9CxcQhJyanomVlT0gHcy+TooSpq6hqaFOl5JJ8bmuhYoIhw6HhICwAEZsAhgPBpPBUVrKTrlHrtPomIyaFjmYLCCxBdSTEx+OaIczWdH6byaSmGExubTbcIgSL7GJHeKnJIXFjXcp3B61epfV7vT4vRQsCBgOg0YFgiFQlAwuHtBHdJTIxCo9GYvE4rHWAlEhZBPSLTTmPxUqZGaw7Rl7aKHOInRLnNJcm4VKr857fXgEWB1cU0CAFHCSABC4Mh0KoACUwABHCGZb2ClpieEyRFq0B9bQmbwmizmbzGSwDayG2xGIYU7x+C3mTFmoy2pkO2LHBJnFJu2XRhVUAAikulEGFAtFPz+AKBrH78sVGeVWdVvUQM001hY3m0m2Em2tQQLhs01oxozNB806lWmjb9oOnbZLt76QXMZHUsgfoDRCDIZhpGcoxvGSZwHgqZTkqUirq864IA2fjCLWfhmJimq2OYVZGLoJLDNo1j+KMwiTA+URPqyzo9lQAIQGwPBQd8sATj6rylLAYHJnOMEdHBSK5hq6i6HuaHmn41pWPqhoEiw0y3gpdJmIE5hhAydAoBK8DtO2lFOt2zCZl08HqggAC0u6GmZ27qDSpH2Q5pHaORzKOl27KsBwXA8EZ2YIdo2FOIgUm1osvhuOo5ikcMLkdlRBmuigvlrqZllBQg2j6HodYNp41i2d4sV6e5r6cpk2R4MlJmCQgJansIugrNayEmHuwhnkVLL6R5b7ujy9xeiK3xVQJqiIFMuh+MM6w6FNSw3qe55GOYd7GFSwitgyuldSVPach+g4AOL-ICkAjTmY2IZYujLURB4FrZrWnnuLBNUsyGEZM9K7BRO0vntfZRouw6jmdK7GaNfQkShzX6iSpImNY+iLei9YUlFFK3kYaKdW5-1JLRdD0YxQ2vNpsEQxdeaBfMaGFpFRijIEpGaGhm1hEAA */
       id: 'someFeatureMachineId',
       type: 'parallel',
       states: {
-        logging: {
-          on: {
-            '*': {
-              actions: [
-                ({ event }) => {
-                  console.log('logging::::' + JSON.stringify(event, null, 2));
-                },
-              ],
-            },
-          },
-        },
         foo: {
           initial: 'start',
           states: {
@@ -553,7 +555,7 @@ describe('Permission Monitoring Machine', () => {
 
         const id =
           state.context.permissionSubscribers[Permissions.bluetooth][0].id;
-        console.log({ id });
+        expect(id).toBe('permissionHandler');
       });
 
       it('should notify subscribers of changes to permissions', async () => {
@@ -582,7 +584,6 @@ describe('Permission Monitoring Machine', () => {
         expect(featureMachineActor?.getSnapshot().value).toStrictEqual({
           foo: 'waitingForPermission',
           handlingPermissions: {},
-          logging: {},
         });
 
         expect(permissionMonitorActor.getSnapshot().value).toStrictEqual({
@@ -599,7 +600,7 @@ describe('Permission Monitoring Machine', () => {
         const permissionCheckerActor =
           permissionMonitorActor.getSnapshot().children[
             ActorSystemIds.permissionCheckerAndRequester
-          ];
+          ]!;
 
         expect(permissionCheckerActor?.getSnapshot().value).toBe(
           'checkingPermissions'
@@ -618,7 +619,6 @@ describe('Permission Monitoring Machine', () => {
         expect(featureMachineActor?.getSnapshot().value).toStrictEqual({
           foo: 'bluetoothDenied',
           handlingPermissions: {},
-          logging: {},
         });
 
         // await waitFor(featureMachineActor, (state) => {
@@ -640,7 +640,6 @@ describe('Permission Monitoring Machine', () => {
         expect(featureMachineActor?.getSnapshot().value).toStrictEqual({
           foo: 'bluetoothGranted',
           handlingPermissions: {},
-          logging: {},
         });
         // await new Promise((resolve) => setTimeout(resolve, forever));
       });
@@ -763,6 +762,6 @@ describe('Permission Monitoring Machine', () => {
 
   it('should immediately report back to parent if permission is already granted', async () => {});
   describe('Blocked Permission', () => {
-    it('should immediately report back to parent if permission is already granted', async () => {});
+    it('should immediately report back to parent if permission is blocked', async () => {});
   });
 });
diff --git a/libs/permissions/permissionLogic/src/lib/permissionMonitor.machine.ts b/libs/permissions/permissionLogic/src/lib/permissionMonitor.machine.ts
index a232467..68c2041 100644
--- a/libs/permissions/permissionLogic/src/lib/permissionMonitor.machine.ts
+++ b/libs/permissions/permissionLogic/src/lib/permissionMonitor.machine.ts
@@ -104,6 +104,7 @@ export const permissionMonitoringMachine = setup({
   type: 'parallel',
 
   // TODO: this should live at the top level of the application, not here
+  // https://jabraenhance.atlassian.net/browse/JES-3817
   invoke: [
     {
       src: 'features',