#
#
# patch "mtn_cvs/Makefile.am"
#  from [ef9c574400c98dbb33e4509bdba2fe165d83af1f]
#    to [6adc28ce3e8187df8fea247772c7192ec94f86e5]
# 
# patch "mtn_cvs/cvs_client.cc"
#  from [5d7e3478a7a99c55e3122c98c51dc5fcb05db697]
#    to [350504a1a568913eca849a996f03fd0de49a7f8b]
# 
# patch "mtn_cvs/cvs_sync.cc"
#  from [05ce02a596b076dc862d92f378a0a361edf0865b]
#    to [f01d3ab265012a5df1d211b72fd12367800e6c09]
# 
# patch "mtn_cvs/cvs_sync_pull.cc"
#  from [b6c307907836f4ba9143a60df584e7bb2783c81c]
#    to [de69440a552933744f744532beeda6c8ab790fcb]
# 
# patch "mtn_cvs/cvs_sync_push.cc"
#  from [c38afdc462021c4a36fd88f863d566aff1163ebb]
#    to [e3b149a83cc6de7343be174701ad9e373df407c6]
# 
# patch "mtn_cvs/cvs_sync_takeover.cc"
#  from [fab8adee5d700ee0e2f1e74e8cb041d2b075b011]
#    to [fc15d0c472c21a107bfb94d12ebfd8b6d7caa9ed]
# 
# patch "mtn_cvs/mtn_automate.cc"
#  from [98558a2817ab068dde6305504ed5d32ef4af8144]
#    to [f12b7c143543981b35ba358ba78b2a80fe599d12]
# 
# patch "mtn_cvs/mtn_cvs.cc"
#  from [d44d6722cfa17b1f68dd6760c64c2e0bebb71877]
#    to [cba272faed07c62c7432c3caf15f016274def2ac]
# 
# patch "mtn_cvs/mtn_pipe.cc"
#  from [e7301e40a135e59b2e38b710ef9a6e6f21e60379]
#    to [ad7b9a7bdb821f697701f9fd066c28a3ea2b2dcc]
# 
# patch "mtn_cvs/options_list.hh"
#  from [501f3906548c56552b6b0aead1471758c42237c9]
#    to [a0c250180df7dd9509af7f0b036bad0e3eb93661]
# 
# patch "mtn_cvs/piece_table.cc"
#  from [f91003f8ded135319434d64ac50e7a1286bfea67]
#    to [14d20dee7fcf6fd1203183077a906cbceec9540c]
#
============================================================
--- mtn_cvs/Makefile.am	ef9c574400c98dbb33e4509bdba2fe165d83af1f
+++ mtn_cvs/Makefile.am	6adc28ce3e8187df8fea247772c7192ec94f86e5
@@ -1,4 +1,4 @@
-AM_CXXFLAGS=-I. -I.. -DLIBMTN_COMPILE
+AM_CXXFLAGS=-I. -I.. -DLIBMTN_COMPILE -I../lua
 
 noinst_LIBRARIES=libmtn.a
 
============================================================
--- mtn_cvs/cvs_client.cc	5d7e3478a7a99c55e3122c98c51dc5fcb05db697
+++ mtn_cvs/cvs_client.cc	350504a1a568913eca849a996f03fd0de49a7f8b
@@ -32,7 +32,7 @@ void cvs_client::writestr(const std::str
   { compress.next_out=(Bytef*)outbuf;
     compress.avail_out=sizeof outbuf;
     int err=deflate(&compress,flush?Z_SYNC_FLUSH:Z_NO_FLUSH);
-    E(err==Z_OK || err==Z_BUF_ERROR, F("deflate error %d") % err);
+    E(err==Z_OK || err==Z_BUF_ERROR, origin::network, F("deflate error %d") % err);
     unsigned written=sizeof(outbuf)-compress.avail_out;
     if (written && byte_out_ticker.get())
       (*byte_out_ticker)+=stream->write(outbuf,written);
@@ -48,7 +48,7 @@ std::string cvs_client::readline()
   std::string result;
   for (;;)
   { if (inputbuffer.empty()) underflow(); 
-    E(!inputbuffer.empty(),F("no data avail"));
+    E(!inputbuffer.empty(),origin::network, F("no data avail"));
     std::string::size_type eol=inputbuffer.find('\n');
     if (eol==std::string::npos)
     { result+=inputbuffer;
@@ -85,9 +85,9 @@ try_again:
 try_again:
   Netxx::Probe::result_type res = probe.ready(Netxx::Timeout(60L),
                       Netxx::Probe::ready_read); // 60 seconds
-  E((res.second&Netxx::Probe::ready_read),F("timeout reading from CVS server"));
+  E((res.second&Netxx::Probe::ready_read),origin::network, F("timeout reading from CVS server"));
   ssize_t avail_in=stream->read(buf,sizeof buf);
-  E(avail_in>0, F("read error %s") % strerror(errno));
+  E(avail_in>0, origin::network, F("read error %s") % strerror(errno));
   if (byte_in_ticker.get())
     (*byte_in_ticker)+=avail_in;
   if (!gzip_level)
@@ -100,7 +100,7 @@ try_again:
   { decompress.next_out=(Bytef*)buf2;
     decompress.avail_out=sizeof(buf2);
     int err=inflate(&decompress,Z_NO_FLUSH);
-    E(err==Z_OK || err==Z_BUF_ERROR, F("inflate error %d") % err);
+    E(err==Z_OK || err==Z_BUF_ERROR, origin::network, F("inflate error %d") % err);
     unsigned bytes_in=sizeof(buf2)-decompress.avail_out;
     if (bytes_in) inputbuffer+=std::string(buf2,buf2+bytes_in);
     else break;
@@ -195,7 +195,7 @@ std::string cvs_client::localhost_name()
 #ifdef WIN32
   strcpy(domainname,"localhost"); // gethostname does not work here ...
 #else
-  E(!gethostname(domainname,sizeof domainname),
+  E(!gethostname(domainname,sizeof domainname),origin::internal,
     F("gethostname %s\n") % strerror(errno));
   domainname[sizeof(domainname)-1]=0;
 #endif
@@ -205,7 +205,7 @@ std::string cvs_client::localhost_name()
   { domainname[len]='.';
     domainname[++len]=0;
   }
-  E(!getdomainname(domainname+len,sizeof(domainname)-len),
+  E(!getdomainname(domainname+len,sizeof(domainname)-len),origin::internal,
     F("getdomainname %s\n") % strerror(errno));
   domainname[sizeof(domainname)-1]=0;
 #endif
@@ -230,7 +230,7 @@ void cvs_client::connect()
     writestr(pserver_password(":pserver:"+user+"@"+host+":"+root)+"\n");
     writestr("END AUTH REQUEST\n");
     std::string answer=readline();
-    E(answer=="I LOVE YOU", F("pserver Authentification failed\n"));
+    E(answer=="I LOVE YOU", origin::network, F("pserver Authentification failed\n"));
   }
   else // rsh
   { std::string local_name=localhost_name();
@@ -284,13 +284,13 @@ void cvs_client::connect()
   std::string answer=readline();
   MM(answer);
   E(begins_with(answer,"Valid-requests "),
-      F("CVS server answered '%s' to Valid-requests\n") % answer);
+      origin::network, F("CVS server answered '%s' to Valid-requests\n") % answer);
   // boost::tokenizer does not provide the needed functionality (e.g. preserve -)
   push_back2insert<stringset_t> adaptor(Valid_requests);
   stringtok(adaptor,answer.substr(15));
   answer=readline();
   E(answer=="ok",
-      F("CVS server did not answer ok to Valid-requests: %s\n") % answer);
+      origin::network, F("CVS server did not answer ok to Valid-requests: %s\n") % answer);
   
   I(CommandValid("UseUnchanged"));
   writestr("UseUnchanged\n");
@@ -318,9 +318,9 @@ void cvs_client::InitZipStream(int level
 
 void cvs_client::InitZipStream(int level)
 { int error=deflateInit(&compress,level);
-  E(error==Z_OK,F("deflateInit %d\n") % error);
+  E(error==Z_OK,origin::internal,F("deflateInit %d\n") % error);
   error=inflateInit(&decompress);
-  E(error==Z_OK,F("inflateInit %d\n") % error);
+  E(error==Z_OK,origin::internal,F("inflateInit %d\n") % error);
 }
 
 void cvs_client::GzipStream(int level)
@@ -330,7 +330,7 @@ void cvs_client::GzipStream(int level)
   cmd+='\n';
   writestr(cmd);
   int error=deflateParams(&compress,level,Z_DEFAULT_STRATEGY);
-  E(error==Z_OK,F("deflateParams %d\n") % error);
+  E(error==Z_OK,origin::internal,F("deflateParams %d\n") % error);
   gzip_level=level;
 }
 
@@ -562,7 +562,7 @@ static time_t cvs111date2time_t(const st
 static time_t cvs111date2time_t(const std::string &t)
 { // 2000/11/10 14:43:25
   MM(t);
-  E(t.size()==19, F("cvs111date2time_t unknown format '%s'\n") % t);
+  E(t.size()==19, origin::internal,F("cvs111date2time_t unknown format '%s'\n") % t);
   I(t[4]=='/' && t[7]=='/');
   I(t[10]==' ' && t[13]==':');
   I(t[16]==':');
@@ -581,7 +581,7 @@ static time_t rls_l2time_t(const std::st
 static time_t rls_l2time_t(const std::string &t)
 { // 2003-11-26 09:20:57 +0000
   MM(t);
-  E(t.size()==25, F("rls_l2time_t unknown format '%s'\n") % t);
+  E(t.size()==25, origin::internal,F("rls_l2time_t unknown format '%s'\n") % t);
   I(t[4]=='-' && t[7]=='-');
   I(t[10]==' ' && t[13]==':');
   I(t[16]==':' && t[19]==' ');
@@ -646,7 +646,7 @@ time_t cvs_client::Entries2time_t(const 
 
 time_t cvs_client::Entries2time_t(const std::string &t)
 { MM(t);
-  E(t.size()==24, F("Entries2time_t unknown format '%s'\n") % t);
+  E(t.size()==24, origin::workspace,F("Entries2time_t unknown format '%s'\n") % t);
   I(t[3]==' ');
   I(t[7]==' ');
   std::vector<std::string> parts;
@@ -863,7 +863,7 @@ void cvs_client::processLogOutput(const 
     I(!lresult.empty());
     MM(lresult[0].first);
     MM(lresult[0].second);
-    E(lresult[0].first!="CMD" || lresult[0].second!="error", F("log failed"));
+    E(lresult[0].first!="CMD" || lresult[0].second!="error", origin::network,F("log failed"));
     switch(state)
     { case st_head:
       { std::string result=combine_result(lresult);
@@ -1025,7 +1025,7 @@ cvs_client::checkout cvs_client::CheckOu
     { case st_co:
       { I(!lresult.empty());
         if (lresult[0].first=="CMD")
-        { E(lresult[0].second!="error", F("failed to check out %s\n") % file);
+        { E(lresult[0].second!="error", origin::network,F("failed to check out %s\n") % file);
           if (lresult[0].second=="Clear-sticky")
           { I(lresult.size()==3);
             I(lresult[1].first=="dir");
@@ -1299,7 +1299,7 @@ void cvs_client::Update(const std::vecto
         result.contents=lresult[6].second; // strictly this is unnecessary ...
         parse_entry(lresult[3].second,result.new_revision,result.keyword_substitution);
         result.mode=permissions2int(lresult[4].second);
-        E(false, F("Update ->%s of %s exposed CVS bug\n") 
+        E(false, origin::network,F("Update ->%s of %s exposed CVS bug\n") 
             % result.new_revision % result.file);
         cb(result);
         result=update();
@@ -1512,7 +1512,7 @@ std::vector<std::string> cvs_client::Exp
   std::vector<std::pair<std::string,std::string> > lresult;
   while (fetch_result(lresult))
   { if (lresult.size()==1 && lresult[0].first=="CMD" && lresult[0].second=="error")
-      E(false, F("error accessing CVS module %s\n") % module);
+      E(false, origin::network,F("error accessing CVS module %s\n") % module);
     I(lresult.size()==2);
     I(lresult[0].second=="Module-expansion");
     result.push_back(lresult[1].second);
============================================================
--- mtn_cvs/cvs_sync.cc	05ce02a596b076dc862d92f378a0a361edf0865b
+++ mtn_cvs/cvs_sync.cc	f01d3ab265012a5df1d211b72fd12367800e6c09
@@ -96,26 +96,26 @@ std::string debug_manifest(const cvs_man
   { result+= i->first + " " + i->second->cvs_version;
     if (!i->second->keyword_substitution.empty()) 
       result+="/"+i->second->keyword_substitution;
-    result+=" " + std::string(i->second->dead?"dead ":"") + encode_hexenc(i->second->sha1sum.inner()()) + "\n";
+    result+=" " + std::string(i->second->dead?"dead ":"") + encode_hexenc(i->second->sha1sum.inner()(),origin::internal) + "\n";
   }
   return result;
 }
 
 template <> void
-static dump(cvs_sync::file_state const& fs, std::string& result)
+dump(cvs_sync::file_state const& fs, std::string& result)
 { 
     result="since "+cvs_repository::time_t2human(fs.since_when);
     result+=" V"+fs.cvs_version+" ";
     if (fs.dead) result+= "dead";
     else if (fs.size) result+= boost::lexical_cast<string>(fs.size);
     else if (fs.patchsize) result+= "p" + boost::lexical_cast<string>(fs.patchsize);
-    else if (!fs.sha1sum.inner()().empty()) result+= encode_hexenc(fs.sha1sum.inner()()).substr(0,4) + fs.keyword_substitution;
+    else if (!fs.sha1sum.inner()().empty()) result+= encode_hexenc(fs.sha1sum.inner()(),origin::internal).substr(0,4) + fs.keyword_substitution;
     result+=" "+fs.log_msg.substr(0,20)+"\n";
 }
 
 std::string cvs_repository::debug_file(std::string const& name)
 { std::map<std::string,file_history>::const_iterator i=files.find(name);
-  E(i!=files.end(),F("file '%s' not found\n") % name);
+  E(i!=files.end(),origin::internal,F("file '%s' not found\n") % name);
   std::string result;
   for (std::set<file_state>::const_iterator j=i->second.known_states.begin();
         j!=i->second.known_states.end();++j)
@@ -156,27 +156,27 @@ void cvs_repository::parse_cvs_cert_head
 { 
 //  MM(value);
   file_path sp=file_path_internal("");
-  repository=const_map_access(value,std::make_pair(sp,attr_key(domain+":root")))();
-  module=const_map_access(value,std::make_pair(sp,attr_key(domain+":module")))();
-  branch=const_map_access(value,std::make_pair(sp,attr_key(domain+":branch")))();
+  repository=const_map_access(value,std::make_pair(sp,attr_key(domain+":root",origin::internal)))();
+  module=const_map_access(value,std::make_pair(sp,attr_key(domain+":module",origin::internal)))();
+  branch=const_map_access(value,std::make_pair(sp,attr_key(domain+":branch",origin::internal)))();
 }
 
 mtn_automate::sync_map_t cvs_repository::create_cvs_cert_header() const
 { 
   mtn_automate::sync_map_t result;
   file_path sp=file_path_internal("");
-  result[std::make_pair(sp,attr_key(app.opts.domain+":root"))]= attr_value(host+":"+root);
-  result[std::make_pair(sp,attr_key(app.opts.domain+":module"))]= attr_value(module);
+  result[std::make_pair(sp,attr_key(app.opts.domain+":root",origin::internal))]= attr_value(host+":"+root,origin::internal);
+  result[std::make_pair(sp,attr_key(app.opts.domain+":module",origin::internal))]= attr_value(module,origin::internal);
   if (!branch.empty())
-    result[std::make_pair(sp,attr_key(app.opts.domain+":branch"))]= attr_value(branch);
+    result[std::make_pair(sp,attr_key(app.opts.domain+":branch",origin::internal))]= attr_value(branch,origin::internal);
   return result;
 }
 
 template <> void
-static dump(cvs_sync::cvs_edge const& e, std::string& result)
+dump(cvs_sync::cvs_edge const& e, std::string& result)
 { result= "[" + cvs_repository::time_t2human(e.time);
     if (e.time!=e.time2) result+= "+" + boost::lexical_cast<string>(e.time2-e.time);
-    if (!e.revision.inner()().empty()) result+= "," + encode_hexenc(e.revision.inner()()).substr(0,4);
+    if (!e.revision.inner()().empty()) result+= "," + encode_hexenc(e.revision.inner()(),origin::internal).substr(0,4);
     if (!e.xfiles.empty()) 
       result+= "," + boost::lexical_cast<string>(e.xfiles.size()) 
          + (e.delta_base.inner()().empty()?"files":"deltas");
@@ -303,7 +303,7 @@ mtn_automate::sync_map_t cvs_repository:
     }
     file_path sp=file_path_internal(dirname);
     if (!dirname.empty() || i->second!=root+"/"+module+"/")
-      state[std::make_pair(sp,attr_key(app.opts.domain+":path"))]=attr_value(i->second);
+      state[std::make_pair(sp,attr_key(app.opts.domain+":path",origin::internal))]=attr_value(i->second,origin::internal);
   }
   
   for (cvs_manifest::const_iterator i=e.xfiles.begin(); i!=e.xfiles.end(); ++i)
@@ -324,15 +324,15 @@ mtn_automate::sync_map_t cvs_repository:
     I(!i->second->cvs_version.empty());
 #endif
     file_path sp=file_path_internal(i->first);
-    state[std::make_pair(sp,attr_key(app.opts.domain+":revision"))]
-        =attr_value(i->second->cvs_version);
+    state[std::make_pair(sp,attr_key(app.opts.domain+":revision",origin::internal))]
+        =attr_value(i->second->cvs_version,origin::internal);
     if (!i->second->keyword_substitution.empty())
-      state[std::make_pair(sp,attr_key(app.opts.domain+":keyword"))]
-          =attr_value(i->second->keyword_substitution);
+      state[std::make_pair(sp,attr_key(app.opts.domain+":keyword",origin::internal))]
+          =attr_value(i->second->keyword_substitution,origin::internal);
 // FIXME: How to flag locally modified files? add the synched sha1sum?
     if (!i->second->sha1sum.inner()().empty())
-      state[std::make_pair(sp,attr_key(app.opts.domain+":sha1"))]
-            =attr_value(encode_hexenc(i->second->sha1sum.inner()()).substr(0,6));
+      state[std::make_pair(sp,attr_key(app.opts.domain+":sha1",origin::internal))]
+            =attr_value(encode_hexenc(i->second->sha1sum.inner()(),origin::internal).substr(0,6),origin::internal);
   }
   return state;
 }
@@ -347,7 +347,7 @@ cvs_repository::cvs_repository(mtncvs_st
   remove_state=remove_set.insert(file_state(0,"-",true)).first;
   if (!app.opts.since.empty())
   { sync_since=posix2time_t(app.opts.since);
-    N(sync_since<=time(0), F("Since lies in the future. Remember to specify time in UTC\n"));
+    E(sync_since<=time(0), origin::user, F("Since lies in the future. Remember to specify time in UTC\n"));
   }
 }
 
@@ -391,7 +391,7 @@ static void guess_repository(std::string
                 % branch % module % repository);
   }
   catch (std::runtime_error)
-  { N(false, F("can not guess repository (in domain %s), "
+  { E(false, origin::internal, F("can not guess repository (in domain %s), "
         "please specify on first pull") % app.opts.domain);
   }
 }
@@ -406,11 +406,11 @@ cvs_sync::cvs_repository *cvs_sync::prep
   revision_id lastid;
   if (app.opts.branchname().empty())
   {
-    app.opts.branchname=branch_name(app.get_option("branch"));
+    app.opts.branchname=branch_name(app.get_option("branch"),origin::user);
     if (!app.opts.branchname().empty() && app.opts.branchname()[app.opts.branchname().size()-1]=='\n')
-      app.opts.branchname=branch_name(app.opts.branchname().substr(0,app.opts.branchname().size()-1));
+      app.opts.branchname=branch_name(app.opts.branchname().substr(0,app.opts.branchname().size()-1),origin::user);
   }
-  N(!app.opts.branchname().empty(), F("no destination branch specified\n"));
+  E(!app.opts.branchname().empty(), origin::user, F("no destination branch specified\n"));
   { std::string rep,mod,br;
     // search for module and last revision
     guess_repository(rep, mod, br, last_sync_info, lastid, app);
@@ -435,8 +435,8 @@ cvs_sync::cvs_repository *cvs_sync::prep
         W(F("Branches do not match: '%s' != '%s'\n") % branch % br);
     }
   }
-  N(!repository.empty(), F("you must name a repository, I can't guess"));
-  N(!module.empty(), F("you must name a module, I can't guess"));
+  E(!repository.empty(), origin::user, F("you must name a repository, I can't guess"));
+  E(!module.empty(), origin::user, F("you must name a module, I can't guess"));
    
   cvs_repository *repo = new cvs_repository(app,repository,module,branch);
 // turn compression on when not DEBUGGING
@@ -455,9 +455,9 @@ revision_id cvs_sync::last_sync(mtncvs_s
 	app.open();
 	  mtn_automate::sync_map_t last_sync_info;
 	  revision_id lastid;
-	  app.opts.branchname=branch_name(app.get_option("branch"));
+	  app.opts.branchname=branch_name(app.get_option("branch"),origin::user);
 	  if (!app.opts.branchname().empty() && app.opts.branchname()[app.opts.branchname().size()-1]=='\n')
-	      app.opts.branchname=branch_name(app.opts.branchname().substr(0,app.opts.branchname().size()-1));
+	      app.opts.branchname=branch_name(app.opts.branchname().substr(0,app.opts.branchname().size()-1),origin::user);
 	  std::string rep,mod,br;
 	    // search for module and last revision
 	  guess_repository(rep, mod, br, last_sync_info, lastid, app);
@@ -505,9 +505,9 @@ void cvs_repository::process_sync_info(m
         
         file_state fs;
         fs.since_when=e.time;
-        fs.cvs_version=const_map_access(sync_info,std::make_pair(sp,attr_key(app.opts.domain+":revision")))();
-        fs.cvssha1sum=const_map_access(sync_info,std::make_pair(sp,attr_key(app.opts.domain+":sha1")))();
-        fs.keyword_substitution=const_map_access(sync_info,std::make_pair(sp,attr_key(app.opts.domain+":keywords")))();
+        fs.cvs_version=const_map_access(sync_info,std::make_pair(sp,attr_key(app.opts.domain+":revision",origin::internal)))();
+        fs.cvssha1sum=const_map_access(sync_info,std::make_pair(sp,attr_key(app.opts.domain+":sha1",origin::internal)))();
+        fs.keyword_substitution=const_map_access(sync_info,std::make_pair(sp,attr_key(app.opts.domain+":keywords",origin::internal)))();
         
         fs.sha1sum=i->second.first;
         if (fs.sha1sum.inner()().empty()) continue; // directory node
@@ -581,7 +581,7 @@ void cvs_sync::debug(const std::string &
     std::vector< revision<cert> > certs;
     app.db.get_revision_certs(rid,cvs_cert_name,certs);
     // erase_bogus_certs ?
-    N(!certs.empty(),F("revision has no 'cvs-revisions' certificates\n"));
+    E(!certs.empty(),origin::user,F("revision has no 'cvs-revisions' certificates\n"));
     
     std::string repository,module,branch;
     cvs_repository::parse_cvs_cert_header(certs.front(), repository, module, branch);
============================================================
--- mtn_cvs/cvs_sync_pull.cc	b6c307907836f4ba9143a60df584e7bb2783c81c
+++ mtn_cvs/cvs_sync_pull.cc	de69440a552933744f744532beeda6c8ab790fcb
@@ -74,27 +74,27 @@ void cvs_repository::store_update(std::s
     }
     // check md5
     Botan::MD5 hash;
-    std::string md5sum=xform<Botan::Hex_Decoder>(u.checksum);
+    std::string md5sum=xform<Botan::Hex_Decoder>(u.checksum,origin::internal);
     I(md5sum.size()==hash.OUTPUT_LENGTH);
     Botan::SecureVector<Botan::byte> hashval=hash.process(contents);
     I(hashval.size()==hash.OUTPUT_LENGTH);
     unsigned hashidx=hash.OUTPUT_LENGTH;
     for (;hashidx && hashval[hashidx-1]==Botan::byte(md5sum[hashidx-1]);--hashidx) ;
     if (!hashidx)
-    { store_delta(file_data(contents), file_data(old_contents), s->sha1sum, 
+    { store_delta(file_data(contents,origin::internal), file_data(old_contents,origin::internal), s->sha1sum, 
 			const_cast<file_id&>(s2->sha1sum));
     }
     else
-    { E(false, F("MD5 sum %s<>%s") % u.checksum 
-          % xform<Botan::Hex_Encoder>(std::string(hashval.begin(),hashval.end())));
+    { E(false, origin::internal, F("MD5 sum %s<>%s") % u.checksum 
+          % xform<Botan::Hex_Encoder>(std::string(hashval.begin(),hashval.end()),origin::internal));
     }
   }
   else
   { if (!s->sha1sum.inner()().empty()) 
     // we default to patch if it's at all possible
-      store_delta(file_data(u.contents), file_data(contents), s->sha1sum, const_cast<file_id&>(s2->sha1sum));
+      store_delta(file_data(u.contents,origin::internal), file_data(contents,origin::internal), s->sha1sum, const_cast<file_id&>(s2->sha1sum));
     else
-      store_contents(file_data(u.contents), const_cast<file_id&>(s2->sha1sum));
+      store_contents(file_data(u.contents,origin::internal), const_cast<file_id&>(s2->sha1sum));
     const_cast<unsigned&>(s2->size)=u.contents.size();
     contents=u.contents;
     const_cast<std::string&>(s2->keyword_substitution)=u.keyword_substitution;
@@ -125,7 +125,7 @@ void cvs_repository::update(std::set<fil
     if (c.mod_time!=s2->since_when && c.mod_time!=-1 && s2->since_when!=sync_since)
     { W(F("checkout time %s and log time %s disagree\n") % time_t2human(c.mod_time) % time_t2human(s2->since_when));
     }
-    store_contents(file_data(c.contents), const_cast<file_id&>(s2->sha1sum));
+    store_contents(file_data(c.contents,origin::internal), const_cast<file_id&>(s2->sha1sum));
     const_cast<unsigned&>(s2->size)=c.contents.size();
     contents=c.contents;
     const_cast<std::string&>(s2->keyword_substitution)=c.keyword_substitution;
@@ -137,7 +137,7 @@ void cvs_repository::update(std::set<fil
   { cvs_client::update u=Update(file,s->cvs_version,s2->cvs_version,s->keyword_substitution);
     try 
     { store_update(s,s2,u,contents);
-    } catch (informative_failure &e)
+    } catch (recoverable_failure &e)
     { W(F("Update: patching failed with %s\n") % e.what());
       cvs_client::update c=Update(file,s2->cvs_version);
       if (c.mod_time!=s2->since_when && c.mod_time!=-1 && s2->since_when!=sync_since)
@@ -145,7 +145,7 @@ void cvs_repository::update(std::set<fil
       }
       const_cast<std::string&>(s2->md5sum)="";
       const_cast<unsigned&>(s2->patchsize)=0;
-      store_contents(file_data(c.contents), const_cast<file_id&>(s2->sha1sum));
+      store_contents(file_data(c.contents,origin::internal), const_cast<file_id&>(s2->sha1sum));
       const_cast<unsigned&>(s2->size)=c.contents.size();
       contents=c.contents;
       const_cast<std::string&>(s2->keyword_substitution)=c.keyword_substitution;
@@ -157,7 +157,7 @@ void cvs_repository::update(std::set<fil
       }
       const_cast<std::string&>(s2->md5sum)="";
       const_cast<unsigned&>(s2->patchsize)=0;
-      store_contents(file_data(c.contents), const_cast<file_id&>(s2->sha1sum));
+      store_contents(file_data(c.contents,origin::internal), const_cast<file_id&>(s2->sha1sum));
       const_cast<unsigned&>(s2->size)=c.contents.size();
       contents=c.contents;
       const_cast<std::string&>(s2->keyword_substitution)=c.keyword_substitution;
@@ -173,7 +173,7 @@ void cvs_repository::store_checkout(std:
     if (c.mod_time!=s2->since_when && c.mod_time!=-1 && s2->since_when!=sync_since)
     { W(F("checkout time %s and log time %s disagree\n") % time_t2human(c.mod_time) % time_t2human(s2->since_when));
     }
-    store_contents(file_data(c.contents), const_cast<file_id&>(s2->sha1sum));
+    store_contents(file_data(c.contents,origin::internal), const_cast<file_id&>(s2->sha1sum));
     const_cast<unsigned&>(s2->size)=c.contents.size();
     file_contents=c.contents;
     const_cast<std::string&>(s2->keyword_substitution)=c.keyword_substitution;
@@ -189,7 +189,7 @@ void cvs_repository::store_checkout(std:
     if (c.mod_time!=s2->since_when && c.mod_time!=-1 && s2->since_when!=sync_since)
     { W(F("checkout time %s and log time %s disagree\n") % time_t2human(c.mod_time) % time_t2human(s2->since_when));
     }
-    store_contents(file_data(c.contents), const_cast<file_id&>(s2->sha1sum));
+    store_contents(file_data(c.contents,origin::internal), const_cast<file_id&>(s2->sha1sum));
     const_cast<unsigned&>(s2->size)=c.contents.size();
     file_contents=c.contents;
     const_cast<std::string&>(s2->keyword_substitution)=c.keyword_substitution;
@@ -247,14 +247,14 @@ void cvs_repository::attach_sync_state(c
   }
   // delete old dummy attribute if present
   { mtn_automate::manifest_map::const_iterator f=oldmanifest.find(file_path_internal(""));
-    if (f!=oldmanifest.end() && f->second.second.find(attr_key(app.opts.domain+":touch"))!=f->second.second.end())
-    { cs.attrs_cleared.insert(std::make_pair(file_path_internal(""),attr_key(app.opts.domain+":touch")));
+    if (f!=oldmanifest.end() && f->second.second.find(attr_key(app.opts.domain+":touch",origin::internal))!=f->second.second.end())
+    { cs.attrs_cleared.insert(std::make_pair(file_path_internal(""),attr_key(app.opts.domain+":touch",origin::internal)));
       any_change=true;
     }
   }
   if (!any_change) // this happens if only deletions happened
-  { cs.attrs_set[std::make_pair(file_path_internal(""),attr_key(app.opts.domain+":touch"))]
-        =attr_value("synchronized");
+  { cs.attrs_set[std::make_pair(file_path_internal(""),attr_key(app.opts.domain+":touch",origin::internal))]
+        =attr_value("synchronized",origin::internal);
   }
 }
 
@@ -482,7 +482,7 @@ void cvs_repository::prime()
     
     if (!branch.empty())
     { args.push_back("-r"+branch);
-      N(sync_since==-1, F("--since does not work on a side branch"));
+      E(sync_since==-1, origin::user, F("--since does not work on a side branch"));
     }
     else 
       args.push_back("-b");
@@ -707,13 +707,13 @@ void cvs_repository::update()
       { // we do not need to ask the host, we already did ...
         try
         { store_update(last,s2,*i,initial_contents);
-        } catch (informative_failure &e)
+        } catch (recoverable_failure &e)
         { W(F("error during update: %s\n") % e.what());
           // we _might_ try to use store delta ...
           cvs_client::update c=Update(i->file,s2->cvs_version);
           const_cast<std::string&>(s2->md5sum)="";
           const_cast<unsigned&>(s2->patchsize)=0;
-          store_contents(file_data(c.contents), const_cast<file_id&>(s2->sha1sum));
+          store_contents(file_data(c.contents,origin::internal), const_cast<file_id&>(s2->sha1sum));
           const_cast<unsigned&>(s2->size)=c.contents.size();
           const_cast<std::string&>(s2->keyword_substitution)=c.keyword_substitution;
         }
============================================================
--- mtn_cvs/cvs_sync_push.cc	c38afdc462021c4a36fd88f863d566aff1163ebb
+++ mtn_cvs/cvs_sync_push.cc	e3b149a83cc6de7343be174701ad9e373df407c6
@@ -70,7 +70,7 @@ std::string cvs_repository::gather_merge
     }
     result+="-------------------\n"
         +changelog+"\nmtn "+author+" "
-        +cvs_client::time_t2rfc822(date)+" "+encode_hexenc(i->inner()()).substr(0,6)+"\n";
+        +cvs_client::time_t2rfc822(date)+" "+encode_hexenc(i->inner()(),origin::internal).substr(0,6)+"\n";
     result+=gather_merge_information(*i);
   }
   return result;
@@ -107,7 +107,7 @@ void cvs_repository::commit()
   { // search for a matching start of history
     // take first head 
     std::vector<revision_id> heads=app.heads(app.opts.branchname());
-    N(!heads.empty(), F("branch %s has no heads") % app.opts.branchname());
+    E(!heads.empty(),origin::user, F("branch %s has no heads") % app.opts.branchname());
     
     revision_id actual=*heads.begin();
     is_branch branch_comparer(app.opts.branchname());
@@ -327,7 +327,7 @@ std::set<cvs_edge>::iterator cvs_reposit
     }
     std::string changelog;
     changelog=e.changelog+"\nmtn "+e.author+" "
-        +cvs_client::time_t2rfc822(e.time)+" "+encode_hexenc(e.revision.inner()()).substr(0,6)+"\n";
+        +cvs_client::time_t2rfc822(e.time)+" "+encode_hexenc(e.revision.inner()(),origin::internal).substr(0,6)+"\n";
     // gather information CVS does not know about into the changelog
     changelog+=gather_merge_information(e.revision);
     std::map<std::string,std::pair<std::string,std::string> > result
============================================================
--- mtn_cvs/cvs_sync_takeover.cc	fab8adee5d700ee0e2f1e74e8cb041d2b075b011
+++ mtn_cvs/cvs_sync_takeover.cc	fc15d0c472c21a107bfb94d12ebfd8b6d7caa9ed
@@ -34,7 +34,7 @@ static void read_file(std::string const&
     is.read(buf,sizeof buf);
     if (is.gcount()) dest+=std::string(buf,buf+is.gcount());
   }
-  result=file_data(dest);
+  result=file_data(dest,origin::system);
 }
 
 void cvs_repository::takeover_dir(const std::string &path)
@@ -42,14 +42,14 @@ void cvs_repository::takeover_dir(const 
   MM(path);
   { std::string repository;
     std::ifstream cvs_repository((path+"CVS/Repository").c_str());
-    N(cvs_repository.good(), F("can't open %sCVS/Repository\n") % path);
+    E(cvs_repository.good(), origin::workspace, F("can't open %sCVS/Repository\n") % path);
     std::getline(cvs_repository,repository);
     I(!repository.empty());
     if (repository[0]!='/') repository=root+"/"+repository;
     validate_path(path,repository+"/");
   }
   std::ifstream cvs_Entries((path+"CVS/Entries").c_str());
-  N(cvs_Entries.good(),
+  E(cvs_Entries.good(),origin::workspace,
       F("can't open %s\n") % (path+"CVS/Entries"));
   L(FL("takeover_dir %s\n") % path);
   static hexenc<id> empty_file;
@@ -83,7 +83,7 @@ void cvs_repository::takeover_dir(const 
         try
         { modtime=cvs_client::Entries2time_t(parts[3]);
         } 
-        catch (informative_failure &e) {}
+        catch (recoverable_failure &e) {}
         catch (std::exception &e) {}
         
         I(files.find(filename)==files.end());
@@ -184,7 +184,7 @@ void cvs_repository::takeover()
     I(!(--edges.end())->revision.inner()().empty());
     of << "format_version \"1\"\n\n"
       "new_manifest [0000000000000000000000000000000000000001]\n\n"
-      "old_revision [" << encode_hexenc((--edges.end())->revision.inner()()) << "]\n";
+      "old_revision [" << encode_hexenc((--edges.end())->revision.inner()(),origin::internal) << "]\n";
   }
 // like in commit ?
 //  update_any_attrs(app);
@@ -197,9 +197,9 @@ void cvs_sync::takeover(mtncvs_state &ap
 void cvs_sync::takeover(mtncvs_state &app, const std::string &_module)
 { std::string root,module=_module,branch;
 
-  N(access("_MTN",F_OK),F("Found a _MTN file or directory, already under monotone's control?"));
+  E(access("_MTN",F_OK),origin::workspace,F("Found a _MTN file or directory, already under monotone's control?"));
   { fstream cvs_root("CVS/Root");
-    N(cvs_root.good(),
+    E(cvs_root.good(),origin::workspace,
       F("can't open ./CVS/Root, please change into the working directory\n"));
     std::getline(cvs_root,root);
   }
@@ -214,7 +214,7 @@ void cvs_sync::takeover(mtncvs_state &ap
   }
   if (module.empty())
   { fstream cvs_repository("CVS/Repository");
-    N(cvs_repository.good(),
+    E(cvs_repository.good(),origin::workspace,
       F("can't open ./CVS/Repository\n"));
     std::getline(cvs_repository,module);
     W(F("Guessing '%s' as the module name\n") % module);
============================================================
--- mtn_cvs/mtn_automate.cc	98558a2817ab068dde6305504ed5d32ef4af8144
+++ mtn_cvs/mtn_automate.cc	f12b7c143543981b35ba358ba78b2a80fe599d12
@@ -20,7 +20,7 @@ void mtn_automate::check_interface_revis
 
 void mtn_automate::check_interface_revision(std::string const& minimum)
 { std::string present=automate("interface_version");
-  N(present>=minimum,
+  E(present>=minimum, origin::user,
       F("your monotone automate interface revision %s does not match the "
           "requirements %s") % present % minimum);
 }
@@ -81,22 +81,22 @@ file_id mtn_automate::put_file(file_data
 file_id mtn_automate::put_file(file_data const& d, file_id const& base)
 { std::vector<std::string> args;
   if (!null_id(base.inner())) 
-    args.push_back(encode_hexenc(base.inner()()));
+    args.push_back(encode_hexenc(base.inner()(),origin::internal));
   args.push_back(d.inner()());
-  return file_id(decode_hexenc(automate("put_file",args).substr(0,constants::idlen)));
+  return file_id(decode_hexenc(automate("put_file",args).substr(0,constants::idlen),origin::network),origin::network);
 }
 
 file_data mtn_automate::get_file(file_id const& fid)
 { std::vector<std::string> args;
-  args.push_back(encode_hexenc(fid.inner()()));
-  return file_data(automate("get_file",args));
+  args.push_back(encode_hexenc(fid.inner()(),origin::internal));
+  return file_data(automate("get_file",args),origin::network);
 }
 
 #include <piece_table.hh>
 
 std::vector<revision_id> mtn_automate::get_revision_children(revision_id const& rid)
 { std::vector<std::string> args;
-  args.push_back(encode_hexenc(rid.inner()()));
+  args.push_back(encode_hexenc(rid.inner()(),origin::internal));
   std::string children=automate("children",args);
   std::vector<revision_id> result;
   piece::piece_table lines;
@@ -104,7 +104,7 @@ std::vector<revision_id> mtn_automate::g
   result.reserve(children.size());
   for (piece::piece_table::const_iterator p=lines.begin();p!=lines.end();++p)
   { // L(FL("child '%s'") % (**p).substr(0,constants::idlen));
-    result.push_back(revision_id(decode_hexenc((**p).substr(0,constants::idlen))));
+    result.push_back(revision_id(decode_hexenc((**p).substr(0,constants::idlen),origin::network),origin::network));
   }
   piece::reset();
   return result;
@@ -112,14 +112,14 @@ std::vector<revision_id> mtn_automate::g
 
 std::vector<revision_id> mtn_automate::get_revision_parents(revision_id const& rid)
 { std::vector<std::string> args;
-  args.push_back(encode_hexenc(rid.inner()()));
+  args.push_back(encode_hexenc(rid.inner()(),origin::internal));
   std::string children=automate("parents",args);
   std::vector<revision_id> result;
   piece::piece_table lines;
   piece::index_deltatext(children,lines);
   result.reserve(children.size());
   for (piece::piece_table::const_iterator p=lines.begin();p!=lines.end();++p)
-    result.push_back(revision_id(decode_hexenc((**p).substr(0,constants::idlen))));
+    result.push_back(revision_id(decode_hexenc((**p).substr(0,constants::idlen),origin::network),origin::network));
   piece::reset();
   return result;
 }
@@ -132,7 +132,7 @@ std::vector<revision_id> mtn_automate::h
   piece::index_deltatext(heads,lines);
   result.reserve(heads.size());
   for (piece::piece_table::const_iterator p=lines.begin();p!=lines.end();++p)
-    result.push_back(revision_id(decode_hexenc((**p).substr(0,constants::idlen))));
+    result.push_back(revision_id(decode_hexenc((**p).substr(0,constants::idlen),origin::internal),origin::network));
   piece::reset();
   return result;
 }
@@ -168,7 +168,7 @@ static void print_cset(basic_io::printer
     {
       basic_io::stanza st;
       st.push_file_pair(syms::add_file, i->first);
-      st.push_hex_pair(syms::content, hexenc<id>(encode_hexenc(i->second.inner()())));
+      st.push_hex_pair(syms::content, hexenc<id>(encode_hexenc(i->second.inner()(),origin::internal),origin::internal));
       printer.print_stanza(st);
     }
 
@@ -177,8 +177,8 @@ static void print_cset(basic_io::printer
     {
       basic_io::stanza st;
       st.push_file_pair(syms::patch, i->first);
-      st.push_hex_pair(syms::from, hexenc<id>(encode_hexenc(i->second.first.inner()())));
-      st.push_hex_pair(syms::to, hexenc<id>(encode_hexenc(i->second.second.inner()())));
+      st.push_hex_pair(syms::from, hexenc<id>(encode_hexenc(i->second.first.inner()(),origin::internal),origin::internal));
+      st.push_hex_pair(syms::to, hexenc<id>(encode_hexenc(i->second.second.inner()(),origin::internal),origin::internal));
       printer.print_stanza(st);
     }
 
@@ -214,15 +214,15 @@ revision_id mtn_automate::put_revision(r
 
 // changeset stanza  
   basic_io::stanza st;
-  st.push_hex_pair(syms::old_revision, hexenc<id>(encode_hexenc(parent.inner()())));
+  st.push_hex_pair(syms::old_revision, hexenc<id>(encode_hexenc(parent.inner()(),origin::internal),origin::internal));
   printer.print_stanza(st);
   print_cset(printer, changes);
   std::vector<std::string> args(1,printer.buf);
-  return revision_id(decode_hexenc(automate("put_revision",args).substr(0,constants::idlen)));
+  return revision_id(decode_hexenc(automate("put_revision",args).substr(0,constants::idlen),origin::network),origin::network);
 }
 
 mtn_automate::manifest_map mtn_automate::get_manifest_of(revision_id const& rid)
-{ std::vector<std::string> args(1,encode_hexenc(rid.inner()()));
+{ std::vector<std::string> args(1,encode_hexenc(rid.inner()(),origin::internal));
   std::string aresult=automate("get_manifest_of",args);
   
   basic_io::input_source source(aresult,"automate get_manifest_of result");
@@ -249,7 +249,7 @@ mtn_automate::manifest_map mtn_automate:
           pa.str(pth);
           pa.esym(syms::content);
           pa.hex(content);
-          result[file_path_internal(pth)].first=file_id(decode_hexenc(content));
+          result[file_path_internal(pth)].first=file_id(decode_hexenc(content,origin::network),origin::network);
         }
       else if (pa.symp(syms::dir))
         {
@@ -268,25 +268,27 @@ mtn_automate::manifest_map mtn_automate:
           pa.str(k);
           pa.str(v);
           safe_insert(result[file_path_internal(pth)].second, 
-                    make_pair(attr_key(k),attr_value(v)));
+                    make_pair(attr_key(k,origin::network),attr_value(v,origin::network)));
         }
         
-      // Dormant attrs
+#if 0
+      // Dormant attrs ??
       while(pa.symp(basic_io::syms::dormant_attr))
         {
           pa.sym();
           string k;
           pa.str(k);
           safe_insert(result[file_path_internal(pth)].second, 
-                    make_pair(attr_key(k),attr_value()));
+                    make_pair(attr_key(k,origin::network),attr_value()));
         }
+#endif
     }
   return result;
 }
 
 void mtn_automate::cert_revision(revision_id const& rid, std::string const& name, std::string const& value)
 { std::vector<std::string> args;
-  args.push_back(encode_hexenc(rid.inner()()));
+  args.push_back(encode_hexenc(rid.inner()(),origin::internal));
   args.push_back(name);
   args.push_back(value);
   automate("cert",args);
@@ -294,7 +296,7 @@ std::vector<mtn_automate::certificate> m
 
 std::vector<mtn_automate::certificate> mtn_automate::get_revision_certs(revision_id const& rid)
 { std::vector<std::string> args;
-  args.push_back(encode_hexenc(rid.inner()()));
+  args.push_back(encode_hexenc(rid.inner()(),origin::internal));
   std::string aresult=automate("certs",args);
 
   basic_io::input_source source(aresult,"automate get_revision_certs result");
@@ -406,7 +408,7 @@ parse_cset(basic_io::parser & parser,
 //      prev_path = p1;
       parser.esym(syms::content);
       parser.hex(t1);
-      safe_insert(cs.files_added, make_pair(p1, file_id(decode_hexenc(t1))));
+      safe_insert(cs.files_added, make_pair(p1, file_id(decode_hexenc(t1,origin::network),origin::network)));
     }
 
 //  prev_path.clear();
@@ -421,7 +423,8 @@ parse_cset(basic_io::parser & parser,
       parser.esym(syms::to);
       parser.hex(t2);
       safe_insert(cs.deltas_applied,
-                  make_pair(p1, make_pair(file_id(decode_hexenc(t1)), file_id(decode_hexenc(t2)))));
+                  make_pair(p1, make_pair(file_id(decode_hexenc(t1,origin::network),origin::network), 
+                                file_id(decode_hexenc(t2,origin::network),origin::network))));
     }
 
 //  prev_pair.first.clear();
@@ -431,7 +434,7 @@ parse_cset(basic_io::parser & parser,
       parse_path(parser, p1);
       parser.esym(syms::attr);
       parser.str(t1);
-      pair<file_path, attr_key> new_pair(p1, attr_key(t1));
+      pair<file_path, attr_key> new_pair(p1, attr_key(t1,origin::network));
 //      I(prev_pair.first.empty() || new_pair > prev_pair);
 //      prev_pair = new_pair;
       safe_insert(cs.attrs_cleared, new_pair);
@@ -444,12 +447,12 @@ parse_cset(basic_io::parser & parser,
       parse_path(parser, p1);
       parser.esym(syms::attr);
       parser.str(t1);
-      pair<file_path, attr_key> new_pair(p1, attr_key(t1));
+      pair<file_path, attr_key> new_pair(p1, attr_key(t1,origin::network));
 //      I(prev_pair.first.empty() || new_pair > prev_pair);
 //      prev_pair = new_pair;
       parser.esym(syms::value);
       parser.str(t2);
-      safe_insert(cs.attrs_set, make_pair(new_pair, attr_value(t2)));
+      safe_insert(cs.attrs_set, make_pair(new_pair, attr_value(t2,origin::network)));
     }
 }
 
@@ -464,7 +467,7 @@ parse_edge(basic_io::parser & parser,
 
   parser.esym(syms::old_revision);
   parser.hex(tmp);
-  old_rev = revision_id(decode_hexenc(tmp));
+  old_rev = revision_id(decode_hexenc(tmp,origin::network),origin::network);
 
   parse_cset(parser, *cs);
 
@@ -473,7 +476,7 @@ mtn_automate::revision_t mtn_automate::g
 
 mtn_automate::revision_t mtn_automate::get_revision(revision_id const& rid)
 { std::vector<std::string> args;
-  args.push_back(encode_hexenc(rid.inner()()));
+  args.push_back(encode_hexenc(rid.inner()(),origin::internal));
   std::string aresult=automate("get_revision",args);
   
   basic_io::input_source source(aresult,"automate get_revision result");
@@ -486,7 +489,7 @@ mtn_automate::revision_t mtn_automate::g
   string tmp;
   parser.esym(syms::format_version);
   parser.str(tmp);
-  E(tmp == "1",
+  E(tmp == "1", origin::workspace,
     F("encountered a revision with unknown format, version '%s'\n"
       "I only know how to understand the version '1' format\n"
       "a newer version of mtn_cvs is required to complete this operation")
@@ -548,7 +551,7 @@ bool mtn_automate::is_synchronized(revis
   
   // look for a certificate
   std::vector<certificate> certs;
-  certs=get_revision_certs(rid,cert_name(sync_prefix+domain));
+  certs=get_revision_certs(rid,cert_name(sync_prefix+domain,origin::internal));
   return !certs.empty();
 }
 
@@ -594,7 +597,7 @@ revision_id mtn_automate::find_newest_sy
       if (!null_id(e->first))
         heads.push_back(e->first);
     }
-    N(!heads.empty(), F("no synchronized revision found in branch %s for domain %s")
+    E(!heads.empty(), origin::user, F("no synchronized revision found in branch %s for domain %s")
         % branch % domain);
   }
 
@@ -630,7 +633,7 @@ static void parse_attributes(std::string
     parse_path(parser, p1);
     parser.esym(syms::attr);
     parser.str(t1);
-    pair<file_path, attr_key> new_pair(p1, attr_key(t1));
+    pair<file_path, attr_key> new_pair(p1, attr_key(t1,origin::network));
     safe_erase(result, new_pair);
   }
   while (parser.symp(syms::set))
@@ -639,10 +642,10 @@ static void parse_attributes(std::string
     parse_path(parser, p1);
     parser.esym(syms::attr);
     parser.str(t1);
-    pair<file_path, attr_key> new_pair(p1, attr_key(t1));
+    pair<file_path, attr_key> new_pair(p1, attr_key(t1,origin::network));
     parser.esym(syms::value);
     parser.str(t2);
-    safe_insert(result, make_pair(new_pair, attr_value(t2)));
+    safe_insert(result, make_pair(new_pair, attr_value(t2,origin::network)));
   }
 }
 
@@ -658,14 +661,14 @@ sync_map_t mtn_automate::get_sync_info(r
   
   L(FL("get_sync_info: checking revision certificates %s") % rid);
   std::vector<certificate> certs;
-  certs=get_revision_certs(rid,cert_name(sync_prefix+domain));
+  certs=get_revision_certs(rid,cert_name(sync_prefix+domain,origin::internal));
   I(certs.size()<=1); // FIXME: what to do with multiple certs ...
   if (certs.size()==1) 
-  { std::string decomp_cert_val=xform<Botan::Gzip_Decompression>(idx(certs,0).value);
+  { std::string decomp_cert_val=xform<Botan::Gzip_Decompression>(idx(certs,0).value,origin::network);
     I(decomp_cert_val.size()>constants::idlen+1);
     I(decomp_cert_val[constants::idlen]=='\n');
     if (decomp_cert_val[0]!=' ')
-    { revision_id old_rid=revision_id(decomp_cert_val.substr(0,constants::idlen));
+    { revision_id old_rid=revision_id(decomp_cert_val.substr(0,constants::idlen),origin::network);
       result=get_sync_info(old_rid,domain,depth);
       ++depth;
     }
@@ -695,7 +698,7 @@ sync_map_t mtn_automate::get_sync_info(r
     }
     depth=0;
   }
-  N(!result.empty(), F("no sync cerficate found in revision %s for domain %s")
+  E(!result.empty(), origin::user, F("no sync cerficate found in revision %s for domain %s")
         % rid % domain);
   return result;
 }
@@ -743,7 +746,7 @@ void mtn_automate::put_sync_info(revisio
             /*|| (o->first==n->first && o->second!=n->second)*/)
         { basic_io::stanza st;
           st.push_file_pair(syms::clear, file_path(o->first.first));
-          st.push_str_pair(syms::attr, encode_hexenc(o->first.second()));
+          st.push_str_pair(syms::attr, encode_hexenc(o->first.second(),origin::internal));
           printer.print_stanza(st);
           if (o->first==n->first) ++n;
           ++o;
@@ -756,8 +759,8 @@ void mtn_automate::put_sync_info(revisio
             || (o->first==n->first && o->second!=n->second))
         { basic_io::stanza st;
           st.push_file_pair(syms::set, file_path(n->first.first));
-          st.push_str_pair(syms::attr, encode_hexenc(n->first.second()));
-          st.push_str_pair(syms::value, encode_hexenc(n->second()));
+          st.push_str_pair(syms::attr, encode_hexenc(n->first.second(),origin::internal));
+          st.push_str_pair(syms::value, encode_hexenc(n->second(),origin::internal));
           printer.print_stanza(st);
           if (o->first==n->first) ++o;
           ++n;
@@ -767,15 +770,16 @@ void mtn_automate::put_sync_info(revisio
       if (printer.buf.size()>=new_data.size()) continue; // look for a shorter form
       
       I(e->first.inner()().size()==constants::idlen);
-      std::string cv=xform<Botan::Gzip_Compression>(encode_hexenc(e->first.inner()())+"\n"+printer.buf);
+      std::string cv=xform<Botan::Gzip_Compression>(encode_hexenc(e->first.inner()(),origin::internal)+"\n"+printer.buf,origin::internal);
       cert_revision(rid,sync_prefix+domain,cv);
       L(FL("sync info encoded as delta from %s") % e->first);
       return;
     }
-    catch (informative_failure &er) {}
+    catch (recoverable_failure &er) {}
+    catch (unrecoverable_failure &er) {}
     catch (std::runtime_error &er) {}
   }
-  std::string cv=xform<Botan::Gzip_Compression>(string(constants::idlen,' ')+"\n"+new_data);
+  std::string cv=xform<Botan::Gzip_Compression>(string(constants::idlen,' ')+"\n"+new_data,origin::internal);
   cert_revision(rid,sync_prefix+domain,cv);
   L(FL("sync info attached to %s") % rid);
 }
============================================================
--- mtn_cvs/mtn_cvs.cc	d44d6722cfa17b1f68dd6760c64c2e0bebb71877
+++ mtn_cvs/mtn_cvs.cc	cba272faed07c62c7432c3caf15f016274def2ac
@@ -139,7 +139,7 @@ CMD(takeover, "takeover", "", CMD_REF(wo
   std::string module;
   if (args.size() == 1) module = idx(args, 0)();
   mtncvs_state &myapp=mtncvs_state::upcast(app);
-  N(!myapp.opts.branchname().empty(), F("no destination branch specified\n"));
+  E(!myapp.opts.branchname().empty(), origin::user, F("no destination branch specified\n"));
   cvs_sync::takeover(myapp, module);
 }
 
@@ -376,7 +376,7 @@ cpp_main(int argc, char ** argv)
     }
   catch (option::option_error const & e)
     {
-      N(false, i18n_format("%s") % e.what());
+      E(false, origin::user, i18n_format("%s") % e.what());
     }
   catch (usage & u)
     {
@@ -411,16 +411,29 @@ cpp_main(int argc, char ** argv)
 
     }
   }
-  catch (informative_failure & inf)
+  catch (recoverable_failure & inf)
     {
       ui.inform(inf.what());
       return 1;
     }
+  catch (unrecoverable_failure & inf)
+    {
+      if (inf.caused_by() == origin::database)
+        ui.fatal_db(inf.what());
+      else
+        ui.fatal(inf.what());
+      return 3;
+    }
   catch (ios_base::failure const & ex)
     {
       // an error has already been printed
       return 1;
     }
+  catch (std::bad_alloc)
+    {
+      ui.inform(_("error: memory exhausted"));
+      return 1;
+    }
   catch (std::exception const & ex)
     {
       ui.fatal_exception (ex);
============================================================
--- mtn_cvs/mtn_pipe.cc	e7301e40a135e59b2e38b710ef9a6e6f21e60379
+++ mtn_cvs/mtn_pipe.cc	ad7b9a7bdb821f697701f9fd066c28a3ea2b2dcc
@@ -101,7 +101,7 @@ again:
   // at least we can expect 8 bytes
   
   int read=blocking_read(*pipe,probe,buf,7+s_cmdnum.size());
-  N(read==7+s_cmdnum.size(), F("mtn pipe failure\n"));
+  E(read==7+s_cmdnum.size(), origin::internal, F("mtn pipe failure\n"));
   int colons;
   while ((colons=count_colons(buf,read))<4 && read+(4-colons)<=sizeof(buf))
   { int res=blocking_read(*pipe,probe,buf+read,4-colons);
============================================================
--- mtn_cvs/options_list.hh	501f3906548c56552b6b0aead1471758c42237c9
+++ mtn_cvs/options_list.hh	a0c250180df7dd9509af7f0b036bad0e3eb93661
@@ -16,7 +16,7 @@ OPTION(globals, positionals, true, "--",
 OPTION(globals, positionals, true, "--", "")
 #ifdef option_bodies
 {
-  args.push_back(arg_type(arg));
+  args.push_back(arg_type(arg, origin::user));
 }
 #endif
 
@@ -24,7 +24,7 @@ OPTION(branch, branch, true, "branch,b",
 OPTION(branch, branch, true, "branch,b", N_("select branch cert for operation"))
 #ifdef option_bodies
 {
-  branchname = branch_name(arg);
+  branchname = branch_name(arg, origin::user);
 }
 #endif
 
@@ -61,7 +61,7 @@ OPTION(revision, revision, true, "revisi
       N_("select revision id(s) for operation"))
 #ifdef option_bodies
 {
-  revisions.push_back(revision_id(decode_hexenc(arg)));
+  revisions.push_back(revision_id(decode_hexenc(arg, origin::user),origin::user));
 }
 #endif
 
@@ -150,7 +150,7 @@ OPTION(globals, dump, true, "dump",
         gettext_noop("file to dump debugging log to, on failure"))
 #ifdef option_bodies
 {
-  global_sanity.set_dump_path(system_path(arg).as_external());
+  global_sanity.set_dump_path(system_path(arg, origin::user).as_external());
 }
 #endif
 
============================================================
--- mtn_cvs/piece_table.cc	f91003f8ded135319434d64ac50e7a1286bfea67
+++ mtn_cvs/piece_table.cc	14d20dee7fcf6fd1203183077a906cbceec9540c
@@ -82,7 +82,7 @@ process_one_hunk(piece::piece_table cons
       char code;
       int pos, len;
       if (sscanf(directive.c_str(), " %c %d %d", &code, &pos, &len) != 3)
-              E(false, F("illformed directive '%s'\n") % directive);
+              E(false, origin::internal, F("illformed directive '%s'\n") % directive);
 
       if (code == 'a')
         {
@@ -104,11 +104,11 @@ process_one_hunk(piece::piece_table cons
           cursor += len;
         }
       else
-        E(false,F("unknown directive '%s'\n") % directive);
+        E(false,origin::internal, F("unknown directive '%s'\n") % directive);
     } 
   catch (std::out_of_range & oor)
     {
-      E(false, F("out_of_range while processing '%s' with source.size() == %d and cursor == %d")
+      E(false, origin::internal, F("out_of_range while processing '%s' with source.size() == %d and cursor == %d")
           % directive % source.size() % cursor);
     }  
 }