feat(cli): perima metadata command + ls --with-metadata flag

New metadata subcommand re-extracts metadata for a specific file
(debugging / one-off fixes). ls gains an optional --with-metadata
flag that adds captured_at + dimensions + camera_model columns
via the new LEFT JOIN query path. Default ls output is unchanged
for v0.3.x script compatibility.

Scanner now enqueues freshly hashed files (Inserted | Updated) into
a MetadataQueue after each successful upsert_file. Scan performs a
bounded drain (default 30s, --no-wait-metadata bypasses) so CLI
callers can rely on metadata rows being present by exit — the
integration test scan_with_metadata_test asserts this directly.

Watcher still does not enqueue on Modified events in v0.4.0 —
content changes mark status=stale; next scan re-extracts. Avoids
Modified-storm pathology during file-in-flight downloads.

Adds perima-media workspace dep to crates/cli so release-plz's dep
graph propagates version bumps when feat(media): commits land.

Hardens scripts/pre-commit by exporting PKG_CONFIG_PATH / LIBRARY_PATH
/ RUSTFLAGS for the Tauri toolchain so `just ci` succeeds inside
git's non-interactive hook shell.

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

Author: utof

Cargo.lock

@@ -27,6 +27,10 @@ module_name_repetitions = "allow"
 missing_errors_doc = "warn"
 
 [workspace.dependencies]
+# WHY workspace-path dep for perima-media: release-plz + other crates
+# (perima CLI) need it reachable via `workspace = true` so bumps
+# propagate correctly via the workspace graph.
+perima-media = { path = "crates/media", version = "0.3.2" }
 anyhow       = "1"
 thiserror    = "2"
 serde        = { version = "1", features = ["derive"] }

Cargo.toml

@@ -7,10 +7,15 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-perima-core = { path = "../core" }
-perima-hash = { path = "../hash" }
-perima-fs   = { path = "../fs" }
-perima-db   = { path = "../db" }
+perima-core  = { path = "../core" }
+perima-hash  = { path = "../hash" }
+perima-fs    = { path = "../fs" }
+perima-db    = { path = "../db" }
+# WHY `workspace = true` (not path-local): release-plz reads the workspace
+# dep graph to decide which crates need version bumps. A `feat(media):`
+# commit must propagate to `perima` so the CLI rev matches the media rev
+# it links against.
+perima-media = { workspace = true }
 chrono.workspace    = true
 serde_json.workspace = true
 serde.workspace      = true
@@ -32,6 +37,10 @@ tempfile.workspace   = true
 insta.workspace      = true
 rusqlite.workspace   = true
 serde_json.workspace = true
+# WHY image + blake3 in dev-deps: `scan_with_metadata_test.rs`
+# synthesises PNG/JPEG fixtures at runtime (no binary blobs in git),
+# matching the pattern already used in `crates/media/tests`.
+image.workspace      = true
 
 [target.'cfg(unix)'.dev-dependencies]
 # WHY: nix provides POSIX signal utilities (kill/SIGTERM) without unsafe libc.

crates/cli/Cargo.toml

@@ -2,7 +2,9 @@
 
 use std::io::Write;
 
-use perima_core::{CoreError, FileLocationRecord, FileRepository, VolumeId};
+use perima_core::{
+    CoreError, FileLocationRecord, FileRepository, MediaMetadata, MetadataRepository, VolumeId,
+};
 
 /// Arguments for the ls command.
 #[derive(Debug, Clone)]
@@ -13,18 +15,46 @@ pub struct LsArgs {
     pub limit: usize,
     /// Output as JSON instead of a human-readable table.
     pub json: bool,
+    /// Include media metadata columns (`captured_at`, dimensions, `camera_model`).
+    ///
+    /// WHY opt-in flag: the `--with-metadata` path uses a LEFT JOIN
+    /// against `file_metadata`, which is slightly more expensive than
+    /// the base `list_file_locations` query and returns extra columns
+    /// that older scripts do not expect. Keeping the default narrow
+    /// preserves v0.3.x output stability.
+    pub with_metadata: bool,
 }
 
 /// Execute `ls`.
 ///
 /// Reads all file location records from `repo` (up to `args.limit`)
-/// and prints them either as a human-readable table or as JSON.
+/// and prints them either as a human-readable table or as JSON. When
+/// `args.with_metadata` is `true`, the listing routes through
+/// `metadata_repo` so each row is joined with its (optional)
+/// `file_metadata`.
 ///
 /// # Errors
 /// Propagates `CoreError` from the repository.
-pub fn run<R: FileRepository + ?Sized>(repo: &R, args: &LsArgs) -> Result<(), CoreError> {
-    let records = repo.list_file_locations(args.limit, args.volume)?;
+pub fn run<R, M>(repo: &R, metadata_repo: &M, args: &LsArgs) -> Result<(), CoreError>
+where
+    R: FileRepository + ?Sized,
+    M: MetadataRepository + ?Sized,
+{
+    if args.with_metadata {
+        let rows = metadata_repo.list_with_metadata(args.limit, args.volume)?;
+        if args.json {
+            let stdout = std::io::stdout();
+            let mut handle = stdout.lock();
+            serde_json::to_writer_pretty(&mut handle, &rows)
+                .map_err(|e| CoreError::Internal(format!("json: {e}")))?;
+            writeln!(handle).map_err(CoreError::Io)?;
+        } else {
+            print_table_with_metadata(&rows)?;
+        }
+        return Ok(());
+    }
 
+    let records = repo.list_file_locations(args.limit, args.volume)?;
     if args.json {
         let stdout = std::io::stdout();
         let mut handle = stdout.lock();
@@ -61,3 +91,52 @@ fn print_table(records: &[FileLocationRecord]) -> Result<(), CoreError> {
     }
     Ok(())
 }
+
+/// Render `ls --with-metadata` as a human-readable table.
+///
+/// WHY separate helper (not a branch inside [`print_table`]): the two
+/// tables have different column counts and different `writeln!` format
+/// strings; sharing the body would mean nullable placeholders for the
+/// metadata columns on plain `ls`, which is more confusing than a
+/// parallel function.
+fn print_table_with_metadata(
+    rows: &[(FileLocationRecord, Option<MediaMetadata>)],
+) -> Result<(), CoreError> {
+    let stdout = std::io::stdout();
+    let mut handle = stdout.lock();
+    writeln!(
+        handle,
+        "{:<10} {:<10} {:<10} {:<20} {:<10} {:<20} PATH",
+        "HASH", "SIZE", "VOLUME", "CAPTURED_AT", "DIMS", "CAMERA",
+    )
+    .map_err(CoreError::Io)?;
+    for (r, meta) in rows {
+        let hash_hex = r.hash.to_hex();
+        let hash_short = &hash_hex[..8];
+        let vol_str = r.volume_id.0.to_string();
+        let vol_short = &vol_str[..8];
+        let size = super::format::format_size(r.size.0);
+        let captured_at = meta
+            .as_ref()
+            .and_then(|m| m.captured_at.clone())
+            .unwrap_or_else(|| "-".to_owned());
+        let dims = meta
+            .as_ref()
+            .and_then(|m| match (m.width, m.height) {
+                (Some(w), Some(h)) => Some(format!("{w}x{h}")),
+                _ => None,
+            })
+            .unwrap_or_else(|| "-".to_owned());
+        let camera = meta
+            .as_ref()
+            .and_then(|m| m.camera_model.clone())
+            .unwrap_or_else(|| "-".to_owned());
+        writeln!(
+            handle,
+            "{hash_short}…  {size:<10} {vol_short}…  {captured_at:<20} {dims:<10} {camera:<20} {}",
+            r.relative_path.as_str()
+        )
+        .map_err(CoreError::Io)?;
+    }
+    Ok(())
+}