#
#
# patch "annotate.cc"
#  from [e2d60b0f0c64accab92bed62d0b45a2a9281160a]
#    to [d359129ebda4db42123b8b92f9effdfdadb2f8f4]
# 
# patch "annotate.hh"
#  from [94f7fb620b8fe37ed5e83975a1ea944fbff089fd]
#    to [c14105693d3c6e7813adc27295e44d2134ef5502]
# 
# patch "cmd.hh"
#  from [6ef78795227127faea508c24356e4c4952373140]
#    to [6bd31b3c5f20311811d208ec0255abbd2012c9cb]
# 
# patch "cmd_db.cc"
#  from [6e0eed17a107e27235d68204bc4dde35b3f78c5e]
#    to [c0385e17b2a21716167d0bbfd52905680397419f]
# 
# patch "cmd_files.cc"
#  from [841f414708a785f55cef6f9dec0577328741085f]
#    to [df0cd6d8b2545d93df4eb70832896212c94c97b0]
# 
# patch "cmd_merging.cc"
#  from [67522c6ca75eacaa3e74427d7ca9ade04aee5970]
#    to [ae9de0a973ad13985c41f2aa6ac22244a5e8653b]
# 
# patch "cmd_netsync.cc"
#  from [aaedc625c889c1b3dfeb9dc270326adc54824976]
#    to [a246173f141d20b75f52ac5746a869557eff497e]
# 
# patch "cmd_othervcs.cc"
#  from [26ce46520e69789d28d93a8c733f26ace5e59592]
#    to [d3d91faf9411b7cd245353edd2469e0ed48a1614]
# 
# patch "cmd_ws_commit.cc"
#  from [7390145329711a7a90339633d7cace8296c92633]
#    to [871fe640df8e15eeb5aa6ee39469e349822d9d08]
# 
# patch "commands.cc"
#  from [9d0b1bc782bc695b35686be8e7718cad538f0f44]
#    to [83b3cbd4dd7fc1fa242b3a7311797449fb88ff14]
# 
# patch "enumerator.cc"
#  from [4400e1ce3ef83739301e15c27f7bad6d42817736]
#    to [9d7d81efbfa8befe3a150399b2bde472d9e5e3b9]
# 
# patch "enumerator.hh"
#  from [d1dac4129cf193b9a2531ca785690a093e4e1248]
#    to [c911c8622932915c90e96b53668df5bdd5317c7a]
# 
# patch "netcmd.hh"
#  from [ec7d86b3af44ce536db4ed266bbf8fb09f5316f1]
#    to [7a72dc722db614fd522f07c040cad8be2de3ecfb]
# 
# patch "netsync.cc"
#  from [0ec6a72cef9e52f71d16535127241642e543cf2a]
#    to [3174e2b050480d6560e61699b342f0418cc6b29d]
# 
# patch "project.hh"
#  from [e66140583a55d848e04c6ca22db6101f32b187a8]
#    to [2bea810a7ef3f86571798989055c79cc5fda23df]
# 
# patch "rcs_import.cc"
#  from [f1cd9a1642dc94e9a50577a962d494b2295b1b18]
#    to [2bdf86d7e0951c686cd68fcf60d831ee5ea2c363]
# 
# patch "rcs_import.hh"
#  from [975c217ebf5a3b8b73ebc64290f12b8050ce05f3]
#    to [a1bdda69e06ea25a4b50cfea9c8e1dbf5f61edd5]
# 
# patch "selectors.cc"
#  from [423dd7fe2a2668ef509bf9269163e0ffc867d387]
#    to [a63cff13b6230113758688098d9be976db0ea60f]
# 
# patch "update.cc"
#  from [2bad4b1ea8a05c37326d410761008d51032074ef]
#    to [4ff426265325f41011fa8460cd261ca645646d5a]
# 
# patch "update.hh"
#  from [f0350936544465c9bd29166d2c809ca1a24acc79]
#    to [af0e12d08bd51ce590f3f7de9e6ac7bf252712cc]
#
============================================================
--- annotate.cc	e2d60b0f0c64accab92bed62d0b45a2a9281160a
+++ annotate.cc	d359129ebda4db42123b8b92f9effdfdadb2f8f4
@@ -58,7 +58,7 @@ public:
 class annotate_context
 {
 public:
-  annotate_context(file_id fid, database & db, project_t & project);
+  annotate_context(file_id fid, project_t & project);
 
   shared_ptr<annotate_lineage_mapping> initial_lineage() const;
 
@@ -85,7 +85,6 @@ private:
 private:
   void build_revisions_to_annotations(map<revision_id, string> & r2a) const;
 
-  database & db;
   project_t & project;
 
   /// keep a count so we can tell quickly whether we can terminate
@@ -207,13 +206,12 @@ typedef multi_index_container<
   > work_units;
 
 
-annotate_context::annotate_context(file_id fid, database & db,
-                                   project_t & project)
-  : db(db), project(project), annotated_lines_completed(0)
+annotate_context::annotate_context(file_id fid, project_t & project)
+  : project(project), annotated_lines_completed(0)
 {
   // initialize file_lines
   file_data fpacked;
-  db.get_file_version(fid, fpacked);
+  project.db.get_file_version(fid, fpacked);
   string encoding = constants::default_encoding; // FIXME
   split_into_lines(fpacked.inner()(), encoding, file_lines);
   L(FL("annotate_context::annotate_context initialized "
@@ -395,7 +393,7 @@ annotate_context::build_revisions_to_ann
     {
       vector< revision<cert> > certs;
       project.get_revision_certs(*i, certs);
-      erase_bogus_certs(certs, db);
+      erase_bogus_certs(certs, project.db);
 
       string author(cert_string_value(certs, author_cert_name,
                                       true, false, "@< "));
@@ -818,14 +816,14 @@ void
 }
 
 void
-do_annotate (database & db, project_t & project, file_t file_node,
+do_annotate (project_t & project, file_t file_node,
              revision_id rid, bool just_revs)
 {
   L(FL("annotating file %s with content %s in revision %s")
     % file_node->self % file_node->content % rid);
 
   shared_ptr<annotate_context>
-    acp(new annotate_context(file_node->content, db, project));
+    acp(new annotate_context(file_node->content, project));
 
   shared_ptr<annotate_lineage_mapping> lineage
     = acp->initial_lineage();
@@ -834,16 +832,18 @@ do_annotate (database & db, project_t & 
   {
     // prepare the first work_unit
     rev_height height;
-    db.get_rev_height(rid, height);
+    project.db.get_rev_height(rid, height);
     set<revision_id> rids_interesting_ancestors;
-    get_file_content_marks(db, rid, file_node->self, rids_interesting_ancestors);
+    get_file_content_marks(project.db, rid, file_node->self,
+                           rids_interesting_ancestors);
     bool rid_marked = (rids_interesting_ancestors.size() == 1
                        && *(rids_interesting_ancestors.begin()) == rid);
     if (rid_marked)
-      db.get_revision_parents(rid, rids_interesting_ancestors);
+      project.db.get_revision_parents(rid, rids_interesting_ancestors);
     
     annotate_node_work workunit(acp, lineage, rid, file_node->self, height,
-                                rids_interesting_ancestors, file_node->content, rid_marked);
+                                rids_interesting_ancestors, file_node->content,
+                                rid_marked);
     work_units.insert(workunit);
   }
   
@@ -858,7 +858,7 @@ do_annotate (database & db, project_t & 
       annotate_node_work work = *w;
       work_units.erase(w);
 
-      do_annotate_node(work, db, work_units);
+      do_annotate_node(work, project.db, work_units);
     }
 
   acp->annotate_equivalent_lines();
============================================================
--- annotate.hh	94f7fb620b8fe37ed5e83975a1ea944fbff089fd
+++ annotate.hh	c14105693d3c6e7813adc27295e44d2134ef5502
@@ -12,12 +12,12 @@
 
 #include "vocab.hh"
 #include "roster.hh"
-class database;
+
 class project_t;
 
 void
-do_annotate(database & db, project_t & project,
-            file_t file_node, revision_id rid, bool just_revs);
+do_annotate(project_t & project, file_t file_node, revision_id rid,
+            bool just_revs);
 
 // Local Variables:
 // mode: C++
============================================================
--- cmd.hh	6ef78795227127faea508c24356e4c4952373140
+++ cmd.hh	6bd31b3c5f20311811d208ec0255abbd2012c9cb
@@ -156,8 +156,7 @@ std::string
 }
 
 std::string
-describe_revision(database & db, project_t & project,
-                  revision_id const & id);
+describe_revision(project_t & project, revision_id const & id);
 
 void
 notify_if_multiple_heads(project_t & project, branch_name const & branchname,
============================================================
--- cmd_db.cc	6e0eed17a107e27235d68204bc4dde35b3f78c5e
+++ cmd_db.cc	c0385e17b2a21716167d0bbfd52905680397419f
@@ -349,7 +349,7 @@ CMD(complete, "complete", "", CMD_REF(in
            i != completions.end(); ++i)
         {
           if (!verbose) cout << i->inner()() << '\n';
-          else cout << describe_revision(app.db, app.get_project(), *i) << '\n';
+          else cout << describe_revision(app.get_project(), *i) << '\n';
         }
     }
   else if (idx(args, 0)() == "file")
============================================================
--- cmd_files.cc	841f414708a785f55cef6f9dec0577328741085f
+++ cmd_files.cc	df0cd6d8b2545d93df4eb70832896212c94c97b0
@@ -181,7 +181,7 @@ CMD(annotate, "annotate", "", CMD_REF(in
 
   file_t file_node = downcast_to_file_t(node);
   L(FL("annotate for file_id %s") % file_node->self);
-  do_annotate(app.db, app.get_project(), file_node, rid, app.opts.revs_only);
+  do_annotate(app.get_project(), file_node, rid, app.opts.revs_only);
 }
 
 CMD(identify, "identify", "", CMD_REF(debug), N_("[PATH]"),
============================================================
--- cmd_merging.cc	67522c6ca75eacaa3e74427d7ca9ade04aee5970
+++ cmd_merging.cc	ae9de0a973ad13985c41f2aa6ac22244a5e8653b
@@ -173,8 +173,8 @@ CMD(update, "update", "", CMD_REF(worksp
       P(F("updating along branch '%s'") % app.opts.branchname);
       set<revision_id> candidates;
       pick_update_candidates(candidates, old_rid, app.opts.branchname,
-                             app.opts.ignore_suspend_certs,
-                             app.db, app.get_project(), app.lua);
+                             app.get_project(),
+                             app.opts.ignore_suspend_certs, app.lua);
       N(!candidates.empty(),
         F("your request matches no descendents of the current revision\n"
           "in fact, it doesn't even match the current revision\n"
@@ -186,7 +186,7 @@ CMD(update, "update", "", CMD_REF(worksp
           for (set<revision_id>::const_iterator i = candidates.begin();
                i != candidates.end(); ++i)
             P(i18n_format("  %s")
-              % describe_revision(app.db, app.get_project(), *i));
+              % describe_revision(app.get_project(), *i));
           P(F("choose one with '%s update -r<id>'") % ui.prog_name);
           E(false, F("multiple update candidates remain after selection"));
         }
@@ -1055,7 +1055,7 @@ CMD(heads, "heads", "", CMD_REF(tree), "
 
   for (set<revision_id>::const_iterator i = heads.begin();
        i != heads.end(); ++i)
-    cout << describe_revision(app.db, app.get_project(), *i) << '\n';
+    cout << describe_revision(app.get_project(), *i) << '\n';
 }
 
 CMD(get_roster, "get_roster", "", CMD_REF(debug), N_("[REVID]"),
============================================================
--- cmd_netsync.cc	aaedc625c889c1b3dfeb9dc270326adc54824976
+++ cmd_netsync.cc	a246173f141d20b75f52ac5746a869557eff497e
@@ -165,7 +165,7 @@ CMD(push, "push", "", CMD_REF(network),
 
   run_netsync_protocol(client_voice, source_role, uris,
                        include_pattern, exclude_pattern,
-                       app.db, app.get_project(), app.keys, app.lua, app.opts);
+                       app.get_project(), app.keys, app.lua, app.opts);
 }
 
 CMD(pull, "pull", "", CMD_REF(network),
@@ -189,7 +189,7 @@ CMD(pull, "pull", "", CMD_REF(network),
 
   run_netsync_protocol(client_voice, sink_role, uris,
                        include_pattern, exclude_pattern,
-                       app.db, app.get_project(), app.keys, app.lua, app.opts);
+                       app.get_project(), app.keys, app.lua, app.opts);
 }
 
 CMD(sync, "sync", "", CMD_REF(network),
@@ -211,7 +211,7 @@ CMD(sync, "sync", "", CMD_REF(network),
 
   run_netsync_protocol(client_voice, source_and_sink_role, uris,
                        include_pattern, exclude_pattern,
-                       app.db, app.get_project(), app.keys, app.lua, app.opts);
+                       app.get_project(), app.keys, app.lua, app.opts);
 }
 
 class dir_cleanup_helper
@@ -331,7 +331,7 @@ CMD(clone, "clone", "", CMD_REF(network)
 
   run_netsync_protocol(client_voice, sink_role, uris,
                        include_pattern, exclude_pattern,
-                       app.db, app.get_project(), app.keys, app.lua, app.opts);
+                       app.get_project(), app.keys, app.lua, app.opts);
 
   change_current_working_dir(workspace_dir);
 
@@ -353,7 +353,7 @@ CMD(clone, "clone", "", CMD_REF(network)
           P(F("branch %s has multiple heads:") % app.opts.branchname);
           for (set<revision_id>::const_iterator i = heads.begin(); i != heads.end(); ++i)
             P(i18n_format("  %s")
-              % describe_revision(app.db, app.get_project(), *i));
+              % describe_revision(app.get_project(), *i));
           P(F("choose one with '%s checkout -r<id>'") % ui.prog_name);
           E(false, F("branch %s has multiple heads") % app.opts.branchname);
         }
@@ -455,7 +455,7 @@ CMD_NO_WORKSPACE(serve, "serve", "", CMD
 
   run_netsync_protocol(server_voice, source_and_sink_role, app.opts.bind_uris,
                        globish("*"), globish(""),
-                       app.db, app.get_project(), app.keys, app.lua, app.opts);
+                       app.get_project(), app.keys, app.lua, app.opts);
 }
 
 // Local Variables:
============================================================
--- cmd_othervcs.cc	26ce46520e69789d28d93a8c733f26ace5e59592
+++ cmd_othervcs.cc	d3d91faf9411b7cd245353edd2469e0ed48a1614
@@ -55,7 +55,7 @@ CMD(cvs_import, "cvs_import", "", CMD_RE
   get_user_key(key, app.keys, app.db);
   require_password(key, app.keys, app.db);
 
-  import_cvs_repo(cvsroot, app.db, app.keys, app.get_project(), app.opts.branchname);
+  import_cvs_repo(cvsroot, app.keys, app.get_project(), app.opts.branchname);
 }
 
 
============================================================
--- cmd_ws_commit.cc	7390145329711a7a90339633d7cace8296c92633
+++ cmd_ws_commit.cc	871fe640df8e15eeb5aa6ee39469e349822d9d08
@@ -603,7 +603,7 @@ CMD(checkout, "checkout", "co", CMD_REF(
           P(F("branch %s has multiple heads:") % app.opts.branchname);
           for (set<revision_id>::const_iterator i = heads.begin(); i != heads.end(); ++i)
             P(i18n_format("  %s")
-              % describe_revision(app.db, app.get_project(), *i));
+              % describe_revision(app.get_project(), *i));
           P(F("choose one with '%s checkout -r<id>'") % ui.prog_name);
           E(false, F("branch %s has multiple heads") % app.opts.branchname);
         }
@@ -1357,7 +1357,7 @@ CMD_NO_WORKSPACE(import, "import", "", C
           P(F("branch %s has multiple heads:") % app.opts.branchname);
           for (set<revision_id>::const_iterator i = heads.begin(); i != heads.end(); ++i)
             P(i18n_format("  %s")
-              % describe_revision(app.db, app.get_project(), *i));
+              % describe_revision(app.get_project(), *i));
           P(F("choose one with '%s checkout -r<id>'") % ui.prog_name);
           E(false, F("branch %s has multiple heads") % app.opts.branchname);
         }
============================================================
--- commands.cc	9d0b1bc782bc695b35686be8e7718cad538f0f44
+++ commands.cc	83b3cbd4dd7fc1fa242b3a7311797449fb88ff14
@@ -853,8 +853,7 @@ string
 }
 
 string
-describe_revision(database & db, project_t & project,
-                  revision_id const & id)
+describe_revision(project_t & project, revision_id const & id)
 {
   cert_name author_name(author_cert_name);
   cert_name date_name(date_cert_name);
============================================================
--- enumerator.cc	4400e1ce3ef83739301e15c27f7bad6d42817736
+++ enumerator.cc	9d7d81efbfa8befe3a150399b2bde472d9e5e3b9
@@ -28,13 +28,13 @@ revision_enumerator::revision_enumerator
 using std::vector;
 
 revision_enumerator::revision_enumerator(enumerator_callbacks & cb,
-                                         database & db, project_t & project)
-  : cb(cb), db(db), project(project)
+                                         project_t & project)
+  : cb(cb), project(project)
 {
   revision_id root;
   revs.push_back(root);
 
-  db.get_revision_ancestry(graph);
+  project.db.get_revision_ancestry(graph);
   for (multimap<revision_id, revision_id>::const_iterator i = graph.begin();
        i != graph.end(); ++i)
     {
@@ -101,7 +101,7 @@ revision_enumerator::files_for_revision(
 
   revision_t rs;
   MM(rs);
-  db.get_revision(r, rs);
+  project.db.get_revision(r, rs);
 
   for (edge_map::const_iterator i = rs.edges.begin();
        i != rs.edges.end(); ++i)
============================================================
--- enumerator.hh	d1dac4129cf193b9a2531ca785690a093e4e1248
+++ enumerator.hh	c911c8622932915c90e96b53668df5bdd5317c7a
@@ -53,7 +53,6 @@ revision_enumerator
 revision_enumerator
 {
   enumerator_callbacks & cb;
-  database & db;
   project_t & project;
   std::set<revision_id> terminal_nodes;
   std::set<revision_id> enumerated_nodes;
@@ -72,7 +71,7 @@ public:
 
 public:
   revision_enumerator(enumerator_callbacks & cb,
-                      database & db, project_t & project);
+                      project_t & project);
   void get_revision_parents(revision_id const & rid,
 			    std::vector<revision_id> & parents);
   void note_cert(revision_id const & rid,
============================================================
--- netcmd.hh	ec7d86b3af44ce536db4ed266bbf8fb09f5316f1
+++ netcmd.hh	7a72dc722db614fd522f07c040cad8be2de3ecfb
@@ -181,7 +181,7 @@ void run_netsync_protocol(protocol_voice
                           std::list<utf8> const & addrs,
                           globish const & include_pattern,
                           globish const & exclude_pattern,
-                          database & db, project_t & project,
+                          project_t & project,
                           key_store & keys, lua_hooks & lua, options & opts);
 
 // Local Variables:
============================================================
--- netsync.cc	0ec6a72cef9e52f71d16535127241642e543cf2a
+++ netsync.cc	3174e2b050480d6560e61699b342f0418cc6b29d
@@ -298,7 +298,6 @@ session:
   globish our_exclude_pattern;
   globish_matcher our_matcher;
 
-  database & db;
   project_t & project;
   key_store & keys;
   lua_hooks & lua;
@@ -402,7 +401,6 @@ session:
           protocol_voice voice,
           globish const & our_include_pattern,
           globish const & our_exclude_pattern,
-          database & db,
           project_t & project,
           key_store & keys,
           lua_hooks & lua,
@@ -522,7 +520,6 @@ session::session(protocol_role role,
                  protocol_voice voice,
                  globish const & our_include_pattern,
                  globish const & our_exclude_pattern,
-                 database & db,
                  project_t & project,
                  key_store & keys,
                  lua_hooks & lua,
@@ -535,7 +532,6 @@ session::session(protocol_role role,
   our_include_pattern(our_include_pattern),
   our_exclude_pattern(our_exclude_pattern),
   our_matcher(our_include_pattern, our_exclude_pattern),
-  db(db),
   project(project),
   keys(keys),
   lua(lua),
@@ -576,7 +572,7 @@ session::session(protocol_role role,
   key_refiner(key_item, voice, *this),
   cert_refiner(cert_item, voice, *this),
   rev_refiner(revision_item, voice, *this),
-  rev_enumerator(*this, db, project),
+  rev_enumerator(*this, project),
   initiated_by_server(initiated_by_server)
 {}
 
@@ -633,7 +629,7 @@ session::~session()
               certs.insert(make_pair(j->key, make_pair(j->name, vtmp)));
             }
           revision_data rdat;
-          db.get_revision(*i, rdat);
+          project.db.get_revision(*i, rdat);
           lua.hook_note_netsync_revision_received(*i, rdat, certs,
                                                   session_id);
         }
@@ -687,7 +683,7 @@ session::note_file_data(file_id const & 
   file_data fd;
   id item;
   decode_hexenc(f.inner(), item);
-  db.get_file_version(f, fd);
+  project.db.get_file_version(f, fd);
   queue_data_cmd(file_item, item, fd.inner()());
   file_items_sent.insert(f);
 }
@@ -701,7 +697,7 @@ session::note_file_delta(file_id const &
   id fid1, fid2;
   decode_hexenc(src.inner(), fid1);
   decode_hexenc(dst.inner(), fid2);
-  db.get_arbitrary_file_delta(src, dst, fdel);
+  project.db.get_arbitrary_file_delta(src, dst, fdel);
   queue_delta_cmd(file_item, fid1, fid2, fdel.inner());
   file_items_sent.insert(dst);
 }
@@ -714,7 +710,7 @@ session::note_rev(revision_id const & re
   revision_t rs;
   id item;
   decode_hexenc(rev.inner(), item);
-  db.get_revision(rev, rs);
+  project.db.get_revision(rev, rs);
   data tmp;
   write_revision(rs, tmp);
   queue_data_cmd(revision_item, item, tmp());
@@ -729,7 +725,7 @@ session::note_cert(hexenc<id> const & c)
   decode_hexenc(c, item);
   revision<cert> cert;
   string str;
-  db.get_revision_cert(c, cert);
+  project.db.get_revision_cert(c, cert);
   write_cert(cert.inner(), str);
   queue_data_cmd(cert_item, item, str);
 }
@@ -1309,10 +1305,10 @@ session::process_hello_cmd(rsa_keypair_i
       key_hash_code(their_keyname, their_key_encoded, their_key_hash);
       L(FL("server key has name %s, hash %s") % their_keyname % their_key_hash);
       var_key their_key_key(known_servers_domain, var_name(peer_id));
-      if (db.var_exists(their_key_key))
+      if (project.db.var_exists(their_key_key))
         {
           var_value expected_key_hash;
-          db.get_var(their_key_key, expected_key_hash);
+          project.db.get_var(their_key_key, expected_key_hash);
           if (expected_key_hash() != their_key_hash())
             {
               P(F("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n"
@@ -1333,9 +1329,9 @@ session::process_hello_cmd(rsa_keypair_i
           P(F("first time connecting to server %s\n"
               "I'll assume it's really them, but you might want to double-check\n"
               "their key's fingerprint: %s") % peer_id % their_key_hash);
-          db.set_var(their_key_key, var_value(their_key_hash()));
+          project.db.set_var(their_key_key, var_value(their_key_hash()));
         }
-      if (db.put_key(their_keyname, their_key_encoded))
+      if (project.db.put_key(their_keyname, their_key_encoded))
         W(F("saving public key for %s to database") % their_keyname);
 
       {
@@ -1345,7 +1341,7 @@ session::process_hello_cmd(rsa_keypair_i
           % their_key_hash % hnonce);
       }
 
-      I(db.public_key_exists(their_key_hash));
+      I(project.db.public_key_exists(their_key_hash));
 
       // save their identity
       id their_key_hash_decoded;
@@ -1377,12 +1373,12 @@ session::process_hello_cmd(rsa_keypair_i
       // this also ensures our public key is in the database
       base64<rsa_sha1_signature> sig;
       rsa_sha1_signature sig_raw;
-      keys.make_signature(db, signing_key, nonce(), sig);
+      keys.make_signature(project.db, signing_key, nonce(), sig);
       decode_base64(sig, sig_raw);
 
       // get the hash identifier for our pubkey
       base64<rsa_pub_key> our_pub;
-      db.get_key(signing_key, our_pub);
+      project.db.get_key(signing_key, our_pub);
       hexenc<id> our_key_hash;
       id our_key_hash_raw;
       key_hash_code(signing_key, our_pub, our_key_hash);
@@ -1528,14 +1524,14 @@ session::process_auth_cmd(protocol_role 
 
   globish_matcher their_matcher(their_include_pattern, their_exclude_pattern);
 
-  if (!db.public_key_exists(their_key_hash))
+  if (!project.db.public_key_exists(their_key_hash))
     {
       // If it's not in the db, it still could be in the keystore if we
       // have the private key that goes with it.
       rsa_keypair_id their_key_id;
       keypair their_keypair;
       if (keys.maybe_get_key_pair(their_key_hash, their_key_id, their_keypair))
-        db.put_key(their_key_id, their_keypair.pub);
+        project.db.put_key(their_key_id, their_keypair.pub);
       else
         {
           this->saved_nonce = id("");
@@ -1553,7 +1549,7 @@ session::process_auth_cmd(protocol_role 
   // Get their public key.
   rsa_keypair_id their_id;
   base64<rsa_pub_key> their_key;
-  db.get_pubkey(their_key_hash, their_id, their_key);
+  project.db.get_pubkey(their_key_hash, their_id, their_key);
 
   lua.hook_note_netsync_start(session_id, "server", their_role,
                               peer_id, their_id,
@@ -1646,7 +1642,7 @@ session::process_auth_cmd(protocol_role 
   // Check the signature.
   base64<rsa_sha1_signature> sig;
   encode_base64(rsa_sha1_signature(signature), sig);
-  if (db.check_signature(their_id, nonce1(), sig) == cert_ok)
+  if (project.db.check_signature(their_id, nonce1(), sig) == cert_ok)
     {
       // Get our private key and sign back.
       L(FL("client signature OK, accepting authentication"));
@@ -1831,18 +1827,18 @@ session::data_exists(netcmd_item_type ty
     {
     case key_item:
       return key_refiner.local_item_exists(item)
-        || db.public_key_exists(hitem);
+        || project.db.public_key_exists(hitem);
     case file_item:
-      return db.file_version_exists(file_id(hitem));
+      return project.db.file_version_exists(file_id(hitem));
     case revision_item:
       return rev_refiner.local_item_exists(item)
-        || db.revision_exists(revision_id(hitem));
+        || project.db.revision_exists(revision_id(hitem));
     case cert_item:
       return cert_refiner.local_item_exists(item)
-        || db.revision_cert_exists(hitem);
+        || project.db.revision_cert_exists(hitem);
     case epoch_item:
       return epoch_refiner.local_item_exists(item)
-        || db.epoch_exists(epoch_id(hitem));
+        || project.db.epoch_exists(epoch_id(hitem));
     }
   return false;
 }
@@ -1867,7 +1863,7 @@ session::load_data(netcmd_item_type type
       {
         branch_name branch;
         epoch_data epoch;
-        db.get_epoch(epoch_id(hitem), branch, epoch);
+        project.db.get_epoch(epoch_id(hitem), branch, epoch);
         write_epoch(branch, epoch, out);
       }
       break;
@@ -1875,7 +1871,7 @@ session::load_data(netcmd_item_type type
       {
         rsa_keypair_id keyid;
         base64<rsa_pub_key> pub_encoded;
-        db.get_pubkey(hitem, keyid, pub_encoded);
+        project.db.get_pubkey(hitem, keyid, pub_encoded);
         L(FL("public key '%s' is also called '%s'") % hitem % keyid);
         write_pubkey(keyid, pub_encoded, out);
       }
@@ -1885,7 +1881,7 @@ session::load_data(netcmd_item_type type
       {
         revision_data mdat;
         data dat;
-        db.get_revision(revision_id(hitem), mdat);
+        project.db.get_revision(revision_id(hitem), mdat);
         out = mdat.inner()();
       }
       break;
@@ -1894,7 +1890,7 @@ session::load_data(netcmd_item_type type
       {
         file_data fdat;
         data dat;
-        db.get_file_version(file_id(hitem), fdat);
+        project.db.get_file_version(file_id(hitem), fdat);
         out = fdat.inner()();
       }
       break;
@@ -1902,7 +1898,7 @@ session::load_data(netcmd_item_type type
     case cert_item:
       {
         revision<cert> c;
-        db.get_revision_cert(hitem, c);
+        project.db.get_revision_cert(hitem, c);
         string tmp;
         write_cert(c.inner(), out);
       }
@@ -1939,13 +1935,13 @@ session::process_data_cmd(netcmd_item_ty
         read_epoch(dat, branch, epoch);
         L(FL("received epoch %s for branch %s") % epoch % branch);
         map<branch_name, epoch_data> epochs;
-        db.get_epochs(epochs);
+        project.db.get_epochs(epochs);
         map<branch_name, epoch_data>::const_iterator i;
         i = epochs.find(branch);
         if (i == epochs.end())
           {
             L(FL("branch %s has no epoch; setting epoch to %s") % branch % epoch);
-            db.set_epoch(branch, epoch);
+            project.db.set_epoch(branch, epoch);
           }
         else
           {
@@ -1983,7 +1979,7 @@ session::process_data_cmd(netcmd_item_ty
           throw bad_decode(F("hash check failed for public key '%s' (%s);"
                              " wanted '%s' got '%s'")
                            % hitem % keyid % hitem % tmp);
-        if (db.put_key(keyid, pub))
+        if (project.db.put_key(keyid, pub))
           written_keys.push_back(keyid);
         else
           error(partial_transfer,
@@ -1999,7 +1995,7 @@ session::process_data_cmd(netcmd_item_ty
         cert_hash_code(c, tmp);
         if (! (tmp == hitem))
           throw bad_decode(F("hash check failed for revision cert '%s'")  % hitem);
-        if (db.put_revision_cert(revision<cert>(c)))
+        if (project.db.put_revision_cert(revision<cert>(c)))
           written_certs.push_back(c);
       }
       break;
@@ -2007,7 +2003,7 @@ session::process_data_cmd(netcmd_item_ty
     case revision_item:
       {
         L(FL("received revision '%s'") % hitem);
-        if (db.put_revision(revision_id(hitem), revision_data(dat)))
+        if (project.db.put_revision(revision_id(hitem), revision_data(dat)))
           written_revisions.push_back(revision_id(hitem));
       }
       break;
@@ -2015,7 +2011,7 @@ session::process_data_cmd(netcmd_item_ty
     case file_item:
       {
         L(FL("received file '%s'") % hitem);
-        db.put_file(file_id(hitem), file_data(dat));
+        project.db.put_file(file_id(hitem), file_data(dat));
       }
       break;
     }
@@ -2043,7 +2039,7 @@ session::process_delta_cmd(netcmd_item_t
     case file_item:
       {
         file_id src_file(hbase), dst_file(hident);
-        db.put_file_version(src_file, dst_file, file_delta(del));
+        project.db.put_file_version(src_file, dst_file, file_delta(del));
       }
       break;
 
@@ -2406,7 +2402,6 @@ call_server(protocol_role role,
 call_server(protocol_role role,
             globish const & include_pattern,
             globish const & exclude_pattern,
-            database & db,
             project_t & project,
             key_store & keys,
             lua_hooks & lua,
@@ -2416,7 +2411,7 @@ call_server(protocol_role role,
             unsigned long timeout_seconds)
 {
   Netxx::PipeCompatibleProbe probe;
-  transaction_guard guard(db);
+  transaction_guard guard(project.db);
   I(addresses.size() == 1);
   utf8 address(*addresses.begin());
 
@@ -2440,7 +2435,7 @@ call_server(protocol_role role,
   session sess(role, client_voice,
                include_pattern,
                exclude_pattern,
-               db, project, keys, lua, opts, address(), server);
+               project, keys, lua, opts, address(), server);
 
   while (true)
     {
@@ -2605,7 +2600,7 @@ handle_new_connection(Netxx::Address & a
                       globish const & include_pattern,
                       globish const & exclude_pattern,
                       map<Netxx::socket_type, shared_ptr<session> > & sessions,
-                      database & db, project_t & project, key_store & keys,
+                      project_t & project, key_store & keys,
                       lua_hooks & lua, options & opts)
 {
   L(FL("accepting new connection on %s : %s")
@@ -2632,7 +2627,7 @@ handle_new_connection(Netxx::Address & a
 
       shared_ptr<session> sess(new session(role, server_voice,
                                            include_pattern, exclude_pattern,
-                                           db, project, keys, lua, opts,
+                                           project, keys, lua, opts,
                                            lexical_cast<string>(client), str));
       sess->begin_service();
       sessions.insert(make_pair(client.get_socketfd(), sess));
@@ -2774,7 +2769,6 @@ serve_connections(protocol_role role,
 serve_connections(protocol_role role,
                   globish const & include_pattern,
                   globish const & exclude_pattern,
-                  database & db,
                   project_t & project,
                   key_store & keys,
                   lua_hooks & lua,
@@ -2869,7 +2863,8 @@ serve_connections(protocol_role role,
                 probe.add(server);
 
               if (!guard)
-                guard = shared_ptr<transaction_guard>(new transaction_guard(db));
+                guard = shared_ptr<transaction_guard>
+                  (new transaction_guard(project.db));
 
               I(guard);
 
@@ -2907,7 +2902,7 @@ serve_connections(protocol_role role,
 
                       shared_ptr<session> sess(new session(role, client_voice,
                                                            inc, exc,
-                                                           db, project, keys,
+                                                           project, keys,
                                                            lua, opts,
                                                            addr(), server, true));
 
@@ -2948,7 +2943,7 @@ serve_connections(protocol_role role,
                   else if (fd == server)
                     handle_new_connection(addr, server, timeout, role,
                                           include_pattern, exclude_pattern,
-                                          sessions, db, project, keys,
+                                          sessions, project, keys,
                                           lua, opts);
 
                   // or an existing session woke up
@@ -3047,7 +3042,7 @@ serve_single_connection(shared_ptr<sessi
 
   sess->begin_service();
 
-  transaction_guard guard(sess->db);
+  transaction_guard guard(sess->project.db);
 
   map<Netxx::socket_type, shared_ptr<session> > sessions;
   set<Netxx::socket_type> armed_sessions;
@@ -3199,7 +3194,7 @@ session::rebuild_merkle_trees(set<branch
 
   {
     map<branch_name, epoch_data> epochs;
-    db.get_epochs(epochs);
+    project.db.get_epochs(epochs);
 
     epoch_data epoch_zero(string(constants::epochlen, '0'));
     for (set<branch_name>::const_iterator i = branchnames.begin();
@@ -3214,7 +3209,7 @@ session::rebuild_merkle_trees(set<branch
           {
             L(FL("setting epoch on %s to zero") % branch);
             epochs.insert(make_pair(branch, epoch_zero));
-            db.set_epoch(branch, epoch_zero);
+            project.db.set_epoch(branch, epoch_zero);
           }
 
         // Then insert all epochs into merkle tree.
@@ -3233,7 +3228,7 @@ session::rebuild_merkle_trees(set<branch
       pair<revision_id, rsa_keypair_id> > > cert_idx;
 
     cert_idx idx;
-    db.get_revision_cert_nobranch_index(idx);
+    project.db.get_revision_cert_nobranch_index(idx);
 
     // Insert all non-branch certs reachable via these revisions
     // (branch certs were inserted earlier).
@@ -3265,11 +3260,11 @@ session::rebuild_merkle_trees(set<branch
     {
       if (inserted_keys.find(*key) == inserted_keys.end())
         {
-          if (!db.public_key_exists(*key))
+          if (!project.db.public_key_exists(*key))
             {
               keypair kp;
               if (keys.maybe_get_key_pair(*key, kp))
-                db.put_key(*key, kp.pub);
+                project.db.put_key(*key, kp.pub);
               else
                 W(F("Cannot find key '%s'") % *key);
             }
@@ -3281,10 +3276,10 @@ session::rebuild_merkle_trees(set<branch
   for (set<rsa_keypair_id>::const_iterator key = inserted_keys.begin();
        key != inserted_keys.end(); key++)
     {
-      if (db.public_key_exists(*key))
+      if (project.db.public_key_exists(*key))
         {
           base64<rsa_pub_key> pub_encoded;
-          db.get_key(*key, pub_encoded);
+          project.db.get_key(*key, pub_encoded);
           hexenc<id> keyhash;
           key_hash_code(*key, pub_encoded, keyhash);
           L(FL("noting key '%s' = '%s' to send") % *key % keyhash);
@@ -3307,7 +3302,7 @@ run_netsync_protocol(protocol_voice voic
                      std::list<utf8> const & addrs,
                      globish const & include_pattern,
                      globish const & exclude_pattern,
-                     database & db, project_t & project, key_store & keys,
+                     project_t & project, key_store & keys,
                      lua_hooks & lua, options & opts)
 {
   if (include_pattern().find_first_of("'\"") != string::npos)
@@ -3334,13 +3329,13 @@ run_netsync_protocol(protocol_voice voic
               shared_ptr<Netxx::PipeStream> str(new Netxx::PipeStream(0,1));
               shared_ptr<session> sess(new session(role, server_voice,
                                                    include_pattern, exclude_pattern,
-                                                   db, project, keys, lua, opts,
+                                                   project, keys, lua, opts,
                                                    "stdio", str));
               serve_single_connection(sess,constants::netsync_timeout_seconds);
             }
           else
             serve_connections(role, include_pattern, exclude_pattern,
-                              db, project, keys, lua, opts,
+                              project, keys, lua, opts,
                               addrs, static_cast<Netxx::port_type>(constants::netsync_default_port),
                               static_cast<unsigned long>(constants::netsync_timeout_seconds),
                               static_cast<unsigned long>(constants::netsync_connection_limit));
@@ -3349,7 +3344,7 @@ run_netsync_protocol(protocol_voice voic
         {
           I(voice == client_voice);
           call_server(role, include_pattern, exclude_pattern,
-                      db, project, keys, lua, opts,
+                      project, keys, lua, opts,
                       addrs, static_cast<Netxx::port_type>(constants::netsync_default_port),
                       static_cast<unsigned long>(constants::netsync_timeout_seconds));
         }
============================================================
--- project.hh	e66140583a55d848e04c6ca22db6101f32b187a8
+++ project.hh	2bea810a7ef3f86571798989055c79cc5fda23df
@@ -30,8 +30,19 @@ class project_t
 
 class project_t
 {
+  // In the hypothetical future situation where one monotone process is
+  // using more than one database at a time, it will be essential to use a
+  // project object only with the database it was created from.  To make it
+  // easy to get this right, we expose the database handle inside the
+  // project object, and make it a style rule that you pass around a
+  // database _or_ you pass around a project; not both.
+public:
   database & db;
-  std::map<std::pair<branch_name, suspended_indicator>, std::pair<outdated_indicator, std::set<revision_id> > > branch_heads;
+
+private:
+  std::map<std::pair<branch_name, suspended_indicator>,
+           std::pair<outdated_indicator, std::set<revision_id> >
+           > branch_heads;
   std::set<branch_name> branches;
   outdated_indicator indicator;
 
============================================================
--- rcs_import.cc	f1cd9a1642dc94e9a50577a962d494b2295b1b18
+++ rcs_import.cc	2bdf86d7e0951c686cd68fcf60d831ee5ea2c363
@@ -664,7 +664,8 @@ static void
 
 
 static void
-import_rcs_file_with_cvs(string const & filename, database & db, cvs_history & cvs)
+import_rcs_file_with_cvs(string const & filename, database & db,
+                         cvs_history & cvs)
 {
   rcs_file r;
   L(FL("parsing RCS file %s") % filename);
@@ -1008,7 +1009,6 @@ cluster_consumer
 cluster_consumer
 {
   cvs_history & cvs;
-  database & db;
   key_store & keys;
   project_t & project;
 
@@ -1039,7 +1039,6 @@ cluster_consumer
   revision_id parent_rid, child_rid;
 
   cluster_consumer(cvs_history & cvs,
-                   database & db,
                    key_store & keys,
                    project_t & project,
                    string const & branchname,
@@ -1071,7 +1070,6 @@ import_branch(cvs_history & cvs,
 
 void
 import_branch(cvs_history & cvs,
-              database & db,
               key_store & keys,
               project_t & project,
               string const & branchname,
@@ -1079,7 +1077,7 @@ import_branch(cvs_history & cvs,
               ticker & n_revs)
 {
   cluster_set clusters;
-  cluster_consumer cons(cvs, db, keys, project, branchname, *branch, n_revs);
+  cluster_consumer cons(cvs, keys, project, branchname, *branch, n_revs);
   unsigned long commits_remaining = branch->lineage.size();
 
   // step 1: sort the lineage
@@ -1204,7 +1202,6 @@ import_cvs_repo(system_path const & cvsr
 
 void
 import_cvs_repo(system_path const & cvsroot,
-                database & db,
                 key_store & keys,
                 project_t & project,
                 branch_name const & branchname)
@@ -1225,9 +1222,9 @@ import_cvs_repo(system_path const & cvsr
   cvs.bstk.push(cvs.branch_interner.intern(cvs.base_branch));
 
   {
-    transaction_guard guard(db);
-    cvs_tree_walker walker(cvs, db);
-    db.ensure_open();
+    transaction_guard guard(project.db);
+    cvs_tree_walker walker(cvs, project.db);
+    project.db.ensure_open();
     change_current_working_dir(cvsroot);
     walk_tree(file_path(), walker);
     guard.commit();
@@ -1239,12 +1236,12 @@ import_cvs_repo(system_path const & cvsr
 
   while (cvs.branches.size() > 0)
     {
-      transaction_guard guard(db);
+      transaction_guard guard(project.db);
       map<string, shared_ptr<cvs_branch> >::const_iterator i = cvs.branches.begin();
       string branchname = i->first;
       shared_ptr<cvs_branch> branch = i->second;
       L(FL("branch %s has %d entries") % branchname % branch->lineage.size());
-      import_branch(cvs, db, keys, project, branchname, branch, n_revs);
+      import_branch(cvs, keys, project, branchname, branch, n_revs);
 
       // free up some memory
       cvs.branches.erase(branchname);
@@ -1252,16 +1249,16 @@ import_cvs_repo(system_path const & cvsr
     }
 
   {
-    transaction_guard guard(db);
+    transaction_guard guard(project.db);
     L(FL("trunk has %d entries") % cvs.trunk->lineage.size());
-    import_branch(cvs, db, keys, project, cvs.base_branch, cvs.trunk, n_revs);
+    import_branch(cvs, keys, project, cvs.base_branch, cvs.trunk, n_revs);
     guard.commit();
   }
 
   // now we have a "last" rev for each tag
   {
     ticker n_tags(_("tags"), "t", 1);
-    transaction_guard guard(db);
+    transaction_guard guard(project.db);
     for (map<unsigned long, pair<time_t, revision_id> >::const_iterator i = cvs.resolved_tags.begin();
          i != cvs.resolved_tags.end(); ++i)
       {
@@ -1275,14 +1272,12 @@ cluster_consumer::cluster_consumer(cvs_h
 }
 
 cluster_consumer::cluster_consumer(cvs_history & cvs,
-                                   database & db,
                                    key_store & keys,
                                    project_t & project,
                                    string const & branchname,
                                    cvs_branch const & branch,
                                    ticker & n_revs)
   : cvs(cvs),
-    db(db),
     keys(keys),
     project(project),
     branchname(branchname),
@@ -1342,7 +1337,7 @@ cluster_consumer::store_revisions()
 {
   for (vector<prepared_revision>::const_iterator i = preps.begin();
        i != preps.end(); ++i)
-    if (db.put_revision(i->rid, *(i->rev)))
+    if (project.db.put_revision(i->rid, *(i->rev)))
       {
         store_auxiliary_certs(*i);
         ++n_revisions;
============================================================
--- rcs_import.hh	975c217ebf5a3b8b73ebc64290f12b8050ce05f3
+++ rcs_import.hh	a1bdda69e06ea25a4b50cfea9c8e1dbf5f61edd5
@@ -17,7 +17,7 @@ void test_parse_rcs_file(system_path con
 class branch_name;
 
 void test_parse_rcs_file(system_path const & filename, database & db);
-void import_cvs_repo(system_path const & cvsroot, database & db, key_store & keys,
+void import_cvs_repo(system_path const & cvsroot, key_store & keys,
                      project_t & project, branch_name const & branchname);
 
 // Local Variables:
============================================================
--- selectors.cc	423dd7fe2a2668ef509bf9269163e0ffc867d387
+++ selectors.cc	a63cff13b6230113758688098d9be976db0ea60f
@@ -210,45 +210,45 @@ complete_one_selector(selector_type ty, 
 static void
 complete_one_selector(selector_type ty, string const & value,
                       set<revision_id> & completions,
-                      database & db, project_t & project)
+                      project_t & project)
 {
   switch (ty)
     {
     case sel_ident:
-      db.complete(value, completions);
+      project.db.complete(value, completions);
       break;
 
     case sel_parent:
-      db.select_parent(value, completions);
+      project.db.select_parent(value, completions);
       break;
         
     case sel_author:
-      db.select_cert(author_cert_name(), value, completions);
+      project.db.select_cert(author_cert_name(), value, completions);
       break;
 
     case sel_tag:
-      db.select_cert(tag_cert_name(), value, completions);
+      project.db.select_cert(tag_cert_name(), value, completions);
       break;
 
     case sel_branch:
       I(!value.empty());
-      db.select_cert(branch_cert_name(), value, completions);
+      project.db.select_cert(branch_cert_name(), value, completions);
       break;
 
     case sel_unknown:
-      db.select_author_tag_or_branch(value, completions);
+      project.db.select_author_tag_or_branch(value, completions);
       break;
 
     case sel_date:
-      db.select_date(value, "GLOB", completions);
+      project.db.select_date(value, "GLOB", completions);
       break;
 
     case sel_earlier:
-      db.select_date(value, "<=", completions);
+      project.db.select_date(value, "<=", completions);
       break;
 
     case sel_later:
-      db.select_date(value, ">", completions);
+      project.db.select_date(value, ">", completions);
       break;
 
     case sel_cert:
@@ -265,10 +265,10 @@ complete_one_selector(selector_type ty, 
             spot++;
             certvalue = value.substr(spot);
 
-            db.select_cert(certname, certvalue, completions);
+            project.db.select_cert(certname, certvalue, completions);
           }
         else
-          db.select_cert(value, completions);
+          project.db.select_cert(value, completions);
       }
       break;
 
@@ -300,23 +300,23 @@ complete_selector(selector_list const & 
 static void
 complete_selector(selector_list const & limit,
                   set<revision_id> & completions,
-                  database & db, project_t & project)
+                  project_t & project)
 {
   if (limit.empty()) // all the ids in the database
     {
-      db.complete("", completions);
+      project.db.complete("", completions);
       return;
     }
 
   selector_list::const_iterator i = limit.begin();
-  complete_one_selector(i->first, i->second, completions, db, project);
+  complete_one_selector(i->first, i->second, completions, project);
   i++;
 
   while (i != limit.end())
     {
       set<revision_id> candidates;
       set<revision_id> intersection;
-      complete_one_selector(i->first, i->second, candidates, db, project);
+      complete_one_selector(i->first, i->second, candidates, project);
 
       intersection.clear();
       set_intersection(completions.begin(), completions.end(),
@@ -348,7 +348,7 @@ complete(app_state & app,
     }
 
   P(F("expanding selection '%s'") % str);
-  complete_selector(sels, completions, app.db, app.get_project());
+  complete_selector(sels, completions, app.get_project());
 
   N(completions.size() != 0,
     F("no match for selection '%s'") % str);
@@ -398,7 +398,7 @@ expand_selector(app_state & app,
       return;
     }
 
-  complete_selector(sels, completions, app.db, app.get_project());
+  complete_selector(sels, completions, app.get_project());
 }
 
 void
@@ -413,7 +413,7 @@ diagnose_ambiguous_expansion(app_state &
                 % str).str();
   for (set<revision_id>::const_iterator i = completions.begin();
        i != completions.end(); ++i)
-    err += ("\n" + describe_revision(app.db, app.get_project(), *i));
+    err += ("\n" + describe_revision(app.get_project(), *i));
 
   N(false, i18n_format(err));
 }
============================================================
--- update.cc	2bad4b1ea8a05c37326d410761008d51032074ef
+++ update.cc	4ff426265325f41011fa8460cd261ca645646d5a
@@ -55,7 +55,7 @@ get_test_results_for_revision(revision_i
 static void
 get_test_results_for_revision(revision_id const & id,
                               map<rsa_keypair_id, bool> & results,
-                              database & db, project_t & project)
+                              project_t & project)
 {
   vector< revision<cert> > certs;
   project.get_revision_certs_by_name(id, cert_name(testresult_cert_name),
@@ -82,7 +82,7 @@ acceptable_descendent(branch_name const 
                       revision_id const & base,
                       map<rsa_keypair_id, bool> & base_results,
                       revision_id const & target,
-                      database & db, project_t & project,
+                      project_t & project,
                       lua_hooks & lua)
 {
   L(FL("Considering update target %s") % target);
@@ -96,7 +96,7 @@ acceptable_descendent(branch_name const 
 
   // step 2: check the testresults
   map<rsa_keypair_id, bool> target_results;
-  get_test_results_for_revision(target, target_results, db, project);
+  get_test_results_for_revision(target, target_results, project);
   if (lua.hook_accept_testresult_change(base_results, target_results))
     {
       L(FL("%s is acceptable update candidate") % target);
@@ -113,21 +113,21 @@ pick_update_candidates(set<revision_id> 
 pick_update_candidates(set<revision_id> & candidates,
                        revision_id const & base,
                        branch_name const & branch,
+                       project_t & project,
                        bool ignore_suspend_certs,
-                       database & db, project_t & project,
                        lua_hooks & lua)
 {
   I(!null_id(base));
   I(!branch().empty());
 
   map<rsa_keypair_id, bool> base_results;
-  get_test_results_for_revision(base, base_results, db, project);
+  get_test_results_for_revision(base, base_results, project);
 
   candidates.clear();
   // we possibly insert base into the candidate set as well; returning a set
   // containing just it means that we are up to date; returning an empty set
   // means that there is no acceptable update.
-  if (acceptable_descendent(branch, base, base_results, base, db, project, lua))
+  if (acceptable_descendent(branch, base, base_results, base, project, lua))
     candidates.insert(base);
 
   // keep a visited set to avoid repeating work
@@ -135,7 +135,7 @@ pick_update_candidates(set<revision_id> 
   set<revision_id> children;
   vector<revision_id> to_traverse;
 
-  db.get_revision_children(base, children);
+  project.db.get_revision_children(base, children);
   copy(children.begin(), children.end(), back_inserter(to_traverse));
 
   while (!to_traverse.empty())
@@ -150,15 +150,15 @@ pick_update_candidates(set<revision_id> 
 
       // then, possibly insert this revision as a candidate
       if (acceptable_descendent(branch, base, base_results,
-                                target, db, project, lua))
+                                target, project, lua))
         candidates.insert(target);
 
       // and traverse its children as well
-      db.get_revision_children(target, children);
+      project.db.get_revision_children(target, children);
       copy(children.begin(), children.end(), back_inserter(to_traverse));
     }
 
-  erase_ancestors(candidates, db);
+  erase_ancestors(candidates, project.db);
 
   if (ignore_suspend_certs)
     return;
============================================================
--- update.hh	f0350936544465c9bd29166d2c809ca1a24acc79
+++ update.hh	af0e12d08bd51ce590f3f7de9e6ac7bf252712cc
@@ -13,7 +13,6 @@
 #include <set>
 #include "vocab.hh"
 
-class database;
 class project_t;
 class lua_hooks;
 
@@ -29,8 +28,8 @@ void pick_update_candidates(std::set<rev
 void pick_update_candidates(std::set<revision_id> & candidates,
                             revision_id const & base_ident,
                             branch_name const & branchname,
+                            project_t & project,
                             bool ignore_suspend_certs,
-                            database & db, project_t & project,
                             lua_hooks & lua);
 
 // Local Variables: