1 files changed, 111 insertions, 0 deletions

diff --git a/shell/src/lib.rs b/shell/src/lib.rs
index d1710cc..9ca999e 100644
--- a/shell/src/lib.rs
+++ b/shell/src/lib.rs
@@ -745,6 +745,15 @@ write `{} <path> TIL <marker>`",
         }
     }
 
+    // Resolution rule (ADR 0006): \bin\<kind>\<name> first, else the
+    // built-in.  The frozen core (help/clear/echo/poweroff/exit/halt/
+    // rescan) is exempt — it exists to fix the system and never migrates.
+    if !matches!(cmd, "help" | "clear" | "echo" | "halt" | "poweroff" | "exit" | "rescan")
+        && exec_external(&parsed)
+    {
+        return;
+    }
+
     match cmd {
         "help" => cmd_help(&parsed),
         "echo" => cmd_echo(&parsed),
@@ -792,6 +801,108 @@ write `{} <path> TIL <marker>`",
 }
 
 // ---------------------------------------------------------------------------
+// External binaries (ADR 0006 Phase 2)
+//
+// Resolution: \bin\cli\<name> on each mounted volume; else "unknown
+// command".  The Exports table is constructed per invocation: v1 wires
+// put_line to the active terminal and get_line to EOF (stream injection
+// through the filter pipeline lands in Phase 3).
+// ---------------------------------------------------------------------------
+
+static mut LAST_EXIT_CODE: i32 = 0;
+
+/// Last exit code of an external command ($? equivalent for scripts).
+pub fn last_exit_code() -> i32 {
+    unsafe { core::ptr::addr_of!(LAST_EXIT_CODE).read() }
+}
+
+/// ABI callback: print one line to the invoking terminal.
+fn abi_put_line(line: rsapi::Line) -> bool {
+    term_println(line.as_str());
+    true
+}
+
+/// ABI callback: read one input line — no stream source wired yet (Phase 3).
+fn abi_get_line(_out: &mut rsapi::Line) -> rsapi::StreamResult {
+    rsapi::StreamResult::Eof
+}
+
+/// ABI callback: kernel log.
+fn abi_log_line(line: rsapi::Line) {
+    rsnix::klog::append(line.as_str(), 0);
+}
+
+/// ABI callback: exit with a code.
+fn abi_exit(code: i32) -> ! {
+    unsafe {
+        LAST_EXIT_CODE = code;
+    }
+    // Unwind the binary by longjmp-style task abort: the trampoline never
+    // returns here.  We report the code via the static and kill the task.
+    rsnix::sched::abort_current("exit")
+}
+
+static EXPORTS_V1: rsapi::Exports = rsapi::Exports {
+    magic: rsapi::EXPORTS_MAGIC,
+    version: rsapi::ABI_VERSION,
+    put_line: abi_put_line,
+    get_line: abi_get_line,
+    log_line: abi_log_line,
+    exit: abi_exit,
+};
+
+/// Run `cmd` as an external PE32+ binary from /bin/cli/.  Returns false
+/// when no external binary resolved (the caller falls back to built-ins).
+fn exec_external(p: &Parsed) -> bool {
+    let Some(h) = rsnix::exec::resolve("cli", &p.cmd) else {
+        return false;
+    };
+    let bytes = match rsnix::exec::read_file(h) {
+        Ok(b) => b,
+        Err(_) => {
+            term_err(&alloc::format!("{}: read failed", p.cmd));
+            return true;
+        }
+    };
+    let image = match rsnix::load::load_image(&bytes) {
+        Ok(img) => img,
+        Err(e) => {
+            term_err(&alloc::format!("{}: cannot load ({:?})", p.cmd, e));
+            return true;
+        }
+    };
+    let mut argv: Vec<String> = Vec::with_capacity(p.args.len() + 1);
+    argv.push(p.cmd.clone());
+    argv.extend(p.args.iter().cloned());
+    let name = alloc::format!("{}", p.cmd);
+    match rsnix::exec::spawn(image, &EXPORTS_V1, &argv, &name) {
+        Ok(id) => {
+            // Wait for the completion message (TaskMsg::User(exit_code)).
+            loop {
+                match rsnix::sched::recv_blocking() {
+                    rsnix::sched::TaskMsg::User(code) => {
+                        unsafe {
+                            LAST_EXIT_CODE = code as i32;
+                        }
+                        break;
+                    }
+                    rsnix::sched::TaskMsg::Key(rsnix::ps2::KeyEvent::Ctrl('c')) => {
+                        // ^C while waiting: kill the command task.
+                        let _ = rsnix::sched::kill(id);
+                        term_err("^C");
+                        break;
+                    }
+                    _ => {}
+                }
+            }
+        }
+        Err(rsnix::exec::ExecError::Busy) => term_err(&alloc::format!("{}: task table full", p.cmd)),
+        Err(_) => term_err(&alloc::format!("{}: cannot start", p.cmd)),
+    }
+    true
+}
+
+// ---------------------------------------------------------------------------
 // Built-in commands
 // ---------------------------------------------------------------------------