Remove DaxFS backend: simplify to BranchFS-only

Signed-off-by: Cong Wang <cwang@multikernel.io>

Author: congwang-mk

README.md

@@ -467,17 +467,12 @@ branching status --json
 
 ## How it works
 
-BranchContext uses copy-on-write filesystems to create instant, zero-cost
-branches of your workspace. Two backends are supported, auto-detected at
-runtime:
+BranchContext uses [BranchFS](https://github.com/multikernel/branchfs), a
+copy-on-write FUSE filesystem, to create instant, zero-cost branches of your
+workspace. Branches are virtual paths within a single mount, with
+first-winner-commit semantics.
 
-| Backend | How branches work |
-|---|---|
-| **[BranchFS](https://github.com/multikernel/branchfs)** (FUSE) | Single mount; branches are virtual paths within it. First-winner-commit semantics. |
-| **[DaxFS](https://github.com/multikernel/daxfs)** (kernel) | Separate mount per branch. Fastest option for DAX-capable storage. |
-
-You just create a `Workspace` pointed at a mounted path - the backend is
-detected automatically.
+You just create a `Workspace` pointed at a mounted BranchFS path.
 
 Process isolation (`BranchContext`) uses unprivileged Linux user namespaces
 to give each child its own filesystem view. No root required - works on any

examples/parallel_speculation.py

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 """Parallel speculation example — first successful fix wins.
 
-Requires a mounted branchfs or daxfs filesystem.
+Requires a mounted branchfs filesystem.
 
 Usage:
     python parallel_speculation.py /mnt/workspace

examples/simple_branch.py

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 """Simple branch example — speculative execution with auto-commit/abort.
 
-Requires a mounted branchfs or daxfs filesystem.
+Requires a mounted branchfs filesystem.
 
 Usage:
     python simple_branch.py /mnt/workspace

examples/speculate_fix.py

@@ -299,7 +299,7 @@ def main():
     parser = argparse.ArgumentParser(
         description="Fix a buggy module: one LLM call, N branches.",
     )
-    parser.add_argument("workspace", help="BranchFS/DaxFS workspace path")
+    parser.add_argument("workspace", help="BranchFS workspace path")
     parser.add_argument("--model", default="gpt-4o-mini",
                         help="LLM model name (default: gpt-4o-mini)")
     parser.add_argument("-n", type=int, default=4,

integration/SKILL.md

@@ -6,19 +6,17 @@ the winner, and abort the rest — instantly.
 
 ## Workspace
 
-A workspace is a directory backed by a copy-on-write filesystem (branchfs
-or daxfs). All branching operations happen within a workspace.
+A workspace is a directory backed by [BranchFS](https://github.com/multikernel/branchfs),
+a copy-on-write FUSE filesystem. All branching operations happen within a workspace.
 
-**Prerequisite:** The workspace must be mounted before use. Two backends
-are supported, auto-detected at runtime:
+**Prerequisite:** The workspace must be mounted before use:
 
-| Backend | Mount |
-|---------|-------|
-| [BranchFS](https://github.com/multikernel/branchfs) (FUSE) | `branchfs /mnt/workspace` |
-| [DaxFS](https://github.com/multikernel/daxfs) (kernel) | `mount -t daxfs <device> /mnt/workspace` |
+```bash
+branchfs /mnt/workspace
+```
 
 The CLI auto-detects the workspace from your current directory if you are
-inside a branchfs/daxfs mount. Otherwise pass `-w /mnt/workspace`.
+inside a branchfs mount. Otherwise pass `-w /mnt/workspace`.
 
 ## CLI
 

src/branching/__init__.py

@@ -2,7 +2,7 @@
 """
 BranchContext - Unified branching for speculative execution.
 
-Supports filesystem branching (BranchFS FUSE, DaxFS), process branching
+Supports filesystem branching (BranchFS FUSE), process branching
 (fork + namespaces), and AI agent integration patterns (speculation,
 best-of-N, reflexion, tree-of-thoughts).
 

src/branching/core/base.py

@@ -28,7 +28,7 @@ def fstype(cls) -> str:
         Return filesystem type name as it appears in /proc/mounts.
 
         Returns:
-            Filesystem type string (e.g., 'daxfs', 'fuse.branchfs')
+            Filesystem type string (e.g., 'fuse.branchfs')
         """
         pass
 
@@ -80,12 +80,3 @@ def abort(cls, mountpoint: Path) -> None:
         """
         pass
 
-    @classmethod
-    def single_mount(cls) -> bool:
-        """Whether this backend uses a single mount (view switches in-place).
-
-        Returns True for ioctl-based backends like BranchFS where branching
-        happens within a single mount. Returns False for mount-per-branch
-        backends like DaxFS.
-        """
-        return False

src/branching/core/branch.py

@@ -59,8 +59,8 @@ def __init__(
             parent_branch: Parent's branch path (e.g., '/main' or '/main/L1')
             on_success: Action on clean exit - "commit" or None
             on_error: Action on exception - "abort" or None
-            mount_root: Filesystem mount root (for single-mount backends where
-                branch virtual paths are always relative to root).
+            mount_root: Filesystem mount root (branch virtual paths are
+                always relative to this root).
         """
         self._fs = fs
         self._name = name
@@ -107,13 +107,7 @@ def branch(
         Returns:
             New Branch instance
         """
-        if self._fs.single_mount():
-            # Single-mount backends: mountpoint is always the mount root
-            # (create_branch will return the actual virtual path)
-            child_mount = self._mount_root
-        else:
-            # Mount-per-branch backends: create sibling directory
-            child_mount = self._path.parent / f"{self._path.name}_{name}"
+        child_mount = self._mount_root
         return Branch(
             fs=self._fs,
             name=name,
@@ -127,10 +121,7 @@ def branch(
 
     def commit(self) -> None:
         """
-        Commit the branch.
-
-        For DaxFS: commits the entire branch chain to main.
-        For BranchFS: commits the leaf branch to its parent.
+        Commit the branch (merges changes to parent).
         """
         if self._finished:
             return
@@ -139,10 +130,7 @@ def commit(self) -> None:
 
     def abort(self) -> None:
         """
-        Abort the branch.
-
-        For DaxFS: aborts the entire branch chain back to main.
-        For BranchFS: aborts the leaf branch, returning to parent.
+        Abort the branch (rolls back to parent).
         """
         if self._finished:
             return

src/branching/core/registry.py

@@ -19,7 +19,7 @@ def register(fstype: str, fs_class: Type[FSBackend]) -> None:
     Called by filesystem modules during import to register themselves.
 
     Args:
-        fstype: Filesystem type name (e.g., 'daxfs', 'fuse.branchfs')
+        fstype: Filesystem type name (e.g., 'fuse.branchfs')
         fs_class: FSBackend subclass that handles this filesystem
     """
     _registry[fstype] = fs_class
@@ -91,11 +91,6 @@ def _ensure_implementations_loaded() -> None:
 
     Imports backend modules which register themselves on import.
     """
-    if "daxfs" not in _registry:
-        try:
-            from ..fs import daxfs as _  # noqa: F401
-        except ImportError:
-            pass
     if "fuse.branchfs" not in _registry:
         try:
             from ..fs import branchfs as _  # noqa: F401

src/branching/core/workspace.py

@@ -54,33 +54,17 @@ def fstype(self) -> str:
         """Detected filesystem type name."""
         return self._fs.fstype()
 
-    @property
-    def single_mount(self) -> bool:
-        """Whether the backend uses stack-based branching on a single mount.
-
-        When True, branches are serialized (no concurrent siblings).
-        """
-        return self._fs.single_mount()
-
     def _generate_mountpoint(self, name: str) -> Path:
         """
         Generate a mountpoint path for a branch.
 
-        Backend-aware: single-mount backends (BranchFS) reuse the mount root;
-        mount-per-branch backends (DaxFS) create a sibling directory.
-
         Args:
             name: Branch name
 
         Returns:
             Path for the new branch mount
         """
-        if self._fs.single_mount():
-            # BranchFS: view switches in-place, same mount root
-            return self._mount_root
-        else:
-            # DaxFS: each branch gets its own mount
-            return self._path.parent / f"{self._path.name}_{name}"
+        return self._mount_root
 
     def branch(
         self,