fs: /bin alias for the system volume

ADR 0006 deferred root-path unification because it "needs VFS
bind/alias machinery".  Implement the /bin half: paths whose first
component is `bin` are rewritten to the first mounted volume whose
root has a \bin directory, so `ls /bin/cli`, `cat /bin/cli/x.efi` and
a binary's own fs_resolve("/bin/cli/x.efi") work without knowing the
volume UID.

The alias is transparent — it creates no node, so `ls /` keeps its old
listing and /bin simply does not exist when no system volume is
mounted — and allocates nothing for non-matching paths.  exec::resolve
keeps its per-file volume scan (stricter for multiple volumes).

Update ADR 0006 to record the decision and what remains deferred
(\etc and friends at the root).

2 files changed, 52 insertions, 1 deletions

diff --git a/docs/adr/0006-executable-binaries-and-bin-tree.md b/docs/adr/0006-executable-binaries-and-bin-tree.md
index 17109c4..f3de95f 100644
--- a/docs/adr/0006-executable-binaries-and-bin-tree.md
+++ b/docs/adr/0006-executable-binaries-and-bin-tree.md
@@ -48,6 +48,14 @@ and so a launcher can enumerate launchable apps by listing a directory.
 - **Resolution rule.**  For name N: run `\bin\<kind>\N` from the first
   mounted volume that has it; else the built-in N; else "unknown
   command".  No volume is privileged; no boot-volume identity exists.
+- **`/bin` is a VFS path alias.**  User paths whose first component is
+  `bin` are rewritten (in `fs::resolve`) to the first mounted volume
+  whose root has `\bin` — so `ls /bin/cli`, `cat /bin/cli/x.efi` and a
+  binary's own `fs_resolve("/bin/cli/x.efi")` work without knowing the
+  volume UID.  The alias is transparent: it creates no node (`ls /` does
+  not list `bin`), and without a system volume mounted `/bin` does not
+  exist.  It covers `/bin` only — the rest of root-path unification
+  stays deferred, but the bind/alias machinery it needed now exists.
 - **Kind = launch surface.**  `/bin/cli` holds programs that run inside a
   terminal session; `/bin/gui` holds programs launchable with no terminal
   (they own their windows).  A future launcher enumerates `/bin/gui`.
@@ -91,7 +99,9 @@ and so a launcher can enumerate launchable apps by listing a directory.
   through FAT write-back persists across reboots, and the image doubles
   as the distribution artifact.
 - **Boot-volume identity / root-path unification** (`\etc` visible at
-  `/etc`) — deferred; needs VFS bind/alias machinery.
+  `/etc`) — deferred; needed VFS bind/alias machinery.  The `/bin` half
+  landed as a path alias (see the resolution-rule section); `\etc`,
+  `\bzImage` etc. at the root stay deferred.
 - **A third "TUI" binary kind for rsdosedit** — rejected; `edit` is
   classified CLI (it lives in a terminal session) and migrates only after
   the CLI ABI grows raw-mode surface access.  Until then it stays a
diff --git a/rsnix/src/fs.rs b/rsnix/src/fs.rs
index 3585c00..a3bae6d 100644
--- a/rsnix/src/fs.rs
+++ b/rsnix/src/fs.rs
@@ -274,12 +274,53 @@ fn lookup(dir: usize, name: &str) -> Option<usize> {
     None
 }
 
+/// `/bin` alias for the system volume (ADR 0006): the binaries actually
+/// live on the FAT volume at `\<vol>\bin\<kind>\`, but `/bin` is the
+/// stable user-facing path.  When the first path component is `bin`, the
+/// path is rewritten to the first mounted volume whose root has a `\bin`
+/// directory — so `ls /bin/cli` and a binary's own
+/// `fs_resolve("/bin/cli/x.efi")` work without knowing the volume UID.
+/// Every other path returns `None` here without allocating.  (The alias is
+/// transparent: `ls /` does not list `bin`, and with no system volume
+/// mounted `/bin` simply does not exist.)
+fn alias_bin(path: &str) -> Option<String> {
+    let p = path.trim_start_matches('/');
+    let p = p.trim_start_matches("./"); // tolerate a leading ./ prefix
+    let first = match p.find('/') {
+        Some(i) => &p[..i],
+        None => p,
+    };
+    if first != "bin" {
+        return None;
+    }
+    for vol in 0..crate::fat::volume_count() {
+        if !crate::fat::is_mounted(vol) {
+            continue;
+        }
+        if crate::fat::find(vol, crate::fat::root_cluster(vol), "bin").is_err() {
+            continue; // volume has no \bin root — not the system volume
+        }
+        let uid = String::from(crate::fat::uid(vol));
+        return Some(alloc::format!("/disk/{}/{}", uid, p));
+    }
+    None
+}
+
 /// Resolve an absolute path (supports `.` and `..`).  Paths under
 /// `/disk` walk the mounted FAT32 volume through ephemeral Disk nodes.
+/// A leading `bin` component goes through the `/bin` alias first.
 pub fn resolve(path: &str) -> Option<usize> {
     if nodes().is_empty() {
         return None;
     }
+    let aliased;
+    let path = match alias_bin(path) {
+        Some(p) => {
+            aliased = p;
+            aliased.as_str()
+        }
+        None => path,
+    };
     let mut cur = 0usize; // root
     // (vol, cluster, parent, name) of directories descended into under /disk.
     let mut dstack: Vec<(usize, u32, u32, String)> = Vec::new();