# 
# 
# patch "commands.cc"
#  from [52977ffa0b3d2e9519214050ed4ce7c0648e9ac3]
#    to [79d1f15df92d76c6006d52d87ccf1a0198107147]
# 
# patch "restrictions.cc"
#  from [99587c2d19e7554350c96be42ae45cb87f2943e8]
#    to [1598e20a0a9e11d51c97fb493b5ac9452ce09135]
# 
# patch "restrictions.hh"
#  from [4bb92e680ba4588a887cdaaf91f392767d924ecd]
#    to [68df5137976d04348d5a0a7a965254cb2664b32c]
# 
# patch "roster.cc"
#  from [4bec0e6ca6cc5cb0f64abf3a8385fb02070ff17b]
#    to [e11e0e8bae48e82f02d190dc889157dc8b6ea0aa]
# 
# patch "roster.hh"
#  from [a044f3d270422283c51b933cf62a15ee01bd629b]
#    to [cd52bc9735826753c3320caa147fed044e5fdae5]
# 
# patch "tests/t_restrictions.at"
#  from [84972130299ee9cc3449101f4a4135795cf863f0]
#    to [ca23ce3a30758abad47e9919544b743130bb66de]
# 
# patch "tests/t_revert.at"
#  from [243cf86fd8d0335298446ea299b099540e206cfb]
#    to [e6f8b570d747a39a35865d3d072e4d34e72b86f1]
# 
# patch "work.cc"
#  from [ea83b9e5b2cc4d2990686d63454c37c414fa118e]
#    to [a043cb7bf631ed4519986fd5e518926d74b67ca2]
# 
# patch "work.hh"
#  from [81add376cf6c2448fa5d48c117b6b472d02def69]
#    to [410b69b097ae15b89d9b80b3973d4f57b2a5d43e]
# 
============================================================
--- commands.cc	52977ffa0b3d2e9519214050ed4ce7c0648e9ac3
+++ commands.cc	79d1f15df92d76c6006d52d87ccf1a0198107147
@@ -2682,8 +2682,9 @@
     OPT_UNIFIED_DIFF % OPT_CONTEXT_DIFF % OPT_EXTERNAL_DIFF %
     OPT_EXTERNAL_DIFF_ARGS)
 {
-  revision_set r_old, r_new;
+  path_set paths;
   roster_t new_roster, old_roster;
+  temp_node_id_source nis;
   bool new_is_archived;
   diff_type type = app.diff_format;
   ostringstream header;
@@ -2693,7 +2694,7 @@
       F("--diff-args requires --external\n"
         "try adding --external or removing --diff-args?"));
 
-  cset composite;
+  cset included;
   cset excluded;
 
   // initialize before transaction so we have a database to work with
@@ -2703,19 +2704,29 @@
   else if (app.revision_selectors.size() == 1)
     app.require_working_copy();
 
+  for (vector<utf8>::const_iterator i = args.begin(); i != args.end(); ++i)
+    {
+      split_path sp;
+      file_path_external(*i).split(sp);
+      paths.insert(sp);
+    }
+
   if (app.revision_selectors.size() == 0)
     {
-      get_working_revision_and_rosters(app, args, r_new,
-                                       old_roster, 
-                                       new_roster,
-                                       excluded);
+      get_base_and_current_roster_shape(old_roster, new_roster, nis, app);
 
-      I(r_new.edges.size() == 1 || r_new.edges.size() == 0);
-      if (r_new.edges.size() == 1)
-        composite = edge_changes(r_new.edges.begin());
-      new_is_archived = false;
       revision_id old_rid;
       get_revision_id(old_rid);
+
+      restriction mask;
+      mask.add_nodes(old_roster, paths);
+      mask.add_nodes(new_roster, paths);
+
+      update_working_roster_from_filesystem(new_roster, mask, app);
+
+      make_restricted_csets(old_roster, new_roster, included, excluded, mask);
+
+      new_is_archived = false;
       header << "# old_revision [" << old_rid << "]" << endl;
     }
   else if (app.revision_selectors.size() == 1)
@@ -2724,56 +2735,69 @@
       complete(app, idx(app.revision_selectors, 0)(), r_old_id);
       N(app.db.revision_exists(r_old_id),
         F("no such revision '%s'") % r_old_id);
-      get_working_revision_and_rosters(app, args, r_new,
-                                       old_roster, 
-                                       new_roster,
-                                       excluded);
+
+      get_base_and_current_roster_shape(old_roster, new_roster, nis, app);
       // Clobber old_roster with the one specified
-      app.db.get_revision(r_old_id, r_old);
       app.db.get_roster(r_old_id, old_roster);
-      I(r_new.edges.size() == 1 || r_new.edges.size() == 0);
-      N(r_new.edges.size() == 1, F("current revision has no ancestor"));
+
+      // FIXME: handle no ancestor case
+      // N(r_new.edges.size() == 1, F("current revision has no ancestor"));
+
+      restriction mask;
+      mask.add_nodes(old_roster, paths);
+      mask.add_nodes(new_roster, paths);
+      
+      update_working_roster_from_filesystem(new_roster, mask, app);
+
+      make_restricted_csets(old_roster, new_roster, included, excluded, mask);
+
       new_is_archived = false;
       header << "# old_revision [" << r_old_id << "]" << endl;
-      {
-        // Calculate a cset from old->new, then re-restrict it (using the
-        // one from get_working_revision_and_rosters doesn't work here,
-        // since it only restricts the edge base->new, and there might be
-        // changes outside the restriction in old->base)
-        cset tmp1, tmp2;
-        make_cset (old_roster, new_roster, tmp1);
-        calculate_restricted_cset (app, args, tmp1, composite, tmp2);
-      }
     }
   else if (app.revision_selectors.size() == 2)
     {
       revision_id r_old_id, r_new_id;
+
       complete(app, idx(app.revision_selectors, 0)(), r_old_id);
       complete(app, idx(app.revision_selectors, 1)(), r_new_id);
+
       N(app.db.revision_exists(r_old_id),
         F("no such revision '%s'") % r_old_id);
-      app.db.get_revision(r_old_id, r_old);
       N(app.db.revision_exists(r_new_id),
         F("no such revision '%s'") % r_new_id);
-      app.db.get_revision(r_new_id, r_new);
+
       app.db.get_roster(r_old_id, old_roster);
       app.db.get_roster(r_new_id, new_roster);
+
+      restriction mask;
+      mask.add_nodes(old_roster, paths);
+      mask.add_nodes(new_roster, paths);
+      
+      // FIXME: this is *possibly* a UI bug, insofar as we
+      // look at the restriction name(s) you provided on the command
+      // line in the context of new and old, *not* the working copy.
+      // One way of "fixing" this is to map the filenames on the command
+      // line to node_ids, and then restrict based on those. This 
+      // might be more intuitive; on the other hand it would make it
+      // impossible to restrict to paths which are dead in the working
+      // copy but live between old and new. So ... no rush to "fix" it;
+      // discuss implications first.
+      //
+      // let the discussion begin...
+      //
+      // - "map filenames on the command line to node_ids" needs to be done 
+      //   in the context of some roster, possibly the working copy base or
+      //   the current working copy (or both)
+      // - diff with two --revision's may be done with no working copy 
+      // - some form of "peg" revision syntax for paths that would allow 
+      //   for each path to specify which revision it is relevant to is
+      //   probably the "right" way to go eventually. something like address@hidden
+      //   (which fails for paths with @'s in them) or possibly //rev/file 
+      //   since versioned paths are required to be relative.
+
+      make_restricted_csets(old_roster, new_roster, included, excluded, mask);
+
       new_is_archived = true;
-      {
-        // Calculate a cset from old->new, then re-restrict it. 
-        // FIXME: this is *possibly* a UI bug, insofar as we
-        // look at the restriction name(s) you provided on the command
-        // line in the context of new and old, *not* the working copy.
-        // One way of "fixing" this is to map the filenames on the command
-        // line to node_ids, and then restrict based on those. This 
-        // might be more intuitive; on the other hand it would make it
-        // impossible to restrict to paths which are dead in the working
-        // copy but live between old and new. So ... no rush to "fix" it;
-        // discuss implications first.
-        cset tmp1, tmp2;
-        make_cset (old_roster, new_roster, tmp1);
-        calculate_restricted_cset (app, args, tmp1, composite, tmp2);
-      }
     }
   else
     {
@@ -2782,7 +2806,7 @@
 
   
   data summary;
-  write_cset(composite, summary);
+  write_cset(included, summary);
 
   vector<string> lines;
   split_into_lines(summary(), lines);
@@ -2800,9 +2824,9 @@
   cout << "# " << endl;
 
   if (type == external_diff) {
-    do_external_diff(composite, app, new_is_archived);
+    do_external_diff(included, app, new_is_archived);
   } else
-    dump_diffs(composite, app, new_is_archived, type);
+    dump_diffs(included, app, new_is_archived, type);
 }
 
 
============================================================
--- restrictions.cc	99587c2d19e7554350c96be42ae45cb87f2943e8
+++ restrictions.cc	1598e20a0a9e11d51c97fb493b5ac9452ce09135
@@ -13,6 +13,8 @@
 #include "safe_map.hh"
 #include "transforms.hh"
 
+using std::vector;
+
 void
 restriction::add_nodes(roster_t const & roster, path_set const & paths)
 {
@@ -118,7 +120,7 @@
   restricted_node_map[nid] |= recursive;
 }
 
-void
+static void
 extract_rearranged_paths(cset const & cs, path_set & paths)
 {
   paths.insert(cs.nodes_deleted.begin(), cs.nodes_deleted.end());
@@ -139,7 +141,7 @@
 }
 
 
-void 
+static void 
 add_intermediate_paths(path_set & paths)
 {
   path_set intermediate_paths;
@@ -156,7 +158,7 @@
   paths.insert(intermediate_paths.begin(), intermediate_paths.end());
 }
 
-void
+static void
 restrict_cset(cset const & cs, 
               cset & included,
               cset & excluded,
@@ -245,7 +247,7 @@
 // Project the old_paths through r_old + work, to find the new names of the
 // paths (if they survived work)
 
-void
+static void
 remap_paths(path_set const & old_paths,
             roster_t const & r_old,
             cset const & work,
@@ -269,9 +271,9 @@
     }
 }
 
-void
+static void
 get_base_roster_and_working_cset(app_state & app, 
-                                 std::vector<utf8> const & args,
+                                 vector<utf8> const & args,
                                  revision_id & old_revision_id,
                                  roster_t & old_roster,
                                  path_set & old_paths, 
@@ -307,9 +309,11 @@
     new_paths.insert(i->second);
 }
 
+// commands.cc
+
 void
 get_working_revision_and_rosters(app_state & app, 
-                                 std::vector<utf8> const & args,
+                                 vector<utf8> const & args,
                                  revision_set & rev,
                                  roster_t & old_roster,
                                  roster_t & new_roster,
@@ -321,6 +325,7 @@
   path_set old_paths, new_paths;
 
   rev.edges.clear();
+
   get_base_roster_and_working_cset(app, args, 
                                    old_revision_id,
                                    old_roster,
@@ -335,8 +340,21 @@
   editable_roster_base er(new_roster, nis);
   cs->apply_to(er);
 
+  path_set paths;
+
+  for (vector<utf8>::const_iterator i = args.begin(); i != args.end(); ++i)
+    {
+      split_path sp;
+      file_path_external(*i).split(sp);
+      paths.insert(sp);
+    }
+
+  restriction mask;
+  mask.add_nodes(old_roster, paths);
+  mask.add_nodes(new_roster, paths);
+
   // Now update any idents in the new roster
-  update_restricted_roster_from_filesystem(new_roster, app);
+  update_working_roster_from_filesystem(new_roster, mask, app);
 
   calculate_ident(new_roster, rev.new_manifest);
   L(F("new manifest_id is %s\n") % rev.new_manifest);
@@ -370,9 +388,11 @@
                                         std::make_pair(old_manifest_id, cs)));
 }
 
+// commands.cc
+
 void
 get_working_revision_and_rosters(app_state & app, 
-                                 std::vector<utf8> const & args,
+                                 vector<utf8> const & args,
                                  revision_set & rev,
                                  roster_t & old_roster,
                                  roster_t & new_roster)
@@ -382,50 +402,17 @@
                                    old_roster, new_roster, excluded);
 }
 
+// commands.cc automate.cc
+
 void
 get_unrestricted_working_revision_and_rosters(app_state & app, 
                                               revision_set & rev,
                                               roster_t & old_roster,
                                               roster_t & new_roster)
 {
-  std::vector<utf8> empty_args;
+  vector<utf8> empty_args;
   std::set<utf8> saved_exclude_patterns(app.exclude_patterns);
   app.exclude_patterns.clear();
   get_working_revision_and_rosters(app, empty_args, rev, old_roster, new_roster);
   app.exclude_patterns = saved_exclude_patterns;
 }
-
-
-static void
-extract_changed_paths(cset const & cs, path_set & paths)
-{
-  extract_rearranged_paths(cs, paths);
-
-  for (std::map<split_path, std::pair<file_id, file_id> >::const_iterator i 
-         = cs.deltas_applied.begin(); i != cs.deltas_applied.end(); ++i)
-    paths.insert(i->first);
-  
-  for (std::set<std::pair<split_path, attr_key> >::const_iterator i =
-         cs.attrs_cleared.begin(); i != cs.attrs_cleared.end(); ++i)
-    paths.insert(i->first);
-
-  for (std::map<std::pair<split_path, attr_key>, attr_value>::const_iterator i =
-         cs.attrs_set.begin(); i != cs.attrs_set.end(); ++i)
-    paths.insert(i->first.first);
-}
-
-void
-calculate_restricted_cset(app_state & app, 
-                          std::vector<utf8> const & args,
-                          cset const & cs,
-                          cset & included,
-                          cset & excluded)
-{
-  path_set valid_paths;
-
-  extract_changed_paths(cs, valid_paths);
-  add_intermediate_paths(valid_paths);
-
-  app.set_restriction(valid_paths, args); 
-  restrict_cset(cs, included, excluded, app);
-}
============================================================
--- restrictions.hh	4bb92e680ba4588a887cdaaf91f392767d924ecd
+++ restrictions.hh	68df5137976d04348d5a0a7a965254cb2664b32c
@@ -47,35 +47,6 @@
 };
 
 void 
-extract_rearranged_paths(cset const & rearrangement, 
-                         path_set & paths);
-
-void 
-add_intermediate_paths(path_set & paths);
-
-void 
-restrict_cset(cset const & work, 
-              cset & included,
-              cset & excluded,
-              app_state & app);
-
-void
-remap_paths(path_set const & old_paths,
-            roster_t const & r_old,
-            cset const & work,
-            path_set & new_paths);
-
-void 
-get_base_roster_and_working_cset(app_state & app, 
-                                 std::vector<utf8> const & args,
-                                 revision_id & old_revision_id,
-                                 roster_t & old_roster,
-                                 path_set & old_paths, 
-                                 path_set & new_paths,
-                                 cset & included,
-                                 cset & excluded);
-
-void 
 get_working_revision_and_rosters(app_state & app, 
                                  std::vector<utf8> const & args,
                                  revision_set & rev,
@@ -97,11 +68,4 @@
                                               roster_t & old_roster,
                                               roster_t & new_roster);
 
-void
-calculate_restricted_cset(app_state & app, 
-                          std::vector<utf8> const & args,
-                          cset const & cs,
-                          cset & included,
-                          cset & excluded);
-
 #endif  // header guard
============================================================
--- roster.cc	4bec0e6ca6cc5cb0f64abf3a8385fb02070ff17b
+++ roster.cc	e11e0e8bae48e82f02d190dc889157dc8b6ea0aa
@@ -1810,6 +1810,10 @@
 //   getting rosters from the working copy
 ////////////////////////////////////////////////////////////////////
 
+// TODO: doesn't that mean they should go in work.cc ? 
+// perhaps do that after propagating back to n.v.m.experiment.rosters
+// or to mainline so that diffs are more informative
+
 inline static bool
 inodeprint_unchanged(inodeprint_map const & ipm, file_path const & path) 
 {
@@ -1826,6 +1830,12 @@
     return false; // unavailable
 }
 
+// TODO: unchanged, changed, missing might be better as set<node_id>
+
+// note that this does not take a restriction because it is used only by
+// automate_inventory which operates on the entire, unrestricted, working
+// directory.
+
 void 
 classify_roster_paths(roster_t const & ros,
                       path_set & unchanged,
@@ -1857,46 +1867,37 @@
 
       split_path sp;
       ros.get_name(nid, sp);
-      file_path fp(sp);
 
-      // FIXME_RESTRICTIONS: this looks ok for roster restriction
+      file_path fp(sp);
 
-      // Only analyze restriction-included files.
-      if (app.restriction_includes(sp))
+      if (is_dir_t(node) || inodeprint_unchanged(ipm, fp))
         {
-          if (is_dir_t(node) || inodeprint_unchanged(ipm, fp))
+          // dirs don't have content changes
+          unchanged.insert(sp);
+        }
+      else 
+        {
+          file_t file = downcast_to_file_t(node);
+          file_id fid;
+          if (ident_existing_file(fp, fid, app.lua))
             {
-              // dirs don't have content changes
-              unchanged.insert(sp);
+              if (file->content == fid)
+                unchanged.insert(sp);
+              else
+                changed.insert(sp);
             }
-          else 
+          else
             {
-              file_t file = downcast_to_file_t(node);
-              file_id fid;
-              if (ident_existing_file(fp, fid, app.lua))
-                {
-                  if (file->content == fid)
-                    unchanged.insert(sp);
-                  else
-                    changed.insert(sp);
-                }
-              else
-                {
-                  missing.insert(sp);
-                }
+              missing.insert(sp);
             }
         }
-      else
-        {
-          // changes to excluded files are ignored
-          unchanged.insert(sp);
-        }
     }
 }
 
 void 
-update_restricted_roster_from_filesystem(roster_t & ros, 
-                                         app_state & app)
+update_working_roster_from_filesystem(roster_t & ros, 
+                                      restriction const & mask,
+                                      app_state & app)
 {
   temp_node_id_source nis;
   inodeprint_map ipm;
@@ -1916,8 +1917,6 @@
   if (!ros.has_root())
     return;
 
-  // FIXME_RESTRICTIONS: this looks ok for roster restriction
-
   node_map const & nodes = ros.all_nodes();
   for (node_map::const_iterator i = nodes.begin(); i != nodes.end(); ++i)
     {
@@ -1928,14 +1927,14 @@
       if (! is_file_t(node))
         continue;
 
+      // Only analyze restriction-included files.
+      if (!mask.includes(ros, nid))
+        continue;
+
       split_path sp;
       ros.get_name(nid, sp);
       file_path fp(sp);
 
-      // Only analyze restriction-included files.
-      if (!app.restriction_includes(sp))
-        continue;
-
       // Only analyze changed files (or all files if inodeprints mode
       // is disabled).
       if (inodeprint_unchanged(ipm, fp))
============================================================
--- roster.hh	a044f3d270422283c51b933cf62a15ee01bd629b
+++ roster.hh	cd52bc9735826753c3320caa147fed044e5fdae5
@@ -313,8 +313,9 @@
                       app_state & app);
 
 void 
-update_restricted_roster_from_filesystem(roster_t & ros, 
-                                         app_state & app);
+update_working_roster_from_filesystem(roster_t & ros, 
+                                      restriction const & mask,
+                                      app_state & app);
 
 void
 extract_roster_path_set(roster_t const & ros, 
============================================================
--- tests/t_restrictions.at	84972130299ee9cc3449101f4a4135795cf863f0
+++ tests/t_restrictions.at	ca23ce3a30758abad47e9919544b743130bb66de
@@ -42,21 +42,23 @@
 AT_CHECK(MONOTONE add work/A/fileA, [], [ignore], [ignore])
 AT_CHECK(MONOTONE add work/A/B/fileAB, [], [ignore], [ignore])
 
-AT_CHECK(MONOTONE ls known --depth=0, [], [stdout], [ignore])
-AT_CHECK(grep fileX stdout, [1], [ignore])
+# FIXME_RESTRICTIONS: replace --depth with ... recursive wildcards
 
-AT_CHECK(MONOTONE ls known --depth=0 . , [], [stdout], [ignore])
-AT_CHECK(grep fileX stdout, [1], [ignore])
+#AT_CHECK(MONOTONE ls known --depth=0, [], [stdout], [ignore])
+#AT_CHECK(grep fileX stdout, [1], [ignore])
 
-AT_CHECK(MONOTONE ls known --depth=1 . , [], [stdout], [ignore])
-AT_CHECK(grep fileX stdout, [0], [ignore])
+#AT_CHECK(MONOTONE ls known --depth=0 . , [], [stdout], [ignore])
+#AT_CHECK(grep fileX stdout, [1], [ignore])
 
-AT_CHECK(MONOTONE ls known --depth=0 work/A , [], [stdout], [ignore])
-AT_CHECK(grep fileAB stdout, [1], [ignore])
+#AT_CHECK(MONOTONE ls known --depth=1 . , [], [stdout], [ignore])
+#AT_CHECK(grep fileX stdout, [0], [ignore])
 
-AT_CHECK(MONOTONE ls known --depth=1 work/A , [], [stdout], [ignore])
-AT_CHECK(grep fileAB stdout, [0], [ignore])
+#AT_CHECK(MONOTONE ls known --depth=0 work/A , [], [stdout], [ignore])
+#AT_CHECK(grep fileAB stdout, [1], [ignore])
 
+#AT_CHECK(MONOTONE ls known --depth=1 work/A , [], [stdout], [ignore])
+#AT_CHECK(grep fileAB stdout, [0], [ignore])
+
 # test restriction of unknown, missing, ignored files
 
 AT_CHECK(MONOTONE ls unknown, [], [stdout], [ignore])
@@ -164,18 +166,20 @@
 AT_CHECK(MONOTONE diff, [], [stdout], [ignore])
 AT_CHECK(INCLUDED(X 1 2 3 4), [0], [ignore])
 
-AT_CHECK(MONOTONE diff --depth=0 . , [], [stdout], [ignore])
-AT_CHECK(grep fileAB stdout, [1], [ignore])
+# FIXME_RESTRICTIONS: replace --depth with ... recursive wildcards
 
-AT_CHECK(MONOTONE diff --depth=2 . , [], [stdout], [ignore])
-AT_CHECK(grep fileA stdout, [0], [ignore])
+#AT_CHECK(MONOTONE diff --depth=0 . , [], [stdout], [ignore])
+#AT_CHECK(grep fileAB stdout, [1], [ignore])
 
-AT_CHECK(MONOTONE diff --context --depth=0 . , [], [stdout], [ignore])
-AT_CHECK(grep fileAB stdout, [1], [ignore])
+#AT_CHECK(MONOTONE diff --depth=2 . , [], [stdout], [ignore])
+#AT_CHECK(grep fileA stdout, [0], [ignore])
 
-AT_CHECK(MONOTONE diff --context --depth=2 . , [], [stdout], [ignore])
-AT_CHECK(grep fileA stdout, [0], [ignore])
+#AT_CHECK(MONOTONE diff --context --depth=0 . , [], [stdout], [ignore])
+#AT_CHECK(grep fileAB stdout, [1], [ignore])
 
+#AT_CHECK(MONOTONE diff --context --depth=2 . , [], [stdout], [ignore])
+#AT_CHECK(grep fileA stdout, [0], [ignore])
+
 # include both source and target of rename
 
 AT_CHECK(MONOTONE diff work/fileX work/file1, [], [stdout], [ignore])
============================================================
--- tests/t_revert.at	243cf86fd8d0335298446ea299b099540e206cfb
+++ tests/t_revert.at	e6f8b570d747a39a35865d3d072e4d34e72b86f1
@@ -102,7 +102,7 @@
 AT_CHECK(MONOTONE revert, [], [ignore], [ignore])
 AT_CHECK(rm testfile0)
 AT_CHECK(MONOTONE status, [1], [ignore], [ignore])
-AT_CHECK(MONOTONE revert testfile0, [], [stdout])
+AT_CHECK(MONOTONE revert testfile0, [], [stdout], [ignore])
 AT_CHECK(MONOTONE status, [], [ignore], [ignore])
 
 # check reverting some changes and leaving others
============================================================
--- work.cc	ea83b9e5b2cc4d2990686d63454c37c414fa118e
+++ work.cc	a043cb7bf631ed4519986fd5e518926d74b67ca2
@@ -425,12 +425,14 @@
   cs.apply_to(er);
 }
 
+/**
 void
 get_current_restricted_roster(roster_t & ros, node_id_source & nis, app_state & app)
 {
   get_current_roster_shape(ros, nis, app);
   update_restricted_roster_from_filesystem(ros, app);
 }
+**/
 
 void
 get_base_and_current_roster_shape(roster_t & base_roster,
@@ -446,6 +448,7 @@
   cs.apply_to(er);
 }
 
+/**
 void
 get_base_and_current_restricted_roster(roster_t & base_roster,
                                        roster_t & current_roster,
@@ -455,6 +458,7 @@
   get_base_and_current_roster_shape(base_roster, current_roster, nis, app);
   update_restricted_roster_from_filesystem(current_roster, app);
 }
+**/
 
 // user log file
 
============================================================
--- work.hh	81add376cf6c2448fa5d48c117b6b472d02def69
+++ work.hh	410b69b097ae15b89d9b80b3973d4f57b2a5d43e
@@ -96,8 +96,11 @@
 // hashes in that roster -- the "shape" is correct, all files and dirs exist
 // and under the correct names -- but do not trust file content hashes.
 void get_current_roster_shape(roster_t & ros, node_id_source & nis, app_state & app);
+
+/**
 // This does update hashes, but only those that match the current restriction
 void get_current_restricted_roster(roster_t & ros, node_id_source & nis, app_state & app);
+**/
 
 // This returns the current roster, except it does not bother updating the
 // hashes in that roster -- the "shape" is correct, all files and dirs exist
@@ -106,11 +109,14 @@
                                        roster_t & current_roster,
                                        node_id_source & nis,
                                        app_state & app);
+
+/**
 // This does update hashes, but only those that match the current restriction
 void get_base_and_current_restricted_roster(roster_t & base_roster,
                                             roster_t & current_roster,
                                             node_id_source & nis,
                                             app_state & app);
+**/
 
 // the "user log" is a file the user can edit as they program to record
 // changes they make to their source code. Upon commit the file is read