wrzonance
diff --git a/‎dashboard/lib/api-types.generated.ts‎
Lines changed: 26 additions & 0 deletions b/‎dashboard/lib/api-types.generated.ts‎
Lines changed: 26 additions & 0 deletions
diff --git a/‎server/app/api/setbuilder.py‎
Lines changed: 17 additions & 2 deletions b/‎server/app/api/setbuilder.py‎
Lines changed: 17 additions & 2 deletions
diff --git a/‎server/app/schemas/setbuilder.py‎
Lines changed: 16 additions & 0 deletions b/‎server/app/schemas/setbuilder.py‎
Lines changed: 16 additions & 0 deletions
diff --git a/‎server/app/services/setbuilder/agent_display.py‎
Lines changed: 11 additions & 2 deletions b/‎server/app/services/setbuilder/agent_display.py‎
Lines changed: 11 additions & 2 deletions
diff --git a/‎server/app/services/setbuilder/agent_tool_specs.py‎
Lines changed: 4 additions & 1 deletion b/‎server/app/services/setbuilder/agent_tool_specs.py‎
Lines changed: 4 additions & 1 deletion
diff --git a/‎server/app/services/setbuilder/agent_tools_imports.py‎
Lines changed: 3 additions & 0 deletions b/‎server/app/services/setbuilder/agent_tools_imports.py‎
Lines changed: 3 additions & 0 deletions
diff --git a/‎server/app/services/setbuilder/agent_tools_sensing.py‎
Lines changed: 17 additions & 3 deletions b/‎server/app/services/setbuilder/agent_tools_sensing.py‎
Lines changed: 17 additions & 3 deletions
diff --git a/‎server/app/services/setbuilder/agent_tools_structural.py‎
Lines changed: 15 additions & 2 deletions b/‎server/app/services/setbuilder/agent_tools_structural.py‎
Lines changed: 15 additions & 2 deletions
@@ -2715,6 +2715,10 @@ export interface paths {
         /**
          * Build Set
          * @description Run deterministic pass 1 after explicit user confirmation.
+         *
+         *     Coverage of the five required pool→builder fields is computed and returned so
+         *     the build-confirmation dialog can show data completeness and a SOFT,
+         *     overridable warning (#542/#538) — the build itself is never blocked on it.
          */
         post: operations["build_set_api_setbuilder_sets__set_id__build_post"];
         delete?: never;
@@ -4249,6 +4253,7 @@ export interface components {
          * @description Result of the deterministic pass.
          */
         BuildSetResponse: {
+            coverage: components["schemas"]["PoolCoverageOut"];
             /** Iterations */
             iterations: number;
             /** Slot Count */
@@ -5786,6 +5791,27 @@ export interface components {
             /** Source */
             source: string;
         };
+        /**
+         * PoolCoverageOut
+         * @description Pre-build coverage of the five required pool→builder contract fields (#542).
+         *
+         *     A SOFT, overridable signal surfaced in the build-confirmation dialog (#538):
+         *     ``missing`` is the per-field count of pool tracks lacking each field,
+         *     ``fully_covered_count`` how many carry all five, and ``ready`` whether the
+         *     pool clears the readiness threshold. The build is never hard-blocked on this.
+         */
+        PoolCoverageOut: {
+            /** Fully Covered Count */
+            fully_covered_count: number;
+            /** Missing */
+            missing: {
+                [key: string]: number;
+            };
+            /** Pool Size */
+            pool_size: number;
+            /** Ready */
+            ready: boolean;
+        };
         /**
          * PoolImportEventIn
          * @description Body for importing a WrzDJ event's requests.
 
@@ -54,6 +54,7 @@
     PlaybackReportSummary,
     PlaybackSlotOutcomeOut,
     PlayHistoryFeedbackOut,
+    PoolCoverageOut,
     PoolImportEventIn,
     PoolImportManualIn,
     PoolImportPlaylistIn,
@@ -113,6 +114,9 @@
     vibe_enrichment,
     vibe_resolver,
 )
+from app.services.setbuilder import (
+    coverage as pool_coverage_service,
+)
 from app.services.setbuilder.playlist_url import InvalidPlaylistUrl, parse_public_playlist_url
 
 router = APIRouter()
@@ -665,17 +669,23 @@ def build_set(
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_active_user),
 ) -> BuildSetResponse:
-    """Run deterministic pass 1 after explicit user confirmation."""
+    """Run deterministic pass 1 after explicit user confirmation.
+
+    Coverage of the five required pool→builder fields is computed and returned so
+    the build-confirmation dialog can show data completeness and a SOFT,
+    overridable warning (#542/#538) — the build itself is never blocked on it."""
     set_obj = _get_owned_or_404(db, set_id, current_user)
     if not payload.confirmed:
         raise HTTPException(status_code=400, detail="Build requires explicit confirmation")
+    coverage = pool_coverage_service.coverage_for_set(db, set_obj.id)
     result = pass1_deterministic.build_set(db, set_obj)
     db.expire(set_obj, ["slots"])
     return BuildSetResponse(
         slot_count=result.slot_count,
         iterations=result.iterations,
         slots=_slots_out(db, set_obj),
         transition_scores=_transition_scores_out(result.transition_scores),
+        coverage=PoolCoverageOut(**coverage),
     )
 
 
@@ -1079,6 +1089,7 @@ def import_pool_event(
         label=event.name,
         meta="WrzDJ event requests",
     )
+    candidates = pool.hydrate_candidates_from_store(db, candidates, user=current_user)
     added, deduped = pool.import_candidates(db, set_obj, source, candidates)
     return _import_result(db, set_obj.id, source, added, deduped)
 
@@ -1108,6 +1119,7 @@ def import_pool_tidal(
         label=payload.label or "Tidal playlist",
         meta="Tidal playlist",
     )
+    candidates = pool.hydrate_candidates_from_store(db, candidates, user=current_user)
     added, deduped = pool.import_candidates(db, set_obj, source, candidates)
     return _import_result(db, set_obj.id, source, added, deduped)
 
@@ -1133,6 +1145,7 @@ def import_pool_beatport(
         label=payload.label or "Beatport playlist",
         meta="Beatport playlist",
     )
+    candidates = pool.hydrate_candidates_from_store(db, candidates, user=current_user)
     added, deduped = pool.import_candidates(db, set_obj, source, candidates)
     return _import_result(db, set_obj.id, source, added, deduped)
 
@@ -1192,6 +1205,7 @@ def import_pool_url(
         label=name,
         meta=f"Public {parsed.provider} playlist",
     )
+    candidates = pool.hydrate_candidates_from_store(db, candidates, user=current_user)
     added, deduped = pool.import_candidates(db, set_obj, source, candidates)
     return _import_result(db, set_obj.id, source, added, deduped)
 
@@ -1223,7 +1237,8 @@ def import_pool_manual(
     source = pool.get_or_create_source(
         db, set_obj, kind="manual", external_ref=None, label="Manual", meta="Single-track search"
     )
-    added, deduped = pool.import_candidates(db, set_obj, source, [candidate])
+    candidates = pool.hydrate_candidates_from_store(db, [candidate], user=current_user)
+    added, deduped = pool.import_candidates(db, set_obj, source, candidates)
     return _import_result(db, set_obj.id, source, added, deduped)
 
 
 
@@ -443,13 +443,29 @@ class TransitionScoreOut(BaseModel):
     warnings: list[str]
 
 
+class PoolCoverageOut(BaseModel):
+    """Pre-build coverage of the five required pool→builder contract fields (#542).
+
+    A SOFT, overridable signal surfaced in the build-confirmation dialog (#538):
+    ``missing`` is the per-field count of pool tracks lacking each field,
+    ``fully_covered_count`` how many carry all five, and ``ready`` whether the
+    pool clears the readiness threshold. The build is never hard-blocked on this.
+    """
+
+    pool_size: int
+    fully_covered_count: int
+    ready: bool
+    missing: dict[str, int]
+
+
 class BuildSetResponse(BaseModel):
     """Result of the deterministic pass."""
 
     slot_count: int
     iterations: int
     slots: list[SlotOut]
     transition_scores: list[TransitionScoreOut]
+    coverage: PoolCoverageOut
 
 
 class SlotOrderRequest(BaseModel):
 
@@ -136,10 +136,13 @@ def _tool_display_summary(
     if name == "analyze_pool_gaps":
         missing = result.get("missing_camelot_keys") or []
         sparse = result.get("sparse_bands") or []
+        missing_genre = int(result.get("missing_genre_count") or 0)
+        missing_energy = int(result.get("missing_energy_count") or 0)
         return (
             f"Analyzed pool gaps over {int(result.get('pool_size') or 0)} tracks: "
             f"{len(missing)} missing Camelot key{'s' if len(missing) != 1 else ''}, "
-            f"{len(sparse)} sparse BPM band{'s' if len(sparse) != 1 else ''}."
+            f"{len(sparse)} sparse BPM band{'s' if len(sparse) != 1 else ''}, "
+            f"{missing_genre} missing genre, {missing_energy} missing energy."
         )
     if name == "critique_set":
         grade = result.get("overall_grade")
@@ -161,10 +164,16 @@ def _tool_display_summary(
     if name == "autobuild":
         slots = int(result.get("slot_count") or 0)
         iterations = int(result.get("iterations") or 0)
-        return (
+        summary = (
             f"Rebuilt the set: {slots} slot{'s' if slots != 1 else ''}, "
             f"{iterations} refinement pass{'es' if iterations != 1 else ''}."
         )
+        coverage = result.get("coverage") or {}
+        pool_size = int(coverage.get("pool_size") or 0)
+        fully = int(coverage.get("fully_covered_count") or 0)
+        if pool_size and fully < pool_size:
+            summary += f" {fully}/{pool_size} pool tracks fully enriched."
+        return summary
     if name == "fill_to_duration":
         added = int(result.get("inserted_count") or 0)
         now_min = int(result.get("estimated_total_sec") or 0) // 60
 
@@ -186,7 +186,10 @@ def _agent_tools() -> list[ToolSpec]:
         ),
         ToolSpec(
             name="analyze_pool_gaps",
-            description=("Report pool coverage holes: missing Camelot keys and sparse BPM bands."),
+            description=(
+                "Report pool coverage holes: missing Camelot keys, sparse BPM bands, "
+                "and how many tracks are missing genre or energy."
+            ),
             input_schema={"type": "object", "properties": {}},
         ),
         ToolSpec(
 
@@ -104,6 +104,7 @@ def _tool_import_from_event(
         label=event.name,
         meta="WrzDJ event requests",
     )
+    candidates = pool.hydrate_candidates_from_store(db, candidates, user=owner, commit=False)
     added, deduped = pool.import_candidates(db, set_obj, source, candidates, commit=False)
     return _import_summary(source, added, deduped), set()
 
@@ -151,6 +152,7 @@ def _connected_playlist_import(
         label=playlist.name,
         meta=f"{kind.capitalize()} playlist",
     )
+    candidates = pool.hydrate_candidates_from_store(db, candidates, user=owner, commit=False)
     added, deduped = pool.import_candidates(db, set_obj, source, candidates, commit=False)
     return _import_summary(source, added, deduped), set()
 
@@ -219,5 +221,6 @@ def _tool_import_from_url(
         label=name,
         meta=f"Public {parsed.provider} playlist",
     )
+    candidates = pool.hydrate_candidates_from_store(db, candidates, user=owner, commit=False)
     added, deduped = pool.import_candidates(db, set_obj, source, candidates, commit=False)
     return _import_summary(source, added, deduped), set()
@@ -255,26 +255,40 @@ def _energy_profile(values: list[float | None]) -> dict[str, Any]:
 def _tool_analyze_pool_gaps(
     db: Session, set_obj: Set, payload: dict[str, Any]
 ) -> tuple[dict[str, Any], set[int]]:
-    """Read-only coverage report over the set's pool (missing keys + BPM bands)."""
+    """Read-only coverage report over the set's pool: missing Camelot keys, BPM
+    bands, and genre + energy coverage (#542).
+
+    Genre + energy are read straight from the resolved pool rows (which #542's
+    store hydration now fills), not from the previously-dead pool energy column —
+    consistent with the build-gate ``coverage.pool_coverage`` field set."""
     del payload
-    metas = [_pass1_track_meta(t) for t in _pool_tracks(db, set_obj.id)]
+    pool = _pool_tracks(db, set_obj.id)
+    metas = [_pass1_track_meta(t) for t in pool]
     camelot_keys = [str(pos) for pos in (parse_key(m.key) for m in metas) if pos is not None]
     bpms = [float(m.bpm) for m in metas if m.bpm is not None]
+    genre_count = sum(1 for t in pool if t.genre)
+    energy_count = sum(1 for t in pool if t.energy is not None)
     present = set(camelot_keys)
     missing = [key for key in ALL_CAMELOT_KEYS if key not in present]
     bands = _bpm_bands(set_obj, bpms)
     logger.debug(
-        "Set %s analyze_pool_gaps: pool=%d keyed=%d bpm=%d missing_keys=%d",
+        "Set %s analyze_pool_gaps: pool=%d keyed=%d bpm=%d genre=%d energy=%d missing_keys=%d",
         set_obj.id,
         len(metas),
         len(camelot_keys),
         len(bpms),
+        genre_count,
+        energy_count,
         len(missing),
     )
     return {
         "pool_size": len(metas),
         "keyed_track_count": len(camelot_keys),
         "bpm_track_count": len(bpms),
+        "genre_track_count": genre_count,
+        "energy_track_count": energy_count,
+        "missing_genre_count": len(metas) - genre_count,
+        "missing_energy_count": len(metas) - energy_count,
         "missing_camelot_keys": missing,
         "bpm_bands": bands,
         "sparse_bands": [b for b in bands if b["count"] < SPARSE_BAND_THRESHOLD],
 
@@ -16,6 +16,7 @@
 from app.models.set import Set
 from app.services.setbuilder.agent_common import AgentToolError, _ordered_slots, _pool_tracks
 from app.services.setbuilder.agent_tools_mutations import _insert_track_at
+from app.services.setbuilder.coverage import coverage_for_set
 from app.services.setbuilder.pass1_deterministic import AVG_TRACK_LENGTH_SEC, build_set
 from app.services.setbuilder.pass1_deterministic import _track_meta as _pass1_track_meta
 
@@ -35,15 +36,27 @@ def _tool_autobuild(
     already honors locked slots and saved pairings. Runs with ``commit=False``
     so the agent turn commits/rolls back as one unit.
     """
+    # Coverage of the five required pool→builder fields BEFORE the rebuild, so the
+    # agent can warn the DJ about under-enriched tracks (#542). Soft/advisory only:
+    # autobuild proceeds regardless, mirroring the REST build's overridable gate.
+    coverage = coverage_for_set(db, set_obj.id)
     result = build_set(db, set_obj, commit=False)
     affected = {slot.position for slot in result.slots}
     logger.info(
-        "setbuilder autobuild: set %s rebuilt to %s slots (%s refinement iterations)",
+        "setbuilder autobuild: set %s rebuilt to %s slots (%s refinement iterations); "
+        "pool coverage ready=%s (%s/%s fully enriched)",
         set_obj.id,
         result.slot_count,
         result.iterations,
+        coverage["ready"],
+        coverage["fully_covered_count"],
+        coverage["pool_size"],
     )
-    return {"slot_count": result.slot_count, "iterations": result.iterations}, affected
+    return {
+        "slot_count": result.slot_count,
+        "iterations": result.iterations,
+        "coverage": coverage,
+    }, affected
 
 
 def _duration_for(track) -> int:
Original file line number	Diff line number	Diff line change
`@@ -104,6 +104,7 @@ def _tool_import_from_event(`
`104`	`104`	`label=event.name,`
`105`	`105`	`meta="WrzDJ event requests",`
`106`	`106`	`)`
	`107`	`+ candidates = pool.hydrate_candidates_from_store(db, candidates, user=owner, commit=False)`
`107`	`108`	`added, deduped = pool.import_candidates(db, set_obj, source, candidates, commit=False)`
`108`	`109`	`return _import_summary(source, added, deduped), set()`
`109`	`110`
`@@ -151,6 +152,7 @@ def _connected_playlist_import(`
`151`	`152`	`label=playlist.name,`
`152`	`153`	`meta=f"{kind.capitalize()} playlist",`
`153`	`154`	`)`
	`155`	`+ candidates = pool.hydrate_candidates_from_store(db, candidates, user=owner, commit=False)`
`154`	`156`	`added, deduped = pool.import_candidates(db, set_obj, source, candidates, commit=False)`
`155`	`157`	`return _import_summary(source, added, deduped), set()`
`156`	`158`
`@@ -219,5 +221,6 @@ def _tool_import_from_url(`
`219`	`221`	`label=name,`
`220`	`222`	`meta=f"Public {parsed.provider} playlist",`
`221`	`223`	`)`
	`224`	`+ candidates = pool.hydrate_candidates_from_store(db, candidates, user=owner, commit=False)`
`222`	`225`	`added, deduped = pool.import_candidates(db, set_obj, source, candidates, commit=False)`
`223`	`226`	`return _import_summary(source, added, deduped), set()`