Add stage-2 metadata enrichment pipeline for known files

Known-classified files now flow to a second queue with its own worker pool
that extracts metadata via exiftool and writes a normalized JSON sidecar
next to the file in done/, leaving the original bytes untouched.

- Two-stage pipeline: spool/ → classify → known/ → enrich → done/;
  unknowns park in unknown/ as a seam for a future pool
- src/metadata.jl: exiftool -json -G -n with timeout, normalized schema
  (file_type, mime_type, author, created_by, dimensions, ...) + raw dump;
  degraded sidecar on extraction failure rather than quarantine
- Sidecar-first commit so a file in done/ always has its sidecar
- Parametrized worker_loop with classify/enrich handlers; blocking
  backpressure on a full known queue (never drop a classified file)
- Stage-aware recovery: spool/ and known/ resume at their correct stage
- Ordered drain: close stage-1 and wait its workers (the known queue's
  only producer) before closing the known queue
- exiftool required at startup (fail-fast); new FS_KNOWN_*/FS_UNKNOWN_DIR/
  FS_EXIFTOOL_TIMEOUT config knobs; combined-pool thread warning

src/config.jl

@@ -7,10 +7,18 @@ Base.@kwdef struct Config
     port::Int           = 8080
     worker_count::Int   = Threads.nthreads()
     queue_capacity::Int = 1000
-    spool_dir::String   = "data/spool"   # files land here on intake (pending)
-    done_dir::String    = "data/done"    # files move here after successful processing
+    # Stage 2 (enrichment) has its own pool + queue: exiftool work is process-spawn
+    # and I/O bound, a different cost profile than the CPU-bound Lux classify, so
+    # the two pools are tuned independently.
+    known_worker_count::Int   = Threads.nthreads()
+    known_queue_capacity::Int = 1000
+    spool_dir::String   = "data/spool"   # files land here on intake (pending classification)
+    known_dir::String   = "data/known"   # classified-known, awaiting enrichment (stage 2)
+    unknown_dir::String = "data/unknown" # classified-unknown, parked for a future pipeline
+    done_dir::String    = "data/done"    # fully enriched known files (+ .meta.json sidecars)
     failed_dir::String  = "data/failed"  # files move here if a worker throws
     model_path::String  = "model/classifier.jld2"  # committed classifier artifact, loaded at startup
+    exiftool_timeout::Int = 30           # seconds before a stuck exiftool is killed → degraded sidecar
 end
 
 """
@@ -22,26 +30,35 @@ and for `FileServer.run(; port=...)`).
 
 Recognised variables:
   FS_HOST, FS_PORT, FS_WORKERS, FS_QUEUE_CAPACITY,
-  FS_SPOOL_DIR, FS_DONE_DIR, FS_FAILED_DIR, FS_MODEL_PATH
+  FS_KNOWN_WORKERS, FS_KNOWN_QUEUE_CAPACITY,
+  FS_SPOOL_DIR, FS_KNOWN_DIR, FS_UNKNOWN_DIR, FS_DONE_DIR, FS_FAILED_DIR,
+  FS_MODEL_PATH, FS_EXIFTOOL_TIMEOUT
 """
 function config_from_env(; host=nothing, port=nothing, worker_count=nothing,
-                          queue_capacity=nothing, spool_dir=nothing,
-                          done_dir=nothing, failed_dir=nothing, model_path=nothing)
+                          queue_capacity=nothing, known_worker_count=nothing,
+                          known_queue_capacity=nothing, spool_dir=nothing,
+                          known_dir=nothing, unknown_dir=nothing, done_dir=nothing,
+                          failed_dir=nothing, model_path=nothing, exiftool_timeout=nothing)
     Config(
-        host           = something(host,           get(ENV, "FS_HOST", "127.0.0.1")),
-        port           = something(port,           parse(Int, get(ENV, "FS_PORT", "8080"))),
-        worker_count   = something(worker_count,   parse(Int, get(ENV, "FS_WORKERS", string(Threads.nthreads())))),
-        queue_capacity = something(queue_capacity, parse(Int, get(ENV, "FS_QUEUE_CAPACITY", "1000"))),
-        spool_dir      = something(spool_dir,      get(ENV, "FS_SPOOL_DIR", "data/spool")),
-        done_dir       = something(done_dir,       get(ENV, "FS_DONE_DIR", "data/done")),
-        failed_dir     = something(failed_dir,     get(ENV, "FS_FAILED_DIR", "data/failed")),
-        model_path     = something(model_path,     get(ENV, "FS_MODEL_PATH", "model/classifier.jld2")),
+        host                 = something(host,                 get(ENV, "FS_HOST", "127.0.0.1")),
+        port                 = something(port,                 parse(Int, get(ENV, "FS_PORT", "8080"))),
+        worker_count         = something(worker_count,         parse(Int, get(ENV, "FS_WORKERS", string(Threads.nthreads())))),
+        queue_capacity       = something(queue_capacity,       parse(Int, get(ENV, "FS_QUEUE_CAPACITY", "1000"))),
+        known_worker_count   = something(known_worker_count,   parse(Int, get(ENV, "FS_KNOWN_WORKERS", string(Threads.nthreads())))),
+        known_queue_capacity = something(known_queue_capacity, parse(Int, get(ENV, "FS_KNOWN_QUEUE_CAPACITY", "1000"))),
+        spool_dir            = something(spool_dir,            get(ENV, "FS_SPOOL_DIR", "data/spool")),
+        known_dir            = something(known_dir,            get(ENV, "FS_KNOWN_DIR", "data/known")),
+        unknown_dir          = something(unknown_dir,          get(ENV, "FS_UNKNOWN_DIR", "data/unknown")),
+        done_dir             = something(done_dir,             get(ENV, "FS_DONE_DIR", "data/done")),
+        failed_dir           = something(failed_dir,           get(ENV, "FS_FAILED_DIR", "data/failed")),
+        model_path           = something(model_path,           get(ENV, "FS_MODEL_PATH", "model/classifier.jld2")),
+        exiftool_timeout     = something(exiftool_timeout,     parse(Int, get(ENV, "FS_EXIFTOOL_TIMEOUT", "30"))),
     )
 end
 
-"Create the spool/done/failed directories if they don't already exist."
+"Create all the pipeline-stage directories if they don't already exist."
 function ensure_dirs(cfg::Config)
-    for d in (cfg.spool_dir, cfg.done_dir, cfg.failed_dir)
+    for d in (cfg.spool_dir, cfg.known_dir, cfg.unknown_dir, cfg.done_dir, cfg.failed_dir)
         mkpath(d)
     end
     return nothing