diff --git a/modules/bit/cmd/bit/add.mbt b/modules/bit/cmd/bit/add.mbt
index 1395679c..c7f735e3 100644
--- a/modules/bit/cmd/bit/add.mbt
+++ b/modules/bit/cmd/bit/add.mbt
@@ -781,7 +781,7 @@ fn normalize_add_path(path : String) -> String {
   while out.length() > 1 && out.has_suffix("/") {
     out = String::unsafe_substring(out, start=0, end=out.length() - 1)
   }
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   let mut i = 0
   while i < out.length() {
     let c = out[i].unsafe_to_char()
@@ -841,10 +841,10 @@ fn add_normalize_input_path(root : String, raw_path : String) -> String {
 
 ///|
 fn add_repo_relative_cwd(root : String) -> String {
-  let cwd = match @sys.get_env_var("GIT_SHIM_CWD") {
+  let cwd = match @env.get_env_var("GIT_SHIM_CWD") {
     Some(dir) => dir
     None =>
-      match @sys.get_env_var("GIT_SHIM_PWD") {
+      match @env.get_env_var("GIT_SHIM_PWD") {
         Some(dir) => dir
         None =>
           match @env.current_dir() {
diff --git a/modules/bit/cmd/bit/add_wbtest.mbt b/modules/bit/cmd/bit/add_wbtest.mbt
index 98092d40..0a166eb0 100644
--- a/modules/bit/cmd/bit/add_wbtest.mbt
+++ b/modules/bit/cmd/bit/add_wbtest.mbt
@@ -128,14 +128,14 @@ async test "add: stages parent-relative path from subdirectory" {
   add_test_run_git(root, ["init", "-q"])
   fs.write_string(root + "/top/x", "hello\n")
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_CWD", root + "/top/sub")
-  @sys.set_env_var("GIT_SHIM_PWD", root + "/top/sub")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", root + "/top/sub")
+  @env.set_env_var("GIT_SHIM_PWD", root + "/top/sub")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
   handle_add(["../x"])
 
   let entries = @bitlib.read_index_entries(fs, root + "/.git")
@@ -165,14 +165,14 @@ async test "add: explicit add is clean for real git diff-files" {
   add_test_run_git(root, ["commit", "-q", "-m", "initial"])
   fs.write_string(root + "/file", "changed\n")
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_CWD", root)
-  @sys.set_env_var("GIT_SHIM_PWD", root)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", root)
+  @env.set_env_var("GIT_SHIM_PWD", root)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
   handle_add(["file"])
 
   let diff = add_test_git_stdout(root, ["diff-files", "--name-only", "file"])
@@ -201,14 +201,14 @@ async test "add: update from subdirectory is clean for real git diff-files" {
   add_test_run_git(root, ["commit", "-q", "-m", "initial"])
   fs.write_string(root + "/dir1/sub2", "changed\n")
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_CWD", root + "/dir1")
-  @sys.set_env_var("GIT_SHIM_PWD", root + "/dir1")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", root + "/dir1")
+  @env.set_env_var("GIT_SHIM_PWD", root + "/dir1")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
   handle_add(["-u", "sub2"])
 
   let diff = add_test_git_stdout(root, [
@@ -245,14 +245,14 @@ async test "add: update refreshes touched tracked files for real git diff-files"
   )
   assert_eq(touch_code, 0)
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_CWD", root)
-  @sys.set_env_var("GIT_SHIM_PWD", root)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", root)
+  @env.set_env_var("GIT_SHIM_PWD", root)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
   handle_add(["-u"])
 
   let diff = add_test_git_stdout(root, ["diff-files", "--name-only", "check"])
@@ -308,7 +308,7 @@ fn add_test_trim_trailing_newline(s : String) -> String {
 ///|
 fn add_test_restore_env(name : String, value : String?) -> Unit {
   match value {
-    Some(v) => @sys.set_env_var(name, v)
-    None => @sys.unset_env_var(name)
+    Some(v) => @env.set_env_var(name, v)
+    None => @env.unset_env_var(name)
   }
 }
diff --git a/modules/bit/cmd/bit/ai.mbt b/modules/bit/cmd/bit/ai.mbt
index 512d60d4..107c3776 100644
--- a/modules/bit/cmd/bit/ai.mbt
+++ b/modules/bit/cmd/bit/ai.mbt
@@ -83,7 +83,7 @@ fn build_diff_units_for_ai(diffs : Array[@bitdiff.DiffFile]) -> String {
   if diffs.length() == 0 {
     return ""
   }
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   for unit in split_diff_units(diffs) {
     out.write_string("## Logical unit: " + unit.name + "\n")
     for item in unit.diffs {
@@ -118,7 +118,7 @@ fn split_diff_units(diffs : Array[@bitdiff.DiffFile]) -> Array[AiDiffUnit] {
 
 ///|
 fn build_single_diff_unit_for_ai(unit : AiDiffUnit) -> String {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   out.write_string("## Logical unit: " + unit.name + "\n")
   for item in unit.diffs {
     out.write_string("### " + item.path + "\n")
diff --git a/modules/bit/cmd/bit/am.mbt b/modules/bit/cmd/bit/am.mbt
index 45f175f3..c12295be 100644
--- a/modules/bit/cmd/bit/am.mbt
+++ b/modules/bit/cmd/bit/am.mbt
@@ -341,11 +341,11 @@ async fn apply_remaining_patches(
     }
     stage_all_changes(fs, root)
     if author.length() > 0 {
-      @sys.set_env_var("GIT_AUTHOR_NAME", extract_name_str(author))
-      @sys.set_env_var("GIT_AUTHOR_EMAIL", extract_email_str(author))
+      @env.set_env_var("GIT_AUTHOR_NAME", extract_name_str(author))
+      @env.set_env_var("GIT_AUTHOR_EMAIL", extract_email_str(author))
     }
     if author_date.length() > 0 {
-      @sys.set_env_var("GIT_AUTHOR_DATE", author_date)
+      @env.set_env_var("GIT_AUTHOR_DATE", author_date)
     }
     let commit_author = get_author_string()
     let commit_timestamp = get_commit_timestamp()
diff --git a/modules/bit/cmd/bit/bench_apply_wbtest.mbt b/modules/bit/cmd/bit/bench_apply_wbtest.mbt
index b667c5e4..3c954d84 100644
--- a/modules/bit/cmd/bit/bench_apply_wbtest.mbt
+++ b/modules/bit/cmd/bit/bench_apply_wbtest.mbt
@@ -21,7 +21,7 @@ fn bench_apply_ensure_repo() -> Unit {
   }
   // Create base files
   for i in 0..<100 {
-    let content = StringBuilder::new()
+    let content = StringBuilder()
     for line in 0..<50 {
       content.write_string("line \{line} of file \{i}\n")
     }
@@ -42,7 +42,7 @@ fn bench_apply_ensure_repo() -> Unit {
     _ => ()
   }
   // Generate patch file directly (unified diff format)
-  let diff_buf = StringBuilder::new()
+  let diff_buf = StringBuilder()
   for i in 0..<20 {
     diff_buf.write_string("diff --git a/file_\{i}.txt b/file_\{i}.txt\n")
     diff_buf.write_string("--- a/file_\{i}.txt\n")
diff --git a/modules/bit/cmd/bit/bench_cat_file_wbtest.mbt b/modules/bit/cmd/bit/bench_cat_file_wbtest.mbt
index 1c933f79..b9061031 100644
--- a/modules/bit/cmd/bit/bench_cat_file_wbtest.mbt
+++ b/modules/bit/cmd/bit/bench_cat_file_wbtest.mbt
@@ -79,9 +79,9 @@ test "bench cat-file -t commit (×10)" (b : @bench.T) {
   let oids = ensure_catfile_bench_repo()
   let oid = oids[0]
   let args = ["bit", "-C", bench_catfile_repo, "cat-file", "-t", oid]
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.unset_env_var("GIT_SHIM_CWD")
   b.bench(fn() {
     bench_stdout_suppress()
     for _ in 0..<bench_catfile_repeat {
@@ -97,9 +97,9 @@ test "bench cat-file -p commit (×10)" (b : @bench.T) {
   let oids = ensure_catfile_bench_repo()
   let oid = oids[0]
   let args = ["bit", "-C", bench_catfile_repo, "cat-file", "-p", oid]
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.unset_env_var("GIT_SHIM_CWD")
   b.bench(fn() {
     bench_stdout_suppress()
     for _ in 0..<bench_catfile_repeat {
@@ -115,9 +115,9 @@ test "bench cat-file -s commit (×10)" (b : @bench.T) {
   let oids = ensure_catfile_bench_repo()
   let oid = oids[0]
   let args = ["bit", "-C", bench_catfile_repo, "cat-file", "-s", oid]
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.unset_env_var("GIT_SHIM_CWD")
   b.bench(fn() {
     bench_stdout_suppress()
     for _ in 0..<bench_catfile_repeat {
@@ -133,9 +133,9 @@ test "bench cat-file -e commit (×10)" (b : @bench.T) {
   let oids = ensure_catfile_bench_repo()
   let oid = oids[0]
   let args = ["bit", "-C", bench_catfile_repo, "cat-file", "-e", oid]
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.unset_env_var("GIT_SHIM_CWD")
   b.bench(fn() {
     bench_stdout_suppress()
     for _ in 0..<bench_catfile_repeat {
diff --git a/modules/bit/cmd/bit/bench_e2e_clone_fetch_wbtest.mbt b/modules/bit/cmd/bit/bench_e2e_clone_fetch_wbtest.mbt
index 7b194b31..b2a75b16 100644
--- a/modules/bit/cmd/bit/bench_e2e_clone_fetch_wbtest.mbt
+++ b/modules/bit/cmd/bit/bench_e2e_clone_fetch_wbtest.mbt
@@ -55,14 +55,14 @@ fn e2e_cleanup_tree(fs : OsFs, path : String) -> Unit {
 
 ///|
 fn e2e_reset_git_env() -> Unit {
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_SHIM_PWD")
-  @sys.unset_env_var("GIT_SHIM_EXPLICIT_GIT_DIR")
-  @sys.unset_env_var("GIT_CONFIG_OVERRIDES")
-  @sys.unset_env_var("SHIM_REAL_GIT")
-  @sys.unset_env_var("GIT_SHIM_REAL_GIT")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_SHIM_PWD")
+  @env.unset_env_var("GIT_SHIM_EXPLICIT_GIT_DIR")
+  @env.unset_env_var("GIT_CONFIG_OVERRIDES")
+  @env.unset_env_var("SHIM_REAL_GIT")
+  @env.unset_env_var("GIT_SHIM_REAL_GIT")
 }
 
 ///|
diff --git a/modules/bit/cmd/bit/bench_grep_wbtest.mbt b/modules/bit/cmd/bit/bench_grep_wbtest.mbt
index 1808aa8a..6d26a521 100644
--- a/modules/bit/cmd/bit/bench_grep_wbtest.mbt
+++ b/modules/bit/cmd/bit/bench_grep_wbtest.mbt
@@ -51,7 +51,7 @@ fn bench_grep_file_body(
   lines_per_file : Int,
   hit_interval : Int,
 ) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for line_idx in 0..<lines_per_file {
     buf.write_string(
       "line=\{line_idx} file=\{file_idx} payload lorem ipsum dolor sit amet\n",
diff --git a/modules/bit/cmd/bit/bench_init_wbtest.mbt b/modules/bit/cmd/bit/bench_init_wbtest.mbt
index 027fdc09..9c64bdd6 100644
--- a/modules/bit/cmd/bit/bench_init_wbtest.mbt
+++ b/modules/bit/cmd/bit/bench_init_wbtest.mbt
@@ -27,9 +27,9 @@ fn ensure_bench_dir(path : String) -> Unit {
 
 ///|
 fn bench_reset_env() -> Unit {
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.unset_env_var("GIT_SHIM_CWD")
 }
 
 ///|
@@ -92,7 +92,7 @@ fn ensure_bench_config() -> Unit {
   @fs.write_string_to_file(bench_config_path, content) catch {
     _ => ()
   }
-  @sys.set_env_var("GIT_CONFIG_GLOBAL", bench_config_path)
+  @env.set_env_var("GIT_CONFIG_GLOBAL", bench_config_path)
 }
 
 ///|
@@ -150,10 +150,10 @@ test "bench init first status startup (-C)" (b : @bench.T) {
     _ => ()
   }
   let args = ["bit", "-C", bench_status_repo_root, "status", "--porcelain"]
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_CONFIG_OVERRIDES")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_CONFIG_OVERRIDES")
   b.bench(fn() {
     bench_stdout_suppress()
     for _ in 0..<bench_startup_repeat {
diff --git a/modules/bit/cmd/bit/blame.mbt b/modules/bit/cmd/bit/blame.mbt
index 96bc4cb2..0b6fe283 100644
--- a/modules/bit/cmd/bit/blame.mbt
+++ b/modules/bit/cmd/bit/blame.mbt
@@ -1,13 +1,13 @@
 ///|
 fn resolve_real_git_for_blame() -> String {
-  match @sys.get_env_var("SHIM_REAL_GIT") {
+  match @env.get_env_var("SHIM_REAL_GIT") {
     Some(path) =>
       if path.length() > 0 {
         path
       } else {
-        @sys.get_env_var("GIT_SHIM_REAL_GIT").unwrap_or("/usr/bin/git")
+        @env.get_env_var("GIT_SHIM_REAL_GIT").unwrap_or("/usr/bin/git")
       }
-    None => @sys.get_env_var("GIT_SHIM_REAL_GIT").unwrap_or("/usr/bin/git")
+    None => @env.get_env_var("GIT_SHIM_REAL_GIT").unwrap_or("/usr/bin/git")
   }
 }
 
@@ -814,7 +814,7 @@ async fn blame_find_line_origin_with_opts(
 ///|
 fn normalize_whitespace(s : String) -> String {
   // Collapse all whitespace to single spaces and trim
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   let mut in_space = true // Start true to trim leading spaces
   for c in s {
     if c == ' ' || c == '\t' {
diff --git a/modules/bit/cmd/bit/branch.mbt b/modules/bit/cmd/bit/branch.mbt
index 032671cc..096c2a3e 100644
--- a/modules/bit/cmd/bit/branch.mbt
+++ b/modules/bit/cmd/bit/branch.mbt
@@ -453,7 +453,7 @@ fn branch_pad_right(s : String, width : Int) -> String {
   if s.length() >= width {
     return s
   }
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_string(s)
   for i = s.length(); i < width; i = i + 1 {
     buf.write_char(' ')
@@ -572,7 +572,7 @@ fn branch_resolve_column_mode(
 
 ///|
 fn branch_term_columns() -> Int {
-  match @sys.get_env_var("COLUMNS") {
+  match @env.get_env_var("COLUMNS") {
     Some(raw) => {
       let parsed = @string.parse_int(raw) catch { _ => 80 }
       if parsed > 1 {
@@ -731,14 +731,14 @@ async fn branch_resolve_start_point(
 
 ///|
 fn branch_get_committer_identity() -> (String, String, Int64, String) {
-  let name = match @sys.get_env_var("GIT_COMMITTER_NAME") {
+  let name = match @env.get_env_var("GIT_COMMITTER_NAME") {
     Some(n) => n
-    None => @sys.get_env_var("USER").unwrap_or("Unknown")
+    None => @env.get_env_var("USER").unwrap_or("Unknown")
   }
-  let email = match @sys.get_env_var("GIT_COMMITTER_EMAIL") {
+  let email = match @env.get_env_var("GIT_COMMITTER_EMAIL") {
     Some(e) => e
     None =>
-      match @sys.get_env_var("USER") {
+      match @env.get_env_var("USER") {
         Some(u) => u + "@localhost"
         None => "unknown@localhost"
       }
diff --git a/modules/bit/cmd/bit/cat_file.mbt b/modules/bit/cmd/bit/cat_file.mbt
index d2e88961..1e31f3f5 100644
--- a/modules/bit/cmd/bit/cat_file.mbt
+++ b/modules/bit/cmd/bit/cat_file.mbt
@@ -416,7 +416,7 @@ async fn handle_cat_file(args : Array[String]) -> Unit raise Error {
     let mut pending_chunks : Array[Bytes] = []
     let buffer_enabled = batch_buffer && !batch_no_buffer
     let suppress_flush_on_exit = match
-      @sys.get_env_var("GIT_TEST_CAT_FILE_NO_FLUSH_ON_EXIT") {
+      @env.get_env_var("GIT_TEST_CAT_FILE_NO_FLUSH_ON_EXIT") {
       Some(value) => value == "1"
       None => false
     }
diff --git a/modules/bit/cmd/bit/check_ref_format.mbt b/modules/bit/cmd/bit/check_ref_format.mbt
index 5d5b2265..2386d2d4 100644
--- a/modules/bit/cmd/bit/check_ref_format.mbt
+++ b/modules/bit/cmd/bit/check_ref_format.mbt
@@ -132,7 +132,7 @@ fn check_ref_format_valid(
 ///|
 fn check_ref_format_normalize(refname : String) -> String {
   // Collapse consecutive slashes (shouldn't exist if valid, but just in case)
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   let chars = refname.to_array()
   let mut prev_slash = false
   for c in chars {
diff --git a/modules/bit/cmd/bit/checkout.mbt b/modules/bit/cmd/bit/checkout.mbt
index d75c4a57..c38e8d43 100644
--- a/modules/bit/cmd/bit/checkout.mbt
+++ b/modules/bit/cmd/bit/checkout.mbt
@@ -299,14 +299,14 @@ fn checkout_append_head_reflog(
   old_id : @bitcore.ObjectId,
   new_id : @bitcore.ObjectId,
 ) -> Unit raise Error {
-  let name = match @sys.get_env_var("GIT_COMMITTER_NAME") {
+  let name = match @env.get_env_var("GIT_COMMITTER_NAME") {
     Some(n) => n
-    None => @sys.get_env_var("USER").unwrap_or("Unknown")
+    None => @env.get_env_var("USER").unwrap_or("Unknown")
   }
-  let email = match @sys.get_env_var("GIT_COMMITTER_EMAIL") {
+  let email = match @env.get_env_var("GIT_COMMITTER_EMAIL") {
     Some(e) => e
     None =>
-      match @sys.get_env_var("USER") {
+      match @env.get_env_var("USER") {
         Some(u) => u + "@localhost"
         None => "unknown@localhost"
       }
@@ -716,11 +716,11 @@ fn collect_missing_checkout_blob_ids(
 
 ///|
 fn append_checkout_fetch_trace(fs : OsFs) -> Unit {
-  match @sys.get_env_var("GIT_TRACE_PACKET") {
+  match @env.get_env_var("GIT_TRACE_PACKET") {
     Some(path) => append_checkout_trace_line(fs, path, "fetch> done\n")
     None => ()
   }
-  match @sys.get_env_var("GIT_TRACE2_EVENT") {
+  match @env.get_env_var("GIT_TRACE2_EVENT") {
     Some(path) =>
       append_checkout_trace_line(
         fs, path, "{\"event\":\"data\",\"category\":\"fetch\",\"key\":\"total_rounds\",\"value\":\"1\"}\n",
diff --git a/modules/bit/cmd/bit/checkout_wbtest.mbt b/modules/bit/cmd/bit/checkout_wbtest.mbt
index a792badd..91575573 100644
--- a/modules/bit/cmd/bit/checkout_wbtest.mbt
+++ b/modules/bit/cmd/bit/checkout_wbtest.mbt
@@ -86,10 +86,10 @@ async fn checkout_wbtest_case_treeish_restore() -> Unit raise Error {
   let repo_dir = root + "/repo"
   let linked_dir = root + "/linked"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -112,10 +112,10 @@ async fn checkout_wbtest_case_treeish_restore() -> Unit raise Error {
   )
   fs.write_string(repo_dir + "/init.t", "dirty\n")
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
   checkout_wbtest_run_shim_git(repo_dir, [
     "checkout", "-q", "newmain", "--", "init.t",
   ])
@@ -143,10 +143,10 @@ async fn checkout_wbtest_case_switch_back_to_main() -> Unit raise Error {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -155,10 +155,10 @@ async fn checkout_wbtest_case_switch_back_to_main() -> Unit raise Error {
   add_test_run_git(repo_dir, ["add", "init.t"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   checkout_wbtest_run_shim_git(repo_dir, ["checkout", "-q", "-b", "newbranch"])
   fs.write_string(repo_dir + "/myworld", "hello\n")
@@ -190,10 +190,10 @@ async fn checkout_wbtest_case_switch_back_with_detached_worktree() -> Unit raise
   let repo_dir = root + "/repo"
   let detached_dir = root + "/existing_empty"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -212,10 +212,10 @@ async fn checkout_wbtest_case_switch_back_with_detached_worktree() -> Unit raise
     new_branch=None,
   )
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   checkout_wbtest_run_shim_git(repo_dir, ["checkout", "-q", "-b", "newbranch"])
   fs.write_string(repo_dir + "/myworld", "hello\n")
@@ -246,10 +246,10 @@ async fn checkout_wbtest_case_switch_back_after_shim_commit() -> Unit raise Erro
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -258,10 +258,10 @@ async fn checkout_wbtest_case_switch_back_after_shim_commit() -> Unit raise Erro
   add_test_run_git(repo_dir, ["add", "init.t"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   checkout_wbtest_run_shim_git(repo_dir, ["checkout", "-q", "-b", "newbranch"])
   fs.write_string(repo_dir + "/myworld", "hello\n")
@@ -293,10 +293,10 @@ async fn checkout_wbtest_case_branch_in_use() -> Unit raise Error {
   let repo_dir = root + "/repo"
   let linked_dir = root + "/linked"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -314,10 +314,10 @@ async fn checkout_wbtest_case_branch_in_use() -> Unit raise Error {
     new_branch=Some("newmain"),
   )
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   let (_, stdout, stderr) = checkout_wbtest_collect_shim_git_output(repo_dir, [
     "checkout", "-q", "newmain",
@@ -347,10 +347,10 @@ async fn checkout_wbtest_case_force_branch_in_use() -> Unit raise Error {
   let repo_dir = root + "/repo"
   let linked_dir = root + "/linked"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -369,10 +369,10 @@ async fn checkout_wbtest_case_force_branch_in_use() -> Unit raise Error {
   )
   add_test_run_git(repo_dir, ["checkout", "--detach", "-q", "HEAD"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   @test.assert_eq(
     checkout_branch_in_use_path(fs, repo_dir, "newmain"),
@@ -419,10 +419,10 @@ async fn checkout_wbtest_case_symlinked_branch_in_use() -> Unit raise Error {
   let linked_dir = root + "/there"
   let linked_head = repo_dir + "/.git/worktrees/there/HEAD"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -448,10 +448,10 @@ async fn checkout_wbtest_case_symlinked_branch_in_use() -> Unit raise Error {
   )
   @test.assert_eq(link_code, 0)
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   @test.assert_eq(
     checkout_branch_in_use_path(fs, repo_dir, "newmain"),
@@ -482,10 +482,10 @@ async fn checkout_wbtest_case_recheckout_current_branch_with_symlink_head() -> U
   let linked_dir = root + "/there"
   let linked_head = repo_dir + "/.git/worktrees/there/HEAD"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -511,10 +511,10 @@ async fn checkout_wbtest_case_recheckout_current_branch_with_symlink_head() -> U
   )
   @test.assert_eq(link_code, 0)
 
-  @sys.set_env_var("GIT_SHIM_CWD", linked_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", linked_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", linked_dir)
+  @env.set_env_var("GIT_SHIM_PWD", linked_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   checkout_wbtest_run_shim_git(linked_dir, ["checkout", "-q", "newmain"])
 
@@ -541,10 +541,10 @@ async fn checkout_wbtest_case_bare_repo_checkout_fails() -> Unit raise Error {
   let repo_dir = root + "/repo"
   let bare_dir = root + "/bare.git"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -554,10 +554,10 @@ async fn checkout_wbtest_case_bare_repo_checkout_fails() -> Unit raise Error {
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
   add_test_run_git(root, ["clone", "--bare", "repo", "bare.git"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", bare_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", bare_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", bare_dir)
+  @env.set_env_var("GIT_SHIM_PWD", bare_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   let (_, stdout, stderr) = checkout_wbtest_collect_shim_git_output(bare_dir, [
     "checkout", "-q", "main",
@@ -582,10 +582,10 @@ async fn checkout_wbtest_case_orphan_branch() -> Unit raise Error {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -594,10 +594,10 @@ async fn checkout_wbtest_case_orphan_branch() -> Unit raise Error {
   add_test_run_git(repo_dir, ["add", "init.t"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   checkout_wbtest_run_shim_git(repo_dir, [
     "checkout", "-q", "--orphan", "orphan1",
@@ -632,10 +632,10 @@ async fn checkout_wbtest_case_checkout_updates_head_reflog() -> Unit raise Error
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -647,10 +647,10 @@ async fn checkout_wbtest_case_checkout_updates_head_reflog() -> Unit raise Error
   fs.write_string(repo_dir + "/init.t", "second\n")
   add_test_run_git(repo_dir, ["commit", "-am", "second", "-q"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   let before = @bitrepo.read_reflog(fs, repo_dir + "/.git", "HEAD")
   @test.assert_eq(before.length(), 2)
@@ -690,10 +690,10 @@ async fn checkout_wbtest_case_force_checkout_clears_merge_state() -> Unit raise
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -711,10 +711,10 @@ async fn checkout_wbtest_case_force_checkout_clears_merge_state() -> Unit raise
   fs.write_string(repo_dir + "/.git/MERGE_HEAD", side_id + "\n")
   fs.write_string(repo_dir + "/.git/MERGE_MSG", "merge side\n")
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   checkout_wbtest_run_shim_git(repo_dir, ["checkout", "-q", "-f", "side"])
 
@@ -746,10 +746,10 @@ async fn checkout_wbtest_case_treeish_restore_updates_index() -> Unit raise Erro
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -760,10 +760,10 @@ async fn checkout_wbtest_case_treeish_restore_updates_index() -> Unit raise Erro
   fs.write_string(repo_dir + "/file", "dirty\n")
   add_test_run_git(repo_dir, ["add", "file"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
   checkout_wbtest_run_shim_git(repo_dir, [
     "checkout", "-q", "HEAD", "--", "file",
   ])
@@ -791,10 +791,10 @@ async fn checkout_wbtest_case_treeish_restore_without_separator() -> Unit raise
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -808,10 +808,10 @@ async fn checkout_wbtest_case_treeish_restore_without_separator() -> Unit raise
   add_test_run_git(repo_dir, ["checkout", "-q", "main"])
   fs.write_string(repo_dir + "/file", "dirty\n")
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
   checkout_wbtest_run_shim_git(repo_dir, ["checkout", "-q", "side", "file"])
 
   @test.assert_eq(decode_bytes(fs.read_file(repo_dir + "/file")), "side\n")
@@ -837,10 +837,10 @@ async fn checkout_wbtest_case_track_sets_branch_config() -> Unit raise Error {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -851,10 +851,10 @@ async fn checkout_wbtest_case_track_sets_branch_config() -> Unit raise Error {
   add_test_run_git(repo_dir, ["remote", "add", "me", "."])
   add_test_run_git(repo_dir, ["update-ref", "refs/remotes/me/main", "HEAD"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
   checkout_wbtest_run_shim_git(repo_dir, [
     "checkout", "-q", "--track", "-b", "topic", "me/main",
   ])
@@ -885,10 +885,10 @@ async fn checkout_wbtest_case_detach_head_without_target() -> Unit raise Error {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -900,10 +900,10 @@ async fn checkout_wbtest_case_detach_head_without_target() -> Unit raise Error {
     add_test_git_stdout(repo_dir, ["rev-parse", "HEAD"]),
   )
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
   checkout_wbtest_run_shim_git(repo_dir, ["checkout", "-q", "--detach"])
 
   @test.assert_eq(
@@ -928,10 +928,10 @@ async fn checkout_wbtest_case_previous_checkout_syntax() -> Unit raise Error {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -940,10 +940,10 @@ async fn checkout_wbtest_case_previous_checkout_syntax() -> Unit raise Error {
   add_test_run_git(repo_dir, ["add", "file"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "base"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   checkout_wbtest_run_shim_git(repo_dir, ["checkout", "-q", "-b", "topic"])
   checkout_wbtest_run_shim_git(repo_dir, ["checkout", "-q", "main"])
diff --git a/modules/bit/cmd/bit/clone.mbt b/modules/bit/cmd/bit/clone.mbt
index bd9dc4b0..0a1eda71 100644
--- a/modules/bit/cmd/bit/clone.mbt
+++ b/modules/bit/cmd/bit/clone.mbt
@@ -5,10 +5,10 @@ fn clone_parse_recurse_submodules_filter(arg : String) -> String {
 
 ///|
 fn clone_command_root(fallback_root : String) -> String {
-  match @sys.get_env_var("GIT_SHIM_CWD") {
+  match @env.get_env_var("GIT_SHIM_CWD") {
     Some(dir) => dir
     None =>
-      match @sys.get_env_var("GIT_SHIM_PWD") {
+      match @env.get_env_var("GIT_SHIM_PWD") {
         Some(dir) => dir
         None =>
           match @env.current_dir() {
@@ -360,13 +360,13 @@ async fn handle_clone(args : Array[String]) -> Unit raise Error {
   let config_overrides = @bitlib.parse_config_overrides()
   let protocol_version = match config_overrides.get("protocol.version") {
     Some(v) => v
-    None => @sys.get_env_var("GIT_TEST_PROTOCOL_VERSION").unwrap_or("0")
+    None => @env.get_env_var("GIT_TEST_PROTOCOL_VERSION").unwrap_or("0")
   }
   let prefer_v2 = protocol_version == "2"
   let transport_prefer_v2 = prefer_v2 || depth > 0 || filter.is_partial()
   match ssh_ip_option {
-    Some(v) => @sys.set_env_var("BIT_SSH_IP_VERSION", v)
-    None => @sys.unset_env_var("BIT_SSH_IP_VERSION")
+    Some(v) => @env.set_env_var("BIT_SSH_IP_VERSION", v)
+    None => @env.unset_env_var("BIT_SSH_IP_VERSION")
   }
   ignore(has_filter_flag)
   ignore(mirror)
@@ -473,7 +473,7 @@ async fn handle_clone(args : Array[String]) -> Unit raise Error {
   let mut clone_root = target
   let mut use_env_work_tree = false
   if !bare {
-    match @sys.get_env_var("GIT_WORK_TREE") {
+    match @env.get_env_var("GIT_WORK_TREE") {
       Some(work_tree) => {
         clone_root = absolutize_clone_path(
           command_root,
@@ -867,8 +867,8 @@ async fn handle_clone(args : Array[String]) -> Unit raise Error {
 ///|
 fn clone_restore_env(name : String, value : String?) -> Unit {
   match value {
-    Some(v) => @sys.set_env_var(name, v)
-    None => @sys.unset_env_var(name)
+    Some(v) => @env.set_env_var(name, v)
+    None => @env.unset_env_var(name)
   }
 }
 
@@ -933,14 +933,14 @@ async fn clone_run_recurse_submodules(
   filters : Array[String],
   quiet : Bool,
 ) -> Unit raise Error {
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_CWD", clone_root)
-  @sys.set_env_var("GIT_SHIM_PWD", clone_root)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", clone_root)
+  @env.set_env_var("GIT_SHIM_PWD", clone_root)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
   let args = clone_build_recurse_submodules_args(filters, quiet)
   let result : Result[Unit, Error] = try handle_submodule(args) catch {
     e => Err(e)
@@ -1144,12 +1144,12 @@ fn clone_normalize_optional_value(value : String?) -> String? {
 
 ///|
 fn clone_relay_preferred_sender() -> String? {
-  clone_normalize_optional_value(@sys.get_env_var("BIT_RELAY_CLONE_SENDER"))
+  clone_normalize_optional_value(@env.get_env_var("BIT_RELAY_CLONE_SENDER"))
 }
 
 ///|
 fn clone_relay_preferred_repo() -> String? {
-  clone_normalize_optional_value(@sys.get_env_var("BIT_RELAY_CLONE_REPO"))
+  clone_normalize_optional_value(@env.get_env_var("BIT_RELAY_CLONE_REPO"))
 }
 
 ///|
@@ -1212,7 +1212,7 @@ fn clone_ref_format_requires_advanced_compat(ref_format : String) -> Bool {
 
 ///|
 fn clone_default_ref_format() -> String {
-  match @sys.get_env_var("GIT_TEST_DEFAULT_REF_FORMAT") {
+  match @env.get_env_var("GIT_TEST_DEFAULT_REF_FORMAT") {
     Some(value) => {
       let normalized = value.to_lower()
       if normalized == "reftable" {
@@ -1317,13 +1317,13 @@ fn clone_caps_contain_token(caps : Array[String], token : String) -> Bool {
 ///|
 fn clone_split_words(input : String) -> Array[String] {
   let words : Array[String] = []
-  let mut current = StringBuilder::new()
+  let mut current = StringBuilder()
   for ch in input {
     if ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' {
       let s = current.to_string()
       if s.length() > 0 {
         words.push(s)
-        current = StringBuilder::new()
+        current = StringBuilder()
       }
     } else {
       current.write_char(ch)
@@ -1526,7 +1526,7 @@ fn emit_clone_bundle_trace_events(
   if bundle_uris.length() == 0 {
     return ()
   }
-  match @sys.get_env_var("GIT_TRACE2_EVENT") {
+  match @env.get_env_var("GIT_TRACE2_EVENT") {
     Some(path) =>
       for uri in bundle_uris {
         append_clone_trace_line(
diff --git a/modules/bit/cmd/bit/clone_wbtest.mbt b/modules/bit/cmd/bit/clone_wbtest.mbt
index 7a3d1c65..cc4801ab 100644
--- a/modules/bit/cmd/bit/clone_wbtest.mbt
+++ b/modules/bit/cmd/bit/clone_wbtest.mbt
@@ -117,21 +117,21 @@ test "clone relay: no peers returns none" {
 
 ///|
 test "clone relay: preferred sender env is trimmed and optional" {
-  @sys.set_env_var("BIT_RELAY_CLONE_SENDER", " node-preferred ")
+  @env.set_env_var("BIT_RELAY_CLONE_SENDER", " node-preferred ")
   @test.assert_eq(clone_relay_preferred_sender(), Some("node-preferred"))
-  @sys.set_env_var("BIT_RELAY_CLONE_SENDER", "   ")
+  @env.set_env_var("BIT_RELAY_CLONE_SENDER", "   ")
   @test.assert_eq(clone_relay_preferred_sender(), None)
-  @sys.unset_env_var("BIT_RELAY_CLONE_SENDER")
+  @env.unset_env_var("BIT_RELAY_CLONE_SENDER")
   @test.assert_eq(clone_relay_preferred_sender(), None)
 }
 
 ///|
 test "clone relay: preferred repo env is trimmed and optional" {
-  @sys.set_env_var("BIT_RELAY_CLONE_REPO", " repo-b ")
+  @env.set_env_var("BIT_RELAY_CLONE_REPO", " repo-b ")
   @test.assert_eq(clone_relay_preferred_repo(), Some("repo-b"))
-  @sys.set_env_var("BIT_RELAY_CLONE_REPO", "   ")
+  @env.set_env_var("BIT_RELAY_CLONE_REPO", "   ")
   @test.assert_eq(clone_relay_preferred_repo(), None)
-  @sys.unset_env_var("BIT_RELAY_CLONE_REPO")
+  @env.unset_env_var("BIT_RELAY_CLONE_REPO")
   @test.assert_eq(clone_relay_preferred_repo(), None)
 }
 
@@ -189,8 +189,8 @@ fn cleanup_clone_wbtest_tree(fs : OsFs, path : String) -> Unit {
 ///|
 fn restore_clone_env(name : String, value : String?) -> Unit {
   match value {
-    Some(v) => @sys.set_env_var(name, v)
-    None => @sys.unset_env_var(name)
+    Some(v) => @env.set_env_var(name, v)
+    None => @env.unset_env_var(name)
   }
 }
 
@@ -214,10 +214,10 @@ test "clone: configure_reftable_ref_storage writes reftable metadata" {
 
 ///|
 test "clone: command root prefers shim pwd when cwd is absent" {
-  let prev_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.set_env_var("GIT_SHIM_PWD", "/tmp/bit-clone-command-root")
+  let prev_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.set_env_var("GIT_SHIM_PWD", "/tmp/bit-clone-command-root")
   let resolved = clone_command_root("/tmp/bit-clone-fallback")
   restore_clone_env("GIT_SHIM_CWD", prev_cwd)
   restore_clone_env("GIT_SHIM_PWD", prev_pwd)
diff --git a/modules/bit/cmd/bit/column.mbt b/modules/bit/cmd/bit/column.mbt
index 409435c9..d8ee7835 100644
--- a/modules/bit/cmd/bit/column.mbt
+++ b/modules/bit/cmd/bit/column.mbt
@@ -98,7 +98,7 @@ async fn column_layout_column(
     1
   }
   let num_rows = (items.length() + num_cols - 1) / num_cols
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   let mut row = 0
   while row < num_rows {
     let mut col = 0
@@ -149,7 +149,7 @@ async fn column_layout_row(
   } else {
     1
   }
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i, item in items {
     result.write_string(item)
     let col_in_row = i % num_cols
diff --git a/modules/bit/cmd/bit/commit.mbt b/modules/bit/cmd/bit/commit.mbt
index ea1bc598..fb5059bb 100644
--- a/modules/bit/cmd/bit/commit.mbt
+++ b/modules/bit/cmd/bit/commit.mbt
@@ -104,8 +104,8 @@ async fn handle_commit(args : Array[String]) -> Unit raise Error {
     match commit_storage_runtime_delegate_args(fs, git_dir, args) {
       Some(commit_args) => {
         // Pass resolved author/committer to storage_runtime via env bridge
-        @sys.set_env_var("BIT_COMMIT_AUTHOR", get_author_string())
-        @sys.set_env_var("BIT_COMMIT_COMMITTER", get_committer_string())
+        @env.set_env_var("BIT_COMMIT_AUTHOR", get_author_string())
+        @env.set_env_var("BIT_COMMIT_COMMITTER", get_committer_string())
         @runtime.run_storage_command(
           fs,
           rfs,
diff --git a/modules/bit/cmd/bit/commit_graph.mbt b/modules/bit/cmd/bit/commit_graph.mbt
index c5e24cbe..895dfa11 100644
--- a/modules/bit/cmd/bit/commit_graph.mbt
+++ b/modules/bit/cmd/bit/commit_graph.mbt
@@ -179,7 +179,7 @@ async fn check_commit_graph_paranoia(
   fs : OsFs,
   git_dir : String,
 ) -> Unit raise Error {
-  match @sys.get_env_var("GIT_COMMIT_GRAPH_PARANOIA") {
+  match @env.get_env_var("GIT_COMMIT_GRAPH_PARANOIA") {
     Some(value) => if value != "true" { return }
     None => return
   }
diff --git a/modules/bit/cmd/bit/commit_tree.mbt b/modules/bit/cmd/bit/commit_tree.mbt
index 2f72b14b..45e4ba6c 100644
--- a/modules/bit/cmd/bit/commit_tree.mbt
+++ b/modules/bit/cmd/bit/commit_tree.mbt
@@ -130,8 +130,8 @@ fn get_commit_tree_ident(
   name_env : String,
   email_env : String,
 ) -> (String, String) {
-  let name_from_env = @sys.get_env_var(name_env)
-  let email_from_env = @sys.get_env_var(email_env)
+  let name_from_env = @env.get_env_var(name_env)
+  let email_from_env = @env.get_env_var(email_env)
   let mut name = name_from_env.unwrap_or("")
   let mut email = email_from_env.unwrap_or("")
   let name_set = name_from_env is Some(_)
@@ -199,7 +199,7 @@ fn get_commit_tree_ident(
 
 ///|
 fn get_commit_tree_timestamp(env_name : String) -> Int64 {
-  match @sys.get_env_var(env_name) {
+  match @env.get_env_var(env_name) {
     Some(raw) =>
       match parse_git_env_timestamp(raw) {
         Some(ts) => ts
@@ -211,7 +211,7 @@ fn get_commit_tree_timestamp(env_name : String) -> Int64 {
 
 ///|
 fn get_commit_tree_timezone(env_name : String) -> String {
-  match @sys.get_env_var(env_name) {
+  match @env.get_env_var(env_name) {
     Some(raw) =>
       match parse_git_env_timezone(raw) {
         Some(tz) => tz
diff --git a/modules/bit/cmd/bit/commit_wbtest.mbt b/modules/bit/cmd/bit/commit_wbtest.mbt
index 98e042a1..9e091d34 100644
--- a/modules/bit/cmd/bit/commit_wbtest.mbt
+++ b/modules/bit/cmd/bit/commit_wbtest.mbt
@@ -194,13 +194,13 @@ async test "commit: pathspec staging updates submodule gitlink entry" {
   commit_wbtest_run_git(super_dir, ["config", "user.name", "Test User"])
   commit_wbtest_run_git(super_dir, ["config", "user.email", "test@example.com"])
 
-  let prev_allow_protocol = @sys.get_env_var("GIT_ALLOW_PROTOCOL")
-  @sys.set_env_var("GIT_ALLOW_PROTOCOL", "file")
+  let prev_allow_protocol = @env.get_env_var("GIT_ALLOW_PROTOCOL")
+  @env.set_env_var("GIT_ALLOW_PROTOCOL", "file")
   commit_wbtest_run_git(super_dir, ["submodule", "add", "./../sub", "submodule"])
   commit_wbtest_run_git(super_dir, ["commit", "-qam", "initial"])
   match prev_allow_protocol {
-    Some(value) => @sys.set_env_var("GIT_ALLOW_PROTOCOL", value)
-    None => @sys.unset_env_var("GIT_ALLOW_PROTOCOL")
+    Some(value) => @env.set_env_var("GIT_ALLOW_PROTOCOL", value)
+    None => @env.unset_env_var("GIT_ALLOW_PROTOCOL")
   }
 
   commit_wbtest_run_git(super_dir + "/submodule", [
@@ -251,16 +251,16 @@ async test "commit: amend preserves distinct author and committer dates" {
   cleanup_tree(fs, root)
   fs.mkdir_p(root)
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  let prev_author_name = @sys.get_env_var("GIT_AUTHOR_NAME")
-  let prev_author_email = @sys.get_env_var("GIT_AUTHOR_EMAIL")
-  let prev_committer_name = @sys.get_env_var("GIT_COMMITTER_NAME")
-  let prev_committer_email = @sys.get_env_var("GIT_COMMITTER_EMAIL")
-  let prev_author_date = @sys.get_env_var("GIT_AUTHOR_DATE")
-  let prev_committer_date = @sys.get_env_var("GIT_COMMITTER_DATE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  let prev_author_name = @env.get_env_var("GIT_AUTHOR_NAME")
+  let prev_author_email = @env.get_env_var("GIT_AUTHOR_EMAIL")
+  let prev_committer_name = @env.get_env_var("GIT_COMMITTER_NAME")
+  let prev_committer_email = @env.get_env_var("GIT_COMMITTER_EMAIL")
+  let prev_author_date = @env.get_env_var("GIT_AUTHOR_DATE")
+  let prev_committer_date = @env.get_env_var("GIT_COMMITTER_DATE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_DIR", prev_git_dir)
@@ -282,18 +282,18 @@ async test "commit: amend preserves distinct author and committer dates" {
   fs.write_string(root + "/a.txt", "after\n")
   commit_wbtest_run_git(root, ["add", "a.txt"])
 
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_PWD", root)
-  @sys.set_env_var("GIT_AUTHOR_NAME", "Author User")
-  @sys.set_env_var("GIT_AUTHOR_EMAIL", "author@example.com")
-  @sys.set_env_var("GIT_COMMITTER_NAME", "Committer User")
-  @sys.set_env_var("GIT_COMMITTER_EMAIL", "committer@example.com")
-  @sys.set_env_var("GIT_AUTHOR_DATE", "1112911993 -0700")
-  @sys.set_env_var("GIT_COMMITTER_DATE", "1112912001 +0900")
-
-  @sys.set_env_var("GIT_SHIM_PWD", root)
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_PWD", root)
+  @env.set_env_var("GIT_AUTHOR_NAME", "Author User")
+  @env.set_env_var("GIT_AUTHOR_EMAIL", "author@example.com")
+  @env.set_env_var("GIT_COMMITTER_NAME", "Committer User")
+  @env.set_env_var("GIT_COMMITTER_EMAIL", "committer@example.com")
+  @env.set_env_var("GIT_AUTHOR_DATE", "1112911993 -0700")
+  @env.set_env_var("GIT_COMMITTER_DATE", "1112912001 +0900")
+
+  @env.set_env_var("GIT_SHIM_PWD", root)
   handle_commit(["-q", "--amend", "-m", "rewritten"]) catch {
     err => fail("handle_commit failed: \{err}")
   }
@@ -328,10 +328,10 @@ async test "commit: merge state commit records MERGE_HEAD as second parent" {
   cleanup_tree(fs, root)
   fs.mkdir_p(root)
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   commit_wbtest_run_git(root, ["init", "--initial-branch=main", "-q", "."])
   commit_wbtest_run_git(root, ["config", "user.name", "Test User"])
@@ -359,10 +359,10 @@ async test "commit: merge state commit records MERGE_HEAD as second parent" {
   fs.write_string(root + "/file", "main\nside\n")
   commit_wbtest_run_git(root, ["add", "file"])
 
-  @sys.set_env_var("GIT_SHIM_PWD", root)
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_PWD", root)
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_DIR", prev_git_dir)
@@ -394,10 +394,10 @@ async test "commit: -S stores gpgsig header via configured signing program" {
   cleanup_tree(fs, root)
   fs.mkdir_p(root)
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_DIR", prev_git_dir)
@@ -414,10 +414,10 @@ async test "commit: -S stores gpgsig header via configured signing program" {
   fs.write_string(root + "/signed.txt", "signed\n")
   commit_wbtest_run_git(root, ["add", "signed.txt"])
 
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_PWD", root)
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_PWD", root)
 
   handle_commit(["-q", "-S", "-m", "signed"]) catch {
     err => fail("handle_commit failed: \{err}")
@@ -448,10 +448,10 @@ async test "commit: -S stores ssh signature header via ssh signing format" {
   cleanup_tree(fs, root)
   fs.mkdir_p(root)
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_DIR", prev_git_dir)
@@ -474,10 +474,10 @@ async test "commit: -S stores ssh signature header via ssh signing format" {
   fs.write_string(root + "/signed-ssh.txt", "signed ssh\n")
   commit_wbtest_run_git(root, ["add", "signed-ssh.txt"])
 
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_PWD", root)
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_PWD", root)
 
   handle_commit(["-q", "-S", "-m", "signed ssh"]) catch {
     err => fail("handle_commit failed: \{err}")
diff --git a/modules/bit/cmd/bit/completion.mbt b/modules/bit/cmd/bit/completion.mbt
index b0454b55..148ad86e 100644
--- a/modules/bit/cmd/bit/completion.mbt
+++ b/modules/bit/cmd/bit/completion.mbt
@@ -20,7 +20,7 @@ async fn handle_completion(args : Array[String]) -> Unit {
 
 ///|
 fn generate_bash_completion() -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   let header =
     #|#!/bin/bash
     #|# bit shell completion - generated by 'bit completion bash'
@@ -341,7 +341,7 @@ fn generate_bash_completion() -> String {
 
 ///|
 fn generate_zsh_completion() -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   let header =
     #|#compdef bit
     #|# bit shell completion - generated by 'bit completion zsh'
diff --git a/modules/bit/cmd/bit/config.mbt b/modules/bit/cmd/bit/config.mbt
index dbae2b22..2658f5fc 100644
--- a/modules/bit/cmd/bit/config.mbt
+++ b/modules/bit/cmd/bit/config.mbt
@@ -261,19 +261,19 @@ async fn handle_config(args : Array[String]) -> Unit raise Error {
     Some(path) => if path == "-" { "-" } else { resolve_in_cwd(path) }
     None =>
       if global_mode {
-        match @sys.get_env_var("GIT_CONFIG_GLOBAL") {
+        match @env.get_env_var("GIT_CONFIG_GLOBAL") {
           Some(path) => path
           None =>
-            match @sys.get_env_var("HOME") {
+            match @env.get_env_var("HOME") {
               Some(home) => home + "/.gitconfig"
               None => ".gitconfig"
             }
         }
       } else if system_mode {
-        @sys.get_env_var("GIT_CONFIG_SYSTEM").unwrap_or("/etc/gitconfig")
+        @env.get_env_var("GIT_CONFIG_SYSTEM").unwrap_or("/etc/gitconfig")
       } else {
         // GIT_CONFIG environment variable overrides default path
-        match @sys.get_env_var("GIT_CONFIG") {
+        match @env.get_env_var("GIT_CONFIG") {
           Some(path) => if path == "-" { "-" } else { resolve_in_cwd(path) }
           None => {
             let rfs : &@bitcore.RepoFileSystem = fs
@@ -303,7 +303,7 @@ async fn handle_config(args : Array[String]) -> Unit raise Error {
   // Handle --edit
   if edit_mode {
     // Editor precedence: GIT_EDITOR > core.editor > VISUAL > EDITOR > vi
-    let editor = match @sys.get_env_var("GIT_EDITOR") {
+    let editor = match @env.get_env_var("GIT_EDITOR") {
       Some(e) => e
       None => {
         // Try core.editor from repo config
@@ -321,9 +321,9 @@ async fn handle_config(args : Array[String]) -> Unit raise Error {
         match core_editor {
           Some(e) => e
           None =>
-            match @sys.get_env_var("VISUAL") {
+            match @env.get_env_var("VISUAL") {
               Some(e) => e
-              None => @sys.get_env_var("EDITOR").unwrap_or("vi")
+              None => @env.get_env_var("EDITOR").unwrap_or("vi")
             }
         }
       }
@@ -356,8 +356,8 @@ async fn handle_config(args : Array[String]) -> Unit raise Error {
   let is_read_op = list_mode || get_mode || get_all_mode || get_regexp_mode
   if is_read_op && config_path != "-" && !@fs.path_exists(config_path) {
     if config_path_override is Some(_) ||
-      (global_mode && @sys.get_env_var("GIT_CONFIG_GLOBAL") is Some(_)) ||
-      (system_mode && @sys.get_env_var("GIT_CONFIG_SYSTEM") is Some(_)) {
+      (global_mode && @env.get_env_var("GIT_CONFIG_GLOBAL") is Some(_)) ||
+      (system_mode && @env.get_env_var("GIT_CONFIG_SYSTEM") is Some(_)) {
       eprint_line(
         "fatal: unable to read config file '\{config_path}': No such file or directory",
       )
@@ -379,9 +379,9 @@ async fn handle_config(args : Array[String]) -> Unit raise Error {
     if need_multi_source {
       // Multi-source list with scope/origin prefix
       let rfs3 : &@bitcore.RepoFileSystem = fs
-      let nosystem = @sys.get_env_var("GIT_CONFIG_NOSYSTEM")
+      let nosystem = @env.get_env_var("GIT_CONFIG_NOSYSTEM")
       if nosystem is None || nosystem == Some("false") {
-        let sys_path = @sys.get_env_var("GIT_CONFIG_SYSTEM").unwrap_or(
+        let sys_path = @env.get_env_var("GIT_CONFIG_SYSTEM").unwrap_or(
           "/etc/gitconfig",
         )
         if rfs3.is_file(sys_path) {
@@ -395,11 +395,11 @@ async fn handle_config(args : Array[String]) -> Unit raise Error {
         }
       }
       // Global: GIT_CONFIG_GLOBAL or XDG + HOME
-      let global_path = match @sys.get_env_var("GIT_CONFIG_GLOBAL") {
+      let global_path = match @env.get_env_var("GIT_CONFIG_GLOBAL") {
         Some(p) => [p]
         None => {
           let paths : Array[String] = []
-          match @sys.get_env_var("HOME") {
+          match @env.get_env_var("HOME") {
             Some(home) => {
               let xdg = home + "/.config/git/config"
               if rfs3.is_file(xdg) {
@@ -544,9 +544,9 @@ async fn handle_config(args : Array[String]) -> Unit raise Error {
       let mut found = false
       if need_multi_source {
         let rfs4 : &@bitcore.RepoFileSystem = fs
-        let nosystem = @sys.get_env_var("GIT_CONFIG_NOSYSTEM")
+        let nosystem = @env.get_env_var("GIT_CONFIG_NOSYSTEM")
         if nosystem is None || nosystem == Some("false") {
-          let sys_path = @sys.get_env_var("GIT_CONFIG_SYSTEM").unwrap_or(
+          let sys_path = @env.get_env_var("GIT_CONFIG_SYSTEM").unwrap_or(
             "/etc/gitconfig",
           )
           if rfs4.is_file(sys_path) {
@@ -573,11 +573,11 @@ async fn handle_config(args : Array[String]) -> Unit raise Error {
             }
           }
         }
-        let global_paths = match @sys.get_env_var("GIT_CONFIG_GLOBAL") {
+        let global_paths = match @env.get_env_var("GIT_CONFIG_GLOBAL") {
           Some(p) => [p]
           None => {
             let paths : Array[String] = []
-            match @sys.get_env_var("HOME") {
+            match @env.get_env_var("HOME") {
               Some(home) => {
                 let xdg = home + "/.config/git/config"
                 if rfs4.is_file(xdg) {
@@ -1988,7 +1988,7 @@ fn format_config_output_value(
     }
   } else if get_path {
     if val.has_prefix("~/") {
-      match @sys.get_env_var("HOME") {
+      match @env.get_env_var("HOME") {
         Some(home) =>
           if home.length() == 0 {
             raise @bitcore.GitError::InvalidObject(
@@ -2120,14 +2120,14 @@ fn parse_config_color(value : String) -> String? {
 
 ///|
 fn resolve_real_git_for_config() -> String {
-  match @sys.get_env_var("SHIM_REAL_GIT") {
+  match @env.get_env_var("SHIM_REAL_GIT") {
     Some(path) =>
       if path.length() > 0 {
         path
       } else {
-        @sys.get_env_var("GIT_SHIM_REAL_GIT").unwrap_or("/usr/bin/git")
+        @env.get_env_var("GIT_SHIM_REAL_GIT").unwrap_or("/usr/bin/git")
       }
-    None => @sys.get_env_var("GIT_SHIM_REAL_GIT").unwrap_or("/usr/bin/git")
+    None => @env.get_env_var("GIT_SHIM_REAL_GIT").unwrap_or("/usr/bin/git")
   }
 }
 
diff --git a/modules/bit/cmd/bit/credential.mbt b/modules/bit/cmd/bit/credential.mbt
index 3ee466a6..7db878e2 100644
--- a/modules/bit/cmd/bit/credential.mbt
+++ b/modules/bit/cmd/bit/credential.mbt
@@ -69,10 +69,10 @@ async fn credential_fill() -> Unit raise Error {
   }
   // Try GIT_ASKPASS or SSH_ASKPASS
   if username.length() == 0 || password.length() == 0 {
-    let askpass = match @sys.get_env_var("GIT_ASKPASS") {
+    let askpass = match @env.get_env_var("GIT_ASKPASS") {
       Some(v) if v.length() > 0 => Some(v)
       _ =>
-        match @sys.get_env_var("SSH_ASKPASS") {
+        match @env.get_env_var("SSH_ASKPASS") {
           Some(v) if v.length() > 0 => Some(v)
           _ => None
         }
diff --git a/modules/bit/cmd/bit/diff.mbt b/modules/bit/cmd/bit/diff.mbt
index 83d7e38c..967ff990 100644
--- a/modules/bit/cmd/bit/diff.mbt
+++ b/modules/bit/cmd/bit/diff.mbt
@@ -3,7 +3,7 @@
 ///|
 fn find_git_dir(fs : OsFs) -> String {
   // Check GIT_DIR environment variable first
-  if @sys.get_env_var("GIT_DIR") is Some(dir) {
+  if @env.get_env_var("GIT_DIR") is Some(dir) {
     if fs.is_dir(dir) || fs.is_file(dir) {
       return dir
     }
@@ -47,7 +47,7 @@ fn find_git_dir(fs : OsFs) -> String {
 
 ///|
 fn get_config_override(key : String) -> String? {
-  let overrides = @sys.get_env_var("GIT_CONFIG_OVERRIDES")
+  let overrides = @env.get_env_var("GIT_CONFIG_OVERRIDES")
   match overrides {
     Some(data) => {
       let mut found : String? = None
@@ -118,7 +118,7 @@ fn diff_get_external_command(
   fs : &@bitcore.RepoFileSystem,
   git_dir : String,
 ) -> String? {
-  match @sys.get_env_var("GIT_EXTERNAL_DIFF") {
+  match @env.get_env_var("GIT_EXTERNAL_DIFF") {
     Some(value) if value.trim().length() > 0 =>
       return Some(value.trim().to_owned())
     _ => ()
@@ -269,10 +269,10 @@ fn diff_current_relative_prefix(root : String) -> String {
 
 ///|
 fn diff_effective_cwd(root : String) -> String {
-  match @sys.get_env_var("GIT_SHIM_CWD") {
+  match @env.get_env_var("GIT_SHIM_CWD") {
     Some(dir) => dir
     None =>
-      match @sys.get_env_var("GIT_SHIM_PWD") {
+      match @env.get_env_var("GIT_SHIM_PWD") {
         Some(dir) => dir
         None =>
           match @env.current_dir() {
@@ -2824,7 +2824,7 @@ fn diff_index_to_octal(value : Int) -> String {
     v = v / 8
   }
   let rev = digits.rev()
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   if value < 0 {
     sb.write_char('-')
   }
diff --git a/modules/bit/cmd/bit/diff_wbtest.mbt b/modules/bit/cmd/bit/diff_wbtest.mbt
index 45b6e934..5b804c99 100644
--- a/modules/bit/cmd/bit/diff_wbtest.mbt
+++ b/modules/bit/cmd/bit/diff_wbtest.mbt
@@ -171,8 +171,8 @@ async test "diff: resolve relative prefix from cwd and config" {
   let fs = @bitcore.TestFs::new()
   fs.mkdir_p("/repo/.git")
   fs.write_string("/repo/.git/config", "[diff]\n\trelative = true\n")
-  @sys.set_env_var("GIT_SHIM_CWD", "/repo/subdir")
-  @sys.set_env_var("GIT_SHIM_PWD", "/repo/subdir")
+  @env.set_env_var("GIT_SHIM_CWD", "/repo/subdir")
+  @env.set_env_var("GIT_SHIM_PWD", "/repo/subdir")
   let from_config = diff_resolve_relative_prefix(
     fs,
     "/repo/.git",
@@ -197,8 +197,8 @@ async test "diff: resolve relative prefix from cwd and config" {
     true,
   )
   @test.assert_eq(disabled, None)
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_SHIM_PWD")
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_SHIM_PWD")
 }
 
 ///|
@@ -520,8 +520,8 @@ async test "diff: real fs diff_worktree sees gitlink head change" {
     "config", "user.email", "test@example.com",
   ])
 
-  let prev_allow_protocol = @sys.get_env_var("GIT_ALLOW_PROTOCOL")
-  @sys.set_env_var("GIT_ALLOW_PROTOCOL", "file")
+  let prev_allow_protocol = @env.get_env_var("GIT_ALLOW_PROTOCOL")
+  @env.set_env_var("GIT_ALLOW_PROTOCOL", "file")
   let (code_add, _, _) = @process.collect_output(
     "git",
     ["-C", super_dir, "submodule", "add", "./../init", "init"],
diff --git a/modules/bit/cmd/bit/fast_export.mbt b/modules/bit/cmd/bit/fast_export.mbt
index 25e50d4f..ee1573d0 100644
--- a/modules/bit/cmd/bit/fast_export.mbt
+++ b/modules/bit/cmd/bit/fast_export.mbt
@@ -168,7 +168,7 @@ async fn handle_fast_export(args : Array[String]) -> Unit raise Error {
   }
   let topo_order = topo_order.rev()
   // Output stream
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   let blob_marks : Map[String, Int] = Map([]) // blob oid hex -> mark
   for oid_hex, mark_val in mark_map {
     blob_marks[oid_hex] = mark_val
@@ -437,7 +437,7 @@ async fn handle_fast_export(args : Array[String]) -> Unit raise Error {
   }
   // Write export marks file if requested
   if export_marks_file is Some(path) {
-    let marks_buf = StringBuilder::new()
+    let marks_buf = StringBuilder()
     for oid_hex, mark_val in mark_map {
       marks_buf.write_string(":\{mark_val} \{oid_hex}\n")
     }
diff --git a/modules/bit/cmd/bit/fast_import.mbt b/modules/bit/cmd/bit/fast_import.mbt
index 79775ffb..1ab4f192 100644
--- a/modules/bit/cmd/bit/fast_import.mbt
+++ b/modules/bit/cmd/bit/fast_import.mbt
@@ -169,7 +169,7 @@ async fn handle_fast_import(args : Array[String]) -> Unit raise Error {
   // Export marks if specified
   if export_marks_file is Some(path) {
     let abs_path = if path.has_prefix("/") { path } else { root + "/" + path }
-    let buf = StringBuilder::new()
+    let buf = StringBuilder()
     // Sort marks by number for deterministic output
     let mark_keys : Array[Int] = []
     for k, _ in marks {
@@ -811,7 +811,7 @@ async fn fast_import_parse_tag(
   let message_bytes = parser.read_data()
   let message = decode_bytes(message_bytes)
   // Build tag object content
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_string("object ")
   buf.write_string(target_id.to_hex())
   buf.write_string("\n")
diff --git a/modules/bit/cmd/bit/fetch.mbt b/modules/bit/cmd/bit/fetch.mbt
index 89980a1b..dca2887e 100644
--- a/modules/bit/cmd/bit/fetch.mbt
+++ b/modules/bit/cmd/bit/fetch.mbt
@@ -1,7 +1,7 @@
 ///|
 fn collect_global_config_overrides_for_delegate() -> Array[String] {
   let overrides : Array[String] = []
-  match @sys.get_env_var("GIT_CONFIG_OVERRIDES") {
+  match @env.get_env_var("GIT_CONFIG_OVERRIDES") {
     Some(encoded) =>
       for line_view in encoded.split("\n") {
         let line = line_view.to_owned()
@@ -19,10 +19,10 @@ fn collect_global_config_overrides_for_delegate() -> Array[String] {
 ///|
 fn collect_global_path_overrides_for_delegate() -> Array[String] {
   let overrides : Array[String] = []
-  let delegate_cwd = match @sys.get_env_var("GIT_SHIM_CWD") {
+  let delegate_cwd = match @env.get_env_var("GIT_SHIM_CWD") {
     Some(dir) if dir.length() > 0 => Some(dir)
     _ =>
-      match @sys.get_env_var("GIT_SHIM_PWD") {
+      match @env.get_env_var("GIT_SHIM_PWD") {
         Some(dir) if dir.length() > 0 => Some(dir)
         _ => None
       }
@@ -34,12 +34,12 @@ fn collect_global_path_overrides_for_delegate() -> Array[String] {
     }
     None => ()
   }
-  let explicit_git_dir = match @sys.get_env_var("GIT_SHIM_EXPLICIT_GIT_DIR") {
+  let explicit_git_dir = match @env.get_env_var("GIT_SHIM_EXPLICIT_GIT_DIR") {
     Some(value) => value == "1"
     None => false
   }
   if explicit_git_dir {
-    match @sys.get_env_var("GIT_DIR") {
+    match @env.get_env_var("GIT_DIR") {
       Some(dir) if dir.length() > 0 => overrides.push("--git-dir=" + dir)
       _ => ()
     }
@@ -371,7 +371,7 @@ async fn handle_fetch(args : Array[String]) -> Unit raise Error {
   } else if !explicit_filter_flag && inherited_filter.is_partial() {
     filter = inherited_filter
   }
-  let local_root = match @sys.get_env_var("GIT_SHIM_CWD") {
+  let local_root = match @env.get_env_var("GIT_SHIM_CWD") {
     Some(dir) => dir
     None => root
   }
@@ -441,12 +441,12 @@ fn fetch_normalize_optional_value(value : String?) -> String? {
 
 ///|
 fn fetch_relay_preferred_sender() -> String? {
-  fetch_normalize_optional_value(@sys.get_env_var("BIT_RELAY_FETCH_SENDER"))
+  fetch_normalize_optional_value(@env.get_env_var("BIT_RELAY_FETCH_SENDER"))
 }
 
 ///|
 fn fetch_relay_preferred_repo() -> String? {
-  fetch_normalize_optional_value(@sys.get_env_var("BIT_RELAY_FETCH_REPO"))
+  fetch_normalize_optional_value(@env.get_env_var("BIT_RELAY_FETCH_REPO"))
 }
 
 ///|
diff --git a/modules/bit/cmd/bit/fetch_wbtest.mbt b/modules/bit/cmd/bit/fetch_wbtest.mbt
index 207a6280..7e1842d7 100644
--- a/modules/bit/cmd/bit/fetch_wbtest.mbt
+++ b/modules/bit/cmd/bit/fetch_wbtest.mbt
@@ -1,21 +1,21 @@
 ///|
 fn restore_env_var_for_fetch_wbtest(name : String, prev : String?) -> Unit {
   match prev {
-    Some(value) => @sys.set_env_var(name, value)
-    None => @sys.unset_env_var(name)
+    Some(value) => @env.set_env_var(name, value)
+    None => @env.unset_env_var(name)
   }
 }
 
 ///|
 test "fetch-delegate: collects global path overrides in deterministic order" {
-  let prev_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_explicit_git_dir = @sys.get_env_var("GIT_SHIM_EXPLICIT_GIT_DIR")
-  @sys.set_env_var("GIT_SHIM_CWD", "/tmp/bit-delegate-cwd")
-  @sys.set_env_var("GIT_SHIM_PWD", "/tmp/bit-delegate-pwd")
-  @sys.set_env_var("GIT_DIR", "/tmp/bit-delegate-gitdir")
-  @sys.set_env_var("GIT_SHIM_EXPLICIT_GIT_DIR", "1")
+  let prev_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_explicit_git_dir = @env.get_env_var("GIT_SHIM_EXPLICIT_GIT_DIR")
+  @env.set_env_var("GIT_SHIM_CWD", "/tmp/bit-delegate-cwd")
+  @env.set_env_var("GIT_SHIM_PWD", "/tmp/bit-delegate-pwd")
+  @env.set_env_var("GIT_DIR", "/tmp/bit-delegate-gitdir")
+  @env.set_env_var("GIT_SHIM_EXPLICIT_GIT_DIR", "1")
   let args = collect_global_path_overrides_for_delegate()
   @test.assert_eq(args.length(), 3)
   @test.assert_eq(args[0], "-C")
@@ -31,14 +31,14 @@ test "fetch-delegate: collects global path overrides in deterministic order" {
 
 ///|
 test "fetch-delegate: falls back to GIT_SHIM_PWD when CWD is missing" {
-  let prev_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_explicit_git_dir = @sys.get_env_var("GIT_SHIM_EXPLICIT_GIT_DIR")
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.set_env_var("GIT_SHIM_PWD", "/tmp/bit-delegate-pwd")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_SHIM_EXPLICIT_GIT_DIR")
+  let prev_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_explicit_git_dir = @env.get_env_var("GIT_SHIM_EXPLICIT_GIT_DIR")
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.set_env_var("GIT_SHIM_PWD", "/tmp/bit-delegate-pwd")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_SHIM_EXPLICIT_GIT_DIR")
   let args = collect_global_path_overrides_for_delegate()
   @test.assert_eq(args.length(), 2)
   @test.assert_eq(args[0], "-C")
@@ -53,14 +53,14 @@ test "fetch-delegate: falls back to GIT_SHIM_PWD when CWD is missing" {
 
 ///|
 test "fetch-delegate: skips unset global path overrides" {
-  let prev_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_explicit_git_dir = @sys.get_env_var("GIT_SHIM_EXPLICIT_GIT_DIR")
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_SHIM_PWD")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_SHIM_EXPLICIT_GIT_DIR")
+  let prev_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_explicit_git_dir = @env.get_env_var("GIT_SHIM_EXPLICIT_GIT_DIR")
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_SHIM_PWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_SHIM_EXPLICIT_GIT_DIR")
   let args = collect_global_path_overrides_for_delegate()
   @test.assert_eq(args.length(), 0)
   restore_env_var_for_fetch_wbtest("GIT_SHIM_CWD", prev_cwd)
@@ -73,14 +73,14 @@ test "fetch-delegate: skips unset global path overrides" {
 
 ///|
 test "fetch-delegate: does not append --git-dir without explicit marker" {
-  let prev_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_explicit_git_dir = @sys.get_env_var("GIT_SHIM_EXPLICIT_GIT_DIR")
-  @sys.set_env_var("GIT_SHIM_CWD", "/tmp/bit-delegate-cwd")
-  @sys.unset_env_var("GIT_SHIM_PWD")
-  @sys.set_env_var("GIT_DIR", "/tmp/bit-delegate-gitdir")
-  @sys.unset_env_var("GIT_SHIM_EXPLICIT_GIT_DIR")
+  let prev_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_explicit_git_dir = @env.get_env_var("GIT_SHIM_EXPLICIT_GIT_DIR")
+  @env.set_env_var("GIT_SHIM_CWD", "/tmp/bit-delegate-cwd")
+  @env.unset_env_var("GIT_SHIM_PWD")
+  @env.set_env_var("GIT_DIR", "/tmp/bit-delegate-gitdir")
+  @env.unset_env_var("GIT_SHIM_EXPLICIT_GIT_DIR")
   let args = collect_global_path_overrides_for_delegate()
   @test.assert_eq(args.length(), 2)
   @test.assert_eq(args[0], "-C")
@@ -95,8 +95,8 @@ test "fetch-delegate: does not append --git-dir without explicit marker" {
 
 ///|
 test "fetch-delegate: parses multiline -c overrides and ignores empty lines" {
-  let prev_overrides = @sys.get_env_var("GIT_CONFIG_OVERRIDES")
-  @sys.set_env_var(
+  let prev_overrides = @env.get_env_var("GIT_CONFIG_OVERRIDES")
+  @env.set_env_var(
     "GIT_CONFIG_OVERRIDES", "push.default=upstream\n\ncore.eol=lf\n",
   )
   let args = collect_global_config_overrides_for_delegate()
@@ -125,20 +125,20 @@ test "fetch relay: remote detection handles explicit relay schemes" {
 
 ///|
 test "fetch relay: preferred sender env is trimmed and optional" {
-  let prev_sender = @sys.get_env_var("BIT_RELAY_FETCH_SENDER")
-  @sys.set_env_var("BIT_RELAY_FETCH_SENDER", " node-a ")
+  let prev_sender = @env.get_env_var("BIT_RELAY_FETCH_SENDER")
+  @env.set_env_var("BIT_RELAY_FETCH_SENDER", " node-a ")
   @test.assert_eq(fetch_relay_preferred_sender(), Some("node-a"))
-  @sys.set_env_var("BIT_RELAY_FETCH_SENDER", "   ")
+  @env.set_env_var("BIT_RELAY_FETCH_SENDER", "   ")
   @test.assert_eq(fetch_relay_preferred_sender(), None)
   restore_env_var_for_fetch_wbtest("BIT_RELAY_FETCH_SENDER", prev_sender)
 }
 
 ///|
 test "fetch relay: preferred repo env is trimmed and optional" {
-  let prev_repo = @sys.get_env_var("BIT_RELAY_FETCH_REPO")
-  @sys.set_env_var("BIT_RELAY_FETCH_REPO", " repo-b ")
+  let prev_repo = @env.get_env_var("BIT_RELAY_FETCH_REPO")
+  @env.set_env_var("BIT_RELAY_FETCH_REPO", " repo-b ")
   @test.assert_eq(fetch_relay_preferred_repo(), Some("repo-b"))
-  @sys.set_env_var("BIT_RELAY_FETCH_REPO", "   ")
+  @env.set_env_var("BIT_RELAY_FETCH_REPO", "   ")
   @test.assert_eq(fetch_relay_preferred_repo(), None)
   restore_env_var_for_fetch_wbtest("BIT_RELAY_FETCH_REPO", prev_repo)
 }
@@ -187,12 +187,12 @@ async test "fetch: depth and unshallow update shallow metadata natively" {
   cleanup_tree(fs, root)
   fs.mkdir_p(src)
   fs.mkdir_p(dst)
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_SHIM_PWD")
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_SHIM_PWD")
   commit_wbtest_run_git(src, ["init", "--initial-branch=main", "-q"])
   commit_wbtest_run_git(src, ["config", "user.name", "Test User"])
   commit_wbtest_run_git(src, ["config", "user.email", "test@example.com"])
diff --git a/modules/bit/cmd/bit/fmt_merge_msg.mbt b/modules/bit/cmd/bit/fmt_merge_msg.mbt
index ab393588..a0bdd44b 100644
--- a/modules/bit/cmd/bit/fmt_merge_msg.mbt
+++ b/modules/bit/cmd/bit/fmt_merge_msg.mbt
@@ -71,7 +71,7 @@ fn fmt_merge_msg_format(
       None => ""
     }
   }
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   // Prepend custom message if given
   match custom_message {
     Some(msg) => {
diff --git a/modules/bit/cmd/bit/for_each_ref.mbt b/modules/bit/cmd/bit/for_each_ref.mbt
index 3c3c79c4..a5277fe6 100644
--- a/modules/bit/cmd/bit/for_each_ref.mbt
+++ b/modules/bit/cmd/bit/for_each_ref.mbt
@@ -617,9 +617,7 @@ async fn for_each_ref_collect_refs_safe(
       }
     }
   }
-  let result : Array[(String, @bitcore.ObjectId)] = Array::new(
-    capacity=out.length(),
-  )
+  let result : Array[(String, @bitcore.ObjectId)] = Array(capacity=out.length())
   for name, id in out {
     result.push((name, id))
   }
@@ -2384,7 +2382,7 @@ fn for_each_ref_quote(value : String, style : String) -> String {
   }
   match style {
     "shell" => {
-      let buf = StringBuilder::new()
+      let buf = StringBuilder()
       buf.write_char('\'')
       for c in value {
         if c == '\'' {
@@ -2397,7 +2395,7 @@ fn for_each_ref_quote(value : String, style : String) -> String {
       buf.to_string()
     }
     "perl" => {
-      let buf = StringBuilder::new()
+      let buf = StringBuilder()
       buf.write_char('\'')
       for c in value {
         if c == '\'' || c == '\\' {
@@ -2409,7 +2407,7 @@ fn for_each_ref_quote(value : String, style : String) -> String {
       buf.to_string()
     }
     "python" => {
-      let buf = StringBuilder::new()
+      let buf = StringBuilder()
       buf.write_char('\'')
       for c in value {
         if c == '\n' {
@@ -2425,7 +2423,7 @@ fn for_each_ref_quote(value : String, style : String) -> String {
       buf.to_string()
     }
     "tcl" => {
-      let buf = StringBuilder::new()
+      let buf = StringBuilder()
       buf.write_char('"')
       for c in value {
         if c == '"' ||
@@ -3312,7 +3310,7 @@ fn for_each_ref_strip_quotes(s : String) -> String {
 fn for_each_ref_find_real_git(git_dir : String) -> String {
   // Try to find the real git executable
   // Check SHIM_REAL_GIT env var first
-  match @sys.get_env_var("SHIM_REAL_GIT") {
+  match @env.get_env_var("SHIM_REAL_GIT") {
     Some(path) if path.length() > 0 => path
     _ => {
       // Try git-dir relative path
@@ -4286,7 +4284,7 @@ async fn for_each_ref_commit_atom(
     "subject" => subject
     "subject:sanitize" => {
       // Replace runs of non-filename-safe chars with a single '-', like git does
-      let sb = StringBuilder::new()
+      let sb = StringBuilder()
       let mut last_was_dash = false
       for c in subject {
         let code = c.to_int()
@@ -4633,7 +4631,7 @@ fn for_each_ref_decode_hex_escapes(s : String) -> String {
   // Decode %xNN hex escapes
   let chars = s.to_array()
   let len = chars.length()
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   let mut i = 0
   while i < len {
     if i + 3 < len && chars[i] == '%' && chars[i + 1] == 'x' {
@@ -4667,7 +4665,7 @@ fn for_each_ref_hex_digit(c : Char) -> Int {
 ///|
 fn for_each_ref_unfold_trailer_value(value : String) -> String {
   // Replace newline+whitespace with single space
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   let chars = value.to_array()
   let len = chars.length()
   let mut i = 0
@@ -4873,7 +4871,7 @@ fn format_timestamp_strftime(ts : Int64, tz : String, fmt : String) -> String {
     "January", "February", "March", "April", "May", "June", "July", "August", "September",
     "October", "November", "December",
   ]
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   let chars = fmt.to_array()
   let len = chars.length()
   let mut i = 0
diff --git a/modules/bit/cmd/bit/for_each_repo.mbt b/modules/bit/cmd/bit/for_each_repo.mbt
index dac83b79..e3632304 100644
--- a/modules/bit/cmd/bit/for_each_repo.mbt
+++ b/modules/bit/cmd/bit/for_each_repo.mbt
@@ -103,7 +103,7 @@ async fn handle_for_each_repo(args : Array[String]) -> Unit raise Error {
 ///|
 fn for_each_repo_expand_path(path : String) -> String {
   if path.has_prefix("~/") {
-    match @sys.get_env_var("HOME") {
+    match @env.get_env_var("HOME") {
       Some(home) =>
         home + String::unsafe_substring(path, start=1, end=path.length())
       None => path
@@ -121,9 +121,9 @@ fn for_each_repo_read_config_values(
 ) -> Array[String] {
   let values : Array[String] = []
   // 1. System config
-  let nosystem = @sys.get_env_var("GIT_CONFIG_NOSYSTEM")
+  let nosystem = @env.get_env_var("GIT_CONFIG_NOSYSTEM")
   if nosystem is None || nosystem == Some("false") {
-    let sys_path = @sys.get_env_var("GIT_CONFIG_SYSTEM").unwrap_or(
+    let sys_path = @env.get_env_var("GIT_CONFIG_SYSTEM").unwrap_or(
       "/etc/gitconfig",
     )
     if rfs.is_file(sys_path) {
@@ -136,11 +136,11 @@ fn for_each_repo_read_config_values(
     }
   }
   // 2. Global config (XDG + ~/.gitconfig)
-  let global_paths = match @sys.get_env_var("GIT_CONFIG_GLOBAL") {
+  let global_paths = match @env.get_env_var("GIT_CONFIG_GLOBAL") {
     Some(p) => [p]
     None => {
       let paths : Array[String] = []
-      match @sys.get_env_var("HOME") {
+      match @env.get_env_var("HOME") {
         Some(home) => {
           let xdg = home + "/.config/git/config"
           if rfs.is_file(xdg) {
diff --git a/modules/bit/cmd/bit/format_patch.mbt b/modules/bit/cmd/bit/format_patch.mbt
index efcba3e6..723ce39f 100644
--- a/modules/bit/cmd/bit/format_patch.mbt
+++ b/modules/bit/cmd/bit/format_patch.mbt
@@ -226,7 +226,7 @@ fn format_patch_signature_suffix(signature : String?) -> String {
 
 ///|
 fn format_patch_concat(parts : Array[String]) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for part in parts {
     sb.write_string(part)
   }
@@ -549,7 +549,7 @@ fn filter_format_patch_commits_by_grep(
 
 ///|
 fn generate_cover_letter(num_patches : Int, signature : String?) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string(
     "From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001\n",
   )
@@ -585,7 +585,7 @@ fn generate_patch(
   let subject = get_first_line(message)
   let body = get_rest_lines(message)
   // Build patch header
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("From ")
   sb.write_string(commit_id.to_hex())
   sb.write_string(" Mon Sep 17 00:00:00 2001\n")
@@ -650,7 +650,7 @@ fn format_patch_filename(
 
 ///|
 fn sanitize_filename(s : String) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   let mut last_was_dash = false
   for c in s {
     if (c >= 'a' && c <= 'z') ||
diff --git a/modules/bit/cmd/bit/gitconfig.mbt b/modules/bit/cmd/bit/gitconfig.mbt
index 5ff2e76b..f786ef93 100644
--- a/modules/bit/cmd/bit/gitconfig.mbt
+++ b/modules/bit/cmd/bit/gitconfig.mbt
@@ -104,7 +104,7 @@ pub fn resolve_alias(
 ///|
 pub fn split_alias_command(value : String) -> Array[String] {
   let args : Array[String] = []
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   let mut in_single = false
   let mut in_double = false
   let mut escape = false
@@ -152,13 +152,13 @@ pub fn split_alias_command(value : String) -> Array[String] {
 
 ///|
 fn find_global_gitconfig_path() -> String? {
-  match @sys.get_env_var("GIT_CONFIG_GLOBAL") {
+  match @env.get_env_var("GIT_CONFIG_GLOBAL") {
     Some(path) => Some(path)
     None =>
-      match @sys.get_env_var("HOME") {
+      match @env.get_env_var("HOME") {
         Some(home) => Some(home + "/.gitconfig")
         None =>
-          match @sys.get_env_var("USERPROFILE") {
+          match @env.get_env_var("USERPROFILE") {
             Some(home) => Some(home + "/.gitconfig")
             None => None
           }
@@ -260,7 +260,7 @@ fn unquote_value(value : String) -> String {
 
 ///|
 fn unescape_config_string(value : String) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   let mut escape = false
   for c in value {
     if escape {
diff --git a/modules/bit/cmd/bit/grep.mbt b/modules/bit/cmd/bit/grep.mbt
index cded0ff6..71e30b3d 100644
--- a/modules/bit/cmd/bit/grep.mbt
+++ b/modules/bit/cmd/bit/grep.mbt
@@ -786,10 +786,10 @@ fn grep_resolve_pattern_file_path(root : String, file : String) -> String {
 
 ///|
 fn grep_get_invocation_cwd(root : String) -> String {
-  match @sys.get_env_var("GIT_SHIM_CWD") {
+  match @env.get_env_var("GIT_SHIM_CWD") {
     Some(dir) => dir
     None =>
-      match @sys.get_env_var("GIT_SHIM_PWD") {
+      match @env.get_env_var("GIT_SHIM_PWD") {
         Some(dir) => dir
         None => @env.current_dir().unwrap_or(root)
       }
@@ -1126,7 +1126,7 @@ fn grep_colorize_line(
   }
   let ordered = spans.copy()
   ordered.sort_by((a, b) => Int::compare(a.start_column, b.start_column))
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   let mut cursor = 0
   for span in ordered {
     let start = span.start_column - 1
@@ -1174,7 +1174,7 @@ fn grep_build_prefix(
   color_spec : GrepColorSpec,
 ) -> String {
   let sep = sign.to_string()
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   if !show_heading {
     out.write_string(grep_color_wrap(file_path, color_spec.filename))
     out.write_string(grep_color_wrap(sep, color_spec.separator))
@@ -2229,7 +2229,7 @@ fn grep_split_path_segments(path : String) -> Array[String] {
 
 ///|
 fn grep_join_path_segments(parts : Array[String]) -> String {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   for i in 0..<parts.length() {
     if i > 0 {
       out.write_char('/')
diff --git a/modules/bit/cmd/bit/handlers_core_wbtest.mbt b/modules/bit/cmd/bit/handlers_core_wbtest.mbt
index c9e2eacc..9fc850e6 100644
--- a/modules/bit/cmd/bit/handlers_core_wbtest.mbt
+++ b/modules/bit/cmd/bit/handlers_core_wbtest.mbt
@@ -26,14 +26,14 @@ async test "core: init --bit creates .bit repository metadata directory" {
   let fs = OsFs::new()
   let path = "/tmp/bit-test-init-bit-" + get_current_timestamp().to_string()
   cleanup_tree(fs, path)
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.set_env_var("GIT_SHIM_PWD", ".")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.set_env_var("GIT_SHIM_PWD", ".")
   handle_init(["-q", "--bit", path])
   assert_true(fs.is_dir(path + "/.bit"))
   assert_true(fs.is_file(path + "/.bit/HEAD"))
@@ -41,26 +41,26 @@ async test "core: init --bit creates .bit repository metadata directory" {
   assert_eq(resolved, path + "/.bit")
   let status = @bitlib.status(fs, path)
   assert_eq(status.untracked.length(), 0)
-  @sys.set_env_var("GIT_SHIM_CWD", path)
-  @sys.set_env_var("GIT_SHIM_PWD", path)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", path)
+  @env.set_env_var("GIT_SHIM_PWD", path)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
   handle_status(["--porcelain"])
   match prev_git_dir {
-    Some(value) => @sys.set_env_var("GIT_DIR", value)
-    None => @sys.unset_env_var("GIT_DIR")
+    Some(value) => @env.set_env_var("GIT_DIR", value)
+    None => @env.unset_env_var("GIT_DIR")
   }
   match prev_work_tree {
-    Some(value) => @sys.set_env_var("GIT_WORK_TREE", value)
-    None => @sys.unset_env_var("GIT_WORK_TREE")
+    Some(value) => @env.set_env_var("GIT_WORK_TREE", value)
+    None => @env.unset_env_var("GIT_WORK_TREE")
   }
   match prev_shim_cwd {
-    Some(value) => @sys.set_env_var("GIT_SHIM_CWD", value)
-    None => @sys.unset_env_var("GIT_SHIM_CWD")
+    Some(value) => @env.set_env_var("GIT_SHIM_CWD", value)
+    None => @env.unset_env_var("GIT_SHIM_CWD")
   }
   match prev_shim_pwd {
-    Some(value) => @sys.set_env_var("GIT_SHIM_PWD", value)
-    None => @sys.unset_env_var("GIT_SHIM_PWD")
+    Some(value) => @env.set_env_var("GIT_SHIM_PWD", value)
+    None => @env.unset_env_var("GIT_SHIM_PWD")
   }
   cleanup_tree(fs, path)
 }
@@ -71,14 +71,14 @@ async test "core: init --template= does not precreate hooks directory" {
   let path = "/tmp/bit-test-init-template-empty-" +
     get_current_timestamp().to_string()
   cleanup_tree(fs, path)
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.set_env_var("GIT_SHIM_PWD", ".")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.set_env_var("GIT_SHIM_PWD", ".")
   handle_init(["-q", "--template=", path])
   assert_true(fs.is_dir(path + "/.git"))
   assert_false(fs.is_dir(path + "/.git/hooks"))
@@ -88,20 +88,20 @@ async test "core: init --template= does not precreate hooks directory" {
   fs.mkdir_p(path + "/.git/hooks")
   assert_true(fs.is_dir(path + "/.git/hooks"))
   match prev_git_dir {
-    Some(value) => @sys.set_env_var("GIT_DIR", value)
-    None => @sys.unset_env_var("GIT_DIR")
+    Some(value) => @env.set_env_var("GIT_DIR", value)
+    None => @env.unset_env_var("GIT_DIR")
   }
   match prev_work_tree {
-    Some(value) => @sys.set_env_var("GIT_WORK_TREE", value)
-    None => @sys.unset_env_var("GIT_WORK_TREE")
+    Some(value) => @env.set_env_var("GIT_WORK_TREE", value)
+    None => @env.unset_env_var("GIT_WORK_TREE")
   }
   match prev_shim_cwd {
-    Some(value) => @sys.set_env_var("GIT_SHIM_CWD", value)
-    None => @sys.unset_env_var("GIT_SHIM_CWD")
+    Some(value) => @env.set_env_var("GIT_SHIM_CWD", value)
+    None => @env.unset_env_var("GIT_SHIM_CWD")
   }
   match prev_shim_pwd {
-    Some(value) => @sys.set_env_var("GIT_SHIM_PWD", value)
-    None => @sys.unset_env_var("GIT_SHIM_PWD")
+    Some(value) => @env.set_env_var("GIT_SHIM_PWD", value)
+    None => @env.unset_env_var("GIT_SHIM_PWD")
   }
   cleanup_tree(fs, path)
 }
@@ -112,60 +112,60 @@ async test "core: commit --allow-empty creates initial commit" {
   let path = "/tmp/bit-test-commit-allow-empty-" +
     get_current_timestamp().to_string()
   cleanup_tree(fs, path)
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_author_name = @sys.get_env_var("GIT_AUTHOR_NAME")
-  let prev_author_email = @sys.get_env_var("GIT_AUTHOR_EMAIL")
-  let prev_committer_name = @sys.get_env_var("GIT_COMMITTER_NAME")
-  let prev_committer_email = @sys.get_env_var("GIT_COMMITTER_EMAIL")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.set_env_var("GIT_SHIM_PWD", ".")
-  @sys.set_env_var("GIT_AUTHOR_NAME", "Test User")
-  @sys.set_env_var("GIT_AUTHOR_EMAIL", "test@example.com")
-  @sys.set_env_var("GIT_COMMITTER_NAME", "Test User")
-  @sys.set_env_var("GIT_COMMITTER_EMAIL", "test@example.com")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_author_name = @env.get_env_var("GIT_AUTHOR_NAME")
+  let prev_author_email = @env.get_env_var("GIT_AUTHOR_EMAIL")
+  let prev_committer_name = @env.get_env_var("GIT_COMMITTER_NAME")
+  let prev_committer_email = @env.get_env_var("GIT_COMMITTER_EMAIL")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.set_env_var("GIT_SHIM_PWD", ".")
+  @env.set_env_var("GIT_AUTHOR_NAME", "Test User")
+  @env.set_env_var("GIT_AUTHOR_EMAIL", "test@example.com")
+  @env.set_env_var("GIT_COMMITTER_NAME", "Test User")
+  @env.set_env_var("GIT_COMMITTER_EMAIL", "test@example.com")
   handle_init(["-q", "-b", "main", path])
-  @sys.set_env_var("GIT_SHIM_CWD", path)
-  @sys.set_env_var("GIT_SHIM_PWD", path)
+  @env.set_env_var("GIT_SHIM_CWD", path)
+  @env.set_env_var("GIT_SHIM_PWD", path)
   handle_commit(["-q", "--allow-empty", "-m", "empty commit"])
   assert_true(fs.is_file(path + "/.git/refs/heads/main"))
   let head_ref = fs.read_file(path + "/.git/refs/heads/main")
   assert_true(head_ref.length() > 0)
   match prev_git_dir {
-    Some(value) => @sys.set_env_var("GIT_DIR", value)
-    None => @sys.unset_env_var("GIT_DIR")
+    Some(value) => @env.set_env_var("GIT_DIR", value)
+    None => @env.unset_env_var("GIT_DIR")
   }
   match prev_work_tree {
-    Some(value) => @sys.set_env_var("GIT_WORK_TREE", value)
-    None => @sys.unset_env_var("GIT_WORK_TREE")
+    Some(value) => @env.set_env_var("GIT_WORK_TREE", value)
+    None => @env.unset_env_var("GIT_WORK_TREE")
   }
   match prev_shim_cwd {
-    Some(value) => @sys.set_env_var("GIT_SHIM_CWD", value)
-    None => @sys.unset_env_var("GIT_SHIM_CWD")
+    Some(value) => @env.set_env_var("GIT_SHIM_CWD", value)
+    None => @env.unset_env_var("GIT_SHIM_CWD")
   }
   match prev_shim_pwd {
-    Some(value) => @sys.set_env_var("GIT_SHIM_PWD", value)
-    None => @sys.unset_env_var("GIT_SHIM_PWD")
+    Some(value) => @env.set_env_var("GIT_SHIM_PWD", value)
+    None => @env.unset_env_var("GIT_SHIM_PWD")
   }
   match prev_author_name {
-    Some(value) => @sys.set_env_var("GIT_AUTHOR_NAME", value)
-    None => @sys.unset_env_var("GIT_AUTHOR_NAME")
+    Some(value) => @env.set_env_var("GIT_AUTHOR_NAME", value)
+    None => @env.unset_env_var("GIT_AUTHOR_NAME")
   }
   match prev_author_email {
-    Some(value) => @sys.set_env_var("GIT_AUTHOR_EMAIL", value)
-    None => @sys.unset_env_var("GIT_AUTHOR_EMAIL")
+    Some(value) => @env.set_env_var("GIT_AUTHOR_EMAIL", value)
+    None => @env.unset_env_var("GIT_AUTHOR_EMAIL")
   }
   match prev_committer_name {
-    Some(value) => @sys.set_env_var("GIT_COMMITTER_NAME", value)
-    None => @sys.unset_env_var("GIT_COMMITTER_NAME")
+    Some(value) => @env.set_env_var("GIT_COMMITTER_NAME", value)
+    None => @env.unset_env_var("GIT_COMMITTER_NAME")
   }
   match prev_committer_email {
-    Some(value) => @sys.set_env_var("GIT_COMMITTER_EMAIL", value)
-    None => @sys.unset_env_var("GIT_COMMITTER_EMAIL")
+    Some(value) => @env.set_env_var("GIT_COMMITTER_EMAIL", value)
+    None => @env.unset_env_var("GIT_COMMITTER_EMAIL")
   }
   cleanup_tree(fs, path)
 }
diff --git a/modules/bit/cmd/bit/handlers_interactive_wbtest.mbt b/modules/bit/cmd/bit/handlers_interactive_wbtest.mbt
index ab881fc7..0da06278 100644
--- a/modules/bit/cmd/bit/handlers_interactive_wbtest.mbt
+++ b/modules/bit/cmd/bit/handlers_interactive_wbtest.mbt
@@ -9,7 +9,7 @@ test "interactive: detect add patch mode" {
 
 ///|
 async test "interactive: add patch default runner rejects with error" {
-  let runner_called = Array::new(capacity=1)
+  let runner_called = Array(capacity=1)
   let runner = Some(async fn(_args : Array[String]) -> Int noraise {
     runner_called.push(true)
     0
@@ -69,17 +69,17 @@ async test "interactive: rebase todo editor callback is invoked" {
 
 ///|
 test "interactive: resolve commit editor precedence" {
-  @sys.set_env_var("EDITOR", "vi")
-  @sys.set_env_var("VISUAL", "nvim")
-  @sys.set_env_var("GIT_EDITOR", "hx")
+  @env.set_env_var("EDITOR", "vi")
+  @env.set_env_var("VISUAL", "nvim")
+  @env.set_env_var("GIT_EDITOR", "hx")
   let selected = resolve_commit_editor()
   match selected {
     Some(cmd) => @test.assert_eq(cmd, "hx")
     None => fail("expected editor")
   }
-  @sys.unset_env_var("GIT_EDITOR")
-  @sys.unset_env_var("VISUAL")
-  @sys.unset_env_var("EDITOR")
+  @env.unset_env_var("GIT_EDITOR")
+  @env.unset_env_var("VISUAL")
+  @env.unset_env_var("EDITOR")
 }
 
 ///|
diff --git a/modules/bit/cmd/bit/handlers_misc_wbtest.mbt b/modules/bit/cmd/bit/handlers_misc_wbtest.mbt
index 1207d335..7efca603 100644
--- a/modules/bit/cmd/bit/handlers_misc_wbtest.mbt
+++ b/modules/bit/cmd/bit/handlers_misc_wbtest.mbt
@@ -71,21 +71,21 @@ async test "config: --global writes to HOME/.gitconfig without delegation" {
   let home = root + "/home"
   fs.mkdir_p(home)
   let config_path = home + "/.gitconfig"
-  let prev_home = @sys.get_env_var("HOME")
-  let prev_global = @sys.get_env_var("GIT_CONFIG_GLOBAL")
-  @sys.set_env_var("HOME", home)
-  @sys.unset_env_var("GIT_CONFIG_GLOBAL")
+  let prev_home = @env.get_env_var("HOME")
+  let prev_global = @env.get_env_var("GIT_CONFIG_GLOBAL")
+  @env.set_env_var("HOME", home)
+  @env.unset_env_var("GIT_CONFIG_GLOBAL")
   handle_config(["--global", "user.name", "bit-test"])
   let content = decode_bytes(fs.read_file(config_path))
   assert_true(content.contains("[user]"))
   assert_true(content.contains("name = bit-test"))
   match prev_home {
-    Some(v) => @sys.set_env_var("HOME", v)
-    None => @sys.unset_env_var("HOME")
+    Some(v) => @env.set_env_var("HOME", v)
+    None => @env.unset_env_var("HOME")
   }
   match prev_global {
-    Some(v) => @sys.set_env_var("GIT_CONFIG_GLOBAL", v)
-    None => @sys.unset_env_var("GIT_CONFIG_GLOBAL")
+    Some(v) => @env.set_env_var("GIT_CONFIG_GLOBAL", v)
+    None => @env.unset_env_var("GIT_CONFIG_GLOBAL")
   }
   fs.remove_file(config_path) catch {
     _ => ()
diff --git a/modules/bit/cmd/bit/handlers_remote_pull_wbtest.mbt b/modules/bit/cmd/bit/handlers_remote_pull_wbtest.mbt
index d2d2a8ea..9bf1116e 100644
--- a/modules/bit/cmd/bit/handlers_remote_pull_wbtest.mbt
+++ b/modules/bit/cmd/bit/handlers_remote_pull_wbtest.mbt
@@ -249,7 +249,7 @@ async fn handlers_remote_pull_wbtest_collect_shim_git(
   handlers_remote_pull_wbtest_shim_lock.acquire()
   defer handlers_remote_pull_wbtest_shim_lock.release()
   // Derive repo root from the executable path to avoid CWD pollution
-  let repo_root = match @sys.get_env_var("CARGO_MANIFEST_DIR") {
+  let repo_root = match @env.get_env_var("CARGO_MANIFEST_DIR") {
     Some(d) => d
     None => {
       let exe = @env.args()[0]
@@ -327,14 +327,14 @@ async test "pull: local fetch with main:main writes target ref and FETCH_HEAD" {
   let dst_dir = root + "/dst"
 
   // Protect against env pollution from other tests
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_git_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.unset_env_var("GIT_SHIM_PWD")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_git_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.unset_env_var("GIT_SHIM_PWD")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_DIR", prev_git_dir)
   defer add_test_restore_env("GIT_WORK_TREE", prev_git_work_tree)
@@ -381,14 +381,14 @@ async test "pull: local fetch for main writes remote-tracking ref and FETCH_HEAD
   let dst_dir = root + "/dst"
 
   // Protect against env pollution from other tests
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_git_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.unset_env_var("GIT_SHIM_PWD")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_git_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.unset_env_var("GIT_SHIM_PWD")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_DIR", prev_git_dir)
   defer add_test_restore_env("GIT_WORK_TREE", prev_git_work_tree)
@@ -950,14 +950,14 @@ test "pull relay: remote detection handles explicit relay schemes" {
 
 ///|
 test "pull relay: preferred sender/repo env is trimmed and optional" {
-  let prev_sender = @sys.get_env_var("BIT_RELAY_PULL_SENDER")
-  let prev_repo = @sys.get_env_var("BIT_RELAY_PULL_REPO")
-  @sys.set_env_var("BIT_RELAY_PULL_SENDER", " node-a ")
-  @sys.set_env_var("BIT_RELAY_PULL_REPO", " repo-b ")
+  let prev_sender = @env.get_env_var("BIT_RELAY_PULL_SENDER")
+  let prev_repo = @env.get_env_var("BIT_RELAY_PULL_REPO")
+  @env.set_env_var("BIT_RELAY_PULL_SENDER", " node-a ")
+  @env.set_env_var("BIT_RELAY_PULL_REPO", " repo-b ")
   @test.assert_eq(pull_relay_preferred_sender(), Some("node-a"))
   @test.assert_eq(pull_relay_preferred_repo(), Some("repo-b"))
-  @sys.set_env_var("BIT_RELAY_PULL_SENDER", "   ")
-  @sys.set_env_var("BIT_RELAY_PULL_REPO", "   ")
+  @env.set_env_var("BIT_RELAY_PULL_SENDER", "   ")
+  @env.set_env_var("BIT_RELAY_PULL_REPO", "   ")
   @test.assert_eq(pull_relay_preferred_sender(), None)
   @test.assert_eq(pull_relay_preferred_repo(), None)
   restore_env_var_for_fetch_wbtest("BIT_RELAY_PULL_SENDER", prev_sender)
diff --git a/modules/bit/cmd/bit/handlers_remote_push_wbtest.mbt b/modules/bit/cmd/bit/handlers_remote_push_wbtest.mbt
index 5d20b517..f83d35fc 100644
--- a/modules/bit/cmd/bit/handlers_remote_push_wbtest.mbt
+++ b/modules/bit/cmd/bit/handlers_remote_push_wbtest.mbt
@@ -1,8 +1,8 @@
 ///|
 fn restore_env_var_for_push_wbtest(name : String, prev : String?) -> Unit {
   match prev {
-    Some(value) => @sys.set_env_var(name, value)
-    None => @sys.unset_env_var(name)
+    Some(value) => @env.set_env_var(name, value)
+    None => @env.unset_env_var(name)
   }
 }
 
@@ -380,14 +380,14 @@ test "push relay: remote detection handles explicit relay schemes" {
 
 ///|
 test "push relay: preferred sender/repo env is trimmed and optional" {
-  let prev_sender = @sys.get_env_var("BIT_RELAY_PUSH_SENDER")
-  let prev_repo = @sys.get_env_var("BIT_RELAY_PUSH_REPO")
-  @sys.set_env_var("BIT_RELAY_PUSH_SENDER", " node-a ")
-  @sys.set_env_var("BIT_RELAY_PUSH_REPO", " repo-b ")
+  let prev_sender = @env.get_env_var("BIT_RELAY_PUSH_SENDER")
+  let prev_repo = @env.get_env_var("BIT_RELAY_PUSH_REPO")
+  @env.set_env_var("BIT_RELAY_PUSH_SENDER", " node-a ")
+  @env.set_env_var("BIT_RELAY_PUSH_REPO", " repo-b ")
   @test.assert_eq(push_relay_preferred_sender(), Some("node-a"))
   @test.assert_eq(push_relay_preferred_repo(), Some("repo-b"))
-  @sys.set_env_var("BIT_RELAY_PUSH_SENDER", "   ")
-  @sys.set_env_var("BIT_RELAY_PUSH_REPO", "   ")
+  @env.set_env_var("BIT_RELAY_PUSH_SENDER", "   ")
+  @env.set_env_var("BIT_RELAY_PUSH_REPO", "   ")
   @test.assert_eq(push_relay_preferred_sender(), None)
   @test.assert_eq(push_relay_preferred_repo(), None)
   restore_env_var_for_push_wbtest("BIT_RELAY_PUSH_SENDER", prev_sender)
@@ -799,7 +799,7 @@ test "push-lease: remote tracking refname follows pushed remote" {
 fn serve_lfs_wbtest_sha256_hex(data : Bytes) -> String {
   let raw = @bithash.sha256_bytes(data)
   let digits = "0123456789abcdef"
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   for b in raw {
     let v = b.to_int()
     out.write_char(digits[v / 16].to_int().unsafe_to_char())
diff --git a/modules/bit/cmd/bit/handlers_scalar_wbtest.mbt b/modules/bit/cmd/bit/handlers_scalar_wbtest.mbt
index d59e8bbd..bcdc9b42 100644
--- a/modules/bit/cmd/bit/handlers_scalar_wbtest.mbt
+++ b/modules/bit/cmd/bit/handlers_scalar_wbtest.mbt
@@ -38,9 +38,9 @@ async test "scalar: register + unregister maintenance repo entries" {
   let root = "/tmp/bit-test-scalar-config-" +
     get_current_timestamp().to_string()
   fs.mkdir_p(root)
-  let prev_global = @sys.get_env_var("GIT_CONFIG_GLOBAL")
+  let prev_global = @env.get_env_var("GIT_CONFIG_GLOBAL")
   let config_path = root + "/global.gitconfig"
-  @sys.set_env_var("GIT_CONFIG_GLOBAL", config_path)
+  @env.set_env_var("GIT_CONFIG_GLOBAL", config_path)
   scalar_add_maintenance_repo(fs, "/tmp/repo-a")
   scalar_add_maintenance_repo(fs, "/tmp/repo-b")
   let listed = scalar_list_maintenance_repos(fs)
@@ -52,8 +52,8 @@ async test "scalar: register + unregister maintenance repo entries" {
   assert_eq(listed2.length(), 1)
   assert_eq(listed2[0], "/tmp/repo-b")
   match prev_global {
-    Some(path) => @sys.set_env_var("GIT_CONFIG_GLOBAL", path)
-    None => @sys.unset_env_var("GIT_CONFIG_GLOBAL")
+    Some(path) => @env.set_env_var("GIT_CONFIG_GLOBAL", path)
+    None => @env.unset_env_var("GIT_CONFIG_GLOBAL")
   }
   cleanup_scalar_test_dir(fs, root)
 }
diff --git a/modules/bit/cmd/bit/handlers_subdir_wbtest.mbt b/modules/bit/cmd/bit/handlers_subdir_wbtest.mbt
index 8c95dd90..a5bf025e 100644
--- a/modules/bit/cmd/bit/handlers_subdir_wbtest.mbt
+++ b/modules/bit/cmd/bit/handlers_subdir_wbtest.mbt
@@ -3,7 +3,7 @@
 
 ///|
 fn bytes_to_string(bytes : Bytes) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i = 0; i < bytes.length(); i = i + 1 {
     result.write_char(bytes[i].to_int().unsafe_to_char())
   }
diff --git a/modules/bit/cmd/bit/hash_object.mbt b/modules/bit/cmd/bit/hash_object.mbt
index 65553512..1af46992 100644
--- a/modules/bit/cmd/bit/hash_object.mbt
+++ b/modules/bit/cmd/bit/hash_object.mbt
@@ -218,7 +218,7 @@ fn hash_object_resolve_path_hint(root : String, hint : String) -> String {
 
 ///|
 fn get_cwd_for_hash_object() -> String {
-  match @sys.get_env_var("GIT_SHIM_PWD") {
+  match @env.get_env_var("GIT_SHIM_PWD") {
     Some(path) => path
     None =>
       match @env.current_dir() {
@@ -490,7 +490,7 @@ async fn hash_object_validate_tag(
     eprint_line("error: badType: empty type")
     @sys.exit(128)
   }
-  let type_buf = StringBuilder::new()
+  let type_buf = StringBuilder()
   for i in type_start..<(type_start + type_len) {
     type_buf.write_char(content[i].to_int().unsafe_to_char())
   }
@@ -608,7 +608,7 @@ async fn hash_object_validate_tree(
       eprint_line("error: badTree: empty filename in tree entry")
       @sys.exit(128)
     }
-    let name_buf = StringBuilder::new()
+    let name_buf = StringBuilder()
     for i in name_start..<pos {
       name_buf.write_char(content[i].to_int().unsafe_to_char())
     }
diff --git a/modules/bit/cmd/bit/helpers.mbt b/modules/bit/cmd/bit/helpers.mbt
index 460854dc..e82029e1 100644
--- a/modules/bit/cmd/bit/helpers.mbt
+++ b/modules/bit/cmd/bit/helpers.mbt
@@ -57,7 +57,7 @@ fn resolve_run_git_path(path : String, cwd : String?) -> String {
   match cwd {
     Some(base) => normalize_path(base + "/" + path)
     None =>
-      @sys.get_env_var("GIT_SHIM_PWD")
+      @env.get_env_var("GIT_SHIM_PWD")
       .map(base => normalize_path(base + "/" + path))
       .unwrap_or(path)
   }
@@ -118,31 +118,31 @@ fn parse_run_git_invocation(
 ///|
 fn restore_env_var(name : String, value : String?) -> Unit {
   match value {
-    Some(v) => @sys.set_env_var(name, v)
-    None => @sys.unset_env_var(name)
+    Some(v) => @env.set_env_var(name, v)
+    None => @env.unset_env_var(name)
   }
 }
 
 ///|
 fn enter_run_git_env(cwd : String?, git_dir : String?) -> RunGitEnvSnapshot {
   let snapshot = {
-    shim_cwd: @sys.get_env_var("GIT_SHIM_CWD"),
-    git_dir: @sys.get_env_var("GIT_DIR"),
-    bit_work_tree: @sys.get_env_var("GIT_WORK_TREE"),
+    shim_cwd: @env.get_env_var("GIT_SHIM_CWD"),
+    git_dir: @env.get_env_var("GIT_DIR"),
+    bit_work_tree: @env.get_env_var("GIT_WORK_TREE"),
   }
   let fs = OsFs::new()
   match git_dir {
-    Some(dir) => @sys.set_env_var("GIT_DIR", dir)
+    Some(dir) => @env.set_env_var("GIT_DIR", dir)
     None => ()
   }
   match cwd {
     Some(dir) => {
-      @sys.set_env_var("GIT_SHIM_CWD", dir)
-      if @sys.get_env_var("GIT_DIR") is None {
-        @sys.set_env_var("GIT_DIR", default_repo_marker_path(fs, dir))
+      @env.set_env_var("GIT_SHIM_CWD", dir)
+      if @env.get_env_var("GIT_DIR") is None {
+        @env.set_env_var("GIT_DIR", default_repo_marker_path(fs, dir))
       }
-      if @sys.get_env_var("GIT_WORK_TREE") is None {
-        @sys.set_env_var("GIT_WORK_TREE", dir)
+      if @env.get_env_var("GIT_WORK_TREE") is None {
+        @env.set_env_var("GIT_WORK_TREE", dir)
       }
     }
     None => ()
@@ -300,15 +300,15 @@ fn default_repo_marker_path(
 ///|
 fn resolve_git_dir(fs : &@bitcore.RepoFileSystem, root : String) -> String {
   let default_git_dir = default_repo_marker_path(fs, root)
-  match @sys.get_env_var("GIT_DIR") {
+  match @env.get_env_var("GIT_DIR") {
     Some(dir) => {
       let resolved = if dir.has_prefix("/") {
         dir
       } else {
-        match @sys.get_env_var("GIT_SHIM_CWD") {
+        match @env.get_env_var("GIT_SHIM_CWD") {
           Some(base) => normalize_path(base + "/" + dir)
           None =>
-            @sys.get_env_var("GIT_SHIM_PWD")
+            @env.get_env_var("GIT_SHIM_PWD")
             .map(base => normalize_path(base + "/" + dir))
             .unwrap_or(dir)
         }
@@ -604,9 +604,9 @@ fn repository_validate_extension(name : String, value : String) -> String? {
 
 ///|
 fn get_author_string() -> String {
-  match @sys.get_env_var("GIT_AUTHOR_NAME") {
+  match @env.get_env_var("GIT_AUTHOR_NAME") {
     Some(name) => {
-      let email = @sys.get_env_var("GIT_AUTHOR_EMAIL").unwrap_or("unknown")
+      let email = @env.get_env_var("GIT_AUTHOR_EMAIL").unwrap_or("unknown")
       name + " <" + email + ">"
     }
     None => get_identity_from_config()
@@ -643,7 +643,7 @@ fn get_identity_from_config() -> String {
     None
   }
   // Also check ~/.gitconfig (global config)
-  let home = @sys.get_env_var("HOME").unwrap_or("")
+  let home = @env.get_env_var("HOME").unwrap_or("")
   let global_content = if home.length() > 0 {
     @fs.read_file_to_string(home + "/.gitconfig") catch {
       _ => ""
@@ -683,11 +683,11 @@ fn get_identity_from_config() -> String {
     (Some(n), Some(e)) => n + " <" + e + ">"
     (Some(n), None) => n + " <" + n + "@localhost>"
     (None, Some(e)) => {
-      let user = @sys.get_env_var("USER").unwrap_or("Unknown")
+      let user = @env.get_env_var("USER").unwrap_or("Unknown")
       user + " <" + e + ">"
     }
     (None, None) =>
-      match @sys.get_env_var("USER") {
+      match @env.get_env_var("USER") {
         Some(u) => u + " <" + u + "@localhost>"
         None => "Unknown <unknown@localhost>"
       }
@@ -696,9 +696,9 @@ fn get_identity_from_config() -> String {
 
 ///|
 fn get_committer_string() -> String {
-  match @sys.get_env_var("GIT_COMMITTER_NAME") {
+  match @env.get_env_var("GIT_COMMITTER_NAME") {
     Some(name) => {
-      let email = @sys.get_env_var("GIT_COMMITTER_EMAIL").unwrap_or("unknown")
+      let email = @env.get_env_var("GIT_COMMITTER_EMAIL").unwrap_or("unknown")
       name + " <" + email + ">"
     }
     None => get_author_string()
@@ -707,7 +707,7 @@ fn get_committer_string() -> String {
 
 ///|
 fn get_hub_signing_key() -> String? {
-  match @sys.get_env_var("BIT_COLLAB_SIGN_KEY") {
+  match @env.get_env_var("BIT_COLLAB_SIGN_KEY") {
     Some(value) => if value.length() > 0 { Some(value) } else { None }
     None => None
   }
@@ -715,7 +715,7 @@ fn get_hub_signing_key() -> String? {
 
 ///|
 fn get_hub_require_signed() -> Bool {
-  match @sys.get_env_var("BIT_COLLAB_REQUIRE_SIGNED") {
+  match @env.get_env_var("BIT_COLLAB_REQUIRE_SIGNED") {
     Some(value) => {
       let normalized = value.to_lower()
       normalized == "1" || normalized == "true" || normalized == "yes"
@@ -726,7 +726,7 @@ fn get_hub_require_signed() -> Bool {
 
 ///|
 fn get_commit_timestamp() -> Int64 {
-  match @sys.get_env_var("GIT_COMMITTER_DATE") {
+  match @env.get_env_var("GIT_COMMITTER_DATE") {
     Some(s) =>
       match parse_git_env_timestamp(s) {
         Some(ts) => ts
@@ -738,7 +738,7 @@ fn get_commit_timestamp() -> Int64 {
 
 ///|
 fn get_author_timestamp() -> Int64 {
-  match @sys.get_env_var("GIT_AUTHOR_DATE") {
+  match @env.get_env_var("GIT_AUTHOR_DATE") {
     Some(s) =>
       match parse_git_env_timestamp(s) {
         Some(ts) => ts
@@ -912,7 +912,7 @@ fn days_from_epoch(year : Int64, month : Int64, day : Int64) -> Int64 {
 
 ///|
 fn get_commit_timezone() -> String {
-  match @sys.get_env_var("GIT_COMMITTER_DATE") {
+  match @env.get_env_var("GIT_COMMITTER_DATE") {
     Some(raw) =>
       match parse_git_env_timezone(raw) {
         Some(tz) => tz
@@ -924,7 +924,7 @@ fn get_commit_timezone() -> String {
 
 ///|
 fn get_author_timezone() -> String {
-  match @sys.get_env_var("GIT_AUTHOR_DATE") {
+  match @env.get_env_var("GIT_AUTHOR_DATE") {
     Some(raw) =>
       match parse_git_env_timezone(raw) {
         Some(tz) => tz
@@ -1048,7 +1048,7 @@ fn make_relative_to_cwd(path : String) -> String {
   if !path.has_prefix("/") {
     return path
   }
-  let cwd = match @sys.get_env_var("GIT_SHIM_PWD") {
+  let cwd = match @env.get_env_var("GIT_SHIM_PWD") {
     Some(d) => d
     None =>
       match @env.current_dir() {
@@ -1084,7 +1084,7 @@ fn quote_origin_path(path : String) -> String {
   if !needs_quote {
     return path
   }
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_char('"')
   for ch in path {
     if ch == '"' || ch == '\\' {
diff --git a/modules/bit/cmd/bit/helpers_shared.mbt b/modules/bit/cmd/bit/helpers_shared.mbt
index 2e46767e..34b26a9d 100644
--- a/modules/bit/cmd/bit/helpers_shared.mbt
+++ b/modules/bit/cmd/bit/helpers_shared.mbt
@@ -127,7 +127,7 @@ fn find_repo_root(start : String) -> String? {
     current = "."
   }
   let ceiling_dirs : Array[String] = []
-  match @sys.get_env_var("GIT_CEILING_DIRECTORIES") {
+  match @env.get_env_var("GIT_CEILING_DIRECTORIES") {
     Some(raw) =>
       for view in raw.split(":") {
         let dir = view.to_owned()
@@ -192,7 +192,7 @@ fn find_repo_root(start : String) -> String? {
 
 ///|
 fn get_work_root() -> String {
-  match @sys.get_env_var("GIT_SHIM_CWD") {
+  match @env.get_env_var("GIT_SHIM_CWD") {
     Some(dir) =>
       // -C dir sets CWD to a subdirectory; find the repo root from there
       if is_bare_repo_dir(dir) {
@@ -201,13 +201,13 @@ fn get_work_root() -> String {
         find_repo_root(dir).unwrap_or(dir)
       }
     None =>
-      match @sys.get_env_var("GIT_WORK_TREE") {
+      match @env.get_env_var("GIT_WORK_TREE") {
         Some(dir) => dir
         None =>
-          match @sys.get_env_var("GIT_DIR") {
+          match @env.get_env_var("GIT_DIR") {
             Some(dir) => normalize_repo_root(dir)
             None =>
-              match @sys.get_env_var("GIT_SHIM_PWD") {
+              match @env.get_env_var("GIT_SHIM_PWD") {
                 Some(pwd) =>
                   if is_bare_repo_dir(pwd) {
                     pwd
@@ -215,7 +215,7 @@ fn get_work_root() -> String {
                     find_repo_root(pwd).unwrap_or(".")
                   }
                 None => {
-                  if @sys.get_env_var("PWD") is Some(pwd) {
+                  if @env.get_env_var("PWD") is Some(pwd) {
                     if is_bare_repo_dir(pwd) {
                       return pwd
                     }
diff --git a/modules/bit/cmd/bit/helpers_wbtest.mbt b/modules/bit/cmd/bit/helpers_wbtest.mbt
index b0186fec..f8265e8b 100644
--- a/modules/bit/cmd/bit/helpers_wbtest.mbt
+++ b/modules/bit/cmd/bit/helpers_wbtest.mbt
@@ -5,13 +5,13 @@ test "helpers: resolve_git_dir falls back to bare repo when GIT_DIR points missi
     get_current_timestamp().to_string()
   fs.mkdir_p(root + "/objects")
   fs.write_string(root + "/HEAD", "ref: refs/heads/main\n")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  @sys.set_env_var("GIT_DIR", root + "/.git")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  @env.set_env_var("GIT_DIR", root + "/.git")
   let resolved = resolve_git_dir(fs, root)
   @test.assert_eq(resolved, root)
   match prev_git_dir {
-    Some(value) => @sys.set_env_var("GIT_DIR", value)
-    None => @sys.unset_env_var("GIT_DIR")
+    Some(value) => @env.set_env_var("GIT_DIR", value)
+    None => @env.unset_env_var("GIT_DIR")
   }
   fs.remove_file(root + "/HEAD") catch {
     _ => ()
@@ -68,13 +68,13 @@ test "helpers: resolve_git_dir prefers .git when .git is present" {
     get_current_timestamp().to_string()
   fs.mkdir_p(root + "/.bit")
   fs.mkdir_p(root + "/.git")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_DIR")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_DIR")
   let resolved = resolve_git_dir(fs, root)
   @test.assert_eq(resolved, root + "/.git")
   match prev_git_dir {
-    Some(value) => @sys.set_env_var("GIT_DIR", value)
-    None => @sys.unset_env_var("GIT_DIR")
+    Some(value) => @env.set_env_var("GIT_DIR", value)
+    None => @env.unset_env_var("GIT_DIR")
   }
   fs.remove_dir(root + "/.bit") catch {
     _ => ()
@@ -93,13 +93,13 @@ test "helpers: resolve_git_dir falls back to .bit when .git is absent" {
   let root = "/tmp/bit-test-resolve-git-dir-bit-only-" +
     get_current_timestamp().to_string()
   fs.mkdir_p(root + "/.bit")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_DIR")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_DIR")
   let resolved = resolve_git_dir(fs, root)
   @test.assert_eq(resolved, root + "/.bit")
   match prev_git_dir {
-    Some(value) => @sys.set_env_var("GIT_DIR", value)
-    None => @sys.unset_env_var("GIT_DIR")
+    Some(value) => @env.set_env_var("GIT_DIR", value)
+    None => @env.unset_env_var("GIT_DIR")
   }
   fs.remove_dir(root + "/.bit") catch {
     _ => ()
@@ -116,13 +116,13 @@ test "helpers: resolve_git_dir keeps explicit GIT_DIR even if .bit exists" {
     get_current_timestamp().to_string()
   fs.mkdir_p(root + "/.bit")
   fs.mkdir_p(root + "/custom-meta")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  @sys.set_env_var("GIT_DIR", root + "/custom-meta")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  @env.set_env_var("GIT_DIR", root + "/custom-meta")
   let resolved = resolve_git_dir(fs, root)
   @test.assert_eq(resolved, root + "/custom-meta")
   match prev_git_dir {
-    Some(value) => @sys.set_env_var("GIT_DIR", value)
-    None => @sys.unset_env_var("GIT_DIR")
+    Some(value) => @env.set_env_var("GIT_DIR", value)
+    None => @env.unset_env_var("GIT_DIR")
   }
   fs.remove_dir(root + "/custom-meta") catch {
     _ => ()
@@ -191,147 +191,147 @@ test "helpers: parse_git_env_timezone extracts timezone token" {
 
 ///|
 test "helpers: get_commit_timestamp parses git-style committer date" {
-  let prev = @sys.get_env_var("GIT_COMMITTER_DATE")
-  @sys.set_env_var("GIT_COMMITTER_DATE", "1234567890 -0700")
+  let prev = @env.get_env_var("GIT_COMMITTER_DATE")
+  @env.set_env_var("GIT_COMMITTER_DATE", "1234567890 -0700")
   @test.assert_eq(get_commit_timestamp(), 1234567890L)
   match prev {
-    Some(value) => @sys.set_env_var("GIT_COMMITTER_DATE", value)
-    None => @sys.unset_env_var("GIT_COMMITTER_DATE")
+    Some(value) => @env.set_env_var("GIT_COMMITTER_DATE", value)
+    None => @env.unset_env_var("GIT_COMMITTER_DATE")
   }
 }
 
 ///|
 test "helpers: get_author_timestamp prefers author date" {
-  let prev_author = @sys.get_env_var("GIT_AUTHOR_DATE")
-  let prev_committer = @sys.get_env_var("GIT_COMMITTER_DATE")
-  @sys.set_env_var("GIT_AUTHOR_DATE", "1234567891 -0600")
-  @sys.set_env_var("GIT_COMMITTER_DATE", "1234567890 -0700")
+  let prev_author = @env.get_env_var("GIT_AUTHOR_DATE")
+  let prev_committer = @env.get_env_var("GIT_COMMITTER_DATE")
+  @env.set_env_var("GIT_AUTHOR_DATE", "1234567891 -0600")
+  @env.set_env_var("GIT_COMMITTER_DATE", "1234567890 -0700")
   @test.assert_eq(get_author_timestamp(), 1234567891L)
   match prev_author {
-    Some(value) => @sys.set_env_var("GIT_AUTHOR_DATE", value)
-    None => @sys.unset_env_var("GIT_AUTHOR_DATE")
+    Some(value) => @env.set_env_var("GIT_AUTHOR_DATE", value)
+    None => @env.unset_env_var("GIT_AUTHOR_DATE")
   }
   match prev_committer {
-    Some(value) => @sys.set_env_var("GIT_COMMITTER_DATE", value)
-    None => @sys.unset_env_var("GIT_COMMITTER_DATE")
+    Some(value) => @env.set_env_var("GIT_COMMITTER_DATE", value)
+    None => @env.unset_env_var("GIT_COMMITTER_DATE")
   }
 }
 
 ///|
 test "helpers: get_commit_timezone parses git-style committer date" {
-  let prev = @sys.get_env_var("GIT_COMMITTER_DATE")
-  @sys.set_env_var("GIT_COMMITTER_DATE", "1234567890 -0700")
+  let prev = @env.get_env_var("GIT_COMMITTER_DATE")
+  @env.set_env_var("GIT_COMMITTER_DATE", "1234567890 -0700")
   @test.assert_eq(get_commit_timezone(), "-0700")
   match prev {
-    Some(value) => @sys.set_env_var("GIT_COMMITTER_DATE", value)
-    None => @sys.unset_env_var("GIT_COMMITTER_DATE")
+    Some(value) => @env.set_env_var("GIT_COMMITTER_DATE", value)
+    None => @env.unset_env_var("GIT_COMMITTER_DATE")
   }
 }
 
 ///|
 test "helpers: get_author_timezone prefers author date" {
-  let prev_author = @sys.get_env_var("GIT_AUTHOR_DATE")
-  let prev_committer = @sys.get_env_var("GIT_COMMITTER_DATE")
-  @sys.set_env_var("GIT_AUTHOR_DATE", "1234567891 -0600")
-  @sys.set_env_var("GIT_COMMITTER_DATE", "1234567890 -0700")
+  let prev_author = @env.get_env_var("GIT_AUTHOR_DATE")
+  let prev_committer = @env.get_env_var("GIT_COMMITTER_DATE")
+  @env.set_env_var("GIT_AUTHOR_DATE", "1234567891 -0600")
+  @env.set_env_var("GIT_COMMITTER_DATE", "1234567890 -0700")
   @test.assert_eq(get_author_timezone(), "-0600")
   match prev_author {
-    Some(value) => @sys.set_env_var("GIT_AUTHOR_DATE", value)
-    None => @sys.unset_env_var("GIT_AUTHOR_DATE")
+    Some(value) => @env.set_env_var("GIT_AUTHOR_DATE", value)
+    None => @env.unset_env_var("GIT_AUTHOR_DATE")
   }
   match prev_committer {
-    Some(value) => @sys.set_env_var("GIT_COMMITTER_DATE", value)
-    None => @sys.unset_env_var("GIT_COMMITTER_DATE")
+    Some(value) => @env.set_env_var("GIT_COMMITTER_DATE", value)
+    None => @env.unset_env_var("GIT_COMMITTER_DATE")
   }
 }
 
 ///|
 test "helpers: get_committer_string prefers GIT_COMMITTER identity" {
-  let prev_committer_name = @sys.get_env_var("GIT_COMMITTER_NAME")
-  let prev_committer_email = @sys.get_env_var("GIT_COMMITTER_EMAIL")
-  let prev_author_name = @sys.get_env_var("GIT_AUTHOR_NAME")
-  let prev_author_email = @sys.get_env_var("GIT_AUTHOR_EMAIL")
-  @sys.set_env_var("GIT_COMMITTER_NAME", "Committer")
-  @sys.set_env_var("GIT_COMMITTER_EMAIL", "committer@example.com")
-  @sys.set_env_var("GIT_AUTHOR_NAME", "Author")
-  @sys.set_env_var("GIT_AUTHOR_EMAIL", "author@example.com")
+  let prev_committer_name = @env.get_env_var("GIT_COMMITTER_NAME")
+  let prev_committer_email = @env.get_env_var("GIT_COMMITTER_EMAIL")
+  let prev_author_name = @env.get_env_var("GIT_AUTHOR_NAME")
+  let prev_author_email = @env.get_env_var("GIT_AUTHOR_EMAIL")
+  @env.set_env_var("GIT_COMMITTER_NAME", "Committer")
+  @env.set_env_var("GIT_COMMITTER_EMAIL", "committer@example.com")
+  @env.set_env_var("GIT_AUTHOR_NAME", "Author")
+  @env.set_env_var("GIT_AUTHOR_EMAIL", "author@example.com")
   @test.assert_eq(get_committer_string(), "Committer <committer@example.com>")
   match prev_committer_name {
-    Some(value) => @sys.set_env_var("GIT_COMMITTER_NAME", value)
-    None => @sys.unset_env_var("GIT_COMMITTER_NAME")
+    Some(value) => @env.set_env_var("GIT_COMMITTER_NAME", value)
+    None => @env.unset_env_var("GIT_COMMITTER_NAME")
   }
   match prev_committer_email {
-    Some(value) => @sys.set_env_var("GIT_COMMITTER_EMAIL", value)
-    None => @sys.unset_env_var("GIT_COMMITTER_EMAIL")
+    Some(value) => @env.set_env_var("GIT_COMMITTER_EMAIL", value)
+    None => @env.unset_env_var("GIT_COMMITTER_EMAIL")
   }
   match prev_author_name {
-    Some(value) => @sys.set_env_var("GIT_AUTHOR_NAME", value)
-    None => @sys.unset_env_var("GIT_AUTHOR_NAME")
+    Some(value) => @env.set_env_var("GIT_AUTHOR_NAME", value)
+    None => @env.unset_env_var("GIT_AUTHOR_NAME")
   }
   match prev_author_email {
-    Some(value) => @sys.set_env_var("GIT_AUTHOR_EMAIL", value)
-    None => @sys.unset_env_var("GIT_AUTHOR_EMAIL")
+    Some(value) => @env.set_env_var("GIT_AUTHOR_EMAIL", value)
+    None => @env.unset_env_var("GIT_AUTHOR_EMAIL")
   }
 }
 
 ///|
 test "helpers: get_committer_string falls back to author identity" {
-  let prev_committer_name = @sys.get_env_var("GIT_COMMITTER_NAME")
-  let prev_committer_email = @sys.get_env_var("GIT_COMMITTER_EMAIL")
-  let prev_author_name = @sys.get_env_var("GIT_AUTHOR_NAME")
-  let prev_author_email = @sys.get_env_var("GIT_AUTHOR_EMAIL")
-  @sys.unset_env_var("GIT_COMMITTER_NAME")
-  @sys.unset_env_var("GIT_COMMITTER_EMAIL")
-  @sys.set_env_var("GIT_AUTHOR_NAME", "Author")
-  @sys.set_env_var("GIT_AUTHOR_EMAIL", "author@example.com")
+  let prev_committer_name = @env.get_env_var("GIT_COMMITTER_NAME")
+  let prev_committer_email = @env.get_env_var("GIT_COMMITTER_EMAIL")
+  let prev_author_name = @env.get_env_var("GIT_AUTHOR_NAME")
+  let prev_author_email = @env.get_env_var("GIT_AUTHOR_EMAIL")
+  @env.unset_env_var("GIT_COMMITTER_NAME")
+  @env.unset_env_var("GIT_COMMITTER_EMAIL")
+  @env.set_env_var("GIT_AUTHOR_NAME", "Author")
+  @env.set_env_var("GIT_AUTHOR_EMAIL", "author@example.com")
   @test.assert_eq(get_committer_string(), "Author <author@example.com>")
   match prev_committer_name {
-    Some(value) => @sys.set_env_var("GIT_COMMITTER_NAME", value)
-    None => @sys.unset_env_var("GIT_COMMITTER_NAME")
+    Some(value) => @env.set_env_var("GIT_COMMITTER_NAME", value)
+    None => @env.unset_env_var("GIT_COMMITTER_NAME")
   }
   match prev_committer_email {
-    Some(value) => @sys.set_env_var("GIT_COMMITTER_EMAIL", value)
-    None => @sys.unset_env_var("GIT_COMMITTER_EMAIL")
+    Some(value) => @env.set_env_var("GIT_COMMITTER_EMAIL", value)
+    None => @env.unset_env_var("GIT_COMMITTER_EMAIL")
   }
   match prev_author_name {
-    Some(value) => @sys.set_env_var("GIT_AUTHOR_NAME", value)
-    None => @sys.unset_env_var("GIT_AUTHOR_NAME")
+    Some(value) => @env.set_env_var("GIT_AUTHOR_NAME", value)
+    None => @env.unset_env_var("GIT_AUTHOR_NAME")
   }
   match prev_author_email {
-    Some(value) => @sys.set_env_var("GIT_AUTHOR_EMAIL", value)
-    None => @sys.unset_env_var("GIT_AUTHOR_EMAIL")
+    Some(value) => @env.set_env_var("GIT_AUTHOR_EMAIL", value)
+    None => @env.unset_env_var("GIT_AUTHOR_EMAIL")
   }
 }
 
 ///|
 test "main: resolve_global_path uses GIT_SHIM_PWD when available" {
-  let prev = @sys.get_env_var("GIT_SHIM_PWD")
-  @sys.set_env_var("GIT_SHIM_PWD", "/tmp/bit-main-wbtest")
+  let prev = @env.get_env_var("GIT_SHIM_PWD")
+  @env.set_env_var("GIT_SHIM_PWD", "/tmp/bit-main-wbtest")
   let resolved = resolve_global_path("dest", None)
   @test.assert_eq(resolved, "/tmp/bit-main-wbtest/dest")
   match prev {
-    Some(value) => @sys.set_env_var("GIT_SHIM_PWD", value)
-    None => @sys.unset_env_var("GIT_SHIM_PWD")
+    Some(value) => @env.set_env_var("GIT_SHIM_PWD", value)
+    None => @env.unset_env_var("GIT_SHIM_PWD")
   }
 }
 
 ///|
 test "main: resolve_global_path resolves relative path without GIT_SHIM_PWD" {
-  let prev = @sys.get_env_var("GIT_SHIM_PWD")
-  @sys.unset_env_var("GIT_SHIM_PWD")
+  let prev = @env.get_env_var("GIT_SHIM_PWD")
+  @env.unset_env_var("GIT_SHIM_PWD")
   let resolved = resolve_global_path("dest", None)
   assert_true(resolved.has_prefix("/"))
   assert_true(resolved.has_suffix("/dest"))
   match prev {
-    Some(value) => @sys.set_env_var("GIT_SHIM_PWD", value)
-    None => @sys.unset_env_var("GIT_SHIM_PWD")
+    Some(value) => @env.set_env_var("GIT_SHIM_PWD", value)
+    None => @env.unset_env_var("GIT_SHIM_PWD")
   }
 }
 
 ///|
 test "main: parse_global_options resolves -C relative path without GIT_SHIM_PWD" {
-  let prev = @sys.get_env_var("GIT_SHIM_PWD")
-  @sys.unset_env_var("GIT_SHIM_PWD")
+  let prev = @env.get_env_var("GIT_SHIM_PWD")
+  @env.unset_env_var("GIT_SHIM_PWD")
   let opts = parse_global_options(["bit", "-C", "dest", "status"])
   @test.assert_eq(opts.subcmd, Some("status"))
   match opts.cwd {
@@ -342,8 +342,8 @@ test "main: parse_global_options resolves -C relative path without GIT_SHIM_PWD"
     None => fail("expected cwd to be resolved")
   }
   match prev {
-    Some(value) => @sys.set_env_var("GIT_SHIM_PWD", value)
-    None => @sys.unset_env_var("GIT_SHIM_PWD")
+    Some(value) => @env.set_env_var("GIT_SHIM_PWD", value)
+    None => @env.unset_env_var("GIT_SHIM_PWD")
   }
 }
 
@@ -363,36 +363,36 @@ test "helpers: get_work_root finds repo root from PWD when shim pwd is absent" {
   cleanup_tree(fs, root)
   fs.mkdir_p(root + "/.git")
   fs.mkdir_p(subdir)
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_pwd = @sys.get_env_var("PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  @sys.unset_env_var("GIT_SHIM_PWD")
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.set_env_var("PWD", subdir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_pwd = @env.get_env_var("PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  @env.unset_env_var("GIT_SHIM_PWD")
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.set_env_var("PWD", subdir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
   @test.assert_eq(get_work_root(), root)
   match prev_shim_pwd {
-    Some(value) => @sys.set_env_var("GIT_SHIM_PWD", value)
-    None => @sys.unset_env_var("GIT_SHIM_PWD")
+    Some(value) => @env.set_env_var("GIT_SHIM_PWD", value)
+    None => @env.unset_env_var("GIT_SHIM_PWD")
   }
   match prev_shim_cwd {
-    Some(value) => @sys.set_env_var("GIT_SHIM_CWD", value)
-    None => @sys.unset_env_var("GIT_SHIM_CWD")
+    Some(value) => @env.set_env_var("GIT_SHIM_CWD", value)
+    None => @env.unset_env_var("GIT_SHIM_CWD")
   }
   match prev_pwd {
-    Some(value) => @sys.set_env_var("PWD", value)
-    None => @sys.unset_env_var("PWD")
+    Some(value) => @env.set_env_var("PWD", value)
+    None => @env.unset_env_var("PWD")
   }
   match prev_git_dir {
-    Some(value) => @sys.set_env_var("GIT_DIR", value)
-    None => @sys.unset_env_var("GIT_DIR")
+    Some(value) => @env.set_env_var("GIT_DIR", value)
+    None => @env.unset_env_var("GIT_DIR")
   }
   match prev_work_tree {
-    Some(value) => @sys.set_env_var("GIT_WORK_TREE", value)
-    None => @sys.unset_env_var("GIT_WORK_TREE")
+    Some(value) => @env.set_env_var("GIT_WORK_TREE", value)
+    None => @env.unset_env_var("GIT_WORK_TREE")
   }
   cleanup_tree(fs, root)
 }
@@ -483,19 +483,19 @@ async test "main: show_command_help supports command aliases" {
 
 ///|
 test "main: opt-in help text is disabled by default" {
-  let prev_full = @sys.get_env_var("BIT_HELP_FULL")
-  let prev_dir = @sys.get_env_var("BIT_HELP_TEXT_DIR")
-  @sys.unset_env_var("BIT_HELP_FULL")
-  @sys.unset_env_var("BIT_HELP_TEXT_DIR")
+  let prev_full = @env.get_env_var("BIT_HELP_FULL")
+  let prev_dir = @env.get_env_var("BIT_HELP_TEXT_DIR")
+  @env.unset_env_var("BIT_HELP_FULL")
+  @env.unset_env_var("BIT_HELP_TEXT_DIR")
   assert_false(help_text_opt_in_enabled())
   @test.assert_eq(load_opt_in_help_text("status"), None)
   match prev_full {
-    Some(value) => @sys.set_env_var("BIT_HELP_FULL", value)
-    None => @sys.unset_env_var("BIT_HELP_FULL")
+    Some(value) => @env.set_env_var("BIT_HELP_FULL", value)
+    None => @env.unset_env_var("BIT_HELP_FULL")
   }
   match prev_dir {
-    Some(value) => @sys.set_env_var("BIT_HELP_TEXT_DIR", value)
-    None => @sys.unset_env_var("BIT_HELP_TEXT_DIR")
+    Some(value) => @env.set_env_var("BIT_HELP_TEXT_DIR", value)
+    None => @env.unset_env_var("BIT_HELP_TEXT_DIR")
   }
 }
 
@@ -506,22 +506,22 @@ test "main: opt-in help text is loaded from external files" {
   cleanup_tree(fs, dir)
   fs.mkdir_p(dir)
   fs.write_string(dir + "/show-branch.txt", "Detailed show-branch help")
-  let prev_full = @sys.get_env_var("BIT_HELP_FULL")
-  let prev_dir = @sys.get_env_var("BIT_HELP_TEXT_DIR")
-  @sys.set_env_var("BIT_HELP_FULL", "1")
-  @sys.set_env_var("BIT_HELP_TEXT_DIR", dir)
+  let prev_full = @env.get_env_var("BIT_HELP_FULL")
+  let prev_dir = @env.get_env_var("BIT_HELP_TEXT_DIR")
+  @env.set_env_var("BIT_HELP_FULL", "1")
+  @env.set_env_var("BIT_HELP_TEXT_DIR", dir)
   assert_true(help_text_opt_in_enabled())
   @test.assert_eq(
     load_opt_in_help_text("show-branches"),
     Some("Detailed show-branch help"),
   )
   match prev_full {
-    Some(value) => @sys.set_env_var("BIT_HELP_FULL", value)
-    None => @sys.unset_env_var("BIT_HELP_FULL")
+    Some(value) => @env.set_env_var("BIT_HELP_FULL", value)
+    None => @env.unset_env_var("BIT_HELP_FULL")
   }
   match prev_dir {
-    Some(value) => @sys.set_env_var("BIT_HELP_TEXT_DIR", value)
-    None => @sys.unset_env_var("BIT_HELP_TEXT_DIR")
+    Some(value) => @env.set_env_var("BIT_HELP_TEXT_DIR", value)
+    None => @env.unset_env_var("BIT_HELP_TEXT_DIR")
   }
   cleanup_tree(fs, dir)
 }
diff --git a/modules/bit/cmd/bit/hq.mbt b/modules/bit/cmd/bit/hq.mbt
index 41f29b7f..98e879e2 100644
--- a/modules/bit/cmd/bit/hq.mbt
+++ b/modules/bit/cmd/bit/hq.mbt
@@ -333,7 +333,7 @@ async fn handle_hq_root(_args : Array[String]) -> Unit {
 ///|
 /// Get environment variable
 fn get_env_hq(key : String) -> String? {
-  @sys.get_env_var(key)
+  @env.get_env_var(key)
 }
 
 ///|
@@ -347,7 +347,7 @@ fn get_git_config_hq(_key : String) -> String? {
 ///|
 /// Get home directory
 fn get_home_dir_hq() -> String {
-  @sys.get_env_var("HOME").unwrap_or("/home/user")
+  @env.get_env_var("HOME").unwrap_or("/home/user")
 }
 
 ///|
diff --git a/modules/bit/cmd/bit/hub_active.mbt b/modules/bit/cmd/bit/hub_active.mbt
index 2be75f8a..290b6ef3 100644
--- a/modules/bit/cmd/bit/hub_active.mbt
+++ b/modules/bit/cmd/bit/hub_active.mbt
@@ -22,7 +22,7 @@ fn parse_active_issues(content : String) -> Array[String] {
 ///|
 /// Join entries with newlines.
 fn serialize_active_issues(entries : Array[String]) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for entry in entries {
     buf.write_string(entry)
     buf.write_char('\n')
@@ -124,7 +124,7 @@ async fn handle_hub_issue_active(_args : Array[String]) -> Unit raise Error {
     print_line("No active issues")
     return
   }
-  let home = @sys.get_env_var("HOME").unwrap_or("/")
+  let home = @env.get_env_var("HOME").unwrap_or("/")
   let aliases = load_aliases(git_dir)
   for entry in entries {
     let (repo_ref, issue_id) = parse_cross_repo_ref(entry)
diff --git a/modules/bit/cmd/bit/hub_github_sync.mbt b/modules/bit/cmd/bit/hub_github_sync.mbt
index 350419a4..6ac7107e 100644
--- a/modules/bit/cmd/bit/hub_github_sync.mbt
+++ b/modules/bit/cmd/bit/hub_github_sync.mbt
@@ -805,7 +805,7 @@ async fn handle_hub_issue_sync_status(args : Array[String]) -> Unit raise Error
 /// Check if GitHub sync write operations (push, bidirectional, install-hook) are enabled.
 /// Currently disabled by default. Set BIT_GITHUB_SYNC_WRITE=1 to enable.
 fn github_sync_write_enabled() -> Bool {
-  match @sys.get_env_var("BIT_GITHUB_SYNC_WRITE") {
+  match @env.get_env_var("BIT_GITHUB_SYNC_WRITE") {
     Some(v) => v == "1" || v == "true"
     None => false
   }
diff --git a/modules/bit/cmd/bit/hub_helpers.mbt b/modules/bit/cmd/bit/hub_helpers.mbt
index e981a64a..1cf4b15e 100644
--- a/modules/bit/cmd/bit/hub_helpers.mbt
+++ b/modules/bit/cmd/bit/hub_helpers.mbt
@@ -360,7 +360,7 @@ fn format_issue_summary(
   let id = issue.id()
   let title = issue.title()
   let state = issue.state().to_string()
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string(indent)
   sb.write_string("#\{id} [\{state}] \{title}")
   let detail_parts : Array[String] = []
@@ -414,7 +414,7 @@ fn format_issue_json(issue : @hub.Issue) -> String {
     Some(pid) => json_escape_string(pid)
     None => "null"
   }
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_string("{")
   buf.write_string("\"id\":" + json_escape_string(issue.id()))
   buf.write_string(",\"title\":" + json_escape_string(issue.title()))
@@ -442,7 +442,7 @@ fn format_issue_json(issue : @hub.Issue) -> String {
 /// Replaces raw epoch in serialize output with ISO-style dates.
 fn format_issue_detail(issue : @hub.Issue) -> String {
   let raw = issue.serialize()
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for line_view in raw.split("\n") {
     let line = line_view.to_owned()
     if line.has_prefix("created ") {
@@ -488,7 +488,7 @@ fn parse_int64_safe(s : String) -> Int64 {
 
 ///|
 fn json_escape_string(s : String) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_string("\"")
   for ch in s {
     match ch {
@@ -515,7 +515,7 @@ fn format_work_item_summary(item : @hub.WorkItem) -> String {
 
 ///|
 fn format_work_item_detail(item : @hub.WorkItem) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("id ")
   sb.write_string(item.id())
   sb.write_char('\n')
diff --git a/modules/bit/cmd/bit/hub_issue.mbt b/modules/bit/cmd/bit/hub_issue.mbt
index cdd39fe9..ca259a91 100644
--- a/modules/bit/cmd/bit/hub_issue.mbt
+++ b/modules/bit/cmd/bit/hub_issue.mbt
@@ -313,7 +313,7 @@ fn build_issue_children_map(
 
 ///|
 fn issue_tree_indent(depth : Int) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   let mut i = 0
   while i < depth {
     sb.write_string("  ")
@@ -756,7 +756,7 @@ async fn handle_hub_issue_get(args : Array[String]) -> Unit raise Error {
   let root = get_work_root()
   let (git_dir, id) = if repo_ref.length() > 0 {
     let local_git_dir = resolve_hub_git_dir(root)
-    let home = @sys.get_env_var("HOME").unwrap_or("/")
+    let home = @env.get_env_var("HOME").unwrap_or("/")
     let aliases = load_aliases(local_git_dir)
     let remote_path = resolve_repo_ref_to_path(repo_ref, home, aliases~)
     (resolve_hub_git_dir(remote_path), parsed_id)
@@ -952,7 +952,7 @@ async fn handle_hub_issue_create(args : Array[String]) -> Unit raise Error {
   let root = get_work_root()
   let git_dir = match repo_ref {
     Some(rref) => {
-      let home = @sys.get_env_var("HOME").unwrap_or("/")
+      let home = @env.get_env_var("HOME").unwrap_or("/")
       let local_git_dir = resolve_hub_git_dir(root)
       let aliases = load_aliases(local_git_dir)
       let remote_path = resolve_repo_ref_to_path(rref, home, aliases~)
@@ -1740,7 +1740,7 @@ async fn handle_hub_issue_init(_args : Array[String]) -> Unit raise Error {
 
 ///|
 fn issue_default_relay_url() -> String {
-  match @sys.get_env_var("BIT_RELAY_URL") {
+  match @env.get_env_var("BIT_RELAY_URL") {
     Some(url) => url
     None => "relay+https://bit-relay.mizchi.workers.dev"
   }
diff --git a/modules/bit/cmd/bit/hub_remote.mbt b/modules/bit/cmd/bit/hub_remote.mbt
index 5fab121c..27c1b51f 100644
--- a/modules/bit/cmd/bit/hub_remote.mbt
+++ b/modules/bit/cmd/bit/hub_remote.mbt
@@ -54,7 +54,7 @@ fn hub_remotes_path(git_dir : String) -> String {
 ///|
 /// Serialize alias entries to TSV format: "name\tpath\n" per line.
 fn serialize_alias_entries(entries : Array[(String, String)]) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for entry in entries {
     let (name, path) = entry
     buf.write_string(name)
@@ -174,7 +174,7 @@ async fn handle_hub_issue_remote_add(args : Array[String]) -> Unit raise Error {
   let git_dir = resolve_hub_git_dir(root)
   let aliases = load_aliases(git_dir)
   // Resolve target: if it looks like owner/repo, resolve to ghq path
-  let home = @sys.get_env_var("HOME").unwrap_or("/")
+  let home = @env.get_env_var("HOME").unwrap_or("/")
   let resolved_path = if target.has_prefix("/") {
     target
   } else {
diff --git a/modules/bit/cmd/bit/hub_stores.mbt b/modules/bit/cmd/bit/hub_stores.mbt
index ad4adda4..1ab44fc2 100644
--- a/modules/bit/cmd/bit/hub_stores.mbt
+++ b/modules/bit/cmd/bit/hub_stores.mbt
@@ -190,7 +190,7 @@ fn hub_stdin_is_tty() -> Bool {
 
 ///|
 fn hub_should_prompt() -> Bool {
-  match @sys.get_env_var("BIT_HUB_INIT_PROMPT") {
+  match @env.get_env_var("BIT_HUB_INIT_PROMPT") {
     Some(value) =>
       parse_hub_init_prompt_override(value).unwrap_or(hub_stdin_is_tty())
     None => hub_stdin_is_tty()
diff --git a/modules/bit/cmd/bit/hub_sync.mbt b/modules/bit/cmd/bit/hub_sync.mbt
index 3edee44a..8b69b880 100644
--- a/modules/bit/cmd/bit/hub_sync.mbt
+++ b/modules/bit/cmd/bit/hub_sync.mbt
@@ -181,7 +181,7 @@ fn parse_hub_sync_runtime_options(
         Some(url)
       } else {
         // Treat as namespace/room name → use default relay
-        let base = match @sys.get_env_var("BIT_RELAY_URL") {
+        let base = match @env.get_env_var("BIT_RELAY_URL") {
           Some(u) => u
           None => "relay+https://bit-relay.mizchi.workers.dev"
         }
diff --git a/modules/bit/cmd/bit/index_pack.mbt b/modules/bit/cmd/bit/index_pack.mbt
index 5713aacb..00c94ceb 100644
--- a/modules/bit/cmd/bit/index_pack.mbt
+++ b/modules/bit/cmd/bit/index_pack.mbt
@@ -922,7 +922,7 @@ async fn handle_index_pack(args : Array[String]) -> Unit raise Error {
           @stdio.stderr.write("fatal: not a git repository\n")
           @sys.exit(1)
         }
-        let trace2_event = @sys.get_env_var("GIT_TRACE2_EVENT")
+        let trace2_event = @env.get_env_var("GIT_TRACE2_EVENT")
         match trace2_event {
           Some(path) =>
             write_trace2_region_event(
diff --git a/modules/bit/cmd/bit/init.mbt b/modules/bit/cmd/bit/init.mbt
index f61bd410..d4c4b9bc 100644
--- a/modules/bit/cmd/bit/init.mbt
+++ b/modules/bit/cmd/bit/init.mbt
@@ -10,9 +10,9 @@ async fn show_init_command_help() -> Unit {
 
 ///|
 async fn handle_init(args : Array[String]) -> Unit raise Error {
-  let root = match @sys.get_env_var("GIT_SHIM_CWD") {
+  let root = match @env.get_env_var("GIT_SHIM_CWD") {
     Some(dir) => dir
-    None => @sys.get_env_var("GIT_SHIM_PWD").unwrap_or(".")
+    None => @env.get_env_var("GIT_SHIM_PWD").unwrap_or(".")
   }
   let fs = OsFs::new()
   // Parse options
@@ -111,9 +111,9 @@ async fn handle_init(args : Array[String]) -> Unit raise Error {
   // Resolve ref format from env if not explicitly set via --ref-format
   let mut ref_format_from_env = false
   if ref_format_env_deferred && !ref_format_explicit {
-    let env_ref_format = match @sys.get_env_var("GIT_DEFAULT_REF_FORMAT") {
+    let env_ref_format = match @env.get_env_var("GIT_DEFAULT_REF_FORMAT") {
       Some(value) => Some(value)
-      None => @sys.get_env_var("GIT_TEST_DEFAULT_REF_FORMAT")
+      None => @env.get_env_var("GIT_TEST_DEFAULT_REF_FORMAT")
     }
     match env_ref_format {
       Some(value) => {
@@ -141,8 +141,8 @@ async fn handle_init(args : Array[String]) -> Unit raise Error {
     return
   }
   // Check GIT_DIR and GIT_WORK_TREE environment variables
-  let bit_dir_env = @sys.get_env_var("GIT_DIR")
-  let work_tree_env = @sys.get_env_var("GIT_WORK_TREE")
+  let bit_dir_env = @env.get_env_var("GIT_DIR")
+  let work_tree_env = @env.get_env_var("GIT_WORK_TREE")
   // GIT_WORK_TREE without GIT_DIR is an error during init
   if work_tree_env is Some(_) && (bit_dir_env is None || bare) {
     eprint_line(
@@ -153,7 +153,7 @@ async fn handle_init(args : Array[String]) -> Unit raise Error {
   }
   // Check GIT_TEMPLATE_DIR environment variable, then config
   if template_dir is None {
-    template_dir = @sys.get_env_var("GIT_TEMPLATE_DIR")
+    template_dir = @env.get_env_var("GIT_TEMPLATE_DIR")
   }
   if template_dir is None {
     // Read init.templatedir from global config
@@ -173,7 +173,7 @@ async fn handle_init(args : Array[String]) -> Unit raise Error {
           Some(tpl_path) => {
             // Expand ~ to HOME
             let expanded = if tpl_path.has_prefix("~/") {
-              match @sys.get_env_var("HOME") {
+              match @env.get_env_var("HOME") {
                 Some(home) =>
                   home +
                   String::unsafe_substring(
@@ -260,7 +260,7 @@ async fn handle_init(args : Array[String]) -> Unit raise Error {
   let branch = match initial_branch {
     Some(b) => b
     None =>
-      match @sys.get_env_var("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME") {
+      match @env.get_env_var("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME") {
         Some(env_branch) if env_branch != "" => env_branch
         _ => {
           let config_branch = init_read_default_branch(fs)
@@ -488,7 +488,7 @@ async fn handle_init(args : Array[String]) -> Unit raise Error {
       None => ()
     }
     if object_format is None {
-      let env_default = @sys.get_env_var("GIT_DEFAULT_HASH").unwrap_or("sha1")
+      let env_default = @env.get_env_var("GIT_DEFAULT_HASH").unwrap_or("sha1")
       let normalized = env_default.to_lower()
       if normalized != "sha1" && normalized != "sha256" {
         eprint_line("fatal: unknown hash algorithm '\{normalized}'")
diff --git a/modules/bit/cmd/bit/init_wbtest.mbt b/modules/bit/cmd/bit/init_wbtest.mbt
index 60d59fca..5aaf00f8 100644
--- a/modules/bit/cmd/bit/init_wbtest.mbt
+++ b/modules/bit/cmd/bit/init_wbtest.mbt
@@ -33,14 +33,14 @@ async test "init: --object-format sha256 creates SHA-256 repo with valid config"
   let root = "/tmp/bit-test-init-sha256-" + get_current_timestamp().to_string()
   cleanup_tree(fs, root)
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.set_env_var("GIT_SHIM_PWD", ".")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.set_env_var("GIT_SHIM_PWD", ".")
 
   handle_init(["-q", "--object-format", "sha256", root])
 
@@ -124,19 +124,19 @@ async test "init: respects GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME" {
   cleanup_tree(fs, root)
   fs.mkdir_p(root)
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  let prev_default_branch = @sys.get_env_var(
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  let prev_default_branch = @env.get_env_var(
     "GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME",
   )
 
-  @sys.set_env_var("GIT_SHIM_CWD", root)
-  @sys.set_env_var("GIT_SHIM_PWD", root)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME", "main")
+  @env.set_env_var("GIT_SHIM_CWD", root)
+  @env.set_env_var("GIT_SHIM_PWD", root)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME", "main")
 
   handle_init(["-q", "repo"])
 
diff --git a/modules/bit/cmd/bit/interactive.mbt b/modules/bit/cmd/bit/interactive.mbt
index fa4057f3..16277609 100644
--- a/modules/bit/cmd/bit/interactive.mbt
+++ b/modules/bit/cmd/bit/interactive.mbt
@@ -70,16 +70,16 @@ async fn run_add_interactive(
 
 ///|
 fn resolve_sequence_editor() -> String? {
-  match @sys.get_env_var("GIT_SEQUENCE_EDITOR") {
+  match @env.get_env_var("GIT_SEQUENCE_EDITOR") {
     Some(cmd) if cmd.trim().to_owned().length() > 0 => Some(cmd)
     _ =>
-      match @sys.get_env_var("GIT_EDITOR") {
+      match @env.get_env_var("GIT_EDITOR") {
         Some(cmd) if cmd.trim().to_owned().length() > 0 => Some(cmd)
         _ =>
-          match @sys.get_env_var("VISUAL") {
+          match @env.get_env_var("VISUAL") {
             Some(cmd) if cmd.trim().to_owned().length() > 0 => Some(cmd)
             _ =>
-              match @sys.get_env_var("EDITOR") {
+              match @env.get_env_var("EDITOR") {
                 Some(cmd) if cmd.trim().to_owned().length() > 0 => Some(cmd)
                 _ => None
               }
@@ -90,13 +90,13 @@ fn resolve_sequence_editor() -> String? {
 
 ///|
 fn resolve_commit_editor() -> String? {
-  match @sys.get_env_var("GIT_EDITOR") {
+  match @env.get_env_var("GIT_EDITOR") {
     Some(cmd) if cmd.trim().to_owned().length() > 0 => Some(cmd)
     _ =>
-      match @sys.get_env_var("VISUAL") {
+      match @env.get_env_var("VISUAL") {
         Some(cmd) if cmd.trim().to_owned().length() > 0 => Some(cmd)
         _ =>
-          match @sys.get_env_var("EDITOR") {
+          match @env.get_env_var("EDITOR") {
             Some(cmd) if cmd.trim().to_owned().length() > 0 => Some(cmd)
             _ => None
           }
@@ -131,7 +131,7 @@ async fn default_rebase_todo_editor(todo_path : String) -> Bool raise Error {
 
 ///|
 fn commit_edit_buffer_template(initial_message : String?) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   match initial_message {
     Some(msg) => {
       sb.write_string(msg)
@@ -169,7 +169,7 @@ fn normalize_commit_edit_buffer(content : String) -> String? {
   while end >= start && kept[end].trim().to_owned().length() == 0 {
     end -= 1
   }
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for i = start; i <= end; i = i + 1 {
     if i > start {
       sb.write_string("\n")
diff --git a/modules/bit/cmd/bit/interpret_trailers.mbt b/modules/bit/cmd/bit/interpret_trailers.mbt
index e4852878..551c1f2c 100644
--- a/modules/bit/cmd/bit/interpret_trailers.mbt
+++ b/modules/bit/cmd/bit/interpret_trailers.mbt
@@ -85,7 +85,7 @@ async fn handle_interpret_trailers(args : Array[String]) -> Unit raise Error {
   if only_trailers {
     // Parse and print existing trailers only
     let existing = @trailers.parse_trailers(input)
-    let result = StringBuilder::new()
+    let result = StringBuilder()
     for trailer in existing {
       result.write_string(trailer.0)
       result.write_string(": ")
diff --git a/modules/bit/cmd/bit/last_modified.mbt b/modules/bit/cmd/bit/last_modified.mbt
index d4700c1e..02f72bf4 100644
--- a/modules/bit/cmd/bit/last_modified.mbt
+++ b/modules/bit/cmd/bit/last_modified.mbt
@@ -156,7 +156,7 @@ async fn handle_last_modified(args : Array[String]) -> Unit raise Error {
   )
 
   // -- emit -----------------------------------------------------------------
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for r in results {
     if r.boundary {
       buf.write_char('^')
diff --git a/modules/bit/cmd/bit/log.mbt b/modules/bit/cmd/bit/log.mbt
index 0f2bb8ce..7faf64bf 100644
--- a/modules/bit/cmd/bit/log.mbt
+++ b/modules/bit/cmd/bit/log.mbt
@@ -738,7 +738,7 @@ fn log_read_config_entries(
     }
   }
   let override_key = section_lower + "." + key_lower
-  match @sys.get_env_var("GIT_CONFIG_OVERRIDES") {
+  match @env.get_env_var("GIT_CONFIG_OVERRIDES") {
     Some(data) =>
       for line_view in data.split("\n") {
         let line = line_view.to_owned()
@@ -1731,7 +1731,7 @@ fn log_parse_wrap_spec(text : String) -> LogWrapSpec {
 
 ///|
 fn log_indent_string(count : Int) -> String {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   for _ in 0..<count {
     out.write_char(' ')
   }
@@ -3275,7 +3275,7 @@ fn log_string_without_last_char(text : String) -> String {
 
 ///|
 fn log_repeat_char(c : Char, count : Int) -> String {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   let mut i = 0
   while i < count {
     out.write_char(c)
@@ -3600,7 +3600,7 @@ fn format_commit_string(fmt : String, data : CommitFormatData) -> String {
 
 ///|
 fn log_sanitize_subject_for_format(s : String) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   let mut last_was_dash = false
   for c in s {
     if (c >= 'a' && c <= 'z') ||
@@ -3781,7 +3781,7 @@ fn log_format_commit_identity(
   abbrev_commit : Bool,
   show_parents : Bool,
 ) -> String {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   let format_hex = fn(hex : String) -> String {
     if abbrev_commit {
       log_abbrev_hex(hex, abbrev_len)
@@ -5730,7 +5730,7 @@ async fn handle_log(args : Array[String]) -> Unit raise Error {
           line_prefix,
         )
         if entry.parents.length() > 1 {
-          let mline = StringBuilder::new()
+          let mline = StringBuilder()
           mline.write_string("Merge:")
           for p in entry.parents {
             mline.write_string(" ")
@@ -6881,7 +6881,7 @@ async fn log_emit_commit_graph(
       // Merge commits carry a "Merge: <p1> <p2> ..." line (abbreviated parents,
       // always at abbrev_len even when the commit id is shown in full).
       if e.parents.length() > 1 {
-        let mline = StringBuilder::new()
+        let mline = StringBuilder()
         mline.write_string("Merge:")
         for p in e.parents {
           mline.write_string(" ")
diff --git a/modules/bit/cmd/bit/log_graph.mbt b/modules/bit/cmd/bit/log_graph.mbt
index 2f7ba3ea..ad473db9 100644
--- a/modules/bit/cmd/bit/log_graph.mbt
+++ b/modules/bit/cmd/bit/log_graph.mbt
@@ -318,7 +318,7 @@ fn graph_pad_horizontally(g : GitGraph, line : Array[Char]) -> Unit {
 
 ///|
 fn graph_chars_to_string(line : Array[Char]) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for c in line {
     sb.write_char(c)
   }
diff --git a/modules/bit/cmd/bit/ls_files.mbt b/modules/bit/cmd/bit/ls_files.mbt
index e2c951fc..f26fd8f5 100644
--- a/modules/bit/cmd/bit/ls_files.mbt
+++ b/modules/bit/cmd/bit/ls_files.mbt
@@ -635,12 +635,12 @@ fn ls_files_repo_root_abs(root : String) -> String {
   if root.has_prefix("/") {
     return normalize_path(root)
   }
-  let base_dir = match @sys.get_env_var("GIT_SHIM_PWD") {
+  let base_dir = match @env.get_env_var("GIT_SHIM_PWD") {
     Some(dir) => Some(dir)
     None =>
       match @env.current_dir() {
         Some(dir) => Some(dir)
-        None => @sys.get_env_var("PWD")
+        None => @env.get_env_var("PWD")
       }
   }
   match base_dir {
@@ -747,7 +747,7 @@ pub(all) struct SubmoduleInfo {
 
 ///|
 fn submodule_info_show_string(value : String) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_char('"')
   for c in value {
     if c == '"' {
@@ -1145,10 +1145,10 @@ fn normalize_ls_tree_filters(
 
 ///|
 fn compute_cwd_prefix(root : String) -> String {
-  let cwd = match @sys.get_env_var("GIT_SHIM_PWD") {
+  let cwd = match @env.get_env_var("GIT_SHIM_PWD") {
     Some(dir) => Some(dir)
     None =>
-      match @sys.get_env_var("PWD") {
+      match @env.get_env_var("PWD") {
         Some(dir) => Some(dir)
         None => @env.current_dir()
       }
diff --git a/modules/bit/cmd/bit/ls_files_wbtest.mbt b/modules/bit/cmd/bit/ls_files_wbtest.mbt
index f7cfa6e9..4830f0d5 100644
--- a/modules/bit/cmd/bit/ls_files_wbtest.mbt
+++ b/modules/bit/cmd/bit/ls_files_wbtest.mbt
@@ -160,18 +160,18 @@ test "ls-files: display path relativizes sibling and parent paths" {
 
 ///|
 test "ls-files: cwd prefix falls back to PWD when shim pwd is absent" {
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_pwd = @sys.get_env_var("PWD")
-  @sys.unset_env_var("GIT_SHIM_PWD")
-  @sys.set_env_var("PWD", "/repo/sub")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_pwd = @env.get_env_var("PWD")
+  @env.unset_env_var("GIT_SHIM_PWD")
+  @env.set_env_var("PWD", "/repo/sub")
   @test.assert_eq(compute_cwd_prefix("/repo"), "sub")
   match prev_shim_pwd {
-    Some(value) => @sys.set_env_var("GIT_SHIM_PWD", value)
-    None => @sys.unset_env_var("GIT_SHIM_PWD")
+    Some(value) => @env.set_env_var("GIT_SHIM_PWD", value)
+    None => @env.unset_env_var("GIT_SHIM_PWD")
   }
   match prev_pwd {
-    Some(value) => @sys.set_env_var("PWD", value)
-    None => @sys.unset_env_var("PWD")
+    Some(value) => @env.set_env_var("PWD", value)
+    None => @env.unset_env_var("PWD")
   }
 }
 
diff --git a/modules/bit/cmd/bit/ls_tree.mbt b/modules/bit/cmd/bit/ls_tree.mbt
index 8e64f0f5..91f31b61 100644
--- a/modules/bit/cmd/bit/ls_tree.mbt
+++ b/modules/bit/cmd/bit/ls_tree.mbt
@@ -415,7 +415,7 @@ fn ls_tree_format_output(
   id : @bitcore.ObjectId,
 ) -> String raise Error {
   let is_dir = type_str == "tree" || type_str == "commit"
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   let chars = fmt.to_array()
   let mut i = 0
   while i < chars.length() {
@@ -485,7 +485,7 @@ fn ls_tree_pad_size(size : String, width : Int) -> String {
   if size.length() >= width {
     return size
   }
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for _ in 0..<(width - size.length()) {
     buf.write_char(' ')
   }
@@ -542,7 +542,7 @@ fn c_quote_path(path : String) -> String {
   if !needs_quote {
     return path
   }
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_char('"')
   for c in path {
     if c == '"' {
diff --git a/modules/bit/cmd/bit/mailinfo.mbt b/modules/bit/cmd/bit/mailinfo.mbt
index 6c89b061..f4fece7e 100644
--- a/modules/bit/cmd/bit/mailinfo.mbt
+++ b/modules/bit/cmd/bit/mailinfo.mbt
@@ -47,8 +47,8 @@ async fn handle_mailinfo(args : Array[String]) -> Unit raise Error {
   let mut subject = ""
   let mut date = ""
   let mut in_headers = true
-  let body = StringBuilder::new()
-  let patch = StringBuilder::new()
+  let body = StringBuilder()
+  let patch = StringBuilder()
   let mut in_patch = false
   let mut past_scissors = false
   for line_view in input.split("\n") {
diff --git a/modules/bit/cmd/bit/mailsplit.mbt b/modules/bit/cmd/bit/mailsplit.mbt
index 9d616bb6..75ae7f2a 100644
--- a/modules/bit/cmd/bit/mailsplit.mbt
+++ b/modules/bit/cmd/bit/mailsplit.mbt
@@ -46,7 +46,7 @@ async fn handle_mailsplit(args : Array[String]) -> Unit raise Error {
   }
   // Read input: from files or stdin
   let input = if positional.length() > 0 {
-    let sb = StringBuilder::new()
+    let sb = StringBuilder()
     for path in positional {
       let data = @fs.read_file_to_bytes(path) catch {
         err => {
@@ -72,7 +72,7 @@ async fn handle_mailsplit(args : Array[String]) -> Unit raise Error {
   for line in lines {
     if line.has_prefix("From ") {
       // Start a new message
-      let msg = StringBuilder::new()
+      let msg = StringBuilder()
       if keep_from {
         msg.write_string(line)
         msg.write_char('\n')
@@ -129,7 +129,7 @@ fn mailsplit_format_number(n : Int, width : Int) -> String {
   if pad <= 0 {
     return s
   }
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for _i = 0; _i < pad; _i = _i + 1 {
     sb.write_char('0')
   }
diff --git a/modules/bit/cmd/bit/main.mbt b/modules/bit/cmd/bit/main.mbt
index 5a64eee1..493294c0 100644
--- a/modules/bit/cmd/bit/main.mbt
+++ b/modules/bit/cmd/bit/main.mbt
@@ -512,7 +512,7 @@ fn show_command_help_specs() -> Array[(String, String, String)] {
 
 ///|
 fn help_text_opt_in_enabled() -> Bool {
-  match @sys.get_env_var("BIT_HELP_FULL") {
+  match @env.get_env_var("BIT_HELP_FULL") {
     Some(value) => {
       let normalized = value.to_lower()
       normalized == "1" || normalized == "true" || normalized == "yes"
@@ -523,7 +523,7 @@ fn help_text_opt_in_enabled() -> Bool {
 
 ///|
 fn help_text_external_dir() -> String? {
-  match @sys.get_env_var("BIT_HELP_TEXT_DIR") {
+  match @env.get_env_var("BIT_HELP_TEXT_DIR") {
     Some(value) => if value.length() > 0 { Some(value) } else { None }
     None => None
   }
@@ -758,7 +758,7 @@ async fn run_main_for_args(args : Array[String]) -> Unit {
   // to a real git binary instead of silently falling back.
   for arg in args {
     if arg == "--no-git-fallback" {
-      @sys.set_env_var("BIT_NO_GIT_FALLBACK", "1")
+      @env.set_env_var("BIT_NO_GIT_FALLBACK", "1")
       break
     }
   }
@@ -776,13 +776,13 @@ async fn run_main_for_args(args : Array[String]) -> Unit {
   }
   match opts.git_dir {
     Some(dir) => {
-      @sys.set_env_var("GIT_DIR", dir)
-      @sys.set_env_var("GIT_SHIM_EXPLICIT_GIT_DIR", "1")
+      @env.set_env_var("GIT_DIR", dir)
+      @env.set_env_var("GIT_SHIM_EXPLICIT_GIT_DIR", "1")
     }
-    None => @sys.unset_env_var("GIT_SHIM_EXPLICIT_GIT_DIR")
+    None => @env.unset_env_var("GIT_SHIM_EXPLICIT_GIT_DIR")
   }
   match opts.work_tree {
-    Some(dir) => @sys.set_env_var("GIT_WORK_TREE", dir)
+    Some(dir) => @env.set_env_var("GIT_WORK_TREE", dir)
     None => ()
   }
   // Store config overrides in environment variable for handlers to access
@@ -792,7 +792,7 @@ async fn run_main_for_args(args : Array[String]) -> Unit {
       // Encode as key=value, separated by newlines
       encoded.push(pair.0 + "=" + pair.1)
     }
-    @sys.set_env_var("GIT_CONFIG_OVERRIDES", encoded.join("\n"))
+    @env.set_env_var("GIT_CONFIG_OVERRIDES", encoded.join("\n"))
   }
   let fs = OsFs::new()
   match missing_global_cwd_error(fs, opts.cwd, opts.cwd_raw) {
@@ -805,22 +805,22 @@ async fn run_main_for_args(args : Array[String]) -> Unit {
   // Set working directory if -C was used
   match opts.cwd {
     Some(dir) => {
-      let caller_pwd = match @sys.get_env_var("GIT_SHIM_PWD") {
+      let caller_pwd = match @env.get_env_var("GIT_SHIM_PWD") {
         Some(value) => Some(value)
         None =>
-          match @sys.get_env_var("GIT_SHIM_CWD") {
+          match @env.get_env_var("GIT_SHIM_CWD") {
             Some(value) => Some(value)
-            None => @sys.get_env_var("PWD")
+            None => @env.get_env_var("PWD")
           }
       }
       match caller_pwd {
-        Some(value) => @sys.set_env_var("GIT_SHIM_CALLER_PWD", value)
-        None => @sys.unset_env_var("GIT_SHIM_CALLER_PWD")
+        Some(value) => @env.set_env_var("GIT_SHIM_CALLER_PWD", value)
+        None => @env.unset_env_var("GIT_SHIM_CALLER_PWD")
       }
-      @sys.set_env_var("GIT_SHIM_CWD", dir)
-      @sys.set_env_var("GIT_SHIM_PWD", dir)
+      @env.set_env_var("GIT_SHIM_CWD", dir)
+      @env.set_env_var("GIT_SHIM_PWD", dir)
     }
-    None => @sys.unset_env_var("GIT_SHIM_CALLER_PWD")
+    None => @env.unset_env_var("GIT_SHIM_CALLER_PWD")
   }
   let aliases = load_global_aliases(fs)
   apply_alias_overrides(aliases, opts.config_overrides)
@@ -893,7 +893,7 @@ fn missing_global_cwd_error(
 /// variable by `run_main_for_args` so per-command handlers can consult it
 /// without threading global options through every dispatch path.
 fn git_fallback_disabled() -> Bool {
-  match @sys.get_env_var("BIT_NO_GIT_FALLBACK") {
+  match @env.get_env_var("BIT_NO_GIT_FALLBACK") {
     Some(value) => value == "1"
     None => false
   }
@@ -912,14 +912,14 @@ async fn exit_no_git_fallback(what : String) -> Unit {
 
 ///|
 fn resolve_real_git_for_dispatch() -> String {
-  match @sys.get_env_var("SHIM_REAL_GIT") {
+  match @env.get_env_var("SHIM_REAL_GIT") {
     Some(path) =>
       if path.length() > 0 {
         path
       } else {
-        @sys.get_env_var("GIT_SHIM_REAL_GIT").unwrap_or("/usr/bin/git")
+        @env.get_env_var("GIT_SHIM_REAL_GIT").unwrap_or("/usr/bin/git")
       }
-    None => @sys.get_env_var("GIT_SHIM_REAL_GIT").unwrap_or("/usr/bin/git")
+    None => @env.get_env_var("GIT_SHIM_REAL_GIT").unwrap_or("/usr/bin/git")
   }
 }
 
@@ -1049,14 +1049,14 @@ fn should_delegate_to_real_git(
     return false
   }
   let has_global_config = has_global_config_injection(args)
-  let has_env_parameters = match @sys.get_env_var("GIT_CONFIG_PARAMETERS") {
+  let has_env_parameters = match @env.get_env_var("GIT_CONFIG_PARAMETERS") {
     Some(v) => v.length() > 0
     None => false
   }
-  let has_env_pairs = @sys.get_env_var("GIT_CONFIG_COUNT") is Some(_)
-  let has_env_pairs_without_count = @sys.get_env_var("GIT_CONFIG_KEY_0")
+  let has_env_pairs = @env.get_env_var("GIT_CONFIG_COUNT") is Some(_)
+  let has_env_pairs_without_count = @env.get_env_var("GIT_CONFIG_KEY_0")
     is Some(_) ||
-    @sys.get_env_var("GIT_CONFIG_VALUE_0") is Some(_)
+    @env.get_env_var("GIT_CONFIG_VALUE_0") is Some(_)
   let has_config_env = has_global_config ||
     has_env_parameters ||
     has_env_pairs ||
@@ -1093,12 +1093,12 @@ fn resolve_global_path(raw : String, cwd : String?) -> String {
   let base_dir = match cwd {
     Some(dir) => Some(dir)
     None =>
-      match @sys.get_env_var("GIT_SHIM_PWD") {
+      match @env.get_env_var("GIT_SHIM_PWD") {
         Some(dir) => Some(dir)
         None =>
           match @env.current_dir() {
             Some(dir) => Some(dir)
-            None => @sys.get_env_var("PWD")
+            None => @env.get_env_var("PWD")
           }
       }
   }
diff --git a/modules/bit/cmd/bit/main_js.mbt b/modules/bit/cmd/bit/main_js.mbt
index 16471eea..31b6f830 100644
--- a/modules/bit/cmd/bit/main_js.mbt
+++ b/modules/bit/cmd/bit/main_js.mbt
@@ -2,7 +2,11 @@
 
 ///|
 async fn main_js_async() -> Unit {
-  let args = @sys.get_cli_args()
+  // `@env.args()` keeps `process.argv[0]`, the JavaScript runtime
+  // executable, which the deprecated `@sys.get_cli_args()` dropped. The
+  // dispatch below indexes from the script path, so drop it here instead
+  // of shifting every index.
+  let args = @env.args()[1:].to_owned()
   if args.length() < 2 {
     show_help_js()
     return
diff --git a/modules/bit/cmd/bit/main_wbtest.mbt b/modules/bit/cmd/bit/main_wbtest.mbt
index 03c14ae0..153b8ab9 100644
--- a/modules/bit/cmd/bit/main_wbtest.mbt
+++ b/modules/bit/cmd/bit/main_wbtest.mbt
@@ -65,14 +65,14 @@ test "main: grep supported -c overrides stay in shim" {
 
 ///|
 test "main: config overrides use last matching value" {
-  let prev = @sys.get_env_var("GIT_CONFIG_OVERRIDES")
-  @sys.set_env_var(
+  let prev = @env.get_env_var("GIT_CONFIG_OVERRIDES")
+  @env.set_env_var(
     "GIT_CONFIG_OVERRIDES", "grep.patternType=extended\ngrep.patternType=default\ngrep.patternType=fixed",
   )
   @test.assert_eq(get_config_override("grep.patternType"), Some("fixed"))
   match prev {
-    Some(value) => @sys.set_env_var("GIT_CONFIG_OVERRIDES", value)
-    None => @sys.unset_env_var("GIT_CONFIG_OVERRIDES")
+    Some(value) => @env.set_env_var("GIT_CONFIG_OVERRIDES", value)
+    None => @env.unset_env_var("GIT_CONFIG_OVERRIDES")
   }
 }
 
@@ -94,29 +94,29 @@ test "main: config and status stay native without config injection" {
 
 ///|
 test "main: bit-only commands stay native under config injection" {
-  let prev = @sys.get_env_var("GIT_CONFIG_PARAMETERS")
-  @sys.set_env_var("GIT_CONFIG_PARAMETERS", "'core.editor'='vim'")
+  let prev = @env.get_env_var("GIT_CONFIG_PARAMETERS")
+  @env.set_env_var("GIT_CONFIG_PARAMETERS", "'core.editor'='vim'")
   for cmd in ["issue", "pr", "hub", "relay", "workspace", "ws", "hq"] {
     let opts = parse_global_options(["bit", cmd, "list"])
     assert_false(should_delegate_to_real_git(["bit", cmd, "list"], opts))
   }
   match prev {
-    Some(value) => @sys.set_env_var("GIT_CONFIG_PARAMETERS", value)
-    None => @sys.unset_env_var("GIT_CONFIG_PARAMETERS")
+    Some(value) => @env.set_env_var("GIT_CONFIG_PARAMETERS", value)
+    None => @env.unset_env_var("GIT_CONFIG_PARAMETERS")
   }
 }
 
 ///|
 test "main: config and status still delegate under config injection" {
-  let prev = @sys.get_env_var("GIT_CONFIG_PARAMETERS")
-  @sys.set_env_var("GIT_CONFIG_PARAMETERS", "'core.editor'='vim'")
+  let prev = @env.get_env_var("GIT_CONFIG_PARAMETERS")
+  @env.set_env_var("GIT_CONFIG_PARAMETERS", "'core.editor'='vim'")
   for cmd in ["config", "status"] {
     let opts = parse_global_options(["bit", cmd])
     assert_true(should_delegate_to_real_git(["bit", cmd], opts))
   }
   match prev {
-    Some(value) => @sys.set_env_var("GIT_CONFIG_PARAMETERS", value)
-    None => @sys.unset_env_var("GIT_CONFIG_PARAMETERS")
+    Some(value) => @env.set_env_var("GIT_CONFIG_PARAMETERS", value)
+    None => @env.unset_env_var("GIT_CONFIG_PARAMETERS")
   }
 }
 
@@ -130,14 +130,14 @@ test "main: worktree stays in shim without config overrides" {
 
 ///|
 test "main: worktree stays in shim with config env overrides" {
-  let prev = @sys.get_env_var("GIT_CONFIG_PARAMETERS")
-  @sys.set_env_var("GIT_CONFIG_PARAMETERS", "'core.abbrev'='false'")
+  let prev = @env.get_env_var("GIT_CONFIG_PARAMETERS")
+  @env.set_env_var("GIT_CONFIG_PARAMETERS", "'core.abbrev'='false'")
   let opts = parse_global_options(["bit", "worktree", "add", "wt", "-"])
   assert_false(
     should_delegate_to_real_git(["bit", "worktree", "add", "wt", "-"], opts),
   )
   match prev {
-    Some(value) => @sys.set_env_var("GIT_CONFIG_PARAMETERS", value)
-    None => @sys.unset_env_var("GIT_CONFIG_PARAMETERS")
+    Some(value) => @env.set_env_var("GIT_CONFIG_PARAMETERS", value)
+    None => @env.unset_env_var("GIT_CONFIG_PARAMETERS")
   }
 }
diff --git a/modules/bit/cmd/bit/merge.mbt b/modules/bit/cmd/bit/merge.mbt
index 4298a901..9242cfb6 100644
--- a/modules/bit/cmd/bit/merge.mbt
+++ b/modules/bit/cmd/bit/merge.mbt
@@ -746,7 +746,7 @@ async fn handle_octopus_merge(
   let msg = match message {
     Some(m) => m
     None => {
-      let buf = StringBuilder::new()
+      let buf = StringBuilder()
       buf.write_string("Merge")
       for i = 0; i < labels.length(); i = i + 1 {
         if i == 0 {
@@ -830,7 +830,7 @@ fn truncate_and_append_reflog(
     }
   }
   // Keep only the first keep_count lines (entries before octopus merge started)
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for i = 0; i < keep_count && i < lines.length(); i = i + 1 {
     buf.write_string(lines[i])
     buf.write_string("\n")
diff --git a/modules/bit/cmd/bit/merge_index.mbt b/modules/bit/cmd/bit/merge_index.mbt
index afdc139d..62231a88 100644
--- a/modules/bit/cmd/bit/merge_index.mbt
+++ b/modules/bit/cmd/bit/merge_index.mbt
@@ -134,7 +134,7 @@ fn merge_index_format_mode(mode : Int) -> String {
     digits.push((n % 8).to_string())
     n = n / 8
   }
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for i = digits.length() - 1; i >= 0; i = i - 1 {
     sb.write_string(digits[i])
   }
diff --git a/modules/bit/cmd/bit/merge_wbtest.mbt b/modules/bit/cmd/bit/merge_wbtest.mbt
index 7d77d449..d74f6987 100644
--- a/modules/bit/cmd/bit/merge_wbtest.mbt
+++ b/modules/bit/cmd/bit/merge_wbtest.mbt
@@ -22,10 +22,10 @@ async test "merge: -S stores gpgsig header on merge commit" {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_DIR", prev_git_dir)
@@ -53,10 +53,10 @@ async test "merge: -S stores gpgsig header on merge commit" {
   grep_test_run_git(repo_dir, ["add", "main.txt"])
   grep_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
 
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
 
   handle_merge(["-q", "-S", "-m", "signed merge", "side"]) catch {
     err => fail("handle_merge failed: \{err}")
@@ -179,10 +179,10 @@ async test "merge: --no-commit with strategy ours keeps merge state" {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_DIR", prev_git_dir)
@@ -210,10 +210,10 @@ async test "merge: --no-commit with strategy ours keeps merge state" {
     grep_test_git_stdout(repo_dir, ["rev-parse", "HEAD"]),
   )
 
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
 
   handle_merge(["-q", "--no-commit", "-s", "ours", "side"]) catch {
     err => fail("handle_merge failed: \{err}")
@@ -313,7 +313,7 @@ async test "merge: --continue records MERGE_HEAD as second parent" {
   fs.write_string(repo_dir + "/file", "main\n")
   grep_test_run_git(repo_dir, ["commit", "-q", "-am", "main"])
 
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
   let (conflict_code, _) = grep_test_git_stderr(repo_dir, [
     "merge", "-m", "merge", "side",
   ])
diff --git a/modules/bit/cmd/bit/multi_pack_index.mbt b/modules/bit/cmd/bit/multi_pack_index.mbt
index 8b5cff49..52a572c6 100644
--- a/modules/bit/cmd/bit/multi_pack_index.mbt
+++ b/modules/bit/cmd/bit/multi_pack_index.mbt
@@ -1616,7 +1616,7 @@ fn midx_parse_config_bool(value : String) -> Bool? {
 
 ///|
 fn midx_emit_lookup_table_trace(fs : OsFs) -> Unit {
-  match @sys.get_env_var("GIT_TRACE2_EVENT") {
+  match @env.get_env_var("GIT_TRACE2_EVENT") {
     Some(path) => {
       let target = path.trim().to_owned()
       if target.length() == 0 || target == "1" || target == "2" {
@@ -2683,7 +2683,7 @@ fn midx_write_rev_file(
 
 ///|
 fn midx_should_write_rev() -> Bool {
-  match @sys.get_env_var("GIT_TEST_MIDX_WRITE_REV") {
+  match @env.get_env_var("GIT_TEST_MIDX_WRITE_REV") {
     Some(value) => {
       let v = value.trim().to_owned()
       v == "1" || v.to_lower() == "true"
diff --git a/modules/bit/cmd/bit/name_rev.mbt b/modules/bit/cmd/bit/name_rev.mbt
index c04c414f..99a6fd6f 100644
--- a/modules/bit/cmd/bit/name_rev.mbt
+++ b/modules/bit/cmd/bit/name_rev.mbt
@@ -270,7 +270,7 @@ fn name_rev_replace_oids(
   // Find 40-char hex strings and replace with names. With --name-only the oid
   // is replaced by just the name; otherwise it becomes `<oid> (<name>)`.
   let chars = line.to_array()
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   let mut i = 0
   while i < chars.length() {
     // Check if we have a 40-char hex starting here
diff --git a/modules/bit/cmd/bit/notes.mbt b/modules/bit/cmd/bit/notes.mbt
index 09129c6a..a8a2c874 100644
--- a/modules/bit/cmd/bit/notes.mbt
+++ b/modules/bit/cmd/bit/notes.mbt
@@ -572,7 +572,7 @@ async fn notes_add(
   let tree_id = notes_write_tree(wfs, common_git_dir, notes)
   // Create commit
   let author = get_author_string()
-  let timestamp = @sys.get_env_var("GIT_COMMITTER_DATE")
+  let timestamp = @env.get_env_var("GIT_COMMITTER_DATE")
     .map(parse_commit_date)
     .unwrap_or(get_current_timestamp())
   let parents = match parent_commit {
@@ -733,7 +733,7 @@ async fn notes_copy(
   notes.push((to_hex, src_id))
   let tree_id = notes_write_tree(wfs, common_git_dir, notes)
   let author = get_author_string()
-  let timestamp = @sys.get_env_var("GIT_COMMITTER_DATE")
+  let timestamp = @env.get_env_var("GIT_COMMITTER_DATE")
     .map(parse_commit_date)
     .unwrap_or(get_current_timestamp())
   let commit = @bitcore.Commit::new(
@@ -798,7 +798,7 @@ async fn notes_remove(
   let tree_id = notes_write_tree(wfs, common_git_dir, notes)
   // Create commit
   let author = get_author_string()
-  let timestamp = @sys.get_env_var("GIT_COMMITTER_DATE")
+  let timestamp = @env.get_env_var("GIT_COMMITTER_DATE")
     .map(parse_commit_date)
     .unwrap_or(get_current_timestamp())
   let commit = @bitcore.Commit::new(
@@ -855,7 +855,7 @@ async fn notes_prune(
   let tree_id = notes_write_tree(wfs, common_git_dir, notes)
   // Create commit
   let author = get_author_string()
-  let timestamp = @sys.get_env_var("GIT_COMMITTER_DATE")
+  let timestamp = @env.get_env_var("GIT_COMMITTER_DATE")
     .map(parse_commit_date)
     .unwrap_or(get_current_timestamp())
   let commit = @bitcore.Commit::new(
@@ -979,13 +979,13 @@ fn merge_notes_cat_sort_uniq(ours : String, theirs : String) -> String {
 ///|
 fn split_whitespace_tokens(line : String) -> Array[String] {
   let tokens : Array[String] = []
-  let mut current = StringBuilder::new()
+  let mut current = StringBuilder()
   let mut in_token = false
   for c in line {
     if c == ' ' || c == '\t' {
       if in_token {
         tokens.push(current.to_string())
-        current = StringBuilder::new()
+        current = StringBuilder()
         in_token = false
       }
     } else {
diff --git a/modules/bit/cmd/bit/osfs.mbt b/modules/bit/cmd/bit/osfs.mbt
index 6bd2f552..bd018360 100644
--- a/modules/bit/cmd/bit/osfs.mbt
+++ b/modules/bit/cmd/bit/osfs.mbt
@@ -52,7 +52,7 @@ pub impl @bitcore.RepoFileSystem for OsFs with fn read_file(_self, path) {
 
 ///|
 pub impl @bitcore.RepoFileSystem for OsFs with fn readdir(_self, path) {
-  @fs.read_dir(path).to_array() catch {
+  @fs.read_dir(path).to_owned() catch {
     err => raise io_error(err)
   }
 }
diff --git a/modules/bit/cmd/bit/pack_helpers.mbt b/modules/bit/cmd/bit/pack_helpers.mbt
index fc0d2958..96c357eb 100644
--- a/modules/bit/cmd/bit/pack_helpers.mbt
+++ b/modules/bit/cmd/bit/pack_helpers.mbt
@@ -1,13 +1,13 @@
 ///|
 fn shim_cwd_from_env() -> String? {
-  @sys.get_env_var("GIT_SHIM_CWD")
+  @env.get_env_var("GIT_SHIM_CWD")
 }
 
 ///|
 fn resolve_in_cwd(path : String) -> String {
   let base = match shim_cwd_from_env() {
     Some(cwd) => Some(cwd)
-    None => @sys.get_env_var("GIT_SHIM_PWD")
+    None => @env.get_env_var("GIT_SHIM_PWD")
   }
   match base {
     None => path
@@ -108,7 +108,7 @@ fn scan_ref_delta_bases(pack : Bytes, hash_size? : Int = 20) -> Array[String] {
 ///|
 fn bytes_to_hex_at(data : Bytes, offset : Int, len : Int) -> String {
   let hex_chars = "0123456789abcdef"
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for i in 0..<len {
     let b = data[offset + i].to_int()
     buf.write_char(hex_chars[b >> 4].to_int().unsafe_to_char())
@@ -271,7 +271,7 @@ fn is_sha256_repo_from_env() -> Bool {
   if is_sha256_repo(git_dir) {
     return true
   }
-  match @sys.get_env_var("GIT_SHIM_CWD") {
+  match @env.get_env_var("GIT_SHIM_CWD") {
     Some(cwd) => {
       let alt_git_dir = cwd + "/.git"
       if alt_git_dir != git_dir && is_sha256_repo(alt_git_dir) {
@@ -280,7 +280,7 @@ fn is_sha256_repo_from_env() -> Bool {
     }
     None => ()
   }
-  match @sys.get_env_var("GIT_WORK_TREE") {
+  match @env.get_env_var("GIT_WORK_TREE") {
     Some(dir) => {
       let alt_git_dir = dir + "/.git"
       if alt_git_dir != git_dir && is_sha256_repo(alt_git_dir) {
@@ -294,7 +294,7 @@ fn is_sha256_repo_from_env() -> Bool {
   while i + 1 < args.length() {
     if args[i] == "-C" {
       let raw = args[i + 1]
-      let base = @sys.get_env_var("GIT_SHIM_PWD").unwrap_or(".")
+      let base = @env.get_env_var("GIT_SHIM_PWD").unwrap_or(".")
       let cwd = if raw.has_prefix("/") { raw } else { base + "/" + raw }
       if is_sha256_repo(cwd + "/.git") {
         return true
diff --git a/modules/bit/cmd/bit/pack_objects.mbt b/modules/bit/cmd/bit/pack_objects.mbt
index 9b19b665..cdbda517 100644
--- a/modules/bit/cmd/bit/pack_objects.mbt
+++ b/modules/bit/cmd/bit/pack_objects.mbt
@@ -2471,7 +2471,7 @@ async fn handle_pack_objects(args : Array[String]) -> Unit raise Error {
       }
       let fs = OsFs::new()
       let git_dir = find_git_dir(fs)
-      match @sys.get_env_var("GIT_TEST_NAME_HASH_VERSION") {
+      match @env.get_env_var("GIT_TEST_NAME_HASH_VERSION") {
         Some(_) => ()
         None => ()
       }
@@ -2484,7 +2484,7 @@ async fn handle_pack_objects(args : Array[String]) -> Unit raise Error {
         @bitobject.HashAlgorithm::Sha1
       }
       let hash_size = hash_algo.hash_size()
-      let trace2_event = @sys.get_env_var("GIT_TRACE2_EVENT")
+      let trace2_event = @env.get_env_var("GIT_TRACE2_EVENT")
       ignore(is_pack_reuse_config_enabled(git_dir))
       // Keep these flags visible for future compatibility tuning.
       let non_default_delta_params = cfg.window == 0 || cfg.depth != 50
@@ -2848,7 +2848,7 @@ async fn handle_pack_objects(args : Array[String]) -> Unit raise Error {
         let use_sparse = match cfg.sparse_mode {
           Some(v) => v
           None =>
-            match @sys.get_env_var("GIT_TEST_PACK_SPARSE") {
+            match @env.get_env_var("GIT_TEST_PACK_SPARSE") {
               Some(val) =>
                 parse_bool_value(val).unwrap_or(get_pack_use_sparse(git_dir))
               None => get_pack_use_sparse(git_dir)
diff --git a/modules/bit/cmd/bit/pull.mbt b/modules/bit/cmd/bit/pull.mbt
index df957ac4..8e9daf5a 100644
--- a/modules/bit/cmd/bit/pull.mbt
+++ b/modules/bit/cmd/bit/pull.mbt
@@ -1360,14 +1360,14 @@ fn pull_reflog_action(args : Array[String]) -> String {
 
 ///|
 fn pull_reflog_identity() -> (String, String) {
-  let name = match @sys.get_env_var("GIT_COMMITTER_NAME") {
+  let name = match @env.get_env_var("GIT_COMMITTER_NAME") {
     Some(n) => n
-    None => @sys.get_env_var("USER").unwrap_or("Unknown")
+    None => @env.get_env_var("USER").unwrap_or("Unknown")
   }
-  let email = match @sys.get_env_var("GIT_COMMITTER_EMAIL") {
+  let email = match @env.get_env_var("GIT_COMMITTER_EMAIL") {
     Some(e) => e
     None =>
-      match @sys.get_env_var("USER") {
+      match @env.get_env_var("USER") {
         Some(u) => u + "@localhost"
         None => "unknown@localhost"
       }
@@ -1411,12 +1411,12 @@ fn pull_append_fast_forward_reflog(
 
 ///|
 fn pull_relay_preferred_sender() -> String? {
-  pull_normalize_optional_value(@sys.get_env_var("BIT_RELAY_PULL_SENDER"))
+  pull_normalize_optional_value(@env.get_env_var("BIT_RELAY_PULL_SENDER"))
 }
 
 ///|
 fn pull_relay_preferred_repo() -> String? {
-  pull_normalize_optional_value(@sys.get_env_var("BIT_RELAY_PULL_REPO"))
+  pull_normalize_optional_value(@env.get_env_var("BIT_RELAY_PULL_REPO"))
 }
 
 ///|
diff --git a/modules/bit/cmd/bit/push.mbt b/modules/bit/cmd/bit/push.mbt
index d1369252..21c68ace 100644
--- a/modules/bit/cmd/bit/push.mbt
+++ b/modules/bit/cmd/bit/push.mbt
@@ -599,7 +599,7 @@ async fn handle_push(args : Array[String]) -> Unit raise Error {
   }
   let protocol_version = match overrides.get("protocol.version") {
     Some(v) => v
-    None => @sys.get_env_var("GIT_TEST_PROTOCOL_VERSION").unwrap_or("2")
+    None => @env.get_env_var("GIT_TEST_PROTOCOL_VERSION").unwrap_or("2")
   }
   let negotiation_failed = push_negotiate && protocol_version == "0"
   if negotiation_failed {
@@ -915,7 +915,7 @@ async fn handle_push(args : Array[String]) -> Unit raise Error {
     refspec_args.length() == 0 &&
     !push_all &&
     default_plan is Some(_) {
-    if @sys.get_env_var("GIT_REMOTE_TESTGIT_NOREFSPEC") is Some(_) {
+    if @env.get_env_var("GIT_REMOTE_TESTGIT_NOREFSPEC") is Some(_) {
       raise @bitcore.GitError::InvalidObject(
         "remote-helper doesn't support push; refspec needed",
       )
@@ -993,7 +993,7 @@ async fn handle_push(args : Array[String]) -> Unit raise Error {
             )
           }
           if helper_is_testgit &&
-            @sys.get_env_var("GIT_REMOTE_TESTGIT_FAILURE") is Some(_) {
+            @env.get_env_var("GIT_REMOTE_TESTGIT_FAILURE") is Some(_) {
             raise @bitcore.GitError::InvalidObject(
               "failed to push some refs to '\{url}'",
             )
@@ -1019,7 +1019,7 @@ async fn handle_push(args : Array[String]) -> Unit raise Error {
           ).map(fn(v) { v.to_lower() })
           let push_hide_refs = read_hide_refs(fs, rgd, ["transfer", "receive"])
           let no_private_update = helper_is_testgit &&
-            @sys.get_env_var("GIT_REMOTE_TESTGIT_NO_PRIVATE_UPDATE") is Some(_)
+            @env.get_env_var("GIT_REMOTE_TESTGIT_NO_PRIVATE_UPDATE") is Some(_)
           let (
             push_log_name,
             push_log_email,
@@ -2084,12 +2084,12 @@ fn push_normalize_optional_value(value : String?) -> String? {
 
 ///|
 fn push_relay_preferred_sender() -> String? {
-  push_normalize_optional_value(@sys.get_env_var("BIT_RELAY_PUSH_SENDER"))
+  push_normalize_optional_value(@env.get_env_var("BIT_RELAY_PUSH_SENDER"))
 }
 
 ///|
 fn push_relay_preferred_repo() -> String? {
-  push_normalize_optional_value(@sys.get_env_var("BIT_RELAY_PUSH_REPO"))
+  push_normalize_optional_value(@env.get_env_var("BIT_RELAY_PUSH_REPO"))
 }
 
 ///|
diff --git a/modules/bit/cmd/bit/rebase.mbt b/modules/bit/cmd/bit/rebase.mbt
index e33b7af9..571b510a 100644
--- a/modules/bit/cmd/bit/rebase.mbt
+++ b/modules/bit/cmd/bit/rebase.mbt
@@ -550,7 +550,7 @@ async fn handle_rebase(args : Array[String]) -> Unit raise Error {
         let stopped_path = git_dir + "/rebase-merge/stopped-sha"
         if rfs.is_file(stopped_path) {
           let hex = trim_string(decode_bytes(rfs.read_file(stopped_path)))
-          if @sys.get_env_var("GIT_TRACE") is Some(v) && v != "" && v != "0" {
+          if @env.get_env_var("GIT_TRACE") is Some(v) && v != "" && v != "0" {
             let backend_path = git_dir + "/rebase-merge/backend"
             let use_apply = rfs.is_file(backend_path) &&
               trim_string(decode_bytes(rfs.read_file(backend_path))) == "apply"
@@ -1605,7 +1605,7 @@ fn generate_rebase_todo(
   rfs : &@bitcore.RepoFileSystem,
   commits : Array[@bitcore.ObjectId],
 ) -> String raise Error {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for commit in commits {
     let full_hex = commit.to_hex()
     let obj = db.get(rfs, commit)
@@ -1834,7 +1834,7 @@ fn parse_rebase_todo(content : String) -> Array[RebaseTodoEntry] {
 ///|
 fn split_whitespace(s : String, max_parts : Int) -> Array[String] {
   let result : Array[String] = []
-  let current = StringBuilder::new()
+  let current = StringBuilder()
   let mut in_word = false
   for c in s {
     if c == ' ' || c == '\t' {
@@ -2360,7 +2360,7 @@ fn parse_commit_author_message(content : Bytes) -> (String, String) {
   let text = @utf8.decode_lossy(content[:])
   let mut author = ""
   let mut in_message = false
-  let message = StringBuilder::new()
+  let message = StringBuilder()
   for line_view in text.split("\n") {
     let line = line_view.to_owned()
     if in_message {
@@ -2503,7 +2503,7 @@ fn subdir_write_tree(
 
 ///|
 fn subdir_bytes_to_string(bytes : Bytes) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i in 0..<bytes.length() {
     result.write_char(bytes[i].to_int().unsafe_to_char())
   }
diff --git a/modules/bit/cmd/bit/rebase_wbtest.mbt b/modules/bit/cmd/bit/rebase_wbtest.mbt
index efc7094a..53965744 100644
--- a/modules/bit/cmd/bit/rebase_wbtest.mbt
+++ b/modules/bit/cmd/bit/rebase_wbtest.mbt
@@ -73,10 +73,10 @@ async test "rebase: -S stores gpgsig header on rewritten commit" {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_DIR", prev_git_dir)
@@ -108,10 +108,10 @@ async test "rebase: -S stores gpgsig header on rewritten commit" {
   )
 
   commit_wbtest_run_git(repo_dir, ["switch", "-q", "feature"])
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
 
   // handle_rebase writes "Successfully rebased and updated refs. [...]"
   // to stdout via print_line. In `moon test` that bleeds into the
diff --git a/modules/bit/cmd/bit/receive_pack.mbt b/modules/bit/cmd/bit/receive_pack.mbt
index dc316b45..56f63c1a 100644
--- a/modules/bit/cmd/bit/receive_pack.mbt
+++ b/modules/bit/cmd/bit/receive_pack.mbt
@@ -465,7 +465,7 @@ async fn receive_run_hook(
     hook_path
   }
   // Build stdin data: "<old-oid> <new-oid> <refname>\n" for each update
-  let stdin_buf = StringBuilder::new()
+  let stdin_buf = StringBuilder()
   for upd in updates {
     stdin_buf.write_string(upd.old_id.to_hex())
     stdin_buf.write_char(' ')
@@ -832,7 +832,7 @@ fn receive_parse_proc_receive_output(
 
 ///|
 fn receive_proc_bytes_to_string(data : Bytes) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for b in data {
     buf.write_char(b.to_int().unsafe_to_char())
   }
diff --git a/modules/bit/cmd/bit/relay_ci_review.mbt b/modules/bit/cmd/bit/relay_ci_review.mbt
index ef0aa55a..54ba2181 100644
--- a/modules/bit/cmd/bit/relay_ci_review.mbt
+++ b/modules/bit/cmd/bit/relay_ci_review.mbt
@@ -56,7 +56,7 @@ async fn handle_relay_ci_push(args : Array[String]) -> Unit raise Error {
     @sys.exit(1)
   }
   let (base_url, room) = relay_resolve_room_arg(room_arg)
-  let sender = match @sys.get_env_var("BIT_RELAY_SENDER") {
+  let sender = match @env.get_env_var("BIT_RELAY_SENDER") {
     Some(s) => s
     None => "ci"
   }
diff --git a/modules/bit/cmd/bit/relay_watch.mbt b/modules/bit/cmd/bit/relay_watch.mbt
index 2c75a3f3..96302e31 100644
--- a/modules/bit/cmd/bit/relay_watch.mbt
+++ b/modules/bit/cmd/bit/relay_watch.mbt
@@ -2,12 +2,12 @@
 
 ///|
 fn relay_safe_sender() -> String {
-  match @sys.get_env_var("BIT_RELAY_SENDER") {
+  match @env.get_env_var("BIT_RELAY_SENDER") {
     Some(s) => s
     None => {
       // Extract name from git author config, URL-safe
       let author = get_author_string()
-      let buf = StringBuilder::new()
+      let buf = StringBuilder()
       for c in author {
         if c == '<' {
           break
@@ -29,7 +29,7 @@ fn relay_safe_sender() -> String {
 
 ///|
 fn relay_default_base_url() -> String {
-  match @sys.get_env_var("BIT_RELAY_URL") {
+  match @env.get_env_var("BIT_RELAY_URL") {
     Some(url) =>
       // Strip relay+ prefix if present
       if url.has_prefix("relay+") {
diff --git a/modules/bit/cmd/bit/relay_watch_wbtest.mbt b/modules/bit/cmd/bit/relay_watch_wbtest.mbt
index 4de74d97..84f5fc68 100644
--- a/modules/bit/cmd/bit/relay_watch_wbtest.mbt
+++ b/modules/bit/cmd/bit/relay_watch_wbtest.mbt
@@ -32,13 +32,13 @@ test "relay_resolve_room_arg: full URL without room" {
 
 ///|
 test "relay_safe_sender: from env" {
-  let prev = @sys.get_env_var("BIT_RELAY_SENDER")
-  @sys.set_env_var("BIT_RELAY_SENDER", "test-bot")
+  let prev = @env.get_env_var("BIT_RELAY_SENDER")
+  @env.set_env_var("BIT_RELAY_SENDER", "test-bot")
   let sender = relay_safe_sender()
   assert_eq(sender, "test-bot")
   match prev {
-    Some(v) => @sys.set_env_var("BIT_RELAY_SENDER", v)
-    None => @sys.unset_env_var("BIT_RELAY_SENDER")
+    Some(v) => @env.set_env_var("BIT_RELAY_SENDER", v)
+    None => @env.unset_env_var("BIT_RELAY_SENDER")
   }
 }
 
diff --git a/modules/bit/cmd/bit/remote.mbt b/modules/bit/cmd/bit/remote.mbt
index 2c3a18c0..ab63c917 100644
--- a/modules/bit/cmd/bit/remote.mbt
+++ b/modules/bit/cmd/bit/remote.mbt
@@ -58,7 +58,7 @@ fn emit_trace_region(
   category : String,
   label : String,
 ) -> Unit raise @bitcore.GitError {
-  let path = @sys.get_env_var("GIT_TRACE2_EVENT")
+  let path = @env.get_env_var("GIT_TRACE2_EVENT")
   guard path is Some(target) else { return () }
   let enter = "{\"event\":\"region_enter\",\"category\":\"" +
     category +
@@ -93,7 +93,7 @@ fn append_text_file(fs : OsFs, path : String, text : String) -> Unit {
 
 ///|
 fn emit_push_trace_event(fs : OsFs, key : String, value : String) -> Unit {
-  match @sys.get_env_var("GIT_TRACE2_EVENT") {
+  match @env.get_env_var("GIT_TRACE2_EVENT") {
     Some(path) => {
       let line = "{\"event\":\"data\",\"key\":\"" +
         key +
@@ -108,7 +108,7 @@ fn emit_push_trace_event(fs : OsFs, key : String, value : String) -> Unit {
 
 ///|
 fn emit_push_trace_subcommand(fs : OsFs, argv : Array[String]) -> Unit {
-  match @sys.get_env_var("GIT_TRACE2_EVENT") {
+  match @env.get_env_var("GIT_TRACE2_EVENT") {
     Some(path) => {
       let encoded : Array[String] = []
       for arg in argv {
@@ -1259,7 +1259,7 @@ async fn remote_prune(
   let url = rc.urls[0]
   print_line("Pruning \{name}")
   print_line("URL: \{url}")
-  let local_root = match @sys.get_env_var("GIT_SHIM_CWD") {
+  let local_root = match @env.get_env_var("GIT_SHIM_CWD") {
     Some(dir) => dir
     None => root
   }
@@ -1500,7 +1500,7 @@ async fn remote_set_head_auto(
   if url.length() == 0 {
     raise @bitcore.GitError::InvalidObject("No remote configured")
   }
-  let local_root = match @sys.get_env_var("GIT_SHIM_CWD") {
+  let local_root = match @env.get_env_var("GIT_SHIM_CWD") {
     Some(dir) => dir
     None => root
   }
@@ -1547,21 +1547,21 @@ async fn remote_set_head_auto(
 
 ///|
 fn get_committer_identity() -> (String, String, Int64, String) {
-  let name = match @sys.get_env_var("GIT_COMMITTER_NAME") {
+  let name = match @env.get_env_var("GIT_COMMITTER_NAME") {
     Some(n) => n
-    None => @sys.get_env_var("USER").unwrap_or("Unknown")
+    None => @env.get_env_var("USER").unwrap_or("Unknown")
   }
-  let email = match @sys.get_env_var("GIT_COMMITTER_EMAIL") {
+  let email = match @env.get_env_var("GIT_COMMITTER_EMAIL") {
     Some(e) => e
     None =>
-      match @sys.get_env_var("USER") {
+      match @env.get_env_var("USER") {
         Some(u) => u + "@localhost"
         None => "unknown@localhost"
       }
   }
   let mut timestamp = get_current_timestamp()
   let mut timezone = "+0000"
-  match @sys.get_env_var("GIT_COMMITTER_DATE") {
+  match @env.get_env_var("GIT_COMMITTER_DATE") {
     Some(raw) => {
       let parts = @bitlib.split_whitespace_all(raw)
       if parts.length() > 0 {
@@ -1776,7 +1776,7 @@ fn parse_legacy_branches_entry(
 
 ///|
 fn legacy_default_branch_name() -> String {
-  @sys.get_env_var("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME").unwrap_or("main")
+  @env.get_env_var("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME").unwrap_or("main")
 }
 
 ///|
@@ -1837,10 +1837,10 @@ fn write_clone_alternates(
 fn read_global_branch_autosetuprebase(
   fs : &@bitcore.RepoFileSystem,
 ) -> String? raise Error {
-  let config_path = match @sys.get_env_var("GIT_CONFIG_GLOBAL") {
+  let config_path = match @env.get_env_var("GIT_CONFIG_GLOBAL") {
     Some(path) => path
     None =>
-      match @sys.get_env_var("HOME") {
+      match @env.get_env_var("HOME") {
         Some(home) => home + "/.gitconfig"
         None => return None
       }
@@ -2668,7 +2668,7 @@ async fn fetch_local_repo(
   } else {
     src_path
   }
-  match @sys.get_env_var("GIT_TRACE_PACKET") {
+  match @env.get_env_var("GIT_TRACE_PACKET") {
     Some(path) => append_text_file(fs, path, "")
     None => ()
   }
@@ -2748,7 +2748,7 @@ async fn fetch_local_repo(
     "uploadpack",
     "allowreachablesha1inwant",
   ).unwrap_or(false)
-  let protocol_version = @sys.get_env_var("GIT_TEST_PROTOCOL_VERSION").unwrap_or(
+  let protocol_version = @env.get_env_var("GIT_TEST_PROTOCOL_VERSION").unwrap_or(
     "2",
   )
   let enforce_unadvertised_oid = protocol_version == "0"
@@ -3088,7 +3088,7 @@ async fn fetch_from_remote(
   force_transport? : Bool = false,
   quiet? : Bool = false,
 ) -> Unit raise Error {
-  let local_root = match @sys.get_env_var("GIT_SHIM_CWD") {
+  let local_root = match @env.get_env_var("GIT_SHIM_CWD") {
     Some(dir) => dir
     None => root
   }
@@ -3519,7 +3519,7 @@ async fn remote_show(
       print_line("  Push  URL: \{pu}")
     }
   }
-  let local_root = match @sys.get_env_var("GIT_SHIM_CWD") {
+  let local_root = match @env.get_env_var("GIT_SHIM_CWD") {
     Some(dir) => dir
     None => root
   }
diff --git a/modules/bit/cmd/bit/repack.mbt b/modules/bit/cmd/bit/repack.mbt
index d5f010e4..fa0cdee9 100644
--- a/modules/bit/cmd/bit/repack.mbt
+++ b/modules/bit/cmd/bit/repack.mbt
@@ -335,7 +335,7 @@ async fn handle_repack(args : Array[String]) -> Unit raise Error {
 ///|
 fn repack_find_bit_exe(git_dir : String) -> String {
   // Check GIT_TEST_INSTALLED (used in shim tests)
-  match @sys.get_env_var("GIT_TEST_INSTALLED") {
+  match @env.get_env_var("GIT_TEST_INSTALLED") {
     Some(dir) if dir.length() > 0 => {
       let fs = OsFs::new()
       let candidate = dir + "/git"
@@ -346,7 +346,7 @@ fn repack_find_bit_exe(git_dir : String) -> String {
     _ => ()
   }
   // Check SHIM_MOON env var (bit binary path for shim tests)
-  match @sys.get_env_var("SHIM_MOON") {
+  match @env.get_env_var("SHIM_MOON") {
     Some(path) if path.length() > 0 => return path
     _ => ()
   }
@@ -391,7 +391,7 @@ fn repack_update_server_info(
   }
   let packs_path = info_dir + "/packs"
   let entries = fs.readdir(pack_dir) catch { _ => return }
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for entry in entries {
     if entry.has_suffix(".pack") && !entry.has_prefix(".tmp-") {
       buf.write_string("P ")
@@ -411,7 +411,7 @@ fn repack_update_server_info(
   let refs_path = refs_info_dir + "/refs"
   let rfs : &@bitcore.RepoFileSystem = fs
   let all_refs = @bitrepo.show_ref(rfs, git_dir) catch { _ => [] }
-  let refs_buf = StringBuilder::new()
+  let refs_buf = StringBuilder()
   for item in all_refs {
     let (name, id) = item
     refs_buf.write_string(id.to_hex())
diff --git a/modules/bit/cmd/bit/replace.mbt b/modules/bit/cmd/bit/replace.mbt
index 2d9049f6..19211490 100644
--- a/modules/bit/cmd/bit/replace.mbt
+++ b/modules/bit/cmd/bit/replace.mbt
@@ -441,7 +441,7 @@ fn replace_rebuild_commit(
 /// Split a string into lines, keeping the newline character at the end of each line.
 fn replace_split_lines_keep_newlines(text : String) -> Array[String] {
   let lines : Array[String] = []
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for c in text {
     buf.write_char(c)
     if c == '\n' {
diff --git a/modules/bit/cmd/bit/reset.mbt b/modules/bit/cmd/bit/reset.mbt
index a75603dc..97368d41 100644
--- a/modules/bit/cmd/bit/reset.mbt
+++ b/modules/bit/cmd/bit/reset.mbt
@@ -728,7 +728,7 @@ fn reset_is_iso_8859_1(encoding : String) -> Bool {
 ///|
 fn reset_normalize_encoding_name(value : String) -> String {
   let trimmed = trim_string(value).to_lower()
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   for c in trimmed {
     if c == '-' || c == '_' || c == ' ' {
       continue
diff --git a/modules/bit/cmd/bit/reset_wbtest.mbt b/modules/bit/cmd/bit/reset_wbtest.mbt
index 23148730..3221846a 100644
--- a/modules/bit/cmd/bit/reset_wbtest.mbt
+++ b/modules/bit/cmd/bit/reset_wbtest.mbt
@@ -32,8 +32,8 @@ async test "reset pathspec: trailing slash unstages submodule gitlink" {
   let init_dir = root + "/init"
   let super_dir = root + "/super"
 
-  let prev_allow_protocol = @sys.get_env_var("GIT_ALLOW_PROTOCOL")
-  @sys.set_env_var("GIT_ALLOW_PROTOCOL", "file")
+  let prev_allow_protocol = @env.get_env_var("GIT_ALLOW_PROTOCOL")
+  @env.set_env_var("GIT_ALLOW_PROTOCOL", "file")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "init"])
   add_test_run_git(init_dir, ["config", "user.name", "Test User"])
@@ -61,14 +61,14 @@ async test "reset pathspec: trailing slash unstages submodule gitlink" {
   ])
   assert_eq(diff_before, 1)
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_CWD", super_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", super_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", super_dir)
+  @env.set_env_var("GIT_SHIM_PWD", super_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_DIR", prev_git_dir)
@@ -108,14 +108,14 @@ async test "reset: hard restores a valid root cache-tree for indexed-object nega
   fs.write_string(repo_dir + "/only-in-index", "only-in-index\n")
   add_test_run_git(repo_dir, ["add", "only-in-index"])
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_DIR", prev_git_dir)
diff --git a/modules/bit/cmd/bit/rev_list.mbt b/modules/bit/cmd/bit/rev_list.mbt
index a72b30c4..87233eb3 100644
--- a/modules/bit/cmd/bit/rev_list.mbt
+++ b/modules/bit/cmd/bit/rev_list.mbt
@@ -878,7 +878,7 @@ async fn handle_rev_list(args : Array[String]) -> Unit raise Error {
     }
     None =>
       for id in sliced_result {
-        let buf = StringBuilder::new()
+        let buf = StringBuilder()
         let hex = id.to_hex()
         buf.write_string(
           rev_list_output_prefix(
@@ -1662,7 +1662,7 @@ async fn rev_list_test_bitmap(fs : OsFs, git_dir : String) -> Unit raise Error {
 
 ///|
 fn emit_revindex_trace(fs : OsFs, kind : String) -> Unit {
-  match @sys.get_env_var("GIT_TRACE2_EVENT") {
+  match @env.get_env_var("GIT_TRACE2_EVENT") {
     Some(path) => {
       let target = path.trim().to_owned()
       if target.length() == 0 || target == "1" || target == "2" {
diff --git a/modules/bit/cmd/bit/rev_parse.mbt b/modules/bit/cmd/bit/rev_parse.mbt
index 56a62841..25f798fb 100644
--- a/modules/bit/cmd/bit/rev_parse.mbt
+++ b/modules/bit/cmd/bit/rev_parse.mbt
@@ -47,21 +47,21 @@ async fn handle_rev_parse(args : Array[String]) -> Unit raise Error {
       None => ()
     }
   }
-  let cwd_abs = match @sys.get_env_var("GIT_SHIM_CWD") {
+  let cwd_abs = match @env.get_env_var("GIT_SHIM_CWD") {
     Some(v) => v
     None =>
-      match @sys.get_env_var("GIT_SHIM_PWD") {
+      match @env.get_env_var("GIT_SHIM_PWD") {
         Some(v) => v
-        None => @sys.get_env_var("PWD").unwrap_or(root)
+        None => @env.get_env_var("PWD").unwrap_or(root)
       }
   }
   // When GIT_DIR is explicitly set (env var or --git-dir flag) and
   // GIT_WORK_TREE is not set, git uses CWD as the work tree root.
   // Override root accordingly for --show-prefix/--show-cdup/--show-toplevel.
-  let explicit_git_dir = @sys.get_env_var("GIT_DIR") is Some(_)
+  let explicit_git_dir = @env.get_env_var("GIT_DIR") is Some(_)
   let root = if explicit_git_dir &&
-    @sys.get_env_var("GIT_WORK_TREE") is None &&
-    @sys.get_env_var("GIT_SHIM_CWD") is Some(_) {
+    @env.get_env_var("GIT_WORK_TREE") is None &&
+    @env.get_env_var("GIT_SHIM_CWD") is Some(_) {
     cwd_abs
   } else {
     root
@@ -341,7 +341,7 @@ async fn handle_rev_parse(args : Array[String]) -> Unit raise Error {
             // When GIT_DIR was explicitly set by the user (env var),
             // use the raw value for display (e.g. "../.git")
             let display_git_dir = if explicit_git_dir {
-              @sys.get_env_var("GIT_DIR").unwrap_or(git_dir)
+              @env.get_env_var("GIT_DIR").unwrap_or(git_dir)
             } else {
               git_dir
             }
@@ -1153,7 +1153,7 @@ fn rev_parse_resolve_git_path(
 
 ///|
 fn rev_parse_git_path_output_cwd(cwd_abs : String) -> String {
-  @sys.get_env_var("GIT_SHIM_CALLER_PWD").unwrap_or(cwd_abs)
+  @env.get_env_var("GIT_SHIM_CALLER_PWD").unwrap_or(cwd_abs)
 }
 
 ///|
@@ -1783,7 +1783,7 @@ fn rev_parse_is_bare_repository(
   }
   // If git_dir == root (no separate work tree), it's bare
   let abs_root = if root == "." {
-    @sys.get_env_var("PWD").unwrap_or(root)
+    @env.get_env_var("PWD").unwrap_or(root)
   } else {
     root
   }
@@ -1853,7 +1853,7 @@ fn rev_parse_is_inside_work_tree(
 ///|
 fn rev_parse_show_prefix(root : String, cwd_abs : String) -> String {
   let abs_root = if root == "." {
-    @sys.get_env_var("PWD").unwrap_or(root)
+    @env.get_env_var("PWD").unwrap_or(root)
   } else {
     root
   }
@@ -1884,7 +1884,7 @@ fn rev_parse_show_prefix(root : String, cwd_abs : String) -> String {
 ///|
 fn rev_parse_show_cdup(root : String, cwd_abs : String) -> String {
   let abs_root = if root == "." {
-    @sys.get_env_var("PWD").unwrap_or(root)
+    @env.get_env_var("PWD").unwrap_or(root)
   } else {
     root
   }
@@ -1980,9 +1980,9 @@ fn rev_parse_resolve_abs_root(root : String, cwd_abs : String) -> String {
   if root.has_prefix("/") {
     root
   } else {
-    let base = match @sys.get_env_var("GIT_SHIM_PWD") {
+    let base = match @env.get_env_var("GIT_SHIM_PWD") {
       Some(v) => v
-      None => @sys.get_env_var("PWD").unwrap_or(cwd_abs)
+      None => @env.get_env_var("PWD").unwrap_or(cwd_abs)
     }
     if root == "." {
       base
@@ -2388,7 +2388,7 @@ fn parseopt_format_help(
   opts : Array[ParseoptOpt],
   show_all : Bool,
 ) -> String {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   let mut blurb_start = -1
   for i = 0; i < usage_lines.length(); i = i + 1 {
     if usage_lines[i].length() == 0 {
@@ -2619,7 +2619,7 @@ async fn parseopt_parse_args(
   stuck_long : Bool,
   usage_lines : Array[String],
 ) -> String raise Error {
-  let parsed = StringBuilder::new()
+  let parsed = StringBuilder()
   parsed.write_string("set --")
   let remaining : Array[String] = []
   let mut i = 0
@@ -2799,7 +2799,7 @@ fn parseopt_match_long(
     }
   }
   let disallow_abbreviated = match
-    @sys.get_env_var("GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS") {
+    @env.get_env_var("GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS") {
     Some(v) => v == "true" || v == "1" || v == "yes"
     None => false
   }
@@ -2858,7 +2858,7 @@ fn parseopt_format_matched_long(
   all_args : Array[String],
   arg_idx : Int,
 ) -> ParseoptMatchResult {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   let mut consumed = 1
   if unset {
     out.write_string(" --no-")
@@ -2881,7 +2881,7 @@ fn parseopt_format_matched_long(
     match opt_value {
       Some(v) => {
         if stuck_long && opt.long_name.length() > 0 && !unset {
-          let out2 = StringBuilder::new()
+          let out2 = StringBuilder()
           out2.write_string(" --")
           out2.write_string(opt.long_name)
           out2.write_char('=')
@@ -2926,7 +2926,7 @@ fn parseopt_match_short(
   all_args : Array[String],
   arg_idx : Int,
 ) -> ParseoptMatchResult {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   let mut consumed = 1
   let mut ci = 1
   while ci < arg.length() {
diff --git a/modules/bit/cmd/bit/rev_parse_wbtest.mbt b/modules/bit/cmd/bit/rev_parse_wbtest.mbt
index 5f4459f7..9f2d37ae 100644
--- a/modules/bit/cmd/bit/rev_parse_wbtest.mbt
+++ b/modules/bit/cmd/bit/rev_parse_wbtest.mbt
@@ -69,12 +69,12 @@ test "rev-parse: --git-path prefers cwd-relative path for absolute git dir" {
 
 ///|
 test "rev-parse: --git-path prefers caller pwd under -C" {
-  let prev = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", "/repo")
+  let prev = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", "/repo")
   @test.assert_eq(rev_parse_git_path_output_cwd("/repo/there"), "/repo")
   match prev {
-    Some(value) => @sys.set_env_var("GIT_SHIM_CALLER_PWD", value)
-    None => @sys.unset_env_var("GIT_SHIM_CALLER_PWD")
+    Some(value) => @env.set_env_var("GIT_SHIM_CALLER_PWD", value)
+    None => @env.unset_env_var("GIT_SHIM_CALLER_PWD")
   }
 }
 
diff --git a/modules/bit/cmd/bit/rm.mbt b/modules/bit/cmd/bit/rm.mbt
index 5c60f34c..7ee67407 100644
--- a/modules/bit/cmd/bit/rm.mbt
+++ b/modules/bit/cmd/bit/rm.mbt
@@ -739,7 +739,7 @@ fn rm_append_conflict_block(
 
 ///|
 fn rm_quote_path(path : String) -> String {
-  let b = StringBuilder::new()
+  let b = StringBuilder()
   b.write_char('\'')
   for c in path {
     if c == '\'' {
diff --git a/modules/bit/cmd/bit/rm_wbtest.mbt b/modules/bit/cmd/bit/rm_wbtest.mbt
index 82624150..3f3d2da8 100644
--- a/modules/bit/cmd/bit/rm_wbtest.mbt
+++ b/modules/bit/cmd/bit/rm_wbtest.mbt
@@ -205,22 +205,22 @@ async test "rm: stage-only missing submodule is removable" {
   submodule_wbtest_run_git(super_dir, ["add", "t"])
   submodule_wbtest_run_git(super_dir, ["commit", "-q", "-m", "base"])
 
-  let prev_allow_protocol = @sys.get_env_var("GIT_ALLOW_PROTOCOL")
-  @sys.set_env_var("GIT_ALLOW_PROTOCOL", "file")
+  let prev_allow_protocol = @env.get_env_var("GIT_ALLOW_PROTOCOL")
+  @env.set_env_var("GIT_ALLOW_PROTOCOL", "file")
   submodule_wbtest_run_git(super_dir, [
     "submodule", "add", "./../source", "repo",
   ])
   submodule_wbtest_restore_env("GIT_ALLOW_PROTOCOL", prev_allow_protocol)
   cleanup_tree(fs, super_dir + "/repo")
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_CWD", super_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", super_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", super_dir)
+  @env.set_env_var("GIT_SHIM_PWD", super_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
   defer submodule_wbtest_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer submodule_wbtest_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer submodule_wbtest_restore_env("GIT_DIR", prev_git_dir)
@@ -246,10 +246,10 @@ async test "rm: orphan checkout keeps tracked files removable" {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -258,10 +258,10 @@ async test "rm: orphan checkout keeps tracked files removable" {
   add_test_run_git(repo_dir, ["add", "init.t"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   checkout_wbtest_run_shim_git(repo_dir, [
     "checkout", "-q", "--orphan", "orphan1",
@@ -313,22 +313,22 @@ async test "rm: removing named submodule clears matching gitmodules section only
   submodule_wbtest_run_git(super_dir, ["add", "t"])
   submodule_wbtest_run_git(super_dir, ["commit", "-q", "-m", "base"])
 
-  let prev_allow_protocol = @sys.get_env_var("GIT_ALLOW_PROTOCOL")
-  @sys.set_env_var("GIT_ALLOW_PROTOCOL", "file")
+  let prev_allow_protocol = @env.get_env_var("GIT_ALLOW_PROTOCOL")
+  @env.set_env_var("GIT_ALLOW_PROTOCOL", "file")
   handle_submodule_add(fs, super_dir, super_dir + "/.git", [
     "--quiet", "--name", "repo_new", "./../source", "repo",
   ])
   submodule_wbtest_restore_env("GIT_ALLOW_PROTOCOL", prev_allow_protocol)
   submodule_wbtest_run_git(super_dir, ["commit", "-q", "-am", "add submodule"])
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_CWD", super_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", super_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", super_dir)
+  @env.set_env_var("GIT_SHIM_PWD", super_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   handle_rm(["-q", "repo"])
 
@@ -387,8 +387,8 @@ async test "rm: cached submodule removal preserves gitmodules entry" {
   submodule_wbtest_run_git(super_dir, ["add", "t"])
   submodule_wbtest_run_git(super_dir, ["commit", "-q", "-m", "base"])
 
-  let prev_allow_protocol = @sys.get_env_var("GIT_ALLOW_PROTOCOL")
-  @sys.set_env_var("GIT_ALLOW_PROTOCOL", "file")
+  let prev_allow_protocol = @env.get_env_var("GIT_ALLOW_PROTOCOL")
+  @env.set_env_var("GIT_ALLOW_PROTOCOL", "file")
   handle_submodule_add(fs, super_dir, super_dir + "/.git", [
     "--quiet", "--name", "repo_new", "./../source", "repo",
   ])
@@ -397,14 +397,14 @@ async test "rm: cached submodule removal preserves gitmodules entry" {
 
   let before_gitmodules = decode_bytes(fs.read_file(super_dir + "/.gitmodules"))
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_CWD", super_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", super_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", super_dir)
+  @env.set_env_var("GIT_SHIM_PWD", super_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   handle_rm(["-q", "--cached", "repo"])
 
diff --git a/modules/bit/cmd/bit/scalar.mbt b/modules/bit/cmd/bit/scalar.mbt
index c8affa0f..288beaf8 100644
--- a/modules/bit/cmd/bit/scalar.mbt
+++ b/modules/bit/cmd/bit/scalar.mbt
@@ -26,10 +26,10 @@ fn scalar_current_dir() -> String {
   match @env.current_dir() {
     Some(dir) => dir
     None =>
-      match @sys.get_env_var("PWD") {
+      match @env.get_env_var("PWD") {
         Some(dir) => dir
         None =>
-          match @sys.get_env_var("GIT_SHIM_PWD") {
+          match @env.get_env_var("GIT_SHIM_PWD") {
             Some(dir) => dir
             None => "."
           }
@@ -48,10 +48,10 @@ fn scalar_abs_path(path : String, cwd : String) -> String {
 
 ///|
 fn scalar_global_config_path() -> String {
-  match @sys.get_env_var("GIT_CONFIG_GLOBAL") {
+  match @env.get_env_var("GIT_CONFIG_GLOBAL") {
     Some(path) => path
     None =>
-      match @sys.get_env_var("HOME") {
+      match @env.get_env_var("HOME") {
         Some(home) => home + "/.gitconfig"
         None => ".gitconfig"
       }
@@ -409,7 +409,7 @@ fn scalar_remove_dir_recursive(fs : OsFs, path : String) -> Unit {
 
 ///|
 fn scalar_append_trace_line(fs : OsFs, line : String) -> Unit {
-  match @sys.get_env_var("GIT_TRACE2_EVENT") {
+  match @env.get_env_var("GIT_TRACE2_EVENT") {
     Some(path) => {
       let existing = if fs.is_file(path) {
         decode_bytes(fs.read_file(path)) catch {
@@ -442,7 +442,7 @@ fn scalar_trace_subcommand(fs : OsFs, argv : Array[String]) -> Unit {
 
 ///|
 fn scalar_ensure_trace_file(fs : OsFs) -> Unit {
-  match @sys.get_env_var("GIT_TRACE2_EVENT") {
+  match @env.get_env_var("GIT_TRACE2_EVENT") {
     Some(path) =>
       if !fs.is_file(path) {
         fs.write_string(path, "") catch {
diff --git a/modules/bit/cmd/bit/serve.mbt b/modules/bit/cmd/bit/serve.mbt
index abc37087..70f47669 100644
--- a/modules/bit/cmd/bit/serve.mbt
+++ b/modules/bit/cmd/bit/serve.mbt
@@ -90,7 +90,7 @@ fn parse_hub_serve_options(args : Array[String]) -> HubServeOptions? {
   let url = match relay_url {
     Some(u) => u
     None =>
-      match @sys.get_env_var("BIT_RELAY_URL") {
+      match @env.get_env_var("BIT_RELAY_URL") {
         Some(u) => u
         None => "relay+https://bit-relay.mizchi.workers.dev"
       }
@@ -160,7 +160,7 @@ fn serve_b64_char(idx : Int) -> Char {
 
 ///|
 fn serve_base64_encode(data : Bytes) -> String {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   let len = data.length()
   let mut i = 0
   while i < len {
@@ -1110,7 +1110,7 @@ fn serve_parse_pkt_len(data : Bytes, start : Int) -> Int {
 
 ///|
 fn serve_bytes_to_string(data : Bytes, start : Int, end : Int) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   let mut i = start
   while i < end {
     buf.write_char(data[i].to_int().unsafe_to_char())
@@ -1122,7 +1122,7 @@ fn serve_bytes_to_string(data : Bytes, start : Int, end : Int) -> String {
 ///|
 fn serve_split_spaces(s : String) -> Array[String] {
   let out : Array[String] = []
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for c in s {
     if c == ' ' {
       out.push(buf.to_string())
@@ -1512,7 +1512,7 @@ fn serve_parent_path(path : String) -> String {
 
 ///|
 fn serve_add_auth_header(headers : Map[String, String]) -> Unit {
-  match @sys.get_env_var("BIT_RELAY_AUTH_TOKEN") {
+  match @env.get_env_var("BIT_RELAY_AUTH_TOKEN") {
     Some(token) =>
       if token.length() > 0 {
         if token.has_prefix("Bearer ") || token.has_prefix("bearer ") {
diff --git a/modules/bit/cmd/bit/show_branches.mbt b/modules/bit/cmd/bit/show_branches.mbt
index f7ca2208..fc4fae73 100644
--- a/modules/bit/cmd/bit/show_branches.mbt
+++ b/modules/bit/cmd/bit/show_branches.mbt
@@ -78,7 +78,7 @@ async fn handle_show_branches(args : Array[String]) -> Unit raise Error {
       }
       displayed[hex] = true
       // Build indicator line
-      let indicators = StringBuilder::new()
+      let indicators = StringBuilder()
       for i = 0; i < branches_to_show.length(); i = i + 1 {
         if i == branch_idx {
           let ch = if i < branch_chars.length() {
diff --git a/modules/bit/cmd/bit/signing_helpers.mbt b/modules/bit/cmd/bit/signing_helpers.mbt
index 15b78bc9..3b5f7062 100644
--- a/modules/bit/cmd/bit/signing_helpers.mbt
+++ b/modules/bit/cmd/bit/signing_helpers.mbt
@@ -765,7 +765,7 @@ fn signing_openpgp_native_keyring(
   root : String,
   git_dir : String,
 ) -> Array[String]? raise @bitcore.GitError {
-  let configured = match @sys.get_env_var("BIT_OPENPGP_KEYRING") {
+  let configured = match @env.get_env_var("BIT_OPENPGP_KEYRING") {
     Some(value) if value.trim().to_owned().length() > 0 => Some(value)
     _ => bit_config_get(git_dir, "gpg", "openpgpKeyringFile")
   }
@@ -813,7 +813,7 @@ fn signing_openpgp_native_result(
 /// (OpenPGP self-activates whenever a native keyring is configured, so it does
 /// not require this flag.)
 fn signing_native_verify_enabled(git_dir : String) -> Bool {
-  match @sys.get_env_var("BIT_NATIVE_VERIFY") {
+  match @env.get_env_var("BIT_NATIVE_VERIFY") {
     Some(value) => {
       let normalized = value.trim().to_owned().to_lower()
       if normalized != "" && normalized != "0" && normalized != "false" {
diff --git a/modules/bit/cmd/bit/sparse_checkout.mbt b/modules/bit/cmd/bit/sparse_checkout.mbt
index ec263abd..944dbb3f 100644
--- a/modules/bit/cmd/bit/sparse_checkout.mbt
+++ b/modules/bit/cmd/bit/sparse_checkout.mbt
@@ -263,7 +263,7 @@ fn sparse_checkout_unquote_c_style(text : String) -> String {
     start=1,
     end=trimmed.length() - 1,
   )
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   let mut escape = false
   for c in inner {
     if escape {
@@ -354,7 +354,7 @@ fn sparse_checkout_split_check_rules_input(
 ) -> Array[(String, String)] {
   let entries : Array[(String, String)] = []
   if nul_terminated {
-    let buf = StringBuilder::new()
+    let buf = StringBuilder()
     for c in input {
       if c == '\u{0}' {
         let raw = buf.to_string()
@@ -388,7 +388,7 @@ fn sparse_checkout_filter_check_rules_input(
   patterns : Array[String],
   nul_terminated : Bool,
 ) -> String {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   for entry in sparse_checkout_split_check_rules_input(input, nul_terminated) {
     let raw = entry.0
     let path = entry.1
diff --git a/modules/bit/cmd/bit/sparse_checkout_wbtest.mbt b/modules/bit/cmd/bit/sparse_checkout_wbtest.mbt
index 1c3b9183..bb2e208b 100644
--- a/modules/bit/cmd/bit/sparse_checkout_wbtest.mbt
+++ b/modules/bit/cmd/bit/sparse_checkout_wbtest.mbt
@@ -99,7 +99,7 @@ fn sparse_checkout_wbtest_strip_moon_warnings(text : String) -> String {
   if lines.length() == 0 {
     return ""
   }
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   for i, line in lines {
     if i > 0 {
       out.write_char('\n')
@@ -1072,7 +1072,7 @@ test "sparse-checkout: check-rules helper preserves quoted and nul-delimited mat
   )
   @test.assert_eq(quoted, "\"folder\\\" a/file\"\n")
 
-  let nul_input = StringBuilder::new()
+  let nul_input = StringBuilder()
   nul_input.write_string("folder\" a/a")
   nul_input.write_char('\u{0}')
   nul_input.write_string("folder\" b/file")
@@ -1082,7 +1082,7 @@ test "sparse-checkout: check-rules helper preserves quoted and nul-delimited mat
     patterns,
     true,
   )
-  let expect = StringBuilder::new()
+  let expect = StringBuilder()
   expect.write_string("folder\" a/a")
   expect.write_char('\u{0}')
   @test.assert_eq(nul_output, expect.to_string())
diff --git a/modules/bit/cmd/bit/storage_runtime_wbtest.mbt b/modules/bit/cmd/bit/storage_runtime_wbtest.mbt
index 9cf819ef..3eb542ac 100644
--- a/modules/bit/cmd/bit/storage_runtime_wbtest.mbt
+++ b/modules/bit/cmd/bit/storage_runtime_wbtest.mbt
@@ -33,8 +33,8 @@ fn cmd_storage_trim(s : String) -> String {
 ///|
 fn cmd_storage_restore_env(name : String, prev : String?) -> Unit {
   match prev {
-    Some(value) => @sys.set_env_var(name, value)
-    None => @sys.unset_env_var(name)
+    Some(value) => @env.set_env_var(name, value)
+    None => @env.unset_env_var(name)
   }
 }
 
@@ -47,18 +47,18 @@ fn cmd_storage_setup_test_env() -> (
   String?,
   String?,
 ) {
-  let prev_author_name = @sys.get_env_var("GIT_AUTHOR_NAME")
-  let prev_author_email = @sys.get_env_var("GIT_AUTHOR_EMAIL")
-  let prev_committer_name = @sys.get_env_var("GIT_COMMITTER_NAME")
-  let prev_committer_email = @sys.get_env_var("GIT_COMMITTER_EMAIL")
-  let prev_committer_date = @sys.get_env_var("GIT_COMMITTER_DATE")
-  let prev_quiet = @sys.get_env_var("BIT_STORAGE_RUNTIME_QUIET")
-  @sys.set_env_var("GIT_AUTHOR_NAME", "Storage Delegate Test")
-  @sys.set_env_var("GIT_AUTHOR_EMAIL", "storage-delegate@example.com")
-  @sys.set_env_var("GIT_COMMITTER_NAME", "Storage Delegate Test")
-  @sys.set_env_var("GIT_COMMITTER_EMAIL", "storage-delegate@example.com")
-  @sys.set_env_var("GIT_COMMITTER_DATE", "1700000000")
-  @sys.set_env_var("BIT_STORAGE_RUNTIME_QUIET", "1")
+  let prev_author_name = @env.get_env_var("GIT_AUTHOR_NAME")
+  let prev_author_email = @env.get_env_var("GIT_AUTHOR_EMAIL")
+  let prev_committer_name = @env.get_env_var("GIT_COMMITTER_NAME")
+  let prev_committer_email = @env.get_env_var("GIT_COMMITTER_EMAIL")
+  let prev_committer_date = @env.get_env_var("GIT_COMMITTER_DATE")
+  let prev_quiet = @env.get_env_var("BIT_STORAGE_RUNTIME_QUIET")
+  @env.set_env_var("GIT_AUTHOR_NAME", "Storage Delegate Test")
+  @env.set_env_var("GIT_AUTHOR_EMAIL", "storage-delegate@example.com")
+  @env.set_env_var("GIT_COMMITTER_NAME", "Storage Delegate Test")
+  @env.set_env_var("GIT_COMMITTER_EMAIL", "storage-delegate@example.com")
+  @env.set_env_var("GIT_COMMITTER_DATE", "1700000000")
+  @env.set_env_var("BIT_STORAGE_RUNTIME_QUIET", "1")
   (
     prev_author_name, prev_author_email, prev_committer_name, prev_committer_email,
     prev_committer_date, prev_quiet,
diff --git a/modules/bit/cmd/bit/stripspace.mbt b/modules/bit/cmd/bit/stripspace.mbt
index 9e3c9b38..18866899 100644
--- a/modules/bit/cmd/bit/stripspace.mbt
+++ b/modules/bit/cmd/bit/stripspace.mbt
@@ -22,7 +22,7 @@ async fn handle_stripspace(args : Array[String]) -> Unit raise Error {
   let input = decode_bytes(read_all_stdin())
   if comment_lines {
     // Prefix each line with "# "
-    let result = StringBuilder::new()
+    let result = StringBuilder()
     let lines = stripspace_split_lines(input)
     for i, line in lines {
       if i > 0 {
@@ -95,7 +95,7 @@ fn stripspace_clean(input : String, strip_comments : Bool) -> String {
   if result.length() == 0 {
     return ""
   }
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for i, line in result {
     if i > 0 {
       sb.write_char('\n')
diff --git a/modules/bit/cmd/bit/subdir_clone.mbt b/modules/bit/cmd/bit/subdir_clone.mbt
index 05e25d02..045ad6d5 100644
--- a/modules/bit/cmd/bit/subdir_clone.mbt
+++ b/modules/bit/cmd/bit/subdir_clone.mbt
@@ -87,7 +87,7 @@ async fn subdir_clone(
   )
   let fs = OsFs::new()
   let target_existed = fs.is_dir(target)
-  let local_root = match @sys.get_env_var("GIT_SHIM_CWD") {
+  let local_root = match @env.get_env_var("GIT_SHIM_CWD") {
     Some(dir) => dir
     None => root
   }
diff --git a/modules/bit/cmd/bit/submodule.mbt b/modules/bit/cmd/bit/submodule.mbt
index b0b6c87e..561091c8 100644
--- a/modules/bit/cmd/bit/submodule.mbt
+++ b/modules/bit/cmd/bit/submodule.mbt
@@ -75,7 +75,7 @@ async fn show_submodule_usage_stderr() -> Unit raise Error {
 
 ///|
 fn resolve_submodule_root() -> String {
-  match @sys.get_env_var("GIT_SHIM_CWD") {
+  match @env.get_env_var("GIT_SHIM_CWD") {
     Some(dir) =>
       if is_bare_repo_dir(dir) {
         dir
@@ -83,7 +83,7 @@ fn resolve_submodule_root() -> String {
         find_repo_root(dir).unwrap_or(dir)
       }
     None =>
-      match @sys.get_env_var("GIT_SHIM_PWD") {
+      match @env.get_env_var("GIT_SHIM_PWD") {
         Some(dir) =>
           if is_bare_repo_dir(dir) {
             dir
@@ -91,7 +91,7 @@ fn resolve_submodule_root() -> String {
             find_repo_root(dir).unwrap_or(dir)
           }
         None =>
-          match @sys.get_env_var("PWD") {
+          match @env.get_env_var("PWD") {
             Some(dir) =>
               match find_repo_root(dir) {
                 Some(root) => root
@@ -113,14 +113,14 @@ fn resolve_submodule_root() -> String {
 
 ///|
 async fn handle_submodule(args : Array[String]) -> Unit raise Error {
-  let raw_root = match @sys.get_env_var("GIT_WORK_TREE") {
+  let raw_root = match @env.get_env_var("GIT_WORK_TREE") {
     Some(path) => path
     None => resolve_submodule_root()
   }
   let fs = OsFs::new()
   let rfs : &@bitcore.RepoFileSystem = fs
   let root = normalize_path(raw_root)
-  let raw_git_dir = match @sys.get_env_var("GIT_DIR") {
+  let raw_git_dir = match @env.get_env_var("GIT_DIR") {
     Some(path) => path
     None => raw_root + "/.git"
   }
@@ -324,7 +324,7 @@ fn submodule_expand_template_dir(path : String) -> String {
   if !path.has_prefix("~/") {
     return path
   }
-  match @sys.get_env_var("HOME") {
+  match @env.get_env_var("HOME") {
     Some(home) =>
       home + String::unsafe_substring(path, start=1, end=path.length())
     None => path
@@ -333,7 +333,7 @@ fn submodule_expand_template_dir(path : String) -> String {
 
 ///|
 fn submodule_add_template_dir(fs : OsFs) -> String? {
-  match @sys.get_env_var("GIT_TEMPLATE_DIR") {
+  match @env.get_env_var("GIT_TEMPLATE_DIR") {
     Some(path) => Some(submodule_expand_template_dir(path))
     None => {
       let rfs : &@bitcore.RepoFileSystem = fs
@@ -1782,12 +1782,12 @@ fn submodule_status_exact_ref_label(
 
 ///|
 fn submodule_cwd_prefix(root : String) -> String {
-  let cwd_abs = match @sys.get_env_var("GIT_SHIM_CWD") {
+  let cwd_abs = match @env.get_env_var("GIT_SHIM_CWD") {
     Some(v) => v
     None =>
-      match @sys.get_env_var("GIT_SHIM_PWD") {
+      match @env.get_env_var("GIT_SHIM_PWD") {
         Some(v) => v
-        None => @sys.get_env_var("PWD").unwrap_or(root)
+        None => @env.get_env_var("PWD").unwrap_or(root)
       }
   }
   let raw_cwd_prefix = rev_parse_show_prefix(root, cwd_abs)
diff --git a/modules/bit/cmd/bit/submodule_wbtest.mbt b/modules/bit/cmd/bit/submodule_wbtest.mbt
index be943816..f48ae4ba 100644
--- a/modules/bit/cmd/bit/submodule_wbtest.mbt
+++ b/modules/bit/cmd/bit/submodule_wbtest.mbt
@@ -58,8 +58,8 @@ async fn submodule_wbtest_git_stderr(
 ///|
 fn submodule_wbtest_restore_env(name : String, value : String?) -> Unit {
   match value {
-    Some(v) => @sys.set_env_var(name, v)
-    None => @sys.unset_env_var(name)
+    Some(v) => @env.set_env_var(name, v)
+    None => @env.unset_env_var(name)
   }
 }
 
@@ -130,8 +130,8 @@ async fn submodule_wbtest_setup_deinit_repo(
     "config", "user.email", "test@example.com",
   ])
 
-  let prev_allow_protocol = @sys.get_env_var("GIT_ALLOW_PROTOCOL")
-  @sys.set_env_var("GIT_ALLOW_PROTOCOL", "file")
+  let prev_allow_protocol = @env.get_env_var("GIT_ALLOW_PROTOCOL")
+  @env.set_env_var("GIT_ALLOW_PROTOCOL", "file")
   submodule_wbtest_run_git(super_dir, ["submodule", "add", "./../init", "init"])
   submodule_wbtest_restore_env("GIT_ALLOW_PROTOCOL", prev_allow_protocol)
   super_dir
@@ -175,7 +175,7 @@ async test "submodule absorbgitdirs: embedded repo migrates and update reuses mo
     get_current_timestamp().to_string()
   ignore(@process.run("rm", ["-rf", root], inherit_env=true))
   fs.mkdir_p(root)
-  let prev_allow_protocol = @sys.get_env_var("GIT_ALLOW_PROTOCOL")
+  let prev_allow_protocol = @env.get_env_var("GIT_ALLOW_PROTOCOL")
   submodule_wbtest_run_git(root, ["init", "--initial-branch=main", "-q", "."])
   submodule_wbtest_run_git(root, ["config", "user.name", "Test User"])
   submodule_wbtest_run_git(root, ["config", "user.email", "test@example.com"])
@@ -188,7 +188,7 @@ async test "submodule absorbgitdirs: embedded repo migrates and update reuses mo
   submodule_wbtest_run_git(root + "/sub1", ["add", "a"])
   submodule_wbtest_run_git(root + "/sub1", ["commit", "-q", "-m", "initial"])
 
-  @sys.set_env_var("GIT_ALLOW_PROTOCOL", "file")
+  @env.set_env_var("GIT_ALLOW_PROTOCOL", "file")
   let (add_code, add_stderr) = submodule_wbtest_collect_shim_git_stderr(root, [
     "submodule", "add", "./sub1",
   ])
@@ -232,7 +232,7 @@ async test "submodule add: relative local url works from absorbed submodule root
     get_current_timestamp().to_string()
   ignore(@process.run("rm", ["-rf", root], inherit_env=true))
   fs.mkdir_p(root)
-  let prev_allow_protocol = @sys.get_env_var("GIT_ALLOW_PROTOCOL")
+  let prev_allow_protocol = @env.get_env_var("GIT_ALLOW_PROTOCOL")
   submodule_wbtest_run_git(root, ["init", "--initial-branch=main", "-q", "."])
   submodule_wbtest_run_git(root, ["config", "user.name", "Test User"])
   submodule_wbtest_run_git(root, ["config", "user.email", "test@example.com"])
@@ -245,7 +245,7 @@ async test "submodule add: relative local url works from absorbed submodule root
   submodule_wbtest_run_git(root + "/sub1", ["add", "a"])
   submodule_wbtest_run_git(root + "/sub1", ["commit", "-q", "-m", "initial"])
 
-  @sys.set_env_var("GIT_ALLOW_PROTOCOL", "file")
+  @env.set_env_var("GIT_ALLOW_PROTOCOL", "file")
   submodule_wbtest_run_shim_git(root, ["submodule", "add", "./sub1"])
   submodule_wbtest_run_git(root, ["commit", "-q", "-am", "superproject"])
   let (absorb_code, _absorb_stderr) = submodule_wbtest_collect_shim_git_stderr(
@@ -560,8 +560,8 @@ async test "submodule update --remote: moved source fails until set-url" {
   submodule_wbtest_run_git(super_dir, [
     "config", "user.email", "test@example.com",
   ])
-  let prev_allow_protocol = @sys.get_env_var("GIT_ALLOW_PROTOCOL")
-  @sys.set_env_var("GIT_ALLOW_PROTOCOL", "file")
+  let prev_allow_protocol = @env.get_env_var("GIT_ALLOW_PROTOCOL")
+  @env.set_env_var("GIT_ALLOW_PROTOCOL", "file")
   submodule_wbtest_run_git(super_dir, ["submodule", "add", "../source"])
   submodule_wbtest_run_git(super_dir, ["commit", "-q", "-am", "add submodule"])
 
@@ -610,10 +610,10 @@ async test "submodule add: template dir is read from global config" {
   fs.mkdir_p(root + "/home")
   let global_config = root + "/home/.gitconfig"
   fs.write_string(global_config, "[init]\n\ttemplateDir = ~/templates\n")
-  let prev_home = @sys.get_env_var("HOME")
-  let prev_global = @sys.get_env_var("GIT_CONFIG_GLOBAL")
-  @sys.set_env_var("HOME", root + "/home")
-  @sys.set_env_var("GIT_CONFIG_GLOBAL", global_config)
+  let prev_home = @env.get_env_var("HOME")
+  let prev_global = @env.get_env_var("GIT_CONFIG_GLOBAL")
+  @env.set_env_var("HOME", root + "/home")
+  @env.set_env_var("GIT_CONFIG_GLOBAL", global_config)
   let actual = submodule_add_template_dir(fs)
   submodule_wbtest_restore_env("HOME", prev_home)
   submodule_wbtest_restore_env("GIT_CONFIG_GLOBAL", prev_global)
@@ -666,8 +666,8 @@ async test "submodule add: template hook keeps executable bit" {
   fs.write_string(hook_path, "#!/bin/sh\nexit 0\n")
   let chmod_code = @process.run("chmod", ["+x", hook_path], inherit_env=true)
   @test.assert_eq(chmod_code, 0)
-  let prev_template_dir = @sys.get_env_var("GIT_TEMPLATE_DIR")
-  @sys.set_env_var("GIT_TEMPLATE_DIR", template_dir)
+  let prev_template_dir = @env.get_env_var("GIT_TEMPLATE_DIR")
+  @env.set_env_var("GIT_TEMPLATE_DIR", template_dir)
   @bitlib.init_repo(fs, super_git_dir, bare=true)
   submodule_init_modules_repo(fs, super_git_dir, modules_dir)
   submodule_wbtest_restore_env("GIT_TEMPLATE_DIR", prev_template_dir)
@@ -1258,8 +1258,8 @@ async test "submodule status: ignores config-only entries" {
     "config", "user.email", "test@example.com",
   ])
 
-  let prev_allow_protocol = @sys.get_env_var("GIT_ALLOW_PROTOCOL")
-  @sys.set_env_var("GIT_ALLOW_PROTOCOL", "file")
+  let prev_allow_protocol = @env.get_env_var("GIT_ALLOW_PROTOCOL")
+  @env.set_env_var("GIT_ALLOW_PROTOCOL", "file")
   submodule_wbtest_run_git(super_dir, ["submodule", "add", "./../init", "init"])
   submodule_wbtest_run_git(super_dir, ["commit", "-qam", "initial"])
   submodule_wbtest_restore_env("GIT_ALLOW_PROTOCOL", prev_allow_protocol)
@@ -1401,8 +1401,8 @@ async test "submodule deinit: unregisters config and removes worktree gitfile" {
     "config", "user.email", "test@example.com",
   ])
 
-  let prev_allow_protocol = @sys.get_env_var("GIT_ALLOW_PROTOCOL")
-  @sys.set_env_var("GIT_ALLOW_PROTOCOL", "file")
+  let prev_allow_protocol = @env.get_env_var("GIT_ALLOW_PROTOCOL")
+  @env.set_env_var("GIT_ALLOW_PROTOCOL", "file")
   submodule_wbtest_run_git(super_dir, ["submodule", "add", "./../init", "init"])
   submodule_wbtest_restore_env("GIT_ALLOW_PROTOCOL", prev_allow_protocol)
 
@@ -1451,8 +1451,8 @@ async test "submodule deinit: missing worktree path is recreated as empty direct
     "config", "user.email", "test@example.com",
   ])
 
-  let prev_allow_protocol = @sys.get_env_var("GIT_ALLOW_PROTOCOL")
-  @sys.set_env_var("GIT_ALLOW_PROTOCOL", "file")
+  let prev_allow_protocol = @env.get_env_var("GIT_ALLOW_PROTOCOL")
+  @env.set_env_var("GIT_ALLOW_PROTOCOL", "file")
   submodule_wbtest_run_git(super_dir, ["submodule", "add", "./../init", "init"])
   submodule_wbtest_run_git(super_dir, ["commit", "-qam", "initial"])
   submodule_wbtest_restore_env("GIT_ALLOW_PROTOCOL", prev_allow_protocol)
@@ -1566,8 +1566,8 @@ async test "submodule update: recreates missing worktree before writing gitfile"
     "config", "user.email", "test@example.com",
   ])
 
-  let prev_allow_protocol = @sys.get_env_var("GIT_ALLOW_PROTOCOL")
-  @sys.set_env_var("GIT_ALLOW_PROTOCOL", "file")
+  let prev_allow_protocol = @env.get_env_var("GIT_ALLOW_PROTOCOL")
+  @env.set_env_var("GIT_ALLOW_PROTOCOL", "file")
   submodule_wbtest_run_git(super_dir, ["submodule", "add", "./../init", "init"])
   submodule_wbtest_run_git(super_dir, ["commit", "-qam", "initial"])
   submodule_wbtest_restore_env("GIT_ALLOW_PROTOCOL", prev_allow_protocol)
@@ -1611,8 +1611,8 @@ async test "submodule update: linked worktree reads shared submodule config" {
     read_submodule_config_value(fs, linked_git_dir, "init", "url") is Some(_),
   )
 
-  let prev_allow_protocol = @sys.get_env_var("GIT_ALLOW_PROTOCOL")
-  @sys.set_env_var("GIT_ALLOW_PROTOCOL", "file")
+  let prev_allow_protocol = @env.get_env_var("GIT_ALLOW_PROTOCOL")
+  @env.set_env_var("GIT_ALLOW_PROTOCOL", "file")
   submodule_wbtest_run_shim_git(linked_dir, ["submodule", "update", "--quiet"])
   submodule_wbtest_restore_env("GIT_ALLOW_PROTOCOL", prev_allow_protocol)
 
@@ -1670,8 +1670,8 @@ async test "submodule update: restores deinitialized worktree when another submo
     "config", "user.email", "test@example.com",
   ])
 
-  let prev_allow_protocol = @sys.get_env_var("GIT_ALLOW_PROTOCOL")
-  @sys.set_env_var("GIT_ALLOW_PROTOCOL", "file")
+  let prev_allow_protocol = @env.get_env_var("GIT_ALLOW_PROTOCOL")
+  @env.set_env_var("GIT_ALLOW_PROTOCOL", "file")
   submodule_wbtest_run_git(super_dir, ["submodule", "add", "./../init", "init"])
   submodule_wbtest_run_git(super_dir, [
     "submodule", "add", "./../other", "other",
@@ -2386,8 +2386,8 @@ async test "submodule sync: relative url resolves against superproject root when
     "config", "user.email", "test@example.com",
   ])
 
-  let prev_allow_protocol = @sys.get_env_var("GIT_ALLOW_PROTOCOL")
-  @sys.set_env_var("GIT_ALLOW_PROTOCOL", "file")
+  let prev_allow_protocol = @env.get_env_var("GIT_ALLOW_PROTOCOL")
+  @env.set_env_var("GIT_ALLOW_PROTOCOL", "file")
   submodule_wbtest_run_git(super_dir, [
     "submodule", "add", "../repo", "relative",
   ])
@@ -2446,8 +2446,8 @@ async test "submodule sync: relative url stays relative in config when origin ex
     "remote", "add", "origin", "../parent.git",
   ])
 
-  let prev_allow_protocol = @sys.get_env_var("GIT_ALLOW_PROTOCOL")
-  @sys.set_env_var("GIT_ALLOW_PROTOCOL", "file")
+  let prev_allow_protocol = @env.get_env_var("GIT_ALLOW_PROTOCOL")
+  @env.set_env_var("GIT_ALLOW_PROTOCOL", "file")
   submodule_wbtest_run_git(super_dir, [
     "submodule", "add", "../repo", "relative",
   ])
diff --git a/modules/bit/cmd/bit/tag.mbt b/modules/bit/cmd/bit/tag.mbt
index 24a83bdc..b3945df0 100644
--- a/modules/bit/cmd/bit/tag.mbt
+++ b/modules/bit/cmd/bit/tag.mbt
@@ -787,7 +787,7 @@ fn tag_resolve_column_mode(
 
 ///|
 fn tag_term_columns() -> Int {
-  match @sys.get_env_var("COLUMNS") {
+  match @env.get_env_var("COLUMNS") {
     Some(raw) => {
       let parsed = @string.parse_int(raw) catch { _ => 80 }
       if parsed > 1 {
@@ -969,7 +969,7 @@ fn tag_apply_trailers(message : String, trailers : Array[String]) -> String {
   } else {
     true
   }
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   result.write_string(message)
   if !message.has_suffix("\n") {
     result.write_char('\n')
@@ -1286,7 +1286,7 @@ async fn tag_edit_message(
 
 ///|
 fn tag_edit_buffer_template(initial_message : String?) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   match initial_message {
     Some(message) =>
       if message.length() > 0 {
diff --git a/modules/bit/cmd/bit/tag_wbtest.mbt b/modules/bit/cmd/bit/tag_wbtest.mbt
index cb783ccc..87a5d8ae 100644
--- a/modules/bit/cmd/bit/tag_wbtest.mbt
+++ b/modules/bit/cmd/bit/tag_wbtest.mbt
@@ -108,10 +108,10 @@ async test "tag: -s stores signature block via configured signing program" {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_DIR", prev_git_dir)
@@ -128,10 +128,10 @@ async test "tag: -s stores signature block via configured signing program" {
   grep_test_run_git(repo_dir, ["add", "tracked.txt"])
   grep_test_run_git(repo_dir, ["commit", "-q", "-m", "initial"])
 
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
 
   handle_tag(["-s", "-m", "signed tag", "v1"]) catch {
     err => fail("handle_tag failed: \{err}")
diff --git a/modules/bit/cmd/bit/tree.mbt b/modules/bit/cmd/bit/tree.mbt
index a2d499f6..b74a2bfb 100644
--- a/modules/bit/cmd/bit/tree.mbt
+++ b/modules/bit/cmd/bit/tree.mbt
@@ -34,14 +34,14 @@ fn print_cat_usage() -> Unit {
 
 ///|
 fn temp_root_dir() -> String {
-  match @sys.get_env_var("TMPDIR") {
+  match @env.get_env_var("TMPDIR") {
     Some(dir) =>
       if dir.has_suffix("/") && dir.length() > 1 {
         string_slice_to(dir, dir.length() - 1)
       } else {
         dir
       }
-    None => @sys.get_env_var("TMP").unwrap_or("/tmp")
+    None => @env.get_env_var("TMP").unwrap_or("/tmp")
   }
 }
 
diff --git a/modules/bit/cmd/bit/unpack_file.mbt b/modules/bit/cmd/bit/unpack_file.mbt
index 0db63794..65f1ef1e 100644
--- a/modules/bit/cmd/bit/unpack_file.mbt
+++ b/modules/bit/cmd/bit/unpack_file.mbt
@@ -109,14 +109,14 @@ fn unpack_file_find_object(
 
 ///|
 fn unpack_file_make_temp(fs : OsFs) -> String {
-  let base_dir = match @sys.get_env_var("TMPDIR") {
+  let base_dir = match @env.get_env_var("TMPDIR") {
     Some(dir) =>
       if dir.has_suffix("/") && dir.length() > 1 {
         String::unsafe_substring(dir, start=0, end=dir.length() - 1)
       } else {
         dir
       }
-    None => @sys.get_env_var("TMP").unwrap_or("/tmp")
+    None => @env.get_env_var("TMP").unwrap_or("/tmp")
   }
   let ts = get_current_timestamp()
   let base = base_dir + "/git-blob-" + "\{ts}"
diff --git a/modules/bit/cmd/bit/update_index_wbtest.mbt b/modules/bit/cmd/bit/update_index_wbtest.mbt
index f3278bae..68de9905 100644
--- a/modules/bit/cmd/bit/update_index_wbtest.mbt
+++ b/modules/bit/cmd/bit/update_index_wbtest.mbt
@@ -128,8 +128,8 @@ async fn update_index_wbtest_run_sparse_checkout_shim(
 ///|
 fn update_index_wbtest_restore_cwd(prev : String?) -> Unit {
   match prev {
-    Some(value) => @sys.set_env_var("GIT_SHIM_CWD", value)
-    None => @sys.unset_env_var("GIT_SHIM_CWD")
+    Some(value) => @env.set_env_var("GIT_SHIM_CWD", value)
+    None => @env.unset_env_var("GIT_SHIM_CWD")
   }
 }
 
@@ -157,8 +157,8 @@ async test "update-index: assume-unchanged works for sparse missing path" {
   update_index_wbtest_run_git(repo_dir, ["add", "a", "b", "dir/c"])
   update_index_wbtest_run_git(repo_dir, ["commit", "-q", "-m", "initial"])
 
-  let prev_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
+  let prev_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
   update_index_wbtest_run_sparse_checkout_shim(repo_dir, ["init", "--no-cone"])
   update_index_wbtest_run_sparse_checkout_shim(repo_dir, [
     "set", "/*", "!b", "!/*/",
diff --git a/modules/bit/cmd/bit/update_ref.mbt b/modules/bit/cmd/bit/update_ref.mbt
index 3e9ad2a5..ed893e74 100644
--- a/modules/bit/cmd/bit/update_ref.mbt
+++ b/modules/bit/cmd/bit/update_ref.mbt
@@ -794,10 +794,10 @@ fn get_author_info(
   let mut name = "Unknown"
   let mut email = "unknown@unknown"
   // Check environment variables first
-  if @sys.get_env_var("GIT_COMMITTER_NAME") is Some(n) {
+  if @env.get_env_var("GIT_COMMITTER_NAME") is Some(n) {
     name = n
   }
-  if @sys.get_env_var("GIT_COMMITTER_EMAIL") is Some(e) {
+  if @env.get_env_var("GIT_COMMITTER_EMAIL") is Some(e) {
     email = e
   }
   // If not in env, try config
@@ -1083,7 +1083,7 @@ async fn update_ref_parse_stdin_z(
   let mut create_reflog = create_reflog_init
   // Split into NUL-terminated records; the trailing NUL closes the last field.
   let records : Array[String] = []
-  let cur = StringBuilder::new()
+  let cur = StringBuilder()
   let mut pending = false
   for ch in input {
     if ch == '\u{0}' {
@@ -1551,7 +1551,7 @@ fn reftable_pad_hex12(value : UInt64) -> String {
     b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7', b'8', b'9', b'a', b'b', b'c',
     b'd', b'e', b'f',
   ]
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for i = 11; i >= 0; i = i - 1 {
     let shift = i * 4
     let nibble = ((value >> shift.to_uint64().to_int()) & 0xfUL).to_int()
diff --git a/modules/bit/cmd/bit/upload_pack.mbt b/modules/bit/cmd/bit/upload_pack.mbt
index 7c43735a..24fa9038 100644
--- a/modules/bit/cmd/bit/upload_pack.mbt
+++ b/modules/bit/cmd/bit/upload_pack.mbt
@@ -79,7 +79,7 @@ async fn handle_upload_pack(args : Array[String]) -> Unit raise Error {
     }
     if advertise {
       let proto = @bitlib.get_protocol_version()
-      let agent = @sys.get_env_var("GIT_USER_AGENT").unwrap_or("git/moonbit")
+      let agent = @env.get_env_var("GIT_USER_AGENT").unwrap_or("git/moonbit")
       let out = @bitlib.build_upload_pack_advertisement(
         fs,
         root,
diff --git a/modules/bit/cmd/bit/var.mbt b/modules/bit/cmd/bit/var.mbt
index a9fa98c1..eced8634 100644
--- a/modules/bit/cmd/bit/var.mbt
+++ b/modules/bit/cmd/bit/var.mbt
@@ -78,7 +78,7 @@ fn var_default_branch() -> String {
 
 ///|
 fn var_editor() -> String {
-  match @sys.get_env_var("GIT_EDITOR") {
+  match @env.get_env_var("GIT_EDITOR") {
     Some(e) => return e
     None => ()
   }
@@ -87,11 +87,11 @@ fn var_editor() -> String {
     Some(e) => return e
     None => ()
   }
-  match @sys.get_env_var("VISUAL") {
+  match @env.get_env_var("VISUAL") {
     Some(e) => return e
     None => ()
   }
-  match @sys.get_env_var("EDITOR") {
+  match @env.get_env_var("EDITOR") {
     Some(e) => return e
     None => ()
   }
@@ -100,7 +100,7 @@ fn var_editor() -> String {
 
 ///|
 fn var_pager() -> String {
-  match @sys.get_env_var("GIT_PAGER") {
+  match @env.get_env_var("GIT_PAGER") {
     Some(p) => return p
     None => ()
   }
@@ -109,7 +109,7 @@ fn var_pager() -> String {
     Some(p) => return p
     None => ()
   }
-  match @sys.get_env_var("PAGER") {
+  match @env.get_env_var("PAGER") {
     Some(p) => return p
     None => ()
   }
diff --git a/modules/bit/cmd/bit/verify_wbtest.mbt b/modules/bit/cmd/bit/verify_wbtest.mbt
index 26e5eda2..dd9de565 100644
--- a/modules/bit/cmd/bit/verify_wbtest.mbt
+++ b/modules/bit/cmd/bit/verify_wbtest.mbt
@@ -82,10 +82,10 @@ async test "verify: verify-commit validates ssh signatures via native ssh-keygen
   cleanup_tree(fs, root)
   fs.mkdir_p(root)
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_DIR", prev_git_dir)
@@ -106,10 +106,10 @@ async test "verify: verify-commit validates ssh signatures via native ssh-keygen
   fs.write_string(root + "/signed.txt", "signed\n")
   commit_wbtest_run_git(root, ["add", "signed.txt"])
 
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_PWD", root)
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_PWD", root)
 
   handle_commit(["-q", "-S", "-m", "signed ssh"]) catch {
     err => fail("handle_commit failed: \{err}")
@@ -133,12 +133,12 @@ async test "verify: ssh verifier uses commit timestamp for key validity" {
   fs.mkdir_p(root)
   let git_dir = root + "/.git"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  let prev_author_date = @sys.get_env_var("GIT_AUTHOR_DATE")
-  let prev_committer_date = @sys.get_env_var("GIT_COMMITTER_DATE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  let prev_author_date = @env.get_env_var("GIT_AUTHOR_DATE")
+  let prev_committer_date = @env.get_env_var("GIT_COMMITTER_DATE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_DIR", prev_git_dir)
@@ -157,12 +157,12 @@ async test "verify: ssh verifier uses commit timestamp for key validity" {
     "config", "gpg.ssh.allowedSignersFile", allowed_signers,
   ])
 
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_PWD", root)
-  @sys.set_env_var("GIT_AUTHOR_DATE", "1112912001 +0000")
-  @sys.set_env_var("GIT_COMMITTER_DATE", "1112912001 +0000")
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_PWD", root)
+  @env.set_env_var("GIT_AUTHOR_DATE", "1112912001 +0000")
+  @env.set_env_var("GIT_COMMITTER_DATE", "1112912001 +0000")
 
   commit_wbtest_run_git(root, ["config", "user.signingkey", valid_key])
   fs.write_string(root + "/signed.txt", "valid\n")
@@ -235,10 +235,10 @@ async test "verify: verify-tag validates ssh signatures via native ssh-keygen" {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_DIR", prev_git_dir)
@@ -261,10 +261,10 @@ async test "verify: verify-tag validates ssh signatures via native ssh-keygen" {
   grep_test_run_git(repo_dir, ["add", "tracked.txt"])
   grep_test_run_git(repo_dir, ["commit", "-q", "-m", "initial"])
 
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
 
   handle_tag(["-s", "-m", "signed tag", "v1"]) catch {
     err => fail("handle_tag failed: \{err}")
@@ -289,11 +289,11 @@ async test "verify: ssh verifier uses tagger timestamp for key validity" {
   let repo_dir = root + "/repo"
   let git_dir = repo_dir + "/.git"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
-  let prev_committer_date = @sys.get_env_var("GIT_COMMITTER_DATE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
+  let prev_committer_date = @env.get_env_var("GIT_COMMITTER_DATE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_DIR", prev_git_dir)
@@ -316,11 +316,11 @@ async test "verify: ssh verifier uses tagger timestamp for key validity" {
   grep_test_run_git(repo_dir, ["add", "tracked.txt"])
   grep_test_run_git(repo_dir, ["commit", "-q", "-m", "initial"])
 
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_COMMITTER_DATE", "1112912001 +0000")
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_COMMITTER_DATE", "1112912001 +0000")
 
   grep_test_run_git(repo_dir, ["config", "user.signingkey", valid_key])
   handle_tag(["-s", "-m", "signed tag", "v-valid"]) catch {
@@ -388,10 +388,10 @@ async test "verify: verify-commit uses external openpgp verifier" {
   cleanup_tree(fs, root)
   fs.mkdir_p(root)
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_DIR", prev_git_dir)
@@ -408,10 +408,10 @@ async test "verify: verify-commit uses external openpgp verifier" {
   fs.write_string(root + "/signed.txt", "signed\n")
   commit_wbtest_run_git(root, ["add", "signed.txt"])
 
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_PWD", root)
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_PWD", root)
 
   handle_commit(["-q", "-S", "-m", "signed gpg"]) catch {
     err => fail("handle_commit failed: \{err}")
@@ -435,10 +435,10 @@ async test "verify: verify-tag uses external openpgp verifier" {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_DIR", prev_git_dir)
@@ -457,10 +457,10 @@ async test "verify: verify-tag uses external openpgp verifier" {
   grep_test_run_git(repo_dir, ["add", "tracked.txt"])
   grep_test_run_git(repo_dir, ["commit", "-q", "-m", "initial"])
 
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
 
   handle_tag(["-s", "-m", "signed tag", "v1"]) catch {
     err => fail("handle_tag failed: \{err}")
diff --git a/modules/bit/cmd/bit/web_browse.mbt b/modules/bit/cmd/bit/web_browse.mbt
index d9a4b4d7..f3b78c99 100644
--- a/modules/bit/cmd/bit/web_browse.mbt
+++ b/modules/bit/cmd/bit/web_browse.mbt
@@ -49,12 +49,12 @@ async fn handle_web_browse(args : Array[String]) -> Unit raise Error {
 ///|
 fn web_browse_detect_browser() -> String {
   // Check GIT_BROWSER env var first
-  match @sys.get_env_var("GIT_BROWSER") {
+  match @env.get_env_var("GIT_BROWSER") {
     Some(b) => if b.length() > 0 { return b }
     None => ()
   }
   // Check BROWSER env var
-  match @sys.get_env_var("BROWSER") {
+  match @env.get_env_var("BROWSER") {
     Some(b) => if b.length() > 0 { return b }
     None => ()
   }
diff --git a/modules/bit/cmd/bit/worktree.mbt b/modules/bit/cmd/bit/worktree.mbt
index 7231709f..cfa5af9b 100644
--- a/modules/bit/cmd/bit/worktree.mbt
+++ b/modules/bit/cmd/bit/worktree.mbt
@@ -4,9 +4,9 @@
 /// Get absolute work root path for worktree operations
 fn get_absolute_work_root() -> String {
   let root = get_work_root()
-  let base = match @sys.get_env_var("GIT_SHIM_PWD") {
+  let base = match @env.get_env_var("GIT_SHIM_PWD") {
     Some(pwd) => Some(pwd)
-    None => @sys.get_env_var("PWD")
+    None => @env.get_env_var("PWD")
   }
   if root == "." {
     // Use GIT_SHIM_PWD or PWD if available
@@ -31,17 +31,17 @@ fn get_absolute_worktree_cwd() -> String {
       normalize_path(get_absolute_work_root() + "/" + path)
     }
   }
-  if @sys.get_env_var("GIT_SHIM_CALLER_PWD") is Some(_) {
-    return match @sys.get_env_var("GIT_SHIM_CWD") {
+  if @env.get_env_var("GIT_SHIM_CALLER_PWD") is Some(_) {
+    return match @env.get_env_var("GIT_SHIM_CWD") {
       Some(path) => from_hint(path)
       None =>
-        match @sys.get_env_var("GIT_SHIM_PWD") {
+        match @env.get_env_var("GIT_SHIM_PWD") {
           Some(path) => from_hint(path)
           None => get_absolute_work_root()
         }
     }
   }
-  match @sys.get_env_var("PWD") {
+  match @env.get_env_var("PWD") {
     Some(path) => from_hint(path)
     None =>
       match @env.current_dir() {
@@ -102,7 +102,7 @@ fn worktree_quote_path(path : String) -> String {
   if !needs_quote {
     return path
   }
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_char('"')
   for b in encoded {
     let v = b.to_int()
@@ -619,7 +619,7 @@ async fn handle_worktree_list(args : Array[String]) -> Unit raise Error {
 
 ///|
 fn escape_lock_reason(reason : String) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for c in reason {
     match c {
       '\n' => {
diff --git a/modules/bit/cmd/bit/worktree_wbtest.mbt b/modules/bit/cmd/bit/worktree_wbtest.mbt
index 6226356f..40410ee6 100644
--- a/modules/bit/cmd/bit/worktree_wbtest.mbt
+++ b/modules/bit/cmd/bit/worktree_wbtest.mbt
@@ -6,7 +6,7 @@ let worktree_wbtest_shim_lock : @async.Semaphore = @async.Semaphore(
 
 ///|
 fn worktree_wbtest_current_shim_cwd() -> String {
-  @sys.get_env_var("GIT_SHIM_CWD").unwrap_or(".")
+  @env.get_env_var("GIT_SHIM_CWD").unwrap_or(".")
 }
 
 ///|
@@ -137,11 +137,11 @@ async fn worktree_wbtest_case_dash_shorthand() -> Unit raise Error {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -156,11 +156,11 @@ async fn worktree_wbtest_case_dash_shorthand() -> Unit raise Error {
   add_test_run_git(repo_dir, ["checkout", "-q", "main"])
   fs.write_string(repo_dir + "/.git/bit-prev-checkout", "newbranch\n")
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   worktree_wbtest_run_shim_git(["worktree", "add", "short-hand", "-"])
 
@@ -190,11 +190,11 @@ async fn worktree_wbtest_case_relative_path_from_cwd() -> Unit raise Error {
   let repo_dir = root + "/repo"
   let sub_dir = repo_dir + "/sub"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -204,11 +204,11 @@ async fn worktree_wbtest_case_relative_path_from_cwd() -> Unit raise Error {
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
   fs.mkdir_p(sub_dir)
 
-  @sys.set_env_var("GIT_SHIM_CWD", sub_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", sub_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", sub_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", sub_dir)
+  @env.set_env_var("GIT_SHIM_PWD", sub_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", sub_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   worktree_wbtest_run_shim_git(["worktree", "add", "--detach", "here", "main"])
 
@@ -233,11 +233,11 @@ async fn worktree_wbtest_case_lock_reason() -> Unit raise Error {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -246,11 +246,11 @@ async fn worktree_wbtest_case_lock_reason() -> Unit raise Error {
   add_test_run_git(repo_dir, ["add", "init.t"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   worktree_wbtest_run_shim_git([
     "worktree", "add", "--detach", "--lock", "--reason", "why not", "here-with-lock",
@@ -282,11 +282,11 @@ async fn worktree_wbtest_case_detach_defaults_to_head() -> Unit raise Error {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -295,11 +295,11 @@ async fn worktree_wbtest_case_detach_defaults_to_head() -> Unit raise Error {
   add_test_run_git(repo_dir, ["add", "init.t"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   let expected_head = add_test_git_stdout(repo_dir, ["rev-parse", "HEAD"])
   worktree_wbtest_run_shim_git(["worktree", "add", "--detach", "detached-here"])
@@ -327,11 +327,11 @@ async fn worktree_wbtest_case_explicit_head_creates_detached_worktree() -> Unit
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -340,11 +340,11 @@ async fn worktree_wbtest_case_explicit_head_creates_detached_worktree() -> Unit
   add_test_run_git(repo_dir, ["add", "init.t"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   let expected_head = add_test_git_stdout(repo_dir, ["rev-parse", "HEAD"])
   worktree_wbtest_run_shim_git(["worktree", "add", "head-explicit", "HEAD"])
@@ -379,11 +379,11 @@ async fn worktree_wbtest_case_preserves_executable_mode() -> Unit raise Error {
   let repo_dir = root + "/repo"
   let worktree_dir = root + "/worker"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_SHIM_CALLER_PWD", prev_caller_pwd)
@@ -402,11 +402,11 @@ async fn worktree_wbtest_case_preserves_executable_mode() -> Unit raise Error {
   add_test_run_git(repo_dir, ["add", "hook.sh"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "base"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   worktree_wbtest_run_shim_git([
     "worktree", "add", "-b", "repro/mode", worktree_dir, "HEAD",
@@ -421,9 +421,9 @@ async fn worktree_wbtest_case_preserves_executable_mode() -> Unit raise Error {
     "",
   )
 
-  @sys.set_env_var("GIT_SHIM_CWD", worktree_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", worktree_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", worktree_dir)
+  @env.set_env_var("GIT_SHIM_CWD", worktree_dir)
+  @env.set_env_var("GIT_SHIM_PWD", worktree_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", worktree_dir)
   let (status_code, status_out, _) = worktree_wbtest_collect_shim_git([
     "status", "--porcelain",
   ])
@@ -438,9 +438,9 @@ async fn worktree_wbtest_case_preserves_executable_mode() -> Unit raise Error {
   @test.assert_eq(diff_code, 0)
   @test.assert_eq(diff_out, "")
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
   worktree_wbtest_run_shim_git(["worktree", "remove", worktree_dir])
   assert_false(fs.is_dir(worktree_dir))
 }
@@ -457,11 +457,11 @@ async fn worktree_wbtest_case_detects_mode_only_change() -> Unit raise Error {
   let repo_dir = root + "/repo"
   let worktree_dir = root + "/worker"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_SHIM_CALLER_PWD", prev_caller_pwd)
@@ -480,11 +480,11 @@ async fn worktree_wbtest_case_detects_mode_only_change() -> Unit raise Error {
   add_test_run_git(repo_dir, ["add", "hook.sh"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "base"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
   worktree_wbtest_run_shim_git([
     "worktree", "add", "-b", "repro/mode-only", worktree_dir, "HEAD",
   ])
@@ -493,9 +493,9 @@ async fn worktree_wbtest_case_detects_mode_only_change() -> Unit raise Error {
     @process.run("chmod", ["-x", worktree_dir + "/hook.sh"], inherit_env=true),
     0,
   )
-  @sys.set_env_var("GIT_SHIM_CWD", worktree_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", worktree_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", worktree_dir)
+  @env.set_env_var("GIT_SHIM_CWD", worktree_dir)
+  @env.set_env_var("GIT_SHIM_PWD", worktree_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", worktree_dir)
   let (status_code, status_out, _) = worktree_wbtest_collect_shim_git([
     "status", "--porcelain",
   ])
@@ -504,9 +504,9 @@ async fn worktree_wbtest_case_detects_mode_only_change() -> Unit raise Error {
   let (diff_code, _, _) = worktree_wbtest_collect_shim_git(["diff", "--quiet"])
   @test.assert_eq(diff_code, 1)
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
   let (remove_code, _, _) = worktree_wbtest_collect_shim_git([
     "worktree", "remove", worktree_dir,
   ])
@@ -532,11 +532,11 @@ async fn worktree_wbtest_case_symlink_stays_clean() -> Unit raise Error {
   let repo_dir = root + "/repo"
   let worktree_dir = root + "/worker"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_SHIM_CALLER_PWD", prev_caller_pwd)
@@ -551,11 +551,11 @@ async fn worktree_wbtest_case_symlink_stays_clean() -> Unit raise Error {
   add_test_run_git(repo_dir, ["add", "hook.sh", "hook-link"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "base"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
   worktree_wbtest_run_shim_git([
     "worktree", "add", "-b", "repro/symlink", worktree_dir, "HEAD",
   ])
@@ -568,9 +568,9 @@ async fn worktree_wbtest_case_symlink_stays_clean() -> Unit raise Error {
     add_test_git_stdout(worktree_dir, ["status", "--porcelain"]),
     "",
   )
-  @sys.set_env_var("GIT_SHIM_CWD", worktree_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", worktree_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", worktree_dir)
+  @env.set_env_var("GIT_SHIM_CWD", worktree_dir)
+  @env.set_env_var("GIT_SHIM_PWD", worktree_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", worktree_dir)
   let (status_code, status_out, _) = worktree_wbtest_collect_shim_git([
     "status", "--porcelain",
   ])
@@ -579,9 +579,9 @@ async fn worktree_wbtest_case_symlink_stays_clean() -> Unit raise Error {
   let (diff_code, _, _) = worktree_wbtest_collect_shim_git(["diff", "--quiet"])
   @test.assert_eq(diff_code, 0)
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
   worktree_wbtest_run_shim_git(["worktree", "remove", worktree_dir])
   assert_false(fs.is_dir(worktree_dir))
 }
@@ -598,11 +598,11 @@ async fn worktree_wbtest_case_no_checkout_leaves_files_absent() -> Unit raise Er
   let repo_dir = root + "/repo"
   let worktree_dir = root + "/worker-no-checkout"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
   defer add_test_restore_env("GIT_SHIM_CWD", prev_shim_cwd)
   defer add_test_restore_env("GIT_SHIM_PWD", prev_shim_pwd)
   defer add_test_restore_env("GIT_SHIM_CALLER_PWD", prev_caller_pwd)
@@ -616,11 +616,11 @@ async fn worktree_wbtest_case_no_checkout_leaves_files_absent() -> Unit raise Er
   add_test_run_git(repo_dir, ["add", "init.t"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "base"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
   worktree_wbtest_run_shim_git([
     "worktree", "add", "--no-checkout", "-b", "repro/no-checkout", worktree_dir,
     "HEAD",
@@ -637,9 +637,9 @@ async fn worktree_wbtest_case_no_checkout_leaves_files_absent() -> Unit raise Er
     "main\n",
   )
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
   worktree_wbtest_run_shim_git(["worktree", "remove", worktree_dir])
 }
 
@@ -653,11 +653,11 @@ async fn worktree_wbtest_case_prune_keeps_recent_checkout() -> Unit raise Error
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -666,11 +666,11 @@ async fn worktree_wbtest_case_prune_keeps_recent_checkout() -> Unit raise Error
   add_test_run_git(repo_dir, ["add", "init.t"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   worktree_wbtest_run_shim_git(["worktree", "add", "jlm", "HEAD"])
   cleanup_tree(fs, repo_dir + "/jlm")
@@ -698,11 +698,11 @@ async fn worktree_wbtest_case_existing_branch_dwim() -> Unit raise Error {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -714,11 +714,11 @@ async fn worktree_wbtest_case_existing_branch_dwim() -> Unit raise Error {
   add_test_run_git(repo_dir, ["commit", "-q", "-a", "-m", "second"])
   add_test_run_git(repo_dir, ["branch", "dwim", "HEAD~1"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   let expected_head = add_test_git_stdout(repo_dir, ["rev-parse", "dwim"])
   worktree_wbtest_run_shim_git(["worktree", "add", "dwim"])
@@ -746,11 +746,11 @@ async fn worktree_wbtest_case_force_allows_current_branch_dwim() -> Unit raise E
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -760,11 +760,11 @@ async fn worktree_wbtest_case_force_allows_current_branch_dwim() -> Unit raise E
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
   add_test_run_git(repo_dir, ["checkout", "-q", "-b", "test-branch"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   worktree_wbtest_run_shim_git(["worktree", "add", "--force", "test-branch"])
 
@@ -794,11 +794,11 @@ async fn worktree_wbtest_case_copies_filtered_worktree_config() -> Unit raise Er
   let there4_dir = root + "/there4"
   let there5_dir = root + "/there5"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "seed"])
   add_test_run_git(seed_dir, ["config", "user.name", "Test User"])
@@ -816,17 +816,17 @@ async fn worktree_wbtest_case_copies_filtered_worktree_config() -> Unit raise Er
     "[core]\n\tbare = true\n\tworktree = /bogus\n[bogus]\n\tkey = value\n",
   )
 
-  @sys.set_env_var("GIT_SHIM_CWD", source_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", source_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", source_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", source_dir)
+  @env.set_env_var("GIT_SHIM_PWD", source_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", source_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   worktree_wbtest_run_shim_git(["worktree", "add", there4_dir, "main"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", there4_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", there4_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", there4_dir)
+  @env.set_env_var("GIT_SHIM_CWD", there4_dir)
+  @env.set_env_var("GIT_SHIM_PWD", there4_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", there4_dir)
   worktree_wbtest_run_shim_git(["worktree", "add", "--detach", there5_dir])
 
   let there4_config = decode_bytes(
@@ -864,11 +864,11 @@ async fn worktree_wbtest_case_relative_paths_option() -> Unit raise Error {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -877,11 +877,11 @@ async fn worktree_wbtest_case_relative_paths_option() -> Unit raise Error {
   add_test_run_git(repo_dir, ["add", "init.t"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   worktree_wbtest_run_shim_git([
     "worktree", "add", "--detach", "--relative-paths", "relative", "main",
@@ -917,11 +917,11 @@ async fn worktree_wbtest_case_config_relative_paths_default_and_override() -> Un
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -931,11 +931,11 @@ async fn worktree_wbtest_case_config_relative_paths_default_and_override() -> Un
   add_test_run_git(repo_dir, ["add", "init.t"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   worktree_wbtest_run_shim_git([
     "worktree", "add", "--detach", "config-relative", "main",
@@ -981,19 +981,19 @@ async fn worktree_wbtest_case_infers_orphan_without_guess_remote() -> Unit raise
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   worktree_wbtest_run_shim_git(["worktree", "add", "--no-guess-remote", "foo"])
 
@@ -1053,11 +1053,11 @@ async fn worktree_wbtest_case_guess_remote_uses_configured_remote_name() -> Unit
   let repo_dir = root + "/repo"
   let upstream_dir = root + "/upstream"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "upstream"])
@@ -1070,11 +1070,11 @@ async fn worktree_wbtest_case_guess_remote_uses_configured_remote_name() -> Unit
 
   add_test_run_git(repo_dir, ["remote", "add", "upstream", "../upstream"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   worktree_wbtest_run_shim_git(["fetch", "-q"])
   worktree_wbtest_run_shim_git(["worktree", "add", "--guess-remote", "foo"])
@@ -1112,19 +1112,19 @@ async fn worktree_wbtest_case_repair_rejects_invalid_path() -> Unit raise Error
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   let (invalid_code, _stdout, invalid_stderr) = worktree_wbtest_collect_shim_git([
       "worktree", "repair", "/notvalid",
@@ -1151,20 +1151,20 @@ async fn worktree_wbtest_case_repair_rejects_git_dir_directory() -> Unit raise E
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["init", "-q", "not-a-worktree"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   let (gitdir_code, _stdout, gitdir_stderr) = worktree_wbtest_collect_shim_git([
     "worktree", "repair", "not-a-worktree",
@@ -1190,11 +1190,11 @@ async fn worktree_wbtest_case_repair_rejects_non_repo_gitfile() -> Unit raise Er
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -1209,11 +1209,11 @@ async fn worktree_wbtest_case_repair_rejects_non_repo_gitfile() -> Unit raise Er
     "gitdir: " + repo_dir + "/not-a-repo\n",
   )
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   let (nonrepo_code, _stdout, nonrepo_stderr) = worktree_wbtest_collect_shim_git([
       "worktree", "repair", "side",
@@ -1242,11 +1242,11 @@ async fn worktree_wbtest_case_list_shows_main_and_linked() -> Unit raise Error {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -1255,11 +1255,11 @@ async fn worktree_wbtest_case_list_shows_main_and_linked() -> Unit raise Error {
   add_test_run_git(repo_dir, ["add", "init.t"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   worktree_wbtest_run_shim_git([
     "worktree", "add", "--detach", "linked1", "main",
@@ -1303,11 +1303,11 @@ async fn worktree_wbtest_case_remove_linked_worktree() -> Unit raise Error {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -1316,11 +1316,11 @@ async fn worktree_wbtest_case_remove_linked_worktree() -> Unit raise Error {
   add_test_run_git(repo_dir, ["add", "init.t"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   worktree_wbtest_run_shim_git([
     "worktree", "add", "--detach", "to-remove", "main",
@@ -1350,11 +1350,11 @@ async fn worktree_wbtest_case_remove_locked_worktree_fails() -> Unit raise Error
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -1363,11 +1363,11 @@ async fn worktree_wbtest_case_remove_locked_worktree_fails() -> Unit raise Error
   add_test_run_git(repo_dir, ["add", "init.t"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   worktree_wbtest_run_shim_git([
     "worktree", "add", "--detach", "--lock", "locked-wt", "main",
@@ -1406,11 +1406,11 @@ async fn worktree_wbtest_case_move_worktree() -> Unit raise Error {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -1419,11 +1419,11 @@ async fn worktree_wbtest_case_move_worktree() -> Unit raise Error {
   add_test_run_git(repo_dir, ["add", "init.t"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   worktree_wbtest_run_shim_git([
     "worktree", "add", "--detach", "before-move", "main",
@@ -1463,11 +1463,11 @@ async fn worktree_wbtest_case_lock_and_unlock() -> Unit raise Error {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -1476,11 +1476,11 @@ async fn worktree_wbtest_case_lock_and_unlock() -> Unit raise Error {
   add_test_run_git(repo_dir, ["add", "init.t"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   worktree_wbtest_run_shim_git([
     "worktree", "add", "--detach", "locktest", "main",
@@ -1539,11 +1539,11 @@ async fn worktree_wbtest_case_add_list_remove_e2e() -> Unit raise Error {
   fs.mkdir_p(root)
   let repo_dir = root + "/repo"
 
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_caller_pwd = @sys.get_env_var("GIT_SHIM_CALLER_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_caller_pwd = @env.get_env_var("GIT_SHIM_CALLER_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
   add_test_run_git(root, ["init", "--initial-branch=main", "-q", "repo"])
   add_test_run_git(repo_dir, ["config", "user.name", "Test User"])
@@ -1552,11 +1552,11 @@ async fn worktree_wbtest_case_add_list_remove_e2e() -> Unit raise Error {
   add_test_run_git(repo_dir, ["add", "init.t"])
   add_test_run_git(repo_dir, ["commit", "-q", "-m", "main"])
 
-  @sys.set_env_var("GIT_SHIM_CWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_PWD", repo_dir)
-  @sys.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("GIT_SHIM_CWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_PWD", repo_dir)
+  @env.set_env_var("GIT_SHIM_CALLER_PWD", repo_dir)
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   // Add multiple worktrees
   worktree_wbtest_run_shim_git([
diff --git a/modules/bit/cmd/git-bit/git_helpers.mbt b/modules/bit/cmd/git-bit/git_helpers.mbt
index c1e9cc7a..efbdb3c8 100644
--- a/modules/bit/cmd/git-bit/git_helpers.mbt
+++ b/modules/bit/cmd/git-bit/git_helpers.mbt
@@ -61,9 +61,9 @@ fn get_effective_remote_url(fs : OsFs, git_dir : String) -> String? {
 
 ///|
 fn get_author_string() -> String {
-  match @sys.get_env_var("GIT_AUTHOR_NAME") {
+  match @env.get_env_var("GIT_AUTHOR_NAME") {
     Some(name) => {
-      let email = @sys.get_env_var("GIT_AUTHOR_EMAIL").unwrap_or("unknown")
+      let email = @env.get_env_var("GIT_AUTHOR_EMAIL").unwrap_or("unknown")
       name + " <" + email + ">"
     }
     None => get_identity_from_config()
@@ -96,7 +96,7 @@ fn get_identity_from_config() -> String {
   } else {
     None
   }
-  let home = @sys.get_env_var("HOME").unwrap_or("")
+  let home = @env.get_env_var("HOME").unwrap_or("")
   let global_content = if home.length() > 0 {
     @fs.read_file_to_string(home + "/.gitconfig") catch {
       _ => ""
@@ -136,11 +136,11 @@ fn get_identity_from_config() -> String {
     (Some(n), Some(e)) => n + " <" + e + ">"
     (Some(n), None) => n + " <" + n + "@localhost>"
     (None, Some(e)) => {
-      let user = @sys.get_env_var("USER").unwrap_or("Unknown")
+      let user = @env.get_env_var("USER").unwrap_or("Unknown")
       user + " <" + e + ">"
     }
     (None, None) =>
-      match @sys.get_env_var("USER") {
+      match @env.get_env_var("USER") {
         Some(u) => u + " <" + u + "@localhost>"
         None => "Unknown <unknown@localhost>"
       }
@@ -149,7 +149,7 @@ fn get_identity_from_config() -> String {
 
 ///|
 fn get_hub_signing_key() -> String? {
-  match @sys.get_env_var("BIT_COLLAB_SIGN_KEY") {
+  match @env.get_env_var("BIT_COLLAB_SIGN_KEY") {
     Some(value) => if value.length() > 0 { Some(value) } else { None }
     None => None
   }
@@ -157,7 +157,7 @@ fn get_hub_signing_key() -> String? {
 
 ///|
 fn get_hub_require_signed() -> Bool {
-  match @sys.get_env_var("BIT_COLLAB_REQUIRE_SIGNED") {
+  match @env.get_env_var("BIT_COLLAB_REQUIRE_SIGNED") {
     Some(value) => {
       let normalized = value.to_lower()
       normalized == "1" || normalized == "true" || normalized == "yes"
@@ -180,7 +180,7 @@ fn format_timestamp_iso(ts : Int64, tz : String) -> String {
 
 ///|
 fn get_commit_timestamp() -> Int64 {
-  match @sys.get_env_var("GIT_COMMITTER_DATE") {
+  match @env.get_env_var("GIT_COMMITTER_DATE") {
     Some(s) =>
       match parse_git_env_timestamp(s) {
         Some(ts) => ts
diff --git a/modules/bit/cmd/git-bit/helpers_shared.mbt b/modules/bit/cmd/git-bit/helpers_shared.mbt
index 2e46767e..34b26a9d 100644
--- a/modules/bit/cmd/git-bit/helpers_shared.mbt
+++ b/modules/bit/cmd/git-bit/helpers_shared.mbt
@@ -127,7 +127,7 @@ fn find_repo_root(start : String) -> String? {
     current = "."
   }
   let ceiling_dirs : Array[String] = []
-  match @sys.get_env_var("GIT_CEILING_DIRECTORIES") {
+  match @env.get_env_var("GIT_CEILING_DIRECTORIES") {
     Some(raw) =>
       for view in raw.split(":") {
         let dir = view.to_owned()
@@ -192,7 +192,7 @@ fn find_repo_root(start : String) -> String? {
 
 ///|
 fn get_work_root() -> String {
-  match @sys.get_env_var("GIT_SHIM_CWD") {
+  match @env.get_env_var("GIT_SHIM_CWD") {
     Some(dir) =>
       // -C dir sets CWD to a subdirectory; find the repo root from there
       if is_bare_repo_dir(dir) {
@@ -201,13 +201,13 @@ fn get_work_root() -> String {
         find_repo_root(dir).unwrap_or(dir)
       }
     None =>
-      match @sys.get_env_var("GIT_WORK_TREE") {
+      match @env.get_env_var("GIT_WORK_TREE") {
         Some(dir) => dir
         None =>
-          match @sys.get_env_var("GIT_DIR") {
+          match @env.get_env_var("GIT_DIR") {
             Some(dir) => normalize_repo_root(dir)
             None =>
-              match @sys.get_env_var("GIT_SHIM_PWD") {
+              match @env.get_env_var("GIT_SHIM_PWD") {
                 Some(pwd) =>
                   if is_bare_repo_dir(pwd) {
                     pwd
@@ -215,7 +215,7 @@ fn get_work_root() -> String {
                     find_repo_root(pwd).unwrap_or(".")
                   }
                 None => {
-                  if @sys.get_env_var("PWD") is Some(pwd) {
+                  if @env.get_env_var("PWD") is Some(pwd) {
                     if is_bare_repo_dir(pwd) {
                       return pwd
                     }
diff --git a/modules/bit/cmd/git-bit/hub_active.mbt b/modules/bit/cmd/git-bit/hub_active.mbt
index a3cae1ad..9f53d092 100644
--- a/modules/bit/cmd/git-bit/hub_active.mbt
+++ b/modules/bit/cmd/git-bit/hub_active.mbt
@@ -22,7 +22,7 @@ fn parse_active_issues(content : String) -> Array[String] {
 ///|
 /// Join entries with newlines.
 fn serialize_active_issues(entries : Array[String]) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for entry in entries {
     buf.write_string(entry)
     buf.write_char('\n')
@@ -124,7 +124,7 @@ async fn handle_hub_issue_active(_args : Array[String]) -> Unit raise Error {
     print_line("No active issues")
     return
   }
-  let home = @sys.get_env_var("HOME").unwrap_or("/")
+  let home = @env.get_env_var("HOME").unwrap_or("/")
   let aliases = load_aliases(git_dir)
   for entry in entries {
     let (repo_ref, issue_id) = parse_cross_repo_ref(entry)
diff --git a/modules/bit/cmd/git-bit/hub_github_sync.mbt b/modules/bit/cmd/git-bit/hub_github_sync.mbt
index 7463cbd7..471ae3dc 100644
--- a/modules/bit/cmd/git-bit/hub_github_sync.mbt
+++ b/modules/bit/cmd/git-bit/hub_github_sync.mbt
@@ -805,7 +805,7 @@ async fn handle_hub_issue_sync_status(args : Array[String]) -> Unit raise Error
 
 ///|
 fn github_sync_write_enabled() -> Bool {
-  match @sys.get_env_var("BIT_GITHUB_SYNC_WRITE") {
+  match @env.get_env_var("BIT_GITHUB_SYNC_WRITE") {
     Some(v) => v == "1" || v == "true"
     None => false
   }
diff --git a/modules/bit/cmd/git-bit/hub_helpers.mbt b/modules/bit/cmd/git-bit/hub_helpers.mbt
index 471556a1..2b710b30 100644
--- a/modules/bit/cmd/git-bit/hub_helpers.mbt
+++ b/modules/bit/cmd/git-bit/hub_helpers.mbt
@@ -379,7 +379,7 @@ fn format_issue_json(issue : @hub.Issue) -> String {
     Some(pid) => json_escape_string(pid)
     None => "null"
   }
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_string("{")
   buf.write_string("\"id\":" + json_escape_string(issue.id()))
   buf.write_string(",\"title\":" + json_escape_string(issue.title()))
@@ -405,7 +405,7 @@ fn format_issue_json(issue : @hub.Issue) -> String {
 /// Replaces raw epoch in serialize output with ISO-style dates.
 fn format_issue_detail(issue : @hub.Issue) -> String {
   let raw = issue.serialize()
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for line_view in raw.split("\n") {
     let line = line_view.to_owned()
     if line.has_prefix("created ") {
@@ -451,7 +451,7 @@ fn parse_int64_safe(s : String) -> Int64 {
 
 ///|
 fn json_escape_string(s : String) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_string("\"")
   for ch in s {
     match ch {
@@ -478,7 +478,7 @@ fn format_work_item_summary(item : @hub.WorkItem) -> String {
 
 ///|
 fn format_work_item_detail(item : @hub.WorkItem) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("id ")
   sb.write_string(item.id())
   sb.write_char('\n')
diff --git a/modules/bit/cmd/git-bit/hub_issue.mbt b/modules/bit/cmd/git-bit/hub_issue.mbt
index 95201973..ed61301f 100644
--- a/modules/bit/cmd/git-bit/hub_issue.mbt
+++ b/modules/bit/cmd/git-bit/hub_issue.mbt
@@ -616,7 +616,7 @@ async fn handle_hub_issue_get(args : Array[String]) -> Unit raise Error {
   let root = get_work_root()
   let (git_dir, id) = if repo_ref.length() > 0 {
     let local_git_dir = resolve_hub_git_dir(root)
-    let home = @sys.get_env_var("HOME").unwrap_or("/")
+    let home = @env.get_env_var("HOME").unwrap_or("/")
     let aliases = load_aliases(local_git_dir)
     let remote_path = resolve_repo_ref_to_path(repo_ref, home, aliases~)
     (resolve_hub_git_dir(remote_path), parsed_id)
@@ -812,7 +812,7 @@ async fn handle_hub_issue_create(args : Array[String]) -> Unit raise Error {
   let root = get_work_root()
   let git_dir = match repo_ref {
     Some(rref) => {
-      let home = @sys.get_env_var("HOME").unwrap_or("/")
+      let home = @env.get_env_var("HOME").unwrap_or("/")
       let local_git_dir = resolve_hub_git_dir(root)
       let aliases = load_aliases(local_git_dir)
       let remote_path = resolve_repo_ref_to_path(rref, home, aliases~)
@@ -1513,7 +1513,7 @@ async fn handle_hub_issue_init(_args : Array[String]) -> Unit raise Error {
 
 ///|
 fn issue_default_relay_url() -> String {
-  match @sys.get_env_var("BIT_RELAY_URL") {
+  match @env.get_env_var("BIT_RELAY_URL") {
     Some(url) => url
     None => "relay+https://bit-relay.mizchi.workers.dev"
   }
diff --git a/modules/bit/cmd/git-bit/hub_remote.mbt b/modules/bit/cmd/git-bit/hub_remote.mbt
index 7f9137b1..f8c9d645 100644
--- a/modules/bit/cmd/git-bit/hub_remote.mbt
+++ b/modules/bit/cmd/git-bit/hub_remote.mbt
@@ -54,7 +54,7 @@ fn hub_remotes_path(git_dir : String) -> String {
 ///|
 /// Serialize alias entries to TSV format: "name\tpath\n" per line.
 fn serialize_alias_entries(entries : Array[(String, String)]) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for entry in entries {
     let (name, path) = entry
     buf.write_string(name)
@@ -174,7 +174,7 @@ async fn handle_hub_issue_remote_add(args : Array[String]) -> Unit raise Error {
   let git_dir = resolve_hub_git_dir(root)
   let aliases = load_aliases(git_dir)
   // Resolve target: if it looks like owner/repo, resolve to ghq path
-  let home = @sys.get_env_var("HOME").unwrap_or("/")
+  let home = @env.get_env_var("HOME").unwrap_or("/")
   let resolved_path = if target.has_prefix("/") {
     target
   } else {
diff --git a/modules/bit/cmd/git-bit/hub_stores.mbt b/modules/bit/cmd/git-bit/hub_stores.mbt
index f6b450c5..c7eb308a 100644
--- a/modules/bit/cmd/git-bit/hub_stores.mbt
+++ b/modules/bit/cmd/git-bit/hub_stores.mbt
@@ -141,7 +141,7 @@ fn can_use_hub_git_backend() -> Bool {
 
 ///|
 fn resolve_hub_repo_backend_kind() -> HubRepoBackendKind {
-  match @sys.get_env_var("BIT_HUB_BACKEND") {
+  match @env.get_env_var("BIT_HUB_BACKEND") {
     Some(raw) =>
       match parse_hub_repo_backend_kind(raw) {
         Some(HubRepoBackendKind::Bit) => HubRepoBackendKind::Bit
diff --git a/modules/bit/cmd/git-bit/hub_stores_wbtest.mbt b/modules/bit/cmd/git-bit/hub_stores_wbtest.mbt
index 9b0f851f..582b9157 100644
--- a/modules/bit/cmd/git-bit/hub_stores_wbtest.mbt
+++ b/modules/bit/cmd/git-bit/hub_stores_wbtest.mbt
@@ -1,6 +1,9 @@
 ///|
 fn cleanup_tree(fs : OsFs, path : String) -> Unit {
-  if fs.is_dir(path) {
+  // Qualified rather than promoted through `extend`: no non-test caller
+  // reaches `is_dir` on a concrete `OsFs`, so promoting it here would only
+  // read as an unused function in the package proper.
+  if @bitcore.RepoFileSystem::is_dir(fs, path) {
     @bitlib.remove_tree(fs, fs, path)
   }
 }
@@ -8,8 +11,8 @@ fn cleanup_tree(fs : OsFs, path : String) -> Unit {
 ///|
 fn add_test_restore_env(name : String, value : String?) -> Unit {
   match value {
-    Some(val) => @sys.set_env_var(name, val)
-    None => @sys.unset_env_var(name)
+    Some(val) => @env.set_env_var(name, val)
+    None => @env.unset_env_var(name)
   }
 }
 
@@ -35,8 +38,8 @@ test "hub backend: parse backend kind aliases" {
 
 ///|
 test "hub backend: forced bit env selects bit backend" {
-  let prev_backend = @sys.get_env_var("BIT_HUB_BACKEND")
-  @sys.set_env_var("BIT_HUB_BACKEND", "bit")
+  let prev_backend = @env.get_env_var("BIT_HUB_BACKEND")
+  @env.set_env_var("BIT_HUB_BACKEND", "bit")
   match resolve_hub_repo_backend_kind() {
     HubRepoBackendKind::Bit => ()
     _ => fail("expected bit backend")
@@ -67,21 +70,21 @@ async test "hub backend: git backend resolves git dir and current branch" {
     get_current_timestamp().to_string()
   cleanup_tree(fs, root)
 
-  let prev_backend = @sys.get_env_var("BIT_HUB_BACKEND")
-  let prev_default_branch = @sys.get_env_var(
+  let prev_backend = @env.get_env_var("BIT_HUB_BACKEND")
+  let prev_default_branch = @env.get_env_var(
     "GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME",
   )
-  let prev_shim_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  let prev_git_dir = @sys.get_env_var("GIT_DIR")
-  let prev_work_tree = @sys.get_env_var("GIT_WORK_TREE")
+  let prev_shim_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  let prev_git_dir = @env.get_env_var("GIT_DIR")
+  let prev_work_tree = @env.get_env_var("GIT_WORK_TREE")
 
-  @sys.set_env_var("BIT_HUB_BACKEND", "git")
-  @sys.set_env_var("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME", "main")
-  @sys.unset_env_var("GIT_SHIM_CWD")
-  @sys.set_env_var("GIT_SHIM_PWD", ".")
-  @sys.unset_env_var("GIT_DIR")
-  @sys.unset_env_var("GIT_WORK_TREE")
+  @env.set_env_var("BIT_HUB_BACKEND", "git")
+  @env.set_env_var("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME", "main")
+  @env.unset_env_var("GIT_SHIM_CWD")
+  @env.set_env_var("GIT_SHIM_PWD", ".")
+  @env.unset_env_var("GIT_DIR")
+  @env.unset_env_var("GIT_WORK_TREE")
 
   @bitrepo.init_repo(fs, root, default_branch="main")
 
diff --git a/modules/bit/cmd/git-bit/main.mbt b/modules/bit/cmd/git-bit/main.mbt
index 05d7c2a1..c01fb021 100644
--- a/modules/bit/cmd/git-bit/main.mbt
+++ b/modules/bit/cmd/git-bit/main.mbt
@@ -31,11 +31,11 @@ fn git_bit_apply_cwd(raw_dir : String) -> Unit {
   let resolved = if raw_dir.has_prefix("/") {
     raw_dir
   } else {
-    let base = @sys.get_env_var("PWD").unwrap_or(".")
+    let base = @env.get_env_var("PWD").unwrap_or(".")
     normalize_path(base + "/" + raw_dir)
   }
-  @sys.set_env_var("GIT_SHIM_CWD", resolved)
-  @sys.set_env_var("GIT_SHIM_PWD", resolved)
+  @env.set_env_var("GIT_SHIM_CWD", resolved)
+  @env.set_env_var("GIT_SHIM_PWD", resolved)
 }
 
 ///|
diff --git a/modules/bit/cmd/git-bit/main_js.mbt b/modules/bit/cmd/git-bit/main_js.mbt
index 2a63793e..a7bd0d3d 100644
--- a/modules/bit/cmd/git-bit/main_js.mbt
+++ b/modules/bit/cmd/git-bit/main_js.mbt
@@ -2,7 +2,11 @@
 
 ///|
 async fn main_js_async() -> Unit {
-  let args = @sys.get_cli_args()
+  // `@env.args()` keeps `process.argv[0]`, the JavaScript runtime
+  // executable, which the deprecated `@sys.get_cli_args()` dropped. The
+  // dispatch below indexes from the script path, so drop it here instead
+  // of shifting every index.
+  let args = @env.args()[1:].to_owned()
   if args.length() >= 2 {
     match args[1] {
       "-v" | "--version" | "version" => {
diff --git a/modules/bit/cmd/git-bit/osfs.mbt b/modules/bit/cmd/git-bit/osfs.mbt
index 6bd2f552..ffb16453 100644
--- a/modules/bit/cmd/git-bit/osfs.mbt
+++ b/modules/bit/cmd/git-bit/osfs.mbt
@@ -52,7 +52,7 @@ pub impl @bitcore.RepoFileSystem for OsFs with fn read_file(_self, path) {
 
 ///|
 pub impl @bitcore.RepoFileSystem for OsFs with fn readdir(_self, path) {
-  @fs.read_dir(path).to_array() catch {
+  @fs.read_dir(path).to_owned() catch {
     err => raise io_error(err)
   }
 }
@@ -78,3 +78,13 @@ pub impl @bitcore.RepoFileSystem for OsFs with fn mtime(self, path) {
     None => raise @bitcore.GitError::IoError("Unable to stat path: \{path}")
   }
 }
+
+///| Promote the trait methods this package calls on a concrete `OsFs`.
+///
+/// Reaching them through the `impl` alone is deprecated: the compiler asks
+/// for either a fully qualified `@bitcore.RepoFileSystem::read_file(fs, ..)`
+/// at every call site or one `extend` declaration here.
+extend OsFs with @bitcore.FileSystem::{ mkdir_p, write_file, write_string }
+
+///|
+extend OsFs with @bitcore.RepoFileSystem::{ is_file, read_file }
diff --git a/modules/bit/fuzz_tests/ignore_fuzz_test.mbt b/modules/bit/fuzz_tests/ignore_fuzz_test.mbt
index 6dd76571..4559e3c6 100644
--- a/modules/bit/fuzz_tests/ignore_fuzz_test.mbt
+++ b/modules/bit/fuzz_tests/ignore_fuzz_test.mbt
@@ -1,6 +1,6 @@
 ///|
 fn build_rule_content(rng : Lcg, len : Int) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for _ in 0..<len {
     let v = rng.next_int() % 100
     let c = if v < 5 {
@@ -19,7 +19,7 @@ fn build_rule_content(rng : Lcg, len : Int) -> String {
 
 ///|
 fn build_pattern(rng : Lcg, len : Int) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for _ in 0..<len {
     let v = rng.next_int() % 10
     let c = match v {
@@ -38,7 +38,7 @@ fn build_pattern(rng : Lcg, len : Int) -> String {
 
 ///|
 fn build_path(rng : Lcg, len : Int) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for _ in 0..<len {
     let v = rng.next_int() % 20
     let c = if v == 0 { '/' } else { (v % 26 + 97).unsafe_to_char() }
diff --git a/modules/bit/fuzz_tests/parsers_fuzz_test.mbt b/modules/bit/fuzz_tests/parsers_fuzz_test.mbt
index e09afabf..6f3ef213 100644
--- a/modules/bit/fuzz_tests/parsers_fuzz_test.mbt
+++ b/modules/bit/fuzz_tests/parsers_fuzz_test.mbt
@@ -12,7 +12,7 @@ fn random_bytes(rng : Lcg, len : Int) -> Bytes {
 
 ///|
 fn random_ascii_string(rng : Lcg, len : Int) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for _ in 0..<len {
     let code = rng.next_int() % 95 + 32
     sb.write_char(code.unsafe_to_char())
@@ -275,7 +275,7 @@ test "fuzz: parse_reflog_selector with random spec" {
   }
   // Structured: `<refname>@{<digits>}`
   for _ in 0..<128 {
-    let sb = StringBuilder::new()
+    let sb = StringBuilder()
     sb.write_string(random_ascii_string(rng, rng.next_int() % 12))
     sb.write_string("@{")
     let digit_count = rng.next_int() % 20
@@ -309,7 +309,7 @@ test "fuzz: parse_index_pathspec with random spec" {
   }
   // Bias toward the `:N:` prefix form.
   for _ in 0..<128 {
-    let sb = StringBuilder::new()
+    let sb = StringBuilder()
     sb.write_char(':')
     let stage_code = rng.next_int() % 60 + 48 // 0..<60 + '0'
     sb.write_char(stage_code.unsafe_to_char())
diff --git a/modules/bit/fuzz_tests/repo_objects_fuzz_test.mbt b/modules/bit/fuzz_tests/repo_objects_fuzz_test.mbt
index 773fa7bb..2cf30f46 100644
Binary files a/modules/bit/fuzz_tests/repo_objects_fuzz_test.mbt and b/modules/bit/fuzz_tests/repo_objects_fuzz_test.mbt differ
diff --git a/modules/bit/tests/git_compat_test.mbt b/modules/bit/tests/git_compat_test.mbt
index 31a35186..55a46dbb 100644
--- a/modules/bit/tests/git_compat_test.mbt
+++ b/modules/bit/tests/git_compat_test.mbt
@@ -563,7 +563,7 @@ test "git compat: blob hash all 256 byte values" {
 /// Helper: parse header from raw loose object format "type size\0content"
 /// Returns (type_str, content_start_index)
 fn parse_loose_header(raw : Bytes) -> (String, Int) {
-  let type_buf = StringBuilder::new()
+  let type_buf = StringBuilder()
   let mut i = 0
   // Read type until space
   while i < raw.length() && raw[i] != b' ' {
diff --git a/modules/bit/tests/integration_test.mbt b/modules/bit/tests/integration_test.mbt
index 615fbfe5..76071b12 100644
--- a/modules/bit/tests/integration_test.mbt
+++ b/modules/bit/tests/integration_test.mbt
@@ -383,7 +383,7 @@ fn test_hex_digit(n : Int) -> Char {
 ///|
 /// Convert packfile to compact hex string (no spaces)
 fn to_hex_string(data : Bytes) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i = 0; i < data.length(); i = i + 1 {
     let b = data[i].to_int()
     let hi = b >> 4
diff --git a/modules/bit/tests/upload_pack_fixture_test.mbt b/modules/bit/tests/upload_pack_fixture_test.mbt
index ebc28db5..73aa2a4b 100644
--- a/modules/bit/tests/upload_pack_fixture_test.mbt
+++ b/modules/bit/tests/upload_pack_fixture_test.mbt
@@ -38,7 +38,7 @@ fn append_bytes(buf : Array[Byte], text : String) -> Unit {
 
 ///|
 fn bytes_to_string(buf : Array[Byte]) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for b in buf {
     sb.write_char(b.to_int().unsafe_to_char())
   }
diff --git a/modules/bit_archive/src/tar.mbt b/modules/bit_archive/src/tar.mbt
index ead74652..3b27e4e3 100644
--- a/modules/bit_archive/src/tar.mbt
+++ b/modules/bit_archive/src/tar.mbt
@@ -4,7 +4,7 @@
 /// Format an Int64 value as a zero-padded octal string of the given width.
 pub fn tar_format_octal(value : Int64, width : Int) -> String {
   if value == 0L {
-    let buf = StringBuilder::new()
+    let buf = StringBuilder()
     for _i in 0..<width {
       buf.write_char('0')
     }
@@ -19,7 +19,7 @@ pub fn tar_format_octal(value : Int64, width : Int) -> String {
     v = v / 8L
   }
   // Reverse
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   let digit_len = digits.length()
   // Pad with leading zeros
   if digit_len < width {
diff --git a/modules/bit_config/src/bench_test.mbt b/modules/bit_config/src/bench_test.mbt
index 5a89b6bc..40adb0bc 100644
--- a/modules/bit_config/src/bench_test.mbt
+++ b/modules/bit_config/src/bench_test.mbt
@@ -24,7 +24,7 @@ let bench_small_config : String =
 /// Synthesize a config with many remotes — realistic upper bound for
 /// a repo with lots of upstreams (e.g. an aggregator).
 fn bench_make_large_config(num_remotes : Int) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("[core]\n\trepositoryformatversion = 0\n\tfilemode = true\n")
   for i in 0..<num_remotes {
     sb.write_string("[remote \"r\{i}\"]\n")
diff --git a/modules/bit_config/src/config_parse.mbt b/modules/bit_config/src/config_parse.mbt
index 7074b321..66927f1b 100644
--- a/modules/bit_config/src/config_parse.mbt
+++ b/modules/bit_config/src/config_parse.mbt
@@ -630,7 +630,7 @@ fn config_decode_escape(c : Char) -> Char {
 ///|
 /// Parse a quoted/escaped config value string.
 pub fn parse_config_value(raw : String) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   let mut in_single = false
   let mut in_double = false
   let mut escape = false
@@ -726,7 +726,7 @@ pub fn encode_config_value(value : String) -> String {
       value.contains("#") ||
       value.contains(";")
     )
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   if needs_quoting {
     sb.write_char('"')
   }
diff --git a/modules/bit_diff3/src/diff3.mbt b/modules/bit_diff3/src/diff3.mbt
index 89bf20e3..836de19d 100644
--- a/modules/bit_diff3/src/diff3.mbt
+++ b/modules/bit_diff3/src/diff3.mbt
@@ -126,7 +126,7 @@ fn split_lines(text : String) -> Array[String] {
     return []
   }
   let lines : Array[String] = []
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for c in text {
     sb.write_char(c)
     if c == '\n' {
@@ -500,7 +500,7 @@ fn diff3_merge(
 
 ///|
 fn render_marker(ch : Char, size : Int, label : String) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for _ in 0..<size {
     sb.write_char(ch)
   }
@@ -523,7 +523,7 @@ pub fn content_merge(
   let ours_lines = split_lines(ours_text)
   let theirs_lines = split_lines(theirs_text)
   let sections = diff3_merge(base_lines, ours_lines, theirs_lines)
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   let mut conflict_count = 0
   for section in sections {
     match section {
diff --git a/modules/bit_diff_core/src/bench_test.mbt b/modules/bit_diff_core/src/bench_test.mbt
index ec6f58ed..9bb1a458 100644
--- a/modules/bit_diff_core/src/bench_test.mbt
+++ b/modules/bit_diff_core/src/bench_test.mbt
@@ -45,7 +45,7 @@ let bench_lines_b_1000_10pct : Array[String] = bench_mutate_lines(
 
 ///|
 let bench_blob_text_100kb : Bytes = {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for i in 0..<2500 {
     sb.write_string("line \{i}: forty-byte template ABCDEFGHIJ\n")
   }
diff --git a/modules/bit_fast_import/src/fast_import_parse.mbt b/modules/bit_fast_import/src/fast_import_parse.mbt
index a0be44de..494d0bb7 100644
--- a/modules/bit_fast_import/src/fast_import_parse.mbt
+++ b/modules/bit_fast_import/src/fast_import_parse.mbt
@@ -121,12 +121,12 @@ pub fn fast_import_parse_ident(line : String) -> FastImportIdent? {
   if gt_pos < 0 {
     return None
   }
-  let ident_buf = StringBuilder::new()
+  let ident_buf = StringBuilder()
   for i in 0..<=gt_pos {
     ident_buf.write_char(chars[i])
   }
   let ident = ident_buf.to_string()
-  let rest_buf = StringBuilder::new()
+  let rest_buf = StringBuilder()
   for i in (gt_pos + 1)..<chars.length() {
     rest_buf.write_char(chars[i])
   }
@@ -157,7 +157,7 @@ pub(all) enum FastImportFileOp {
 
 ///|
 fn fast_import_show_string(value : String) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_char('"')
   for c in value {
     if c == '"' {
@@ -358,7 +358,7 @@ pub fn fast_import_parse_unquote_path(path : String) -> String {
         chars.push(c)
       }
       if chars.length() > 0 && chars[chars.length() - 1] == '"' {
-        let buf = StringBuilder::new()
+        let buf = StringBuilder()
         for i in 0..<(chars.length() - 1) {
           buf.write_char(chars[i])
         }
@@ -373,7 +373,7 @@ pub fn fast_import_parse_unquote_path(path : String) -> String {
     for c in inner {
       chars.push(c)
     }
-    let buf = StringBuilder::new()
+    let buf = StringBuilder()
     let mut i = 0
     while i < chars.length() {
       if chars[i] == '\\' && i + 1 < chars.length() {
diff --git a/modules/bit_fingerprint/src/fingerprint.mbt b/modules/bit_fingerprint/src/fingerprint.mbt
index 314a7ed1..9b85e4f2 100644
--- a/modules/bit_fingerprint/src/fingerprint.mbt
+++ b/modules/bit_fingerprint/src/fingerprint.mbt
@@ -79,7 +79,7 @@ pub fn fast_directory_fingerprint(
   }
   let files : Array[String] = []
   collect_fast_hash_files(fs, root, "", ignore_entries, files)
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for rel in files {
     let file_path = root + "/" + rel
     let content = fs.read_file(file_path) catch { _ => Bytes::from_array([]) }
@@ -220,7 +220,7 @@ fn to_octal_string(value : Int) -> String {
     v = v / 8
   }
   let rev = digits.rev()
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for c in rev {
     sb.write_char(c)
   }
diff --git a/modules/bit_grep/src/pattern.mbt b/modules/bit_grep/src/pattern.mbt
index 65ab5468..2d1b6caa 100644
--- a/modules/bit_grep/src/pattern.mbt
+++ b/modules/bit_grep/src/pattern.mbt
@@ -38,7 +38,7 @@ pub(all) struct GrepExprMatch {
 
 ///|
 fn grep_pattern_show_string(value : String) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_char('"')
   for c in value {
     if c == '"' {
diff --git a/modules/bit_grep/src/search.mbt b/modules/bit_grep/src/search.mbt
index bdb36eac..639ea8f6 100644
--- a/modules/bit_grep/src/search.mbt
+++ b/modules/bit_grep/src/search.mbt
@@ -13,7 +13,7 @@ pub(all) struct GrepFileMatch {
 
 ///|
 fn grep_search_show_string(value : String) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_char('"')
   for c in value {
     if c == '"' {
diff --git a/modules/bit_hash/src/hex.mbt b/modules/bit_hash/src/hex.mbt
index 54519a0a..18f193ff 100644
--- a/modules/bit_hash/src/hex.mbt
+++ b/modules/bit_hash/src/hex.mbt
@@ -53,7 +53,7 @@ pub fn is_hex_string(s : String) -> Bool {
 
 ///|
 pub fn lower_hex_string(s : String) -> String {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   for c in s {
     if c >= 'A' && c <= 'F' {
       out.write_char((c.to_int() + 32).unsafe_to_char())
@@ -98,7 +98,7 @@ pub fn int_to_hex4(n : Int) -> String {
 /// (an ETag, a SigV4 signature, a pack name) needs this.
 pub fn hex_encode(raw : FixedArray[Byte]) -> String {
   let digits = "0123456789abcdef"
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   for b in raw {
     let v = b.to_int()
     out.write_char(digits[v / 16].to_int().unsafe_to_char())
diff --git a/modules/bit_io_native/src/env_native.mbt b/modules/bit_io_native/src/env_native.mbt
index f23af56c..930986bc 100644
--- a/modules/bit_io_native/src/env_native.mbt
+++ b/modules/bit_io_native/src/env_native.mbt
@@ -1,7 +1,7 @@
 ///|
 pub fn init_env_provider() -> Unit {
   let provider = @bitio.EnvProvider::new(
-    fn(name : String) { @sys.get_env_var(name) },
+    fn(name : String) { @env.get_env_var(name) },
     @env.current_dir,
   )
   @bitio.set_env_provider(provider)
diff --git a/modules/bit_io_native/src/http_client_native.mbt b/modules/bit_io_native/src/http_client_native.mbt
index 782b449e..c1c4622e 100644
--- a/modules/bit_io_native/src/http_client_native.mbt
+++ b/modules/bit_io_native/src/http_client_native.mbt
@@ -202,7 +202,7 @@ fn build_credential_input(
   path : String,
   username : String?,
 ) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("protocol=" + protocol + "\n")
   sb.write_string("host=" + host + "\n")
   if path.length() > 0 {
diff --git a/modules/bit_io_native/src/moon.pkg b/modules/bit_io_native/src/moon.pkg
index 842ad238..27facc55 100644
--- a/modules/bit_io_native/src/moon.pkg
+++ b/modules/bit_io_native/src/moon.pkg
@@ -16,7 +16,6 @@ import {
   "moonbitlang/core/env",
   "moonbitlang/x/codec/base64",
   "moonbitlang/x/fs",
-  "moonbitlang/x/sys",
 }
 
 import {
diff --git a/modules/bit_io_native/src/upload_pack_process.mbt b/modules/bit_io_native/src/upload_pack_process.mbt
index db4a66b3..9721de53 100644
--- a/modules/bit_io_native/src/upload_pack_process.mbt
+++ b/modules/bit_io_native/src/upload_pack_process.mbt
@@ -43,7 +43,7 @@ fn is_space_char(c : Char) -> Bool {
 ///|
 fn split_shell_words(cmdline : String) -> Array[String] raise @bit.GitError {
   let out : Array[String] = []
-  let current = StringBuilder::new()
+  let current = StringBuilder()
   let mut in_single = false
   let mut in_double = false
   let mut escaped = false
@@ -363,10 +363,10 @@ fn command_looks_like_script(cmd : String) -> Bool {
 
 ///|
 fn read_ssh_variant_override() -> String? {
-  match @sys.get_env_var("GIT_SSH_VARIANT") {
+  match @env.get_env_var("GIT_SSH_VARIANT") {
     Some(value) => Some(value.to_lower())
     None =>
-      match @sys.get_env_var("GIT_CONFIG_OVERRIDES") {
+      match @env.get_env_var("GIT_CONFIG_OVERRIDES") {
         None => None
         Some(overrides) => {
           for line_view in overrides.split("\n") {
@@ -424,7 +424,7 @@ fn resolve_ssh_variant(
 
 ///|
 fn resolve_ssh_command_spec() -> SshCommandSpec raise @bit.GitError {
-  match @sys.get_env_var("GIT_SSH_COMMAND") {
+  match @env.get_env_var("GIT_SSH_COMMAND") {
     Some(cmdline) => {
       let words = split_shell_words(cmdline)
       let cmd = words[0]
@@ -435,7 +435,7 @@ fn resolve_ssh_command_spec() -> SshCommandSpec raise @bit.GitError {
       { cmd, args }
     }
     None =>
-      match @sys.get_env_var("GIT_SSH") {
+      match @env.get_env_var("GIT_SSH") {
         Some(cmd) => { cmd, args: [] }
         None => { cmd: "ssh", args: [] }
       }
@@ -444,7 +444,7 @@ fn resolve_ssh_command_spec() -> SshCommandSpec raise @bit.GitError {
 
 ///|
 fn read_ssh_ip_option() -> String? {
-  match @sys.get_env_var("BIT_SSH_IP_VERSION") {
+  match @env.get_env_var("BIT_SSH_IP_VERSION") {
     Some("-4") => Some("-4")
     Some("-6") => Some("-6")
     _ => None
@@ -462,14 +462,14 @@ fn build_upload_pack_remote_command(path : String) -> String {
 
 ///|
 fn resolve_upload_pack_local_command() -> String {
-  match @sys.get_env_var("SHIM_EXEC_PATH") {
+  match @env.get_env_var("SHIM_EXEC_PATH") {
     Some(exec_path) =>
       if exec_path.length() > 0 {
         return exec_path + "/git-upload-pack"
       }
     None => ()
   }
-  match @sys.get_env_var("GIT_EXEC_PATH") {
+  match @env.get_env_var("GIT_EXEC_PATH") {
     Some(exec_path) =>
       if exec_path.length() > 0 {
         return exec_path + "/git-upload-pack"
@@ -481,7 +481,7 @@ fn resolve_upload_pack_local_command() -> String {
 
 ///|
 fn quote_shell_arg_single(value : String) -> String {
-  let b = StringBuilder::new()
+  let b = StringBuilder()
   b.write_char('\'')
   for c in value {
     if c == '\'' {
@@ -604,15 +604,15 @@ fn cleanup_temp_files(paths : Array[String]) -> Unit {
 
 ///|
 fn resolve_process_cwd() -> String? {
-  match @sys.get_env_var("GIT_SHIM_CWD") {
+  match @env.get_env_var("GIT_SHIM_CWD") {
     Some(dir) => Some(dir)
-    None => @sys.get_env_var("GIT_SHIM_PWD")
+    None => @env.get_env_var("GIT_SHIM_PWD")
   }
 }
 
 ///|
 fn maybe_trace_packfile(pack : Bytes) -> Unit {
-  match @sys.get_env_var("GIT_TRACE_PACKFILE") {
+  match @env.get_env_var("GIT_TRACE_PACKFILE") {
     Some(path) => ignore(@fs.write_bytes_to_file(path, pack) catch { _ => () })
     None => ()
   }
diff --git a/modules/bit_io_native/src/upload_pack_process_wbtest.mbt b/modules/bit_io_native/src/upload_pack_process_wbtest.mbt
index 300d7d8a..964f8dc8 100644
--- a/modules/bit_io_native/src/upload_pack_process_wbtest.mbt
+++ b/modules/bit_io_native/src/upload_pack_process_wbtest.mbt
@@ -4,17 +4,17 @@ fn restore_env_var_for_upload_pack_process_wbtest(
   prev : String?,
 ) -> Unit {
   match prev {
-    Some(value) => @sys.set_env_var(name, value)
-    None => @sys.unset_env_var(name)
+    Some(value) => @env.set_env_var(name, value)
+    None => @env.unset_env_var(name)
   }
 }
 
 ///|
 test "upload-pack process: info-refs over ssh uses native protocol (no stateless-rpc)" {
-  let prev_ssh_command = @sys.get_env_var("GIT_SSH_COMMAND")
-  let prev_ssh = @sys.get_env_var("GIT_SSH")
-  @sys.unset_env_var("GIT_SSH_COMMAND")
-  @sys.unset_env_var("GIT_SSH")
+  let prev_ssh_command = @env.get_env_var("GIT_SSH_COMMAND")
+  let prev_ssh = @env.get_env_var("GIT_SSH")
+  @env.unset_env_var("GIT_SSH_COMMAND")
+  @env.unset_env_var("GIT_SSH")
   let spec = build_upload_pack_info_refs_process_spec(
     "git@github.com:mizchi/bit-vcs.git", true,
   )
@@ -37,10 +37,10 @@ test "upload-pack process: info-refs over ssh uses native protocol (no stateless
 
 ///|
 test "upload-pack process: request over ssh uses native protocol (no stateless-rpc)" {
-  let prev_ssh_command = @sys.get_env_var("GIT_SSH_COMMAND")
-  let prev_ssh = @sys.get_env_var("GIT_SSH")
-  @sys.unset_env_var("GIT_SSH_COMMAND")
-  @sys.unset_env_var("GIT_SSH")
+  let prev_ssh_command = @env.get_env_var("GIT_SSH_COMMAND")
+  let prev_ssh = @env.get_env_var("GIT_SSH")
+  @env.unset_env_var("GIT_SSH_COMMAND")
+  @env.unset_env_var("GIT_SSH")
   let spec = build_upload_pack_request_process_spec(
     "git@github.com:mizchi/bit-vcs.git", true,
   )
@@ -62,10 +62,10 @@ test "upload-pack process: request over ssh uses native protocol (no stateless-r
 
 ///|
 test "upload-pack process: ssh remote command escapes single quote in path" {
-  let prev_ssh_command = @sys.get_env_var("GIT_SSH_COMMAND")
-  let prev_ssh = @sys.get_env_var("GIT_SSH")
-  @sys.unset_env_var("GIT_SSH_COMMAND")
-  @sys.unset_env_var("GIT_SSH")
+  let prev_ssh_command = @env.get_env_var("GIT_SSH_COMMAND")
+  let prev_ssh = @env.get_env_var("GIT_SSH")
+  @env.unset_env_var("GIT_SSH_COMMAND")
+  @env.unset_env_var("GIT_SSH")
   let spec = build_upload_pack_info_refs_process_spec(
     "git@github.com:mizchi/o'hara.git", true,
   )
@@ -81,8 +81,8 @@ test "upload-pack process: ssh remote command escapes single quote in path" {
 
 ///|
 test "upload-pack process: file transport prefers SHIM_EXEC_PATH" {
-  let prev_exec_path = @sys.get_env_var("SHIM_EXEC_PATH")
-  @sys.set_env_var("SHIM_EXEC_PATH", "/tmp/git-core")
+  let prev_exec_path = @env.get_env_var("SHIM_EXEC_PATH")
+  @env.set_env_var("SHIM_EXEC_PATH", "/tmp/git-core")
   let spec = build_upload_pack_info_refs_process_spec("/tmp/repo.git", false)
   assert_eq(spec.cmd, "/tmp/git-core/git-upload-pack")
   restore_env_var_for_upload_pack_process_wbtest(
@@ -92,8 +92,8 @@ test "upload-pack process: file transport prefers SHIM_EXEC_PATH" {
 
 ///|
 async test "upload-pack process: run_process_with_files works with cwd override" {
-  let prev_cwd = @sys.get_env_var("GIT_SHIM_CWD")
-  @sys.set_env_var("GIT_SHIM_CWD", "/tmp")
+  let prev_cwd = @env.get_env_var("GIT_SHIM_CWD")
+  @env.set_env_var("GIT_SHIM_CWD", "/tmp")
   let stdin_data = Bytes::from_array([b'h', b'i', b'\n'])
   let (code, stdout, stderr) = run_process_with_files(
     { cmd: "/bin/cat", args: [], extra_env: None },
diff --git a/modules/bit_lib/src/bench_config_test.mbt b/modules/bit_lib/src/bench_config_test.mbt
index 68b1d74e..f4551399 100644
--- a/modules/bit_lib/src/bench_config_test.mbt
+++ b/modules/bit_lib/src/bench_config_test.mbt
@@ -14,7 +14,7 @@ fn bench_setup_config_repo(num_remotes : Int) -> @bit.TestFs {
   let fs = @bit.TestFs::new()
   let git_dir = bench_config_root + "/.git"
   fs.mkdir_p(git_dir)
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string(
     "[core]\n\trepositoryformatversion = 0\n\tfilemode = true\n\tautocrlf = false\n",
   )
diff --git a/modules/bit_lib/src/branch.mbt b/modules/bit_lib/src/branch.mbt
index e45054ad..0fe35d71 100644
--- a/modules/bit_lib/src/branch.mbt
+++ b/modules/bit_lib/src/branch.mbt
@@ -186,7 +186,7 @@ fn pad_right(s : String, width : Int) -> String {
   if s.length() >= width {
     return s
   }
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_string(s)
   for i = s.length(); i < width; i = i + 1 {
     buf.write_char(' ')
diff --git a/modules/bit_lib/src/cherry_pick.mbt b/modules/bit_lib/src/cherry_pick.mbt
index 013af05f..98e7ffbf 100644
--- a/modules/bit_lib/src/cherry_pick.mbt
+++ b/modules/bit_lib/src/cherry_pick.mbt
@@ -264,7 +264,7 @@ fn cherry_pick_trim_trailing_newlines(s : String) -> String {
   while end > 0 && (chars[end - 1] == '\n' || chars[end - 1] == '\r') {
     end -= 1
   }
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i in 0..<end {
     result.write_char(chars[i])
   }
diff --git a/modules/bit_lib/src/commit_graph_reader.mbt b/modules/bit_lib/src/commit_graph_reader.mbt
index fe1cd838..5a72e864 100644
--- a/modules/bit_lib/src/commit_graph_reader.mbt
+++ b/modules/bit_lib/src/commit_graph_reader.mbt
@@ -202,7 +202,7 @@ pub fn CommitGraphFile::synthesize_commit_object(
 ) -> @bit.PackObject {
   let (tree_oid, parents, timestamp) = self.read_commit(pos)
   // Build minimal commit content
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_string("tree ")
   buf.write_string(tree_oid.to_hex())
   buf.write_string("\n")
diff --git a/modules/bit_lib/src/commit_helpers.mbt b/modules/bit_lib/src/commit_helpers.mbt
index 007b405b..f64a89a1 100644
--- a/modules/bit_lib/src/commit_helpers.mbt
+++ b/modules/bit_lib/src/commit_helpers.mbt
@@ -110,7 +110,7 @@ pub fn commit_apply_signoff(msg : String, committer~ : String) -> String {
   } else {
     true
   }
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   // Preserve original message
   if msg.has_suffix("\n") {
     result.write_string(msg)
@@ -130,7 +130,7 @@ pub fn commit_apply_signoff(msg : String, committer~ : String) -> String {
 /// Decode commit message bytes, handling ISO-8859-1 and UTF-8 encodings.
 pub fn decode_commit_message_bytes(data : Bytes, encoding : String) -> String {
   if is_iso_8859_1_encoding(encoding) {
-    let out = StringBuilder::new()
+    let out = StringBuilder()
     for b in data {
       out.write_char(b.to_int().unsafe_to_char())
     }
@@ -148,7 +148,7 @@ fn is_iso_8859_1_encoding(encoding : String) -> Bool {
 
 ///|
 fn normalize_commit_encoding_name(value : String) -> String {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   for c in commit_trim_string(value).to_lower() {
     if c == '-' || c == '_' || c == ' ' {
       continue
diff --git a/modules/bit_lib/src/index.mbt b/modules/bit_lib/src/index.mbt
index af6d6170..e01eb778 100644
--- a/modules/bit_lib/src/index.mbt
+++ b/modules/bit_lib/src/index.mbt
@@ -147,7 +147,7 @@ fn index_entries_from_stage_entries(
         None => selected[entry.path] = (prio, entry)
       }
     }
-    let deduped : Array[IndexEntry] = Array::new(capacity=selected.length())
+    let deduped : Array[IndexEntry] = Array(capacity=selected.length())
     for _, value in selected {
       deduped.push(value.1)
     }
@@ -365,7 +365,7 @@ fn index_read_stage_entries_from_bytes(
   }
   let count = index_read_u32_be(data, 8)
   let mut offset = 12
-  let entries : Array[IndexStageEntry] = Array::new(capacity=count)
+  let entries : Array[IndexStageEntry] = Array(capacity=count)
   for _ in 0..<count {
     let entry_start = offset
     if offset + 40 + hash_size + 2 > data.length() {
diff --git a/modules/bit_lib/src/js_api_exports.mbt b/modules/bit_lib/src/js_api_exports.mbt
index f38e937f..fa136286 100644
--- a/modules/bit_lib/src/js_api_exports.mbt
+++ b/modules/bit_lib/src/js_api_exports.mbt
@@ -839,7 +839,7 @@ fn js_append_utf8(out : Array[Byte], value : String) -> Unit {
 
 ///|
 fn js_normalize_newlines(value : String) -> String {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   let mut saw_cr = false
   for c in value {
     if saw_cr {
diff --git a/modules/bit_lib/src/js_exports_wbtest.mbt b/modules/bit_lib/src/js_exports_wbtest.mbt
index 993ee6e0..3f9cc9d6 100644
--- a/modules/bit_lib/src/js_exports_wbtest.mbt
+++ b/modules/bit_lib/src/js_exports_wbtest.mbt
@@ -25,7 +25,7 @@ fn js_exports_expect_err_contains(
 
 ///|
 fn js_exports_parse_loose_header(raw : Bytes) -> (String, Int) {
-  let type_buf = StringBuilder::new()
+  let type_buf = StringBuilder()
   let mut i = 0
   while i < raw.length() && raw[i] != b' ' {
     type_buf.write_char(raw[i].to_int().unsafe_to_char())
@@ -241,7 +241,9 @@ extern "js" fn js_exports_register_clone_fixture_transport(
   #| }
 
 ///|
-extern "js" fn js_exports_transport_calls(transport_id : Int) -> Array[String] =
+extern "js" fn js_exports_transport_calls(
+  transport_id : Int,
+) -> FixedArray[String] =
   #| (transportId) => {
   #|   const state = globalThis.__bitGitJsTransportState ??= { nextTransportId: 1, transports: new Map() };
   #|   const transport = state.transports.get(transportId);
diff --git a/modules/bit_lib/src/js_host_bridge.mbt b/modules/bit_lib/src/js_host_bridge.mbt
index e3979492..cb85a3c2 100644
--- a/modules/bit_lib/src/js_host_bridge.mbt
+++ b/modules/bit_lib/src/js_host_bridge.mbt
@@ -16,10 +16,13 @@ fn js_make_host_fs(host_id : Int) -> LibJsHostFs {
 }
 
 ///|
-fn js_bytes_to_array(bytes : Bytes) -> Array[Byte] {
-  let out : Array[Byte] = Array::new(capacity=bytes.length())
+/// A `FixedArray` rather than an `Array`: `Array` is deprecated at the JS FFI
+/// boundary, and a `FixedArray[Byte]` arrives as a `Uint8Array`, which the
+/// bridge's `Uint8Array.from` reads exactly as it read the plain array.
+fn js_bytes_to_fixedarray(bytes : Bytes) -> FixedArray[Byte] {
+  let out = FixedArray::make(bytes.length(), b'\x00')
   for i in 0..<bytes.length() {
-    out.push(bytes[i])
+    out[i] = bytes[i]
   }
   out
 }
@@ -45,7 +48,7 @@ extern "js" fn lib_js_host_last_error() -> String =
 extern "js" fn lib_js_host_write_file(
   host_id : Int,
   path : String,
-  content : Array[Byte],
+  content : FixedArray[Byte],
 ) -> String? =
   #| (hostId, path, content) => {
   #|   const state = globalThis.__bitGitJsState ??= { nextHostId: 1, hosts: new Map() };
@@ -456,7 +459,8 @@ impl @bit.FileSystem for LibJsHostFs with fn mkdir_p(self, path) {
 
 ///|
 impl @bit.FileSystem for LibJsHostFs with fn write_file(self, path, content) {
-  match lib_js_host_write_file(self.host_id, path, js_bytes_to_array(content)) {
+  match
+    lib_js_host_write_file(self.host_id, path, js_bytes_to_fixedarray(content)) {
     Some(error) => raise @bit.GitError::IoError(error)
     None => ()
   }
diff --git a/modules/bit_lib/src/js_transport_bridge.mbt b/modules/bit_lib/src/js_transport_bridge.mbt
index 54310ea0..514c9f96 100644
--- a/modules/bit_lib/src/js_transport_bridge.mbt
+++ b/modules/bit_lib/src/js_transport_bridge.mbt
@@ -1,10 +1,13 @@
 ///| JS transport registry bridge for injected HTTP transports.
 
 ///|
-fn js_transport_bytes_to_array(bytes : Bytes) -> Array[Byte] {
-  let out : Array[Byte] = Array::new(capacity=bytes.length())
+/// A `FixedArray` rather than an `Array`: `Array` is deprecated at the JS FFI
+/// boundary, and a `FixedArray[Byte]` arrives as a `Uint8Array`, which the
+/// bridge's `Uint8Array.from` reads exactly as it read the plain array.
+fn js_transport_bytes_to_fixedarray(bytes : Bytes) -> FixedArray[Byte] {
+  let out = FixedArray::make(bytes.length(), b'\x00')
   for i in 0..<bytes.length() {
-    out.push(bytes[i])
+    out[i] = bytes[i]
   }
   out
 }
@@ -12,13 +15,14 @@ fn js_transport_bytes_to_array(bytes : Bytes) -> Array[Byte] {
 ///|
 fn js_transport_headers_to_arrays(
   headers : Map[String, String],
-) -> (Array[String], Array[String]) {
-  let names : Array[String] = []
-  let values : Array[String] = []
-  for entry in headers.to_array() {
+) -> (FixedArray[String], FixedArray[String]) {
+  let entries = headers.to_array()
+  let names = FixedArray::make(entries.length(), "")
+  let values = FixedArray::make(entries.length(), "")
+  for i, entry in entries {
     let (name, value) = entry
-    names.push(name)
-    values.push(value)
+    names[i] = name
+    values[i] = value
   }
   (names, values)
 }
@@ -101,8 +105,8 @@ fn js_transport_parse_response(
 extern "js" fn lib_js_transport_get(
   transport_id : Int,
   url : String,
-  header_names : Array[String],
-  header_values : Array[String],
+  header_names : FixedArray[String],
+  header_values : FixedArray[String],
 ) -> @js_async.Promise[String] =
   #| async (transportId, url, headerNames, headerValues) => {
   #|   const state = globalThis.__bitGitJsTransportState ??= { nextTransportId: 1, transports: new Map() };
@@ -141,9 +145,9 @@ extern "js" fn lib_js_transport_get(
 extern "js" fn lib_js_transport_post(
   transport_id : Int,
   url : String,
-  body : Array[Byte],
-  header_names : Array[String],
-  header_values : Array[String],
+  body : FixedArray[Byte],
+  header_names : FixedArray[String],
+  header_values : FixedArray[String],
 ) -> @js_async.Promise[String] =
   #| async (transportId, url, body, headerNames, headerValues) => {
   #|   const state = globalThis.__bitGitJsTransportState ??= { nextTransportId: 1, transports: new Map() };
@@ -202,7 +206,7 @@ async fn js_transport_post(
   let raw = lib_js_transport_post(
     transport_id,
     url,
-    js_transport_bytes_to_array(body),
+    js_transport_bytes_to_fixedarray(body),
     header_names,
     header_values,
   ).wait() catch {
diff --git a/modules/bit_lib/src/lfs.mbt b/modules/bit_lib/src/lfs.mbt
index de606ff6..5f920e37 100644
--- a/modules/bit_lib/src/lfs.mbt
+++ b/modules/bit_lib/src/lfs.mbt
@@ -22,7 +22,7 @@ let lfs_max_pointer_size : Int = 1024
 fn lfs_sha256_hex(data : Bytes) -> String {
   let raw = @bithash.sha256_bytes(data)
   let digits = "0123456789abcdef"
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   for b in raw {
     let v = b.to_int()
     out.write_char(digits[v / 16].to_int().unsafe_to_char())
diff --git a/modules/bit_lib/src/merge.mbt b/modules/bit_lib/src/merge.mbt
index 7901a758..7b7295bc 100644
--- a/modules/bit_lib/src/merge.mbt
+++ b/modules/bit_lib/src/merge.mbt
@@ -915,7 +915,7 @@ fn merge_common_line_prefix(a : String, b : String) -> String {
   for part in b.split("\n") {
     b_arr.push(part.to_owned())
   }
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   let limit = if a_arr.length() < b_arr.length() {
     a_arr.length()
   } else {
diff --git a/modules/bit_lib/src/native/remote_ref.mbt b/modules/bit_lib/src/native/remote_ref.mbt
index 9ab79e2a..cf0e2b47 100644
--- a/modules/bit_lib/src/native/remote_ref.mbt
+++ b/modules/bit_lib/src/native/remote_ref.mbt
@@ -23,7 +23,7 @@ fn is_hex_string(s : String) -> Bool {
 
 ///|
 fn lower_hex_string(s : String) -> String {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   for c in s {
     if c >= 'A' && c <= 'F' {
       out.write_char((c.to_int() + 32).unsafe_to_char())
diff --git a/modules/bit_lib/src/object_db.mbt b/modules/bit_lib/src/object_db.mbt
index 8e257ec8..744a3253 100644
--- a/modules/bit_lib/src/object_db.mbt
+++ b/modules/bit_lib/src/object_db.mbt
@@ -1463,7 +1463,7 @@ fn parse_loose_object(data : Bytes) -> @bit.PackObject raise @bit.GitError {
   if len == 0 {
     raise @bit.GitError::InvalidObject("Empty loose object")
   }
-  let type_buf = StringBuilder::new()
+  let type_buf = StringBuilder()
   let mut i = 0
   while i < len && data[i] != b' ' {
     type_buf.write_char(data[i].to_int().unsafe_to_char())
diff --git a/modules/bit_lib/src/rebase_interactive.mbt b/modules/bit_lib/src/rebase_interactive.mbt
index d211bab7..e600b00c 100644
--- a/modules/bit_lib/src/rebase_interactive.mbt
+++ b/modules/bit_lib/src/rebase_interactive.mbt
@@ -200,7 +200,7 @@ pub fn parse_interactive_todo(text : String) -> Array[InteractiveTodoEntry] {
 pub fn serialize_interactive_todo(
   entries : Array[InteractiveTodoEntry],
 ) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for entry in entries {
     match entry.command {
       Label | Reset => {
@@ -371,7 +371,7 @@ pub fn save_interactive_rebase_state(
   }
   // Write labels state (for --rebase-merges)
   if state.labels.length() > 0 {
-    let sb = StringBuilder::new()
+    let sb = StringBuilder()
     for name, hex in state.labels {
       sb.write_string(name)
       sb.write_string(" ")
@@ -386,7 +386,7 @@ pub fn save_interactive_rebase_state(
   }
   // Write update-refs state
   if state.update_refs.length() > 0 {
-    let sb = StringBuilder::new()
+    let sb = StringBuilder()
     for ref_path, old_hex in state.update_refs {
       let new_hex = match state.commit_map.get(old_hex) {
         Some(h) => h
@@ -526,7 +526,7 @@ pub fn generate_interactive_todo_text(
   rfs : &@bit.RepoFileSystem,
   commits : Array[@bit.ObjectId],
 ) -> String raise @bit.GitError {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for commit in commits {
     let hex = commit.to_hex()
     let short = String::unsafe_substring(hex, start=0, end=7)
@@ -602,7 +602,7 @@ pub fn insert_exec_after_picks(
 ///|
 /// Extract comment lines from todo text (lines starting with #).
 fn extract_todo_comments(text : String) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for line_view in text.split("\n") {
     let line = line_view.to_owned()
     if line.has_prefix("#") {
@@ -754,7 +754,7 @@ fn generate_rebase_merges_todo_text(
   // Walk first-parent chains and build branches
   // A "branch" is a sequence of commits along first-parent that ends at
   // a labeled commit or at the base.
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("label onto\n\n")
   // Emit label commands for external parents (outside the rebase range).
   // These are merge parents not in commit_set that need labels so that
@@ -931,7 +931,7 @@ fn generate_rebase_merges_todo_text(
 
 ///|
 fn serialize_single_todo_entry(entry : InteractiveTodoEntry) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   match entry.command {
     Label | Reset => {
       sb.write_string(todo_command_to_string(entry.command))
diff --git a/modules/bit_lib/src/receive_pack.mbt b/modules/bit_lib/src/receive_pack.mbt
index ad3c1598..d3e1d740 100644
--- a/modules/bit_lib/src/receive_pack.mbt
+++ b/modules/bit_lib/src/receive_pack.mbt
@@ -646,7 +646,7 @@ fn receive_bytes_to_string_range(
   start : Int,
   end : Int,
 ) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   let mut i = start
   while i < end {
     buf.write_char(data[i].to_int().unsafe_to_char())
@@ -692,7 +692,7 @@ fn receive_split_by_space(s : String) -> Array[String] {
 
 ///|
 fn receive_chars_to_string(chars : Array[Char]) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for c in chars {
     buf.write_char(c)
   }
diff --git a/modules/bit_lib/src/remote_helpers.mbt b/modules/bit_lib/src/remote_helpers.mbt
index 7dc05544..73708239 100644
--- a/modules/bit_lib/src/remote_helpers.mbt
+++ b/modules/bit_lib/src/remote_helpers.mbt
@@ -147,7 +147,7 @@ pub fn format_remove_warning(branches : Array[String]) -> String {
 ///|
 pub fn split_whitespace_all(s : String) -> Array[String] {
   let result : Array[String] = []
-  let current = StringBuilder::new()
+  let current = StringBuilder()
   let mut in_word = false
   for c in s {
     if c == ' ' || c == '\t' || c == '\n' || c == '\r' {
diff --git a/modules/bit_lib/src/remote_shorthand.mbt b/modules/bit_lib/src/remote_shorthand.mbt
index b5b1afe3..072d4afc 100644
--- a/modules/bit_lib/src/remote_shorthand.mbt
+++ b/modules/bit_lib/src/remote_shorthand.mbt
@@ -9,7 +9,7 @@ pub(all) enum GitHubShorthand {
 
 ///|
 fn bitcore_shorthand_show_string(value : String) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_char('"')
   for c in value {
     if c == '"' {
diff --git a/modules/bit_lib/src/revparse.mbt b/modules/bit_lib/src/revparse.mbt
index 5cbf449a..b611f801 100644
--- a/modules/bit_lib/src/revparse.mbt
+++ b/modules/bit_lib/src/revparse.mbt
@@ -509,7 +509,7 @@ fn revparse_read_graft_parents(
 ///|
 fn substring_revparse(s : String, start : Int, end : Int) -> String {
   let chars = s.to_array()
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i = start; i < end && i < chars.length(); i = i + 1 {
     result.write_char(chars[i])
   }
@@ -665,9 +665,7 @@ pub fn show_ref(
   if fs.is_file(packed) {
     ref_collect_packed(fs, packed, out)
   }
-  let result : Array[(String, @bit.ObjectId)] = Array::new(
-    capacity=out.length(),
-  )
+  let result : Array[(String, @bit.ObjectId)] = Array(capacity=out.length())
   for name, id in out {
     result.push((name, id))
   }
@@ -1065,7 +1063,7 @@ pub fn shorten_oid_hex(hex : String, requested : Int) -> String {
 ///|
 /// Shell-escape a value with single quotes.
 pub fn shell_single_quote(value : String) -> String {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   out.write_char('\'')
   for c in value {
     if c == '\'' {
@@ -1347,7 +1345,7 @@ pub fn rev_parse_parse_config_bool(raw : String) -> Bool? {
 /// Split a string into lines (parseopt helper).
 pub fn parseopt_split_lines(s : String) -> Array[String] {
   let lines : Array[String] = []
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for c in s {
     if c == '\n' {
       lines.push(buf.to_string())
diff --git a/modules/bit_lib/src/status_text.mbt b/modules/bit_lib/src/status_text.mbt
index 2ac21945..f2826603 100644
--- a/modules/bit_lib/src/status_text.mbt
+++ b/modules/bit_lib/src/status_text.mbt
@@ -17,7 +17,7 @@ pub async fn status_text(
   } else {
     bit_marker
   }
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   let head = read_head_ref(fs, git_dir)
   match head {
     Branch(name) => sb.write_string("On branch " + name + "\n")
diff --git a/modules/bit_lib/src/subdir.mbt b/modules/bit_lib/src/subdir.mbt
index 7d101bfc..1533c4a0 100644
--- a/modules/bit_lib/src/subdir.mbt
+++ b/modules/bit_lib/src/subdir.mbt
@@ -11,7 +11,7 @@ pub fn write_subdir_attributes(
   fs.mkdir_p(info_dir) catch {
     _ => ()
   }
-  let content = StringBuilder::new()
+  let content = StringBuilder()
   content.write_string("# subdir-clone metadata\n")
   content.write_string("* subdir-remote=")
   content.write_string(remote_url)
@@ -289,7 +289,7 @@ fn string_to_bytes(s : String) -> Bytes {
 
 ///|
 fn bytes_to_string(bytes : Bytes) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i in 0..<bytes.length() {
     result.write_char(bytes[i].to_int().unsafe_to_char())
   }
diff --git a/modules/bit_lib/src/upload_pack.mbt b/modules/bit_lib/src/upload_pack.mbt
index 01fd6b7f..aa34d452 100644
--- a/modules/bit_lib/src/upload_pack.mbt
+++ b/modules/bit_lib/src/upload_pack.mbt
@@ -676,7 +676,7 @@ fn upload_parse_pkt_len(data : Bytes, start : Int) -> Int raise @bit.GitError {
 
 ///|
 fn upload_bytes_to_string_range(data : Bytes, start : Int, end : Int) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   let mut i = start
   while i < end {
     buf.write_char(data[i].to_int().unsafe_to_char())
@@ -712,7 +712,7 @@ fn upload_split_by_space(s : String) -> Array[String] {
 
 ///|
 fn upload_chars_to_string(chars : Array[Char]) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for c in chars {
     buf.write_char(c)
   }
@@ -853,7 +853,7 @@ pub fn ls_refs_v2(
   let db = if req.peel { Some(ObjectDb::load(fs, git_dir)) } else { None }
   for entry in listing {
     let (name, id) = entry
-    let line = StringBuilder::new()
+    let line = StringBuilder()
     line.write_string(id.to_hex())
     line.write_char(' ')
     line.write_string(name)
diff --git a/modules/bit_lib/src/worktree.mbt b/modules/bit_lib/src/worktree.mbt
index de420e38..75595a6d 100644
--- a/modules/bit_lib/src/worktree.mbt
+++ b/modules/bit_lib/src/worktree.mbt
@@ -118,7 +118,7 @@ pub fn status_porcelain_from(s : Status) -> Array[String] {
     ymap[p] = 'D'
   }
   // xmap.keys() ∪ ymap.keys() — paths touched by either side.
-  let list : Array[String] = Array::new(capacity=tracked_count)
+  let list : Array[String] = Array(capacity=tracked_count)
   for p in xmap.keys() {
     list.push(p)
   }
@@ -128,9 +128,7 @@ pub fn status_porcelain_from(s : Status) -> Array[String] {
     }
   }
   list.sort()
-  let out : Array[String] = Array::new(
-    capacity=list.length() + s.untracked.length(),
-  )
+  let out : Array[String] = Array(capacity=list.length() + s.untracked.length())
   for p in list {
     let x = xmap.get(p).unwrap_or(' ')
     let y = ymap.get(p).unwrap_or(' ')
@@ -1235,7 +1233,7 @@ fn reftable_index_to_hex12(value : UInt64) -> String {
     b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7', b'8', b'9', b'a', b'b', b'c',
     b'd', b'e', b'f',
   ]
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for i = 11; i >= 0; i = i - 1 {
     let shift = i * 4
     let nibble = ((value >> shift.to_uint64().to_int()) & 0xfUL).to_int()
@@ -1855,7 +1853,7 @@ pub fn rm_paths(
       }
     }
   }
-  let out : Array[IndexEntry] = Array::new(capacity=map.length())
+  let out : Array[IndexEntry] = Array(capacity=map.length())
   let remaining_skip_worktree_paths : Map[String, Bool] = Map([])
   let remaining_skip_paths : Array[String] = []
   for path, entry in map {
diff --git a/modules/bit_object/src/object.mbt b/modules/bit_object/src/object.mbt
index 02f5f138..b7522144 100644
--- a/modules/bit_object/src/object.mbt
+++ b/modules/bit_object/src/object.mbt
@@ -30,7 +30,7 @@ fn object_append_utf8_string(out : Array[Byte], s : String) -> Unit {
 
 ///|
 fn object_normalize_encoding_name(value : String) -> String {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   for c in value.trim().to_lower() {
     if c == '-' || c == '_' || c == ' ' {
       continue
diff --git a/modules/bit_object/src/types.mbt b/modules/bit_object/src/types.mbt
index 01c55cb8..3cbe15a1 100644
--- a/modules/bit_object/src/types.mbt
+++ b/modules/bit_object/src/types.mbt
@@ -99,7 +99,7 @@ fn hex_char_to_int(c : Char) -> Int raise GitError {
 
 ///|
 pub fn ObjectId::to_hex(self : ObjectId) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for b in self.bytes {
     let hi = (b.to_int() >> 4) & 0x0f
     let lo = b.to_int() & 0x0f
@@ -203,7 +203,7 @@ pub(all) suberror GitError {
 
 ///|
 fn git_error_show_string(value : String) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_char('"')
   for c in value {
     if c == '"' {
diff --git a/modules/bit_objstore/src/list_xml.mbt b/modules/bit_objstore/src/list_xml.mbt
index 0d15d0e8..b7c619b2 100644
--- a/modules/bit_objstore/src/list_xml.mbt
+++ b/modules/bit_objstore/src/list_xml.mbt
@@ -41,7 +41,7 @@ pub fn xml_unescape(value : String) -> String {
   if value.find("&") is None {
     return value
   }
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   let n = value.length()
   let mut run_start = 0
   let mut i = 0
diff --git a/modules/bit_objstore/src/sigv4.mbt b/modules/bit_objstore/src/sigv4.mbt
index 6167386d..ca5d5cf0 100644
--- a/modules/bit_objstore/src/sigv4.mbt
+++ b/modules/bit_objstore/src/sigv4.mbt
@@ -43,7 +43,7 @@ const S3_SERVICE : String = "s3"
 /// separators while a query value does not.
 pub fn uri_encode(value : String, encode_slash : Bool) -> String {
   let digits = "0123456789ABCDEF"
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   for byte in @utf8.encode(value) {
     let b = byte.to_int()
     let is_unreserved = (b >= 0x41 && b <= 0x5a) ||
@@ -96,7 +96,7 @@ pub fn endpoint_host(endpoint : String) -> String raise @bit.GitError {
 
 ///|
 fn lowercase(s : String) -> String {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   for c in s {
     let code = c.to_int()
     if code >= 0x41 && code <= 0x5a {
@@ -137,7 +137,7 @@ fn canonical_query(query : Array[(String, String)]) -> String {
       lex_compare(a.0, b.0)
     }
   })
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   for i in 0..<pairs.length() {
     if i > 0 {
       out.write_char('&')
@@ -188,8 +188,8 @@ fn canonical_request_of(
     names.push(name)
   }
   names.sort_by((a, b) => lex_compare(a, b))
-  let canonical_headers = StringBuilder::new()
-  let signed_headers = StringBuilder::new()
+  let canonical_headers = StringBuilder()
+  let signed_headers = StringBuilder()
   for i in 0..<names.length() {
     if i > 0 {
       signed_headers.write_char(';')
diff --git a/modules/bit_osfs/src/osfs.mbt b/modules/bit_osfs/src/osfs.mbt
index 2a1aca8a..984c545d 100644
--- a/modules/bit_osfs/src/osfs.mbt
+++ b/modules/bit_osfs/src/osfs.mbt
@@ -88,7 +88,7 @@ pub impl @bit.RepoFileSystem for OsFs with fn read_file(_self, path) {
 
 ///|
 pub impl @bit.RepoFileSystem for OsFs with fn readdir(_self, path) {
-  @fs.read_dir(path).to_array() catch {
+  @fs.read_dir(path).to_owned() catch {
     err => raise io_error(err)
   }
 }
diff --git a/modules/bit_pack/src/bench_profile_test.mbt b/modules/bit_pack/src/bench_profile_test.mbt
index 8e403e15..82634df2 100644
--- a/modules/bit_pack/src/bench_profile_test.mbt
+++ b/modules/bit_pack/src/bench_profile_test.mbt
@@ -5,7 +5,7 @@ fn make_realistic_objects(count : Int) -> Array[@bit.PackObject] {
   // Simulate real repo: mix of blobs, trees, commits with similar content
   let objects : Array[@bit.PackObject] = []
   for i in 0..<count {
-    let content = StringBuilder::new()
+    let content = StringBuilder()
     // Each blob ~200 bytes with shared prefix (realistic for source files)
     content.write_string("// File auto-generated for testing\n")
     content.write_string("package main\n\nimport \"fmt\"\n\n")
@@ -93,7 +93,7 @@ test "bench profile: Array[Byte] collect 500x200B" (b : @bench.T) {
       parts.push(obj.data)
       total += obj.data.length()
     }
-    let arr : Array[Byte] = Array::new(capacity=total)
+    let arr : Array[Byte] = Array(capacity=total)
     for part in parts {
       for i in 0..<part.length() {
         arr.push(part[i])
diff --git a/modules/bit_pack/src/gen_packfile.mbt b/modules/bit_pack/src/gen_packfile.mbt
index c977e64d..af152482 100644
--- a/modules/bit_pack/src/gen_packfile.mbt
+++ b/modules/bit_pack/src/gen_packfile.mbt
@@ -36,7 +36,7 @@ pub fn generate_commit_packfile() -> (@bit.ObjectId, Bytes) {
 ///|
 /// Print packfile as hex dump for debugging
 pub fn hex_dump(data : Bytes) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i = 0; i < data.length(); i = i + 1 {
     if i > 0 && i % 16 == 0 {
       result.write_char('\n')
diff --git a/modules/bit_pack/src/packfile.mbt b/modules/bit_pack/src/packfile.mbt
index ac359a86..36e3aca0 100644
--- a/modules/bit_pack/src/packfile.mbt
+++ b/modules/bit_pack/src/packfile.mbt
@@ -459,7 +459,7 @@ fn build_delta_with_index(
   let base_len = base.length()
   let target_len = target.length()
   // Pre-allocate output buffer: delta is typically smaller than target
-  let out : Array[Byte] = Array::new(capacity=target_len / 2 + 32)
+  let out : Array[Byte] = Array(capacity=target_len / 2 + 32)
   encode_delta_size(base_len, out)
   encode_delta_size(target_len, out)
   if target_len == 0 {
@@ -1361,7 +1361,7 @@ fn build_tree_content(entries : Array[@bit.TreeEntry]) -> Bytes {
 ///|
 /// Build raw commit content (without "commit {size}\0" header)
 fn build_commit_content(commit : @bit.Commit) -> Bytes {
-  let content = StringBuilder::new()
+  let content = StringBuilder()
   content.write_string("tree ")
   content.write_string(commit.tree.to_hex())
   content.write_char('\n')
diff --git a/modules/bit_pack/src/packfile_parse.mbt b/modules/bit_pack/src/packfile_parse.mbt
index 6478c9e3..dbbbf68e 100644
--- a/modules/bit_pack/src/packfile_parse.mbt
+++ b/modules/bit_pack/src/packfile_parse.mbt
@@ -505,8 +505,8 @@ fn parse_packfile_internal(
   }
   let count = read_u32_be(data, 8)
   let mut offset = 12
-  let objects : Array[@bit.PackObject] = Array::new(capacity=count)
-  let resolved : Array[Bool] = Array::new(capacity=count)
+  let objects : Array[@bit.PackObject] = Array(capacity=count)
+  let resolved : Array[Bool] = Array(capacity=count)
   let pending : Array[PendingDelta] = []
   for _ in 0..<count {
     let obj_offset = offset
diff --git a/modules/bit_protocol/src/pktline.mbt b/modules/bit_protocol/src/pktline.mbt
index 3b981581..b968276a 100644
--- a/modules/bit_protocol/src/pktline.mbt
+++ b/modules/bit_protocol/src/pktline.mbt
@@ -80,7 +80,7 @@ pub fn pktline_decode(data : Bytes) -> Array[(Bytes, Bool)] raise @bit.GitError
     }
 
     // Read 4-byte hex length
-    let len_str = StringBuilder::new()
+    let len_str = StringBuilder()
     for i in 0..<4 {
       len_str.write_char(data[offset + i].to_int().unsafe_to_char())
     }
@@ -199,7 +199,7 @@ pub fn parse_refs(
       continue
     }
     let chars = line.to_array()
-    let sha_str = StringBuilder::new()
+    let sha_str = StringBuilder()
     for i in 0..<40 {
       sha_str.write_char(chars[i])
     }
@@ -210,7 +210,7 @@ pub fn parse_refs(
     }
 
     // Read refname until null or newline
-    let refname = StringBuilder::new()
+    let refname = StringBuilder()
     for i = 41; i < chars.length(); i = i + 1 {
       if chars[i] == '\u0000' || chars[i] == '\n' {
         break
@@ -225,7 +225,7 @@ pub fn parse_refs(
 
 ///|
 fn pkt_bytes_to_string(data : Bytes) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for b in data {
     result.write_char(b.to_int().unsafe_to_char())
   }
diff --git a/modules/bit_protocol/src/pktline_test.mbt b/modules/bit_protocol/src/pktline_test.mbt
index c538d046..ca19f901 100644
--- a/modules/bit_protocol/src/pktline_test.mbt
+++ b/modules/bit_protocol/src/pktline_test.mbt
@@ -67,7 +67,7 @@ test "pktline encode decode roundtrip" {
   inspect(decoded.length(), content="1")
   let (payload, is_flush) = decoded[0]
   inspect(is_flush, content="false")
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for b in payload {
     result.write_char(b.to_int().unsafe_to_char())
   }
diff --git a/modules/bit_protocol/src/remote_common.mbt b/modules/bit_protocol/src/remote_common.mbt
index 187b5003..808adf02 100644
--- a/modules/bit_protocol/src/remote_common.mbt
+++ b/modules/bit_protocol/src/remote_common.mbt
@@ -24,7 +24,7 @@ pub fn Remote::new(url : String) -> Remote {
 fn normalize_url(url : String) -> String {
   if url.has_suffix(".git") {
     let chars = url.to_array()
-    let result = StringBuilder::new()
+    let result = StringBuilder()
     for i in 0..<(chars.length() - 4) {
       result.write_char(chars[i])
     }
@@ -261,7 +261,7 @@ pub fn extract_capabilities(data : Bytes) -> Array[String] {
         for c in caps_str {
           if c == ' ' || c == '\n' {
             if current.length() > 0 {
-              let sb = StringBuilder::new()
+              let sb = StringBuilder()
               for ch in current {
                 sb.write_char(ch)
               }
@@ -273,7 +273,7 @@ pub fn extract_capabilities(data : Bytes) -> Array[String] {
           }
         }
         if current.length() > 0 {
-          let sb = StringBuilder::new()
+          let sb = StringBuilder()
           for ch in current {
             sb.write_char(ch)
           }
@@ -292,7 +292,7 @@ fn remote_substring_from(s : String, start : Int) -> String {
   if start >= chars.length() {
     return ""
   }
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i in start..<chars.length() {
     result.write_char(chars[i])
   }
@@ -301,7 +301,7 @@ fn remote_substring_from(s : String, start : Int) -> String {
 
 ///|
 fn remote_bytes_to_string(data : Bytes) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for b in data {
     result.write_char(b.to_int().unsafe_to_char())
   }
diff --git a/modules/bit_protocol/src/upload_pack_common.mbt b/modules/bit_protocol/src/upload_pack_common.mbt
index 3f047e0b..3c2c8a7e 100644
--- a/modules/bit_protocol/src/upload_pack_common.mbt
+++ b/modules/bit_protocol/src/upload_pack_common.mbt
@@ -555,7 +555,7 @@ fn trim_newline(s : String) -> String {
 
 ///|
 fn bytes_to_string(data : Bytes) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for b in data {
     result.write_char(b.to_int().unsafe_to_char())
   }
@@ -567,7 +567,7 @@ fn bytes_to_string_from(data : Bytes, start : Int) -> String {
   if start >= data.length() {
     return ""
   }
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i in start..<data.length() {
     result.write_char(data[i].to_int().unsafe_to_char())
   }
@@ -577,12 +577,12 @@ fn bytes_to_string_from(data : Bytes, start : Int) -> String {
 ///|
 fn split_by_space(s : String) -> Array[String] {
   let parts : Array[String] = []
-  let mut current = StringBuilder::new()
+  let mut current = StringBuilder()
   for c in s {
     if c == ' ' {
       if current.to_string().length() > 0 {
         parts.push(current.to_string())
-        current = StringBuilder::new()
+        current = StringBuilder()
       }
     } else {
       current.write_char(c)
diff --git a/modules/bit_protocol/src/upload_pack_http_wbtest.mbt b/modules/bit_protocol/src/upload_pack_http_wbtest.mbt
index 2dceadf2..81b53c2b 100644
--- a/modules/bit_protocol/src/upload_pack_http_wbtest.mbt
+++ b/modules/bit_protocol/src/upload_pack_http_wbtest.mbt
@@ -29,7 +29,7 @@ fn upload_pack_http_hex_to_bytes(hex : String) -> Bytes {
 
 ///|
 fn upload_pack_http_bytes_to_string(bytes : Bytes) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for b in bytes {
     sb.write_char(b.to_int().unsafe_to_char())
   }
diff --git a/modules/bit_refs/src/bench_test.mbt b/modules/bit_refs/src/bench_test.mbt
index 26752615..bac90a90 100644
--- a/modules/bit_refs/src/bench_test.mbt
+++ b/modules/bit_refs/src/bench_test.mbt
@@ -34,7 +34,7 @@ fn setup_packed_refs_repo(ref_count : Int) -> @bit.TestFs {
   let git_dir = bench_refs_root + "/.git"
   fs.mkdir_p(git_dir + "/refs")
   fs.write_string(git_dir + "/HEAD", "ref: refs/heads/main\n")
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("# pack-refs with: peeled fully-peeled sorted \n")
   let fake_id = "0123456789abcdef0123456789abcdef01234567"
   for i in 0..<ref_count {
diff --git a/modules/bit_refs/src/refs_store.mbt b/modules/bit_refs/src/refs_store.mbt
index c914ec0e..a119fbbd 100644
--- a/modules/bit_refs/src/refs_store.mbt
+++ b/modules/bit_refs/src/refs_store.mbt
@@ -243,7 +243,7 @@ pub fn serialize_packed_refs_entries(entries : Array[PackedRefEntry]) -> String
   // NOTE: String::compare is length-first in MoonBit; git requires plain
   // byte order (memcmp) for the `sorted` trait, which lexical_compare gives.
   unique.sort_by((a, b) => String::lexical_compare(a.refname, b.refname))
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   // Trailing space after "sorted" matches real git's header byte-for-byte.
   buf.write_string("# pack-refs with: peeled fully-peeled sorted \n")
   for e in unique {
diff --git a/modules/bit_reftable/src/reftable.mbt b/modules/bit_reftable/src/reftable.mbt
index c34d0b1d..9b233050 100644
--- a/modules/bit_reftable/src/reftable.mbt
+++ b/modules/bit_reftable/src/reftable.mbt
@@ -49,7 +49,7 @@ pub(all) struct RefRecord {
 
 ///|
 fn reftable_show_string(value : String) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_char('"')
   for c in value {
     if c == '"' {
@@ -241,7 +241,7 @@ pub fn parse_footer(data : Bytes) -> ReftableFooter? {
 ///|
 /// Extract a UTF-8 string from bytes.
 fn bytes_to_string(data : Bytes, start : Int, len : Int) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for i = start; i < start + len; i = i + 1 {
     buf.write_char(Int::unsafe_to_char(data[i].to_int()))
   }
@@ -272,7 +272,7 @@ pub fn decode_ref_record(
   let suffix_len = (suffix_and_type >> 3).to_int()
   let prefix_len_int = prefix_len.to_int()
   // Reconstruct key
-  let key_buf = StringBuilder::new()
+  let key_buf = StringBuilder()
   for i = 0; i < prefix_len_int; i = i + 1 {
     if i < prev_key.length() {
       key_buf.write_char(Int::unsafe_to_char(prev_key[i].to_int()))
diff --git a/modules/bit_reftable/src/stack.mbt b/modules/bit_reftable/src/stack.mbt
index 50ec33fb..15a2b319 100644
--- a/modules/bit_reftable/src/stack.mbt
+++ b/modules/bit_reftable/src/stack.mbt
@@ -19,7 +19,7 @@ pub fn read_tables_list(
 ///|
 fn split_lines(s : String) -> Array[String] {
   let lines : Array[String] = []
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for i = 0; i < s.length(); i = i + 1 {
     let ch = s[i].to_int()
     if ch == 0x0a {
diff --git a/modules/bit_remote/src/remote_path.mbt b/modules/bit_remote/src/remote_path.mbt
index 26af3b6c..a1804b70 100644
--- a/modules/bit_remote/src/remote_path.mbt
+++ b/modules/bit_remote/src/remote_path.mbt
@@ -33,7 +33,7 @@ fn hex_char_to_int(c : Char) -> Int? {
 
 ///|
 fn decode_file_url_path(path : String) -> String {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   let mut i = 0
   while i < path.length() {
     let c = path.unsafe_get(i).to_int().unsafe_to_char()
diff --git a/modules/bit_remote/src/remote_shorthand.mbt b/modules/bit_remote/src/remote_shorthand.mbt
index e298f193..82c2b8ae 100644
--- a/modules/bit_remote/src/remote_shorthand.mbt
+++ b/modules/bit_remote/src/remote_shorthand.mbt
@@ -11,7 +11,7 @@ pub(all) enum GitHubShorthand {
 
 ///|
 fn remote_shorthand_show_string(value : String) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_char('"')
   for c in value {
     if c == '"' {
diff --git a/modules/bit_repo/src/core.mbt b/modules/bit_repo/src/core.mbt
index 0474eaff..967fa8c4 100644
--- a/modules/bit_repo/src/core.mbt
+++ b/modules/bit_repo/src/core.mbt
@@ -103,7 +103,7 @@ fn parse_tree_with_hash_size(
   let mut i = 0
   while i < content.length() {
     // Parse mode (ASCII only, so byte-by-byte is fine)
-    let mode_buf = StringBuilder::new()
+    let mode_buf = StringBuilder()
     while i < content.length() && content[i] != b' ' {
       mode_buf.write_char(content[i].to_int().unsafe_to_char())
       i += 1
diff --git a/modules/bit_repo_ops/src/revparse_ops.mbt b/modules/bit_repo_ops/src/revparse_ops.mbt
index 6ff85b2b..6adfac52 100644
--- a/modules/bit_repo_ops/src/revparse_ops.mbt
+++ b/modules/bit_repo_ops/src/revparse_ops.mbt
@@ -672,7 +672,7 @@ fn revparse_read_graft_parents(
 ///|
 fn substring_revparse(s : String, start : Int, end : Int) -> String {
   let chars = s.to_array()
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i = start; i < end && i < chars.length(); i = i + 1 {
     result.write_char(chars[i])
   }
@@ -732,7 +732,7 @@ fn resolve_index_stage_entry(
       }
       len
     }
-    let entry_path_buf = StringBuilder::new()
+    let entry_path_buf = StringBuilder()
     for i in 0..<actual_len {
       if path_start + i < data.length() {
         entry_path_buf.write_char(
@@ -1250,9 +1250,7 @@ pub fn show_ref(
   if fs.is_file(packed) {
     ref_collect_packed(fs, packed, out)
   }
-  let result : Array[(String, @object.ObjectId)] = Array::new(
-    capacity=out.length(),
-  )
+  let result : Array[(String, @object.ObjectId)] = Array(capacity=out.length())
   for name, id in out {
     result.push((name, id))
   }
diff --git a/modules/bit_runtime/src/moon.pkg b/modules/bit_runtime/src/moon.pkg
index 7191cf6c..19e6b604 100644
--- a/modules/bit_runtime/src/moon.pkg
+++ b/modules/bit_runtime/src/moon.pkg
@@ -11,7 +11,6 @@ import {
   "moonbitlang/core/env",
   "moonbitlang/core/string",
   "moonbitlang/core/strconv",
-  "moonbitlang/x/sys",
 }
 
 warnings = "-29"
diff --git a/modules/bit_runtime/src/storage_runtime.mbt b/modules/bit_runtime/src/storage_runtime.mbt
index e986ce13..ea216959 100644
--- a/modules/bit_runtime/src/storage_runtime.mbt
+++ b/modules/bit_runtime/src/storage_runtime.mbt
@@ -156,7 +156,7 @@ fn storage_default_repo_marker_path(
 ///|
 fn storage_resolve_git_dir(rfs : &@bit.RepoFileSystem, root : String) -> String {
   let default_git_dir = storage_default_repo_marker_path(rfs, root)
-  match @sys.get_env_var("GIT_DIR") {
+  match @env.get_env_var("GIT_DIR") {
     Some(dir) => {
       let resolved = if dir.has_prefix("/") {
         dir
@@ -343,9 +343,9 @@ fn storage_get_current_timestamp() -> Int64 {
 
 ///|
 fn storage_get_author_string() -> String {
-  match @sys.get_env_var("GIT_AUTHOR_NAME") {
+  match @env.get_env_var("GIT_AUTHOR_NAME") {
     Some(name) => {
-      let email = @sys.get_env_var("GIT_AUTHOR_EMAIL").unwrap_or("unknown")
+      let email = @env.get_env_var("GIT_AUTHOR_EMAIL").unwrap_or("unknown")
       name + " <" + email + ">"
     }
     None => storage_get_user_from_config()
@@ -356,11 +356,11 @@ fn storage_get_author_string() -> String {
 fn storage_get_user_from_config() -> String {
   // env BIT_COMMIT_AUTHOR is set by cmd/bit commit handler
   // to pass resolved author from git config
-  match @sys.get_env_var("BIT_COMMIT_AUTHOR") {
+  match @env.get_env_var("BIT_COMMIT_AUTHOR") {
     Some(a) if a.length() > 0 => return a
     _ => ()
   }
-  match @sys.get_env_var("USER") {
+  match @env.get_env_var("USER") {
     Some(user) => user + " <" + user + "@localhost>"
     None => "Unknown <unknown@localhost>"
   }
@@ -368,14 +368,14 @@ fn storage_get_user_from_config() -> String {
 
 ///|
 fn storage_get_committer_string() -> String {
-  match @sys.get_env_var("GIT_COMMITTER_NAME") {
+  match @env.get_env_var("GIT_COMMITTER_NAME") {
     Some(name) => {
-      let email = @sys.get_env_var("GIT_COMMITTER_EMAIL").unwrap_or("unknown")
+      let email = @env.get_env_var("GIT_COMMITTER_EMAIL").unwrap_or("unknown")
       name + " <" + email + ">"
     }
     None =>
       // env BIT_COMMIT_COMMITTER is set by cmd/bit commit handler
-      match @sys.get_env_var("BIT_COMMIT_COMMITTER") {
+      match @env.get_env_var("BIT_COMMIT_COMMITTER") {
         Some(c) if c.length() > 0 => c
         _ => storage_get_author_string()
       }
@@ -384,7 +384,7 @@ fn storage_get_committer_string() -> String {
 
 ///|
 fn storage_get_commit_timestamp() -> Int64 {
-  match @sys.get_env_var("GIT_COMMITTER_DATE") {
+  match @env.get_env_var("GIT_COMMITTER_DATE") {
     Some(raw) =>
       match storage_parse_git_env_timestamp(raw) {
         Some(ts) => ts
@@ -396,7 +396,7 @@ fn storage_get_commit_timestamp() -> Int64 {
 
 ///|
 fn storage_get_author_timestamp() -> Int64 {
-  match @sys.get_env_var("GIT_AUTHOR_DATE") {
+  match @env.get_env_var("GIT_AUTHOR_DATE") {
     Some(raw) =>
       match storage_parse_git_env_timestamp(raw) {
         Some(ts) => ts
@@ -446,7 +446,7 @@ fn storage_parse_git_env_timezone(raw : String) -> String? {
 
 ///|
 fn storage_get_commit_timezone() -> String {
-  match @sys.get_env_var("GIT_COMMITTER_DATE") {
+  match @env.get_env_var("GIT_COMMITTER_DATE") {
     Some(raw) =>
       match storage_parse_git_env_timezone(raw) {
         Some(tz) => tz
@@ -458,7 +458,7 @@ fn storage_get_commit_timezone() -> String {
 
 ///|
 fn storage_get_author_timezone() -> String {
-  match @sys.get_env_var("GIT_AUTHOR_DATE") {
+  match @env.get_env_var("GIT_AUTHOR_DATE") {
     Some(raw) =>
       match storage_parse_git_env_timezone(raw) {
         Some(tz) => tz
@@ -580,7 +580,7 @@ fn storage_fail_unsupported_mode(
 
 ///|
 fn storage_runtime_is_quiet() -> Bool {
-  match @sys.get_env_var("BIT_STORAGE_RUNTIME_QUIET") {
+  match @env.get_env_var("BIT_STORAGE_RUNTIME_QUIET") {
     Some(value) => {
       let normalized = storage_trim_string(value).to_lower()
       normalized == "1" || normalized == "true" || normalized == "yes"
@@ -1174,7 +1174,7 @@ fn storage_handle_hash_object(
   root : String,
   args : StorageHashObjectArgs,
 ) -> Unit raise Error {
-  let cwd = match @sys.get_env_var("GIT_SHIM_PWD") {
+  let cwd = match @env.get_env_var("GIT_SHIM_PWD") {
     Some(path) => path
     None =>
       match @env.current_dir() {
diff --git a/modules/bit_runtime/src/storage_runtime_wbtest.mbt b/modules/bit_runtime/src/storage_runtime_wbtest.mbt
index f6d9b344..c9171df5 100644
--- a/modules/bit_runtime/src/storage_runtime_wbtest.mbt
+++ b/modules/bit_runtime/src/storage_runtime_wbtest.mbt
@@ -49,15 +49,15 @@ fn restore_env_var_for_storage_runtime_wbtest(
   prev : String?,
 ) -> Unit {
   match prev {
-    Some(value) => @sys.set_env_var(name, value)
-    None => @sys.unset_env_var(name)
+    Some(value) => @env.set_env_var(name, value)
+    None => @env.unset_env_var(name)
   }
 }
 
 ///|
 fn setup_storage_runtime_quiet_for_wbtest() -> String? {
-  let prev = @sys.get_env_var("BIT_STORAGE_RUNTIME_QUIET")
-  @sys.set_env_var("BIT_STORAGE_RUNTIME_QUIET", "1")
+  let prev = @env.get_env_var("BIT_STORAGE_RUNTIME_QUIET")
+  @env.set_env_var("BIT_STORAGE_RUNTIME_QUIET", "1")
   prev
 }
 
@@ -68,14 +68,14 @@ fn setup_identity_for_storage_runtime_wbtest() -> (
   String?,
   String?,
 ) {
-  let prev_author_name = @sys.get_env_var("GIT_AUTHOR_NAME")
-  let prev_author_email = @sys.get_env_var("GIT_AUTHOR_EMAIL")
-  let prev_committer_name = @sys.get_env_var("GIT_COMMITTER_NAME")
-  let prev_committer_email = @sys.get_env_var("GIT_COMMITTER_EMAIL")
-  @sys.set_env_var("GIT_AUTHOR_NAME", "Storage Test")
-  @sys.set_env_var("GIT_AUTHOR_EMAIL", "storage@example.com")
-  @sys.set_env_var("GIT_COMMITTER_NAME", "Storage Test")
-  @sys.set_env_var("GIT_COMMITTER_EMAIL", "storage@example.com")
+  let prev_author_name = @env.get_env_var("GIT_AUTHOR_NAME")
+  let prev_author_email = @env.get_env_var("GIT_AUTHOR_EMAIL")
+  let prev_committer_name = @env.get_env_var("GIT_COMMITTER_NAME")
+  let prev_committer_email = @env.get_env_var("GIT_COMMITTER_EMAIL")
+  @env.set_env_var("GIT_AUTHOR_NAME", "Storage Test")
+  @env.set_env_var("GIT_AUTHOR_EMAIL", "storage@example.com")
+  @env.set_env_var("GIT_COMMITTER_NAME", "Storage Test")
+  @env.set_env_var("GIT_COMMITTER_EMAIL", "storage@example.com")
   (
     prev_author_name, prev_author_email, prev_committer_name, prev_committer_email,
   )
@@ -107,10 +107,10 @@ fn setup_commit_date_for_storage_runtime_wbtest(
   author_date : String,
   committer_date : String,
 ) -> (String?, String?) {
-  let prev_author_date = @sys.get_env_var("GIT_AUTHOR_DATE")
-  let prev_committer_date = @sys.get_env_var("GIT_COMMITTER_DATE")
-  @sys.set_env_var("GIT_AUTHOR_DATE", author_date)
-  @sys.set_env_var("GIT_COMMITTER_DATE", committer_date)
+  let prev_author_date = @env.get_env_var("GIT_AUTHOR_DATE")
+  let prev_committer_date = @env.get_env_var("GIT_COMMITTER_DATE")
+  @env.set_env_var("GIT_AUTHOR_DATE", author_date)
+  @env.set_env_var("GIT_COMMITTER_DATE", committer_date)
   (prev_author_date, prev_committer_date)
 }
 
@@ -340,8 +340,8 @@ test "storage runtime: hash-object -w and write-tree work on TestFs" {
   let fs = @bit.TestFs::new()
   let root = "/repo-storage-runtime-objects"
   let prev_quiet = setup_storage_runtime_quiet_for_wbtest()
-  let prev_shim_pwd = @sys.get_env_var("GIT_SHIM_PWD")
-  @sys.set_env_var("GIT_SHIM_PWD", root)
+  let prev_shim_pwd = @env.get_env_var("GIT_SHIM_PWD")
+  @env.set_env_var("GIT_SHIM_PWD", root)
   run_storage_command(fs, fs, root, storage_runtime_wbtest_init_command()) catch {
     err => fail("init failed: \{err}")
   }
diff --git a/modules/bit_trailers/src/trailers.mbt b/modules/bit_trailers/src/trailers.mbt
index 266d10df..62723a11 100644
--- a/modules/bit_trailers/src/trailers.mbt
+++ b/modules/bit_trailers/src/trailers.mbt
@@ -192,7 +192,7 @@ fn trailers_split(input : String) -> (String, Array[String]) {
     trailers.push(lines[ti])
     ti += 1
   }
-  let body_sb = StringBuilder::new()
+  let body_sb = StringBuilder()
   let mut bi = 0
   while bi < trailer_start {
     body_sb.write_string(lines[bi])
@@ -210,7 +210,7 @@ pub fn add_trailer(message : String, key : String, value : String) -> String {
   let all_trailers : Array[String] = []
   all_trailers.append(existing)
   all_trailers.push(trailers_normalize("\{key}: \{value}"))
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   result.write_string(body)
   // Ensure blank line before trailers if body doesn't end with one
   if body.length() > 0 && !body.has_suffix("\n\n") {
diff --git a/modules/bit_utils/src/string_utils.mbt b/modules/bit_utils/src/string_utils.mbt
index b9fa0110..f62aba2e 100644
--- a/modules/bit_utils/src/string_utils.mbt
+++ b/modules/bit_utils/src/string_utils.mbt
@@ -14,7 +14,7 @@ pub fn to_octal_string(value : Int) -> String {
     v = v / 8
   }
   let rev = digits.rev()
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for c in rev {
     sb.write_char(c)
   }
diff --git a/modules/bit_vfs/src/bench_real_test.mbt b/modules/bit_vfs/src/bench_real_test.mbt
index a3dfc905..dc39be77 100644
--- a/modules/bit_vfs/src/bench_real_test.mbt
+++ b/modules/bit_vfs/src/bench_real_test.mbt
@@ -22,7 +22,7 @@
 /// Get the git directory path for benchmarks
 /// Uses BIT_BENCH_GIT_DIR when set, otherwise a local fallback.
 fn get_bench_git_dir() -> String {
-  match @sys.get_env_var("BIT_BENCH_GIT_DIR") {
+  match @env.get_env_var("BIT_BENCH_GIT_DIR") {
     Some(dir) => dir
     None => "/Users/mz/ghq/github.com/mizchi/git/.git"
   }
diff --git a/modules/bit_vfs/src/integration_test.mbt b/modules/bit_vfs/src/integration_test.mbt
index 86bf3f1d..69d4a5c0 100644
--- a/modules/bit_vfs/src/integration_test.mbt
+++ b/modules/bit_vfs/src/integration_test.mbt
@@ -228,7 +228,7 @@ fn file_exists_in_base(
 ///|
 /// Print changes in a readable format
 fn format_changes(changes : Array[FileChange]) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("Changes:\n")
   for change in changes {
     let prefix = match change.change_type {
diff --git a/modules/bit_vfs/src/moon.pkg b/modules/bit_vfs/src/moon.pkg
index 9e073b76..002dde0a 100644
--- a/modules/bit_vfs/src/moon.pkg
+++ b/modules/bit_vfs/src/moon.pkg
@@ -13,8 +13,8 @@ import {
   "mizchi/bit_osfs" @osfs,
   "mizchi/zlib",
   "moonbitlang/core/bench",
+  "moonbitlang/core/env",
   "moonbitlang/async",
-  "moonbitlang/x/sys",
   "moonbitlang/core/test",
 } for "test"
 
diff --git a/modules/bit_vfs/src/snapshot.mbt b/modules/bit_vfs/src/snapshot.mbt
index 70c7daa4..60b60087 100644
--- a/modules/bit_vfs/src/snapshot.mbt
+++ b/modules/bit_vfs/src/snapshot.mbt
@@ -109,7 +109,7 @@ fn parse_commit_details(content : Bytes) -> (String, Int64, String) {
   let mut author = ""
   let mut timestamp = 0L
   let mut in_message = false
-  let message_buf = StringBuilder::new()
+  let message_buf = StringBuilder()
   for line_view in text.split("\n") {
     let line = line_view.to_owned()
     if in_message {
diff --git a/modules/bit_vfs/src/tree_builder.mbt b/modules/bit_vfs/src/tree_builder.mbt
index 3f2c31ce..2ccf617a 100644
--- a/modules/bit_vfs/src/tree_builder.mbt
+++ b/modules/bit_vfs/src/tree_builder.mbt
@@ -328,7 +328,7 @@ fn to_octal_string(value : Int) -> String {
     v = v / 8
   }
   let rev = digits.rev()
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   for c in rev {
     sb.write_char(c)
   }
diff --git a/modules/bitx_bitconfig/src/load.mbt b/modules/bitx_bitconfig/src/load.mbt
index d759d89d..11e236db 100644
--- a/modules/bitx_bitconfig/src/load.mbt
+++ b/modules/bitx_bitconfig/src/load.mbt
@@ -1,7 +1,7 @@
 ///|
 /// ~/.config/bit/bitconfig.toml のパスを解決
 fn config_path() -> String? {
-  match @sys.get_env_var("HOME") {
+  match @env.get_env_var("HOME") {
     Some(home) => Some(home + "/.config/bit/bitconfig.toml")
     None => None
   }
@@ -43,9 +43,9 @@ fn get_table(
 ///|
 /// 環境変数が未設定の場合のみ値を注入
 fn inject_if_unset(env_key : String, value : String) -> Unit {
-  match @sys.get_env_var(env_key) {
+  match @env.get_env_var(env_key) {
     Some(existing) if existing.length() > 0 => () // 既存値を優先
-    _ => @sys.set_env_var(env_key, value)
+    _ => @env.set_env_var(env_key, value)
   }
 }
 
@@ -137,7 +137,7 @@ pub fn load_and_inject() -> Unit {
   let content = @fs.read_file_to_string(path) catch { _ => return }
   let root = @toml.parse(content) catch { _ => return }
   guard root is @toml.TomlValue::TomlTable(top) else { return }
-  let home = @sys.get_env_var("HOME").unwrap_or("")
+  let home = @env.get_env_var("HOME").unwrap_or("")
   // [bit.*] セクションから bit 固有の設定を注入
   if get_table(top, "bit") is Some(bit) {
     inject_from_bit_table(bit, home)
diff --git a/modules/bitx_bitconfig/src/load_wbtest.mbt b/modules/bitx_bitconfig/src/load_wbtest.mbt
index a13028fc..9a2904b8 100644
--- a/modules/bitx_bitconfig/src/load_wbtest.mbt
+++ b/modules/bitx_bitconfig/src/load_wbtest.mbt
@@ -50,28 +50,28 @@ test "expand_home expands tilde prefix" {
 ///|
 test "inject_if_unset sets when unset" {
   let key = "BIT_TEST_INJECT_UNSET_1"
-  @sys.unset_env_var(key)
+  @env.unset_env_var(key)
   inject_if_unset(key, "hello")
-  @test.assert_eq(@sys.get_env_var(key), Some("hello"))
-  @sys.unset_env_var(key)
+  @test.assert_eq(@env.get_env_var(key), Some("hello"))
+  @env.unset_env_var(key)
 }
 
 ///|
 test "inject_if_unset preserves existing value" {
   let key = "BIT_TEST_INJECT_UNSET_2"
-  @sys.set_env_var(key, "original")
+  @env.set_env_var(key, "original")
   inject_if_unset(key, "new")
-  @test.assert_eq(@sys.get_env_var(key), Some("original"))
-  @sys.unset_env_var(key)
+  @test.assert_eq(@env.get_env_var(key), Some("original"))
+  @env.unset_env_var(key)
 }
 
 ///|
 test "inject_if_unset overwrites empty string" {
   let key = "BIT_TEST_INJECT_UNSET_3"
-  @sys.set_env_var(key, "")
+  @env.set_env_var(key, "")
   inject_if_unset(key, "filled")
-  @test.assert_eq(@sys.get_env_var(key), Some("filled"))
-  @sys.unset_env_var(key)
+  @test.assert_eq(@env.get_env_var(key), Some("filled"))
+  @env.unset_env_var(key)
 }
 
 ///|
@@ -83,7 +83,7 @@ test "inject_from_bit_table injects all sections" {
     "BIT_COLLAB_SIGN_KEY", "BIT_COLLAB_REQUIRE_SIGNED",
   ]
   for key in keys {
-    @sys.unset_env_var(key)
+    @env.unset_env_var(key)
   }
   let toml_str =
     #|[bit.user]
@@ -112,40 +112,40 @@ test "inject_from_bit_table injects all sections" {
   guard root is @toml.TomlValue::TomlTable(top) else { fail("expected table") }
   guard get_table(top, "bit") is Some(bit) else { fail("expected [bit] table") }
   inject_from_bit_table(bit, "/home/test")
-  @test.assert_eq(@sys.get_env_var("BIT_RELAY_SENDER"), Some("mizchi"))
-  @test.assert_eq(@sys.get_env_var("BIT_GITHUB_USERNAME"), Some("mizchi"))
+  @test.assert_eq(@env.get_env_var("BIT_RELAY_SENDER"), Some("mizchi"))
+  @test.assert_eq(@env.get_env_var("BIT_GITHUB_USERNAME"), Some("mizchi"))
   @test.assert_eq(
-    @sys.get_env_var("BIT_RELAY_URL"),
+    @env.get_env_var("BIT_RELAY_URL"),
     Some("relay+https://relay.sprites.dev"),
   )
   @test.assert_eq(
-    @sys.get_env_var("BIT_RELAY_AUTH_TOKEN"),
+    @env.get_env_var("BIT_RELAY_AUTH_TOKEN"),
     Some("secret-token"),
   )
   @test.assert_eq(
-    @sys.get_env_var("BIT_RELAY_SIGN_PRIVATE_KEY_FILE"),
+    @env.get_env_var("BIT_RELAY_SIGN_PRIVATE_KEY_FILE"),
     Some("/home/test/.config/bit/keys/ed25519.pem"),
   )
   @test.assert_eq(
-    @sys.get_env_var("BIT_RELAY_SIGN_PUBLIC_KEY"),
+    @env.get_env_var("BIT_RELAY_SIGN_PUBLIC_KEY"),
     Some("base64url_encoded_public_key"),
   )
-  @test.assert_eq(@sys.get_env_var("BIT_SERVE_ALLOW_PUSH"), Some("false"))
-  @test.assert_eq(@sys.get_env_var("BIT_SERVE_BROADCAST"), Some("true"))
-  @test.assert_eq(@sys.get_env_var("BIT_SERVE_AUTO_FETCH"), Some("false"))
-  @test.assert_eq(@sys.get_env_var("BIT_SERVE_ROOM"), Some("my-room"))
-  @test.assert_eq(@sys.get_env_var("BIT_HUB_CONFLICT_POLICY"), Some("ours"))
-  @test.assert_eq(@sys.get_env_var("BIT_COLLAB_SIGN_KEY"), Some("key-value"))
-  @test.assert_eq(@sys.get_env_var("BIT_COLLAB_REQUIRE_SIGNED"), Some("true"))
+  @test.assert_eq(@env.get_env_var("BIT_SERVE_ALLOW_PUSH"), Some("false"))
+  @test.assert_eq(@env.get_env_var("BIT_SERVE_BROADCAST"), Some("true"))
+  @test.assert_eq(@env.get_env_var("BIT_SERVE_AUTO_FETCH"), Some("false"))
+  @test.assert_eq(@env.get_env_var("BIT_SERVE_ROOM"), Some("my-room"))
+  @test.assert_eq(@env.get_env_var("BIT_HUB_CONFLICT_POLICY"), Some("ours"))
+  @test.assert_eq(@env.get_env_var("BIT_COLLAB_SIGN_KEY"), Some("key-value"))
+  @test.assert_eq(@env.get_env_var("BIT_COLLAB_REQUIRE_SIGNED"), Some("true"))
   for key in keys {
-    @sys.unset_env_var(key)
+    @env.unset_env_var(key)
   }
 }
 
 ///|
 test "inject_from_bit_table respects existing env vars" {
   let key = "BIT_RELAY_SENDER"
-  @sys.set_env_var(key, "existing-sender")
+  @env.set_env_var(key, "existing-sender")
   let toml_str =
     #|[bit.user]
     #|sender = "new-sender"
@@ -153,14 +153,14 @@ test "inject_from_bit_table respects existing env vars" {
   guard root is @toml.TomlValue::TomlTable(top) else { fail("expected table") }
   guard get_table(top, "bit") is Some(bit) else { fail("expected [bit] table") }
   inject_from_bit_table(bit, "/home/test")
-  @test.assert_eq(@sys.get_env_var(key), Some("existing-sender"))
-  @sys.unset_env_var(key)
+  @test.assert_eq(@env.get_env_var(key), Some("existing-sender"))
+  @env.unset_env_var(key)
 }
 
 ///|
 test "inject_from_bit_table handles partial config" {
-  @sys.unset_env_var("BIT_RELAY_SENDER")
-  @sys.unset_env_var("BIT_RELAY_URL")
+  @env.unset_env_var("BIT_RELAY_SENDER")
+  @env.unset_env_var("BIT_RELAY_URL")
   let toml_str =
     #|[bit.user]
     #|sender = "mizchi"
@@ -168,14 +168,14 @@ test "inject_from_bit_table handles partial config" {
   guard root is @toml.TomlValue::TomlTable(top) else { fail("expected table") }
   guard get_table(top, "bit") is Some(bit) else { fail("expected [bit] table") }
   inject_from_bit_table(bit, "/home/test")
-  @test.assert_eq(@sys.get_env_var("BIT_RELAY_SENDER"), Some("mizchi"))
-  @test.assert_eq(@sys.get_env_var("BIT_RELAY_URL"), None)
-  @sys.unset_env_var("BIT_RELAY_SENDER")
+  @test.assert_eq(@env.get_env_var("BIT_RELAY_SENDER"), Some("mizchi"))
+  @test.assert_eq(@env.get_env_var("BIT_RELAY_URL"), None)
+  @env.unset_env_var("BIT_RELAY_SENDER")
 }
 
 ///|
 test "no bit section does not crash" {
-  @sys.unset_env_var("BIT_RELAY_SENDER")
+  @env.unset_env_var("BIT_RELAY_SENDER")
   let toml_str =
     #|[user]
     #|name = "mizchi"
@@ -184,7 +184,7 @@ test "no bit section does not crash" {
   guard root is @toml.TomlValue::TomlTable(top) else { fail("expected table") }
   // no [bit] section — should be a no-op
   assert_true(get_table(top, "bit") is None)
-  @test.assert_eq(@sys.get_env_var("BIT_RELAY_SENDER"), None)
+  @test.assert_eq(@env.get_env_var("BIT_RELAY_SENDER"), None)
 }
 
 ///|
diff --git a/modules/bitx_bitconfig/src/moon.pkg b/modules/bitx_bitconfig/src/moon.pkg
index 225e4dc2..da36677c 100644
--- a/modules/bitx_bitconfig/src/moon.pkg
+++ b/modules/bitx_bitconfig/src/moon.pkg
@@ -1,6 +1,6 @@
 import {
   "bobzhang/toml",
-  "moonbitlang/x/sys",
+  "moonbitlang/core/env",
   "moonbitlang/x/fs",
 }
 
diff --git a/modules/bitx_hq/src/config.mbt b/modules/bitx_hq/src/config.mbt
index a19b23fc..4f5984d2 100644
--- a/modules/bitx_hq/src/config.mbt
+++ b/modules/bitx_hq/src/config.mbt
@@ -64,7 +64,7 @@ pub fn contract_home(path : String, home : String) -> String {
 ///|
 /// Safe string slice from start index to end
 fn slice_from(s : String, start : Int) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for i = start; i < s.length(); i = i + 1 {
     match s.get_char(i) {
       Some(c) => buf.write_char(c)
@@ -77,7 +77,7 @@ fn slice_from(s : String, start : Int) -> String {
 ///|
 /// Safe string slice from 0 to end index
 fn slice_to(s : String, end : Int) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for i = 0; i < end && i < s.length(); i = i + 1 {
     match s.get_char(i) {
       Some(c) => buf.write_char(c)
diff --git a/modules/bitx_hq/src/types.mbt b/modules/bitx_hq/src/types.mbt
index c877cd18..ec6eeef7 100644
--- a/modules/bitx_hq/src/types.mbt
+++ b/modules/bitx_hq/src/types.mbt
@@ -13,7 +13,7 @@ pub struct RepoPath {
 
 ///|
 fn hq_show_string(value : String) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_char('"')
   for c in value {
     if c == '"' {
diff --git a/modules/bitx_hq/src/url_parse.mbt b/modules/bitx_hq/src/url_parse.mbt
index 45a0a807..02f4db23 100644
--- a/modules/bitx_hq/src/url_parse.mbt
+++ b/modules/bitx_hq/src/url_parse.mbt
@@ -187,7 +187,7 @@ fn find_char(s : String, c : Char) -> Int? {
 ///|
 /// Join array of string views from start to end with "/"
 fn join_parts(parts : Array[StringView], start : Int, end : Int) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   for i = start; i < end; i = i + 1 {
     if i > start {
       buf.write_char('/')
diff --git a/modules/bitx_hub/src/claim.mbt b/modules/bitx_hub/src/claim.mbt
index b9165180..0b76edf4 100644
--- a/modules/bitx_hub/src/claim.mbt
+++ b/modules/bitx_hub/src/claim.mbt
@@ -38,7 +38,7 @@ pub struct ClaimMessage {
 
 ///|
 fn claim_show_string(value : String) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_char('"')
   for c in value {
     if c == '"' {
diff --git a/modules/bitx_hub/src/crypto/moon.pkg b/modules/bitx_hub/src/crypto/moon.pkg
index 3235041e..68450672 100644
--- a/modules/bitx_hub/src/crypto/moon.pkg
+++ b/modules/bitx_hub/src/crypto/moon.pkg
@@ -9,7 +9,6 @@ import {
   "moonbitlang/core/encoding/utf8",
   "moonbitlang/core/json",
   "moonbitlang/x/crypto" @mbcrypto,
-  "moonbitlang/x/sys",
 }
 
 import {
diff --git a/modules/bitx_hub/src/crypto/relay_sign.mbt b/modules/bitx_hub/src/crypto/relay_sign.mbt
index e6637705..5bd64ed2 100644
--- a/modules/bitx_hub/src/crypto/relay_sign.mbt
+++ b/modules/bitx_hub/src/crypto/relay_sign.mbt
@@ -16,7 +16,7 @@ pub struct RelayPublishHttpSignature {
 
 ///|
 pub fn relay_base64_to_base64url(base64 : String) -> String {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   for c in base64 {
     if c == '+' {
       out.write_char('-')
diff --git a/modules/bitx_hub/src/crypto/relay_sign_js.mbt b/modules/bitx_hub/src/crypto/relay_sign_js.mbt
index 1362a86d..650c5fe1 100644
--- a/modules/bitx_hub/src/crypto/relay_sign_js.mbt
+++ b/modules/bitx_hub/src/crypto/relay_sign_js.mbt
@@ -2,7 +2,7 @@
 
 ///|
 fn relay_sign_public_key() -> String? {
-  match @sys.get_env_var("BIT_RELAY_SIGN_PUBLIC_KEY") {
+  match @env.get_env_var("BIT_RELAY_SIGN_PUBLIC_KEY") {
     Some(value) => {
       let normalized = value.trim(chars=" \n\r\t").to_owned()
       if normalized.length() > 0 {
diff --git a/modules/bitx_hub/src/crypto/relay_sign_native.mbt b/modules/bitx_hub/src/crypto/relay_sign_native.mbt
index ef4181b1..a00bf0ad 100644
--- a/modules/bitx_hub/src/crypto/relay_sign_native.mbt
+++ b/modules/bitx_hub/src/crypto/relay_sign_native.mbt
@@ -10,7 +10,7 @@ pub fn relay_unix_timestamp_sec() -> Int64 {
 
 ///|
 fn relay_sign_private_key_file() -> String? {
-  match @sys.get_env_var("BIT_RELAY_SIGN_PRIVATE_KEY_FILE") {
+  match @env.get_env_var("BIT_RELAY_SIGN_PRIVATE_KEY_FILE") {
     Some(value) => {
       let normalized = value.trim(chars=" \n\r\t").to_owned()
       if normalized.length() > 0 {
@@ -25,7 +25,7 @@ fn relay_sign_private_key_file() -> String? {
 
 ///|
 fn relay_sign_public_key() -> String? {
-  match @sys.get_env_var("BIT_RELAY_SIGN_PUBLIC_KEY") {
+  match @env.get_env_var("BIT_RELAY_SIGN_PUBLIC_KEY") {
     Some(value) => {
       let normalized = value.trim(chars=" \n\r\t").to_owned()
       if normalized.length() > 0 {
diff --git a/modules/bitx_hub/src/crypto/relay_sign_web_wbtest.mbt b/modules/bitx_hub/src/crypto/relay_sign_web_wbtest.mbt
index 5212379a..4859f3c0 100644
--- a/modules/bitx_hub/src/crypto/relay_sign_web_wbtest.mbt
+++ b/modules/bitx_hub/src/crypto/relay_sign_web_wbtest.mbt
@@ -15,8 +15,8 @@ let relay_sign_test_message = "hello relay"
 ///|
 fn relay_sign_test_restore_public_key_override(saved : String?) -> Unit {
   match saved {
-    Some(value) => @sys.set_env_var("BIT_RELAY_SIGN_PUBLIC_KEY", value)
-    None => @sys.unset_env_var("BIT_RELAY_SIGN_PUBLIC_KEY")
+    Some(value) => @env.set_env_var("BIT_RELAY_SIGN_PUBLIC_KEY", value)
+    None => @env.unset_env_var("BIT_RELAY_SIGN_PUBLIC_KEY")
   }
 }
 
@@ -78,8 +78,8 @@ async test "relay sign web: sha256 matches known digest" {
 
 ///|
 async test "relay sign web: resolves public key and signs with Ed25519" {
-  let saved_public_key = @sys.get_env_var("BIT_RELAY_SIGN_PUBLIC_KEY")
-  @sys.unset_env_var("BIT_RELAY_SIGN_PUBLIC_KEY")
+  let saved_public_key = @env.get_env_var("BIT_RELAY_SIGN_PUBLIC_KEY")
+  @env.unset_env_var("BIT_RELAY_SIGN_PUBLIC_KEY")
   let public_key = relay_resolve_public_key(relay_sign_test_private_key)
   assert_eq(public_key, relay_sign_test_public_key)
   let signature = relay_sign_ed25519(
diff --git a/modules/bitx_hub/src/format.mbt b/modules/bitx_hub/src/format.mbt
index bc4b98d3..c1abd38f 100644
--- a/modules/bitx_hub/src/format.mbt
+++ b/modules/bitx_hub/src/format.mbt
@@ -3,7 +3,7 @@
 ///|
 /// Serialize PullRequest to Git-style text format
 pub fn PullRequest::serialize(self : PullRequest) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("pr ")
   sb.write_string(self.id)
   sb.write_char('\n')
@@ -171,7 +171,7 @@ pub fn parse_legacy_pull_request(text : String) -> PullRequest raise PrError {
 ///|
 /// Serialize WorkItem to Git-style text format
 pub fn WorkItem::serialize(self : WorkItem) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("work-item ")
   sb.write_string(self.id)
   sb.write_char('\n')
@@ -407,7 +407,7 @@ pub fn parse_work_item(text : String) -> WorkItem raise PrError {
 ///|
 /// Serialize PrComment to Git-style text format
 pub fn PrComment::serialize(self : PrComment) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("comment ")
   sb.write_string(self.id)
   sb.write_char('\n')
@@ -528,7 +528,7 @@ pub fn parse_pr_comment(text : String) -> PrComment raise PrError {
 ///|
 /// Serialize PrReview to Git-style text format
 pub fn PrReview::serialize(self : PrReview) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("review ")
   sb.write_string(self.id)
   sb.write_char('\n')
@@ -667,7 +667,7 @@ fn parse_review_verdict(s : String) -> ReviewVerdict {
 ///|
 /// Serialize Issue to Git-style text format
 pub fn Issue::serialize(self : Issue) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("issue ")
   sb.write_string(self.id)
   sb.write_char('\n')
@@ -810,7 +810,7 @@ pub fn parse_legacy_issue(text : String) -> Issue raise PrError {
 ///|
 /// Serialize IssueComment to Git-style text format
 pub fn IssueComment::serialize(self : IssueComment) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("comment ")
   sb.write_string(self.id)
   sb.write_char('\n')
@@ -903,7 +903,7 @@ fn parse_issue_state(s : String) -> IssueState {
 /// Serialize Note to Git-style text format
 /// Note: Git standard notes are plain text, but we add metadata for Hub
 pub fn Note::serialize(self : Note) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("commit ")
   sb.write_string(self.commit_id.to_hex())
   sb.write_char('\n')
diff --git a/modules/bitx_hub/src/js_hub_host_bridge.mbt b/modules/bitx_hub/src/js_hub_host_bridge.mbt
index 8af46bc7..5fef8c75 100644
--- a/modules/bitx_hub/src/js_hub_host_bridge.mbt
+++ b/modules/bitx_hub/src/js_hub_host_bridge.mbt
@@ -20,7 +20,7 @@ extern "js" fn hub_js_host_last_error() -> String =
 extern "js" fn hub_js_host_write_file(
   host_id : Int,
   path : String,
-  content : Array[Byte],
+  content : FixedArray[Byte],
 ) -> String? =
   #| (hostId, path, content) => {
   #|   const state = globalThis.__bitGitJsState ??= { nextHostId: 1, hosts: new Map() };
@@ -154,9 +154,12 @@ impl @bit.FileSystem for HubJsHostFs with fn mkdir_p(self, path) {
 
 ///|
 impl @bit.FileSystem for HubJsHostFs with fn write_file(self, path, content) {
-  let arr = Array::new(capacity=content.length())
+  // A `FixedArray` rather than an `Array`: `Array` is deprecated at the JS FFI
+  // boundary, and a `FixedArray[Byte]` arrives as a `Uint8Array`, which the
+  // bridge's `Uint8Array.from` reads exactly as it read the plain array.
+  let arr = FixedArray::make(content.length(), b'\x00')
   for i in 0..<content.length() {
-    arr.push(content[i])
+    arr[i] = content[i]
   }
   match hub_js_host_write_file(self.host_id, path, arr) {
     Some(e) => raise @bit.GitError::IoError(e)
diff --git a/modules/bitx_hub/src/native/claim_native.mbt b/modules/bitx_hub/src/native/claim_native.mbt
index 58f5c140..c57fb5ae 100644
--- a/modules/bitx_hub/src/native/claim_native.mbt
+++ b/modules/bitx_hub/src/native/claim_native.mbt
@@ -144,7 +144,7 @@ let default_relay_http_timeout_ms : Int = 30000
 /// `BIT_RELAY_TIMEOUT_MS` environment variable; set it to `0` (or less) to
 /// disable the timeout entirely.
 fn relay_http_timeout_ms() -> Int {
-  match @sys.get_env_var("BIT_RELAY_TIMEOUT_MS") {
+  match @env.get_env_var("BIT_RELAY_TIMEOUT_MS") {
     Some(value) =>
       @string.parse_int(value) catch {
         _ => default_relay_http_timeout_ms
diff --git a/modules/bitx_hub/src/native/github_api.mbt b/modules/bitx_hub/src/native/github_api.mbt
index 1f488b9f..0c2eebea 100644
--- a/modules/bitx_hub/src/native/github_api.mbt
+++ b/modules/bitx_hub/src/native/github_api.mbt
@@ -2,7 +2,7 @@
 
 ///|
 pub fn github_has_gh_cli() -> Bool {
-  match @sys.get_env_var("PATH") {
+  match @env.get_env_var("PATH") {
     None => false
     Some(_) => true // gh availability checked at call time via exit code
   }
@@ -10,10 +10,10 @@ pub fn github_has_gh_cli() -> Bool {
 
 ///|
 pub fn github_has_token() -> Bool {
-  match @sys.get_env_var("GITHUB_TOKEN") {
+  match @env.get_env_var("GITHUB_TOKEN") {
     Some(t) => t.length() > 0
     None =>
-      match @sys.get_env_var("GH_TOKEN") {
+      match @env.get_env_var("GH_TOKEN") {
         Some(t) => t.length() > 0
         None => false
       }
diff --git a/modules/bitx_hub/src/native/moon.pkg b/modules/bitx_hub/src/native/moon.pkg
index 4c0a7d42..ed7a584c 100644
--- a/modules/bitx_hub/src/native/moon.pkg
+++ b/modules/bitx_hub/src/native/moon.pkg
@@ -17,7 +17,6 @@ import {
   "moonbitlang/core/encoding/utf8",
   "moonbitlang/core/json",
   "moonbitlang/core/string",
-  "moonbitlang/x/sys",
   "moonbitlang/core/strconv",
   "mizchi/x/websocket" @xws,
 }
diff --git a/modules/bitx_hub/src/native/sync_native.mbt b/modules/bitx_hub/src/native/sync_native.mbt
index 141fd7b6..08d07c99 100644
--- a/modules/bitx_hub/src/native/sync_native.mbt
+++ b/modules/bitx_hub/src/native/sync_native.mbt
@@ -151,7 +151,7 @@ fn is_http_url(url : String) -> Bool {
 
 ///|
 fn relay_signing_key() -> String? {
-  match @sys.get_env_var("BIT_COLLAB_SIGN_KEY") {
+  match @env.get_env_var("BIT_COLLAB_SIGN_KEY") {
     Some(value) => if value.length() > 0 { Some(value) } else { None }
     None => None
   }
@@ -159,7 +159,7 @@ fn relay_signing_key() -> String? {
 
 ///|
 fn relay_require_signed() -> Bool {
-  match @sys.get_env_var("BIT_COLLAB_REQUIRE_SIGNED") {
+  match @env.get_env_var("BIT_COLLAB_REQUIRE_SIGNED") {
     Some(value) => {
       let normalized = value.to_lower()
       normalized == "1" || normalized == "true" || normalized == "yes"
@@ -170,7 +170,7 @@ fn relay_require_signed() -> Bool {
 
 ///|
 fn relay_auth_token() -> String? {
-  match @sys.get_env_var("BIT_RELAY_AUTH_TOKEN") {
+  match @env.get_env_var("BIT_RELAY_AUTH_TOKEN") {
     Some(value) => if value.length() > 0 { Some(value) } else { None }
     None => None
   }
@@ -218,7 +218,7 @@ fn relay_is_valid_room_name(room : String) -> Bool {
 ///|
 fn normalize_relay_sender(raw : String) -> String {
   let trimmed = raw.trim(chars=" \n\r\t").to_owned()
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   for c in trimmed {
     if relay_sender_safe_char(c) {
       out.write_char(c)
@@ -236,7 +236,7 @@ fn normalize_relay_sender(raw : String) -> String {
 
 ///|
 fn relay_sender() -> String {
-  match @sys.get_env_var("BIT_RELAY_SENDER") {
+  match @env.get_env_var("BIT_RELAY_SENDER") {
     Some(value) => normalize_relay_sender(value)
     None => "bit"
   }
@@ -244,7 +244,7 @@ fn relay_sender() -> String {
 
 ///|
 fn relay_conflict_policy() -> @hub.RecordMergePolicy {
-  match @sys.get_env_var("BIT_HUB_CONFLICT_POLICY") {
+  match @env.get_env_var("BIT_HUB_CONFLICT_POLICY") {
     Some(value) =>
       match @hub.parse_record_merge_policy(value) {
         Some(policy) => policy
@@ -628,7 +628,7 @@ fn relay_clock_to_string(clock : Map[String, Int64]) -> String {
 
 ///|
 fn relay_serialize_record_unsigned(record : @hub.HubRecord) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("version ")
   sb.write_string(record.version.to_string())
   sb.write_char('\n')
@@ -692,7 +692,7 @@ fn commit_relay_notes(
   message : String,
   timestamp : Int64,
 ) -> @bit.ObjectId raise @bit.GitError {
-  let tree_entries : Array[@bit.TreeEntry] = Array::new(
+  let tree_entries : Array[@bit.TreeEntry] = Array(
     capacity=store.entries.length(),
   )
   for name, blob_id in store.entries {
diff --git a/modules/bitx_hub/src/native/sync_native_bench_wbtest.mbt b/modules/bitx_hub/src/native/sync_native_bench_wbtest.mbt
index 57b3d82b..4f2e3ea2 100644
--- a/modules/bitx_hub/src/native/sync_native_bench_wbtest.mbt
+++ b/modules/bitx_hub/src/native/sync_native_bench_wbtest.mbt
@@ -76,9 +76,9 @@ async fn relay_bench_http_post_ok(
 
 ///|
 test "bench relay push 200 records default sender" (b : @bench.T) {
-  @sys.unset_env_var("BIT_RELAY_SENDER")
-  @sys.unset_env_var("BIT_RELAY_SIGN_PRIVATE_KEY_FILE")
-  @sys.unset_env_var("BIT_RELAY_SIGN_PUBLIC_KEY")
+  @env.unset_env_var("BIT_RELAY_SENDER")
+  @env.unset_env_var("BIT_RELAY_SIGN_PRIVATE_KEY_FILE")
+  @env.unset_env_var("BIT_RELAY_SIGN_PUBLIC_KEY")
   b.bench(fn() {
     let mut ok = false
     @async.run_async_main(async fn() {
@@ -98,9 +98,9 @@ test "bench relay push 200 records default sender" (b : @bench.T) {
 
 ///|
 test "bench relay push 200 records BIT_RELAY_SENDER set" (b : @bench.T) {
-  @sys.set_env_var("BIT_RELAY_SENDER", "node-a")
-  @sys.unset_env_var("BIT_RELAY_SIGN_PRIVATE_KEY_FILE")
-  @sys.unset_env_var("BIT_RELAY_SIGN_PUBLIC_KEY")
+  @env.set_env_var("BIT_RELAY_SENDER", "node-a")
+  @env.unset_env_var("BIT_RELAY_SIGN_PRIVATE_KEY_FILE")
+  @env.unset_env_var("BIT_RELAY_SIGN_PUBLIC_KEY")
   b.bench(fn() {
     let mut ok = false
     @async.run_async_main(async fn() {
@@ -116,5 +116,5 @@ test "bench relay push 200 records BIT_RELAY_SENDER set" (b : @bench.T) {
     })
     b.keep(ok)
   })
-  @sys.unset_env_var("BIT_RELAY_SENDER")
+  @env.unset_env_var("BIT_RELAY_SENDER")
 }
diff --git a/modules/bitx_hub/src/native/sync_native_wbtest.mbt b/modules/bitx_hub/src/native/sync_native_wbtest.mbt
index a3f79504..a17f9ce2 100644
--- a/modules/bitx_hub/src/native/sync_native_wbtest.mbt
+++ b/modules/bitx_hub/src/native/sync_native_wbtest.mbt
@@ -386,8 +386,8 @@ async test "relay: relay push adds relay signature headers when key env is set"
     return
   }
 
-  @sys.set_env_var("BIT_RELAY_SIGN_PRIVATE_KEY_FILE", key_path)
-  @sys.set_env_var("BIT_RELAY_SIGN_PUBLIC_KEY", "test-public-key")
+  @env.set_env_var("BIT_RELAY_SIGN_PRIVATE_KEY_FILE", key_path)
+  @env.set_env_var("BIT_RELAY_SIGN_PUBLIC_KEY", "test-public-key")
 
   let seen_public_keys : Array[String] = []
   let seen_signatures : Array[String] = []
@@ -435,8 +435,8 @@ async test "relay: relay push adds relay signature headers when key env is set"
     auth_token=None,
   )
 
-  @sys.unset_env_var("BIT_RELAY_SIGN_PRIVATE_KEY_FILE")
-  @sys.unset_env_var("BIT_RELAY_SIGN_PUBLIC_KEY")
+  @env.unset_env_var("BIT_RELAY_SIGN_PRIVATE_KEY_FILE")
+  @env.unset_env_var("BIT_RELAY_SIGN_PUBLIC_KEY")
   ignore(
     @process.run("rm", ["-f", key_path], inherit_env=true) catch {
       _ => -1
@@ -479,7 +479,7 @@ async test "relay: relay push uses BIT_RELAY_SENDER for publish sender query" {
       objects, refs, clock_ref, "hub/pr/1/meta", "hub.pr", "payload", "node-local",
     ),
   )
-  @sys.set_env_var("BIT_RELAY_SENDER", "node-a")
+  @env.set_env_var("BIT_RELAY_SENDER", "node-a")
   let seen_urls : Array[String] = []
   let post = async fn(
     url : String,
@@ -506,7 +506,7 @@ async test "relay: relay push uses BIT_RELAY_SENDER for publish sender query" {
     signing_key=None,
     auth_token=None,
   )
-  @sys.unset_env_var("BIT_RELAY_SENDER")
+  @env.unset_env_var("BIT_RELAY_SENDER")
   assert_true(result.success())
   @test.assert_eq(seen_urls.length(), 1)
   assert_true(seen_urls[0].contains("sender=node-a"))
@@ -623,7 +623,7 @@ test "relay: parse_relay_poll_clone_peers extracts latest announce per sender" {
 
 ///|
 async test "relay: relay_publish_clone_announce_with_http publishes notify payload" {
-  @sys.set_env_var("BIT_RELAY_SENDER", "node-self")
+  @env.set_env_var("BIT_RELAY_SENDER", "node-self")
   let seen_urls : Array[String] = []
   let seen_bodies : Array[String] = []
   let seen_auth : Array[String] = []
@@ -656,7 +656,7 @@ async test "relay: relay_publish_clone_announce_with_http publishes notify paylo
     repo=Some("repo-self"),
     auth_token=Some("token-3"),
   )
-  @sys.unset_env_var("BIT_RELAY_SENDER")
+  @env.unset_env_var("BIT_RELAY_SENDER")
   assert_true(accepted)
   @test.assert_eq(seen_urls.length(), 1)
   assert_true(seen_urls[0].contains("sender=node-self"))
diff --git a/modules/bitx_hub/src/proposal.mbt b/modules/bitx_hub/src/proposal.mbt
index f11a9298..904c4b93 100644
--- a/modules/bitx_hub/src/proposal.mbt
+++ b/modules/bitx_hub/src/proposal.mbt
@@ -92,7 +92,7 @@ pub fn Hub::broadcast_feature(
   let node_id = self.store.node_id()
   let key = "hub/broadcast/feature/" + branch_name + "/" + node_id
   // Build payload as serialized key-value text
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("branch ")
   sb.write_string(branch_name)
   sb.write_char('\n')
@@ -152,7 +152,7 @@ pub fn Hub::publish_node_heartbeat(
 ) -> Unit raise @bit.GitError {
   let timestamp = clock.now()
   let key = "hub/node/heartbeat/" + node_id
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("node_id ")
   sb.write_string(node_id)
   sb.write_char('\n')
diff --git a/modules/bitx_hub/src/store.mbt b/modules/bitx_hub/src/store.mbt
index c43cd4a4..731a1948 100644
--- a/modules/bitx_hub/src/store.mbt
+++ b/modules/bitx_hub/src/store.mbt
@@ -174,7 +174,7 @@ pub fn HubRecord::new(
 
 ///|
 fn serialize_hub_record(record : HubRecord, signature : String?) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("version ")
   sb.write_string(record.version.to_string())
   sb.write_char('\n')
@@ -750,7 +750,7 @@ fn commit_notes(
   timestamp : Int64,
 ) -> @bit.ObjectId raise @bit.GitError {
   // Build tree from entries
-  let tree_entries : Array[@bit.TreeEntry] = Array::new(
+  let tree_entries : Array[@bit.TreeEntry] = Array(
     capacity=store.entries.length(),
   )
   for name, blob_id in store.entries {
diff --git a/modules/bitx_hub/src/sync_link.mbt b/modules/bitx_hub/src/sync_link.mbt
index 559d6d0e..e53c5caa 100644
--- a/modules/bitx_hub/src/sync_link.mbt
+++ b/modules/bitx_hub/src/sync_link.mbt
@@ -87,7 +87,7 @@ pub fn SyncLink::remote_updated_at(self : SyncLink) -> Int64 {
 ///|
 /// Serialize SyncLink to Git-style text format
 pub fn SyncLink::serialize(self : SyncLink) -> String {
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("sync-link ")
   sb.write_string(self.local_id)
   sb.write_char('\n')
diff --git a/modules/bitx_hub/src/timestamp.mbt b/modules/bitx_hub/src/timestamp.mbt
index 8a1db565..40172563 100644
--- a/modules/bitx_hub/src/timestamp.mbt
+++ b/modules/bitx_hub/src/timestamp.mbt
@@ -107,7 +107,7 @@ pub fn unix_to_iso8601(unix : Int64) -> String {
   }
   let day = days + 1
   // Format with zero-padding
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_string(pad4(year))
   buf.write_string("-")
   buf.write_string(pad2(month))
diff --git a/modules/bitx_kv/src/merge.mbt b/modules/bitx_kv/src/merge.mbt
index da410f1a..e52fc776 100644
--- a/modules/bitx_kv/src/merge.mbt
+++ b/modules/bitx_kv/src/merge.mbt
@@ -298,7 +298,7 @@ fn Kv::create_merge_commit(
   let snap_info = @bit.parse_commit(obj.data)
   // Create proper merge commit with two parents
   let author = self.node_id.id + " <" + self.node_id.id + ">"
-  let sb = StringBuilder::new()
+  let sb = StringBuilder()
   sb.write_string("tree ")
   sb.write_string(snap_info.tree.to_hex())
   sb.write_char('\n')
diff --git a/modules/bitx_rebase_ai/src/rebase_ai.mbt b/modules/bitx_rebase_ai/src/rebase_ai.mbt
index 221445d3..52ea9566 100644
--- a/modules/bitx_rebase_ai/src/rebase_ai.mbt
+++ b/modules/bitx_rebase_ai/src/rebase_ai.mbt
@@ -129,7 +129,7 @@ fn commit_system_prompt(_agent_loop_mode : Bool) -> String {
 
 ///|
 fn build_commit_message_prompt(diff_units : String, context : String) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_string(
     "Write one commit message that follows Conventional Commits.\n",
   )
@@ -155,7 +155,7 @@ fn build_commit_message_prompt(diff_units : String, context : String) -> String
 
 ///|
 fn build_resolve_prompt(path : String, conflicted_content : String) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_string("Resolve this conflicted file:\n")
   buf.write_string("path: ")
   buf.write_string(path)
@@ -177,7 +177,7 @@ fn build_resolve_prompt_with_context(
   if trimmed_context.length() == 0 {
     return build_resolve_prompt(path, conflicted_content)
   }
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_string("Project/User constraints:\n")
   buf.write_string(trimmed_context)
   buf.write_string("\n\n")
@@ -202,7 +202,7 @@ fn collect_text_with_provider(
   provider : @llmlib.BoxedProvider,
   prompt : String,
 ) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   let handler : @llmlib.StreamHandler = {
     on_event: fn(event) {
       match event {
@@ -321,7 +321,7 @@ fn push_unique_path(paths : Array[String], path : String) -> Unit {
 
 ///|
 fn build_agent_loop_prompt(rel_path : String) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_string("Resolve git conflict markers using tools.\n")
   buf.write_string("Target path: ")
   buf.write_string(rel_path)
@@ -681,7 +681,7 @@ pub fn ai_generate_commit_message(
   )
   if use_agent_loop_mode(options) {
     let registry = build_repo_scoped_read_tools(fs, root)
-    let out = StringBuilder::new()
+    let out = StringBuilder()
     @llmlib.run_agent_cancellable(
       provider,
       registry,
diff --git a/modules/bitx_subdir/src/commit.mbt b/modules/bitx_subdir/src/commit.mbt
index 00b949f9..879e2d13 100644
--- a/modules/bitx_subdir/src/commit.mbt
+++ b/modules/bitx_subdir/src/commit.mbt
@@ -263,7 +263,7 @@ fn write_object(
 /// 文字列から部分文字列を取得
 fn hex_substring(s : String, start : Int, end : Int) -> String {
   let chars = s.to_array()
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i = start; i < end && i < chars.length(); i = i + 1 {
     result.write_char(chars[i])
   }
@@ -282,7 +282,7 @@ fn create_commit_object(
   timestamp : Int64,
 ) -> @bit.ObjectId raise SubdirError {
   // コミット内容を構築
-  let content = StringBuilder::new()
+  let content = StringBuilder()
   content.write_string("tree ")
   content.write_string(tree_id.to_hex())
   content.write_string("\n")
@@ -346,7 +346,7 @@ fn update_head_ref(
 
 ///|
 fn bytes_to_string_commit(data : Bytes) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for b in data {
     result.write_char(b.to_int().unsafe_to_char())
   }
@@ -360,7 +360,7 @@ fn trim_head_content(s : String) -> String {
   while end > 0 && (chars[end - 1] == '\n' || chars[end - 1] == '\r') {
     end -= 1
   }
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i in 0..<end {
     result.write_char(chars[i])
   }
@@ -373,7 +373,7 @@ fn skip_prefix_commit(s : String, n : Int) -> String {
   if n >= chars.length() {
     return ""
   }
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i in n..<chars.length() {
     result.write_char(chars[i])
   }
@@ -392,7 +392,7 @@ fn get_parent_dir(path : String) -> String {
   if last_slash <= 0 {
     return "/"
   }
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i in 0..<last_slash {
     result.write_char(chars[i])
   }
diff --git a/modules/bitx_subdir/src/history.mbt b/modules/bitx_subdir/src/history.mbt
index 489db757..def5b505 100644
--- a/modules/bitx_subdir/src/history.mbt
+++ b/modules/bitx_subdir/src/history.mbt
@@ -51,7 +51,7 @@ fn parse_commit_metadata(data : Bytes) -> (String, String, Int64) {
 ///|
 /// Bytes を String に変換（ローカルヘルパー）
 fn bytes_to_string_local(data : Bytes) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for b in data {
     result.write_char(b.to_int().unsafe_to_char())
   }
@@ -62,7 +62,7 @@ fn bytes_to_string_local(data : Bytes) -> String {
 /// 文字列を行に分割
 fn split_lines(text : String) -> Array[String] {
   let lines : Array[String] = []
-  let current = StringBuilder::new()
+  let current = StringBuilder()
   for c in text {
     if c == '\n' {
       lines.push(current.to_string())
@@ -87,7 +87,7 @@ fn skip_prefix(s : String, n : Int) -> String {
   if n >= chars.length() {
     return ""
   }
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i in n..<chars.length() {
     result.write_char(chars[i])
   }
@@ -113,7 +113,7 @@ fn extract_timestamp_from_author(author : String) -> Int64 {
     return 0L
   }
   // タイムスタンプを読む
-  let ts = StringBuilder::new()
+  let ts = StringBuilder()
   i = timestamp_start
   while i < chars.length() && chars[i] >= '0' && chars[i] <= '9' {
     ts.write_char(chars[i])
@@ -250,13 +250,13 @@ fn split_subdir_path(path : String) -> Array[String] {
     return []
   }
   let parts : Array[String] = []
-  let mut current = StringBuilder::new()
+  let mut current = StringBuilder()
   for c in path {
     if c == '/' {
       let s = current.to_string()
       if s.length() > 0 {
         parts.push(s)
-        current = StringBuilder::new()
+        current = StringBuilder()
       }
     } else {
       current.write_char(c)
diff --git a/modules/bitx_subdir/src/init.mbt b/modules/bitx_subdir/src/init.mbt
index 55eb6cbb..10a11712 100644
--- a/modules/bitx_subdir/src/init.mbt
+++ b/modules/bitx_subdir/src/init.mbt
@@ -133,7 +133,7 @@ pub fn generate_shell_env(
 /// シェル起動用の RC スクリプトを生成
 pub fn generate_shell_rc(subdir_path : String) -> String {
   let normalized_path = normalize_subdir_path(subdir_path)
-  let script = StringBuilder::new()
+  let script = StringBuilder()
   // ヘッダー
   script.write_string("# Moongit subdir shell for: ")
   script.write_string(normalized_path)
@@ -185,7 +185,7 @@ pub fn generate_shell_rc(subdir_path : String) -> String {
 ///|
 /// パスをファイル名安全な形式に変換（/ を _ に）
 fn path_to_safe_name(path : String) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for c in path {
     if c == '/' {
       result.write_char('_')
@@ -199,7 +199,7 @@ fn path_to_safe_name(path : String) -> String {
 ///|
 /// 設定ファイルの内容を生成
 fn build_config_content(subdir_path : String, repo_root : String) -> String {
-  let content = StringBuilder::new()
+  let content = StringBuilder()
   content.write_string("[subdir]\n")
   content.write_string("\tpath = ")
   content.write_string(subdir_path)
@@ -214,7 +214,7 @@ fn build_config_content(subdir_path : String, repo_root : String) -> String {
 ///|
 /// 詳細なマーカーファイルの内容を生成
 fn build_verbose_marker(subdir_path : String, git_dir : String) -> String {
-  let content = StringBuilder::new()
+  let content = StringBuilder()
   content.write_string("# This directory is managed as a git subdirectory\n")
   content.write_string("# Do not edit this file manually\n")
   content.write_string("\n")
@@ -235,7 +235,7 @@ fn create_wrapper_script(
   subdir_path : String,
 ) -> Unit raise SubdirError {
   let script_path = subdir_abs + "/git-subdir"
-  let script = StringBuilder::new()
+  let script = StringBuilder()
   script.write_string("#!/bin/sh\n")
   script.write_string("# Git wrapper for subdirectory: ")
   script.write_string(subdir_path)
diff --git a/modules/bitx_subdir/src/module.mbt b/modules/bitx_subdir/src/module.mbt
index de0b6047..e63a4b77 100644
--- a/modules/bitx_subdir/src/module.mbt
+++ b/modules/bitx_subdir/src/module.mbt
@@ -264,7 +264,7 @@ fn remove_precommit_hook(
 ///|
 /// hook からセクションを削除
 fn remove_hook_section(content : String, marker : String) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   let mut in_section = false
   for line_view in content.split("\n") {
     let line = line_view.to_owned()
@@ -327,7 +327,7 @@ fn add_filter_to_config(
     return ()
   }
   // filter セクションを追加
-  let filter_section = StringBuilder::new()
+  let filter_section = StringBuilder()
   if config.length() > 0 && !config.has_suffix("\n") {
     filter_section.write_string("\n")
   }
@@ -453,7 +453,7 @@ fn remove_filter_from_config(
 ///|
 /// config からセクションを削除
 fn remove_config_section(content : String, section_name : String) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   let section_header = "[" + section_name + "]"
   let mut in_section = false
   let mut prev_was_empty = false
@@ -535,7 +535,7 @@ fn remove_filter_from_gitattributes(
     return ()
   }
   // パターンとコメントを削除
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for line_view in content.split("\n") {
     let line = line_view.to_owned()
     if line == pattern_line || line == comment_line {
@@ -604,7 +604,7 @@ fn _add_to_gitmodules(
     return ()
   }
   // 新しいエントリを追加
-  let entry = StringBuilder::new()
+  let entry = StringBuilder()
   if content.length() > 0 && !content.has_suffix("\n") {
     entry.write_string("\n")
   }
@@ -659,7 +659,7 @@ fn _remove_from_gitmodules(
 ///|
 /// .gitmodules からセクションを削除
 fn remove_gitmodules_section(content : String, subdir_path : String) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   let section_header = "[submodule \"" + subdir_path + "\"]"
   let mut in_section = false
   for line_view in content.split("\n") {
@@ -855,7 +855,7 @@ pub fn list_modules(
 ///|
 /// パスをモジュール名に変換（/ を _ に）
 fn path_to_module_name(path : String) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for c in path {
     if c == '/' {
       result.write_char('_')
@@ -869,7 +869,7 @@ fn path_to_module_name(path : String) -> String {
 ///|
 /// モジュール名をパスに戻す（_ を / に）
 fn module_name_to_path(name : String) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for c in name {
     if c == '_' {
       result.write_char('/')
@@ -895,7 +895,7 @@ fn count_path_depth(path : String) -> Int {
 ///|
 /// 相対パスを構築（../ を depth 回）
 fn _build_relative_path(depth : Int, subdir_path : String) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for _ in 0..<depth {
     result.write_string("../")
   }
@@ -906,7 +906,7 @@ fn _build_relative_path(depth : Int, subdir_path : String) -> String {
 ///|
 /// gitdir パスを構築
 fn build_gitdir_path(depth : Int, module_name : String) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for _ in 0..<depth {
     result.write_string("../")
   }
@@ -918,7 +918,7 @@ fn build_gitdir_path(depth : Int, module_name : String) -> String {
 ///|
 /// モジュール用 config を生成
 fn build_module_config(worktree_path : String, subdir_path : String) -> String {
-  let config = StringBuilder::new()
+  let config = StringBuilder()
   config.write_string("[core]\n")
   config.write_string("\trepositoryformatversion = 0\n")
   config.write_string("\tfilemode = true\n")
@@ -976,7 +976,7 @@ fn string_to_bytes_mod(s : String) -> Bytes {
 
 ///|
 fn bytes_to_string_mod(bytes : Bytes) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i in 0..<bytes.length() {
     result.write_char(bytes[i].to_int().unsafe_to_char())
   }
diff --git a/modules/bitx_subdir/src/sparse.mbt b/modules/bitx_subdir/src/sparse.mbt
index eae57ce7..09a3e97b 100644
--- a/modules/bitx_subdir/src/sparse.mbt
+++ b/modules/bitx_subdir/src/sparse.mbt
@@ -396,7 +396,7 @@ fn match_simple_glob(filename : String, pattern : String) -> Bool {
 ///|
 /// sparse checkout パターンファイルの内容を構築
 fn build_sparse_content(patterns : Array[String]) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   result.write_string("# Sparse checkout patterns\n")
   for p in patterns {
     result.write_string(p)
@@ -434,7 +434,7 @@ fn sparse_trim(s : String) -> String {
 
 ///|
 fn bytes_to_string_sparse(bytes : Bytes) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i in 0..<bytes.length() {
     result.write_char(bytes[i].to_int().unsafe_to_char())
   }
diff --git a/modules/bitx_subdir/src/subdir.mbt b/modules/bitx_subdir/src/subdir.mbt
index 00404bd9..caf84e32 100644
--- a/modules/bitx_subdir/src/subdir.mbt
+++ b/modules/bitx_subdir/src/subdir.mbt
@@ -4,7 +4,7 @@
 ///|
 /// Bytes を String に変換（ASCII/UTF-8 として解釈）
 fn bytes_to_string(data : Bytes) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for b in data {
     result.write_char(b.to_int().unsafe_to_char())
   }
@@ -24,7 +24,7 @@ fn trim_newlines(s : String) -> String {
       break
     }
   }
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i in 0..<end {
     result.write_char(chars[i])
   }
@@ -38,7 +38,7 @@ fn skip_chars(s : String, n : Int) -> String {
   if n >= chars.length() {
     return ""
   }
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i in n..<chars.length() {
     result.write_char(chars[i])
   }
@@ -63,7 +63,7 @@ fn normalize_subdir_path(path : String) -> String {
     end -= 1
   }
   // 結果を構築
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i in start..<end {
     result.write_char(chars[i])
   }
@@ -77,12 +77,12 @@ fn split_path(path : String) -> Array[String] {
     return []
   }
   let parts : Array[String] = []
-  let mut current = StringBuilder::new()
+  let mut current = StringBuilder()
   for c in path {
     if c == '/' {
       if current.to_string().length() > 0 {
         parts.push(current.to_string())
-        current = StringBuilder::new()
+        current = StringBuilder()
       }
     } else {
       current.write_char(c)
diff --git a/modules/bitx_subdir/src/subdir_test.mbt b/modules/bitx_subdir/src/subdir_test.mbt
index faad8f26..3d39a48e 100644
--- a/modules/bitx_subdir/src/subdir_test.mbt
+++ b/modules/bitx_subdir/src/subdir_test.mbt
@@ -612,7 +612,7 @@ test "subdir: init with SubdirRepo integration" {
 
 ///|
 fn bytes_to_string_test(bytes : Bytes) -> String {
-  let result = StringBuilder::new()
+  let result = StringBuilder()
   for i = 0; i < bytes.length(); i = i + 1 {
     result.write_char(bytes[i].to_int().unsafe_to_char())
   }
diff --git a/modules/bitx_workspace/src/moon.pkg b/modules/bitx_workspace/src/moon.pkg
index fd4ca147..8d2d34bc 100644
--- a/modules/bitx_workspace/src/moon.pkg
+++ b/modules/bitx_workspace/src/moon.pkg
@@ -17,7 +17,6 @@ import {
   "moonbitlang/x/encoding",
   "moonbitlang/x/fs",
   "moonbitlang/x/path",
-  "moonbitlang/x/sys",
 }
 
 warnings = "-29"
diff --git a/modules/bitx_workspace/src/workspace.mbt b/modules/bitx_workspace/src/workspace.mbt
index 9689a69e..5b8f2689 100644
--- a/modules/bitx_workspace/src/workspace.mbt
+++ b/modules/bitx_workspace/src/workspace.mbt
@@ -146,15 +146,15 @@ fn is_bare_repo_dir(path : String) -> Bool {
 ///|
 fn resolve_git_dir(fs : &@bit.RepoFileSystem, root : String) -> String {
   let default_git_dir = default_repo_marker_path(fs, root)
-  match @sys.get_env_var("GIT_DIR") {
+  match @env.get_env_var("GIT_DIR") {
     Some(dir) => {
       let resolved = if dir.has_prefix("/") {
         dir
       } else {
-        match @sys.get_env_var("GIT_SHIM_CWD") {
+        match @env.get_env_var("GIT_SHIM_CWD") {
           Some(base) => normalize_path(base + "/" + dir)
           None =>
-            @sys.get_env_var("GIT_SHIM_PWD")
+            @env.get_env_var("GIT_SHIM_PWD")
             .map(base => normalize_path(base + "/" + dir))
             .unwrap_or(dir)
         }
@@ -352,15 +352,15 @@ fn resolve_workspace_probe_dir(cwd : String?) -> String {
   let raw = match cwd {
     Some(dir) => dir
     None =>
-      match @sys.get_env_var("GIT_SHIM_CWD") {
+      match @env.get_env_var("GIT_SHIM_CWD") {
         Some(dir) => dir
         None =>
-          match @sys.get_env_var("GIT_SHIM_PWD") {
+          match @env.get_env_var("GIT_SHIM_PWD") {
             Some(dir) => dir
             None =>
               match @env.current_dir() {
                 Some(dir) => dir
-                None => @sys.get_env_var("PWD").unwrap_or(".")
+                None => @env.get_env_var("PWD").unwrap_or(".")
               }
           }
       }
@@ -740,7 +740,7 @@ fn format_toml_string_array(items : Array[String]) -> String {
 
 ///|
 fn format_workspace_manifest(manifest : WorkspaceManifest) -> String {
-  let buf = StringBuilder::new()
+  let buf = StringBuilder()
   buf.write_string("version = ")
   buf.write_string(manifest.version.to_string())
   buf.write_string("\n")
@@ -996,7 +996,7 @@ fn workspace_json_string(
 
 ///|
 fn workspace_fingerprint_mode() -> @fingerprint.FingerprintMode {
-  match @sys.get_env_var("BIT_WORKSPACE_FINGERPRINT_MODE") {
+  match @env.get_env_var("BIT_WORKSPACE_FINGERPRINT_MODE") {
     Some(raw) =>
       match @fingerprint.parse_fingerprint_mode(raw) {
         Some(mode) => mode
@@ -1491,7 +1491,7 @@ fn workspace_flow_workspace_fingerprint(
   selected : Map[String, Bool],
   signatures : Map[String, String],
 ) -> String {
-  let out = StringBuilder::new()
+  let out = StringBuilder()
   out.write_string("task=")
   out.write_string(task)
   for node_id in ordered_ids {
@@ -1852,7 +1852,7 @@ async fn handle_workspace_status(args : Array[String]) -> Unit raise Error {
     let head = workspace_node_head_hex(fs, node_root).unwrap_or("-")
     let lock_head = lock_commits.get(node.id).unwrap_or("-")
     let drift = head != "-" && lock_head != "-" && head != lock_head
-    let summary = StringBuilder::new()
+    let summary = StringBuilder()
     summary.write_string("- ")
     summary.write_string(node.id)
     summary.write_string(" (")
@@ -2335,7 +2335,7 @@ async fn handle_workspace_flow(
   if star_path is Some(star_file) {
     let external_inputs = @bitflow.parse_external_inputs(
       star_var_cli_args,
-      @sys.get_env_vars(),
+      @env.get_env_vars(),
     )
     if external_inputs.errors.length() > 0 {
       raise @bit.GitError::InvalidObject(