From 5bb98579841d41e680280ada7bf3a3e9a9940553 Mon Sep 17 00:00:00 2001
From: "Dustin J. Mitchell" <djmitche@google.com>
Date: Thu, 15 Dec 2022 02:52:47 +0000
Subject: [PATCH] Use Taskchampion to store Taskwarrior data

This replaces the TF2 task files with a TaskChampion replica.
---
 src/Context.cpp            |   21 +-
 src/TDB2.cpp               | 1292 +++++++-----------------------------
 src/TDB2.h                 |   95 +--
 src/Task.cpp               |   64 ++
 src/Task.h                 |    6 +
 src/commands/CmdExport.cpp |   12 +-
 src/recur.cpp              |    1 -
 src/tc/Replica.cpp         |   67 +-
 src/tc/Replica.h           |   37 +-
 src/tc/Task.cpp            |   55 ++
 src/tc/Task.h              |   18 +-
 test/.gitignore            |    1 +
 test/CMakeLists.txt        |    1 +
 test/backlog.t             |   88 ---
 test/feature.559.t         |    2 +-
 test/ids.t                 |    3 +-
 test/recurrence.t          |    1 +
 test/tc.t.cpp              |    2 +-
 test/tdb2.t.cpp            |    4 +-
 test/tw-1688.t             |    2 +-
 test/tw-2563.t             |   45 --
 test/tw-46.t               |   58 --
 test/undo.t                |    3 +-
 test/uuid.t                |   21 +-
 24 files changed, 537 insertions(+), 1362 deletions(-)
 delete mode 100755 test/backlog.t
 delete mode 100755 test/tw-2563.t
 delete mode 100755 test/tw-46.t

diff --git a/src/Context.cpp b/src/Context.cpp
index 313bdc20d..7879d336b 100644
--- a/src/Context.cpp
+++ b/src/Context.cpp
@@ -560,8 +560,8 @@ int Context::initialize (int argc, const char** argv)
     if (taskdata_overridden && verbose ("override"))
       header (format ("TASKDATA override: {1}", data_dir._data));
 
-    tdb2.set_location (data_dir);
-    createDefaultConfig ();
+    bool create_if_missing = !config.getBoolean ("exit.on.missing.db");
+    tdb2.open_replica (data_dir, create_if_missing);
 
     ////////////////////////////////////////////////////////////////////////////
     //
@@ -1254,23 +1254,6 @@ void Context::createDefaultConfig ()
     if (! File::write (rc_file._data, contents.str ()))
       throw format ("Could not write to '{1}'.", rc_file._data);
   }
-
-  // Create data location, if necessary.
-  Directory d (data_dir);
-  if (! d.exists ())
-  {
-    if (config.getBoolean ("exit.on.missing.db"))
-      throw std::string ("Error: rc.data.location does not exist - exiting according to rc.exit.on.missing.db setting.");
-
-    d.create ();
-
-    if (config.has ("hooks.location"))
-      d = Directory (config.get ("hooks.location"));
-    else
-      d += "hooks";
-
-    d.create ();
-  }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/src/TDB2.cpp b/src/TDB2.cpp
index cbb3faf1d..4348da01c 100644
--- a/src/TDB2.cpp
+++ b/src/TDB2.cpp
@@ -30,7 +30,7 @@
 #include <sstream>
 #include <algorithm>
 #include <list>
-#include <set>
+#include <unordered_set>
 #include <stdlib.h>
 #include <signal.h>
 #include <Context.h>
@@ -42,967 +42,161 @@
 #include <main.h>
 #include <util.h>
 
-#define STRING_TDB2_REVERTED         "Modified task reverted."
-
 bool TDB2::debug_mode = false;
-
-////////////////////////////////////////////////////////////////////////////////
-TF2::TF2 ()
-: _read_only (false)
-, _dirty (false)
-, _loaded_tasks (false)
-, _loaded_lines (false)
-, _has_ids (false)
-, _auto_dep_scan (false)
-{
-}
-
-////////////////////////////////////////////////////////////////////////////////
-TF2::~TF2 ()
-{
-  if (_dirty && TDB2::debug_mode)
-    std::cout << format ("Exiting with unwritten changes to {1}\n", std::string (_file));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void TF2::target (const std::string& f)
-{
-  _file = File (f);
-
-  // A missing file is not considered unwritable.
-  _read_only = false;
-  if (_file.exists () && ! _file.writable ())
-    _read_only = true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-const std::vector <Task>& TF2::get_tasks ()
-{
-  if (! _loaded_tasks)
-    load_tasks ();
-
-  return _tasks;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-const std::vector <std::string>& TF2::get_lines ()
-{
-  if (! _loaded_lines)
-    load_lines ();
-
-  return _lines;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Locate task by id.
-bool TF2::get (int id, Task& task)
-{
-  if (! _loaded_tasks)
-    load_tasks ();
-
-  // This is an optimization.  Since the 'id' is based on the line number of
-  // pending.data file, the task in question cannot appear earlier than line
-  // (id - 1) in the file.  It can, however, appear significantly later because
-  // it is not known how recent a GC operation was run.
-  for (unsigned int i = id - 1; i < _tasks.size (); ++i)
-  {
-    if (_tasks[i].id == id)
-    {
-      task = _tasks[i];
-      return true;
-    }
-  }
-
-  return false;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Locate task by uuid, which may be a partial UUID.
-bool TF2::get (const std::string& uuid, Task& task)
-{
-  if (! _loaded_tasks)
-    load_tasks ();
-
-  if (_tasks_map.size () > 0 && uuid.size () == 36)
-  {
-    // Fast lookup, same result as below. Only used during "task import".
-    auto i = _tasks_map.find (uuid);
-    if (i != _tasks_map.end ())
-    {
-      task = i->second;
-      return true;
-    }
-  }
-  else
-  {
-    // Slow lookup, same result as above.
-    for (auto& i : _tasks)
-    {
-      if (closeEnough (i.get ("uuid"), uuid, uuid.length ()))
-      {
-        task = i;
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-bool TF2::has (const std::string& uuid)
-{
-  if (! _loaded_tasks)
-    load_tasks ();
-
-  for (auto& i : _tasks)
-    if (i.get ("uuid") == uuid)
-      return true;
-
-  return false;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void TF2::add_task (Task& task)
-{
-  _tasks.push_back (task);           // For subsequent queries
-  _added_tasks.push_back (task);     // For commit/synch
-
-  // For faster lookup
-  if (Context::getContext ().cli2.getCommand () == "import")
-    _tasks_map.emplace (task.get("uuid"), task);
-
-  Task::status status = task.getStatus ();
-  if (task.id == 0 &&
-      (status == Task::pending   ||
-       status == Task::recurring ||
-       status == Task::waiting))
-  {
-    task.id = Context::getContext ().tdb2.next_id ();
-  }
-
-  _I2U[task.id] = task.get ("uuid");
-  _U2I[task.get ("uuid")] = task.id;
-
-  _dirty = true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-bool TF2::modify_task (const Task& task)
-{
-  std::string uuid = task.get ("uuid");
-
-  if (Context::getContext ().cli2.getCommand () == "import")
-  {
-    // Update map used for faster lookup
-    auto i = _tasks_map.find (uuid);
-    if (i != _tasks_map.end ())
-    {
-      i->second = task;
-    }
-  }
-
-  for (auto& i : _tasks)
-  {
-    if (i.get ("uuid") == uuid)
-    {
-      // Modify in-place.
-      i = task;
-      _modified_tasks.push_back (task);
-      _dirty = true;
-
-      return true;
-    }
-  }
-
-  return false;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-bool TF2::purge_task (const Task& task)
-{
-  // Bail out if task is not found in this file
-  std::string uuid = task.get ("uuid");
-  if (!has (uuid))
-    return false;
-
-  // Mark the task to be purged
-  _purged_tasks.insert (uuid);
-  _dirty = true;
-
-  return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void TF2::add_line (const std::string& line)
-{
-  _lines.push_back (line);
-  _added_lines.push_back (line);
-  _dirty = true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void TF2::clear_tasks ()
-{
-  _tasks.clear ();
-  _dirty = true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void TF2::clear_lines ()
-{
-  _lines.clear ();
-  _dirty = true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Top-down recomposition.
-void TF2::commit ()
-{
-  // The _dirty flag indicates that the file needs to be written.
-  if (_dirty)
-  {
-    // Special case: added but no modified means just append to the file.
-    if (!_modified_tasks.size () && !_purged_tasks.size () &&
-        (_added_tasks.size () || _added_lines.size ()))
-    {
-      if (_file.open ())
-      {
-        if (Context::getContext ().config.getBoolean ("locking"))
-          _file.lock ();
-
-        // Write out all the added tasks.
-        _file.append (std::string(""));  // Seek to end of file
-        for (auto& task : _added_tasks)
-          _file.write_raw (task.composeF4 () + "\n");
-
-        _added_tasks.clear ();
-
-        // Write out all the added lines.
-        _file.append (_added_lines);
-
-        _added_lines.clear ();
-        _file.close ();
-        _dirty = false;
-      }
-    }
-    else
-    {
-      if (_file.open ())
-      {
-        if (Context::getContext ().config.getBoolean ("locking"))
-          _file.lock ();
-
-        // Truncate the file and rewrite.
-        _file.truncate ();
-
-        // Only write out _tasks, because any deltas have already been applied.
-        _file.append (std::string(""));  // Seek to end of file
-        for (auto& task : _tasks)
-          // Skip over the tasks that are marked to be purged
-          if (_purged_tasks.find (task.get ("uuid")) == _purged_tasks.end ())
-            _file.write_raw (task.composeF4 () + '\n');
-
-        // Write out all the added lines.
-        _file.append (_added_lines);
-
-        _added_lines.clear ();
-        _file.close ();
-        _dirty = false;
-      }
-    }
-  }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Load a single Task object, handle necessary plumbing work
-Task TF2::load_task (const std::string& line)
-{
-  Task task (line);
-
-  // Some tasks get an ID.
-  if (_has_ids)
-  {
-    Task::status status = task.getStatus ();
-    // Completed / deleted tasks in pending.data get an ID if GC is off.
-    if (! Context::getContext ().run_gc ||
-        (status != Task::completed && status != Task::deleted))
-      task.id = Context::getContext ().tdb2.next_id ();
-  }
-
-  // Maintain mapping for ease of link/dependency resolution.
-  // Note that this mapping is not restricted by the filter, and is
-  // therefore a complete set.
-  if (task.id)
-  {
-    _I2U[task.id] = task.get ("uuid");
-    _U2I[task.get ("uuid")] = task.id;
-  }
-
-  return task;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Check whether task needs to be relocated to pending/completed,
-// or needs to be 'woken'.
-void TF2::load_gc (Task& task)
-{
-  Datetime now;
-
-  std::string status = task.get ("status");
-  if (status == "pending" ||
-      status == "recurring")
-  {
-    Context::getContext ().tdb2.pending._tasks.push_back (task);
-  }
-  // 2.6.0: Waiting status is deprecated. Convert to pending to upgrade status
-  // field value in the data files.
-  else if (status == "waiting")
-  {
-    task.set ("status", "pending");
-    Context::getContext ().tdb2.pending._tasks.push_back (task);
-    Context::getContext ().tdb2.pending._dirty = true;
-  }
-  else
-  {
-    Context::getContext ().tdb2.completed._tasks.push_back (task);
-  }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void TF2::load_tasks (bool from_gc /* = false */)
-{
-  Timer timer;
-
-  if (! _loaded_lines)
-  {
-    load_lines ();
-
-    // Apply previously added lines.
-    for (auto& line : _added_lines)
-      _lines.push_back (line);
-  }
-
-  // Reduce unnecessary allocations/copies.
-  // Calling it on _tasks is the right thing to do even when from_gc is set.
-  _tasks.reserve (_lines.size ());
-
-  int line_number = 0;  // Used for error message in catch block.
-  try
-  {
-    for (auto& line : _lines)
-    {
-      ++line_number;
-      auto task = load_task (line);
-
-      if (from_gc)
-        load_gc (task);
-      else
-        _tasks.push_back (task);
-
-      if (Context::getContext ().cli2.getCommand () == "import")  // For faster lookup only
-        _tasks_map.emplace (task.get("uuid"), task);
-    }
-
-    // TDB2::gc() calls this after loading both pending and completed
-    if (_auto_dep_scan && !from_gc)
-      dependency_scan ();
-
-    _loaded_tasks = true;
-  }
-
-  catch (const std::string& e)
-  {
-    throw e + format (" in {1} at line {2}", _file._data, line_number);
-  }
-
-  Context::getContext ().time_load_us += timer.total_us ();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void TF2::load_lines ()
-{
-  if (_file.open ())
-  {
-    if (Context::getContext ().config.getBoolean ("locking"))
-      _file.lock ();
-
-    _file.read (_lines);
-    _file.close ();
-    _loaded_lines = true;
-  }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-std::string TF2::uuid (int id)
-{
-  if (! _loaded_tasks)
-  {
-    load_tasks ();
-
-    // Apply previously added tasks.
-    for (auto& task : _added_tasks)
-      _tasks.push_back (task);
-  }
-
-  auto i = _I2U.find (id);
-  if (i != _I2U.end ())
-    return i->second;
-
-  return "";
-}
-
-////////////////////////////////////////////////////////////////////////////////
-int TF2::id (const std::string& uuid)
-{
-  if (! _loaded_tasks)
-  {
-    load_tasks ();
-
-    // Apply previously added tasks.
-    for (auto& task : _added_tasks)
-      _tasks.push_back (task);
-  }
-
-  auto i = _U2I.find (uuid);
-  if (i != _U2I.end ())
-    return i->second;
-
-  return 0;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void TF2::has_ids ()
-{
-  _has_ids = true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void TF2::auto_dep_scan ()
-{
-  _auto_dep_scan = true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Completely wipe it all clean.
-void TF2::clear ()
-{
-  _read_only       = false;
-  _dirty           = false;
-  _loaded_tasks    = false;
-  _loaded_lines    = false;
-
-  // Note that these are deliberately not cleared.
-  //_file._data      = "";
-  //_has_ids         = false;
-  //_auto_dep_scan   = false;
-
-  _tasks.clear ();
-  _added_tasks.clear ();
-  _modified_tasks.clear ();
-  _purged_tasks.clear ();
-  _lines.clear ();
-  _added_lines.clear ();
-  _I2U.clear ();
-  _U2I.clear ();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// For any task that has depenencies, follow the chain of dependencies until the
-// end.  Along the way, update the Task::is_blocked and Task::is_blocking data
-// cache.
-void TF2::dependency_scan ()
-{
-  // Iterate and modify TDB2 in-place.  Don't do this at home.
-  for (auto& left : _tasks)
-  {
-    for (auto& dep : left.getDependencyUUIDs ())
-    {
-      for (auto& right : _tasks)
-      {
-        if (right.get ("uuid") == dep)
-        {
-          // GC hasn't run yet, check both tasks for their current status
-          Task::status lstatus = left.getStatus ();
-          Task::status rstatus = right.getStatus ();
-          if (lstatus != Task::completed &&
-              lstatus != Task::deleted &&
-              rstatus != Task::completed &&
-              rstatus != Task::deleted)
-          {
-            left.is_blocked = true;
-            right.is_blocking = true;
-          }
-
-          // Only want to break out of the "right" loop.
-          break;
-        }
-      }
-    }
-  }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-const std::string TF2::dump ()
-{
-  Color red    ("rgb500 on rgb100");
-  Color yellow ("rgb550 on rgb220");
-  Color green  ("rgb050 on rgb010");
-
-  // File label.
-  std::string label;
-  auto slash = _file._data.rfind ('/');
-  if (slash != std::string::npos)
-    label = rightJustify (_file._data.substr (slash + 1), 14);
-
-  // File mode.
-  std::string mode = std::string (_file.exists () && _file.readable () ? "r" : "-") +
-                     std::string (_file.exists () && _file.writable () ? "w" : "-");
-       if (mode == "r-") mode = red.colorize (mode);
-  else if (mode == "rw") mode = green.colorize (mode);
-  else                   mode = yellow.colorize (mode);
-
-  // Hygiene.
-  std::string hygiene = _dirty ? red.colorize ("O") : green.colorize ("-");
-
-  std::string tasks          = green.colorize  (rightJustifyZero ((int) _tasks.size (),          4));
-  std::string tasks_added    = red.colorize    (rightJustifyZero ((int) _added_tasks.size (),    3));
-  std::string tasks_modified = yellow.colorize (rightJustifyZero ((int) _modified_tasks.size (), 3));
-  std::string tasks_purged   = red.colorize    (rightJustifyZero ((int) _purged_tasks.size (),   3));
-  std::string lines          = green.colorize  (rightJustifyZero ((int) _lines.size (),          4));
-  std::string lines_added    = red.colorize    (rightJustifyZero ((int) _added_lines.size (),    3));
-
-  char buffer[256];  // Composed string is actually 246 bytes.  Yikes.
-  snprintf (buffer, 256, "%14s %s %s T%s+%s~%s-%s L%s+%s",
-            label.c_str (),
-            mode.c_str (),
-            hygiene.c_str (),
-            tasks.c_str (),
-            tasks_added.c_str (),
-            tasks_modified.c_str (),
-            tasks_purged.c_str (),
-            lines.c_str (),
-            lines_added.c_str ());
-
-  return std::string (buffer);
-}
+static void dependency_scan (std::vector<Task> &);
 
 ////////////////////////////////////////////////////////////////////////////////
 TDB2::TDB2 ()
-: _location ("")
-, _id (1)
+: replica {tc::Replica()} // in-memory Replica
+, _working_set {}
 {
-  // Mark the pending file as the only one that has ID numbers.
-  pending.has_ids ();
-
-  // Indicate that dependencies should be automatically scanned on startup,
-  // setting Task::is_blocked and Task::is_blocking accordingly.
-  pending.auto_dep_scan ();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Once a location is known, the files can be set up.  Note that they are not
-// read.
-void TDB2::set_location (const std::string& location)
+void TDB2::open_replica (const std::string& location, bool create_if_missing)
 {
-  _location = location;
-
-  pending.target   (location + "/pending.data");
-  completed.target (location + "/completed.data");
-  undo.target      (location + "/undo.data");
-  backlog.target   (location + "/backlog.data");
+  replica = tc::Replica(location, create_if_missing);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Add the new task to the appropriate file.
-void TDB2::add (Task& task, bool add_to_backlog /* = true */)
+// Add the new task to the replica.
+void TDB2::add (Task& task, bool/* = true */)
 {
   // Ensure the task is consistent, and provide defaults if necessary.
   // bool argument to validate() is "applyDefault". Pass add_to_backlog through
   // in order to not apply defaults to synchronized tasks.
-  task.validate (add_to_backlog);
+  // This also ensures that the `uuid` attribute is set.
+  task.validate (true);
+
   std::string uuid = task.get ("uuid");
+  auto innertask = replica.import_task_with_uuid (uuid);
 
-  // If the tasks are loaded, then verify that this uuid is not already in
-  // the file.
-  if (!verifyUniqueUUID (uuid))
-    throw format ("Cannot add task because the uuid '{1}' is not unique.", uuid);
-
-  // Only locally-added tasks trigger hooks.  This means that tasks introduced
-  // via 'sync' do not trigger hooks.
-  if (add_to_backlog)
-    Context::getContext ().hooks.onAdd (task);
-
-  update (task, add_to_backlog, true);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void TDB2::modify (Task& task, bool add_to_backlog /* = true */)
-{
-  // Ensure the task is consistent.
-  task.validate (false);
-  std::string uuid = task.get ("uuid");
-
-  // Get the unmodified task as reference, so the hook can compare.
-  if (add_to_backlog)
   {
-    Task original;
-    get (uuid, original);
-    Context::getContext ().hooks.onModify (original, task);
-  }
+    auto guard = replica.mutate_task(innertask);
 
-  update (task, add_to_backlog);
-}
+    // add the task attributes
+    for (auto& attr : task.all ()) {
+      // TaskChampion does not store uuid or id in the taskmap
+      if (attr == "uuid" || attr == "id") {
+        continue; 
+      }
 
-////////////////////////////////////////////////////////////////////////////////
-void TDB2::update (
-  Task& task,
-  const bool add_to_backlog,
-  const bool addition /* = false */)
-{
-  // Validate to add metadata.
-  task.validate (false);
+      // Use `set_status` for the task status, to get expected behavior
+      // with respect to the working set.
+      else if (attr == "status") {
+        innertask.set_status (Task::status2tc (Task::textToStatus (task.get (attr))));
+      }
 
-  // If the task already exists, it is a modification, else addition.
-  Task original;
-  if (not addition && get (task.get ("uuid"), original))
-  {
-    // Update only if the tasks differ
-    if (task == original)
-      return;
+      // use `set_modified` to set the modified timestamp, avoiding automatic
+      // updates to this field by TaskChampion.
+      else if (attr == "modified") {
+        auto mod = (time_t) std::stoi (task.get (attr));
+        innertask.set_modified (mod);
+      }
 
-    if (add_to_backlog)
-    {
-      // All locally modified tasks are timestamped, implicitly overwriting any
-      // changes the user or hooks tried to apply to the "modified" attribute.
-      task.setAsNow ("modified");
+      // otherwise, just set the k/v map value
+      else {
+        innertask.set_value (attr, std::make_optional (task.get (attr)));
+      }
     }
-
-    // Update the task, wherever it is.
-    if (!pending.modify_task (task))
-      completed.modify_task (task);
-
-    // time <time>
-    // old <task>
-    // new <task>
-    // ---
-    undo.add_line ("time " + Datetime ().toEpochString () + '\n');
-    undo.add_line ("old " + original.composeF4 () + '\n');
-    undo.add_line ("new " + task.composeF4 () + '\n');
-    undo.add_line ("---\n");
-  }
-  else
-  {
-    // Add new task to either pending or completed.
-    std::string status = task.get ("status");
-    if (status == "completed" ||
-        status == "deleted")
-      completed.add_task (task);
-    else
-      pending.add_task (task);
-
-    // Add undo data lines:
-    //   time <time>
-    //   new <task>
-    //   ---
-    undo.add_line ("time " + Datetime ().toEpochString () + '\n');
-    undo.add_line ("new " + task.composeF4 () + '\n');
-    undo.add_line ("---\n");
   }
 
-  // Add task to backlog.
-  if (add_to_backlog)
-    backlog.add_line (task.composeJSON () + '\n');
+  auto ws = replica.working_set ();
+
+  // get the ID that was assigned to this task
+  auto id = ws.by_uuid (uuid);
+
+  // update the cached working set with the new information
+  _working_set = std::make_optional (std::move (ws));
+
+  if (id.has_value ()) {
+    task.id = id.value();
+  }
+
+  // run hooks for this new task
+  Context::getContext ().hooks.onAdd (task);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Modify the task in storage to match the given task.
+//
+// This exhibits a bit of a race condition: if the stored task has changed since
+// it was loaded, this will revert those changes.  In practice, this is not an
+// issue.
+void TDB2::modify (Task& task, bool/* = true */)
+{
+  task.validate (false);
+  auto uuid = task.get ("uuid");
+
+	// invoke the hook and allow it to modify the task before updating
+  Task original;
+  get (uuid, original);
+	Context::getContext ().hooks.onModify (original, task);
+
+  auto maybe_tctask = replica.get_task (uuid);
+  if (!maybe_tctask.has_value ()) {
+    throw std::string ("task no longer exists");
+  }
+  auto tctask = std::move (maybe_tctask.value ());
+  auto guard = replica.mutate_task(tctask);
+  auto tctask_map = tctask.get_taskmap ();
+
+  std::unordered_set<std::string> seen;
+  for (auto k : task.all ()) {
+    // ignore task keys that aren't stored
+    if (k == "uuid") {
+      continue;
+    }
+    seen.insert(k);
+    bool update = false;
+    auto v_new = task.get(k);
+    try {
+      auto v_tctask = tctask_map.at(k);
+      update = v_tctask != v_new;
+    } catch (const std::out_of_range& oor) {
+      // tctask_map does not contain k, so update it
+      update = true;
+    }
+    if (update) {
+      tctask.set_value(k, make_optional (v_new));
+    }
+  }
+
+  // we've now added and updated properties; but must find any deleted properties
+  for (auto kv : tctask_map) {
+    if (seen.find (kv.first) == seen.end ()) {
+      tctask.set_value (kv.first, {});
+    }
+  }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 void TDB2::commit ()
 {
-  Timer timer;
-
-  // Ignore harmful signals.
-  signal (SIGHUP,    SIG_IGN);
-  signal (SIGINT,    SIG_IGN);
-  signal (SIGPIPE,   SIG_IGN);
-  signal (SIGTERM,   SIG_IGN);
-  signal (SIGUSR1,   SIG_IGN);
-  signal (SIGUSR2,   SIG_IGN);
-
-  dump ();
-  gather_changes ();
-  pending.commit ();
-  completed.commit ();
-  undo.commit ();
-  backlog.commit ();
-
-  // Restore signal handling.
-  signal (SIGHUP,    SIG_DFL);
-  signal (SIGINT,    SIG_DFL);
-  signal (SIGPIPE,   SIG_DFL);
-  signal (SIGTERM,   SIG_DFL);
-  signal (SIGUSR1,   SIG_DFL);
-  signal (SIGUSR2,   SIG_DFL);
-
-  Context::getContext ().time_commit_us += timer.total_us ();
+  // does nothing; changes are committed as they are made
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void TDB2::gather_changes ()
+const tc::WorkingSet &TDB2::working_set ()
 {
-  _changes.clear ();
-  for (auto& task : pending._added_tasks)
-    _changes.push_back (task);
-
-  for (auto& task : pending._modified_tasks)
-    _changes.push_back (task);
-
-  for (auto& task : completed._added_tasks)
-    _changes.push_back (task);
-
-  for (auto& task : completed._modified_tasks)
-    _changes.push_back (task);
+  if (!_working_set.has_value ()) {
+    _working_set = std::make_optional (replica.working_set ());
+  }
+  return _working_set.value ();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 void TDB2::get_changes (std::vector <Task>& changes)
 {
-  changes = _changes;
+  // Modifications are not supported, therefore there are no changes
+  changes.clear();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 void TDB2::revert ()
 {
-  // Extract the details of the last txn, and roll it back.
-  std::vector <std::string> u = undo.get_lines ();
-  std::string uuid;
-  std::string when;
-  std::string current;
-  std::string prior;
-  revert_undo (u, uuid, when, current, prior);
-
-  // Confirm.
-  if (! Context::getContext ().config.getBoolean ("confirmation") ||
-      confirm ("The undo command is not reversible.  Are you sure you want to revert to the previous state?"))
-  {
-    // There are six kinds of change possible.  Determine which one, and act
-    // accordingly.
-    //
-    // Revert: task add
-    // [1] 0 --> p
-    //   - erase from pending
-    //   - if in backlog, erase, else cannot undo
-    //
-    // Revert: task modify
-    // [2] p --> p'
-    //   - write prior over current in pending
-    //   - add prior to backlog
-    //
-    // Revert: task done/delete
-    // [3] p --> c
-    //   - add prior to pending
-    //   - erase from completed
-    //   - add prior to backlog
-    //
-    // Revert: task modify
-    // [4] c --> p
-    //   - add prior to completed
-    //   - erase from pending
-    //   - add prior to backlog
-    //
-    // Revert: task modify
-    // [5] c --> c'
-    //   - write prior over current in completed
-    //   - add prior to backlog
-    //
-    // Revert: task log
-    // [6] 0 --> c
-    //   - erase from completed
-    //   - if in backlog, erase, else cannot undo
-
-    Task old;
-    if (prior != "")
-      old = Task (prior);
-    Context::getContext ().hooks.onModify (Task (current), old);
-
-    // Modify other data files accordingly.
-    std::vector <std::string> p = pending.get_lines ();
-    revert_pending (p, uuid, prior);
-
-    std::vector <std::string> c = completed.get_lines ();
-    revert_completed (p, c, uuid, prior);
-
-    std::vector <std::string> b = backlog.get_lines ();
-    revert_backlog (b, uuid, current, prior);
-
-    // Commit.  If processing makes it this far with no exceptions, then we're
-    // done.
-    File::write (undo._file._data, u);
-    File::write (pending._file._data, p);
-    File::write (completed._file._data, c);
-    File::write (backlog._file._data, b);
-  }
-  else
-    std::cout << "No changes made.\n";
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void TDB2::revert_undo (
-  std::vector <std::string>& u,
-  std::string& uuid,
-  std::string& when,
-  std::string& current,
-  std::string& prior)
-{
-  if (u.size () < 3)
-    throw std::string ("There are no recorded transactions to undo.");
-
-  // pop last tx
-  u.pop_back (); // separator.
-
-  current = u.back ().substr (4);
-  u.pop_back ();
-
-  if (u.back ().substr (0, 5) == "time ")
-  {
-    when = u.back ().substr (5);
-    u.pop_back ();
-    prior = "";
-  }
-  else
-  {
-    prior = u.back ().substr (4);
-    u.pop_back ();
-    when = u.back ().substr (5);
-    u.pop_back ();
-  }
-
-  // Extract identifying uuid.
-  auto uuidAtt = current.find ("uuid:\"");
-  if (uuidAtt != std::string::npos)
-    uuid = current.substr (uuidAtt + 6, 36); // "uuid:"<uuid>" --> <uuid>
-  else
-    throw std::string ("Cannot locate UUID in task to undo.");
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void TDB2::revert_pending (
-  std::vector <std::string>& p,
-  const std::string& uuid,
-  const std::string& prior)
-{
-  std::string uuid_att = "uuid:\"" + uuid + '"';
-
-  // is 'current' in pending?
-  for (auto task = p.begin (); task != p.end (); ++task)
-  {
-    if (task->find (uuid_att) != std::string::npos)
-    {
-      Context::getContext ().debug ("TDB::revert - task found in pending.data");
-
-      // Either revert if there was a prior state, or remove the task.
-      if (prior != "")
-      {
-        *task = prior;
-        std::cout << STRING_TDB2_REVERTED << '\n';
-      }
-      else
-      {
-        p.erase (task);
-        std::cout << "Task removed.\n";
-      }
-
-      break;
-    }
-  }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void TDB2::revert_completed (
-  std::vector <std::string>& p,
-  std::vector <std::string>& c,
-  const std::string& uuid,
-  const std::string& prior)
-{
-  std::string uuid_att = "uuid:\"" + uuid + '"';
-
-  // is 'current' in completed?
-  for (auto task = c.begin (); task != c.end (); ++task)
-  {
-    if (task->find (uuid_att) != std::string::npos)
-    {
-      Context::getContext ().debug ("TDB::revert_completed - task found in completed.data");
-
-      // Either revert if there was a prior state, or remove the task.
-      if (prior != "")
-      {
-        *task = prior;
-        if (task->find ("status:\"pending\"")   != std::string::npos ||
-            task->find ("status:\"waiting\"")   != std::string::npos ||
-            task->find ("status:\"recurring\"") != std::string::npos)
-        {
-          c.erase (task);
-          p.push_back (prior);
-          std::cout << STRING_TDB2_REVERTED << '\n';
-          Context::getContext ().debug ("TDB::revert_completed - task belongs in pending.data");
-        }
-        else
-        {
-          std::cout << STRING_TDB2_REVERTED << '\n';
-          Context::getContext ().debug ("TDB::revert_completed - task belongs in completed.data");
-        }
-      }
-      else
-      {
-        c.erase (task);
-
-        std::cout << STRING_TDB2_REVERTED << '\n';
-        Context::getContext ().debug ("TDB::revert_completed - task removed");
-      }
-
-      std::cout << "Undo complete.\n";
-      break;
-    }
-  }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void TDB2::revert_backlog (
-  std::vector <std::string>& b,
-  const std::string& uuid,
-  const std::string& current,
-  const std::string& prior)
-{
-  std::string uuid_att = R"("uuid":")" + uuid + '"';
-
-  bool found = false;
-  for (auto task = b.rbegin (); task != b.rend (); ++task)
-  {
-    if (task->find (uuid_att) != std::string::npos)
-    {
-      Context::getContext ().debug ("TDB::revert_backlog - task found in backlog.data");
-      found = true;
-
-      // If this is a new task (no prior), then just remove it from the backlog.
-      if (current != "" && prior == "")
-      {
-        // Yes, this is what is needed, when you want to erase using a reverse
-        // iterator.
-        b.erase ((++task).base ());
-      }
-
-      // If this is a modification of some kind, add the prior to the backlog.
-      else
-      {
-        Task t (prior);
-        b.push_back (t.composeJSON ());
-      }
-
-      break;
-    }
-  }
-
-  if (!found)
-    throw std::string ("Cannot undo change because the task was already synced.  Modify the task instead.");
+  replica.undo (NULL);
+  replica.rebuild_working_set (false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1041,15 +235,6 @@ void TDB2::show_diff (
   }
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// Scans the pending tasks for any that are completed or deleted, and if so,
-// moves them to the completed.data file.  Returns a count of tasks moved.
-// Reverts expired waiting tasks to pending.
-// Cleans up dangling dependencies.
-//
-// Possible scenarios:
-// - task in pending that needs to be in completed
-// - task in completed that needs to be in pending
 void TDB2::gc ()
 {
   Timer timer;
@@ -1057,70 +242,27 @@ void TDB2::gc ()
   // Allowed as an override, but not recommended.
   if (Context::getContext ().config.getBoolean ("gc"))
   {
-    // Load pending, check whether completed changes size
-    auto size_before = completed._tasks.size ();
-    pending.load_tasks (/*from_gc =*/ true);
-    if (size_before != completed._tasks.size ())
-    {
-      // GC moved tasks from pending to completed
-      pending._dirty = true;
-      completed._dirty = true;
-    }
-    else if (pending._dirty)
-    {
-      // A waiting task in pending was woken up
-      pending._dirty = true;
-    }
-
-    // Load completed, check whether pending changes size
-    size_before = pending._tasks.size ();
-    completed.load_tasks (/*from_gc =*/ true);
-    if (size_before != pending._tasks.size ())
-    {
-      // GC moved tasks from completed to pending
-      pending._dirty = true;
-      completed._dirty = true;
-    }
-
-    // Update blocked/blocking status after GC is finished
-    if (pending._auto_dep_scan)
-      pending.dependency_scan ();
-    if (completed._auto_dep_scan)
-      completed.dependency_scan ();
+    replica.rebuild_working_set (true);
   }
 
   Context::getContext ().time_gc_us += timer.total_us ();
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// Next ID is that of the last pending task plus one.
-int TDB2::next_id ()
-{
-  return _id++;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // Latest ID is that of the last pending task.
 int TDB2::latest_id ()
 {
-  return _id - 1;
+  const tc::WorkingSet &ws = working_set ();
+  return (int)ws.largest_index ();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 const std::vector <Task> TDB2::all_tasks ()
 {
-  std::vector <Task> all (pending._tasks.size () +
-                          pending._added_tasks.size () +
-                          completed._tasks.size () +
-                          completed._added_tasks.size ());
-  all = pending.get_tasks ();
-
-  std::vector <Task> extra (completed._tasks.size () +
-                            completed._added_tasks.size ());
-  extra = completed.get_tasks ();
-
-  for (auto& task : extra)
-    all.push_back (task);
+  auto all_tctasks = replica.all_tasks();
+  std::vector <Task> all;
+  for (auto& tctask : all_tctasks)
+    all.push_back (Task (std::move (tctask)));
 
   return all;
 }
@@ -1128,37 +270,93 @@ const std::vector <Task> TDB2::all_tasks ()
 ////////////////////////////////////////////////////////////////////////////////
 const std::vector <Task> TDB2::pending_tasks ()
 {
-  return pending.get_tasks ();
+  const tc::WorkingSet &ws = working_set ();
+  auto largest_index = ws.largest_index ();
+
+  std::vector <Task> result;
+  for (size_t i = 0; i <= largest_index; i++) {
+    auto maybe_uuid = ws.by_index (i);
+    if (maybe_uuid.has_value ()) {
+      auto maybe_task = replica.get_task (maybe_uuid.value ());
+      if (maybe_task.has_value ()) {
+        result.push_back (Task (std::move (maybe_task.value ())));
+      }
+    }
+  }
+
+  dependency_scan(result);
+
+  return result;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 const std::vector <Task> TDB2::completed_tasks ()
 {
-  return completed.get_tasks ();
+  auto all_tctasks = replica.all_tasks();
+  const tc::WorkingSet &ws = working_set ();
+
+  std::vector <Task> result;
+  for (auto& tctask : all_tctasks) {
+    // if this task is _not_ in the working set, return it.
+    if (!ws.by_uuid (tctask.get_uuid ())) {
+      result.push_back (Task (std::move (tctask)));
+    }
+  }
+
+  return result;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Locate task by ID, wherever it is.
 bool TDB2::get (int id, Task& task)
 {
-  return pending.get   (id, task) ||
-         completed.get (id, task);
+  const tc::WorkingSet &ws = working_set ();
+  const auto maybe_uuid = ws.by_index (id);
+  if (maybe_uuid) {
+    auto maybe_task = replica.get_task(*maybe_uuid);
+    if (maybe_task) {
+      task = Task{std::move(*maybe_task)};
+      return true;
+    }
+  }
+
+  return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Locate task by UUID, wherever it is.
+// Locate task by UUID, including by partial ID, wherever it is.
 bool TDB2::get (const std::string& uuid, Task& task)
 {
-  return pending.get   (uuid, task) ||
-         completed.get (uuid, task);
+  // try by raw uuid, if the length is right
+  if (uuid.size () == 36) {
+    try {
+      auto maybe_task = replica.get_task (uuid);
+      if (maybe_task) {
+        task = Task{std::move (*maybe_task)};
+        return true;
+      }
+    } catch (const std::string &err) {
+      return false;
+    }
+  }
+
+  // Nothing to do but iterate over all tasks and check whether it's closeEnough
+  for (auto& tctask : replica.all_tasks ()) {
+    if (closeEnough (tctask.get_uuid (), uuid, uuid.length ())) {
+      task = Task{std::move (tctask)};
+      return true;
+    }
+  }
+
+  return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Locate task by UUID, wherever it is.
 bool TDB2::has (const std::string& uuid)
 {
-  return pending.has (uuid) ||
-         completed.has (uuid);
+  Task task;
+  return get(uuid, task);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1169,11 +367,7 @@ const std::vector <Task> TDB2::siblings (Task& task)
   {
     std::string parent = task.get ("parent");
 
-    // First load and scan pending.
-    if (! pending._loaded_tasks)
-      pending.load_tasks ();
-
-    for (auto& i : pending._tasks)
+    for (auto& i : this->pending_tasks())
     {
       // Do not include self in results.
       if (i.id != task.id)
@@ -1197,28 +391,41 @@ const std::vector <Task> TDB2::siblings (Task& task)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-const std::vector <Task> TDB2::children (Task& task)
+const std::vector <Task> TDB2::children (Task& parent)
 {
-  std::vector <Task> results;
-  std::string parent = task.get ("uuid");
+  // scan _pending_ tasks for those with `parent` equal to this task
+	std::vector <Task> results;
+  std::string this_uuid = parent.get ("uuid");
 
-  // First load and scan pending.
-  if (! pending._loaded_tasks)
-    pending.load_tasks ();
+  const tc::WorkingSet &ws = working_set ();
+  size_t end_idx = ws.largest_index ();
 
-  for (auto& i : pending._tasks)
-  {
-    // Do not include self in results.
-    if (i.id != task.id)
-    {
-      // Do not include completed or deleted tasks.
-      if (i.getStatus () != Task::completed &&
-          i.getStatus () != Task::deleted)
-      {
-        // If task has the given task as a parent, it is a child task.
-        if (i.get ("parent") == parent)
-          results.push_back (i);
-      }
+  for (size_t i = 0; i <= end_idx; i++) {
+    auto uuid_opt = ws.by_index (i);
+    if (!uuid_opt) {
+      continue;
+    }
+    auto uuid = uuid_opt.value ();
+
+    // skip self-references
+    if (uuid == this_uuid) {
+      continue;
+    }
+
+    auto task_opt = replica.get_task (uuid_opt.value ());
+    if (!task_opt) {
+      continue;
+    }
+    auto task = std::move (task_opt.value ());
+
+    auto parent_uuid_opt = task.get_value ("parent");
+    if (!parent_uuid_opt) {
+      continue;
+    }
+    auto parent_uuid = parent_uuid_opt.value ();
+
+    if (parent_uuid == this_uuid) {
+      results.push_back (Task (std::move (task)));
     }
   }
 
@@ -1228,55 +435,66 @@ const std::vector <Task> TDB2::children (Task& task)
 ////////////////////////////////////////////////////////////////////////////////
 std::string TDB2::uuid (int id)
 {
-  std::string result = pending.uuid (id);
-  if (result == "")
-    result = completed.uuid (id);
-
-  return result;
+  const tc::WorkingSet &ws = working_set ();
+  return ws.by_index ((size_t)id).value_or ("");
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 int TDB2::id (const std::string& uuid)
 {
-  int result = pending.id (uuid);
-  if (result == 0)
-    result = completed.id (uuid);
-
-  return result;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Make sure the specified UUID does not already exist in the data.
-bool TDB2::verifyUniqueUUID (const std::string& uuid)
-{
-  pending.get_tasks ();
-  return pending.id (uuid) != 0 ? false : true;
+  const tc::WorkingSet &ws = working_set ();
+  return (int)ws.by_uuid (uuid).value_or (0);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 int TDB2::num_local_changes ()
 {
-  std::vector <std::string> lines = backlog.get_lines ();
-  return std::count_if(lines.begin(), lines.end(), [](const auto& line){ return line.front() == '{'; });
+  return (int)replica.num_local_operations ();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 int TDB2::num_reverts_possible ()
 {
-  std::vector <std::string> lines = undo.get_lines ();
-  return std::count(lines.begin(), lines.end(), "---");
+  return (int)replica.num_undo_points ();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 void TDB2::dump ()
 {
-  if (Context::getContext ().config.getBoolean ("debug"))
+  // TODO
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// For any task that has depenencies, follow the chain of dependencies until the
+// end.  Along the way, update the Task::is_blocked and Task::is_blocking data
+// cache.
+static void dependency_scan (std::vector<Task> &tasks)
+{
+  for (auto& left : tasks)
   {
-    Context::getContext ().debug (pending.dump ());
-    Context::getContext ().debug (completed.dump ());
-    Context::getContext ().debug (undo.dump ());
-    Context::getContext ().debug (backlog.dump ());
-    Context::getContext ().debug (" ");
+    for (auto& dep : left.getDependencyUUIDs ())
+    {
+      for (auto& right : tasks)
+      {
+        if (right.get ("uuid") == dep)
+        {
+          // GC hasn't run yet, check both tasks for their current status
+          Task::status lstatus = left.getStatus ();
+          Task::status rstatus = right.getStatus ();
+          if (lstatus != Task::completed &&
+              lstatus != Task::deleted &&
+              rstatus != Task::completed &&
+              rstatus != Task::deleted)
+          {
+            left.is_blocked = true;
+            right.is_blocking = true;
+          }
+
+          // Only want to break out of the "right" loop.
+          break;
+        }
+      }
+    }
   }
 }
 
diff --git a/src/TDB2.h b/src/TDB2.h
index 979342bbf..6f448af3e 100644
--- a/src/TDB2.h
+++ b/src/TDB2.h
@@ -35,71 +35,8 @@
 #include <stdio.h>
 #include <FS.h>
 #include <Task.h>
-
-// TF2 Class represents a single file in the task database.
-class TF2
-{
-public:
-  TF2 ();
-  ~TF2 ();
-
-  void target (const std::string&);
-
-  const std::vector <Task>&        get_tasks ();
-  const std::vector <std::string>& get_lines ();
-
-  bool get (int, Task&);
-  bool get (const std::string&, Task&);
-  bool has (const std::string&);
-
-  void add_task (Task&);
-  bool modify_task (const Task&);
-  bool purge_task (const Task&);
-  void add_line (const std::string&);
-  void clear_tasks ();
-  void clear_lines ();
-  void commit ();
-
-  Task load_task (const std::string&);
-  void load_gc (Task&);
-  void load_tasks (bool from_gc = false);
-  void load_lines ();
-
-  // ID <--> UUID mapping.
-  std::string uuid (int);
-  int id (const std::string&);
-
-  void has_ids ();
-  void auto_dep_scan ();
-  void clear ();
-  const std::string dump ();
-
-  void dependency_scan ();
-
-  bool _read_only;
-  bool _dirty;
-  bool _loaded_tasks;
-  bool _loaded_lines;
-  bool _has_ids;
-  bool _auto_dep_scan;
-  std::vector <Task> _tasks;
-
-  // _tasks_map was introduced mainly for speeding up "task import".
-  // Iterating over all _tasks for each imported task is slow, making use of
-  // appropriate data structures is fast.
-  std::unordered_map <std::string, Task> _tasks_map;
-
-  std::vector <Task> _added_tasks;
-  std::vector <Task> _modified_tasks;
-  std::unordered_set <std::string> _purged_tasks;
-  std::vector <std::string> _lines;
-  std::vector <std::string> _added_lines;
-  File _file;
-
-private:
-  std::unordered_map <int, std::string> _I2U; // ID -> UUID map
-  std::unordered_map <std::string, int> _U2I; // UUID -> ID map
-};
+#include <tc/WorkingSet.h>
+#include <tc/Replica.h>
 
 // TDB2 Class represents all the files in the task database.
 class TDB2
@@ -109,14 +46,13 @@ public:
 
   TDB2 ();
 
-  void set_location (const std::string&);
+  void open_replica (const std::string&, bool create_if_missing);
   void add (Task&, bool add_to_backlog = true);
   void modify (Task&, bool add_to_backlog = true);
   void commit ();
   void get_changes (std::vector <Task>&);
   void revert ();
   void gc ();
-  int  next_id ();
   int  latest_id ();
 
   // Generalized task accessors.
@@ -139,28 +75,11 @@ public:
   void dump ();
 
 private:
-  void gather_changes ();
-  void update (Task&, const bool, const bool addition = false);
-  bool verifyUniqueUUID (const std::string&);
+  tc::Replica replica;
+  std::optional<tc::WorkingSet> _working_set;
+
+  const tc::WorkingSet &working_set ();
   void show_diff (const std::string&, const std::string&, const std::string&);
-  void revert_undo (std::vector <std::string>&, std::string&, std::string&, std::string&, std::string&);
-  void revert_pending (std::vector <std::string>&, const std::string&, const std::string&);
-  void revert_completed (std::vector <std::string>&, std::vector <std::string>&, const std::string&, const std::string&);
-  void revert_backlog (std::vector <std::string>&, const std::string&, const std::string&, const std::string&);
-
-protected:
-  friend class TF2; // TF2 reaches into TDB2 internals for gc
-  TF2 pending;
-  TF2 completed;
-
-  friend class CmdSync; // CmdSync accesses the backlog directly
-  TF2 backlog;
-  TF2 undo;
-
-private:
-  std::string        _location;
-  int                _id;
-  std::vector <Task> _changes;
 };
 
 #endif
diff --git a/src/Task.cpp b/src/Task.cpp
index 560984b40..9f2b52298 100644
--- a/src/Task.cpp
+++ b/src/Task.cpp
@@ -144,6 +144,19 @@ Task::Task (const json::object* obj)
   parseJSON (obj);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+Task::Task (tc::Task obj)
+{
+  id               = 0;
+  urgency_value    = 0.0;
+  recalc_urgency   = true;
+  is_blocked       = false;
+  is_blocking      = false;
+  annotation_count = 0;
+
+  parseTC (obj);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 Task::status Task::textToStatus (const std::string& input)
 {
@@ -895,6 +908,29 @@ void Task::parseJSON (const json::object* root_obj)
   }
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// Note that all fields undergo encode/decode.
+void Task::parseTC (const tc::Task& task)
+{
+  data = task.get_taskmap ();
+
+  // count annotations
+  annotation_count = 0;
+  for (auto i : data)
+  {
+    if (isAnnotationAttr (i.first))
+    {
+      ++annotation_count;
+    }
+  }
+
+  data["uuid"] = task.get_uuid ();
+  id = Context::getContext ().tdb2.id (data["uuid"]);
+
+  is_blocking = task.is_blocking();
+  is_blocked = task.is_blocked();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // No legacy formats are currently supported as of 2.4.0.
 void Task::parseLegacy (const std::string& line)
@@ -1711,6 +1747,9 @@ void Task::substitute (
 //   1) To provide missing attributes where possible
 //   2) To provide suitable warnings about odd states
 //   3) To generate errors when the inconsistencies are not fixable
+//   4) To update status depending on other attributes
+//
+// Critically, note that despite the name this is not a read-only function.
 //
 void Task::validate (bool applyDefault /* = true */)
 {
@@ -1938,6 +1977,31 @@ const std::string Task::decode (const std::string& value) const
   return          str_replace (modified, "&close;", "]");
 }
 
+////////////////////////////////////////////////////////////////////////////////
+tc::Status Task::status2tc (const Task::status status)
+{
+  switch (status) {
+    case Task::pending: return tc::Status::Pending;
+    case Task::completed: return tc::Status::Completed;
+    case Task::deleted: return tc::Status::Deleted;
+    case Task::waiting: return tc::Status::Pending; // waiting is no longer a status
+    case Task::recurring: return tc::Status::Recurring;
+    default: return tc::Status::Unknown;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+Task::status Task::tc2status (const tc::Status status)
+{
+  switch (status) {
+    case tc::Status::Pending: return Task::pending;
+    case tc::Status::Completed: return Task::completed;
+    case tc::Status::Deleted: return Task::deleted;
+    case tc::Status::Recurring: return Task::recurring;
+    default: return Task::pending;
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 int Task::determineVersion (const std::string& line)
 {
diff --git a/src/Task.h b/src/Task.h
index 0c5f01e0a..eb7b2b71f 100644
--- a/src/Task.h
+++ b/src/Task.h
@@ -35,6 +35,7 @@
 #include <JSON.h>
 #include <Table.h>
 #include <Datetime.h>
+#include <tc/Task.h>
 
 class Task
 {
@@ -65,6 +66,7 @@ public:
   bool operator!= (const Task&);
   Task (const std::string&);
   Task (const json::object*);
+  Task (tc::Task);
 
   void parse (const std::string&);
   std::string composeF4 () const;
@@ -87,6 +89,8 @@ public:
   // Series of helper functions.
   static status textToStatus (const std::string&);
   static std::string statusToText (status);
+  static tc::Status status2tc (const Task::status);
+  static Task::status tc2status (const tc::Status);
 
   void setAsNow (const std::string&);
   bool has (const std::string&) const;
@@ -178,10 +182,12 @@ public:
   Table diffForUndoSide (const Task& after) const;
   Table diffForUndoPatch (const Task& after, const Datetime& lastChange) const;
 
+
 private:
   int determineVersion (const std::string&);
   void parseJSON (const std::string&);
   void parseJSON (const json::object*);
+  void parseTC (const tc::Task&);
   void parseLegacy (const std::string&);
   void validate_before (const std::string&, const std::string&);
   const std::string encode (const std::string&) const;
diff --git a/src/commands/CmdExport.cpp b/src/commands/CmdExport.cpp
index 787e3b634..f5c43f128 100644
--- a/src/commands/CmdExport.cpp
+++ b/src/commands/CmdExport.cpp
@@ -112,15 +112,17 @@ int CmdExport::execute (std::string& output)
   }
   else
   {
-    // There is a sortOrder, so sorting will take place, which means the initial
-    // order of sequence is ascending.
+    // sort_tasks requires the order array initially be identity
     for (unsigned int i = 0; i < filtered.size (); ++i)
       sequence.push_back (i);
 
-    // Sort the tasks.
-    if (sortOrder.size ()) {
-      sort_tasks (filtered, sequence, reportSort);
+    // if no sort order, sort by id
+    if (!sortOrder.size ()) {
+      reportSort = "id";
     }
+
+    // Sort the tasks.
+    sort_tasks (filtered, sequence, reportSort);
   }
 
   // Export == render.
diff --git a/src/recur.cpp b/src/recur.cpp
index 7ace0367b..524c912d3 100644
--- a/src/recur.cpp
+++ b/src/recur.cpp
@@ -90,7 +90,6 @@ void handleRecurrence ()
 
           Task rec (t);                          // Clone the parent.
           rec.setStatus (Task::pending);         // Change the status.
-          rec.id = Context::getContext ().tdb2.next_id ();      // New ID.
           rec.set ("uuid", uuid ());             // New UUID.
           rec.set ("parent", t.get ("uuid"));    // Remember mom.
           rec.setAsNow ("entry");                // New entry date.
diff --git a/src/tc/Replica.cpp b/src/tc/Replica.cpp
index d499d2769..5ce91f8c3 100644
--- a/src/tc/Replica.cpp
+++ b/src/tc/Replica.cpp
@@ -33,6 +33,25 @@
 
 using namespace tc::ffi;
 
+////////////////////////////////////////////////////////////////////////////////
+tc::ReplicaGuard::ReplicaGuard (Replica &replica, Task &task) :
+  replica(replica),
+  task(task)
+{
+  // "steal" the reference from the Replica and store it locally, so that any
+  // attempt to use the Replica will fail
+  tcreplica = replica.inner.release();
+  task.to_mut(tcreplica);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+tc::ReplicaGuard::~ReplicaGuard ()
+{
+  task.to_immut();
+  // return the reference to the Replica.
+  replica.inner.reset(tcreplica);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 tc::Replica::Replica ()
 {
@@ -113,6 +132,45 @@ tc::Task tc::Replica::new_task (tc::Status status, const std::string &descriptio
   return Task (tctask);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+tc::Task tc::Replica::import_task_with_uuid (const std::string &uuid)
+{
+  TCTask *tctask = tc_replica_import_task_with_uuid (&*inner, uuid2tc (uuid));
+  if (!tctask) {
+    throw replica_error ();
+  }
+  return Task (tctask);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void tc::Replica::undo (int32_t *undone_out)
+{
+  auto res = tc_replica_undo (&*inner, undone_out);
+  if (res != TC_RESULT_OK) {
+    throw replica_error ();
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int64_t tc::Replica::num_local_operations ()
+{
+  auto num = tc_replica_num_local_operations (&*inner);
+  if (num < 0) {
+    throw replica_error ();
+  }
+  return num;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int64_t tc::Replica::num_undo_points ()
+{
+  auto num = tc_replica_num_undo_points (&*inner);
+  if (num < 0) {
+    throw replica_error ();
+  }
+  return num;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 std::vector<tc::Task> tc::Replica::all_tasks ()
 {
@@ -134,14 +192,19 @@ std::vector<tc::Task> tc::Replica::all_tasks ()
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void tc::Replica::rebuild_working_set ()
+void tc::Replica::rebuild_working_set (bool force)
 {
-  auto res = tc_replica_rebuild_working_set (&*inner, true);
+  auto res = tc_replica_rebuild_working_set (&*inner, force);
   if (res != TC_RESULT_OK) {
     throw replica_error ();
   }
 }
 
+////////////////////////////////////////////////////////////////////////////////
+tc::ReplicaGuard tc::Replica::mutate_task (tc::Task &task) {
+  return ReplicaGuard(*this, task);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 std::string tc::Replica::replica_error () {
   return replica_error (tc_replica_error (&*inner));
diff --git a/src/tc/Replica.h b/src/tc/Replica.h
index dbf524236..c0563d443 100644
--- a/src/tc/Replica.h
+++ b/src/tc/Replica.h
@@ -45,6 +45,28 @@ namespace tc {
     tc::ffi::TCReplica,
     std::function<void(tc::ffi::TCReplica*)>>;
 
+  // ReplicaGuard uses RAII to ensure that a Replica is not accessed while it
+  // is mutably borrowed (specifically, to make a task mutable).
+  class ReplicaGuard {
+  protected:
+    friend class Replica;
+    explicit ReplicaGuard (Replica &, Task &);
+
+  public:
+    ~ReplicaGuard();
+
+    // No moving or copying allowed
+    ReplicaGuard (const ReplicaGuard &) = delete;
+    ReplicaGuard &operator=(const ReplicaGuard &) = delete;
+    ReplicaGuard (ReplicaGuard &&) = delete;
+    ReplicaGuard &operator=(Replica &&) = delete;
+
+  private:
+    Replica &replica;
+    tc::ffi::TCReplica *tcreplica;
+    Task &task;
+  };
+
   // Replica wraps the TCReplica type, managing its memory, errors, and so on.
   //
   // Except as noted, method names match the suffix to `tc_replica_..`.
@@ -67,12 +89,20 @@ namespace tc {
     tc::WorkingSet working_set ();
     std::optional<tc::Task> get_task (const std::string &uuid);
     tc::Task new_task (Status status, const std::string &description);
+    tc::Task import_task_with_uuid (const std::string &uuid);
 // TODO: struct TCTask *tc_replica_import_task_with_uuid(struct TCReplica *rep, struct TCUuid tcuuid);
 // TODO: TCResult tc_replica_sync(struct TCReplica *rep, struct TCServer *server, bool avoid_snapshots);
-// TODO: TCResult tc_replica_undo(struct TCReplica *rep, int32_t *undone_out);
+    void undo (int32_t *undone_out);
+    int64_t num_local_operations ();
+    int64_t num_undo_points ();
 // TODO: TCResult tc_replica_add_undo_point(struct TCReplica *rep, bool force);
-    void rebuild_working_set ();
-  private:
+    void rebuild_working_set (bool force);
+
+    ReplicaGuard mutate_task(tc::Task &);
+    void immut_task(tc::Task &);
+
+  protected:
+    friend class ReplicaGuard;
     unique_tcreplica_ptr inner;
 
     // construct an error message from tc_replica_error, or from the given
@@ -82,5 +112,6 @@ namespace tc {
   };
 }
 
+
 #endif
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/src/tc/Task.cpp b/src/tc/Task.cpp
index d37a3f199..69a354a9f 100644
--- a/src/tc/Task.cpp
+++ b/src/tc/Task.cpp
@@ -60,6 +60,18 @@ tc::Task& tc::Task::operator= (Task &&other) noexcept
   return *this;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+void tc::Task::to_mut (TCReplica *replica)
+{
+  tc_task_to_mut(&*inner, replica);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void tc::Task::to_immut ()
+{
+  tc_task_to_immut(&*inner);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 std::string tc::Task::get_uuid () const
 {
@@ -100,6 +112,15 @@ std::string tc::Task::get_description () const
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+std::optional<std::string> tc::Task::get_value (std::string property) const
+{
+  auto maybe_desc = tc_task_get_value (&*inner, string2tc(property));
+  if (maybe_desc.ptr == NULL) {
+    return std::nullopt;
+  }
+  return std::make_optional(tc2string(maybe_desc));
+}
+
 bool tc::Task::is_waiting () const
 {
   return tc_task_is_waiting (&*inner);
@@ -123,6 +144,40 @@ bool tc::Task::is_blocking () const
   return tc_task_is_blocking (&*inner);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+void tc::Task::set_status (tc::Status status)
+{
+  TCResult res = tc_task_set_status (&*inner, (TCStatus)status);
+  if (res != TC_RESULT_OK) {
+    throw task_error ();
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void tc::Task::set_value (std::string property, std::optional<std::string> value)
+{
+  TCResult res;
+  if (value.has_value()) {
+    res = tc_task_set_value (&*inner, string2tc(property), string2tc(value.value()));
+  } else {
+    TCString nullstr;
+    nullstr.ptr = NULL;
+    res = tc_task_set_value (&*inner, string2tc(property), nullstr);
+  }
+  if (res != TC_RESULT_OK) {
+    throw task_error ();
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void tc::Task::set_modified (time_t modified)
+{
+  TCResult res = tc_task_set_modified (&*inner, modified);
+  if (res != TC_RESULT_OK) {
+    throw task_error ();
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 std::string tc::Task::task_error () const {
   TCString error = tc_task_error (&*inner);
diff --git a/src/tc/Task.h b/src/tc/Task.h
index ea31592a2..2710768d3 100644
--- a/src/tc/Task.h
+++ b/src/tc/Task.h
@@ -31,10 +31,12 @@
 #include <functional>
 #include <memory>
 #include <map>
+#include <optional>
 #include "tc/ffi.h"
 
 namespace tc {
   class Replica;
+  class ReplicaGuard;
 
   enum Status {
     Pending = tc::ffi::TC_STATUS_PENDING,
@@ -57,10 +59,16 @@ namespace tc {
   class Task
   {
   protected:
-    // Tasks may only be created by tc::Replica
+    // Tasks may only be created and made mutable/immutable
+    // by tc::Replica
     friend class tc::Replica;
     explicit Task (tc::ffi::TCTask *);
 
+    // RplicaGuard handles mut/immut
+    friend class tc::ReplicaGuard;
+    void to_mut(tc::ffi::TCReplica *);
+    void to_immut();
+
   public:
     // This object "owns" inner, so copy is not allowed.
     Task (const Task &) = delete;
@@ -70,12 +78,11 @@ namespace tc {
     Task (Task &&) noexcept;
     Task &operator=(Task &&) noexcept;
 
-// TODO: void tc_task_to_mut(struct TCTask *task, struct TCReplica *tcreplica);
-// TODO: void tc_task_to_immut(struct TCTask *task);
     std::string get_uuid () const;
     Status get_status () const;
     std::map <std::string, std::string> get_taskmap() const;
     std::string get_description() const;
+    std::optional<std::string> get_value(std::string property) const;
 // TODO: time_t tc_task_get_entry(struct TCTask *task);
 // TODO: time_t tc_task_get_wait(struct TCTask *task);
 // TODO: time_t tc_task_get_modified(struct TCTask *task);
@@ -90,11 +97,12 @@ namespace tc {
 // TODO: struct TCString tc_task_get_legacy_uda(struct TCTask *task, struct TCString key);
 // TODO: struct TCUdaList tc_task_get_udas(struct TCTask *task);
 // TODO: struct TCUdaList tc_task_get_legacy_udas(struct TCTask *task);
-// TODO: TCResult tc_task_set_status(struct TCTask *task, enum TCStatus status);
+    void set_status(Status status);
 // TODO: TCResult tc_task_set_description(struct TCTask *task, struct TCString description);
+    void set_value(std::string property, std::optional<std::string> value);
 // TODO: TCResult tc_task_set_entry(struct TCTask *task, time_t entry);
 // TODO: TCResult tc_task_set_wait(struct TCTask *task, time_t wait);
-// TODO: TCResult tc_task_set_modified(struct TCTask *task, time_t modified);
+    void set_modified(time_t modified);
 // TODO: TCResult tc_task_start(struct TCTask *task);
 // TODO: TCResult tc_task_stop(struct TCTask *task);
 // TODO: TCResult tc_task_done(struct TCTask *task);
diff --git a/test/.gitignore b/test/.gitignore
index 44723cd77..cdb132ea3 100644
--- a/test/.gitignore
+++ b/test/.gitignore
@@ -1,6 +1,7 @@
 *.o
 *.pyc
 *.data
+*.sqlite3
 *.log
 *.runlog
 col.t
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index f17d0c750..dd6c1a5a2 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -13,6 +13,7 @@ include_directories (${CMAKE_SOURCE_DIR}
                      ${CMAKE_SOURCE_DIR}/src/commands
                      ${CMAKE_SOURCE_DIR}/src/columns
                      ${CMAKE_SOURCE_DIR}/src/libshared/src
+                     ${CMAKE_SOURCE_DIR}/src/taskchampion/lib
                      ${CMAKE_SOURCE_DIR}/test
                      ${CMAKE_SOURCE_DIR}/taskchampion/lib
                      ${TASK_INCLUDE_DIRS})
diff --git a/test/backlog.t b/test/backlog.t
deleted file mode 100755
index 2bce8fa59..000000000
--- a/test/backlog.t
+++ /dev/null
@@ -1,88 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-###############################################################################
-#
-# Copyright 2006 - 2021, Tomas Babej, Paul Beckingham, Federico Hernandez.
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-#
-# https://www.opensource.org/licenses/mit-license.php
-#
-###############################################################################
-
-import sys
-import os
-import unittest
-
-# Ensure python finds the local simpletap module
-sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-
-from basetest import Task, TestCase
-
-
-class Test1510(TestCase):
-    def setUp(self):
-        self.t = Task()
-
-    def assertNoEmptyValueInBacklog(self, attribute_name):
-        backlog_path = os.path.join(self.t.datadir, 'backlog.data')
-        with open(backlog_path) as backlog:
-            empty_value = '"%s":""' % attribute_name
-            self.assertFalse(any(empty_value in line
-                                 for line in backlog.readlines()))
-
-    def test_no_empty_value_for_deleted_due_in_backlog(self):
-        """
-        1510: Make sure deleted due attribute does not get into
-        backlog.data with empty string value
-        """
-
-        self.t('add test due:2015-05-05')
-        self.t('1 mod due:')
-        self.assertNoEmptyValueInBacklog('due')
-
-    def test_no_empty_value_for_empty_priority_in_backlog(self):
-        """
-        1510: Make sure empty priority attribute does not get into
-        backlog.data with empty string value
-        """
-
-        self.t('add test pri:""')
-        self.t("add test2 pri:''")
-        self.t("add test3 pri:")
-        self.t("add test4 pri:H")
-        self.assertNoEmptyValueInBacklog('priority')
-
-    def test_no_empty_value_for_empty_project_in_backlog(self):
-        """
-        1510: Make sure empty project attribute does not get into
-        backlog.data with empty string value
-        """
-
-        self.t('add test project:""')
-        self.t("add test2 project:''")
-        self.t("add test3 project:")
-        self.t("add test4 project:random")
-        self.assertNoEmptyValueInBacklog('project')
-
-if __name__ == "__main__":
-    from simpletap import TAPTestRunner
-    unittest.main(testRunner=TAPTestRunner())
-
-# vim: ai sts=4 et sw=4 ft=python
diff --git a/test/feature.559.t b/test/feature.559.t
index 7e8bd1074..df71de226 100755
--- a/test/feature.559.t
+++ b/test/feature.559.t
@@ -68,7 +68,7 @@ class TestFeature559(TestCase):
         code, out, err = self.t.runError("rc.data.location=locationdoesnotexist list")
         self.assertNotIn("footask", out)
         self.assertNotIn("Error", out)
-        self.assertRegex(err, re.compile("Error:.+does not exist", re.DOTALL))
+        self.assertRegex(err, re.compile("Could not.+unable to open database file", re.DOTALL))
 
 
 if __name__ == "__main__":
diff --git a/test/ids.t b/test/ids.t
index bf4bc2628..4531f4d51 100755
--- a/test/ids.t
+++ b/test/ids.t
@@ -128,7 +128,8 @@ class TestIDRangeParsing(TestCase):
         with tempfile.NamedTemporaryFile(mode='w') as f:
             f.write('\n'.join([f'{{"description": "test task {i+1}"}}' for i in range(n)]))
             f.flush()
-            code, out, err = self.t(f'import {f.name}')
+            # use a long timeout here, because import is quite slow
+            code, out, err = self.t(f'import {f.name}', timeout=100)
 
     def test_single_digit_range(self):
         """Test that parsing single digit ID range works"""
diff --git a/test/recurrence.t b/test/recurrence.t
index bf9af82af..fa6268431 100755
--- a/test/recurrence.t
+++ b/test/recurrence.t
@@ -377,6 +377,7 @@ class TestUpgradeToRecurring(TestCase):
 
     def test_upgrade(self):
         """Upgrade task to recurring"""
+        # note that this functionality is implemented in Task::validate
         self.t("add foo")
         self.t("1 modify due:tomorrow recur:weekly")
         code, out, err = self.t("_get 1.status")
diff --git a/test/tc.t.cpp b/test/tc.t.cpp
index 48c952246..1d4c7e519 100644
--- a/test/tc.t.cpp
+++ b/test/tc.t.cpp
@@ -77,7 +77,7 @@ int main (int, char**)
   t.ok(maybe_task2.has_value(), "task lookup by uuid finds task");
   t.is ((*maybe_task2).get_description (), std::string ("a test"), "task description round-trip");
 
-  rep.rebuild_working_set ();
+  rep.rebuild_working_set (true);
   t.pass ("rebuild_working_set");
 
   auto tasks = rep.all_tasks ();
diff --git a/test/tdb2.t.cpp b/test/tdb2.t.cpp
index 7bec3e3f0..b90d5ef4e 100644
--- a/test/tdb2.t.cpp
+++ b/test/tdb2.t.cpp
@@ -60,7 +60,7 @@ int main (int, char**)
     context.config.set ("gc", 1);
     context.config.set ("debug", 1);
 
-    context.tdb2.set_location (".");
+    context.tdb2.open_replica (".", true);
 
     // Try reading an empty database.
     std::vector <Task> pending          = context.tdb2.pending_tasks ();
@@ -104,7 +104,7 @@ int main (int, char**)
 
     // Reset for reuse.
     cleardb ();
-    context.tdb2.set_location (".");
+    context.tdb2.open_replica (".", true);
 
     // TODO commit
     // TODO complete a task
diff --git a/test/tw-1688.t b/test/tw-1688.t
index 9eab84230..13b487576 100755
--- a/test/tw-1688.t
+++ b/test/tw-1688.t
@@ -14,5 +14,5 @@ task log two depends:1
 
 task /two/ export > JSON
 
-rm pending.data completed.data
+rm taskchampion.sqlite3
 task import JSON
diff --git a/test/tw-2563.t b/test/tw-2563.t
deleted file mode 100755
index e60c9dbb7..000000000
--- a/test/tw-2563.t
+++ /dev/null
@@ -1,45 +0,0 @@
-#!/usr/bin/env bash
-# This tests the migration path from 2.5.3 or earlier to 2.6.0 with respect to
-# the upgrade of the status field from waiting to pending
-. bash_tap_tw.sh
-
-# Setup
-task add Actionable task wait:yesterday
-task add Non-actionable task wait:tomorrow+1h
-
-# Simulate this was created in 2.5.3 or earlier (status is equal to waiting,
-# not pending). Using more cumbersome sed syntax for Mac OS-X compatibility.
-sed -i".bak" 's/pending/waiting/g' $TASKDATA/pending.data
-rm -f $TASKDATA/pending.data.bak
-
-# Trigger upgrade
-task all
-
-# Report file content
-echo pending.data
-cat $TASKDATA/pending.data
-echo completed.data
-cat $TASKDATA/completed.data
-
-# Assertion: Exactly one task is considered waiting
-[[ `task +WAITING count` == "1" ]]
-[[ `task status:waiting count` == "1" ]]
-
-# Assertion: Exactly one task is considered pending
-[[ `task +PENDING count` == "1" ]]
-[[ `task status:pending count` == "1" ]]
-
-# Assertion: Task 1 is pending
-[[ `task _get 1.status` == "pending" ]]
-
-# Assertion: Task 2 is waiting
-[[ `task _get 2.status` == "waiting" ]]
-
-# Assertion: No lines in data files with "waiting" status
-[[ -z `cat $TASKDATA/pending.data | grep waiting` ]]
-[[ -z `cat $TASKDATA/completed.data | grep waiting` ]]
-
-# Assertion: No tasks were moved into completed.data
-cat $TASKDATA/pending.data | wc -l | tr -d ' '
-[[ `cat $TASKDATA/pending.data | wc -l | tr -d ' '` == "2" ]]
-[[ `cat $TASKDATA/completed.data | wc -l | tr -d ' '` == "0" ]]
diff --git a/test/tw-46.t b/test/tw-46.t
deleted file mode 100755
index 3bdbce96c..000000000
--- a/test/tw-46.t
+++ /dev/null
@@ -1,58 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-###############################################################################
-#
-# Copyright 2006 - 2021, Tomas Babej, Paul Beckingham, Federico Hernandez.
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-#
-# https://www.opensource.org/licenses/mit-license.php
-#
-###############################################################################
-
-import sys
-import os
-import unittest
-# Ensure python finds the local simpletap module
-sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-
-from basetest import Task, TestCase
-
-
-class TestBug46(TestCase):
-    def setUp(self):
-        self.t = Task()
-        self.t("add one")
-        self.t("add two")
-        self.t("add three")
-
-    def test_bug46(self):
-        """Circular dependency detection broken by deletion of completed.data"""
-        self.t("1 mod dep:2")
-        self.t("2 delete", input="y\n")
-        self.t("rc.gc=on list")
-        os.remove(os.path.join(self.t.datadir, "completed.data"))
-        self.t("1 mod dep:2")
-
-
-if __name__ == "__main__":
-    from simpletap import TAPTestRunner
-    unittest.main(testRunner=TAPTestRunner())
-
-# vim: ai sts=4 et sw=4 ft=python
diff --git a/test/undo.t b/test/undo.t
index baed6cfc3..6183a5269 100755
--- a/test/undo.t
+++ b/test/undo.t
@@ -102,7 +102,8 @@ class TestBug634(TestCase):
 
         # If a prompt happens, the test will timeout on input (exitcode != 0)
         code, out, err = self.t("rc.confirmation=off undo")
-        self.assertIn("Task removed", out)
+        code, out, err = self.t("_get 1.description")
+        self.assertEqual(out.strip(), '') # task is gone
 
 
 if __name__ == "__main__":
diff --git a/test/uuid.t b/test/uuid.t
index 0938f6a61..55fe20169 100755
--- a/test/uuid.t
+++ b/test/uuid.t
@@ -179,15 +179,28 @@ class TestUUIDuplicates(TestCase):
         """Executed before each test in the class"""
         self.t = Task()
 
-    def test_uuid_duplicates(self):
-        """Verify that duplicating tasks, and recurring tasks do no create duplicates UUIDs"""
+    def test_uuid_duplicates_dupe(self):
+        """Verify that duplicating tasks does not create duplicate UUIDs"""
         self.t("add simple")
         self.t("1 duplicate")
-        self.t("add periodic recur:daily due:yesterday")
+
+        uuids = list()
+        for id in range(1,3):
+            code, out, err = self.t("_get %d.uuid" % id)
+            uuids.append(out.strip())
+
+        self.assertEqual(len(uuids), len(set(uuids)))
+
+        code, out, err = self.t("diag")
+        self.assertIn("No duplicates found", out)
+
+    def test_uuid_duplicates_recurrence(self):
+        """Verify that recurring tasks do not create duplicate UUIDs"""
+        print(self.t("add periodic recur:daily due:yesterday"))
         self.t("list") # GC/handleRecurrence
 
         uuids = list()
-        for id in range(1,7):
+        for id in range(1,5):
             code, out, err = self.t("_get %d.uuid" % id)
             uuids.append(out.strip())