Paginate detection trees; add all inference services to dev stack

Makefile

@@ -110,21 +110,22 @@ reset: ## Resets Docker containers (down -v, then up -d).
 	@docker compose -f ./docker/compose.yaml up -d
 	@$(call log,Docker containers reset successfully.)
 
-# `NER=1` also starts the GLiNER2 NER service and points the server at the NER
-# engine config. Set by the `run` recipe below.
-ifdef NER
-RUN_ENGINE_ENV := ENGINE_CONFIG_FILEPATH="$$engine_config"
-endif
+# Inference services to start alongside the server. Set NER=1, OCR=1, and/or
+# STT=1 to bring up that bento (first run downloads its model). The `run` recipe
+# below starts the matching compose profiles and generates an engine config
+# naming only the services that are up; with none set, the server runs the
+# built-in pattern recognizers only.
+INFERENCE_PROFILES := $(if $(NER),--profile ner) $(if $(OCR),--profile ocr) $(if $(STT),--profile stt)
 
 .PHONY: run
-run: ## Runs the server (NATS, Postgres, RustFS first). Pass NER=1 to also start the GLiNER2 NER service.
+run: ## Runs the server (NATS, Postgres, RustFS first). Set NER=1, OCR=1, and/or STT=1 to also start that inference service.
 	@$(call log,Starting Postgres, NATS, and RustFS...)
 	@docker compose -f ./docker/compose.yaml up -d --wait postgres nats rustfs
 	@$(call log,Provisioning the blob store bucket...)
 	@docker compose -f ./docker/compose.yaml up --exit-code-from rustfs-init rustfs-init
-ifdef NER
-	@$(call log,Starting the NER service (first run downloads the model)...)
-	@docker compose -f ./docker/compose.yaml --profile ner up -d --wait ner
+ifneq ($(strip $(INFERENCE_PROFILES)),)
+	@$(call log,Starting inference services (first run downloads their models)...)
+	@docker compose -f ./docker/compose.yaml $(INFERENCE_PROFILES) up -d --wait
 endif
 	@$(call log,Starting server... (output also written to latest.log))
 	@# Tee via process substitution rather than a pipe: a pipe would put `tee`
@@ -133,7 +134,19 @@ endif
 	@# then lost and, under `pipefail`, the recipe reports exit 130. With `> >(tee)`
 	@# the server owns the terminal and receives the signal directly; its shutdown
 	@# runs and is logged, and the process exits cleanly.
-	@bash -c 'engine_config=$$(mktemp); trap "rm -f \"$$engine_config\"" EXIT; sed "s|\$${ELIDE_NER_PORT:-3200}|$${ELIDE_NER_PORT:-3200}|g" docker/engine.dev.toml > "$$engine_config"; $(RUN_ENGINE_ENV) cargo run --features dotenv --bin nvisy-cli > >(tee latest.log) 2>&1'
+	@# The engine config is generated from the enabled services, so it always
+	@# matches the running stack and its resolved ports; no config file is used
+	@# when none are enabled.
+	@bash -c '\
+		set -o pipefail; \
+		engine_env=; \
+		if [ -n "$(strip $(INFERENCE_PROFILES))" ]; then \
+			engine_config=$$(mktemp); \
+			trap "rm -f \"$$engine_config\"" EXIT; \
+			NER=$(if $(NER),1) OCR=$(if $(OCR),1) STT=$(if $(STT),1) ./scripts/gen-engine-config.sh > "$$engine_config"; \
+			engine_env="ENGINE_CONFIG_FILEPATH=$$engine_config"; \
+		fi; \
+		env $$engine_env cargo run --features dotenv --bin nvisy-cli > >(tee latest.log) 2>&1'
 
 .PHONY: generate-all
 generate-all: generate-env generate-keys generate-migrations

README.md

@@ -58,10 +58,10 @@ docker compose -f docker/compose.yaml up -d   # Start Postgres, NATS, RustFS
 make run                                                # Run the server
 ```
 
-To run with the GLiNER2 NER service (pattern recognition otherwise runs alone),
-pass `make run NER=1` — it also starts the `ner` compose profile and points the
-server at `docker/engine.dev.toml`. The first run downloads the model (~1.2 GB)
-into a cached volume.
+To run with the inference services (pattern recognition otherwise runs alone),
+set `NER=1`, `OCR=1`, and/or `STT=1` — e.g. `make run NER=1 OCR=1`. Each starts
+its bento compose profile and is added to a generated engine config matching the
+running stack. The first run of each downloads its model into a cached volume.
 
 The API then serves interactive OpenAPI docs (Scalar UI) at the running server's
 docs path. For self-hosted deployments, see [`docker/`](docker/) for compose

crates/nvisy-postgres/src/query/mod.rs

@@ -68,8 +68,8 @@ pub use workspace_connections::{
 pub use workspace_detection_jobs::DetectionJobOutboxRepository;
 pub use workspace_detection_policy_versions::DetectionPolicyVersionRepository;
 pub use workspace_detections::{
-    DetectionCursor, DetectionDocuments, DetectionListRow, DetectionSummary, EditWriteOutcome,
-    WorkspaceDetectionRepository,
+    DetectionCursor, DetectionDocuments, DetectionListRow, DetectionSummary, DetectionTreeRow,
+    EditWriteOutcome, WorkspaceDetectionRepository,
 };
 pub use workspace_documents::{
     DocumentCursor, DocumentWithBlob, ImportedDocumentRef, WorkspaceDocumentRepository,

crates/nvisy-postgres/src/query/workspace_detections.rs

@@ -1,5 +1,6 @@
 //! Workspace detections repository for managing analysis instances.
 
+use std::collections::HashMap;
 use std::future::Future;
 
 use diesel::prelude::*;
@@ -13,6 +14,7 @@ use crate::model::{
     NewWorkspaceDetectionCallMeter, UpdateWorkspaceDetection, WorkspaceDetection,
 };
 use crate::query::search::ilike_contains;
+use crate::query::{DetectionRedactedOutput, WorkspaceRedactionRepository};
 use crate::schema::{
     workspace_blobs as blobs, workspace_detections as detections, workspace_documents as documents,
     workspace_redactions as redactions,
@@ -146,11 +148,34 @@ pub struct DetectionListRow {
     pub input_document_name: Option<String>,
 }
 
+/// One detection tree: a detection run with its artifacts.
+#[derive(Debug, Clone)]
+pub struct DetectionTreeRow {
+    /// Detection run identifier.
+    pub detection_id: Uuid,
+    /// Input document identifier, retained even when the input is deleted.
+    pub input_document_id: Uuid,
+    /// Live input name, or None for a deleted input.
+    pub input_document_name: Option<String>,
+    /// Whether intermediate artifact bytes are retained.
+    pub intermediate_available: bool,
+    /// Live redacted output files for this run, newest first.
+    pub redacted_outputs: Vec<DetectionRedactedOutput>,
+}
+
 /// Repository for workspace detection database operations.
 ///
 /// Handles detection lifecycle management including creation, status updates,
 /// completion tracking, and queries.
 pub trait WorkspaceDetectionRepository {
+    /// Lists detection trees, paginating the roots before fetching their outputs.
+    fn cursor_list_detection_trees(
+        &mut self,
+        workspace_id: Uuid,
+        pagination: CursorPagination<DetectionCursor>,
+        filter: &DetectionFilter,
+    ) -> impl Future<Output = Result<CursorPage<DetectionTreeRow>>> + Send;
+
     /// Creates a new workspace detection record.
     fn create_workspace_detection(
         &mut self,
@@ -286,6 +311,33 @@ pub trait WorkspaceDetectionRepository {
 }
 
 impl WorkspaceDetectionRepository for PgConnection {
+    async fn cursor_list_detection_trees(
+        &mut self,
+        workspace_id: Uuid,
+        pagination: CursorPagination<DetectionCursor>,
+        filter: &DetectionFilter,
+    ) -> Result<CursorPage<DetectionTreeRow>> {
+        let page = self
+            .cursor_list_workspace_detections(workspace_id, pagination, filter)
+            .await?;
+        let ids: Vec<_> = page.items.iter().map(|row| row.detection.id).collect();
+        let outputs = self.detection_outputs_batch(workspace_id, &ids).await?;
+        let mut by_detection: HashMap<Uuid, Vec<DetectionRedactedOutput>> = HashMap::new();
+        for output in outputs {
+            by_detection
+                .entry(output.detection_id)
+                .or_default()
+                .push(output);
+        }
+        Ok(page.map(|row| DetectionTreeRow {
+            detection_id: row.detection.id,
+            input_document_id: row.detection.input_document_id,
+            input_document_name: row.input_document_name,
+            intermediate_available: row.detection.has_intermediate,
+            redacted_outputs: by_detection.remove(&row.detection.id).unwrap_or_default(),
+        }))
+    }
+
     async fn create_workspace_detection(
         &mut self,
         new_detection: NewWorkspaceDetection,
@@ -1076,6 +1128,100 @@ mod tests {
         Ok((seeded, ids))
     }
 
+    #[tokio::test]
+    async fn artifact_trees_paginate_roots_and_keep_outputs_with_their_detection()
+    -> anyhow::Result<()> {
+        use crate::query::WorkspaceDocumentRepository;
+
+        let db = TestDatabase::start().await;
+        let (seeded, _) = seed_searchable_runs(&db).await?;
+        let mut conn = db.client.get_connection().await?;
+        let filter = DetectionFilter {
+            search: Some("Report".into()),
+            ..Default::default()
+        };
+        let first = conn
+            .cursor_list_detection_trees(
+                seeded.workspace_id,
+                CursorPagination::new(1).with_count(),
+                &filter,
+            )
+            .await?;
+        assert_eq!(first.total, Some(2));
+        assert_eq!(first.items.len(), 1);
+        assert!(first.next_cursor.is_some());
+        let second = conn
+            .cursor_list_detection_trees(
+                seeded.workspace_id,
+                CursorPagination::from_cursor_string(1, first.next_cursor.as_deref()).with_count(),
+                &filter,
+            )
+            .await?;
+        assert_eq!(second.total, Some(2));
+        assert_eq!(second.items.len(), 1);
+        assert_ne!(first.items[0].detection_id, second.items[0].detection_id);
+        assert!(second.next_cursor.is_none());
+        for tree in [&first.items[0], &second.items[0]] {
+            assert_eq!(tree.input_document_name.as_deref(), Some("Report_50%.pdf"));
+            assert!(tree.intermediate_available);
+            assert_eq!(tree.redacted_outputs.len(), 3);
+            assert!(
+                tree.redacted_outputs
+                    .iter()
+                    .all(|output| output.detection_id == tree.detection_id)
+            );
+        }
+        let unknown_workspace = conn
+            .cursor_list_detection_trees(
+                Uuid::new_v4(),
+                CursorPagination::new(10).with_count(),
+                &filter,
+            )
+            .await?;
+        assert_eq!(unknown_workspace.total, Some(0));
+        assert_eq!(unknown_workspace.items.len(), 0);
+        assert!(unknown_workspace.next_cursor.is_none());
+
+        // Deleting child files does not remove their detection roots.
+        conn.delete_workspace_document(seeded.document_id).await?;
+        let input_id = first.items[0].input_document_id;
+        let by_input = DetectionFilter {
+            input_document_id: Some(input_id),
+            ..Default::default()
+        };
+        let without_outputs = conn
+            .cursor_list_detection_trees(
+                seeded.workspace_id,
+                CursorPagination::new(10).with_count(),
+                &by_input,
+            )
+            .await?;
+        assert_eq!(without_outputs.total, Some(2));
+        assert!(
+            without_outputs
+                .items
+                .iter()
+                .all(|tree| tree.redacted_outputs.is_empty())
+        );
+        // Deleted inputs also leave the run history intact, with no input metadata.
+        conn.delete_workspace_document(input_id).await?;
+        let without_input = conn
+            .cursor_list_detection_trees(
+                seeded.workspace_id,
+                CursorPagination::new(10).with_count(),
+                &by_input,
+            )
+            .await?;
+        assert_eq!(without_input.total, Some(2));
+        assert!(
+            without_input
+                .items
+                .iter()
+                .all(|tree| tree.input_document_name.is_none())
+        );
+        Ok(())
+    }
+
     #[tokio::test]
     async fn cursor_list_search_and_artifact_counts_preserve_pagination() -> anyhow::Result<()> {
         use crate::query::{WorkspaceDocumentRepository, WorkspaceRedactionRepository};

crates/nvisy-postgres/src/query/workspace_redactions.rs

@@ -25,6 +25,8 @@ pub struct RedactionCursor {
 /// Redacted output metadata for one detection, used by the artifacts endpoint.
 #[derive(Debug, Clone)]
 pub struct DetectionRedactedOutput {
+    /// Detection run that owns this output.
+    pub detection_id: Uuid,
     /// Redaction pass that produced the output.
     pub redaction_id: Uuid,
     /// Output document id.
@@ -43,6 +45,13 @@ pub struct DetectionRedactedOutput {
 /// have many. Each redaction owns the review audit it applied and the redacted
 /// document it produced.
 pub trait WorkspaceRedactionRepository {
+    /// Lists live outputs for a page of detections, newest first within each run.
+    fn detection_outputs_batch(
+        &mut self,
+        workspace_id: Uuid,
+        detection_ids: &[Uuid],
+    ) -> impl Future<Output = Result<Vec<DetectionRedactedOutput>>> + Send;
+
     /// Lists live redacted output files for a detection, newest first.
     fn detection_outputs(
         &mut self,
@@ -94,6 +103,15 @@ impl WorkspaceRedactionRepository for PgConnection {
         &mut self,
         workspace_id: Uuid,
         detection_id: Uuid,
+    ) -> Result<Vec<DetectionRedactedOutput>> {
+        self.detection_outputs_batch(workspace_id, &[detection_id])
+            .await
+    }
+
+    async fn detection_outputs_batch(
+        &mut self,
+        workspace_id: Uuid,
+        detection_ids: &[Uuid],
     ) -> Result<Vec<DetectionRedactedOutput>> {
         use schema::workspace_detections::dsl as detections;
         use schema::workspace_documents::dsl as documents;
@@ -102,6 +120,9 @@ impl WorkspaceRedactionRepository for PgConnection {
             workspace_blobs, workspace_detections, workspace_documents, workspace_redactions,
         };
 
+        if detection_ids.is_empty() {
+            return Ok(Vec::new());
+        }
         let rows = workspace_redactions::table
             .inner_join(workspace_detections::table)
             .inner_join(
@@ -119,22 +140,24 @@ impl WorkspaceRedactionRepository for PgConnection {
             .filter(workspace_blobs::workspace_id.eq(workspace_id))
             .filter(workspace_blobs::purged_at.is_null())
             .order((redactions::created_at.desc(), redactions::id.desc()))
-            .filter(redactions::detection_id.eq(detection_id))
+            .filter(redactions::detection_id.eq_any(detection_ids))
             .select((
+                redactions::detection_id,
                 redactions::id,
                 documents::id,
                 documents::display_name,
                 documents::file_extension,
                 workspace_blobs::file_size_bytes,
             ))
-            .load::<(Uuid, Uuid, String, String, i64)>(self)
+            .load::<(Uuid, Uuid, Uuid, String, String, i64)>(self)
             .await
             .map_err(Error::from)?;
         Ok(rows
             .into_iter()
             .map(
-                |(redaction_id, document_id, display_name, extension, size)| {
+                |(detection_id, redaction_id, document_id, display_name, extension, size)| {
                     DetectionRedactedOutput {
+                        detection_id,
                         redaction_id,
                         document_id,
                         display_name,

crates/nvisy-server/src/domain/output/workspace_detections.rs

@@ -20,13 +20,3 @@ pub struct CreatedDetection {
     /// idempotency key replayed an existing one (`200`).
     pub created: bool,
 }
-
-/// Artifact metadata for one detection run.
-pub struct DetectionArtifacts {
-    /// Live input document, if it has not been deleted.
-    pub input: Option<nvisy_postgres::model::WorkspaceDocument>,
-    /// Whether an intermediate artifact is retained.
-    pub intermediate_available: bool,
-    /// Live redacted output files.
-    pub redacted_outputs: Vec<nvisy_postgres::query::DetectionRedactedOutput>,
-}