Pack merging above 16 packs; modern CLI presentation (colour, spinners, --plain, NO_COLOR); oxy prompt with manifest-based dirty check and docs/prompt.md 135212de5370

//! Fast, side-effect-free status for shell prompts.

//!

//! Every snapshot and checkout writes a manifest of the working copy as it

//! was last seen: `size`, `mtime`, and BLAKE3 of each file. `quick_status`

//! walks the working copy and compares against that manifest, reading a

//! file's content only when its size or mtime changed, and records no

//! operation. Ahead/behind counts come from walking the store between the

//! local bookmark and its `origin` tracking state.

use super::*;

use std::time::UNIX_EPOCH;

#[derive(Debug, Clone, Default, PartialEq, Eq)]

pub struct PromptInfo {

    pub bookmark: String,

    /// Working-copy ChangeId prefix.

    pub change_id: String,

    pub heads: usize,

    pub dirty: bool,

    pub conflicted: bool,

    /// Changes local `main` has that `origin/main` lacks, when tracking exists.

    pub ahead: Option<usize>,

    pub behind: Option<usize>,

}

impl PromptInfo {

    /// Expand `%b` bookmark, `%c` change id, `%h` heads, `%d` dirty marker

    /// (`*`), `%x` conflict marker (`!`), `%a`/`%B` ahead/behind counts

    /// (empty when unknown), `%A`/`%D` `+n`/`-n` when non-zero, `%%` percent.

    pub fn format(&self, fmt: &str) -> String {

        let mut out = String::new();

        let mut chars = fmt.chars();

        while let Some(c) = chars.next() {

            if c != '%' {

                out.push(c);

                continue;

            }

            match chars.next() {

                Some('b') => out.push_str(&self.bookmark),

                Some('c') => out.push_str(&self.change_id),

                Some('h') => out.push_str(&self.heads.to_string()),

                Some('d') => {

                    if self.dirty {

                        out.push('*');

                    }

                }

                Some('x') => {

                    if self.conflicted {

                        out.push('!');

                    }

                }

                Some('a') => out.push_str(&self.ahead.map(|n| n.to_string()).unwrap_or_default()),

                Some('B') => out.push_str(&self.behind.map(|n| n.to_string()).unwrap_or_default()),

                Some('A') => {

                    if let Some(n) = self.ahead.filter(|n| *n > 0) {

                        out.push_str(&format!("+{n}"));

                    }

                }

                Some('D') => {

                    if let Some(n) = self.behind.filter(|n| *n > 0) {

                        out.push_str(&format!("-{n}"));

                    }

                }

                Some('%') => out.push('%'),

                Some(other) => {

                    out.push('%');

                    out.push(other);

                }

                None => out.push('%'),

            }

        }

        out

    }

}

/// Path → (size, mtime in nanoseconds, BLAKE3 hex) as last seen.

type Manifest = BTreeMap<String, (u64, u128, String)>;

pub const DEFAULT_PROMPT_FORMAT: &str = "%b %c%d%x%A%D";

/// One manifest line per file: size, mtime in nanoseconds, hash, path.

fn manifest_line(path: &str, size: u64, mtime_ns: u128, hash: &blake3::Hash) -> String {

    format!("{size}\t{mtime_ns}\t{}\t{path}\n", hash.to_hex())

}

impl Repo {

    fn manifest_path(&self) -> PathBuf {

        self.oxy.join("workspaces").join(self.workspace.to_hex()).join("manifest")

    }

    /// Record the working copy as it is now (after a snapshot, commit, or

    /// checkout), with header lines saying whether the base state is

    /// conflicted and whether the working-copy change holds uncommitted work.

    pub(crate) fn write_manifest(&self, conflicted: bool, uncommitted: bool) -> Result<()> {

        let mut text = format!("# conflicted={}\n# uncommitted={}\n", conflicted as u8, uncommitted as u8);

        for (path, e) in self.walk_working_copy()? {

            let full = self.root.join(&path);

            let (size, mtime_ns) = match fs::symlink_metadata(&full) {

                Ok(m) => (m.len(), m.modified().ok().and_then(|t| t.duration_since(UNIX_EPOCH).ok()).map(|d| d.as_nanos()).unwrap_or(0)),

                Err(_) => (e.content.len() as u64, 0),

            };

            text.push_str(&manifest_line(&path, size, mtime_ns, &blake3::hash(&e.content)));

        }

        let p = self.manifest_path();

        fs::create_dir_all(p.parent().unwrap())?;

        write_atomic(&p, text.as_bytes())

    }

    /// Forget the manifest after an operation that changed the working-copy

    /// change without a snapshot (undo, rewrites); the prompt shows blank

    /// markers until the next snapshot.

    pub(crate) fn drop_manifest(&self) {

        let _ = fs::remove_file(self.manifest_path());

    }

    fn read_manifest(&self) -> Result<Option<(bool, bool, Manifest)>> {

        let text = match fs::read_to_string(self.manifest_path()) {

            Ok(t) => t,

            Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(None),

            Err(e) => return Err(e.into()),

        };

        let mut out = BTreeMap::new();

        let mut conflicted = false;

        let mut uncommitted = false;

        for line in text.lines() {

            if let Some(v) = line.strip_prefix("# conflicted=") {

                conflicted = v.trim() == "1";

                continue;

            }

            if let Some(v) = line.strip_prefix("# uncommitted=") {

                uncommitted = v.trim() == "1";

                continue;

            }

            let f: Vec<&str> = line.splitn(4, '\t').collect();

            if f.len() == 4 {

                out.insert(f[3].to_string(), (f[0].parse().unwrap_or(0), f[1].parse().unwrap_or(0), f[2].to_string()));

            }

        }

        Ok(Some((conflicted, uncommitted, out)))

    }

    /// Whether the working copy differs from the last manifest. Without a

    /// manifest the answer is `None`.

    pub fn quick_dirty(&self) -> Result<Option<bool>> {

        let Some((_, uncommitted, manifest)) = self.read_manifest()? else { return Ok(None) };

        if uncommitted {

            return Ok(Some(true));

        }

        let mut seen = 0usize;

        let mut wb = ignore::WalkBuilder::new(&self.root);

        wb.hidden(false).git_ignore(false).git_global(false).git_exclude(false).require_git(false).follow_links(false).add_custom_ignore_filename(".oxyignore");

        wb.filter_entry(|e| e.file_name() != OXY_DIR);

        for entry in wb.build() {

            let Ok(entry) = entry else { continue };

            let Some(ft) = entry.file_type() else { continue };

            if ft.is_dir() {

                continue;

            }

            let rel: String = entry.path().strip_prefix(&self.root).unwrap().components().map(|c| c.as_os_str().to_string_lossy().to_string()).collect::<Vec<_>>().join("/");

            let Some((size, mtime_ns, hash)) = manifest.get(&rel) else { return Ok(Some(true)) };

            seen += 1;

            let m = fs::symlink_metadata(entry.path())?;

            let now_mtime = m.modified().ok().and_then(|t| t.duration_since(UNIX_EPOCH).ok()).map(|d| d.as_nanos()).unwrap_or(0);

            if ft.is_symlink() {

                let target = fs::read_link(entry.path())?;

                if blake3::hash(target.to_string_lossy().as_bytes()).to_hex().as_str() != hash {

                    return Ok(Some(true));

                }

                continue;

            }

            if m.len() != *size {

                return Ok(Some(true));

            }

            if now_mtime != *mtime_ns && blake3::hash(&fs::read(entry.path())?).to_hex().as_str() != hash {

                return Ok(Some(true));

            }

        }

        Ok(Some(seen != manifest.len()))

    }

    /// Prompt information without recording anything.

    pub fn quick_status(&self) -> Result<PromptInfo> {

        let view = self.view()?;

        let bookmark = self.config.bookmark.clone();

        let heads = self.heads_of(&view, &bookmark)?;

        let wc_hash = view.workspaces.get(&self.workspace).copied();

        let change_id = match wc_hash {

            Some(h) => self.store.get_change(&h)?.change_id.short(8),

            None => String::new(),

        };

        // Conflictedness was recorded by the last snapshot; without a

        // manifest (never snapshotted) both flags are unknown and shown clear.

        let manifest = self.read_manifest()?;

        let conflicted = manifest.as_ref().map(|(c, _, _)| *c).unwrap_or(false);

        let dirty = self.quick_dirty()?.unwrap_or(false);

        let (ahead, behind) = match view.remotes.get("origin").and_then(|b| b.get(&bookmark)) {

            Some(st) => {

                let remote_heads = self.store.get_state(st)?.heads;

                let ahead = self.negotiate(&remote_heads, &heads).map(|v| v.len()).ok();

                let behind = self.negotiate(&heads, &remote_heads).map(|v| v.len()).ok();

                (ahead, behind)

            }

            None => (None, None),

        };

        Ok(PromptInfo { bookmark, change_id, heads: heads.len(), dirty, conflicted, ahead, behind })

    }

}

# Shell prompt integration

`oxy prompt` prints one line about the current repository in a few

milliseconds and records nothing. Outside an Oxygen repository it prints

nothing and exits 1, so it is safe to call from any prompt.

```

$ oxy prompt

main 658990aa*+2

```

That is bookmark, working-copy change id, `*` when the working copy has

uncommitted changes, `!` when the state has conflicts, and `+n`/`-n` for

changes ahead of and behind `origin`. The default format is `%b %c%d%x%A%D`;

`--format` takes any string with these placeholders:

| Placeholder | Meaning |

|---|---|

| `%b` | bookmark |

| `%c` | working-copy ChangeId prefix |

| `%h` | number of heads |

| `%d` | `*` when dirty |

| `%x` | `!` when the base state has conflicts |

| `%A` / `%D` | `+n` ahead / `-n` behind origin, empty when zero or unknown |

| `%a` / `%B` | raw ahead / behind counts |

| `%%` | a percent sign |

Dirtiness is decided from a manifest written at every snapshot and checkout:

files are compared by size and modification time first and by content hash

only when those differ, so the cost is one directory walk.

## bash and oh-my-bash

Add to `~/.bashrc` (or to a custom oh-my-bash theme in

`~/.oh-my-bash/custom/themes/<name>/<name>.theme.sh`):

```bash

# Oxygen repository info for the prompt; silent outside a repository.

oxy_prompt_info() {

  local info

  info=$(oxy prompt --format '%b %c%d%x%A%D' 2>/dev/null) || return

  local color='\[\e[36m\]' reset='\[\e[0m\]' warn='\[\e[33m\]'

  case "$info" in

    *'*'*|*'!'*) printf ' %b(%s)%b' "$warn" "$info" "$reset" ;;

    *)           printf ' %b(%s)%b' "$color" "$info" "$reset" ;;

  esac

}

```

Then reference it from `PS1`, next to your Git info:

```bash

PS1='\u@\h \w$(git_prompt_info 2>/dev/null)$(oxy_prompt_info)\$ '

```

With oh-my-bash, most themes build the prompt in a function such as

`_omb_theme_PROMPT_COMMAND`; append `$(oxy_prompt_info)` to the `PS1`

assignment there, or copy the theme into `custom/themes` and edit that copy

so updates do not overwrite it.

## zsh

```zsh

oxy_prompt_info() {

  local info

  info=$(oxy prompt 2>/dev/null) || return

  print -n " %F{cyan}($info)%f"

}

setopt PROMPT_SUBST

PROMPT='%n@%m %~$(oxy_prompt_info) %# '

```

## Notes

- The dirty and conflict markers come from the manifest written by the last

  `oxy status`, commit, or checkout; in a repository that has never been

  snapshotted they are blank until the first `oxy status`.

- The counts against `origin` use the tracking state from the last

  `oxy fetch`, `pull`, or `push`; the prompt never contacts the network.

- `oxy prompt` uses plain text by default so shells can colour it; colour is

  added in the shell function, not by oxy.

//! Terminal presentation: colour, emphasis, and a live spinner while a

//! command works. Everything degrades to plain text when stdout is not a

//! terminal, when `NO_COLOR` is set, or with `--plain`.

use console::{style, StyledObject, Term};

use indicatif::{ProgressBar, ProgressStyle};

use std::sync::atomic::{AtomicBool, Ordering};

use std::time::Duration;

static PLAIN: AtomicBool = AtomicBool::new(false);

static INIT: std::sync::Once = std::sync::Once::new();

/// Decide once whether to use colour and animation.

pub fn init(plain_flag: bool) {

    INIT.call_once(|| {

        let no_color = std::env::var_os("NO_COLOR").is_some();

        let tty = Term::stdout().features().is_attended();

        let plain = plain_flag || no_color || !tty;

        PLAIN.store(plain, Ordering::Relaxed);

        console::set_colors_enabled(!plain);

    });

}

pub fn plain() -> bool {

    PLAIN.load(Ordering::Relaxed)

}

fn s<T: std::fmt::Display>(v: T) -> StyledObject<T> {

    style(v)

}

/// A ChangeId prefix.

pub fn id<T: std::fmt::Display>(v: T) -> String {

    s(v).cyan().bold().to_string()

}

/// A hash prefix.

pub fn hash<T: std::fmt::Display>(v: T) -> String {

    s(v).dim().to_string()

}

pub fn path<T: std::fmt::Display>(v: T) -> String {

    s(v).bold().to_string()

}

pub fn ok<T: std::fmt::Display>(v: T) -> String {

    s(v).green().to_string()

}

pub fn warn<T: std::fmt::Display>(v: T) -> String {

    s(v).yellow().to_string()

}

pub fn err<T: std::fmt::Display>(v: T) -> String {

    s(v).red().bold().to_string()

}

pub fn dim<T: std::fmt::Display>(v: T) -> String {

    s(v).dim().to_string()

}

pub fn heading<T: std::fmt::Display>(v: T) -> String {

    s(v).bold().underlined().to_string()

}

/// A status tag: green for additions, yellow for modifications, red for removals and conflicts.

pub fn tag(t: &str) -> String {

    match t {

        "A" => s(t).green().bold().to_string(),

        "M" | "X" => s(t).yellow().bold().to_string(),

        "D" | "C!" => s(t).red().bold().to_string(),

        "R" => s(t).cyan().bold().to_string(),

        other => other.to_string(),

    }

}

/// A live spinner with a message, shown only on a terminal. Drop or call

/// `done` to clear it; `done` prints the final line in its place.

pub struct Spinner {

    bar: Option<ProgressBar>,

}

pub fn spinner(msg: &str) -> Spinner {

    if plain() {

        return Spinner { bar: None };

    }

    let bar = ProgressBar::new_spinner();

    bar.set_style(ProgressStyle::with_template("{spinner:.cyan} {msg}").unwrap().tick_strings(&["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏", "✔"]));

    bar.set_message(msg.to_string());

    bar.enable_steady_tick(Duration::from_millis(80));

    Spinner { bar: Some(bar) }

}

impl Spinner {

    /// Replace the spinner with a final line (or print it plainly).

    pub fn done(self, msg: &str) {

        match &self.bar {

            Some(b) => b.finish_with_message(msg.to_string()),

            None => println!("{msg}"),

        }

    }

    /// Clear the spinner without printing.

    pub fn clear(self) {

        if let Some(b) = &self.bar {

            b.finish_and_clear();

        }

    }

}

name = "bumpalo"

version = "3.20.3"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"

[[package]]

name = "console"

version = "0.15.11"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"

dependencies = [

 "encode_unicode",

 "libc",

 "once_cell",

 "unicode-width",

 "windows-sys 0.59.0",

]

[[package]]

name = "encode_unicode"

version = "1.0.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"

[[package]]

name = "indicatif"

version = "0.17.11"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "183b3088984b400f4cfac3620d5e076c84da5364016b4f49473de574b2586235"

dependencies = [

 "console",

 "number_prefix",

 "portable-atomic",

 "unicode-width",

 "web-time",

]

[[package]]

name = "js-sys"

version = "0.3.106"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "7883d941dae510fb2d978fc3fe018c71c9e2892fd38854de3e8b92c2e5ad9cc5"

dependencies = [

 "cfg-if",

 "futures-util",

 "wasm-bindgen",

]

[[package]]

name = "number_prefix"

version = "0.4.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"

[[package]]

 "console",

 "indicatif",

name = "portable-atomic"

version = "1.15.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"

[[package]]

name = "unicode-width"

version = "0.2.2"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"

[[package]]

name = "wasm-bindgen"

version = "0.2.129"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "9bb54f33acc68fd454578d9820b0bde1a1a3d17aa17bb7b6595806d02886d409"

dependencies = [

 "cfg-if",

 "once_cell",

 "rustversion",

 "wasm-bindgen-macro",

 "wasm-bindgen-shared",

]

[[package]]

name = "wasm-bindgen-macro"

version = "0.2.129"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "2e29d0c35b16e224a7eeb5cd2d25e3e1968fbd65604117b44d3b789d00ee8535"

dependencies = [

 "quote",

 "wasm-bindgen-macro-support",

]

[[package]]

name = "wasm-bindgen-macro-support"

version = "0.2.129"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "6f501a8bc3719dba86ef8ae4728879c08001bea749eb1333ac5b91e040e2a6b7"

dependencies = [

 "bumpalo",

 "proc-macro2",

 "quote",

 "syn 3.0.6",

 "wasm-bindgen-shared",

]

[[package]]

name = "wasm-bindgen-shared"

version = "0.2.129"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "23f0c9c52aa7cd7d77769a4cfe2a9adb1b331f489a41d912ce14513d5ab995c6"

dependencies = [

 "unicode-ident",

]

[[package]]

name = "web-time"

version = "1.1.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"

dependencies = [

 "js-sys",

 "wasm-bindgen",

]

[[package]]

version = "0.59.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"

dependencies = [

 "windows-targets",

]

[[package]]

name = "windows-sys"

console = "0.15"

indicatif = "0.17"

        self.write_manifest(report.conflicted, false)?;

    /// Packs folded into one because there were more than `MAX_PACKS`.

    pub merged_packs: usize,

        let merged_packs = self.store.merge_packs()?;

        Ok(GcReport { packed, pruned, reachable: keep.len(), merged_packs })

        self.drop_manifest();

        self.drop_manifest();

mod prompt;

pub use prompt::{PromptInfo, DEFAULT_PROMPT_FORMAT};

            self.store.merge_packs()?;

        self.drop_manifest();

        // The prompt compares against this without recording anything.

        self.write_manifest(base_snapshot.is_conflicted(), !wc.tree_ops.is_empty() || !wc.edits.is_empty())?;

        self.write_manifest(snap.base_snapshot.is_conflicted() && !snap.resolves, false)?;

#[test]

fn quick_status_for_prompts() {

    hermetic();

    let dir = tempfile::tempdir().unwrap();

    let root = dir.path();

    let origin = Repo::init(&root.join("origin")).unwrap();

    let url = root.join("origin").to_string_lossy().to_string();

    let a = Repo::clone(&url, &root.join("a")).unwrap().with_home(root.join("home"));

    let ops_before = a.op_log().unwrap().len();

    let info = a.quick_status().unwrap();

    assert_eq!((info.bookmark.as_str(), info.heads, info.dirty, info.conflicted, info.ahead, info.behind), ("main", 0, false, false, Some(0), Some(0)));

    write(&root.join("a"), "f.txt", b"f\n");

    assert!(a.quick_status().unwrap().dirty, "a new file is dirty");

    assert_eq!(a.op_log().unwrap().len(), ops_before, "quick_status records nothing");

    // A snapshotted but uncommitted change is still dirty.

    a.snapshot("status").unwrap();

    assert!(a.quick_status().unwrap().dirty);

    a.commit("f", &[]).unwrap();

    let info = a.quick_status().unwrap();

    assert!(!info.dirty, "clean right after a commit");

    assert_eq!((info.ahead, info.behind), (Some(1), Some(0)));

    assert_eq!(info.format("%b %c%d%x%A%D"), format!("main {}+1", info.change_id));

    assert_eq!(info.format("[%h heads] %a/%B %%"), "[1 heads] 1/0 %");

    // Touching a file without changing it is not dirty; changing content of

    // the same size is.

    let p = root.join("a/f.txt");

    let content = fs::read(&p).unwrap();

    fs::write(&p, &content).unwrap();

    assert!(!a.quick_status().unwrap().dirty);

    fs::write(&p, b"g\n").unwrap();

    assert!(a.quick_status().unwrap().dirty);

    fs::write(&p, b"f\n").unwrap();

    // Push, then a second clone commits and pushes: we are behind.

    assert!(a.push("origin", false).unwrap()[0].ok);

    assert_eq!(a.quick_status().unwrap().ahead, Some(0));

    let b = Repo::clone(&url, &root.join("b")).unwrap().with_home(root.join("home-b"));

    write(&root.join("b"), "g.txt", b"g\n");

    b.commit("g", &[]).unwrap();

    b.push("origin", false).unwrap();

    a.fetch("origin").unwrap();

    let info = a.quick_status().unwrap();

    assert_eq!((info.ahead, info.behind), (Some(0), Some(1)));

    assert_eq!(info.format("%A%D"), "-1");

    let _ = origin;

}

/// Packs tolerated before `merge_packs` folds them into one (spec §13.4).

pub const MAX_PACKS: usize = 16;

    /// Fold every pack into one when there are more than `MAX_PACKS`

    /// (spec §13.4). Returns how many packs were merged.

    pub fn merge_packs(&self) -> Result<usize> {

        let (refs, paths): (Vec<ObjectRef>, Vec<PathBuf>) = {

            let packs = self.packs.borrow();

            if packs.len() <= MAX_PACKS {

                return Ok(0);

            }

            (packs.iter().flat_map(|p| p.refs.iter().copied()).collect(), packs.iter().map(|p| p.path.clone()).collect())

        };

        let n = paths.len();

        self.write_pack(&refs, &[], &paths)?;

        Ok(n)

    }

    fn many_packs_merge_into_one() {

        let dir = tempfile::tempdir().unwrap();

        let s = Store::open(dir.path()).unwrap();

        let mut refs = Vec::new();

        for i in 0..(MAX_PACKS + 2) {

            refs.push(s.put(ObjectType::Chunk, format!("pack {i}").as_bytes()).unwrap());

            s.pack_loose().unwrap();

        }

        assert_eq!(s.pack_count(), MAX_PACKS + 2);

        assert_eq!(s.merge_packs().unwrap(), MAX_PACKS + 2);

        assert_eq!(s.pack_count(), 1);

        assert_eq!(s.merge_packs().unwrap(), 0);

        for (i, r) in refs.iter().enumerate() {

            assert_eq!(s.get(r).unwrap().1, format!("pack {i}").as_bytes());

        }

        assert_eq!(Store::open(dir.path()).unwrap().pack_count(), 1);

    }

    #[test]

- [ ] Modern CLI presentation (user request, 2026-09-26 23:20): colour and bold for ids, paths, and statuses; a live spinner or updating status line while a command works (snapshot, fetch, push, import, gc); indented, grouped output like Claude Code's. Use `console`/`indicatif` or equivalent; detect a TTY and honour `NO_COLOR` and `--no-color`/`--plain` so pipes and scripts get plain text; keep `--json` where it exists. Touch every command's output for consistency.

- [ ] Shell prompt integration (user request, 2026-09-26 23:30): `oxy prompt` prints a compact one-line summary for shell prompts in a few milliseconds and with no side effects (no snapshot operation recorded, no locks): bookmark, working-copy ChangeId prefix, head count, a dirty marker (compare the file system against the working copy cheaply: sizes and mtimes first, content only when they differ), conflict marker, and ahead/behind counts against `remotes/origin/<bookmark>` when known. Provide `docs/prompt.md` with an oh-my-bash/bash snippet (`oxy_prompt_info` function, silent outside an oxy repository, colours via `--plain` off) and a zsh variant. Format flags: `--format` with placeholders, `--plain`.

- [ ] (Pending) The user's second request in the same message was cut off after "Can we also look at"; ask them to complete it in the morning.

use super::ui;

        let styled = if line.starts_with("INVALID") {

            ui::err(&line)

        } else if line == "unsigned" {

            ui::dim(&line)

        } else {

            ui::ok(&line)

        };

        println!("{} {}  {styled}", ui::id(short_id(&c)), ui::hash(format!("#{}", h.short(12))));

pub mod ui;

    /// Plain output: no colour, no spinner (also implied by NO_COLOR or a non-terminal)

    #[arg(long, global = true)]

    plain: bool,

    /// One-line summary for shell prompts; fast and records nothing

    Prompt {

        /// Placeholders: %b bookmark, %c change id, %h heads, %d dirty (*), %x conflict (!), %A/%D ahead/behind (+n/-n), %a/%B raw counts

        #[arg(long, default_value = oxy_core::repo::DEFAULT_PROMPT_FORMAT)]

        format: String,

    },

    ui::init(cli.plain);

        Cmd::Prompt { format } => workspace::prompt(&format),

use super::ui;

    let sp = ui::spinner(&format!("Cloning {url}…"));

    sp.done(&format!("{} into {} ({} on {}: {})", ui::ok("Cloned"), ui::path(repo.root().display()), url, ui::id(&repo.config.bookmark), plural(heads.len(), "head")));

    let sp = ui::spinner(&format!("Fetching from {remote}…"));

    sp.clear();

        println!("{} {}, {}", ui::id(format!("{remote}/{name}")), plural(heads.len(), "head"), plural(*n, "new change"));

        eprintln!("{} {remote} has no trust policy; nothing fetched from it was verified", ui::warn("warning:"));

    let sp = ui::spinner(&format!("Pulling from {remote}…"));

        sp.done(&ui::dim("Already up to date."));

    sp.done(&format!(

        "{} {} now has {}{}",

        ui::ok("Pulled:"),

        ui::id(&repo.config.bookmark),

    ));

        println!("  {}", ui::warn("the result has conflicts; see oxy status"));

    let sp = ui::spinner(&format!("Pushing to {remote}…"));

    let results = repo.push(&remote, force)?;

    sp.clear();

    for r in results {

            println!("{} {}", ui::id(format!("{remote}/{}", r.name)), ui::ok(if r.reason.is_empty() { "updated" } else { r.reason.as_str() }));

            println!("{} {} {}", ui::id(format!("{remote}/{}", r.name)), ui::err("rejected:"), r.reason);

    let sp = ui::spinner("Exporting to Git…");

    sp.clear();

    let sp = ui::spinner(&format!("Importing {} {branch}…", git_dir.display()));

    sp.clear();

use super::ui;

    println!("{} oxy repository in {}", ui::ok("Initialized"), ui::path(repo.root().display()));

    println!("  bookmark {}   author {} <{}>", ui::id(&repo.config.bookmark), repo.config.author_name, repo.config.author_email);

    let sp = ui::spinner("Snapshotting the working copy…");

    sp.clear();

    println!(

        "{} {} on {} {}",

        ui::heading("Working copy"),

        ui::id(snap.wc.change_id.short(8)),

        ui::id(&repo.config.bookmark),

        ui::dim(format!("({})", plural(heads.len(), "head")))

    );

        println!("  {}", ui::dim("clean"));

        println!("  {:2} {}", ui::tag(status_tag(s.status)), ui::path(&s.path));

    println!();

    println!("{} {}", ui::err("Conflicts"), ui::dim("edit the marked files, or the .oxy-conflict-N candidates, then commit"));

                Some(ChangeStatus::Resolved) => ui::ok("resolved in working copy"),

                Some(ChangeStatus::ConflictEdited) => ui::warn("markers remain"),

                _ => ui::err("unresolved"),

            println!("  {}  {state}", ui::path(p));

    let sp = ui::spinner("Committing…");

    sp.done(&format!("{} {} {} {}", ui::ok("Committed"), ui::id(short_id(&c)), ui::hash(format!("#{}", h.short(12))), message.lines().next().unwrap_or("")));

        let flags = if flags.is_empty() { String::new() } else { ui::warn(format!(" ({})", flags.join(", "))) };

        println!("{} {}{}", ui::id(short_id(c)), ui::hash(format!("#{}", e.hash.short(12))), flags);

        println!("    {}", ui::dim(when(c.hlc.wall_ms)));

            println!("    {}", ui::dim(format!("deps: {}", deps_line(c))));

    println!("{} {} {}", ui::heading("change"), ui::id(short_id(&c)), ui::hash(format!("#{h}")));

    println!("  kind  {:?}", c.kind);

    println!("  date  {}", when(c.hlc.wall_ms));

    println!("  deps  {}", ui::dim(deps_line(&c)));

    println!("  sig   {}", signature_line(&repo, &h)?);

    let sp = ui::spinner(&format!("Checking out {spec}…"));

    sp.done(&format!("{} on {}: {} written, {} removed", ui::ok("Working copy"), ui::id(&spec), plural(r.written, "file"), r.removed));

        println!("  {}", ui::warn("this state has conflicts; see oxy status"));

    println!("{} now at: {}", ui::ok("Undone;"), ui::dim(&op.command));

        println!("{}{} {}  {}", if i == 0 { ui::ok("@ ") } else { "  ".into() }, ui::hash(r.short(12)), ui::dim(when(op.hlc.wall_ms)), op.command);

    let sp = ui::spinner("Packing and pruning…");

    sp.clear();

    println!("{} reachable; pruned {} ({} bytes){}{}; {} present.",

        if r.merged_packs > 0 { format!("; merged {} into one", plural(r.merged_packs, "pack")) } else { String::new() },

    println!("{} {} {} {}", ui::ok("Described"), ui::id(short_id(&c)), ui::hash(format!("#{}", new.short(12))), message.lines().next().unwrap_or(""));

    println!("{} {} {} {}", ui::ok("Amended"), ui::id(short_id(&c)), ui::hash(format!("#{}", new.short(12))), c.message.lines().next().unwrap_or(""));

    let sp = ui::spinner("Writing checkpoint…");

    sp.done(&format!("{} {} of {} ({} bytes) for {}", ui::ok("Checkpoint"), ui::hash(format!("#{}", r.short(12))), plural(changes, "change"), bytes, ui::id(&repo.config.bookmark)));

    Ok(0)

}

/// For shell prompts: silent (exit 1) outside a repository, otherwise one line.

pub fn prompt(format: &str) -> Result<i32> {

    let Ok(repo) = Repo::open(&std::env::current_dir()?) else { return Ok(1) };

    let info = repo.quick_status()?;

    println!("{}", info.format(format));

            cli::ui::init(false);

            eprintln!("{} {e:#}", cli::ui::err("error:"));