diff --git a/src/app/rpmostree-builtin-upgrade.cxx b/src/app/rpmostree-builtin-upgrade.cxx
index 6360cbcfc3..1bc3cdb1d7 100644
--- a/src/app/rpmostree-builtin-upgrade.cxx
+++ b/src/app/rpmostree-builtin-upgrade.cxx
@@ -204,21 +204,43 @@ rpmostree_builtin_upgrade (int argc, char **argv, RpmOstreeCommandInvocation *in
       g_print ("Note: --check and --preview may be unreliable.  See "
                "https://github.com/coreos/rpm-ostree/issues/1579\n");
       g_autoptr (GVariant) cached_update = NULL;
-      if (rpmostree_os_get_has_cached_update_rpm_diff (os_proxy))
+      if (rpmostree_os_get_has_cached_update_rpm_diff (os_proxy)) {
+        g_print ("yes rpm diff.\n");
         cached_update = rpmostree_os_dup_cached_update (os_proxy);
+      }
 
-      if (!cached_update)
-        {
-          g_print ("No updates available.\n");
-          invocation->exit_code = RPM_OSTREE_EXIT_UNCHANGED;
-        }
-      else
+      g_autoptr (GVariant) cached_update_container = NULL;
+      if (rpmostree_os_get_has_cached_update_manifest_diff (os_proxy)) {
+        g_print ("yes container diff.\n");
+        cached_update_container = rpmostree_os_dup_cached_update (os_proxy);
+      }
+      
+      g_print ("exit diff checks\n");
+
+      // cached_update = rpmostree_os_dup_cached_update (os_proxy);
+
+      if (cached_update)
         {
           /* preview --> verbose (i.e. we want the diff) */
+          // if (!rpmostree_print_cached_update (cached_update, opt_preview, FALSE, cancellable,
+          //                                     error))
+          //   return FALSE;
+
           if (!rpmostree_print_cached_update (cached_update, opt_preview, FALSE, cancellable,
                                               error))
             return FALSE;
         }
+      else if (cached_update_container) {
+        if (!rpmostree_print_cached_update_container (cached_update, opt_preview, FALSE, cancellable,
+                                              error))
+            return FALSE;
+      }
+      else 
+        {
+          g_print ("No updates available.\n");
+          invocation->exit_code = RPM_OSTREE_EXIT_UNCHANGED;
+        }
+      
     }
   else if (!opt_reboot)
     {
diff --git a/src/app/rpmostree-clientlib.cxx b/src/app/rpmostree-clientlib.cxx
index 65aa33cf93..cfaefc2b42 100644
--- a/src/app/rpmostree-clientlib.cxx
+++ b/src/app/rpmostree-clientlib.cxx
@@ -1310,6 +1310,92 @@ rpmostree_print_cached_update (GVariant *cached_update, gboolean verbose,
   return TRUE;
 }
 
+gboolean
+rpmostree_print_cached_update_container (GVariant *cached_update, gboolean verbose,
+                               gboolean verbose_advisories, GCancellable *cancellable,
+                               GError **error)
+{
+  GLNX_AUTO_PREFIX_ERROR ("Retrieving cached update", error);
+
+  g_auto (GVariantDict) dict;
+  g_variant_dict_init (&dict, cached_update);
+
+  /* let's just extract 📤 all the info ahead of time */
+
+  g_autoptr (GVariant) manifest_diff
+      = g_variant_dict_lookup_value (&dict, "manifest-diff", G_VARIANT_TYPE ("a{sv}"));
+  
+  g_autoptr (GVariantIter) iter1 = NULL;
+  g_variant_get (manifest_diff, "a{sv}", &iter1);
+
+  if (!manifest_diff)
+    g_print("WE Failed");
+
+  const gchar *key;
+  const gchar *value;
+  while (g_variant_iter_loop (iter1, "{sv}", &key, &value))
+    {
+      g_print("%s", key);
+    }
+  
+  // g_auto (GVariantDict) rpm_diff_dict;
+  // g_variant_dict_init (&rpm_diff_dict, rpm_diff);
+
+  // g_autoptr (GVariant) total
+  //     = g_variant_dict_lookup_value (&rpm_diff_dict, "total_size", G_VARIANT_TYPE ("s"));
+  // if (!total)
+  //   g_print("WE Failed2");
+    // return FALSE;
+
+  // g_autoptr (GVariant) total_size = _rpmostree_vardict_lookup_value_required (
+  //     &rpm_diff_dict, "total_size", RPMOSTREE_DIFF_MODIFIED_GVARIANT_FORMAT, error);
+  // if (!total_size)
+  //   return FALSE;
+
+  // g_autoptr (GVariant) total_removed = _rpmostree_vardict_lookup_value_required (
+  //     &rpm_diff_dict, "total_removed", RPMOSTREE_DIFF_MODIFIED_GVARIANT_FORMAT, error);
+  // if (!total_removed)
+  //   return FALSE;
+
+  // g_autoptr (GVariant) removed_size = _rpmostree_vardict_lookup_value_required (
+  //     &rpm_diff_dict, "removed_size", RPMOSTREE_DIFF_MODIFIED_GVARIANT_FORMAT, error);
+  // if (!removed_size)
+  //   return FALSE;
+
+  // g_autoptr (GVariant) total_added = _rpmostree_vardict_lookup_value_required (
+  //     &rpm_diff_dict, "total_added", RPMOSTREE_DIFF_MODIFIED_GVARIANT_FORMAT, error);
+  // if (!total_added)
+  //   return FALSE;
+
+  // g_autoptr (GVariant) added_size = _rpmostree_vardict_lookup_value_required (
+  //     &rpm_diff_dict, "added_size", RPMOSTREE_DIFF_MODIFIED_GVARIANT_FORMAT, error);
+  // if (!added_size)
+  //   return FALSE;
+
+  // const gchar *tmp1;
+  // const gchar *tmp2;
+  // const gchar *tmp3;
+  // const gchar *tmp4;
+  // const gchar *tmp5;
+  // const gchar *tmp6;
+
+  // g_variant_get (total, "s", &tmp1);
+  // g_variant_get (total_size, "s", &tmp2);
+  // g_variant_get (total_removed, "s", &tmp3);
+  // g_variant_get (removed_size, "s", &tmp4);
+  // g_variant_get (total_added, "s", &tmp5);
+  // g_variant_get (added_size, "s", &tmp6);
+
+  // g_print("%s", tmp1);
+  // g_print("%s", tmp2);
+  // g_print("%s", tmp3);
+  // g_print("%s", tmp4);
+  // g_print("%s", tmp5);
+  // g_print("%s", tmp6);
+
+  return TRUE;
+}
+
 /* Query systemd for systemd unit's object path using method_name provided with
  * parameters. The reply_type of method_name must be G_VARIANT_TYPE_TUPLE. */
 gboolean
diff --git a/src/app/rpmostree-clientlib.h b/src/app/rpmostree-clientlib.h
index dd4f22c4c8..08d7a2a5f0 100644
--- a/src/app/rpmostree-clientlib.h
+++ b/src/app/rpmostree-clientlib.h
@@ -115,6 +115,10 @@ gboolean rpmostree_print_cached_update (GVariant *cached_update, gboolean verbos
                                         gboolean verbose_advisories, GCancellable *cancellable,
                                         GError **error);
 
+gboolean rpmostree_print_cached_update_container (GVariant *cached_update, gboolean verbose,
+                                        gboolean verbose_advisories, GCancellable *cancellable,
+                                        GError **error);
+
 void rpmostree_print_advisories (GVariant *advisories, gboolean verbose, guint max_key_len);
 
 gboolean get_sd_unit_objpath (GDBusConnection *connection, const char *method_name,
diff --git a/src/daemon/org.projectatomic.rpmostree1.xml b/src/daemon/org.projectatomic.rpmostree1.xml
index 7765b3fe54..f888bf4cd1 100644
--- a/src/daemon/org.projectatomic.rpmostree1.xml
+++ b/src/daemon/org.projectatomic.rpmostree1.xml
@@ -106,6 +106,7 @@
       <annotation name="org.qtproject.QtDBus.QtTypeName" value="QVariantMap"/>
     </property>
     <property name="HasCachedUpdateRpmDiff" type="b" access="read"/>
+    <property name="HasCachedUpdateManifestDiff" type="b" access="read"/>
 
     <!-- Available options:
          "mode" (type 's')
diff --git a/src/daemon/rpmostree-sysroot-upgrader.cxx b/src/daemon/rpmostree-sysroot-upgrader.cxx
index 88b4a0933f..f45989a79c 100644
--- a/src/daemon/rpmostree-sysroot-upgrader.cxx
+++ b/src/daemon/rpmostree-sysroot-upgrader.cxx
@@ -39,6 +39,9 @@
 #include "rpmostree-sysroot-upgrader.h"
 #include "rpmostreed-daemon.h"
 #include "rpmostreed-deployment-utils.h"
+// #include "rpmostreed-sysroot.cxx"
+#include "rpmostreed-transaction-types.cxx"
+// #include "rpmostreed-os.cxx"
 
 #include "ostree-repo.h"
 
@@ -401,6 +404,92 @@ rpmostree_sysroot_upgrader_get_sack (RpmOstreeSysrootUpgrader *self, GError **er
   return self->rpmmd_sack;
 }
 
+static gboolean
+refresh_cached_update_impl (RpmostreedOS *self, GVariant **out_cached_update, GError **error)
+{
+  g_autoptr (GVariant) cached_update = NULL;
+
+  /* if we're not booted into our OS, don't look at cache; it's for another OS interface */
+  const char *osname = rpmostree_os_get_name (RPMOSTREE_OS (self));
+  
+  rpmostree_output_message ("%s", osname);
+
+  OstreeSysroot *sysroot = rpmostreed_sysroot_get_root (rpmostreed_sysroot_get ());
+  OstreeDeployment *booted = ostree_sysroot_get_booted_deployment (sysroot);
+  if (!booted || !g_str_equal (osname, ostree_deployment_get_osname (booted))) {
+    rpmostree_output_message ("exit 1");
+    return TRUE; /* Note early return */
+  }
+    
+  glnx_autofd int fd = -1;
+  g_autoptr (GError) local_error = NULL;
+  rpmostree_output_message ("%s", RPMOSTREE_AUTOUPDATES_CACHE_FILE);
+  rpmostree_output_message ("%d", AT_FDCWD);
+  if (!glnx_openat_rdonly (AT_FDCWD, RPMOSTREE_AUTOUPDATES_CACHE_FILE, TRUE, &fd, &local_error))
+    {
+      if (!g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+        return g_propagate_error (error, util::move_nullify (local_error)), FALSE;
+      rpmostree_output_message ("exit 2");
+      return TRUE; /* Note early return */
+    }
+
+  /* sanity check there isn't something fishy going on before even reading it in */
+  struct stat stbuf;
+  if (!glnx_fstat (fd, &stbuf, error))
+    return FALSE;
+
+  if (!rpmostree_check_size_within_limit (stbuf.st_size, OSTREE_MAX_METADATA_SIZE,
+                                          RPMOSTREE_AUTOUPDATES_CACHE_FILE, error))
+    return FALSE;
+
+  g_autoptr (GBytes) data = glnx_fd_readall_bytes (fd, NULL, error);
+  if (!data)
+    return FALSE;
+
+  cached_update
+      = g_variant_ref_sink (g_variant_new_from_bytes (G_VARIANT_TYPE_VARDICT, data, FALSE));
+
+  /* check if cache is still valid -- see rpmostreed_update_generate_variant() */
+  g_auto (GVariantDict) dict;
+  g_variant_dict_init (&dict, cached_update);
+  auto state = static_cast<const char *> (vardict_lookup_ptr (&dict, "update-sha256", "&s"));
+  if (g_strcmp0 (state, ostree_deployment_get_csum (booted)) != 0)
+    {
+      sd_journal_print (LOG_INFO, "Deleting outdated cached update for OS '%s'", osname);
+      g_clear_pointer (&cached_update, (GDestroyNotify)g_variant_unref);
+      if (!glnx_unlinkat (AT_FDCWD, RPMOSTREE_AUTOUPDATES_CACHE_FILE, 0, error))
+        return FALSE;
+    }
+
+  *out_cached_update = util::move_nullify (cached_update);
+  rpmostree_output_message ("exit 3");
+  return TRUE;
+}
+
+static gboolean
+refresh_cached_update (RpmostreedOS *self, GError **error)
+{
+  g_autoptr (GVariant) cached_update = NULL;
+  if (!refresh_cached_update_impl (self, &cached_update, error)) {
+    rpmostree_output_message ("fail_cached_update_func");
+    return FALSE;
+  }
+  
+  rpmostree_output_message ("pass_cached_update_func");
+
+  if (cached_update != NULL) {
+    rpmostree_output_message ("yes update");
+  }
+  else {
+    rpmostree_output_message ("no update");
+  }
+
+  rpmostree_os_set_cached_update (RPMOSTREE_OS (self), cached_update);
+  rpmostree_os_set_has_cached_update_rpm_diff (RPMOSTREE_OS (self), cached_update != NULL);
+  rpmostree_os_set_has_cached_update_manifest_diff (RPMOSTREE_OS (self), cached_update != NULL);
+  return TRUE;
+}
+
 /*
  * Like ostree_sysroot_upgrader_pull(), but also handles the `baserefspec` we
  * use when doing layered packages.
@@ -448,6 +537,89 @@ rpmostree_sysroot_upgrader_pull_base (RpmOstreeSysrootUpgrader *self, const char
                 error);
 
             rpmostree_output_message ("%s", res.c_str ());
+
+            auto obj = (RpmostreedOS *)g_object_new (RPMOSTREED_TYPE_OS, "name", self->osname, NULL);
+            g_autoptr (GError) local_error = NULL;
+            // if (!refresh_cached_update (obj, &local_error))
+            //   {
+            //     sd_journal_print (LOG_WARNING, "Failed to refresh CachedUpdate property: %s",
+            //                       local_error->message);
+
+            // }
+
+            g_autoptr (RpmOstreeSysrootUpgrader) upgrader = rpmostree_sysroot_upgrader_new (
+                self->sysroot, self->osname, (RpmOstreeSysrootUpgraderFlags)0, cancellable, error);
+            if (upgrader == NULL)
+              return FALSE;
+
+            g_autoptr (OstreeDeployment) new_deployment = NULL;
+            if (!rpmostree_sysroot_upgrader_deploy (upgrader, &new_deployment, cancellable, error))
+              return FALSE;
+            
+            OstreeDeployment *booted_deployment = ostree_sysroot_get_booted_deployment (self->sysroot);
+
+            g_autoptr (DnfSack) sack = NULL;
+            if (rpmostree_origin_has_packages (self->computed_origin))
+              {
+                if (!get_sack_for_booted (self->sysroot, self->repo, booted_deployment, &sack, cancellable, error))
+                  return FALSE;
+              }
+
+            // if (!generate_update_variant (self->repo, booted_deployment, new_deployment, sack, cancellable, error))
+            // if (!generate_update_variant (self->repo, booted_deployment, NULL, NULL, TRUE, res.c_str (), cancellable, error))
+            //   return FALSE;
+
+            // auto obj = (RpmostreedOS *)g_object_new (RPMOSTREED_TYPE_OS, "name", self->osname, NULL);
+            // g_autoptr (GError) local_error = NULL;
+            if (!refresh_cached_update (obj, &local_error))
+              {
+                sd_journal_print (LOG_WARNING, "BRUH: %s",
+                                  local_error->message);
+
+            }
+
+            if (!refresh_cached_update (obj, &local_error))
+              {
+                sd_journal_print (LOG_WARNING, "BRUH 22: %s",
+                                  local_error->message);
+
+            }
+
+            // glnx_autofd int fd = -1;
+            // rpmostree_output_message ("stage 1");
+            // // g_autoptr (GError) local_error = NULL;
+            // // rpmostree_output_message ("%s", RPMOSTREE_AUTOUPDATES_CACHE_FILE);
+
+            // // /* sanity check there isn't something fishy going on before even reading it in */
+            // // struct stat stbuf;
+            // // if (!glnx_fstat (fd, &stbuf, error))
+            // //   return FALSE;
+
+            // // if (!rpmostree_check_size_within_limit (stbuf.st_size, OSTREE_MAX_METADATA_SIZE,
+            // //                                         RPMOSTREE_AUTOUPDATES_CACHE_FILE, error))
+            // //   return FALSE;
+
+            // g_autoptr (GBytes) data = glnx_fd_readall_bytes (fd, NULL, error);
+            // rpmostree_output_message ("stage 2");
+            // if (!data)
+            //   return FALSE;
+            // rpmostree_output_message ("stage 3");
+
+            // g_autoptr (GVariant) cached_update = NULL;
+            // cached_update
+            //   = g_variant_ref_sink (g_variant_new_from_bytes (G_VARIANT_TYPE_VARDICT, data, FALSE));
+            rpmostree_output_message ("pass");
+
+            g_autoptr (GVariantDict) dict = g_variant_dict_new (NULL);
+            // g_variant_dict_insert (dict, "ref-has-new-commit", "b", is_new_checksum);
+
+            g_autoptr (GPtrArray) removed = NULL;
+            g_autoptr (GPtrArray) added = NULL;
+            g_autoptr (GPtrArray) modified_old = NULL;
+            g_autoptr (GPtrArray) modified_new = NULL;
+
+
+
             *out_changed = TRUE;
             return TRUE;
           }
diff --git a/src/daemon/rpmostreed-deployment-utils.cxx b/src/daemon/rpmostreed-deployment-utils.cxx
index 4848050942..b223caf8b6 100644
--- a/src/daemon/rpmostreed-deployment-utils.cxx
+++ b/src/daemon/rpmostreed-deployment-utils.cxx
@@ -372,6 +372,7 @@ typedef struct
   GPtrArray *downgraded;
   GPtrArray *removed;
   GPtrArray *added;
+
 } RpmDiff;
 
 static void
@@ -399,6 +400,46 @@ rpm_diff_clear (RpmDiff *diff)
 
 G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC (RpmDiff, rpm_diff_clear);
 
+typedef struct
+{
+  gboolean initialized;
+  GVariant *total;
+  GVariant *total_size;
+  GVariant *total_removed;
+  GVariant *removed_size;
+  GVariant *total_added;
+  GVariant *added_size;
+} ManifestDiff;
+
+static void
+manifest_diff_init (ManifestDiff *diff)
+{
+  g_assert (!diff->initialized);
+  diff->total = g_variant_new ("s", "");
+  diff->total_size = g_variant_new ("s", "");
+  diff->total_removed = g_variant_new ("s", "");
+  diff->removed_size = g_variant_new ("s", "");
+  diff->total_added = g_variant_new ("s", "");
+  diff->added_size = g_variant_new ("s", "");
+  diff->initialized = TRUE;
+}
+
+static void
+manifest_diff_clear (ManifestDiff *diff)
+{
+  if (!diff->initialized)
+    return;
+  g_variant_ref(diff->total);
+  g_variant_ref(diff->total_size);
+  g_variant_ref(diff->total_removed);
+  g_variant_ref(diff->removed_size);
+  g_variant_ref(diff->total_added);
+  g_variant_ref(diff->added_size);
+  diff->initialized = FALSE;
+}
+
+G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC (ManifestDiff, manifest_diff_clear);
+
 static GVariant *
 single_pkg_variant_new (RpmOstreePkgTypes type, RpmOstreePackage *pkg)
 {
@@ -435,8 +476,9 @@ modified_dnfpkg_variant_new (RpmOstreePkgTypes type, RpmOstreePackage *pkg_old,
 static gboolean
 rpm_diff_add_db_diff (RpmDiff *diff, OstreeRepo *repo, RpmOstreePkgTypes type,
                       const char *old_checksum, const char *new_checksum,
-                      GPtrArray **out_modified_new, GCancellable *cancellable, GError **error)
+                      GPtrArray **out_modified_new, const gboolean is_container_refspec, std::string manifest_diff, GCancellable *cancellable, GError **error)
 {
+  rpmostree_output_message ("NOT STAGED");
   g_autoptr (GPtrArray) removed = NULL;
   g_autoptr (GPtrArray) added = NULL;
   g_autoptr (GPtrArray) modified_old = NULL;
@@ -445,14 +487,16 @@ rpm_diff_add_db_diff (RpmDiff *diff, OstreeRepo *repo, RpmOstreePkgTypes type,
   /* Use allow_noent; we'll just skip over the rpm diff if there's no data */
   RpmOstreeDbDiffExtFlags flags = RPM_OSTREE_DB_DIFF_EXT_ALLOW_NOENT;
   if (!rpm_ostree_db_diff_ext (repo, old_checksum, new_checksum, flags, &removed, &added,
-                               &modified_old, &modified_new, cancellable, error))
+                              &modified_old, &modified_new, cancellable, error))
     return FALSE;
-
   /* check if allow_noent kicked in */
   if (!removed)
     return TRUE; /* NB: early return */
+  
+  rpmostree_output_message ("NOT STAGED 3");
 
   g_assert_cmpuint (modified_old->len, ==, modified_new->len);
+
   for (guint i = 0; i < removed->len; i++)
     g_ptr_array_add (diff->removed, single_pkg_variant_new (
                                         type, static_cast<RpmOstreePackage *> (removed->pdata[i])));
@@ -471,6 +515,69 @@ rpm_diff_add_db_diff (RpmDiff *diff, OstreeRepo *repo, RpmOstreePkgTypes type,
 
   if (out_modified_new)
     *out_modified_new = util::move_nullify (modified_new);
+
+  rpmostree_output_message ("NOT STAGED 2");
+  return TRUE;
+}
+
+static gboolean
+manifest_diff_add_db_diff (ManifestDiff *diff, OstreeRepo *repo, RpmOstreePkgTypes type,
+                      const char *old_checksum, const char *new_checksum,
+                      GPtrArray **out_modified_new, const gboolean is_container_refspec, std::string manifest_diff, GCancellable *cancellable, GError **error)
+{
+  rpmostree_output_message ("NOT STAGED");
+
+  g_autoptr (GVariant) total = NULL;
+  g_autoptr (GVariant) total_size = NULL;
+  g_autoptr (GVariant) total_removed = NULL;
+  g_autoptr (GVariant) removed_size = NULL;
+  g_autoptr (GVariant) total_added = NULL;
+  g_autoptr (GVariant) added_size = NULL;
+
+  const gchar *converted_mainfest_diff = strcpy(new char[manifest_diff.length() + 1], manifest_diff.c_str());
+  if (!rpm_ostree_db_diff_ext_container (converted_mainfest_diff, &total, &total_size,
+                              &total_removed, &removed_size, &total_added, &added_size, error))
+    return FALSE;
+  rpmostree_output_message ("Exit Diff Find");
+
+  const gchar *tmp1;
+  const gchar *tmp2;
+  const gchar *tmp3;
+  const gchar *tmp4;
+  const gchar *tmp5;
+  const gchar *tmp6;
+  
+  rpmostree_output_message ("Before Prints");
+
+  g_variant_get (total, "s", &tmp1);
+  rpmostree_output_message ("%s", tmp1);
+  g_variant_get (total_size, "s", &tmp2);
+  rpmostree_output_message ("%s", tmp2);
+  g_variant_get (total_removed, "s", &tmp3);
+  rpmostree_output_message ("%s", tmp3);
+  g_variant_get (removed_size, "s", &tmp4);
+  rpmostree_output_message ("%s", tmp4);
+  g_variant_get (total_added, "s", &tmp5);
+  rpmostree_output_message ("%s", tmp5);
+  g_variant_get (added_size, "s", &tmp6);
+  rpmostree_output_message ("%s", tmp6);
+
+  diff->total = total;
+  diff->total_size = total_size;
+  diff->total_removed = total_removed;
+  diff->removed_size = removed_size;
+  diff->total_added = total_added;
+  diff->added_size = added_size;
+  
+
+  rpmostree_output_message ("After Prints");
+  // rpmostree_output_message ("%s", total_size);
+  // rpmostree_output_message ("%s", total_removed);
+  // rpmostree_output_message ("%s", removed_size);
+  // rpmostree_output_message ("%s", total_added);
+  // rpmostree_output_message ("%s", added_size);
+
+  rpmostree_output_message ("NOT STAGED 2");
   return TRUE;
 }
 
@@ -516,7 +623,13 @@ static gboolean
 rpm_diff_is_empty (RpmDiff *diff)
 {
   g_assert (diff->initialized);
-  return !diff->upgraded->len && !diff->downgraded->len && !diff->removed->len && !diff->added->len;
+  return !diff->upgraded->len && !diff->downgraded->len && !diff->removed->len && !diff->added->len ;
+}
+
+static gboolean
+manifest_diff_is_empty (ManifestDiff *diff) {
+  g_assert (diff->initialized);
+  return !diff->total && !diff->total_size && !diff->total_removed && !diff->removed_size && !diff->total_added && !diff->added_size;
 }
 
 static GVariant *
@@ -539,6 +652,23 @@ rpm_diff_variant_new (RpmDiff *diff)
   return g_variant_dict_end (&dict);
 }
 
+static GVariant *
+manifest_diff_variant_new (ManifestDiff *diff)
+{
+  rpmostree_output_message("HELLO1");
+  g_assert (diff->initialized);
+  g_auto (GVariantDict) dict;
+  g_variant_dict_init (&dict, NULL);
+  g_variant_dict_insert_value (&dict, "total", diff->total);
+  g_variant_dict_insert_value (&dict, "total_size", diff->total_size);
+  g_variant_dict_insert_value (&dict, "total_removed", diff->total_removed);
+  g_variant_dict_insert_value (&dict, "removed_size", diff->removed_size);
+  g_variant_dict_insert_value (&dict, "total_added", diff->total_added);
+  g_variant_dict_insert_value (&dict, "added_size", diff->added_size);
+  rpmostree_output_message("HELLO2");
+  return g_variant_dict_end (&dict);
+}
+
 static DnfPackage *
 find_package (DnfSack *sack, gboolean newer, RpmOstreePackage *pkg)
 {
@@ -653,7 +783,7 @@ gboolean
 rpmostreed_update_generate_variant (OstreeDeployment *booted_deployment,
                                     OstreeDeployment *staged_deployment, OstreeRepo *repo,
                                     DnfSack *sack, /* allow-none */
-                                    GVariant **out_update, GCancellable *cancellable,
+                                    GVariant **out_update, const gboolean is_container_refspec, std::string manifest_diff_string, GCancellable *cancellable,
                                     GError **error)
 {
   GLNX_AUTO_PREFIX_ERROR ("Generating update variant", error);
@@ -697,7 +827,7 @@ rpmostreed_update_generate_variant (OstreeDeployment *booted_deployment,
     }
 
   /* Graciously handle rev no longer in repo; e.g. mucking around with rebase/rollback; we
-   * still want to do the rpm-md phase. In that case, just use the current csum. */
+  * still want to do the rpm-md phase. In that case, just use the current csum. */
   gboolean is_new_checksum = FALSE;
   if (!new_base_checksum)
     new_base_checksum = current_base_checksum;
@@ -716,8 +846,8 @@ rpmostreed_update_generate_variant (OstreeDeployment *booted_deployment,
     return FALSE;
 
   /* This may seem trivial, but it's important to keep the final variant as self-contained
-   * and "diff-based" as possible, since it'll be available as a D-Bus property. This makes
-   * it easier to consume for UIs like GNOME Software and Cockpit. */
+  * and "diff-based" as possible, since it'll be available as a D-Bus property. This makes
+  * it easier to consume for UIs like GNOME Software and Cockpit. */
   g_variant_dict_insert (dict, "ref-has-new-commit", "b", is_new_checksum);
 
   g_auto (RpmDiff) rpm_diff = {
@@ -725,48 +855,70 @@ rpmostreed_update_generate_variant (OstreeDeployment *booted_deployment,
   };
   rpm_diff_init (&rpm_diff);
 
+  g_auto (ManifestDiff) manifest_diff = {
+    0,
+  };
+  manifest_diff_init (&manifest_diff);
+
   /* we'll need these later for advisories, so just keep them around */
   g_autoptr (GPtrArray) ostree_modified_new = NULL;
   g_autoptr (GPtrArray) rpmmd_modified_new = NULL;
 
   if (staged_deployment)
     {
+      rpmostree_output_message ("STAGED");
       /* ok we have a staged deployment; we just need to do a simple diff and BOOM done! */
       /* XXX: we're marking all pkgs as BASE right now even though there could be layered
-       * pkgs too -- we can tease those out in the future if needed */
+      * pkgs too -- we can tease those out in the future if needed */
       if (!rpm_diff_add_db_diff (&rpm_diff, repo, RPM_OSTREE_PKG_TYPE_BASE, current_checksum,
-                                 new_checksum, &ostree_modified_new, cancellable, error))
+                                new_checksum, &ostree_modified_new, FALSE, "", cancellable, error))
         return FALSE;
+      // g_ptr_array_remove_index (rpm_diff.upgraded, 1);
     }
   else
     {
       /* no staged deployment; we do our best to come up with a diff:
-       *  - if a new base checksum was pulled, do a db diff of the old and new bases
-       *  - if there are currently any layered pkgs, lookup in sack for newer versions
-       */
+      *  - if a new base checksum was pulled, do a db diff of the old and new bases
+      *  - if there are currently any layered pkgs, lookup in sack for newer versions
+      */
+      rpmostree_output_message ("NOT STAGED");
       if (is_new_checksum)
         {
           if (!rpm_diff_add_db_diff (&rpm_diff, repo, RPM_OSTREE_PKG_TYPE_BASE,
-                                     current_base_checksum, new_base_checksum, &ostree_modified_new,
-                                     cancellable, error))
+                                    current_base_checksum, new_base_checksum, &ostree_modified_new, FALSE,
+                                    "", cancellable, error))
             return FALSE;
         }
-
+        
+      if (is_container_refspec) {
+        rpmostree_output_message ("IS CONTAINER REFSPEC");
+          if (!manifest_diff_add_db_diff (&manifest_diff, repo, RPM_OSTREE_PKG_TYPE_BASE,
+                                    current_base_checksum, new_base_checksum, &ostree_modified_new, is_container_refspec,
+                                    manifest_diff_string, cancellable, error))
+            return FALSE;
+      }
       /* now we look at the rpm-md/layering side */
 
       /* check that it's actually layered (i.e. the requests are not all just dormant) */
       if (sack && is_new_layered && rpmostree_origin_has_packages (origin))
         {
           if (!rpmmd_diff_guess (repo, current_base_checksum, current_checksum, sack, &rpm_diff,
-                                 &rpmmd_modified_new, error))
+                                &rpmmd_modified_new, error))
             return FALSE;
         }
     }
 
   /* don't bother inserting if there's nothing new */
-  if (!rpm_diff_is_empty (&rpm_diff))
+  if (!rpm_diff_is_empty (&rpm_diff)) {
     g_variant_dict_insert (dict, "rpm-diff", "@a{sv}", rpm_diff_variant_new (&rpm_diff));
+  }
 
+  if (!manifest_diff_is_empty (&manifest_diff)) {
+    rpmostree_output_message ("DIFF EXISTS");
+    g_variant_dict_insert (dict, "mainfest-diff", "@a{sv}", manifest_diff_variant_new (&manifest_diff));
+  }
+  
+  rpmostree_output_message ("We left diff_exists");
   /* now we look for advisories */
 
   if (sack && (ostree_modified_new || rpmmd_modified_new))
@@ -778,7 +930,7 @@ rpmostreed_update_generate_variant (OstreeDeployment *booted_deployment,
       if (ostree_modified_new)
         {
           /* recall that @ostree_modified_new is an array of RpmOstreePackage; try to find
-           * the same pkg in the rpmmd so that we can search for advisories afterwards */
+          * the same pkg in the rpmmd so that we can search for advisories afterwards */
           g_autoptr (GPtrArray) pkgs = rpm_ostree_pkgs_to_dnf (sack, ostree_modified_new);
           for (guint i = 0; i < pkgs->len; i++)
             g_ptr_array_add (new_packages, g_object_ref (pkgs->pdata[i]));
@@ -802,16 +954,22 @@ rpmostreed_update_generate_variant (OstreeDeployment *booted_deployment,
     }
 
   /* but if there are no updates, then just ditch the whole thing and return NULL */
-  if (is_new_checksum || rpmmd_modified_new)
+  if ((is_new_checksum || rpmmd_modified_new))
     {
       /* include a "state" checksum for cache invalidation; for now this is just the
-       * checksum of the deployment against which we ran, though we could base it off more
-       * things later if needed */
+      * checksum of the deployment against which we ran, though we could base it off more
+      * things later if needed */
       g_variant_dict_insert (dict, "update-sha256", "s", current_checksum);
       *out_update = g_variant_ref_sink (g_variant_dict_end (dict));
     }
-  else
+  else if (is_container_refspec && !manifest_diff_is_empty (&manifest_diff)) {
+    rpmostree_output_message ("did we get here?");
+    *out_update = g_variant_dict_end (dict);
+  }
+  else {
     *out_update = NULL;
+  }
+    
 
   return TRUE;
 }
diff --git a/src/daemon/rpmostreed-deployment-utils.h b/src/daemon/rpmostreed-deployment-utils.h
index bc9a40f2b3..e820ffba25 100644
--- a/src/daemon/rpmostreed-deployment-utils.h
+++ b/src/daemon/rpmostreed-deployment-utils.h
@@ -44,7 +44,7 @@ GVariant *rpmostreed_commit_generate_cached_details_variant (OstreeDeployment *d
 
 gboolean rpmostreed_update_generate_variant (OstreeDeployment *booted_deployment,
                                              OstreeDeployment *staged_deployment, OstreeRepo *repo,
-                                             DnfSack *sack, GVariant **out_update,
+                                             DnfSack *sack, GVariant **out_update, const gboolean is_container_refspec, std::string manifest_diff,
                                              GCancellable *cancellable, GError **error);
 
 G_END_DECLS
diff --git a/src/daemon/rpmostreed-os.cxx b/src/daemon/rpmostreed-os.cxx
index 52185c663b..7e0e5ec999 100644
--- a/src/daemon/rpmostreed-os.cxx
+++ b/src/daemon/rpmostreed-os.cxx
@@ -471,6 +471,7 @@ static void
 on_auto_update_done (RpmostreedTransaction *transaction, RpmostreedOS *self)
 {
   g_autoptr (GError) local_error = NULL;
+  rpmostree_output_message("refresh 2");
   if (!refresh_cached_update (self, &local_error))
     {
       sd_journal_print (LOG_WARNING, "Failed to refresh CachedUpdate property: %s",
@@ -1903,7 +1904,7 @@ refresh_cached_update_impl (RpmostreedOS *self, GVariant **out_cached_update, GE
       g_clear_pointer (&cached_update, (GDestroyNotify)g_variant_unref);
       if (!glnx_unlinkat (AT_FDCWD, RPMOSTREE_AUTOUPDATES_CACHE_FILE, 0, error))
         return FALSE;
-    }
+  }
 
   *out_cached_update = util::move_nullify (cached_update);
   return TRUE;
@@ -1912,12 +1913,24 @@ refresh_cached_update_impl (RpmostreedOS *self, GVariant **out_cached_update, GE
 static gboolean
 refresh_cached_update (RpmostreedOS *self, GError **error)
 {
+  rpmostree_output_message("enter refresh");
   g_autoptr (GVariant) cached_update = NULL;
-  if (!refresh_cached_update_impl (self, &cached_update, error))
+  if (!refresh_cached_update_impl (self, &cached_update, error)) {
+    rpmostree_output_message ("fail_cached_update_func");
     return FALSE;
+  }
+  
+  rpmostree_output_message ("pass_cached_update_func");
 
+  if (cached_update != NULL) {
+    rpmostree_output_message ("yes update");
+  }
+  else {
+    rpmostree_output_message ("no update");
+  }
   rpmostree_os_set_cached_update (RPMOSTREE_OS (self), cached_update);
   rpmostree_os_set_has_cached_update_rpm_diff (RPMOSTREE_OS (self), cached_update != NULL);
+  rpmostree_os_set_has_cached_update_manifest_diff (RPMOSTREE_OS (self), cached_update != NULL);
   return TRUE;
 }
 
@@ -1976,6 +1989,7 @@ rpmostreed_os_load_internals (RpmostreedOS *self, GError **error)
     rollback_variant = rpmostreed_deployment_generate_blank_variant ();
   rpmostree_os_set_rollback_deployment (RPMOSTREE_OS (self), rollback_variant);
 
+  rpmostree_output_message("refresh 2");
   if (!refresh_cached_update (self, error))
     return FALSE;
 
diff --git a/src/daemon/rpmostreed-transaction-types.cxx b/src/daemon/rpmostreed-transaction-types.cxx
index b0c4030a7d..8c92f82bd6 100644
--- a/src/daemon/rpmostreed-transaction-types.cxx
+++ b/src/daemon/rpmostreed-transaction-types.cxx
@@ -216,7 +216,8 @@ apply_revision_override (RpmostreedTransaction *transaction, OstreeRepo *repo,
 
   return TRUE;
 }
-
+#include <iostream>
+#include <fstream>
 /* Generates the update GVariant and caches it to disk. This is set as the CachedUpdate
  * property of RPMOSTreeOS by refresh_cached_update, but we calculate during transactions
  * only, since it's potentially costly to do. See:
@@ -224,11 +225,15 @@ apply_revision_override (RpmostreedTransaction *transaction, OstreeRepo *repo,
 static gboolean
 generate_update_variant (OstreeRepo *repo, OstreeDeployment *booted_deployment,
                          OstreeDeployment *staged_deployment, DnfSack *sack, /* allow-none */
-                         GCancellable *cancellable, GError **error)
+                         const gboolean is_container_refspec, std::string manifest_diff, GCancellable *cancellable, GError **error)
 {
   if (!glnx_shutil_mkdir_p_at (AT_FDCWD, dirname (strdupa (RPMOSTREE_AUTOUPDATES_CACHE_FILE)), 0775,
-                               cancellable, error))
-    return FALSE;
+                               cancellable, error)) 
+    {
+      rpmostree_output_message ("update variant 1");
+      return FALSE;
+    }
+    
 
   /* always delete first since we might not be replacing it at all */
   if (!glnx_shutil_rm_rf_at (AT_FDCWD, RPMOSTREE_AUTOUPDATES_CACHE_FILE, cancellable, error))
@@ -236,18 +241,34 @@ generate_update_variant (OstreeRepo *repo, OstreeDeployment *booted_deployment,
 
   g_autoptr (GVariant) update = NULL;
   if (!rpmostreed_update_generate_variant (booted_deployment, staged_deployment, repo, sack,
-                                           &update, cancellable, error))
-    return FALSE;
+                                           &update, is_container_refspec, manifest_diff, cancellable, error))
+    {
+      rpmostree_output_message ("update variant 2");
+      return FALSE;
+    }
+  rpmostree_output_message ("We made it out here");
 
   if (update != NULL)
     {
+      rpmostree_output_message ("enter EXISTS");
+       rpmostree_output_message ("%s", RPMOSTREE_AUTOUPDATES_CACHE_FILE);
       if (!glnx_file_replace_contents_at (AT_FDCWD, RPMOSTREE_AUTOUPDATES_CACHE_FILE,
                                           static_cast<const guint8 *> (g_variant_get_data (update)),
                                           g_variant_get_size (update),
                                           static_cast<GLnxFileReplaceFlags> (0), cancellable,
                                           error))
-        return FALSE;
+        {
+          rpmostree_output_message ("update variant 3");
+          return FALSE;
+        }
+      rpmostree_output_message ("before file check");
+      std::ifstream infile("/var/cache/rpm-ostree/cached-update.gv");
+      rpmostree_output_message ("%d", infile.good());
+
+      rpmostree_output_message ("update EXISTS");
     }
+  
+  rpmostree_output_message ("no fails");
 
   return TRUE;
 }
@@ -359,15 +380,16 @@ package_diff_transaction_execute (RpmostreedTransaction *transaction, GCancellab
 
   if (upgrading)
     {
+      rpmostree_output_message ("Enter Upgrading");
       /* For backwards compatibility, we still need to make sure the CachedUpdate property
        * is updated here. To do this, we cache to disk in libostree mode (no DnfSack), since
        * that's all we updated here. This conflicts with auto-updates for now, though we
        * need better test coverage before uniting those two paths. */
       OstreeDeployment *booted_deployment = ostree_sysroot_get_booted_deployment (sysroot);
-      if (!generate_update_variant (repo, booted_deployment, NULL, NULL, cancellable, error))
+      if (!generate_update_variant (repo, booted_deployment, NULL, NULL, FALSE, "", cancellable, error))
         return FALSE;
     }
-
+  rpmostree_output_message ("Exit ALL");
   return TRUE;
 }
 
@@ -1549,9 +1571,17 @@ deploy_transaction_execute (RpmostreedTransaction *transaction, GCancellable *ca
           if (!get_sack_for_booted (sysroot, repo, booted_deployment, &sack, cancellable, error))
             return FALSE;
         }
-
-      if (!generate_update_variant (repo, booted_deployment, NULL, sack, cancellable, error))
-        return FALSE;
+      
+      auto r = rpmostree_origin_get_refspec (origin);
+      rpmostree_output_message ("We got here");
+      std::ifstream infile("/var/cache/rpm-ostree/cached-update.gv");
+      rpmostree_output_message ("%d", infile.good());
+      // if (r.kind != rpmostreecxx::RefspecType::Container) {
+        if (!generate_update_variant (repo, booted_deployment, NULL, sack, FALSE, "", cancellable, error))
+          return FALSE;
+      // }
+      rpmostree_output_message ("We left here");
+      
 
       /* Note early return */
       return TRUE;
@@ -1610,7 +1640,7 @@ deploy_transaction_execute (RpmostreedTransaction *transaction, GCancellable *ca
           OstreeDeployment *booted_deployment = ostree_sysroot_get_booted_deployment (sysroot);
 
           DnfSack *sack = rpmostree_sysroot_upgrader_get_sack (upgrader, error);
-          if (!generate_update_variant (repo, booted_deployment, new_deployment, sack, cancellable,
+          if (!generate_update_variant (repo, booted_deployment, new_deployment, sack, FALSE, "", cancellable,
                                         error))
             return FALSE;
         }
diff --git a/src/lib/rpmostree-db.c b/src/lib/rpmostree-db.c
index d9ceb74970..549513e61c 100644
--- a/src/lib/rpmostree-db.c
+++ b/src/lib/rpmostree-db.c
@@ -155,3 +155,50 @@ rpm_ostree_db_diff_ext (OstreeRepo *repo, const char *orig_ref, const char *new_
   return _rpm_ostree_diff_package_lists (orig_pkglist, new_pkglist, out_removed, out_added,
                                          out_modified_old, out_modified_new, NULL);
 }
+
+#include <stdio.h>
+gboolean
+rpm_ostree_db_diff_ext_container (const gchar* manifest_diff, GVariant **total,
+                        GVariant **total_size, GVariant **total_removed,
+                        GVariant **removed_size, GVariant **total_added,
+                        GVariant **added_size, GError **error)
+{
+  char *end_str;
+  char *outer_token = strtok_r(manifest_diff, ",", &end_str);
+
+  while (outer_token != NULL) {
+      char *end_token;
+      char *inner_token = strtok_r(outer_token, ":", &end_token);
+      
+      while (inner_token != NULL) {
+        
+        if (!strcmp(inner_token, "total")) {
+          inner_token = strtok_r(NULL, ":", &end_token);
+          *total = g_variant_new("s", inner_token);
+        }
+        else if (!strcmp(inner_token, "total_size")) {
+          inner_token = strtok_r(NULL, ":", &end_token);
+          *total_size = g_variant_new("s", inner_token);
+        }
+        else if (!strcmp(inner_token, "total_removed")) {
+          inner_token = strtok_r(NULL, ":", &end_token);
+          *total_removed = g_variant_new("s", inner_token);
+        }
+        else if (!strcmp(inner_token, "removed_size")) {
+          inner_token = strtok_r(NULL, ":", &end_token);
+          *removed_size = g_variant_new("s", inner_token);
+        }
+        else if (!strcmp(inner_token, "total_added")) {
+          inner_token = strtok_r(NULL, ":", &end_token);
+          *total_added = g_variant_new("s", inner_token);
+        }
+        else if (!strcmp(inner_token, "added_size")) {
+          inner_token = strtok_r(NULL, ":", &end_token);
+          *added_size = g_variant_new("s", inner_token);
+        }
+        inner_token = strtok_r(NULL, ":", &end_token);
+      }
+      outer_token = strtok_r(NULL, ",", &end_str);
+  }
+  return TRUE;
+}
diff --git a/src/lib/rpmostree-db.h b/src/lib/rpmostree-db.h
index 839ad832be..455a282a26 100644
--- a/src/lib/rpmostree-db.h
+++ b/src/lib/rpmostree-db.h
@@ -52,4 +52,10 @@ _RPMOSTREE_EXTERN gboolean rpm_ostree_db_diff_ext (
     OstreeRepo *repo, const char *orig_ref, const char *new_ref, RpmOstreeDbDiffExtFlags flags,
     GPtrArray **out_removed, GPtrArray **out_added, GPtrArray **out_modified_old,
     GPtrArray **out_modified_new, GCancellable *cancellable, GError **error);
+
+_RPMOSTREE_EXTERN gboolean rpm_ostree_db_diff_ext_container (
+    const gchar *manifest_diff, GVariant **total, GVariant **total_size,
+    GVariant **total_removed, GVariant **removed_size, GVariant **total_added,
+    GVariant**added_size, GError **error);
+
 G_END_DECLS