@@ -816,6 +816,54 @@ pub fn runtime_from(candidates: Vec<(PathBuf, &'static str)>) -> Runtime {
     first_failure.expect("at least one candidate")
 }
 
+/// Memory available to a new process now, in bytes (0 when unknown):
+/// Linux's `MemAvailable`; on macOS free, inactive, speculative and
+/// purgeable pages (what Activity Monitor does not count as used).
+#[cfg(target_os = "macos")]
+pub fn available_memory() -> u64 {
+    extern "C" {
+        // libSystem's own; libc's binding is deprecated in favour of a crate.
+        fn mach_host_self() -> libc::mach_port_t;
+    }
+    // One send right to the host port for the life of the process.
+    static HOST: std::sync::OnceLock<libc::mach_port_t> = std::sync::OnceLock::new();
+    // SAFETY: mach_host_self has no preconditions.
+    let host = *HOST.get_or_init(|| unsafe { mach_host_self() });
+    let mut info: libc::vm_statistics64 = unsafe { std::mem::zeroed() };
+    let mut count = libc::HOST_VM_INFO64_COUNT;
+    // SAFETY: host_statistics64 writes at most `count` integers into `info`.
+    let result = unsafe {
+        libc::host_statistics64(
+            host,
+            libc::HOST_VM_INFO64,
+            (&mut info as *mut libc::vm_statistics64).cast(),
+            &mut count,
+        )
+    };
+    // SAFETY: sysconf has no preconditions.
+    let page = unsafe { libc::sysconf(libc::_SC_PAGESIZE) };
+    if result != 0 || page <= 0 {
+        return 0;
+    }
+    let pages = u64::from(info.free_count)
+        + u64::from(info.inactive_count)
+        + u64::from(info.speculative_count)
+        + u64::from(info.purgeable_count);
+    pages.saturating_mul(page as u64)
+}
+
+/// See the macOS version.
+#[cfg(not(target_os = "macos"))]
+pub fn available_memory() -> u64 {
+    let Ok(text) = fs::read_to_string("/proc/meminfo") else {
+        return 0;
+    };
+    text.lines()
+        .find_map(|line| line.strip_prefix("MemAvailable:"))
+        .and_then(|rest| rest.split_whitespace().next()?.parse::<u64>().ok())
+        .map_or(0, |kb| kb.saturating_mul(1024))
+}
+
 /// Installed memory in bytes (0 when unknown).
 #[cfg(target_os = "macos")]
 pub fn read_meminfo() -> u64 {
@@ -892,6 +940,7 @@ pub fn hardware_json(runtime: &Runtime) -> Value {
     json!({
         "cpu_cores": std::thread::available_parallelism().map(|n| n.get()).unwrap_or(1),
         "ram_bytes": ram,
+        "available_bytes": available_memory(),
         "gpu": gpu.map(|g| g.name.clone()),
         "vram_bytes": gpu.map(|g| g.total_bytes),
         "backend": backend,
@@ -914,6 +963,9 @@ pub struct Budget {
     pub runtime_ready: bool,
     pub gpu_bytes: Option<u64>,
     pub ram_bytes: u64,
+    /// Memory free for a new process now (0 when unknown): installed memory
+    /// says whether a model can ever fit, this whether it fits today.
+    pub available_bytes: u64,
     pub context_cap: u64,
     pub architectures: Option<Arc<HashSet<String>>>,
 }
@@ -924,6 +976,7 @@ impl Budget {
             runtime_ready: runtime.ready(),
             gpu_bytes: runtime.gpu().map(|g| g.total_bytes),
             ram_bytes: read_meminfo(),
+            available_bytes: available_memory(),
             context_cap: config.context_cap(),
             architectures: runtime.probe.as_ref().and_then(|p| p.architectures.clone()),
         }
@@ -1138,6 +1191,14 @@ pub fn inspect(candidate: &Candidate, budget: &Budget) -> Result<GgufEntry> {
         reason = "The llama.cpp runtime is not ready; see Settings › Local models.".into();
         "setup_required"
     } else {
+        // In RAM, or in GPU memory that is the same RAM (Apple silicon).
+        let shared = fits == "cpu" || cfg!(target_os = "macos");
+        if shared && budget.available_bytes > 0 && memory.total_bytes > budget.available_bytes {
+            notes.push(format!(
+                "Only {:.1} GB of memory is free right now; close other apps first or it will run very slowly.",
+                gb(budget.available_bytes)
+            ));
+        }
         reason = format!(
             "{} · {}-token context · ≈{:.1} GB {}",
             architecture.as_deref().unwrap_or("gguf"),
@@ -1889,6 +1950,7 @@ mod tests {
             runtime_ready: true,
             gpu_bytes: Some(16 * GIB),
             ram_bytes: 64 * GIB,
+            available_bytes: 0,
             context_cap: DEFAULT_CONTEXT_CAP,
             architectures: Some(Arc::new(archs.iter().map(|s| s.to_string()).collect())),
         }
@@ -1956,6 +2018,45 @@ mod tests {
         );
     }
 
+    #[test]
+    fn free_memory_is_read_and_never_exceeds_installed() {
+        let available = available_memory();
+        let installed = read_meminfo();
+        eprintln!("available={available} installed={installed}");
+        assert!(available > 0 && available <= installed);
+    }
+
+    #[test]
+    fn a_model_bigger_than_free_memory_says_so() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("small.gguf");
+        model(&path, "qwen3", Some("{% if tools %}<tool_call>{% endif %}"));
+        let config = LocalEngineConfig {
+            files: vec![path.display().to_string()],
+            ..Default::default()
+        };
+        // Plenty installed, but the GPU is too small and almost nothing is free.
+        let mut short = budget(&["qwen3"]);
+        short.gpu_bytes = None;
+        short.available_bytes = 1024 * 1024;
+        let entries = scan_with(&config, &short);
+        assert_eq!(entries[0].availability, "ready");
+        assert!(
+            entries[0].reason.contains("of memory is free right now"),
+            "{}",
+            entries[0].reason
+        );
+        // Unknown (0) or enough free memory: no note.
+        short.available_bytes = 0;
+        assert!(!scan_with(&config, &short)[0]
+            .reason
+            .contains("free right now"));
+        short.available_bytes = 64 * GIB;
+        assert!(!scan_with(&config, &short)[0]
+            .reason
+            .contains("free right now"));
+    }
+
     #[test]
     fn metadata_decides_models_projectors_tools_and_compatibility() {
         let dir = tempfile::tempdir().unwrap();
 
@@ -90,29 +90,86 @@ fn patterns() -> &'static [Regex] {
 }
 
 /// High-entropy token heuristic: long base64/hex-like runs outside common words.
+///
+/// An absolute path under a well-known filesystem root (`/Users/…`,
+/// `/Volumes/…`, `/private/var/folders/…`) is judged one segment at a time:
+/// as a whole it is long and mixes cases, digits and `/` like base64, which
+/// hid the folder of a command on its approval card. A secret that is itself
+/// a path segment is still found; a run that does not start at such a root
+/// (base64 may contain `/`) is judged whole, as before.
 fn high_entropy_tokens(text: &str) -> Vec<(usize, usize)> {
     static ENTROPY: OnceLock<Regex> = OnceLock::new();
     let re = ENTROPY.get_or_init(|| Regex::new(r"[A-Za-z0-9+/_=-]{32,}").expect("entropy regex"));
-    re.find_iter(text)
-        .filter(|m| {
-            let s = m.as_str();
-            if s.chars().all(|c| c.is_ascii_digit()) {
-                return false;
-            }
-            let classes = [
-                s.bytes().any(|b| b.is_ascii_lowercase()),
-                s.bytes().any(|b| b.is_ascii_uppercase()),
-                s.bytes().any(|b| b.is_ascii_digit()),
-                s.bytes()
-                    .any(|b| matches!(b, b'+' | b'/' | b'_' | b'=' | b'-')),
-            ]
-            .into_iter()
-            .filter(|v| *v)
-            .count();
-            classes >= 3 && shannon(s) >= 3.5
-        })
-        .map(|m| (m.start(), m.end()))
-        .collect()
+    let mut spans = Vec::new();
+    for found in re.find_iter(text) {
+        let run = found.as_str();
+        if let Some(segments) = path_segments(run) {
+            spans.extend(segments.filter(|(_, segment)| looks_random(segment)).map(
+                |(offset, segment)| {
+                    let start = found.start() + offset;
+                    (start, start + segment.len())
+                },
+            ));
+        } else if looks_random(run) {
+            spans.push((found.start(), found.end()));
+        }
+    }
+    spans
+}
+
+/// The segments (with their offsets) of an absolute path under a well-known
+/// root, or `None` for anything else.
+fn path_segments(run: &str) -> Option<impl Iterator<Item = (usize, &str)>> {
+    const ROOTS: &[&str] = &[
+        "Users",
+        "Volumes",
+        "Applications",
+        "Library",
+        "System",
+        "private",
+        "home",
+        "root",
+        "tmp",
+        "var",
+        "opt",
+        "usr",
+        "srv",
+        "mnt",
+        "media",
+        "run",
+        "etc",
+        "nix",
+        "proc",
+    ];
+    // `file:///Users/…` leaves `///Users/…` in the run.
+    let rest = run.trim_start_matches('/');
+    let lead = run.len() - rest.len();
+    let first = rest.split('/').next()?;
+    if lead == 0 || !ROOTS.contains(&first) || rest.contains("//") || run.contains(['+', '=']) {
+        return None;
+    }
+    Some(rest.split('/').scan(lead, |offset, segment| {
+        let at = *offset;
+        *offset += segment.len() + 1;
+        Some((at, segment))
+    }))
+}
+
+fn looks_random(s: &str) -> bool {
+    if s.len() < 32 || s.chars().all(|c| c.is_ascii_digit()) {
+        return false;
+    }
+    let classes = [
+        s.bytes().any(|b| b.is_ascii_lowercase()),
+        s.bytes().any(|b| b.is_ascii_uppercase()),
+        s.bytes().any(|b| b.is_ascii_digit()),
+        s.bytes()
+            .any(|b| matches!(b, b'+' | b'/' | b'_' | b'=' | b'-')),
+    ]
+    .into_iter()
+    .filter(|v| *v)
+    .count();
+    classes >= 3 && shannon(s) >= 3.5
 }
 
 fn shannon(s: &str) -> f64 {
@@ -584,4 +641,35 @@ mod tests {
         assert!(!result.redacted);
         assert_eq!(result.text, code);
     }
+
+    #[test]
+    fn paths_are_judged_by_segment_so_folders_stay_visible() {
+        for path in [
+            "/Volumes/NVME1TB/shadowcode-macos/task-demo",
+            "/private/var/folders/qq/twswrb793xqgdr954yy4t1dc0000gn/T/.tmpAb3dEf/project",
+            "/Users/Robert/Projects/ShadowCode2026/native/core/src/redaction.rs",
+            "/home/dev/work/Project-2026_v2/src/main.rs",
+            "file:///private/var/folders/qq/twswrb793xqgdr954yy4t1dc0000gn/T/.tmpX1/team.git",
+        ] {
+            let result = redact_text(&format!("cwd: {path}"));
+            assert!(!result.redacted, "{path} -> {}", result.text);
+        }
+        // A secret that is a whole path segment is still hidden, the rest kept.
+        let secret = "Zx9Kq2Lm7Pw4Rt6Yv8Nb3Hc5Jd1Fg0Se7Ua2Qi";
+        let result = redact_text(&format!("/Users/dev/{secret}/notes.txt"));
+        assert!(
+            result.redacted && !result.text.contains(secret),
+            "{}",
+            result.text
+        );
+        assert!(result.text.starts_with("/Users/dev/"), "{}", result.text);
+        // Base64 that merely contains or starts with '/' is judged whole.
+        for token in [
+            "/9j/4AAQSkZJRgABAQEASABIAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODw0QFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj",
+            "dGhpcyBpcyBub3QgYSByZWFsIHNlY3JldC9idXQvaXQ+bG9va3M9bGlrZQ",
+            "/Users/abc+Zx9Kq2Lm7Pw4Rt6Yv8Nb3Hc5Jd1Fg0Se7Ua2Qi=",
+        ] {
+            assert!(redact_text(token).redacted, "{token}");
+        }
+    }
 }
@@ -979,11 +979,9 @@ async fn a_git_import_clones_updates_and_never_checks_out_links() {
     assert_eq!(fs::read_to_string(&leak).unwrap(), "/etc/passwd");
     let book = f.book();
     assert!(book.guidance(&f.workspace()).contains("Team rule one."));
-    // The address itself may be redacted: on macOS the temporary folder
-    // (/var/folders/<random>/T) reads as a high-entropy token.
     assert!(book
         .guidance(&f.workspace())
-        .contains("imported into their ShadowCode profile from file:"));
+        .contains("imported into their ShadowCode profile from file://"));
     let catalog = book.catalog(&f.workspace());
     assert!(catalog
         .definitions