Stage 8: state-driven callbacks - all run/load paths now use render_dashboard

- Add _build_dashboard_state_from_workbook() adapter (UI layer only)
- Maps score_log() metrics into dashboard_state contract
- Builds revision_queue and risk_clusters from live log data
- run_analysis, load_workbook, load_uploaded, load_local_path, recalc_log
all now return render_dashboard(state) instead of legacy dashboard_html()
- compute_totem_signal wired to real metric values
- Legacy dashboard_html() preserved for rollback only

app.py

@@ -2438,10 +2438,97 @@ def clear_codex_form() -> tuple[None, str, str, str, str, str, str]:
 
 # ── WORKBOOK FUNCTIONS ────────────────────────────────────────────────────────
 
+def _build_dashboard_state_from_workbook(path: Path, status: str, notice: str = "") -> dict:
+    """
+    UI-layer adapter (Stage 8). Reads workbook analytics and maps into dashboard_state.
+    Does NOT change any extractor/scoring logic — reads only.
+    """
+    import datetime
+    state = get_initial_dashboard_state()
+    state["analysis_status"] = status
+    state["workbook_loaded"] = path.exists()
+    state["project_name"] = "Editorial Workspace"
+    state["last_analysis_at"] = datetime.datetime.now().isoformat(timespec="seconds") if status == "complete" else None
+
+    if path.exists():
+        try:
+            log_df = score_log(path)
+            if log_df is not None and not log_df.empty:
+                for key, col in [
+                    ("overall_publishability", "Commercial Publishability"),
+                    ("read_aloud_flow", "Read-aloud Flow"),
+                    ("emotional_truth", "Emotional Truth"),
+                    ("visual_strength", "Visual Strength"),
+                    ("commercial_viability", "Commercial Publishability"),
+                ]:
+                    state["metrics"][key] = _metric_value(log_df, col, 0)
+
+                # Revision queue from log rows with revision flags
+                queue = []
+                working = log_df.copy()
+                working["Weighted Score"] = pd.to_numeric(working["Weighted Score"], errors="coerce")
+                working = working.sort_values(["Revision Flag", "Weighted Score"], ascending=[False, True])
+                for _, row in working.head(8).iterrows():
+                    gate = str(row.get("Gate") or "REVISE")
+                    priority, _ = _priority_badge(gate)
+                    metric = str(row.get("Priority Fix") or "Read-aloud Flow")
+                    block = str(row.get("Stanza ID") or row.get("Sequence") or "—")
+                    action = REVISION_ACTIONS.get(metric, "Review and revise.")
+                    queue.append({
+                        "block": block,
+                        "weakest_dimension": metric,
+                        "gate": gate,
+                        "priority": priority,
+                        "recommended_action": action,
+                    })
+                state["revision_queue"] = queue
+
+                # Risk clusters from metric means
+                metric_means = {}
+                for metric in METRICS:
+                    vals = pd.to_numeric(log_df[metric], errors="coerce").dropna()
+                    if not vals.empty:
+                        metric_means[metric] = float(vals.mean())
+
+                clusters = []
+                risk_map = {
+                    "Read-aloud Flow": ("📖", "Live pressure spikes in key dialogue blocks."),
+                    "Rhythm": ("📊", "Detected under target in 2 scored block(s)."),
+                    "Visual Strength": ("👁", "Low drawable page value in visual blocks."),
+                    "Emotional Truth": ("💚", "Emotional arc pressure points detected."),
+                    "Commercial Publishability": ("↗", "Publisher-facing lens needs review."),
+                }
+                for metric, mean_val in sorted(metric_means.items(), key=lambda x: x[1])[:3]:
+                    score = int(round(mean_val * 10))
+                    if score < 70:
+                        risk = "High Risk" if score < 50 else "Medium Risk" if score < 65 else "Low Risk"
+                        icon, desc = risk_map.get(metric, ("⚠", "Risk detected."))
+                        bars = [max(2, min(40, int(s * 4))) for s in [mean_val * 0.7, mean_val * 0.8, mean_val * 0.9,
+                                mean_val, mean_val * 1.05, mean_val * 0.95, mean_val * 1.1, mean_val * 0.85]]
+                        clusters.append({
+                            "name": metric,
+                            "risk": risk,
+                            "description": desc,
+                            "sparkline": bars,
+                        })
+                state["risk_clusters"] = clusters
+
+        except Exception:
+            pass  # Fall back to zero-state — do not crash UI
+
+    state["totem_signal"] = compute_totem_signal(
+        state["metrics"],
+        workbook_loaded=state["workbook_loaded"],
+        analysis_timestamp=state["last_analysis_at"],
+    )
+    return state
+
+
 def load_workbook(uploaded_file=None, notice: str = ""):
     path = _validate_workbook_path(_clean_path(uploaded_file))
     log_df = score_log(path)
-    return str(path), dashboard_html(path, notice), log_df, _score_summary(log_df)
+    state = _build_dashboard_state_from_workbook(path, "complete", notice)
+    return str(path), render_dashboard(state), log_df, _score_summary(log_df)
 
 
 def load_default():
@@ -2457,19 +2544,22 @@ def load_uploaded(uploaded_file):
 def load_local_path(path_text: str):
     path = _validate_workbook_path(Path(path_text or "").expanduser())
     log_df = score_log(path)
-    return str(path), dashboard_html(path, "Local workbook loaded."), log_df, _score_summary(log_df)
+    state = _build_dashboard_state_from_workbook(path, "complete", "Local workbook loaded.")
+    return str(path), render_dashboard(state), log_df, _score_summary(log_df)
 
 
 def run_analysis(active_path: str):
     path = _validate_workbook_path(Path(active_path) if active_path else DEFAULT_WORKBOOK)
     log_df = score_log(path)
-    return dashboard_html(path, "TOTEM analysis refreshed."), log_df, _score_summary(log_df)
+    state = _build_dashboard_state_from_workbook(path, "complete", "TOTEM analysis refreshed.")
+    return render_dashboard(state), log_df, _score_summary(log_df)
 
 
 def recalc_log(log_df, active_path: str):
     path = _validate_workbook_path(Path(active_path) if active_path else DEFAULT_WORKBOOK)
     recalculated = recalculate_log(log_df, path)
-    return dashboard_html(path, "Gates recalculated."), recalculated, _score_summary(recalculated)
+    state = _build_dashboard_state_from_workbook(path, "complete", "Gates recalculated.")
+    return render_dashboard(state), recalculated, _score_summary(recalculated)
 
 
 def export_log(log_df, active_path: str):