pkgs/tskm: Update `taskchampion` to 3.x

10 files changed, 310 insertions, 182 deletions

diff --git a/pkgs/by-name/ts/tskm/Cargo.lock b/pkgs/by-name/ts/tskm/Cargo.lock
index afec1484..20af41dc 100644
--- a/pkgs/by-name/ts/tskm/Cargo.lock
+++ b/pkgs/by-name/ts/tskm/Cargo.lock
@@ -18,18 +18,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
 [[package]]
-name = "ahash"
-version = "0.8.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
-dependencies = [
- "cfg-if",
- "once_cell",
- "version_check",
- "zerocopy",
-]
-
-[[package]]
 name = "android_system_properties"
 version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -101,6 +89,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7d902e3d592a523def97af8f317b08ce16b7ab854c1985a0c671e6f15cebc236"
 
 [[package]]
+name = "async-trait"
+version = "0.1.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
 name = "autocfg"
 version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -108,9 +107,9 @@ checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
 
 [[package]]
 name = "bitflags"
-version = "2.11.1"
+version = "2.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
+checksum = "84d7ced0ae9557296835c32bf1b1e02b44c746701f898460fb000d7eaa84f00a"
 
 [[package]]
 name = "bumpalo"
@@ -126,12 +125,12 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "cc"
-version = "1.2.62"
+version = "1.2.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1dce859f0832a7d088c4f1119888ab94ef4b5d6795d1ce05afb7fe159d79f98"
+checksum = "556e016178bb5662a08681bbe0f00f8e17631781a4dfc8c45e466e4b185ec27f"
 dependencies = [
  "find-msvc-tools",
- "shlex",
+ "shlex 2.0.1",
 ]
 
 [[package]]
@@ -185,7 +184,7 @@ dependencies = [
  "clap",
  "clap_lex",
  "is_executable",
- "shlex",
+ "shlex 1.3.0",
 ]
 
 [[package]]
@@ -309,6 +308,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
 
 [[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
+[[package]]
 name = "form_urlencoded"
 version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -359,28 +364,30 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
  "r-efi",
  "wasip2",
  "wasip3",
+ "wasm-bindgen",
 ]
 
 [[package]]
 name = "hashbrown"
-version = "0.14.5"
+version = "0.15.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
 dependencies = [
- "ahash",
+ "foldhash 0.1.5",
 ]
 
 [[package]]
 name = "hashbrown"
-version = "0.15.5"
+version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
 dependencies = [
- "foldhash",
+ "foldhash 0.2.0",
 ]
 
 [[package]]
@@ -391,20 +398,11 @@ checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
 
 [[package]]
 name = "hashlink"
-version = "0.9.1"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ba4ff7128dee98c7dc9794b6a411377e1404dba1c97deb8d1a55297bd25d8af"
+checksum = "ea0b22561a9c04a7cb1a302c013e0259cd3b4bb619f145b32f72b8b4bcbed230"
 dependencies = [
- "hashbrown 0.14.5",
-]
-
-[[package]]
-name = "hashlink"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7382cf6263419f2d8df38c55d7da83da5c18aef87fc7a7fc1fb1e344edfe14c1"
-dependencies = [
- "hashbrown 0.15.5",
+ "hashbrown 0.16.1",
 ]
 
 [[package]]
@@ -631,9 +629,9 @@ dependencies = [
 
 [[package]]
 name = "libsqlite3-sys"
-version = "0.30.1"
+version = "0.37.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e99fb7a497b1e3339bc746195567ed8d3e24945ecd636e3619d20b9de9e9149"
+checksum = "b1f111c8c41e7c61a49cd34e44c7619462967221a6443b0ec299e0ac30cfb9b1"
 dependencies = [
  "pkg-config",
  "vcpkg",
@@ -647,9 +645,9 @@ checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0"
 
 [[package]]
 name = "log"
-version = "0.4.30"
+version = "0.4.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "616ec5685824bcc94416c6d4a7a446eea774a31efd7062c8480ba6fd06d7a6e5"
+checksum = "113b30b4cd05f7c06868fdb2854f66a7b9fece9a48425351cd532e810d74024f"
 
 [[package]]
 name = "md5"
@@ -773,17 +771,28 @@ dependencies = [
 ]
 
 [[package]]
+name = "rsqlite-vfs"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c51c9ae4df8a7fba42103df5c621fa3c37eccf3a3c650879e90fc48b11cc192c"
+dependencies = [
+ "hashbrown 0.16.1",
+ "thiserror",
+]
+
+[[package]]
 name = "rusqlite"
-version = "0.32.1"
+version = "0.39.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7753b721174eb8ff87a9a0e799e2d7bc3749323e773db92e0984debb00019d6e"
+checksum = "a0d2b0146dd9661bf67bb107c0bb2a55064d556eeb3fc314151b957f313bcd4e"
 dependencies = [
  "bitflags",
  "fallible-iterator",
  "fallible-streaming-iterator",
- "hashlink 0.9.1",
+ "hashlink",
  "libsqlite3-sys",
  "smallvec",
+ "sqlite-wasm-rs",
 ]
 
 [[package]]
@@ -818,6 +827,17 @@ dependencies = [
 ]
 
 [[package]]
+name = "serde-wasm-bindgen"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8302e169f0eddcc139c70f139d19d6467353af16f9fce27e8c30158036a1e16b"
+dependencies = [
+ "js-sys",
+ "serde",
+ "wasm-bindgen",
+]
+
+[[package]]
 name = "serde_core"
 version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -857,6 +877,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
+name = "shlex"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
+
+[[package]]
 name = "simd-adler32"
 version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -875,6 +901,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
+name = "sqlite-wasm-rs"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc3efc0da82635d7e1ced0053bbbfa8c7ab9645d0bf36ceb4f7127bb85315d75"
+dependencies = [
+ "cc",
+ "js-sys",
+ "rsqlite-vfs",
+ "wasm-bindgen",
+]
+
+[[package]]
 name = "stable_deref_trait"
 version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -900,15 +938,15 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "strum"
-version = "0.27.2"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
+checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd"
 
 [[package]]
 name = "strum_macros"
-version = "0.27.2"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
+checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -940,22 +978,28 @@ dependencies = [
 
 [[package]]
 name = "taskchampion"
-version = "2.0.3"
+version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b010f5ebe51e88ae490691ed2a43b699e3468c8e3838e244accd8526aca7751b"
+checksum = "82f3be5bd922568eaaa1cbf30d4daf7979723c53465f3b202a88c7746fd0d7b6"
 dependencies = [
  "anyhow",
+ "async-trait",
  "byteorder",
  "chrono",
  "flate2",
+ "getrandom 0.4.2",
  "log",
  "rusqlite",
  "serde",
+ "serde-wasm-bindgen",
  "serde_json",
  "strum",
  "strum_macros",
  "thiserror",
+ "tokio",
  "uuid",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
 ]
 
 [[package]]
@@ -1007,6 +1051,27 @@ dependencies = [
 ]
 
 [[package]]
+name = "tokio"
+version = "1.52.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fc7f01b389ac15039e4dc9531aa973a135d7a4135281b12d7c1bc79fd57fffe"
+dependencies = [
+ "pin-project-lite",
+ "tokio-macros",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "385a6cb71ab9ab790c5fe8d67f1645e6c450a7ce006a33de03daa956cf70a496"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
 name = "tskm"
 version = "0.1.0"
 dependencies = [
@@ -1020,6 +1085,7 @@ dependencies = [
  "serde_json",
  "stderrlog",
  "taskchampion",
+ "tokio",
  "url",
  "walkdir",
  "yaml-rust2",
@@ -1064,9 +1130,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.23.1"
+version = "1.23.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddd74a9687298c6858e9b88ec8935ec45d22e8fd5e6394fa1bd4e99a87789c76"
+checksum = "d258b83ceec21034727ecee8c382cfa6c3e133699b0742c64571814fb420c9f7"
 dependencies = [
  "getrandom 0.4.2",
  "js-sys",
@@ -1081,12 +1147,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
 
 [[package]]
-name = "version_check"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
-
-[[package]]
 name = "walkdir"
 version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1134,6 +1194,16 @@ dependencies = [
 ]
 
 [[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.72"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9473dbd2991ae90b6291c3c32c30c6187ac49aa32f9905d1cce280ec1e110b0f"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
 name = "wasm-bindgen-macro"
 version = "0.2.122"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1452,13 +1522,13 @@ checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4"
 
 [[package]]
 name = "yaml-rust2"
-version = "0.10.4"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2462ea039c445496d8793d052e13787f2b90e750b833afee748e601c17621ed9"
+checksum = "631a50d867fafb7093e709d75aaee9e0e0d5deb934021fcea25ac2fe09edc51e"
 dependencies = [
  "arraydeque",
  "encoding_rs",
- "hashlink 0.10.0",
+ "hashlink",
 ]
 
 [[package]]
@@ -1485,26 +1555,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "zerocopy"
-version = "0.8.49"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bce33a6288fa3f072a8c2c7d0f2fdbb90e28298f0135c1f99b96c3db2efcc60b"
-dependencies = [
- "zerocopy-derive",
-]
-
-[[package]]
-name = "zerocopy-derive"
-version = "0.8.49"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fd425244944f4ab65ccff928e7323354c5a018c75838362fdce749dfad2ee1e"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
 name = "zerofrom"
 version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
diff --git a/pkgs/by-name/ts/tskm/Cargo.toml b/pkgs/by-name/ts/tskm/Cargo.toml
index 46b97f41..c934ce19 100644
--- a/pkgs/by-name/ts/tskm/Cargo.toml
+++ b/pkgs/by-name/ts/tskm/Cargo.toml
@@ -28,18 +28,19 @@ clap = { version = "4.6.1", features = [
 ], default-features = false }
 clap_complete = { version = "4.6.5", features = ["unstable-dynamic"] }
 dirs = { version = "6.0.0", default-features = false }
-log = { version = "0.4.30", default-features = false }
+log = { version = "0.4.31", default-features = false }
 serde = { version = "1.0.228", features = ["derive"], default-features = false }
 serde_json = { version = "1.0.150", default-features = false }
 stderrlog = { version = "0.6.0", default-features = false }
-taskchampion = { version = "2.0.3", default-features = false }
+taskchampion = { version = "3.1.0", features =["storage", "storage-sqlite"], default-features = false }
 url = { version = "2.5.8", features = [
   "serde",
   "std",
 ], default-features = false }
 walkdir = { version = "2.5.0", default-features = false }
 md5 = { version = "0.8.0", default-features = false }
-yaml-rust2 = "0.10.4"
+yaml-rust2 = "0.11.0"
+tokio = { version = "1.52.3", features = ["rt-multi-thread"] }
 
 [profile.release]
 lto = true
diff --git a/pkgs/by-name/ts/tskm/src/browser/mod.rs b/pkgs/by-name/ts/tskm/src/browser/mod.rs
index 2129982f..fd90b820 100644
--- a/pkgs/by-name/ts/tskm/src/browser/mod.rs
+++ b/pkgs/by-name/ts/tskm/src/browser/mod.rs
@@ -14,7 +14,7 @@ use url::Url;
 use crate::{state::State, task};
 
 #[allow(clippy::too_many_lines)]
-pub fn open_in_browser<U>(
+pub async fn open_in_browser<U>(
     selected_project: &task::Project,
     state: &mut State,
     urls: Option<Vec<U>>,
@@ -24,8 +24,9 @@ where
 {
     let old_project: Option<task::Project> =
         task::Project::get_current().context("Failed to get currently active project")?;
-    let old_task: Option<task::Task> =
-        task::Task::get_current(state).context("Failed to get currently active task")?;
+    let old_task: Option<task::Task> = task::Task::get_current(state)
+        .await
+        .context("Failed to get currently active task")?;
 
     selected_project.activate().with_context(|| {
         format!(
@@ -35,25 +36,36 @@ where
     })?;
 
     let tracking_task = {
-        let all_tasks = selected_project.get_tasks(state).with_context(|| {
+        let all_tasks = selected_project.get_tasks(state).await.with_context(|| {
             format!(
                 "Failed to get assoctiated tasks for project: '{}'",
                 selected_project.to_project_display()
             )
         })?;
 
-        let tracking_task = all_tasks.into_iter().find(|t| {
-            let maybe_desc = t.description(state);
-            if let Ok(desc) = maybe_desc {
-                desc == "tracking"
-            } else {
-                error!(
-                    "Getting task description returned error: {}",
-                    maybe_desc.expect_err("We already check for Ok")
-                );
-                false
+        let tracking_task = {
+            let mut output = None;
+
+            for t in all_tasks {
+                let maybe_desc = t.description(state).await;
+                let found = if let Ok(desc) = maybe_desc {
+                    desc == "tracking"
+                } else {
+                    error!(
+                        "Getting task description returned error: {}",
+                        maybe_desc.expect_err("We already check for Ok")
+                    );
+                    false
+                };
+
+                if found {
+                    output = Some(t);
+                    break;
+                }
             }
-        });
+
+            output
+        };
 
         if let Some(task) = tracking_task {
             info!(
@@ -61,6 +73,7 @@ where
                 selected_project.to_project_display()
             );
             task.start(state)
+                .await
                 .with_context(|| format!("Failed to start task {task}"))?;
         }
         tracking_task
@@ -180,10 +193,12 @@ where
 
     if let Some(task) = tracking_task {
         task.stop(state)
+            .await
             .with_context(|| format!("Failed to stop task {task}"))?;
     }
     if let Some(task) = old_task {
         task.start(state)
+            .await
             .with_context(|| format!("Failed to start task {task}"))?;
     }
 
diff --git a/pkgs/by-name/ts/tskm/src/cli.rs b/pkgs/by-name/ts/tskm/src/cli.rs
index a347f5ce..3dc1181d 100644
--- a/pkgs/by-name/ts/tskm/src/cli.rs
+++ b/pkgs/by-name/ts/tskm/src/cli.rs
@@ -8,11 +8,12 @@
 // You should have received a copy of the License along with this program.
 // If not, see <https://www.gnu.org/licenses/gpl-3.0.txt>.
 
-use std::{ffi::OsStr, path::PathBuf};
+use std::{ffi::OsStr, path::PathBuf, thread};
 
-use anyhow::{Result, bail};
-use clap::{ArgAction, Parser, Subcommand, ValueEnum, builder::StyledStr};
+use anyhow::{bail, Result};
+use clap::{builder::StyledStr, ArgAction, Parser, Subcommand, ValueEnum};
 use clap_complete::{ArgValueCompleter, CompletionCandidate};
+use tokio::runtime::Runtime;
 
 use crate::{
     interface::{
@@ -23,6 +24,43 @@ use crate::{
     state, task,
 };
 
+macro_rules! as_sync {
+    (
+        wrap $old_name_1:ident($($arg_name_1:ident : $arg_type_1:ty),*) -> $output_1:ty => $new_name_1:ident;
+        $(
+            wrap $old_name:ident($($arg_name:ident : $arg_type:ty),*) -> $output:ty => $new_name:ident;
+        )+
+    ) => {
+        as_sync!(
+            wrap $old_name_1($($arg_name_1 : $arg_type_1),*) -> $output_1 => $new_name_1;
+        );
+        as_sync!(
+            $(
+                wrap $old_name($($arg_name : $arg_type),*) -> $output => $new_name;
+            )+
+        );
+    };
+    (
+        wrap $old_name:ident($($arg_name:ident : $arg_type:ty),*) -> $output:ty => $new_name:ident $(;)?
+    ) => {
+        fn $new_name($($arg_name: $arg_type),*) -> $output {
+            $(
+                let $arg_name = $arg_name.to_owned();
+            ),*
+
+            let handle: std::thread::JoinHandle<$output> = thread::spawn(move || {
+                let rt = Runtime::new().expect("No runtime issue");
+
+                let output = rt.block_on($old_name($($arg_name.as_ref()),*));
+
+                output
+            });
+
+            handle.join().expect("The thread should be joinable")
+        }
+    };
+}
+
 #[derive(Parser, Debug)]
 #[command(author, version, about, long_about, verbatim_doc_comment)]
 /// This is the core interface to the system-integrated task management
@@ -94,16 +132,21 @@ pub enum NeorgCommand {
     /// Open the `neorg` project associated with id of the task.
     Task {
         /// The working set id of the task
-        #[arg(value_name = "ID", value_parser = task_from_working_set_id, add = ArgValueCompleter::new(complete_task_id))]
+        #[arg(value_name = "ID", value_parser = task_from_working_set_id_sync, add = ArgValueCompleter::new(complete_task_id_sync))]
         task: task::Task,
     },
 }
 
-fn task_from_working_set_id(id: &str) -> Result<task::Task> {
+as_sync!(
+    wrap task_from_working_set_id(id: &str) -> Result<task::Task> => task_from_working_set_id_sync;
+    wrap complete_task_id(current: &OsStr) -> Vec<CompletionCandidate> => complete_task_id_sync;
+);
+
+async fn task_from_working_set_id(id: &str) -> Result<task::Task> {
     let id: usize = id.parse()?;
-    let mut state = state::State::new_ro()?;
+    let mut state = state::State::new_ro().await?;
 
-    let Some(task) = task::Task::from_working_set(id, &mut state)? else {
+    let Some(task) = task::Task::from_working_set(id, &mut state).await? else {
         bail!("Working set id '{id}' is not valid!")
     };
     Ok(task)
@@ -201,14 +244,14 @@ pub enum InputCommand {
     Tags {},
 }
 
-fn complete_task_id(current: &OsStr) -> Vec<CompletionCandidate> {
-    fn format_task(
+async fn complete_task_id(current: &OsStr) -> Vec<CompletionCandidate> {
+    async fn format_task(
         task: task::Task,
         current: &str,
         state: &mut state::State,
     ) -> Option<CompletionCandidate> {
         let id = {
-            let Ok(base) = task.working_set_id(state) else {
+            let Ok(base) = task.working_set_id(state).await else {
                 return None;
             };
             base.to_string()
@@ -219,7 +262,7 @@ fn complete_task_id(current: &OsStr) -> Vec<CompletionCandidate> {
         }
 
         let description = {
-            let Ok(base) = task.description(state) else {
+            let Ok(base) = task.description(state).await else {
                 return None;
             };
             StyledStr::from(base)
@@ -234,11 +277,11 @@ fn complete_task_id(current: &OsStr) -> Vec<CompletionCandidate> {
         return output;
     };
 
-    let Ok(mut state) = state::State::new_ro() else {
+    let Ok(mut state) = state::State::new_ro().await else {
         return output;
     };
 
-    let Ok(pending) = state.replica().pending_tasks() else {
+    let Ok(pending) = state.replica().pending_tasks().await else {
         return output;
     };
 
@@ -249,9 +292,9 @@ fn complete_task_id(current: &OsStr) -> Vec<CompletionCandidate> {
     if let Some(current_project) = current_project {
         for t in pending {
             let task = task::Task::from(&t);
-            if let Ok(project) = task.project(&mut state) {
+            if let Ok(project) = task.project(&mut state).await {
                 if project == current_project {
-                    if let Some(out) = format_task(task, current, &mut state) {
+                    if let Some(out) = format_task(task, current, &mut state).await {
                         output.push(out);
                     }
                 }
@@ -260,7 +303,7 @@ fn complete_task_id(current: &OsStr) -> Vec<CompletionCandidate> {
     } else {
         for t in pending {
             let task = task::Task::from(&t);
-            if let Some(out) = format_task(task, current, &mut state) {
+            if let Some(out) = format_task(task, current, &mut state).await {
                 output.push(out);
             }
         }
diff --git a/pkgs/by-name/ts/tskm/src/interface/input/handle.rs b/pkgs/by-name/ts/tskm/src/interface/input/handle.rs
index d9904657..cd868f7a 100644
--- a/pkgs/by-name/ts/tskm/src/interface/input/handle.rs
+++ b/pkgs/by-name/ts/tskm/src/interface/input/handle.rs
@@ -28,7 +28,7 @@ use super::{Input, Tag};
 /// # Panics
 /// When internal assertions fail.
 #[allow(clippy::too_many_lines)]
-pub fn handle(command: InputCommand, state: &mut State) -> Result<()> {
+pub async fn handle(command: InputCommand, state: &mut State) -> Result<()> {
     match command {
         InputCommand::Add { inputs } => {
             for input in inputs {
@@ -79,10 +79,11 @@ pub fn handle(command: InputCommand, state: &mut State) -> Result<()> {
                     &project,
                     state,
                     Some(all.iter().map(|f| f.url.clone()).collect()),
-                )?;
+                )
+                .await?;
 
                 {
-                    use std::io::{Write, stdin, stdout};
+                    use std::io::{stdin, stdout, Write};
 
                     let mut s = String::new();
                     eprint!("Continue? (y/N) ");
diff --git a/pkgs/by-name/ts/tskm/src/interface/neorg/handle.rs b/pkgs/by-name/ts/tskm/src/interface/neorg/handle.rs
index 4e433143..12a0180d 100644
--- a/pkgs/by-name/ts/tskm/src/interface/neorg/handle.rs
+++ b/pkgs/by-name/ts/tskm/src/interface/neorg/handle.rs
@@ -10,19 +10,19 @@
 
 use std::{
     env,
-    fs::{self, File, OpenOptions, read_to_string},
+    fs::{self, read_to_string, File, OpenOptions},
     io::Write,
     process::Command,
 };
 
-use anyhow::{Context, Result, bail};
+use anyhow::{bail, Context, Result};
 
 use crate::{cli::NeorgCommand, state::State};
 
-pub fn handle(command: NeorgCommand, state: &mut State) -> Result<()> {
+pub async fn handle(command: NeorgCommand, state: &mut State) -> Result<()> {
     match command {
         NeorgCommand::Task { task } => {
-            let project = task.project(state)?;
+            let project = task.project(state).await?;
             let base = dirs::data_local_dir()
                 .expect("This should exists")
                 .join("tskm/notes");
@@ -46,7 +46,8 @@ pub fn handle(command: NeorgCommand, state: &mut State) -> Result<()> {
 
                     let mut file = options.open(&path)?;
                     file.write_all(
-                        format!("* {} (% {})", task.description(state)?, task.uuid()).as_bytes(),
+                        format!("* {} (% {})", task.description(state).await?, task.uuid())
+                            .as_bytes(),
                     )
                     .with_context(|| {
                         format!("Failed to write task uuid to file: '{}'", path.display())
@@ -92,7 +93,7 @@ pub fn handle(command: NeorgCommand, state: &mut State) -> Result<()> {
             }
 
             {
-                task.mark_neorg_data(state)?;
+                task.mark_neorg_data(state).await?;
             }
         }
     }
diff --git a/pkgs/by-name/ts/tskm/src/interface/open/handle.rs b/pkgs/by-name/ts/tskm/src/interface/open/handle.rs
index 15f749c5..5b9100bc 100644
--- a/pkgs/by-name/ts/tskm/src/interface/open/handle.rs
+++ b/pkgs/by-name/ts/tskm/src/interface/open/handle.rs
@@ -10,7 +10,7 @@
 
 use std::str::FromStr;
 
-use anyhow::{Context, Result, bail};
+use anyhow::{bail, Context, Result};
 use log::{error, info};
 use url::Url;
 
@@ -31,7 +31,7 @@ fn is_empty(project: &task::Project) -> Result<bool> {
 }
 
 #[allow(clippy::too_many_lines)]
-pub fn handle(command: OpenCommand, state: &mut State) -> Result<()> {
+pub async fn handle(command: OpenCommand, state: &mut State) -> Result<()> {
     match command {
         OpenCommand::Review { non_empty } => {
             for project in task::Project::all().context("Failed to get all project files")? {
@@ -43,12 +43,14 @@ pub fn handle(command: OpenCommand, state: &mut State) -> Result<()> {
                         project.to_project_display(),
                         if is_empty { "is empty" } else { "is not empty" }
                     );
-                    open_in_browser(project, state, None::<Vec<Url>>).with_context(|| {
-                        format!(
-                            "Failed to open project ('{}') in qutebrowser",
-                            project.to_project_display()
-                        )
-                    })?;
+                    open_in_browser(project, state, None::<Vec<Url>>)
+                        .await
+                        .with_context(|| {
+                            format!(
+                                "Failed to open project ('{}') in qutebrowser",
+                                project.to_project_display()
+                            )
+                        })?;
 
                     if project.is_touched() {
                         project.untouch().with_context(|| {
@@ -63,9 +65,11 @@ pub fn handle(command: OpenCommand, state: &mut State) -> Result<()> {
         }
         OpenCommand::Project { project, urls } => {
             project.touch().context("Failed to touch project")?;
-            open_in_browser(&project, state, urls).with_context(|| {
-                format!("Failed to open project: {}", project.to_project_display())
-            })?;
+            open_in_browser(&project, state, urls)
+                .await
+                .with_context(|| {
+                    format!("Failed to open project: {}", project.to_project_display())
+                })?;
         }
         OpenCommand::Select { urls } => {
             let selected_project: task::Project = task::Project::from_project_string(
@@ -85,7 +89,9 @@ pub fn handle(command: OpenCommand, state: &mut State) -> Result<()> {
                 .touch()
                 .context("Failed to touch project")?;
 
-            open_in_browser(&selected_project, state, urls).context("Failed to open project")?;
+            open_in_browser(&selected_project, state, urls)
+                .await
+                .context("Failed to open project")?;
         }
         OpenCommand::ListTabs { projects, mode } => {
             let projects = {
@@ -152,7 +158,13 @@ pub fn handle(command: OpenCommand, state: &mut State) -> Result<()> {
                 };
 
                 for (active, url) in tabs {
-                    let is_selected = { if active { "🔻 " } else { "   " } };
+                    let is_selected = {
+                        if active {
+                            "🔻 "
+                        } else {
+                            "   "
+                        }
+                    };
                     println!("{is_selected}{url}");
                 }
             }
diff --git a/pkgs/by-name/ts/tskm/src/main.rs b/pkgs/by-name/ts/tskm/src/main.rs
index e6113111..a852bd7b 100644
--- a/pkgs/by-name/ts/tskm/src/main.rs
+++ b/pkgs/by-name/ts/tskm/src/main.rs
@@ -24,7 +24,8 @@ pub mod rofi;
 pub mod state;
 pub mod task;
 
-fn main() -> Result<(), anyhow::Error> {
+#[tokio::main]
+async fn main() -> Result<(), anyhow::Error> {
     clap_complete::CompleteEnv::with_factory(CliArgs::command).complete();
 
     let args = CliArgs::parse();
@@ -38,12 +39,12 @@ fn main() -> Result<(), anyhow::Error> {
         .init()
         .expect("Let's just hope that this does not panic");
 
-    let mut state = State::new_rw()?;
+    let mut state = State::new_rw().await?;
 
     match args.command {
-        Command::Inputs { command } => input::handle(command, &mut state)?,
-        Command::Neorg { command } => neorg::handle(command, &mut state)?,
-        Command::Open { command } => open::handle(command, &mut state)?,
+        Command::Inputs { command } => input::handle(command, &mut state).await?,
+        Command::Neorg { command } => neorg::handle(command, &mut state).await?,
+        Command::Open { command } => open::handle(command, &mut state).await?,
         Command::Projects { command } => project::handle(command)?,
     }
 
diff --git a/pkgs/by-name/ts/tskm/src/state.rs b/pkgs/by-name/ts/tskm/src/state.rs
index ae71764e..57495bb8 100644
--- a/pkgs/by-name/ts/tskm/src/state.rs
+++ b/pkgs/by-name/ts/tskm/src/state.rs
@@ -11,10 +11,13 @@
 use std::path::PathBuf;
 
 use anyhow::Result;
-use taskchampion::{Replica, StorageConfig, storage::AccessMode};
+use taskchampion::{
+    storage::{sqlite::SqliteStorage, AccessMode},
+    Replica,
+};
 
 pub struct State {
-    replica: Replica,
+    replica: Replica<SqliteStorage>,
 }
 
 impl std::fmt::Debug for State {
@@ -28,28 +31,23 @@ impl State {
         dirs::data_local_dir().expect("Should exist").join("task")
     }
 
-    fn new(taskdb_dir: PathBuf, access_mode: AccessMode) -> Result<Self> {
-        let storage = StorageConfig::OnDisk {
-            taskdb_dir,
-            create_if_missing: false,
-            access_mode,
-        }
-        .into_storage()?;
+    async fn new(taskdb_dir: PathBuf, access_mode: AccessMode) -> Result<Self> {
+        let storage = SqliteStorage::new(taskdb_dir, access_mode, false).await?;
 
         let replica = Replica::new(storage);
 
         Ok(Self { replica })
     }
 
-    pub fn new_ro() -> Result<Self> {
-        Self::new(Self::taskdb_dir(), AccessMode::ReadOnly)
+    pub async fn new_ro() -> Result<Self> {
+        Self::new(Self::taskdb_dir(), AccessMode::ReadOnly).await
     }
-    pub fn new_rw() -> Result<Self> {
-        Self::new(Self::taskdb_dir(), AccessMode::ReadWrite)
+    pub async fn new_rw() -> Result<Self> {
+        Self::new(Self::taskdb_dir(), AccessMode::ReadWrite).await
     }
 
     #[must_use]
-    pub fn replica(&mut self) -> &mut Replica {
+    pub fn replica(&mut self) -> &mut Replica<SqliteStorage> {
         &mut self.replica
     }
 }
diff --git a/pkgs/by-name/ts/tskm/src/task/mod.rs b/pkgs/by-name/ts/tskm/src/task/mod.rs
index 5e223e33..1362615d 100644
--- a/pkgs/by-name/ts/tskm/src/task/mod.rs
+++ b/pkgs/by-name/ts/tskm/src/task/mod.rs
@@ -10,14 +10,14 @@
 
 use std::{
     fmt::Display,
-    fs::{self, File, read_to_string},
+    fs::{self, read_to_string, File},
     path::PathBuf,
     process::Command,
     str::FromStr,
     sync::OnceLock,
 };
 
-use anyhow::{Context, Result, bail};
+use anyhow::{bail, Context, Result};
 use log::{debug, info, trace};
 use taskchampion::Tag;
 
@@ -45,18 +45,20 @@ impl From<&taskchampion::TaskData> for Task {
 }
 
 impl Task {
-    pub fn from_working_set(id: usize, state: &mut State) -> Result<Option<Self>> {
+    pub async fn from_working_set(id: usize, state: &mut State) -> Result<Option<Self>> {
         Ok(state
             .replica()
-            .working_set()?
+            .working_set()
+            .await?
             .by_index(id)
             .map(|uuid| Self { uuid }))
     }
 
-    pub fn get_current(state: &mut State) -> Result<Option<Self>> {
+    pub async fn get_current(state: &mut State) -> Result<Option<Self>> {
         let tasks = state
             .replica()
-            .pending_tasks()?
+            .pending_tasks()
+            .await?
             .into_iter()
             .filter(taskchampion::Task::is_active)
             .collect::<Vec<_>>();
@@ -76,62 +78,65 @@ impl Task {
     pub fn uuid(&self) -> &taskchampion::Uuid {
         &self.uuid
     }
-    pub fn working_set_id(&self, state: &mut State) -> Result<usize> {
+    pub async fn working_set_id(&self, state: &mut State) -> Result<usize> {
         Ok(state
             .replica()
-            .working_set()?
+            .working_set()
+            .await?
             .by_uuid(self.uuid)
             .expect("The task should be in the working set"))
     }
 
-    fn as_task(&self, state: &mut State) -> Result<taskchampion::Task> {
+    async fn as_task(&self, state: &mut State) -> Result<taskchampion::Task> {
         Ok(state
             .replica()
-            .get_task(self.uuid)?
+            .get_task(self.uuid)
+            .await?
             .expect("We have the task from this replica, it should still be in it"))
     }
 
     /// Adds a tag to the task, to show the user that it has additional neorg data.
-    pub fn mark_neorg_data(&self, state: &mut State) -> Result<()> {
+    pub async fn mark_neorg_data(&self, state: &mut State) -> Result<()> {
         let mut ops = vec![];
-        self.as_task(state)?
+        self.as_task(state)
+            .await?
             .add_tag(&Tag::from_str("neorg_data").expect("Is valid"), &mut ops)?;
-        state.replica().commit_operations(ops)?;
+        state.replica().commit_operations(ops).await?;
         Ok(())
     }
 
     /// Try to start this task.
     /// It will stop previously active tasks.
-    pub fn start(&self, state: &mut State) -> Result<()> {
+    pub async fn start(&self, state: &mut State) -> Result<()> {
         info!("Activating {self}");
 
-        if let Some(active) = Self::get_current(state)? {
-            active.stop(state)?;
+        if let Some(active) = Self::get_current(state).await? {
+            active.stop(state).await?;
         }
 
         let mut ops = vec![];
-        self.as_task(state)?.start(&mut ops)?;
-        state.replica().commit_operations(ops)?;
+        self.as_task(state).await?.start(&mut ops)?;
+        state.replica().commit_operations(ops).await?;
         Ok(())
     }
 
     /// Stops this task.
-    pub fn stop(&self, state: &mut State) -> Result<()> {
+    pub async fn stop(&self, state: &mut State) -> Result<()> {
         info!("Stopping {self}");
 
         let mut ops = vec![];
-        self.as_task(state)?.stop(&mut ops)?;
-        state.replica().commit_operations(ops)?;
+        self.as_task(state).await?.stop(&mut ops)?;
+        state.replica().commit_operations(ops).await?;
         Ok(())
     }
 
-    pub fn description(&self, state: &mut State) -> Result<String> {
-        Ok(self.as_task(state)?.get_description().to_owned())
+    pub async fn description(&self, state: &mut State) -> Result<String> {
+        Ok(self.as_task(state).await?.get_description().to_owned())
     }
 
-    pub fn project(&self, state: &mut State) -> Result<Project> {
+    pub async fn project(&self, state: &mut State) -> Result<Project> {
         let output = {
-            let task = self.as_task(state)?;
+            let task = self.as_task(state).await?;
             let task_data = task.into_task_data();
             task_data
                 .get("project")
@@ -303,10 +308,11 @@ impl Project {
 
     /// # Errors
     /// When `task` execution fails.
-    pub fn get_tasks(&self, state: &mut State) -> Result<Vec<Task>> {
+    pub async fn get_tasks(&self, state: &mut State) -> Result<Vec<Task>> {
         Ok(state
             .replica()
-            .pending_task_data()?
+            .pending_task_data()
+            .await?
             .into_iter()
             .filter(|t| t.get("project").expect("Is set") == self.to_project_display())
             .map(|t| Task::from(&t))