v0.2.9 : ps/where/get facon Nushell avec mini-pipeline (ls | where size > 1mb | get name), dir = ls sur Windows, ls beaucoup plus rapide (taille des dossiers bornee a 500 entrees), autocomplet : prefixe commun + menu avec descriptions + fallback chemins

Cargo.lock

@@ -21,7 +21,7 @@ dependencies = [
 
 [[package]]
 name = "agent-manager"
-version = "0.2.2"
+version = "0.2.9"
 dependencies = [
  "anyhow",
  "chrono",
@@ -41,6 +41,7 @@ dependencies = [
  "ureq",
  "wait-timeout",
  "which",
+ "windows-sys 0.52.0",
  "zip",
 ]
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "agent-manager"
-version = "0.2.2"
+version = "0.2.9"
 edition = "2021"
 description = "Manage local AI coding agents: list, install, start, stop, update — with automatic dependency handling and a YAML-driven catalog."
 license = "MIT"
@@ -35,6 +35,9 @@ wait-timeout = "0.2"
 which = "7"
 zip = "0.6"
 
+[target.'cfg(windows)'.dependencies]
+windows-sys = { version = "0.52", features = ["Win32_Foundation", "Win32_System_Threading", "Win32_System_ProcessStatus", "Win32_System_Diagnostics_ToolHelp"] }
+
 [profile.release]
 lto = "thin"
 strip = true

README.md

@@ -90,7 +90,7 @@ sur le PATH) · ⚪ not-installed · 🔴 not-installable (SaaS/desktop)
 | am install <agent> | installe (dépendances vérifiées et proposées) |
 | am install <agent> --method pip | choisit une méthode d'installation |
 | am update <agent> | met à jour vers la dernière version connue |
-| am uninstall <agent> | désinstalle et nettoie (--purge : logs + config) |
+| am uninstall <agent> | désinstalle et nettoie (--purge : logs + config) — gère aussi les agents externes (npm/pip/uv/cargo/bun, sinon suppression des fichiers) |
 | am export / am import | sauvegarde et restaure config + état |
 
 ### 🚀 Exécuter
@@ -112,7 +112,8 @@ sur le PATH) · ⚪ not-installed · 🔴 not-installable (SaaS/desktop)
 | am config show / edit / add | gère votre configuration |
 | am completion <shell> | script de complétion (bash, zsh, fish, powershell) |
 | am self-update | met à jour am lui-même (si configuré) |
-| am | shell interactif avec Tab et historique |
+| am self-uninstall | désinstalle am et tout ce qu'il a créé (confirmation) |
+| am | shell interactif : bannière, passerelle système, Tab et historique |
 
 ---
 
@@ -166,10 +167,70 @@ Disponibles avant **ou après** la sous-commande.
     am start group:dev        # démarre tout un groupe en arrière-plan
     am stop group:dev
 
-    am                        # shell interactif :
-    am> inst<Tab>             # complétion Tab : commandes, agents, groupes, options
-    am> install jcode
-    am> exit                  # historique persistant (flèches haut/bas)
+    am                        # shell interactif (bannière style Hermes) :
+    ❯ inst<Tab>               # complétion Tab : commandes, agents, groupes, options
+    ❯ install jcode
+    ❯ exit                    # historique persistant (flèches haut/bas)
+
+### 🐚 Passerelle système
+
+Le prompt interactif est aussi une **passerelle vers votre shell
+système** : toute saisie qui n'est pas une commande am est exécutée par le
+shell actif. Le **shell par défaut de l'utilisateur est détecté au
+démarrage et mis en évidence** dans la bannière (config
+`settings.default_shell`, puis `SHELL`/`COMSPEC`, puis détection sur le
+PATH — pwsh, powershell, cmd, bash, zsh, fish, sh, nu, elvish).
+
+    ❯ ls                      # liste façon Nushell : tableau encadré (type, taille, date)
+    ❯ dir                     # sur Windows, même affichage que ls
+    ❯ ls src                  # un chemin précis — Tab complète fichiers et dossiers
+    ❯ ps                      # liste des processus (pid, ppid, cpu, mem, threads)
+    ❯ ls | where size > 1mb   # filtre la dernière table  (>, <, >=, <=, ==, !=, =~)
+    ❯ ps | where name =~ am   # =~ cherche dans le texte
+    ❯ ls | get name           # sélectionne une colonne
+    ❯ cd <Tab>                # complétion des dossiers uniquement, un niveau par Tab
+    ❯ shell                   # affiche le shell courant + les shells disponibles
+    ❯ shell bash              # change le shell de la session
+    ❯ !ls · !list             # force l'exécution système (même nom qu'une commande am)
+    ❯ cd ~/projets            # change le répertoire de la session (persistant)
+    ❯ /help                   # commandes slash : /help · /version · /exit · /shell <nom>
+
+Le menu Tab affiche une **description** à côté de chaque candidat
+(commandes et agents), comme Nushell, et **cycle** entre les propositions à
+chaque Tab.
+
+Pour rendre le choix permanent : `settings.default_shell: pwsh` dans
+`config.yaml` (voir `am config path`).
+
+---
+
+## 🧹 Désinstallation propre
+
+Une seule commande, sur tous les OS — elle arrête d'abord les agents en
+arrière-plan, puis supprime les données, l'état (logs, historique), la
+configuration, et enfin l'exécutable lui-même :
+
+    am self-uninstall           # avec confirmation
+    am self-uninstall --yes     # automatique, en une ligne
+
+Sans le binaire (ou en dernier recours), supprimez les répertoires
+qu'agent-manager possède :
+
+    # Linux
+    rm -rf ~/.local/share/agent-manager ~/.local/state/agent-manager ~/.config/agent-manager
+
+    # macOS
+    rm -rf "$HOME/Library/Application Support/agent-manager" "$HOME/.config/agent-manager"
+
+    # Windows — PowerShell
+    Remove-Item -Recurse -Force $env:LOCALAPPDATA\agent-manager, $env:APPDATA\agent-manager -ErrorAction SilentlyContinue
+
+    # Windows — cmd.exe (à ne PAS coller dans PowerShell : rmdir y est un
+    # alias de Remove-Item et le & final lance un job en arrière-plan)
+    rmdir /s /q "%LOCALAPPDATA%\agent-manager" & rmdir /s /q "%APPDATA%\agent-manager"
+
+(Si vous utilisiez `AGENT_MANAGER_DATA`/`AGENT_MANAGER_STATE`/`AGENT_MANAGER_CONFIG_DIR`,
+supprimez aussi ces emplacements.)
 
 ---
 

config.yaml

@@ -14,7 +14,7 @@ version: "1.0"
 settings:
   install_dir: null            # default: ~/.local/share/agent-manager/agents
   log_dir: null                # default: ~/.local/state/agent-manager/logs
-  default_shell: null          # default: sh on Unix
+  default_shell: null          # install scripts + shell gateway (default: user's shell)
   auto_install_deps: true      # offer to install missing dependencies
   confirm_before_run: true     # confirm before running install scripts
   stop_timeout_secs: 5         # SIGTERM grace period before SIGKILL
@@ -56,6 +56,19 @@ agents:
     run: claude
     tags: [anthropic, assistant, source-available, mainstream]
 
+  - name: deepseek-harness
+    display_name: "DeepSeek Harness"
+    description: "CLI officiel DeepSeek (dsh) : boot de profils, gestion des plugins Cordis, orchestration multi-agents, boucles de buts (goals) et interface web. Installez-le pour piloter vos agents depuis am."
+    category: coding-agent
+    website: https://github.com/deepseek-ai/deepseek-harness
+    install:
+      type: npm
+      package: "@deepseek-ai/dsh"
+    dependencies:
+      - { name: node, min_version: "20.0.0", install_hint: "https://nodejs.org" }
+    run: dsh
+    tags: [deepseek, harness, multi-agent, plugins, web-ui]
+
   - name: hermes-agent
     display_name: "Hermes Agent"
     description: "Agent Nous Research multi-modèle (300+ providers). Mémoire persistante, création automatique de skills, exécution de code sandboxée, reach multi-plateforme (Telegram/Slack/Discord/WhatsApp)."

src/cli.rs

@@ -102,7 +102,7 @@ pub enum Command {
         #[arg(long)]
         force: bool,
     },
-    /// Uninstall an agent and clean its files
+    /// Uninstall an agent (managed or external) and clean its files
     Uninstall {
         /// Agent name or alias
         agent: String,
@@ -163,6 +163,12 @@ pub enum Command {
         #[arg(long, value_name = "FILE")]
         to: Option<PathBuf>,
     },
+    /// Remove agent-manager and everything it created from this machine
+    ///
+    /// Stops every managed background agent, then deletes the data, state and
+    /// configuration directories, and finally the executable itself. Combine
+    /// with --yes for a fully automated one-liner.
+    SelfUninstall,
     /// Export the configuration and installation state (backup)
     Export {
         /// Output file (default: am-export.json)

src/commands/info_cmd.rs

@@ -2,6 +2,7 @@
 
 use super::*;
 use crate::output::print_json;
+use colored::Colorize;
 use serde::Serialize;
 
 #[derive(Serialize)]
@@ -101,51 +102,102 @@ pub fn run(app: &App, name: &str) -> Result<i32> {
         return Ok(0);
     }
 
-    println!("{}", agent.title());
-    if agent.name != agent.title() {
-        println!("  slug:       {}", agent.name);
-    }
-    if let Some(d) = &agent.description {
-        println!("  description: {d}");
-    }
+    let color = app.color();
+    let dim = |s: &str| -> String {
+        if color {
+            s.dimmed().to_string()
+        } else {
+            s.to_string()
+        }
+    };
+    let bold = |s: &str| -> String {
+        if color {
+            s.bold().to_string()
+        } else {
+            s.to_string()
+        }
+    };
+
+    // --- Header -------------------------------------------------------------
+    println!("{}", bold(agent.title()));
+    let mut sub: Vec<String> = vec![agent.name.clone()];
     if let Some(c) = &agent.category {
-        println!("  category:   {c}");
+        sub.push(c.clone());
+    }
+    println!("  {}", dim(&sub.join(" · ")));
+    if let Some(d) = &agent.description {
+        println!();
+        println!("  {d}");
     }
     if let Some(w) = &agent.website {
-        println!("  website:    {w}");
-    }
-    if !agent.tags.is_empty() {
-        println!("  tags:       {}", agent.tags.join(", "));
-    }
-    if !agent.platforms.is_empty() {
-        println!("  platforms:  {}", agent.platforms.join(", "));
+        println!();
+        println!("  {} {}", dim("website"), w);
     }
+    println!();
 
-    // Status block
-    let status = if running {
-        format!("running (pid {})", entry.as_ref().and_then(|e| e.pid).unwrap_or(0))
+    // --- Status --------------------------------------------------------------
+    let external = external_path(agent);
+    let (status_word, detail): (&str, String) = if running {
+        let pid = entry.as_ref().and_then(|e| e.pid).unwrap_or(0);
+        ("running", format!(" (pid {pid})"))
     } else if entry.is_some() {
-        format!("installed (version {})", entry.as_ref().and_then(|e| e.version.clone()).unwrap_or_else(|| "unknown".to_string()))
+        let v = entry
+            .as_ref()
+            .and_then(|e| e.version.clone())
+            .map(|v| format!(" — v{v}"))
+            .unwrap_or_default();
+        ("installed", v)
     } else if !agent.installable {
-        "not installable locally".to_string()
-    } else if external_path(agent).is_some() {
-        "found on PATH (external — not managed)".to_string()
+        ("not-installable", String::new())
+    } else if external.is_some() {
+        ("external", " (found on PATH — not managed)".to_string())
     } else {
-        "not installed".to_string()
+        ("not-installed", String::new())
     };
-    println!("  status:     {status}");
+    let word = crate::output::status_style(status_word, color);
+    println!("  {} {}", dim("● status"), format!("{word}{detail}"));
 
+    // Version: recorded for managed installs, detected for external ones.
+    let version_display: Option<String> = entry
+        .as_ref()
+        .and_then(|e| e.version.clone())
+        .or_else(|| external.as_ref().and_then(|p| crate::probe::detect_external_version(p)));
+    if let Some(v) = version_display {
+        println!("  {} {}", dim("● version"), v);
+    }
+    if let Some(t) = entry.as_ref().map(|e| e.installed_at.clone()) {
+        println!("  {} {}", dim("● installed"), t);
+    }
+    if let Some(t) = entry.as_ref().and_then(|e| e.updated_at.clone()) {
+        println!("  {} {}", dim("● updated"), t);
+    }
+    if let Some(p) = entry
+        .as_ref()
+        .map(|e| e.install_dir.clone())
+        .or_else(|| external.clone().map(|p| p.display().to_string()))
+    {
+        println!("  {} {}", dim("● path"), p);
+    }
+    if let Some(e) = &entry {
+        if let Some(bin) = e.bins.first() {
+            println!("  {} {}", dim("● bin"), bin);
+        }
+    }
+
+    // --- How to run it -------------------------------------------------------
     if let Some(run) = &agent.run {
         let args = if agent.args.is_empty() {
             String::new()
         } else {
             format!(" {}", agent.args.join(" "))
         };
-        println!("  run:        {run}{args}");
+        println!();
+        println!("  {} {}", dim("▶ run"), format!("{run}{args}"));
     }
     if !agent.env.is_empty() {
         println!(
-            "  env:        {}",
+            "  {} {}",
+            dim("⚙ env"),
             agent
                 .env
                 .iter()
@@ -155,38 +207,72 @@ pub fn run(app: &App, name: &str) -> Result<i32> {
         );
     }
 
+    // --- Installation ---------------------------------------------------------
     if let Some(spec) = &agent.install {
-        println!("  install methods:");
+        println!();
+        println!("  {}", bold("install"));
         for (i, m) in spec.all_methods().iter().enumerate() {
-            let note = m
-                .note
-                .as_deref()
-                .map(|n| format!("  ({n})"))
-                .unwrap_or_default();
-            println!("    {}) {}{}", i + 1, describe_method(m), note);
+            println!("    {}) {}", i + 1, describe_method(m));
+            if let Some(n) = &m.note {
+                println!("       {}", dim(n));
+            }
         }
         if !spec.post_install.is_empty() {
-            println!("  post-install: {}", spec.post_install.join(" && "));
+            println!(
+                "    {}",
+                dim(&format!("post-install: {}", spec.post_install.join(" && ")))
+            );
         }
     }
+
+    // --- Dependencies, checked live ------------------------------------------
     if !agent.dependencies.is_empty() {
-        println!("  dependencies:");
-        for d in &agent.dependencies {
-            let min = d
-                .min_version
-                .as_deref()
-                .map(|m| format!(" >= {m}"))
-                .unwrap_or_default();
-            let hint = d
-                .install_hint
-                .as_deref()
-                .map(|h| format!(" — {h}"))
-                .unwrap_or_default();
-            println!("    - {}{}{}", d.name, min, hint);
+        println!();
+        println!("  {}", bold("dependencies"));
+        let runner = crate::runner::SystemRunner::new(false, app.cli.verbose, &app.log);
+        let checks = crate::deps::check_agent(agent, &runner);
+        for c in &checks {
+            let mark = if c.ok { "✓" } else { "✗" };
+            let mark = if color {
+                if c.ok {
+                    mark.green().to_string()
+                } else {
+                    mark.red().to_string()
+                }
+            } else {
+                mark.to_string()
+            };
+            let mut line = format!("    {mark} {}", c.name);
+            if let Some(v) = &c.version {
+                line.push_str(&format!(" {v}"));
+            }
+            if let Some(min) = &c.min {
+                line.push_str(&format!(" (min {min})"));
+            }
+            if !c.ok {
+                if let Some(hint) = agent
+                    .dependencies
+                    .iter()
+                    .find(|d| d.name == c.name)
+                    .and_then(|d| d.install_hint.clone())
+                {
+                    line.push_str(&format!(" — {hint}"));
+                } else if !c.detail.is_empty() && c.detail != "not found on PATH" {
+                    line.push_str(&format!(" — {}", c.detail));
+                }
+            }
+            println!("{line}");
         }
     }
+
+    // --- Tags and note ---------------------------------------------------------
+    if !agent.tags.is_empty() {
+        println!();
+        println!("  {}", dim(&format!("tags  {}", agent.tags.join(" · "))));
+    }
     if let Some(n) = &agent.note {
-        println!("  note:       {n}");
+        println!();
+        println!("  {}", dim(&format!("note  {n}")));
     }
     Ok(0)
 }

src/commands/list_cmd.rs

@@ -50,10 +50,11 @@ pub fn run(app: &App, all: bool, category: Option<&str>) -> Result<i32> {
         return Ok(0);
     }
     let color = app.color();
-    let mut table = Table::new(vec!["NAME", "VERSION", "STATUS", "SOURCE", "PATH"]);
+    let mut table = Table::new(vec!["NAME", "AGENT", "VERSION", "STATUS", "SOURCE", "PATH"]);
     for r in &rows {
         table.row(vec![
             r.display_name.clone(),
+            r.name.clone(),
             r.version.clone().unwrap_or_else(|| "—".to_string()),
             status_style(&r.status, color),
             r.source.clone(),

src/commands/mod.rs

@@ -9,6 +9,7 @@ pub mod install_cmd;
 pub mod list_cmd;
 pub mod run_cmd;
 pub mod search_cmd;
+pub mod self_uninstall;
 pub mod self_update;
 pub mod status_cmd;
 pub mod uninstall_cmd;
@@ -59,6 +60,7 @@ pub fn execute_command(app: &App, cmd: &Command) -> Result<i32> {
         Command::Run { agent, args } => run_cmd::run(app, agent, args),
         Command::Completion { shell } => completion_cmd::run(*shell),
         Command::SelfUpdate { check, to } => self_update::run(app, *check, to.as_deref()),
+        Command::SelfUninstall => self_uninstall::run(app),
         Command::Export { output } => export_import::export_cmd(app, output),
         Command::Import { file } => export_import::import_cmd(app, file),
     }

src/commands/self_uninstall.rs

@@ -0,0 +1,386 @@
+//! self-uninstall: remove agent-manager and everything it created from this
+//! machine — background agents are stopped first, then the data, state and
+//! configuration directories are deleted, then the executable itself.
+
+use crate::app::{self, App};
+use anyhow::{bail, Result};
+#[cfg(unix)]
+use anyhow::Context;
+use colored::Colorize;
+use std::path::{Path, PathBuf};
+
+#[cfg(windows)]
+const MOVEFILE_DELAY_UNTIL_REBOOT: u32 = 0x4;
+#[cfg(windows)]
+const FILE_ATTRIBUTE_READONLY: u32 = 0x1;
+#[cfg(windows)]
+const INVALID_FILE_ATTRIBUTES: u32 = 0xFFFF_FFFF;
+
+#[cfg(windows)]
+#[link(name = "Kernel32")]
+extern "system" {
+    fn MoveFileExW(
+        lpExistingFileName: *const u16,
+        lpNewFileName: *const u16,
+        dwFlags: u32,
+    ) -> i32;
+    fn GetFileAttributesW(lpFileName: *const u16) -> u32;
+    fn SetFileAttributesW(lpFileName: *const u16, dwFileAttributes: u32) -> i32;
+}
+
+pub fn run(app: &App) -> Result<i32> {
+    // 1. Stop every managed background agent.
+    let state = app.state.load()?;
+    for (name, entry) in &state.installed {
+        if let Some(pid) = entry.pid {
+            if crate::process::is_running(pid) {
+                app.log.info(&format!("stopping agent '{name}' (pid {pid})"));
+                crate::process::stop_pid(pid, false, 1);
+            }
+        }
+    }
+
+    // 2. Collect the directories agent-manager owns.
+    let data_root = app::data_dir();
+    let state_root = app::state_dir();
+    let mut roots: Vec<(&str, PathBuf)> = Vec::new();
+    if data_root.is_dir() {
+        roots.push(("data", data_root.clone()));
+    }
+    if state_root != data_root && state_root.is_dir() {
+        roots.push(("state", state_root));
+    }
+    if let Some(dir) = crate::config::user_config_dir() {
+        if dir.is_dir() {
+            roots.push(("config", dir));
+        }
+    }
+
+    let exe = std::env::current_exe().ok();
+    let mut renamed: Option<PathBuf> = None;
+
+    if roots.is_empty() {
+        app.log
+            .info("nothing to remove — agent-manager left no traces on this machine");
+    } else {
+        app.log.info("agent-manager will remove:");
+        for (label, path) in &roots {
+            println!("  {label}: {}", path.display());
+        }
+        if !app.confirm("Remove everything listed above?")? {
+            app.log.info("cancelled — nothing was removed");
+            return Ok(0);
+        }
+        if app.dry_run() {
+            app.log.dry("nothing removed (dry run)");
+            return Ok(0);
+        }
+        // Windows allows renaming a running executable (but not deleting
+        // it): do it up-front so the original binary disappears immediately,
+        // even if the deferred deletion has to wait for this process to exit.
+        renamed = exe.as_deref().and_then(rename_for_deletion);
+        if let Some(new) = &renamed {
+            if let Some(old) = &exe {
+                println!(
+                    "{} {} -> {}",
+                    "renamed:".cyan(),
+                    old.display(),
+                    new.display()
+                );
+            }
+        }
+        // Remove everything first; any message logged *after* deleting the
+        // state directory would recreate the log folder, so the removal
+        // itself is silent and the report below goes to plain stdout.
+        // The removal is tolerant: read-only attributes are cleared and files
+        // locked by other processes (for example the running am.exe when it
+        // lives inside the data directory) are scheduled for deletion at the
+        // next reboot instead of failing the whole uninstall.
+        let mut locked: Vec<PathBuf> = Vec::new();
+        for (_, path) in &roots {
+            remove_tree(path, &mut locked);
+        }
+        for (_, path) in &roots {
+            if !path.exists() {
+                println!("{} {}", "removed:".green(), path.display());
+            }
+        }
+        if !locked.is_empty() {
+            let scheduled = schedule_locked(&locked);
+            if !scheduled.is_empty() {
+                println!(
+                    "{} {} entrée(s) verrouillée(s) — suppression planifiée au prochain redémarrage",
+                    "locked:".yellow(),
+                    scheduled.len()
+                );
+            }
+            if scheduled.len() != locked.len() {
+                println!(
+                    "{} {} entrée(s) verrouillée(s) — le processus différé les supprimera après la fermeture de am",
+                    "deferred:".cyan(),
+                    locked.len() - scheduled.len()
+                );
+            }
+        }
+    }
+
+    // 3. Delete the executable itself, then sweep the directories left
+    // empty behind it.
+    let cleanup_roots: Vec<PathBuf> = roots.iter().map(|(_, p)| p.clone()).collect();
+    match &exe {
+        Some(e) => remove_self(e, renamed.as_deref(), &cleanup_roots)?,
+        None => app.log
+            .warn("cannot locate the agent-manager executable — delete it manually"),
+    }
+    Ok(0)
+}
+
+/// Recursively remove a tree, tolerating locked or read-only entries.
+/// Paths that could not be removed are collected into `locked` so the
+/// caller can schedule their deletion at the next reboot.
+fn remove_tree(path: &Path, locked: &mut Vec<PathBuf>) {
+    let meta = match std::fs::symlink_metadata(path) {
+        Ok(m) => m,
+        Err(_) => return,
+    };
+    if meta.is_dir() {
+        if let Ok(entries) = std::fs::read_dir(path) {
+            for entry in entries.flatten() {
+                remove_tree(&entry.path(), locked);
+            }
+        }
+        clear_readonly(path);
+        if std::fs::remove_dir(path).is_err() {
+            locked.push(path.to_path_buf());
+        }
+    } else {
+        clear_readonly(path);
+        if std::fs::remove_file(path).is_err() {
+            locked.push(path.to_path_buf());
+        }
+    }
+}
+
+/// Clear the read-only attribute (a common cause of "Access denied" on
+/// Windows, e.g. files extracted by Expand-Archive).
+#[cfg(windows)]
+fn clear_readonly(path: &Path) {
+    use std::os::windows::ffi::OsStrExt;
+    let wide: Vec<u16> = path
+        .as_os_str()
+        .encode_wide()
+        .chain(std::iter::once(0))
+        .collect();
+    unsafe {
+        let attrs = GetFileAttributesW(wide.as_ptr());
+        if attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_READONLY) != 0 {
+            SetFileAttributesW(wide.as_ptr(), attrs & !FILE_ATTRIBUTE_READONLY);
+        }
+    }
+}
+
+#[cfg(not(windows))]
+fn clear_readonly(_path: &Path) {}
+
+/// Schedule every locked path for deletion at the next reboot (Windows).
+/// Returns the paths that could be scheduled.
+#[cfg(windows)]
+fn schedule_locked(locked: &[PathBuf]) -> Vec<PathBuf> {
+    use std::os::windows::ffi::OsStrExt;
+    let mut scheduled = Vec::new();
+    for path in locked {
+        let wide: Vec<u16> = path
+            .as_os_str()
+            .encode_wide()
+            .chain(std::iter::once(0))
+            .collect();
+        let ok = unsafe {
+            MoveFileExW(wide.as_ptr(), std::ptr::null(), MOVEFILE_DELAY_UNTIL_REBOOT) != 0
+        };
+        if ok {
+            scheduled.push(path.clone());
+        }
+    }
+    scheduled
+}
+
+#[cfg(not(windows))]
+fn schedule_locked(_locked: &[PathBuf]) -> Vec<PathBuf> {
+    Vec::new()
+}
+
+/// Delete the running executable. On Unix the file can be unlinked while it
+/// runs; on Windows a hidden cmd re-tries the deletion right after this
+/// process exits (the file is locked while we run). Empty directories left
+/// behind under the removed roots are swept afterwards.
+fn remove_self(exe: &Path, renamed: Option<&Path>, roots: &[PathBuf]) -> Result<()> {
+    #[cfg(unix)]
+    {
+        std::fs::remove_file(exe)
+            .with_context(|| format!("cannot remove {}", exe.display()))?;
+        // Sweep empty directories upward, but never above a removed root.
+        let mut dir = exe.parent();
+        while let Some(d) = dir {
+            if !roots.iter().any(|r| d.starts_with(r)) {
+                break;
+            }
+            if std::fs::remove_dir(d).is_err() {
+                break;
+            }
+            dir = d.parent();
+        }
+        println!(
+            "{} {}",
+            "agent-manager removed:".green(),
+            exe.display()
+        );
+        return Ok(());
+    }
+    #[cfg(windows)]
+    {
+        use std::os::windows::ffi::OsStrExt;
+        // The file to delete once this process exits: the renamed copy when
+        // the up-front rename worked, the original path otherwise.
+        let target = renamed.unwrap_or(exe);
+        // A temporary batch file retries the deletion for a few seconds (the
+        // image stays locked until we exit), sweeps the directories left
+        // empty, then deletes itself. A .bat avoids every cmd /C command-line
+        // quoting pitfall.
+        let bat = write_cleanup_bat(exe, target, roots);
+        if let Some(b) = &bat {
+            // raw_arg passes the command line verbatim: regular .arg()
+            // backslash-escapes embedded quotes, which cmd.exe does not
+            // understand.
+            use std::os::windows::process::CommandExt as _;
+            let mut cleanup = std::process::Command::new("cmd");
+            cleanup.raw_arg("/C");
+            cleanup.raw_arg(format!("\"{}\"", b.display()));
+            let _ = cleanup.spawn();
+        }
+        // Belt and braces: if something keeps the file locked, the standard
+        // uninstaller mechanism deletes it at the next reboot.
+        let wide: Vec<u16> = target
+            .as_os_str()
+            .encode_wide()
+            .chain(std::iter::once(0))
+            .collect();
+        let at_reboot = unsafe {
+            MoveFileExW(wide.as_ptr(), std::ptr::null(), MOVEFILE_DELAY_UNTIL_REBOOT) != 0
+        };
+        if bat.is_none() && !at_reboot {
+            bail!(
+                "cannot schedule deletion of {} — delete it manually",
+                exe.display()
+            );
+        }
+        if renamed.is_some() {
+            println!(
+                "{} {}",
+                "agent-manager removed; the executable was renamed and will be deleted momentarily:".green(),
+                exe.display()
+            );
+        } else {
+            println!(
+                "{} {}",
+                "agent-manager removed; the executable will be deleted momentarily:".green(),
+                exe.display()
+            );
+        }
+        return Ok(());
+    }
+    #[cfg(not(any(unix, windows)))]
+    {
+        bail!(
+            "automatic removal of the executable is not supported on this platform; delete {} manually",
+            exe.display()
+        );
+    }
+}
+
+/// Rename the running executable out of the way (Windows allows renaming a
+/// running image — only deletion is refused while it executes). Returns the
+/// new path on success.
+#[cfg(windows)]
+fn rename_for_deletion(exe: &Path) -> Option<PathBuf> {
+    let name = exe.file_name()?.to_string_lossy();
+    let new = exe.with_file_name(format!("{name}.deleteme"));
+    std::fs::rename(exe, &new).ok()?;
+    Some(new)
+}
+
+#[cfg(not(windows))]
+fn rename_for_deletion(_exe: &Path) -> Option<PathBuf> {
+    None
+}
+
+/// Write a temporary batch file that deletes the target executable once it
+/// is unlocked, sweeps the directories left empty and then removes itself.
+#[cfg(windows)]
+fn write_cleanup_bat(exe: &Path, target: &Path, roots: &[PathBuf]) -> Option<PathBuf> {
+    let crlf = "\r\n";
+    let q = "\"";
+    let mut script = String::new();
+    let mut line = |s: &str| {
+        script.push_str(s);
+        script.push_str(crlf);
+    };
+    line("@echo off");
+    line("set n=0");
+    line(":retry");
+    line(&format!("del /f /q {q}{}{q} >nul 2>&1", target.display()));
+    line(&format!("del /f /q {q}{}{q} >nul 2>&1", exe.display()));
+    line(&format!(
+        "if not exist {q}{}{q} (if not exist {q}{}{q} goto sweep)",
+        target.display(),
+        exe.display()
+    ));
+    line("set /a n+=1");
+    line("if %n% GEQ 60 goto end");
+    line("ping -n 2 127.0.0.1 >nul");
+    line("goto retry");
+    line(":sweep");
+    if let Some(parent) = exe.parent() {
+        if roots.iter().any(|r| parent.starts_with(r)) {
+            line(&format!("rd /q {q}{}{q} >nul 2>&1", parent.display()));
+        }
+    }
+    for root in roots {
+        line(&format!("rd /q {q}{}{q} >nul 2>&1", root.display()));
+    }
+    line(":end");
+    line(&format!("del {q}%~f0{q} >nul 2>&1"));
+    let path = std::env::temp_dir().join(format!("am-uninstall-{}.bat", std::process::id()));
+    std::fs::write(&path, script).ok()?;
+    Some(path)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn removes_readonly_tree() {
+        let dir = tempfile::tempdir().unwrap();
+        let sub = dir.path().join("sub");
+        std::fs::create_dir_all(&sub).unwrap();
+        let file = sub.join("readonly.txt");
+        std::fs::write(&file, "x").unwrap();
+        // Read-only files are a classic cause of "Access denied" on Windows.
+        let mut perms = std::fs::metadata(&file).unwrap().permissions();
+        #[allow(clippy::permissions_set_readonly_false)]
+        perms.set_readonly(true);
+        std::fs::set_permissions(&file, perms).unwrap();
+
+        let mut locked: Vec<PathBuf> = Vec::new();
+        remove_tree(dir.path(), &mut locked);
+        assert!(!dir.path().exists(), "tree should be fully removed");
+        assert!(locked.is_empty(), "unexpected locked paths: {locked:?}");
+    }
+
+    #[test]
+    fn tolerates_missing_tree() {
+        let mut locked: Vec<PathBuf> = Vec::new();
+        remove_tree(Path::new("/nonexistent/agent-manager-xyz"), &mut locked);
+        assert!(locked.is_empty());
+    }
+}

src/commands/uninstall_cmd.rs

@@ -1,19 +1,19 @@
 //! uninstall: stop the agent if needed, remove its files, bins and state
 //! entry; --purge also removes logs and the user-config definition.
+//! External agents (installed outside agent-manager) are removed through
+//! their package manager when the catalog knows it, or by deleting the
+//! executables found on PATH otherwise.
 
 use super::*;
 use anyhow::{Context, Result};
 use std::path::PathBuf;
+use std::process::Command as ProcessCommand;
 
 pub fn run(app: &App, agent_name: &str, purge: bool) -> Result<i32> {
     let agent = require_agent(app, agent_name)?;
     let entry = app.state.get(&agent.name).ok().flatten();
     let Some(entry) = entry else {
-        app.log.info(&format!(
-            "agent '{}' is not managed by agent-manager — nothing to uninstall",
-            agent.name
-        ));
-        return Ok(0);
+        return uninstall_external(app, agent);
     };
 
     // Stop it first when running.
@@ -65,6 +65,130 @@ pub fn run(app: &App, agent_name: &str, purge: bool) -> Result<i32> {
     Ok(0)
 }
 
+/// Build the package-manager uninstall command for an external agent whose
+/// install method is a known package manager and whose package is recorded.
+fn package_plan(agent: &AgentDef) -> Option<Vec<String>> {
+    use crate::config::InstallType;
+    let spec = agent.install.as_ref()?;
+    for m in spec.all_methods() {
+        let Some(pkg) = m.package.as_deref() else {
+            continue;
+        };
+        let plan = match m.kind {
+            InstallType::Npm => {
+                vec!["npm", "uninstall", "--global", pkg]
+            }
+            InstallType::Pip => {
+                if which::which("pip").is_ok() {
+                    vec!["pip", "uninstall", "-y", pkg]
+                } else if which::which("python3").is_ok() {
+                    vec!["python3", "-m", "pip", "uninstall", "-y", pkg]
+                } else if which::which("python").is_ok() {
+                    vec!["python", "-m", "pip", "uninstall", "-y", pkg]
+                } else {
+                    continue;
+                }
+            }
+            InstallType::Uv => vec!["uv", "tool", "uninstall", pkg],
+            InstallType::Cargo => vec!["cargo", "uninstall", pkg],
+            InstallType::Bun => vec!["bun", "remove", "--global", pkg],
+            _ => continue,
+        };
+        return Some(plan.into_iter().map(|s| s.to_string()).collect());
+    }
+    None
+}
+
+/// Best-effort removal of an agent installed outside agent-manager: first the
+/// package-manager command when the catalog knows one, then the executable
+/// files left on PATH (and their directory when it is dedicated to the
+/// agent, e.g. AppData\Local\atomic-agent).
+fn uninstall_external(app: &App, agent: &AgentDef) -> Result<i32> {
+    let first_token = agent.first_token();
+
+    // 1. Package-manager plan (npm, pip, uv, cargo, bun).
+    if let Some(tokens) = package_plan(agent) {
+        if which::which(&tokens[0]).is_ok() {
+            app.log.info(&format!(
+                "agent '{}' is external (installed outside agent-manager) — uninstall with: {}",
+                agent.name,
+                tokens.join(" ")
+            ));
+            if !app.confirm("Run this command?")? {
+                app.log.info("cancelled — nothing was uninstalled");
+                return Ok(0);
+            }
+            if app.dry_run() {
+                app.log.dry(format!("would run: {}", tokens.join(" ")));
+            } else {
+                // resolve_program handles Windows .cmd/.bat shims (npm,
+                // pip, ...) which std::process::Command cannot launch.
+                let (prog, prefix) = crate::runner::resolve_program(&tokens[0]);
+                let mut args = prefix;
+                args.extend(tokens[1..].iter().cloned());
+                let status = ProcessCommand::new(&prog)
+                    .args(&args)
+                    .status()
+                    .with_context(|| format!("failed to run {}", tokens.join(" ")))?;
+                if !status.success() {
+                    app.log.warn("the command failed — removing the files it left behind");
+                }
+            }
+        }
+    }
+
+    // 2. Whatever executable is still on PATH, delete it directly (and its
+    // directory when it belongs to the agent).
+    let still = first_token.as_deref().and_then(|t| which::which(t).ok());
+    if let Some(path) = still {
+        let parent = path.parent().map(|p| p.to_path_buf());
+        let dedicated = parent
+            .as_ref()
+            .and_then(|p| p.file_name())
+            .map(|n| n.to_string_lossy().eq_ignore_ascii_case(&agent.name))
+            .unwrap_or(false);
+        let target: PathBuf = if dedicated {
+            parent.clone().unwrap_or_else(|| path.clone())
+        } else {
+            path.clone()
+        };
+        app.log.info(&format!(
+            "remove leftover {} {}",
+            if dedicated { "directory" } else { "file" },
+            target.display()
+        ));
+        if !app.confirm("Delete it?")? {
+            app.log.info(&format!("'{}' left in place", target.display()));
+            return Ok(0);
+        }
+        if app.dry_run() {
+            app.log.dry(format!("would remove {}", target.display()));
+        } else if dedicated {
+            std::fs::remove_dir_all(&target)
+                .with_context(|| format!("cannot remove {}", target.display()))?;
+        } else {
+            std::fs::remove_file(&target)
+                .with_context(|| format!("cannot remove {}", target.display()))?;
+        }
+    }
+
+    // 3. Final verification.
+    let gone = first_token
+        .as_deref()
+        .and_then(|t| which::which(t).ok())
+        .is_none();
+    if gone {
+        app.log
+            .success(&format!("uninstalled {} (external)", agent.title()));
+    } else {
+        app.log.warn(&format!(
+            "{} is still present on PATH — remove it manually",
+            agent.title()
+        ));
+    }
+    Ok(0)
+}
+
 /// Remove the agent entry from the user config file (--purge).
 fn remove_from_user_config(app: &App, name: &str) -> Result<()> {
     let Some(path) = &app.config_origin else {
@@ -111,3 +235,80 @@ fn remove_from_user_config(app: &App, name: &str) -> Result<()> {
     Ok(())
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn agent_from_yaml(yaml: &str) -> AgentDef {
+        #[derive(serde::Deserialize)]
+        struct Wrap {
+            agents: Vec<AgentDef>,
+        }
+        let w: Wrap = serde_yaml::from_str(yaml).unwrap();
+        w.agents.into_iter().next().unwrap()
+    }
+
+    #[test]
+    fn package_plan_npm() {
+        let a = agent_from_yaml(
+            r#"
+agents:
+  - name: x
+    install:
+      type: npm
+      package: "@scope/pkg"
+    run: x
+"#,
+        );
+        let plan = package_plan(&a).unwrap();
+        assert_eq!(plan, vec!["npm", "uninstall", "--global", "@scope/pkg"]);
+    }
+
+    #[test]
+    fn package_plan_cargo() {
+        let a = agent_from_yaml(
+            r#"
+agents:
+  - name: x
+    install:
+      type: cargo
+      package: my-crate
+    run: x
+"#,
+        );
+        let plan = package_plan(&a).unwrap();
+        assert_eq!(plan, vec!["cargo", "uninstall", "my-crate"]);
+    }
+
+    #[test]
+    fn package_plan_binary_is_none() {
+        let a = agent_from_yaml(
+            r#"
+agents:
+  - name: y
+    install:
+      type: binary
+      repo: owner/repo
+      binary: y
+    run: y
+"#,
+        );
+        assert!(package_plan(&a).is_none());
+    }
+
+    #[test]
+    fn package_plan_unknown_method_is_none() {
+        let a = agent_from_yaml(
+            r#"
+agents:
+  - name: z
+    install:
+      type: git
+      repo: https://example.com/z.git
+    run: z
+"#,
+        );
+        assert!(package_plan(&a).is_none());
+    }
+}
+

src/config.rs

@@ -50,7 +50,8 @@ pub struct Settings {
     /// Directory for logs.
     #[serde(default)]
     pub log_dir: Option<String>,
-    /// Shell used to execute install scripts (defaults to sh on Unix).
+    /// Shell used to execute install scripts and to run system commands
+    /// in the interactive prompt (defaults to the user's default shell).
     #[serde(default)]
     pub default_shell: Option<String>,
     /// Try to install missing dependencies automatically.
@@ -623,6 +624,7 @@ mod tests {
         let cfg: Config = serde_yaml::from_str(DEFAULT_CONFIG).unwrap();
         assert!(cfg.agents.len() >= 60, "catalog too small: {}", cfg.agents.len());
         assert!(cfg.agents.iter().any(|a| a.name == "claude-code"));
+        assert!(cfg.agents.iter().any(|a| a.name == "deepseek-harness"));
         assert!(validate(&cfg).is_empty(), "embedded config invalid: {:?}", validate(&cfg));
     }
 

src/deps.rs

@@ -151,19 +151,13 @@ pub fn ensure_deps(app: &App, agent: &AgentDef, runner: &dyn Runner) -> Result<(
                 let proceed = app
                     .confirm(&format!("Run the detected installer for {}? -> {cmd}", os.name))?;
                 if proceed {
-                    if let Ok(tokens) = shell_words::split(cmd) {
-                        if !tokens.is_empty() {
-                            let prog = tokens[0].clone();
-                            let args: Vec<String> = tokens[1..].to_vec();
-                            let empty = BTreeMap::new();
-                            let out = runner.run(&prog, &args, &empty, None, false)?;
-                            if out.code != 0 {
-                                app.log.warn(&format!(
-                                    "installation of '{}' failed (exit code {})",
-                                    dep.name, out.code
-                                ));
-                            }
-                        }
+                    let code = crate::toolchain::run_install_command(runner, cmd)?;
+                    crate::toolchain::refresh_path();
+                    if code != 0 {
+                        app.log.warn(&format!(
+                            "installation of '{}' failed (exit code {code})",
+                            dep.name
+                        ));
                     }
                 }
             }

src/doctor.rs

@@ -65,7 +65,12 @@ pub fn run(app: &App, runner: &dyn Runner) -> DoctorReport {
     ];
     let os = crate::toolchain::OsInfo::detect();
     for (tool, required) in tools {
-        match runner.which(tool) {
+        let found = if *tool == "python" {
+            runner.which("python3").or_else(|| runner.which("python"))
+        } else {
+            runner.which(tool)
+        };
+        match found {
             Some(path) => {
                 let mut detail = path.display().to_string();
                 let empty = BTreeMap::new();
@@ -211,8 +216,8 @@ fn is_on_path(dir: &std::path::Path) -> bool {
 pub fn install_missing_tools(app: &App, runner: &dyn Runner) -> Result<Vec<String>> {
     let mut installed = Vec::new();
     let os = crate::toolchain::OsInfo::detect();
-    for tool in ["node", "python", "cargo", "go", "bun", "uv", "docker"] {
-        if runner.which(tool).is_some() {
+    for tool in ["git", "node", "python", "cargo", "go", "bun", "uv", "docker"] {
+        if crate::toolchain::tool_is_present(tool, runner) {
             continue;
         }
         let cmds = crate::toolchain::install_commands(tool, &os);
@@ -225,19 +230,13 @@ pub fn install_missing_tools(app: &App, runner: &dyn Runner) -> Result<Vec<Strin
         ))? {
             continue;
         }
-        if let Ok(tokens) = shell_words::split(cmd) {
-            if !tokens.is_empty() {
-                let prog = tokens[0].clone();
-                let args: Vec<String> = tokens[1..].to_vec();
-                let empty = BTreeMap::new();
-                let out = runner.run(&prog, &args, &empty, None, false)?;
-                installed.push(if out.code == 0 {
-                    format!("installed '{tool}' ({cmd})")
-                } else {
-                    format!("failed to install '{tool}' (exit code {})", out.code)
-                });
-            }
-        }
+        let code = crate::toolchain::run_install_command(runner, cmd)?;
+        crate::toolchain::refresh_path();
+        installed.push(if code == 0 {
+            format!("installed '{tool}' ({cmd})")
+        } else {
+            format!("failed to install '{tool}' (exit code {code})")
+        });
     }
     Ok(installed)
 }

src/lib.rs

@@ -20,12 +20,16 @@ pub mod deps;
 pub mod doctor;
 pub mod download;
 pub mod installers;
+pub mod nav;
 pub mod output;
 pub mod probe;
+pub mod ps;
 pub mod process;
 pub mod repl;
 pub mod runner;
+pub mod shell;
 pub mod state;
+pub mod tables;
 pub mod toolchain;
 pub mod version;
 

src/nav.rs

@@ -0,0 +1,311 @@
+//! Nushell-inspired navigation helpers: a boxed table listing of files and
+//! directories (ls), and directory/path completion for Tab.
+
+use crate::tables::{Cell, DataTable};
+use anyhow::{Context, Result};
+use colored::Colorize;
+use std::path::{Path, PathBuf};
+
+/// Human-readable byte size, like Nushell ("512 B", "1.2 KB", "3.4 MB").
+pub fn format_size(bytes: u64) -> String {
+    const KB: f64 = 1024.0;
+    const MB: f64 = 1024.0 * 1024.0;
+    const GB: f64 = 1024.0 * 1024.0 * 1024.0;
+    let b = bytes as f64;
+    if b < KB {
+        format!("{bytes} B")
+    } else if b < MB {
+        format!("{:.1} KB", b / KB)
+    } else if b < GB {
+        format!("{:.1} MB", b / MB)
+    } else {
+        format!("{:.1} GB", b / GB)
+    }
+}
+
+/// Recursive size of a directory, tightly bounded: beyond the entry cap the
+/// size is reported as unknown (None). The cap is deliberately small so a
+/// listing stays snappy even when it contains huge trees.
+pub fn dir_size(path: &Path) -> Option<u64> {
+    const CAP: usize = 500;
+    let mut total: u64 = 0;
+    let mut stack: Vec<PathBuf> = vec![path.to_path_buf()];
+    let mut visited: usize = 0;
+    while let Some(dir) = stack.pop() {
+        let rd = std::fs::read_dir(&dir).ok()?;
+        for entry in rd.flatten() {
+            visited += 1;
+            if visited > CAP {
+                return None;
+            }
+            let p = entry.path();
+            match std::fs::symlink_metadata(&p) {
+                Ok(m) if m.is_dir() => stack.push(p),
+                Ok(m) if m.is_file() => {
+                    total = total.saturating_add(m.len());
+                }
+                _ => {}
+            }
+        }
+    }
+    Some(total)
+}
+
+fn modified_str(path: &Path) -> String {
+    std::fs::metadata(path)
+        .and_then(|m| m.modified())
+        .ok()
+        .map(|t| {
+            let dt: chrono::DateTime<chrono::Local> = t.into();
+            dt.format("%Y-%m-%d %H:%M").to_string()
+        })
+        .unwrap_or_else(|| "—".to_string())
+}
+
+fn paint(s: &str, color: bool, style: u8) -> String {
+    if !color {
+        return s.to_string();
+    }
+    match style {
+        1 => s.blue().bold().to_string(),   // directory
+        2 => s.green().to_string(),         // executable
+        3 => s.cyan().to_string(),          // symlink
+        4 => s.red().to_string(),           // broken symlink
+        _ => s.to_string(),
+    }
+}
+
+fn is_executable(path: &Path, meta: &std::fs::Metadata) -> bool {
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        meta.permissions().mode() & 0o111 != 0
+    }
+    #[cfg(windows)]
+    {
+        let _ = meta;
+        matches!(
+            path.extension()
+                .and_then(|e| e.to_str())
+                .map(|e| e.to_lowercase())
+                .as_deref(),
+            Some("exe") | Some("bat") | Some("cmd") | Some("com")
+        )
+    }
+}
+
+/// Build the ls table (columns: name, type, size, modified). Directories
+/// come first, then alphabetical order.
+pub fn ls_table(path: &Path, color: bool) -> Result<DataTable> {
+    let rd = std::fs::read_dir(path)
+        .with_context(|| format!("cannot read {}", path.display()))?;
+    let mut rows: Vec<(String, Vec<Cell>)> = Vec::new();
+    for entry in rd.flatten() {
+        let p = entry.path();
+        let meta = match std::fs::symlink_metadata(&p) {
+            Ok(m) => m,
+            Err(_) => continue,
+        };
+        let file_type = meta.file_type();
+        let name = p
+            .file_name()
+            .map(|n| n.to_string_lossy().to_string())
+            .unwrap_or_default();
+        let (kind, style) = if file_type.is_symlink() {
+            ("symlink", if p.exists() { 3 } else { 4 })
+        } else if file_type.is_dir() {
+            ("dir", 1)
+        } else if is_executable(&p, &meta) {
+            ("file", 2)
+        } else {
+            ("file", 0)
+        };
+        let (size_text, size_bytes) = if file_type.is_dir() {
+            match dir_size(&p) {
+                Some(s) => (format_size(s), Some(s)),
+                None => ("—".to_string(), None),
+            }
+        } else {
+            (format_size(meta.len()), Some(meta.len()))
+        };
+        let mut display = name.clone();
+        if file_type.is_dir() {
+            display.push('/');
+        } else if file_type.is_symlink() {
+            if let Ok(target) = std::fs::read_link(&p) {
+                display.push_str(&format!(" -> {}", target.display()));
+            }
+        }
+        rows.push((
+            name.to_lowercase(),
+            vec![
+                Cell::str(paint(&display, color, style)),
+                Cell::str(kind.to_string()),
+                Cell::bytes(size_bytes.unwrap_or(0), size_text),
+                Cell::str(modified_str(&p)),
+            ],
+        ));
+    }
+    // Directories first, then alphabetical.
+    rows.sort_by(|a, b| {
+        let a_dir = a.1[1].text == "dir";
+        let b_dir = b.1[1].text == "dir";
+        b_dir.cmp(&a_dir).then_with(|| a.0.cmp(&b.0))
+    });
+    Ok(DataTable {
+        columns: vec![
+            "name".into(),
+            "type".into(),
+            "size".into(),
+            "modified".into(),
+        ],
+        rows: rows.into_iter().map(|(_, r)| r).collect(),
+    })
+}
+
+/// Render a Nushell-style boxed table of the entries of a path.
+pub fn render_ls(path: &Path, color: bool) -> Result<String> {
+    Ok(ls_table(path, color)?.render(color))
+}
+
+/// Completion candidates for a path fragment typed after cd or ls.
+///
+/// The last segment is matched against the entries of the base directory;
+/// directory candidates end with a separator so the next Tab dives one level
+/// deeper, like Nushell. With dirs_only, files are excluded (cd).
+pub fn path_candidates(base_dir: &Path, input: &str, dirs_only: bool) -> Vec<String> {
+    let sep = std::path::MAIN_SEPARATOR;
+    let alt = if sep == '\\' { '/' } else { '\\' };
+    let idx = input.rfind(|c| c == sep || c == alt);
+    let (base_part, stem) = match idx {
+        Some(i) => (&input[..=i], &input[i + 1..]),
+        None => ("", input),
+    };
+    let use_sep = if input.contains(alt) && !input.contains(sep) {
+        alt
+    } else {
+        sep
+    };
+    let base: PathBuf = if base_part.starts_with('~') {
+        crate::config::expand_path(base_part)
+    } else if base_part.is_empty() {
+        base_dir.to_path_buf()
+    } else {
+        PathBuf::from(base_part)
+    };
+
+    let mut names: Vec<(String, bool)> = Vec::new();
+    if let Ok(rd) = std::fs::read_dir(&base) {
+        for entry in rd.flatten() {
+            let p = entry.path();
+            let is_dir = p.is_dir();
+            if dirs_only && !is_dir {
+                continue;
+            }
+            let Some(name) = p.file_name().and_then(|n| n.to_str()) else {
+                continue;
+            };
+            if !name.starts_with(stem) {
+                continue;
+            }
+            names.push((name.to_string(), is_dir));
+        }
+    }
+    names.sort_by(|a, b| {
+        b.1.cmp(&a.1)
+            .then_with(|| a.0.to_lowercase().cmp(&b.0.to_lowercase()))
+    });
+    names
+        .into_iter()
+        .map(|(name, is_dir)| {
+            let mut full = format!("{base_part}{name}");
+            if is_dir {
+                full.push(use_sep);
+            }
+            full
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn formats_sizes() {
+        assert_eq!(format_size(0), "0 B");
+        assert_eq!(format_size(512), "512 B");
+        assert_eq!(format_size(2048), "2.0 KB");
+        assert_eq!(format_size(5 * 1024 * 1024), "5.0 MB");
+        assert_eq!(format_size(3 * 1024 * 1024 * 1024), "3.0 GB");
+    }
+
+    #[test]
+    fn dir_size_is_bounded() {
+        let dir = tempfile::tempdir().unwrap();
+        let big = dir.path().join("big");
+        std::fs::create_dir_all(&big).unwrap();
+        for i in 0..520 {
+            std::fs::write(big.join(format!("f{i}.txt")), "x").unwrap();
+        }
+        // Beyond the cap the size is unknown, and the walk stays cheap.
+        assert_eq!(dir_size(&big), None);
+        let small = dir.path().join("small");
+        std::fs::create_dir_all(&small).unwrap();
+        std::fs::write(small.join("a.txt"), "hello").unwrap();
+        assert_eq!(dir_size(&small), Some(5));
+    }
+
+    #[test]
+    fn completes_directories_only() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::create_dir_all(dir.path().join("src")).unwrap();
+        std::fs::create_dir_all(dir.path().join("src2")).unwrap();
+        std::fs::write(dir.path().join("readme.txt"), "x").unwrap();
+
+        let cands = path_candidates(dir.path(), "", true);
+        assert!(cands.iter().any(|c| c == "src\\" || c == "src/"));
+        assert!(cands.iter().any(|c| c == "src2\\" || c == "src2/"));
+        assert!(!cands.iter().any(|c| c.contains("readme")));
+
+        let cands = path_candidates(dir.path(), "s", true);
+        assert_eq!(cands.len(), 2, "{cands:?}");
+
+        // Files appear for ls completion.
+        let cands = path_candidates(dir.path(), "", false);
+        assert!(cands.iter().any(|c| c.contains("readme")));
+    }
+
+    #[test]
+    fn completes_nested_paths() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::create_dir_all(dir.path().join("src").join("commands")).unwrap();
+        std::fs::create_dir_all(dir.path().join("src").join("installers")).unwrap();
+        let sep = std::path::MAIN_SEPARATOR;
+        let prefix = format!("src{}", sep);
+        let cands = path_candidates(dir.path(), &format!("src{}co", sep), true);
+        assert!(cands.iter().any(|c| c == &format!("{prefix}commands{}", sep)));
+        assert!(!cands.iter().any(|c| c.contains("installers")));
+    }
+
+    #[test]
+    fn renders_ls_table() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::create_dir_all(dir.path().join("subdir")).unwrap();
+        std::fs::write(dir.path().join("file.txt"), "hello").unwrap();
+        let table = render_ls(dir.path(), false).unwrap();
+        assert!(table.contains("╭"));
+        assert!(table.contains("╰"));
+        assert!(table.contains("name"));
+        assert!(table.contains("type"));
+        assert!(table.contains("modified"));
+        assert!(table.contains("subdir/"));
+        assert!(table.contains("file.txt"));
+        assert!(table.contains("dir"));
+        assert!(table.contains("file"));
+        assert!(table.contains("5 B"));
+        // Every line of the table has the same width.
+        let widths: Vec<usize> = table.lines().map(|l| l.chars().count()).collect();
+        assert!(widths.iter().all(|w| *w == widths[0]), "unaligned table:\n{table}");
+    }
+}

src/ps.rs

@@ -0,0 +1,218 @@
+//! ps: Nushell-style process table.
+//!
+//! Windows uses the Toolhelp32 snapshot API (pid, ppid, name, threads, cpu
+//! time, working set); Unix reads /proc.
+
+use crate::tables::{Cell, DataTable};
+
+/// Columns: pid, ppid, name, cpu, mem, threads.
+fn columns() -> Vec<String> {
+    vec![
+        "pid".into(),
+        "ppid".into(),
+        "name".into(),
+        "cpu".into(),
+        "mem".into(),
+        "threads".into(),
+    ]
+}
+
+/// Build the process table.
+pub fn ps_table() -> DataTable {
+    #[cfg(windows)]
+    let rows = windows_rows();
+    #[cfg(unix)]
+    let rows = unix_rows();
+    #[cfg(not(any(windows, unix)))]
+    let rows = Vec::new();
+
+    let mut rows = rows;
+    rows.sort_by(|a, b| {
+        a[0]
+            .num
+            .unwrap_or(0.0)
+            .partial_cmp(&b[0].num.unwrap_or(0.0))
+            .unwrap_or(std::cmp::Ordering::Equal)
+    });
+    DataTable {
+        columns: columns(),
+        rows,
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Windows: Toolhelp32 snapshot
+// ---------------------------------------------------------------------------
+
+#[cfg(windows)]
+fn windows_rows() -> Vec<Vec<Cell>> {
+    use crate::nav::format_size;
+    use std::mem::size_of;
+    use windows_sys::Win32::Foundation::{CloseHandle, INVALID_HANDLE_VALUE};
+    use windows_sys::Win32::System::Diagnostics::ToolHelp::{
+        CreateToolhelp32Snapshot, Process32FirstW, Process32NextW, PROCESSENTRY32W,
+        TH32CS_SNAPPROCESS,
+    };
+    use windows_sys::Win32::System::ProcessStatus::{
+        K32GetProcessMemoryInfo, PROCESS_MEMORY_COUNTERS,
+    };
+    use windows_sys::Win32::System::Threading::{
+        GetProcessTimes, OpenProcess, PROCESS_QUERY_INFORMATION,
+    };
+
+    let mut rows: Vec<Vec<Cell>> = Vec::new();
+    let snapshot = unsafe { CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0) };
+    if snapshot == INVALID_HANDLE_VALUE {
+        return rows;
+    }
+    let mut entry: PROCESSENTRY32W = unsafe { std::mem::zeroed() };
+    entry.dwSize = size_of::<PROCESSENTRY32W>() as u32;
+    let mut ok = unsafe { Process32FirstW(snapshot, &mut entry) };
+    while ok != 0 {
+        let pid = entry.th32ProcessID;
+        let ppid = entry.th32ParentProcessID;
+        let threads = entry.cntThreads;
+        let mut name = String::new();
+        for &unit in entry.szExeFile.iter() {
+            if unit == 0 {
+                break;
+            }
+            if let Some(c) = char::from_u32(unit as u32) {
+                name.push(c);
+            }
+        }
+
+        // CPU time and memory need a process handle; some system processes
+        // refuse — those cells stay "—".
+        let mut cpu = "—".to_string();
+        let mut mem = "—".to_string();
+        let handle = unsafe { OpenProcess(PROCESS_QUERY_INFORMATION, 0, pid) };
+        if handle != 0 {
+            let mut counters: PROCESS_MEMORY_COUNTERS = unsafe { std::mem::zeroed() };
+            if unsafe {
+                K32GetProcessMemoryInfo(
+                    handle,
+                    &mut counters,
+                    size_of::<PROCESS_MEMORY_COUNTERS>() as u32,
+                )
+            } != 0
+            {
+                mem = format_size(counters.WorkingSetSize as u64);
+            }
+            let (mut created, mut exited, mut kernel, mut user): (
+                windows_sys::Win32::Foundation::FILETIME,
+                windows_sys::Win32::Foundation::FILETIME,
+                windows_sys::Win32::Foundation::FILETIME,
+                windows_sys::Win32::Foundation::FILETIME,
+            ) = unsafe {
+                (
+                    std::mem::zeroed(),
+                    std::mem::zeroed(),
+                    std::mem::zeroed(),
+                    std::mem::zeroed(),
+                )
+            };
+            if unsafe { GetProcessTimes(handle, &mut created, &mut exited, &mut kernel, &mut user) } != 0 {
+                let ticks = (filetime_u64(&kernel) + filetime_u64(&user)) as f64 / 10_000_000.0;
+                cpu = format!("{ticks:.0}s");
+            }
+            unsafe { CloseHandle(handle) };
+        }
+
+        rows.push(vec![
+            Cell::num(pid as f64, pid.to_string()),
+            Cell::num(ppid as f64, ppid.to_string()),
+            Cell::str(name),
+            Cell::str(cpu),
+            Cell::str(mem),
+            Cell::num(threads as f64, threads.to_string()),
+        ]);
+        ok = unsafe { Process32NextW(snapshot, &mut entry) };
+    }
+    unsafe { CloseHandle(snapshot) };
+    rows
+}
+
+#[cfg(windows)]
+fn filetime_u64(ft: &windows_sys::Win32::Foundation::FILETIME) -> u64 {
+    ((ft.dwHighDateTime as u64) << 32) | (ft.dwLowDateTime as u64)
+}
+
+// ---------------------------------------------------------------------------
+// Unix: /proc
+// ---------------------------------------------------------------------------
+
+#[cfg(unix)]
+fn unix_rows() -> Vec<Vec<Cell>> {
+    use crate::nav::format_size;
+    let page_size = page_size();
+    let mut rows: Vec<Vec<Cell>> = Vec::new();
+    let Ok(entries) = std::fs::read_dir("/proc") else {
+        return rows;
+    };
+    for entry in entries.flatten() {
+        let name = entry.file_name().to_string_lossy().to_string();
+        let Ok(pid) = name.parse::<f64>() else {
+            continue;
+        };
+        let base = entry.path();
+        let Ok(stat) = std::fs::read_to_string(base.join("stat")) else {
+            continue;
+        };
+        // The comm field is in parentheses and may contain spaces.
+        let Some(close) = stat.rfind(')') else {
+            continue;
+        };
+        let comm = stat[stat.find('(').unwrap_or(0) + 1..close].to_string();
+        let rest: Vec<&str> = stat[close + 2..].split_whitespace().collect();
+        if rest.len() < 22 {
+            continue;
+        }
+        // rest[0]=state, rest[1]=ppid, rest[11]=utime, rest[12]=stime,
+        // rest[17]=num_threads, rest[21]=rss (pages).
+        let ppid = rest[1].parse::<f64>().unwrap_or(0.0);
+        let utime = rest[11].parse::<f64>().unwrap_or(0.0);
+        let stime = rest[12].parse::<f64>().unwrap_or(0.0);
+        let threads = rest[17].parse::<f64>().unwrap_or(0.0);
+        let rss_pages = rest[21].parse::<u64>().unwrap_or(0);
+        let cpu = (utime + stime) / 100.0;
+        rows.push(vec![
+            Cell::num(pid, pid.to_string()),
+            Cell::num(ppid, ppid.to_string()),
+            Cell::str(comm),
+            Cell::str(format!("{cpu:.0}s")),
+            Cell::str(format_size(rss_pages * page_size)),
+            Cell::num(threads, threads.to_string()),
+        ]);
+    }
+    rows
+}
+
+#[cfg(unix)]
+fn page_size() -> u64 {
+    // Standard page size; RSS in pages * 4096 is close enough for display.
+    4096
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ps_produces_a_table() {
+        let table = ps_table();
+        assert_eq!(
+            table.columns,
+            vec!["pid", "ppid", "name", "cpu", "mem", "threads"]
+        );
+        assert!(!table.rows.is_empty(), "process table should not be empty");
+        // Our own pid is in the table.
+        let me = std::process::id().to_string();
+        assert!(
+            table.rows.iter().any(|r| r[0].text == me),
+            "our pid should be listed"
+        );
+        // Rows have as many cells as columns.
+        assert!(table.rows.iter().all(|r| r.len() == 6));
+    }
+}

src/shell.rs

@@ -0,0 +1,296 @@
+//! System-shell gateway.
+//!
+//! The interactive prompt doubles as a gateway between the user and their
+//! system shell: every input that is not an am command is executed by the
+//! selected shell (pwsh, powershell, cmd, bash, zsh, fish, sh, ...).
+//!
+//! The default shell is resolved at startup from, in order: the
+//! `settings.default_shell` configuration entry, the `SHELL` environment
+//! variable, `COMSPEC` (Windows), then the first shell found on PATH among
+//! the platform's preferred shells. `shell <name>` switches at runtime.
+
+use crate::config::Config;
+use anyhow::{anyhow, Result};
+use std::ffi::OsString;
+use std::path::Path;
+use std::process::Command as ProcessCommand;
+
+/// One supported system shell and how to invoke it with a command line.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ShellSpec {
+    /// Canonical short name ("pwsh", "cmd", "bash", ...).
+    pub name: &'static str,
+    /// Human-readable title ("PowerShell 7", "Command Prompt", ...).
+    pub title: &'static str,
+    /// Executable to spawn.
+    pub program: &'static str,
+    /// Arguments placed before the user's command line.
+    pub args: &'static [&'static str],
+    /// Executable probed on PATH to decide whether the shell is available.
+    pub probe: &'static str,
+}
+
+/// Every shell the gateway understands, in display order.
+pub static KNOWN_SHELLS: &[ShellSpec] = &[
+    ShellSpec {
+        name: "pwsh",
+        title: "PowerShell 7",
+        program: "pwsh",
+        args: &["-NoLogo", "-NoProfile", "-Command"],
+        probe: "pwsh",
+    },
+    ShellSpec {
+        name: "powershell",
+        title: "Windows PowerShell",
+        program: "powershell",
+        args: &["-NoLogo", "-NoProfile", "-Command"],
+        probe: "powershell",
+    },
+    ShellSpec {
+        name: "cmd",
+        title: "Command Prompt",
+        program: "cmd",
+        args: &["/C"],
+        probe: "cmd",
+    },
+    ShellSpec {
+        name: "bash",
+        title: "Bash",
+        program: "bash",
+        args: &["-c"],
+        probe: "bash",
+    },
+    ShellSpec {
+        name: "zsh",
+        title: "Zsh",
+        program: "zsh",
+        args: &["-c"],
+        probe: "zsh",
+    },
+    ShellSpec {
+        name: "fish",
+        title: "Fish",
+        program: "fish",
+        args: &["-c"],
+        probe: "fish",
+    },
+    ShellSpec {
+        name: "sh",
+        title: "POSIX sh",
+        program: "sh",
+        args: &["-c"],
+        probe: "sh",
+    },
+    ShellSpec {
+        name: "nu",
+        title: "Nushell",
+        program: "nu",
+        args: &["-c"],
+        probe: "nu",
+    },
+    ShellSpec {
+        name: "elvish",
+        title: "Elvish",
+        program: "elvish",
+        args: &["-c"],
+        probe: "elvish",
+    },
+];
+
+/// Resolve a shell by canonical name or common alias, case-insensitively
+/// ("pwsh" | "powershell7" | "ps" | "cmd.exe" | "nushell" | ...).
+pub fn find(name: &str) -> Option<&'static ShellSpec> {
+    let mut n = name.trim().to_ascii_lowercase();
+    if let Some(stripped) = n.strip_suffix(".exe") {
+        n = stripped.to_string();
+    }
+    KNOWN_SHELLS.iter().find(|s| {
+        s.name == n
+            || match s.name {
+                "pwsh" => n == "powershell7" || n == "ps7",
+                "powershell" => n == "ps",
+                "cmd" => n == "dos" || n == "command" || n == "command-prompt",
+                "sh" => n == "posix" || n == "dash",
+                "nu" => n == "nushell",
+                _ => false,
+            }
+    })
+}
+
+/// Whether a shell executable can be found (or, for cmd on Windows, whether
+/// COMSPEC is set).
+pub fn probe_available(spec: &ShellSpec) -> bool {
+    which::which(spec.probe).is_ok()
+        || (cfg!(windows) && spec.name == "cmd" && std::env::var_os("COMSPEC").is_some())
+}
+
+/// Resolve the user's default shell from the configuration, environment
+/// variables, then the shells found on PATH. Always returns a shell.
+pub fn resolve_default(
+    configured: Option<&str>,
+    shell_env: Option<OsString>,
+    comspec: Option<OsString>,
+) -> &'static ShellSpec {
+    if let Some(s) = configured.and_then(find) {
+        return s;
+    }
+    if let Some(s) = shell_env.and_then(|v| from_env_path(&v)) {
+        return s;
+    }
+    if let Some(s) = comspec.and_then(|v| from_env_path(&v)) {
+        return s;
+    }
+    let preferred: &[&str] = if cfg!(windows) {
+        &["pwsh", "powershell", "cmd"]
+    } else {
+        &["bash", "zsh", "fish", "sh"]
+    };
+    for name in preferred {
+        if let Some(s) = find(name) {
+            if probe_available(s) {
+                return s;
+            }
+        }
+    }
+    // Last resort: the platform's built-in shell.
+    find(if cfg!(windows) { "cmd" } else { "sh" }).expect("built-in shell must exist")
+}
+
+/// Extract a shell name from an environment value such as SHELL or COMSPEC.
+fn from_env_path(value: &OsString) -> Option<&'static ShellSpec> {
+    let text = value.to_string_lossy();
+    let name = Path::new(text.as_ref())
+        .file_name()
+        .map(|f| f.to_string_lossy().to_string())
+        .unwrap_or_default();
+    find(&name)
+}
+
+/// The gateway's runtime state: which shell executes system commands now,
+/// which one was detected as the user's default, and which are installed.
+#[derive(Debug, Clone)]
+pub struct ShellSession {
+    /// Shell executing system commands right now.
+    pub current: &'static ShellSpec,
+    /// The shell detected as the user's default at startup.
+    pub default: &'static ShellSpec,
+    /// Shells found on this machine.
+    pub available: Vec<&'static ShellSpec>,
+}
+
+impl ShellSession {
+    /// Build a session: detect the default shell and probe availability.
+    pub fn start(config: &Config) -> Self {
+        let default = resolve_default(
+            config.settings.default_shell.as_deref(),
+            std::env::var_os("SHELL"),
+            std::env::var_os("COMSPEC"),
+        );
+        let available = KNOWN_SHELLS
+            .iter()
+            .filter(|s| probe_available(s))
+            .collect();
+        Self {
+            current: default,
+            default,
+            available,
+        }
+    }
+
+    /// Switch the active shell. Fails for unknown or unavailable shells.
+    pub fn switch(&mut self, name: &str) -> Result<&'static ShellSpec> {
+        let spec = find(name).ok_or_else(|| anyhow!("unknown shell '{name}'"))?;
+        if !self.available.iter().any(|s| s.name == spec.name) {
+            return Err(anyhow!(
+                "shell '{}' is not available on this machine (available: {})",
+                spec.name,
+                self.available
+                    .iter()
+                    .map(|s| s.name)
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            ));
+        }
+        self.current = spec;
+        Ok(spec)
+    }
+
+    /// Whether the active shell is the user's default shell.
+    pub fn is_default(&self) -> bool {
+        self.current.name == self.default.name
+    }
+
+    /// Execute one system command line in the current shell with inherited
+    /// stdio, so interactive programs keep working. Returns the exit code.
+    pub fn run(&self, line: &str) -> Result<i32> {
+        let status = ProcessCommand::new(self.current.program)
+            .args(self.current.args)
+            .arg(line)
+            .status()
+            .map_err(|e| anyhow!("cannot run {}: {e}", self.current.program))?;
+        Ok(status.code().unwrap_or(1))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn find_resolves_aliases() {
+        assert_eq!(find("pwsh").unwrap().name, "pwsh");
+        assert_eq!(find("PowerShell7").unwrap().name, "pwsh");
+        assert_eq!(find("ps").unwrap().name, "powershell");
+        assert_eq!(find("cmd.exe").unwrap().name, "cmd");
+        assert_eq!(find("CMD").unwrap().name, "cmd");
+        assert_eq!(find("nushell").unwrap().name, "nu");
+        assert_eq!(find("dash").unwrap().name, "sh");
+        assert!(find("blorp").is_none());
+    }
+
+    #[test]
+    fn resolve_default_prefers_configured_shell() {
+        let s = resolve_default(Some("zsh"), None, None);
+        assert_eq!(s.name, "zsh");
+    }
+
+    #[test]
+    fn resolve_default_uses_environment_values() {
+        // SHELL wins over COMSPEC when the configured value is absent.
+        let s = resolve_default(
+            None,
+            Some(OsString::from("/usr/bin/bash")),
+            Some(OsString::from("C:/Windows/system32/cmd.exe")),
+        );
+        assert_eq!(s.name, "bash");
+        // COMSPEC alone is honored.
+        let s = resolve_default(
+            None,
+            None,
+            Some(OsString::from("C:/Windows/system32/cmd.exe")),
+        );
+        assert_eq!(s.name, "cmd");
+        // Unrecognized values fall through to a probe — result is still a
+        // known shell.
+        let s = resolve_default(None, Some(OsString::from("/usr/bin/weird")), None);
+        assert!(KNOWN_SHELLS.iter().any(|k| k.name == s.name));
+    }
+
+    #[test]
+    fn switch_validates_availability() {
+        let sh = find("sh").unwrap();
+        let bash = find("bash").unwrap();
+        let mut session = ShellSession {
+            current: sh,
+            default: sh,
+            available: vec![sh, bash],
+        };
+        assert_eq!(session.switch("bash").unwrap().name, "bash");
+        assert_eq!(session.current.name, "bash");
+        assert!(!session.is_default());
+        let err = session.switch("zsh").unwrap_err();
+        assert!(err.to_string().contains("not available"), "{err}");
+        let err = session.switch("blorp").unwrap_err();
+        assert!(err.to_string().contains("unknown shell"), "{err}");
+    }
+}

src/tables.rs

@@ -0,0 +1,328 @@
+//! Generic Nushell-style tables: render a boxed table, filter rows with
+//! where-like predicates and select a column with get.
+
+use anyhow::{bail, Result};
+use colored::Colorize;
+
+/// One cell: the text to display plus a typed value for filtering
+/// (number, byte size, or plain string).
+#[derive(Debug, Clone)]
+pub struct Cell {
+    pub text: String,
+    pub num: Option<f64>,
+    pub bytes: Option<u64>,
+}
+
+impl Cell {
+    pub fn str(s: impl Into<String>) -> Self {
+        Cell {
+            text: s.into(),
+            num: None,
+            bytes: None,
+        }
+    }
+
+    pub fn num(n: f64, text: String) -> Self {
+        Cell {
+            text,
+            num: Some(n),
+            bytes: None,
+        }
+    }
+
+    pub fn bytes(b: u64, text: String) -> Self {
+        Cell {
+            text,
+            num: None,
+            bytes: Some(b),
+        }
+    }
+}
+
+/// A tabular result produced by ls, ps, where or get.
+#[derive(Debug, Clone, Default)]
+pub struct DataTable {
+    pub columns: Vec<String>,
+    pub rows: Vec<Vec<Cell>>,
+}
+
+impl DataTable {
+    pub fn column_index(&self, name: &str) -> Option<usize> {
+        self.columns
+            .iter()
+            .position(|c| c.eq_ignore_ascii_case(name))
+    }
+
+    /// Render the boxed Nushell-style table.
+    pub fn render(&self, color: bool) -> String {
+        let headers = self.columns.clone();
+        // Column 0 is the row index; the data columns follow.
+        let index_width = self.rows.len().to_string().len().max(1);
+        let mut widths: Vec<usize> = headers.iter().map(|h| visible_len(h)).collect();
+        let mut cells: Vec<Vec<String>> = Vec::new();
+        for (i, row) in self.rows.iter().enumerate() {
+            let mut line = vec![i.to_string()];
+            for cell in row {
+                line.push(cell.text.clone());
+            }
+            for (c, cell) in line.iter().enumerate().skip(1) {
+                widths[c - 1] = widths[c - 1].max(visible_len(cell));
+            }
+            cells.push(line);
+        }
+        let all_headers: Vec<String> = std::iter::once("#".to_string())
+            .chain(headers.iter().cloned())
+            .collect();
+        let mut all_widths = vec![index_width];
+        all_widths.extend(widths.iter().cloned());
+        for (c, w) in all_widths.iter_mut().enumerate() {
+            if c < all_headers.len() {
+                *w = (*w).max(visible_len(&all_headers[c]));
+            }
+        }
+
+        let pad = |s: &str, w: usize| -> String {
+            let n = visible_len(s);
+            format!("{s}{}", " ".repeat(w.saturating_sub(n)))
+        };
+        let border = |left: char, mid: char, right: char| -> String {
+            let mut line = String::new();
+            line.push(left);
+            for (i, w) in all_widths.iter().enumerate() {
+                if i > 0 {
+                    line.push(mid);
+                }
+                line.push_str(&"─".repeat(w + 2));
+            }
+            line.push(right);
+            line
+        };
+        let row_line = |row: &[String], bold: bool| -> String {
+            let mut line = String::from("│");
+            for (i, c) in row.iter().enumerate() {
+                line.push(' ');
+                let cell = pad(c, all_widths[i]);
+                let rendered = if bold {
+                    cell.bold().to_string()
+                } else {
+                    cell
+                };
+                line.push_str(&rendered);
+                line.push(' ');
+                line.push('│');
+            }
+            line
+        };
+        let dim = |s: &str| -> String {
+            if color {
+                s.dimmed().to_string()
+            } else {
+                s.to_string()
+            }
+        };
+
+        let mut out = String::new();
+        out.push_str(&dim(&border('╭', '┬', '╮')));
+        out.push('\n');
+        out.push_str(&row_line(&all_headers, true));
+        out.push('\n');
+        out.push_str(&dim(&border('├', '┼', '┤')));
+        out.push('\n');
+        for line in &cells {
+            out.push_str(&row_line(line, false));
+            out.push('\n');
+        }
+        out.push_str(&dim(&border('╰', '┴', '╯')));
+        out.push('\n');
+        out
+    }
+}
+
+/// Parse a where value: "1mb"/"512kb"/"2gb" become byte sizes, numbers
+/// become numbers, everything else is a string.
+#[derive(Debug, Clone, PartialEq)]
+enum WhereValue {
+    Num(f64),
+    Bytes(u64),
+    Str(String),
+}
+
+fn parse_value(raw: &str) -> WhereValue {
+    let lower = raw.trim().to_lowercase();
+    for (suffix, mult) in [("gb", 1024u64.pow(3)), ("mb", 1024u64.pow(2)), ("kb", 1024)] {
+        if let Some(n) = lower.strip_suffix(suffix) {
+            if let Ok(v) = n.trim().parse::<f64>() {
+                return WhereValue::Bytes((v * mult as f64) as u64);
+            }
+        }
+    }
+    if let Ok(v) = raw.trim().parse::<f64>() {
+        return WhereValue::Num(v);
+    }
+    WhereValue::Str(raw.trim().to_string())
+}
+
+fn num_cmp(a: f64, b: f64, op: &str) -> bool {
+    match op {
+        ">" => a > b,
+        "<" => a < b,
+        ">=" => a >= b,
+        "<=" => a <= b,
+        "==" => (a - b).abs() < f64::EPSILON,
+        "!=" => (a - b).abs() >= f64::EPSILON,
+        _ => false,
+    }
+}
+
+/// Filter the rows of a table: where <field> <op> <value>.
+pub fn filter_where(table: &DataTable, field: &str, op: &str, value: &str) -> Result<DataTable> {
+    let Some(idx) = table.column_index(field) else {
+        bail!(
+            "unknown column '{field}' — available: {}",
+            table.columns.join(", ")
+        );
+    };
+    let val = parse_value(value);
+    let supported = matches!(op, ">" | "<" | ">=" | "<=" | "==" | "!=" | "=~");
+    if !supported {
+        bail!("unknown operator '{op}' — use > < >= <= == != =~");
+    }
+    let mut out = table.clone();
+    out.rows.retain(|row| match row.get(idx) {
+        None => false,
+        Some(cell) => match &val {
+            WhereValue::Num(n) => match cell.num {
+                Some(v) => num_cmp(v, *n, op),
+                None => false,
+            },
+            WhereValue::Bytes(b) => match cell.bytes {
+                Some(v) => num_cmp(v as f64, *b as f64, op),
+                None => false,
+            },
+            WhereValue::Str(s) => {
+                let text = strip_ansi(&cell.text);
+                match op {
+                    "==" => text.eq_ignore_ascii_case(s),
+                    "!=" => !text.eq_ignore_ascii_case(s),
+                    "=~" => text.to_lowercase().contains(&s.to_lowercase()),
+                    _ => false,
+                }
+            }
+        },
+    });
+    Ok(out)
+}
+
+/// Select one column: get <column>.
+pub fn get_column(table: &DataTable, field: &str) -> Result<DataTable> {
+    let Some(idx) = table.column_index(field) else {
+        bail!(
+            "unknown column '{field}' — available: {}",
+            table.columns.join(", ")
+        );
+    };
+    Ok(DataTable {
+        columns: vec![field.to_string()],
+        rows: table
+            .rows
+            .iter()
+            .map(|row| vec![row[idx].clone()])
+            .collect(),
+    })
+}
+
+fn strip_ansi(s: &str) -> String {
+    let mut out = String::new();
+    let mut chars = s.chars();
+    while let Some(c) = chars.next() {
+        if c == '\u{1b}' {
+            for n in chars.by_ref() {
+                if n == 'm' {
+                    break;
+                }
+            }
+        } else {
+            out.push(c);
+        }
+    }
+    out
+}
+
+fn visible_len(s: &str) -> usize {
+    strip_ansi(s).chars().count()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn sample() -> DataTable {
+        DataTable {
+            columns: vec!["name".into(), "type".into(), "size".into()],
+            rows: vec![
+                vec![
+                    Cell::str("src"),
+                    Cell::str("dir"),
+                    Cell::bytes(2048, "2.0 KB".into()),
+                ],
+                vec![
+                    Cell::str("am.exe"),
+                    Cell::str("file"),
+                    Cell::bytes(5_000_000, "4.8 MB".into()),
+                ],
+                vec![
+                    Cell::str("readme.md"),
+                    Cell::str("file"),
+                    Cell::bytes(512, "512 B".into()),
+                ],
+            ],
+        }
+    }
+
+    #[test]
+    fn filters_numeric_and_size() {
+        let t = sample();
+        let big = filter_where(&t, "size", ">", "1mb").unwrap();
+        assert_eq!(big.rows.len(), 1);
+        assert_eq!(big.rows[0][0].text, "am.exe");
+        let eq = filter_where(&t, "type", "==", "dir").unwrap();
+        assert_eq!(eq.rows.len(), 1);
+        let contains = filter_where(&t, "name", "=~", "read").unwrap();
+        assert_eq!(contains.rows.len(), 1);
+    }
+
+    #[test]
+    fn get_selects_column() {
+        let t = sample();
+        let names = get_column(&t, "name").unwrap();
+        assert_eq!(names.columns, vec!["name".to_string()]);
+        assert_eq!(names.rows.len(), 3);
+        assert_eq!(names.rows[1][0].text, "am.exe");
+    }
+
+    #[test]
+    fn unknown_column_errors() {
+        let t = sample();
+        assert!(filter_where(&t, "nope", "==", "x").is_err());
+        assert!(get_column(&t, "nope").is_err());
+    }
+
+    #[test]
+    fn parses_where_values() {
+        assert_eq!(parse_value("1mb"), WhereValue::Bytes(1024 * 1024));
+        assert_eq!(parse_value("512kb"), WhereValue::Bytes(512 * 1024));
+        assert_eq!(parse_value("3.5"), WhereValue::Num(3.5));
+        assert_eq!(parse_value("hello"), WhereValue::Str("hello".into()));
+    }
+
+    #[test]
+    fn render_is_aligned() {
+        let t = sample();
+        let text = t.render(false);
+        assert!(text.contains("╭"));
+        assert!(text.contains("name"));
+        assert!(text.contains("am.exe"));
+        let widths: Vec<usize> = text.lines().map(|l| l.chars().count()).collect();
+        assert!(widths.iter().all(|w| *w == widths[0]), "unaligned:\n{text}");
+    }
+}

src/toolchain.rs

@@ -5,6 +5,10 @@
 //! already present (scoop/winget on Windows, apt/dnf/pacman/apk on Linux,
 //! brew on macOS) — and proposes the exact command to install it.
 
+use crate::runner::Runner;
+use anyhow::Result;
+use std::path::PathBuf;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Family {
     Windows,
@@ -130,6 +134,66 @@ pub fn install_commands(tool: &str, os: &OsInfo) -> Vec<String> {
     out
 }
 
+/// Run an installer command line. Commands containing shell syntax
+/// (pipes, redirections, ...) are executed through the shell; plain
+/// commands are spawned directly.
+pub fn run_install_command(runner: &dyn Runner, cmd: &str) -> Result<i32> {
+    let needs_shell = cmd.contains('|')
+        || cmd.contains('>')
+        || cmd.contains('<')
+        || cmd.contains('&')
+        || cmd.contains(';');
+    let (prog, args) = if needs_shell {
+        #[cfg(windows)]
+        {
+            ("cmd".to_string(), vec!["/C".to_string(), cmd.to_string()])
+        }
+        #[cfg(not(windows))]
+        {
+            ("sh".to_string(), vec!["-c".to_string(), cmd.to_string()])
+        }
+    } else {
+        let tokens = shell_words::split(cmd)
+            .unwrap_or_else(|_| cmd.split_whitespace().map(String::from).collect());
+        if tokens.is_empty() {
+            return Ok(0);
+        }
+        (tokens[0].clone(), tokens[1..].to_vec())
+    };
+    let empty = std::collections::BTreeMap::new();
+    let out = runner.run(&prog, &args, &empty, None, false)?;
+    Ok(out.code)
+}
+
+/// After installers that modify ~/.profile or ~/.zshrc (rustup, bun, uv),
+/// make the newly installed tools visible to the current process so the
+/// dependency re-check can find them.
+pub fn refresh_path() {
+    let mut extra: Vec<PathBuf> = Vec::new();
+    if let Some(home) = crate::config::home_dir() {
+        extra.push(home.join(".cargo").join("bin"));
+        extra.push(home.join(".bun").join("bin"));
+        extra.push(home.join(".local").join("bin"));
+    }
+    let mut parts: Vec<PathBuf> = extra.into_iter().filter(|p| p.is_dir()).collect();
+    if let Some(current) = std::env::var_os("PATH") {
+        parts.extend(std::env::split_paths(&current));
+    }
+    if let Ok(joined) = std::env::join_paths(parts) {
+        std::env::set_var("PATH", joined);
+    }
+}
+
+/// Is a tool considered present? Python is satisfied by python3 too
+/// (Debian ships python3 without a python symlink).
+pub fn tool_is_present(tool: &str, runner: &dyn Runner) -> bool {
+    if tool == "python" {
+        runner.which("python3").is_some() || runner.which("python").is_some()
+    } else {
+        runner.which(tool).is_some()
+    }
+}
+
 fn scoop_command(tool: &str) -> Option<String> {
     let bucket = match tool {
         "git" => "git",
@@ -208,7 +272,7 @@ fn linux_command(tool: &str, pkg: &str) -> Option<String> {
             ("pip", "apk") => "sudo apk add py3-pip",
             ("pip", "zypper") => "sudo zypper install -y python3-pip",
             ("cargo" | "rust", "apt") => {
-                "curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh"
+                "curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y"
             }
             ("cargo" | "rust", "dnf") => "sudo dnf install -y rust cargo",
             ("cargo" | "rust", "pacman") => "sudo pacman -S --noconfirm rust",
@@ -278,6 +342,36 @@ mod tests {
         assert!(brew_command("docker").unwrap().contains("--cask"));
     }
 
+    #[test]
+    fn pipe_commands_run_through_shell() {
+        let runner = crate::runner::MockRunner::new();
+        let code = run_install_command(&runner, "curl -sSf https://x | sh").unwrap();
+        assert_eq!(code, 0);
+        let calls = runner.snapshot();
+        assert_eq!(calls.len(), 1);
+        if cfg!(windows) {
+            assert!(calls[0].starts_with("cmd /C "));
+        } else {
+            assert!(calls[0].starts_with("sh -c "));
+        }
+    }
+
+    #[test]
+    fn plain_commands_spawn_directly() {
+        let runner = crate::runner::MockRunner::new();
+        run_install_command(&runner, "apt install -y git").unwrap();
+        let calls = runner.snapshot();
+        assert!(calls[0].starts_with("apt install -y git"));
+    }
+
+    #[test]
+    fn python3_satisfies_python() {
+        let runner = crate::runner::MockRunner::new().with_found("python3");
+        assert!(tool_is_present("python", &runner));
+        let runner = crate::runner::MockRunner::new();
+        assert!(!tool_is_present("python", &runner));
+    }
+
     #[test]
     fn os_aware_selection() {
         // Windows without scoop falls back to winget.