fix(ci): run the container as the invoking user, not root

Docker on the dev boxes is rootful, so without `--user` every byte the build
writes into the bind-mounted repo is owned by root and the user needs `sudo` to
delete their own artifacts. This is not hypothetical: `export/` in a working
tree held 227 root-owned paths (149 MB) from earlier runs, and the `sylpheed.db`
regen in the workspace CLAUDE.md writes straight into /work, so it lands
root-owned every time.

The catch is that the daemon creates a named volume root-owned, so a `--user`
container cannot write /cargo or /target at all. So take ownership of both
volumes first -- once, and only when it is actually wrong, since a recursive
chown across a ~36 GB target volume is not something to repeat per invocation.
Both are sampled, not just one, because an older run can leave them drifted.

Volume names become overridable (SYLPH_CI_CARGO_VOL / SYLPH_CI_TARGET_VOL),
which is what let the chown path be tested without touching the real caches.

Placed above the corpus-mount block so it does not collide with #53.

Measured, not assumed:
  * fresh root-owned volumes  -> chowns once, then writes as uid 1000
  * second run                -> no chown, correctly cached
  * `cargo check -p sylpheed-ppc` through the runner -> passes, exit 0
  * a file touched in /work   -> owned fabi:fabi, removable without sudo

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

crates/sylpheed-export/examples/bank_chunks.rs

@@ -7,8 +7,7 @@ use std::process::Command;
 use sylpheed_formats::media;
 
 fn main() {
-    let disc =
-        std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC to the extracted disc root");
+    let disc = std::env::var("SYLPHEED_DISC").unwrap_or_else(|_| "/disc".into());
     let src = media::DirectorySource::new(&disc);
     for bank in ["BGM_103.slb", "BGM_102.slb", "BGM_001.slb"] {
         match media::sound_bank_riffs(&src, bank) {

crates/sylpheed-export/examples/bgm_size_census.rs

@@ -18,8 +18,7 @@
 use sylpheed_formats::media;
 
 fn main() {
-    let root =
-        std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC to the extracted disc root");
+    let root = std::env::var("SYLPHEED_DISC").unwrap_or_else(|_| "/disc".into());
     let src = media::DirectorySource::new(&root);
     const WANT: [usize; 2] = [3_876_864, 3_930_112];
     let (mut found, mut matches) = (0usize, Vec::new());

crates/sylpheed-export/examples/dialog_pairs.rs

@@ -20,8 +20,7 @@ use std::collections::BTreeSet;
 use sylpheed_formats::{pak, ratc, ui_layout};
 
 fn main() {
-    let root =
-        std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC to the extracted disc root");
+    let root = std::env::var("SYLPHEED_DISC").unwrap_or_else(|_| "/disc".into());
     let ar = pak::PakArchive::open(format!("{root}/dat/GP_DIALOG.pak")).expect("GP_DIALOG.pak");
     let sets: Vec<Option<BTreeSet<String>>> = ar
         .entries()

crates/sylpheed-export/examples/dialog_rows.rs

@@ -17,8 +17,7 @@
 use sylpheed_formats::{pak, ratc, ui_layout};
 
 fn main() {
-    let root =
-        std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC to the extracted disc root");
+    let root = std::env::var("SYLPHEED_DISC").unwrap_or_else(|_| "/disc".into());
     // 🔴 WIDENED 2026-08-31 to every pak, to check the Decoder's rival search
     // independently. They report zero four-button builds within 6 px of
     // 259/329/399/469 anywhere on the disc, which turns "another dialog with

crates/sylpheed-export/examples/rat_leaf.rs

@@ -8,8 +8,7 @@
 use sylpheed_formats::{pak::PakArchive, ui_layout};
 
 fn main() {
-    let disc =
-        std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC to the extracted disc root");
+    let disc = std::env::var("SYLPHEED_DISC").unwrap_or_else(|_| "/disc".into());
     let ar = PakArchive::open(format!("{disc}/dat/GP_TITLE.pak")).expect("open");
     let e = &ar.entries()[4]; // entry 4 = the English title
     let bundle = ar.read(e).expect("read");

crates/sylpheed-export/examples/record_loop_control.rs

@@ -48,8 +48,7 @@ fn main() {
         .unwrap_or(8);
     unsafe { OFFSET = off };
     println!("  reading the loop length at header +0x{off:02x}");
-    let root =
-        std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC to the extracted disc root");
+    let root = std::env::var("SYLPHEED_DISC").unwrap_or_else(|_| "/disc".into());
     let mut paks: Vec<_> = std::fs::read_dir(format!("{root}/dat"))
         .expect("dat/")
         .flatten()

crates/sylpheed-export/examples/record_population.rs

@@ -11,8 +11,7 @@
 use sylpheed_formats::{pak, ratc, ui_layout};
 
 fn main() {
-    let root =
-        std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC to the extracted disc root");
+    let root = std::env::var("SYLPHEED_DISC").unwrap_or_else(|_| "/disc".into());
     let mut paks: Vec<_> = std::fs::read_dir(format!("{root}/dat"))
         .expect("dat/")
         .flatten()

crates/sylpheed-export/examples/static_with_cycle.rs

@@ -11,8 +11,7 @@
 use sylpheed_formats::{pak, ratc, ui_layout};
 
 fn main() {
-    let root =
-        std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC to the extracted disc root");
+    let root = std::env::var("SYLPHEED_DISC").unwrap_or_else(|_| "/disc".into());
     let ar = pak::PakArchive::open(format!("{root}/dat/GP_TITLE.pak")).expect("GP_TITLE.pak");
     let (mut total, mut hits, mut multipose) = (0usize, 0usize, 0usize);
     for (i, e) in ar.entries().iter().enumerate() {

crates/sylpheed-export/examples/voice_chunks.rs

@@ -7,8 +7,7 @@ use std::process::Command;
 use sylpheed_formats::{media, slb::VoiceLang};
 
 fn main() {
-    let disc =
-        std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC to the extracted disc root");
+    let disc = std::env::var("SYLPHEED_DISC").unwrap_or_else(|_| "/disc".into());
     let src = media::DirectorySource::new(&disc);
     for movie in ["ADV", "S00A", "RT01A"] {
         let Some((s, e)) = media::resolve_movie_voice_region(&src, movie, VoiceLang::English)

crates/sylpheed-formats/examples/_pbafc.rs

@@ -1,7 +1,6 @@
 use sylpheed_formats::{pak, ratc, ui_layout};
 fn main() {
-    let root =
-        std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC to the extracted disc root");
+    let root = std::env::var("SYLPHEED_DISC").unwrap_or_else(|_| "/disc".into());
     let ar = pak::PakArchive::open(format!("{root}/dat/GP_READY_ROOM.pak")).unwrap();
     for (i, e) in ar.entries().iter().enumerate() {
         let Ok(by) = ar.read(e) else { continue };

crates/sylpheed-formats/examples/correlate_capture.rs

@@ -16,7 +16,8 @@
 //! Usage:
 //!   SYLPHEED_ISO=... cargo run --release --example correlate_capture -- \
 //!       <capture.log> <Stage_SNN> <ship_id> [ref_part_substr] [--emit]
-//! e.g. SYLPHEED_ISO="/path/to/Project Sylpheed - Arc of Deception (USA, Europe) (En,Ja).iso" \
+//! e.g. SYLPHEED_ISO="/home/fabi/RE - Project Sylpheed/Project Sylpheed - Arc of
+//!      Deception (USA, Europe) (En,Ja).iso" \
 //!      cargo run --release --example correlate_capture -- \
 //!      xenia_ship_capture.log Stage_S01 e106 bdy_04 --emit
 

crates/sylpheed-formats/examples/focus_alpha_census.rs

@@ -11,8 +11,7 @@
 use sylpheed_formats::{pak, ratc, ui_layout};
 
 fn main() {
-    let root =
-        std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC to the extracted disc root");
+    let root = std::env::var("SYLPHEED_DISC").unwrap_or_else(|_| "/disc".into());
     let mut paks: Vec<_> = std::fs::read_dir(format!("{root}/dat"))
         .expect("dat/")
         .flatten()

crates/sylpheed-formats/examples/prm_alpha_census.rs

@@ -15,8 +15,7 @@ use std::collections::BTreeMap;
 use sylpheed_formats::{pak, ratc, ui_layout};
 
 fn main() {
-    let root =
-        std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC to the extracted disc root");
+    let root = std::env::var("SYLPHEED_DISC").unwrap_or_else(|_| "/disc".into());
     let mut paks: Vec<_> = std::fs::read_dir(format!("{root}/dat"))
         .expect("dat/")
         .flatten()

crates/sylpheed-formats/examples/prm_colour_census.rs

@@ -6,8 +6,7 @@
 use std::collections::BTreeMap;
 use sylpheed_formats::{pak, ratc, ui_layout};
 fn main() {
-    let root =
-        std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC to the extracted disc root");
+    let root = std::env::var("SYLPHEED_DISC").unwrap_or_else(|_| "/disc".into());
     let mut paks: Vec<_> = std::fs::read_dir(format!("{root}/dat"))
         .expect("dat/")
         .flatten()

crates/sylpheed-formats/examples/prm_forced_first.rs

@@ -14,8 +14,7 @@
 use sylpheed_formats::{pak, ratc, ui_layout};
 
 fn main() {
-    let root =
-        std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC to the extracted disc root");
+    let root = std::env::var("SYLPHEED_DISC").unwrap_or_else(|_| "/disc".into());
     let mut paks: Vec<_> = std::fs::read_dir(format!("{root}/dat"))
         .expect("dat/")
         .flatten()

crates/sylpheed-formats/examples/prm_occlusion_check.rs

@@ -33,8 +33,7 @@ fn opaque_span(el: &ui_layout::Element, thr: u32, tmax: u32) -> Vec<(f64, f64)>
 }
 
 fn main() {
-    let root =
-        std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC to the extracted disc root");
+    let root = std::env::var("SYLPHEED_DISC").unwrap_or_else(|_| "/disc".into());
     let mut paks: Vec<_> = std::fs::read_dir(format!("{root}/dat"))
         .expect("dat/")
         .flatten()

crates/sylpheed-formats/examples/prm_span_sensitivity.rs

@@ -58,8 +58,7 @@ fn forced(b: &ui_layout::UiBuild, el: &ui_layout::Element, tmax: u32, hold: bool
 }
 
 fn main() {
-    let root =
-        std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC to the extracted disc root");
+    let root = std::env::var("SYLPHEED_DISC").unwrap_or_else(|_| "/disc".into());
     let mut paks: Vec<_> = std::fs::read_dir(format!("{root}/dat"))
         .expect("dat/")
         .flatten()

crates/sylpheed-formats/examples/record_loop_length.rs

@@ -20,8 +20,7 @@ use std::collections::BTreeMap;
 use sylpheed_formats::{pak, ratc, ui_layout};
 
 fn main() {
-    let root =
-        std::env::var("SYLPHEED_DISC").expect("set SYLPHEED_DISC to the extracted disc root");
+    let root = std::env::var("SYLPHEED_DISC").unwrap_or_else(|_| "/disc".into());
     let mut paks: Vec<_> = std::fs::read_dir(format!("{root}/dat"))
         .expect("dat/")
         .flatten()

crates/sylpheed-formats/tests/ui_forced_backdrop_disc.rs

@@ -16,8 +16,10 @@ use std::path::PathBuf;
 
 use sylpheed_formats::{pak::PakArchive, ratc, ui_layout};
 
-mod common;
-use common::disc_root;
+fn disc_root() -> Option<PathBuf> {
+    let p = PathBuf::from(std::env::var("SYLPHEED_DISC").ok()?);
+    p.join("dat").is_dir().then_some(p)
+}
 
 fn build(ar: &PakArchive, i: usize) -> (Vec<u8>, ui_layout::UiBuild) {
     let by = ar.read(&ar.entries()[i]).expect("entry");

crates/sylpheed-formats/tests/ui_keyframe_record_disc.rs

@@ -26,8 +26,21 @@ use std::path::{Path, PathBuf};
 
 use sylpheed_formats::{pak::PakArchive, ratc, ui_layout};
 
-mod common;
-use common::disc_root;
+fn disc_root() -> Option<PathBuf> {
+    if let Ok(p) = std::env::var("SYLPHEED_DISC") {
+        let p = PathBuf::from(p);
+        if p.join("dat").is_dir() {
+            return Some(p);
+        }
+    }
+    let default = Path::new(
+        "/home/fabi/RE - Project Sylpheed/Project Sylpheed - Arc of Deception (USA, Europe) (En,Ja)",
+    );
+    if default.join("dat").is_dir() {
+        return Some(default.to_path_buf());
+    }
+    None
+}
 
 fn for_each_build(root: &Path, mut f: impl FnMut(&str, &[u8])) {
     let mut paks: Vec<PathBuf> = std::fs::read_dir(root.join("dat"))

crates/sylpheed-formats/tests/ui_record_loop_length_disc.rs

@@ -22,8 +22,10 @@ use std::path::PathBuf;
 
 use sylpheed_formats::{pak::PakArchive, ratc, ui_layout};
 
-mod common;
-use common::disc_root;
+fn disc_root() -> Option<PathBuf> {
+    let p = PathBuf::from(std::env::var("SYLPHEED_DISC").ok()?);
+    p.join("dat").is_dir().then_some(p)
+}
 
 /// Read a nested record's declared length and its largest keyframe time.
 fn record_len_and_maxt(bundle: &[u8], off: usize, size: usize) -> Option<(i64, i64)> {

crates/sylpheed-formats/tests/ui_settle_time_disc.rs

@@ -25,8 +25,15 @@ use std::path::PathBuf;
 
 use sylpheed_formats::{pak::PakArchive, ratc, ui_layout};
 
-mod common;
-use common::disc_root;
+fn disc_root() -> Option<PathBuf> {
+    if let Ok(p) = std::env::var("SYLPHEED_DISC") {
+        let p = PathBuf::from(p);
+        if p.join("dat").is_dir() {
+            return Some(p);
+        }
+    }
+    None
+}
 
 /// The case that found the bug, asserted end to end.
 #[test]

docker/ci/run

@@ -21,35 +21,56 @@ IMAGE="${SYLPH_CI_IMAGE:-sylph-ci:local}"
 CPUS="${SYLPH_CI_CPUS:-6}"
 MEM_GB="${SYLPH_CI_MEM_GB:-7}"
 
+CARGO_VOL="${SYLPH_CI_CARGO_VOL:-sylph-ci-cargo}"
+TARGET_VOL="${SYLPH_CI_TARGET_VOL:-sylph-ci-target}"
+
+# 🔴 Docker on the dev boxes is ROOTFUL, so without `--user` every byte the build
+# writes into the bind-mounted repo is owned by root — and the user then needs
+# `sudo` to delete their own artifacts. The regen command in the workspace
+# `CLAUDE.md` writes `sylpheed.db` straight into /work, so it lands root-owned,
+# and a stray root-owned file is exactly what survived the last cleanup and had
+# to be sudo'd away.
+#
+# The catch is that the daemon creates a named volume root-owned, so a `--user`
+# container cannot write /cargo or /target at all. Take ownership once — and
+# only when it is actually wrong, because a recursive chown across a ~36 GB
+# target volume is not something to repeat on every invocation.
+RUN_UID="$(id -u)"
+RUN_GID="$(id -g)"
+
+docker volume create "$CARGO_VOL"  >/dev/null
+docker volume create "$TARGET_VOL" >/dev/null
+
+# Both volumes, not just one: they are chowned together but can drift apart if an
+# older root-owned run created only one of them.
+vol_owner="$(docker run --rm -v "$CARGO_VOL:/cargo" -v "$TARGET_VOL:/target" "$IMAGE" \
+             stat -c %u /cargo /target 2>/dev/null | sort -u | tr '\n' ' ' || echo unknown)"
+if [ "$vol_owner" != "$RUN_UID " ]; then
+  echo "docker/ci/run: chowning the cargo/target volumes to $RUN_UID:$RUN_GID (one-off)" >&2
+  docker run --rm \
+    -v "$CARGO_VOL:/cargo" -v "$TARGET_VOL:/target" \
+    "$IMAGE" chown -R "$RUN_UID:$RUN_GID" /cargo /target
+fi
+
 args=(
   --rm
   --cpus "$CPUS"
   --memory "${MEM_GB}g"
   --memory-swap "${MEM_GB}g"
   --pids-limit 2048
+  # Run as the invoking user so build output in /work is owned by them, not root.
+  --user "$RUN_UID:$RUN_GID"
   -v "$REPO:/work"
   # Named volumes, not bind mounts: the host tree keeps a 32 GB `target/` from
   # earlier host-side builds, and mixing the two produces rebuilds that look
   # like cache misses and are actually two toolchains fighting over one directory.
-  -v sylph-ci-cargo:/cargo   -e CARGO_HOME=/cargo
-  -v sylph-ci-target:/target -e CARGO_TARGET_DIR=/target
+  -v "$CARGO_VOL:/cargo"   -e CARGO_HOME=/cargo
+  -v "$TARGET_VOL:/target" -e CARGO_TARGET_DIR=/target
   -w /work
 )
 
-# The corpora, read-only, when a disc-backed test or the exporter needs them.
-#
-# All three, not just the disc: a suite whose corpus is absent self-skips and
-# still counts as passed, so mounting one of three made an in-container run look
-# like a full one while `res3d` and `iso` suites silently sat out (#16). Each is
-# mounted only when it exists, and `target/sylpheed-corpus-report.txt` says which
-# ones the run actually had.
+# The disc, read-only, when a disc-backed test or the exporter needs it.
 DISC="${SYLPHEED_DISC:-$REPO/../sylph_extract}"
 [ -d "$DISC" ] && args+=(-v "$DISC:/disc:ro" -e SYLPHEED_DISC=/disc)
 
-RES3D="${SYLPHEED_RES3D:-}"
-[ -n "$RES3D" ] && [ -d "$RES3D" ] && args+=(-v "$RES3D:/res3d:ro" -e SYLPHEED_RES3D=/res3d)
-
-ISO="${SYLPHEED_ISO:-}"
-[ -n "$ISO" ] && [ -f "$ISO" ] && args+=(-v "$ISO:/disc.iso:ro" -e SYLPHEED_ISO=/disc.iso)
-
 exec docker run "${args[@]}" "$IMAGE" "$@"