Redesign workflow UI by stage

app.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import html
 from typing import Any
 
 import gradio as gr
@@ -49,14 +50,185 @@ from course_slide_factory.workflow import (
     update_setup_from_inputs,
     approve_and_continue,
 )
-from course_slide_factory.quality import get_stage_lock_reasons
-from course_slide_factory.models import IssueSeverity, IssueStatus, IssueType, RevisionConstraints
+from course_slide_factory.quality import can_unlock_next_stage, get_current_stage_artifact, get_stage_lock_reasons
+from course_slide_factory.models import ArtifactStatus, IssueSeverity, IssueStatus, IssueType, RevisionConstraints
 
 
 CSS = """
-.gradio-container { max-width: 1480px !important; }
+.gradio-container { max-width: 1540px !important; background: #f7f8fa; }
 textarea, .cm-editor { font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace; }
 .compact-panel table { font-size: 12px; }
+.workflow-topbar {
+    position: sticky;
+    top: 0;
+    z-index: 20;
+    background: rgba(247, 248, 250, 0.96);
+    border-bottom: 1px solid #d9dee7;
+    padding: 10px 0 12px;
+    backdrop-filter: blur(8px);
+}
+.workflow-shell {
+    border: 1px solid #d9dee7;
+    background: #ffffff;
+    border-radius: 8px;
+    padding: 14px 16px;
+}
+.workflow-title-row {
+    display: flex;
+    align-items: flex-start;
+    justify-content: space-between;
+    gap: 18px;
+}
+.workflow-kicker {
+    color: #667085;
+    font-size: 11px;
+    font-weight: 700;
+    letter-spacing: 0.06em;
+    text-transform: uppercase;
+}
+.workflow-shell h2 {
+    color: #111827;
+    font-size: 22px;
+    line-height: 1.2;
+    margin: 4px 0 2px;
+}
+.workflow-shell p {
+    color: #4b5563;
+    margin: 0;
+}
+.workflow-progress-card {
+    min-width: 170px;
+    border: 1px solid #d9dee7;
+    border-radius: 8px;
+    padding: 10px 12px;
+    text-align: right;
+    background: #f9fafb;
+}
+.workflow-progress-card strong {
+    display: block;
+    color: #111827;
+    font-size: 26px;
+    line-height: 1;
+}
+.workflow-progress-card span {
+    color: #667085;
+    font-size: 12px;
+}
+.workflow-progress-track {
+    height: 8px;
+    background: #e5e7eb;
+    border-radius: 999px;
+    margin-top: 12px;
+    overflow: hidden;
+}
+.workflow-progress-fill {
+    height: 100%;
+    background: #2563eb;
+    border-radius: inherit;
+}
+.workflow-metrics {
+    display: grid;
+    gap: 8px;
+    grid-template-columns: repeat(4, minmax(0, 1fr));
+    margin-top: 12px;
+}
+.workflow-metric {
+    border: 1px solid #e5e7eb;
+    border-radius: 8px;
+    padding: 8px 10px;
+    background: #ffffff;
+}
+.workflow-metric span {
+    color: #667085;
+    display: block;
+    font-size: 11px;
+}
+.workflow-metric strong {
+    color: #111827;
+    display: block;
+    font-size: 15px;
+    margin-top: 2px;
+}
+.stage-score-grid {
+    display: grid;
+    gap: 6px;
+    grid-template-columns: repeat(auto-fit, minmax(126px, 1fr));
+}
+.stage-score-chip {
+    border: 1px solid #d9dee7;
+    border-left: 4px solid #9ca3af;
+    border-radius: 8px;
+    background: #ffffff;
+    padding: 8px;
+    min-height: 74px;
+}
+.stage-score-chip.active {
+    border-color: #2563eb;
+    border-left-color: #2563eb;
+    box-shadow: inset 0 0 0 1px #2563eb;
+}
+.stage-score-chip.complete { border-left-color: #059669; }
+.stage-score-chip.review { border-left-color: #d97706; }
+.stage-score-chip.blocked { border-left-color: #dc2626; }
+.stage-score-chip.stale { border-left-color: #7c3aed; }
+.stage-score-chip.ready { border-left-color: #2563eb; }
+.stage-chip-top {
+    align-items: center;
+    display: flex;
+    gap: 6px;
+    justify-content: space-between;
+}
+.stage-chip-number,
+.stage-chip-score {
+    color: #111827;
+    font-size: 12px;
+    font-weight: 700;
+}
+.stage-chip-label {
+    color: #111827;
+    font-size: 12px;
+    font-weight: 600;
+    line-height: 1.2;
+    margin-top: 6px;
+}
+.stage-chip-state {
+    color: #667085;
+    font-size: 11px;
+    margin-top: 4px;
+    text-transform: capitalize;
+}
+.stage-nav-row button {
+    min-height: 42px;
+    white-space: normal !important;
+}
+.screen-card {
+    border: 1px solid #d9dee7;
+    border-radius: 8px;
+    background: #ffffff;
+    padding: 14px;
+}
+.screen-card h3 {
+    color: #111827;
+    font-size: 18px;
+    margin: 0 0 4px;
+}
+.screen-card p {
+    color: #4b5563;
+    margin: 0 0 10px;
+}
+.action-strip button {
+    min-height: 42px;
+}
+@media (max-width: 900px) {
+    .workflow-title-row,
+    .workflow-metrics {
+        display: block;
+    }
+    .workflow-progress-card {
+        margin-top: 12px;
+        text-align: left;
+    }
+}
 """
 
 START_PATH_SUMMARIES = {
@@ -74,6 +246,277 @@ START_PATH_SUMMARIES = {
     ),
 }
 
+PASSING_STAGE_SCORE = 80
+RESOLVED_ISSUE_STATUSES = {IssueStatus.RESOLVED, IssueStatus.WAIVED, IssueStatus.WONT_FIX}
+COMPLETED_ARTIFACT_STATUSES = {ArtifactStatus.APPROVED, ArtifactStatus.EXPORTED}
+REVIEW_STAGE_DEFAULTS = {
+    "technical_review": ("technical_review", "sme"),
+    "pedagogical_review": ("pedagogical_review", "instructional_designer"),
+    "aesthetic_review": ("aesthetic_review", "visual_designer"),
+}
+ARTIFACT_WORKSPACE_STAGES = {
+    "source_extraction_objective_mapping",
+    "slide_outline_order",
+    "title_generation",
+    "text_generation",
+    "image_visual_asset_generation",
+    "aesthetic_ordering_visual_composition",
+}
+REVIEW_WORKSPACE_STAGES = {"technical_review", "pedagogical_review", "aesthetic_review"}
+FINAL_WORKSPACE_STAGES = {"final_render_export"}
+AUDIT_WORKSPACE_STAGES = {"audit_log_version_history"}
+HISTORY_WORKSPACE_STAGES = ARTIFACT_WORKSPACE_STAGES | AUDIT_WORKSPACE_STAGES
+
+STAGE_UI_CONFIG = {
+    "setup_inputs": {
+        "short": "Setup",
+        "focus": "Collect source material, choose the start path, and lock the deck operating settings.",
+        "primary": "Save the working setup, then run preflight before drafting.",
+    },
+    "source_extraction_objective_mapping": {
+        "short": "Sources",
+        "focus": "Extract usable source context and connect it to measurable learning objectives.",
+        "primary": "Generate mapping",
+    },
+    "slide_outline_order": {
+        "short": "Outline",
+        "focus": "Shape the instructional sequence, slide roles, and objective coverage.",
+        "primary": "Build outline",
+    },
+    "title_generation": {
+        "short": "Titles",
+        "focus": "Draft clear slide titles that make the course arc scannable.",
+        "primary": "Generate titles",
+    },
+    "text_generation": {
+        "short": "Text",
+        "focus": "Draft visible text and speaker notes with density and grounding checks.",
+        "primary": "Generate slide text",
+    },
+    "image_visual_asset_generation": {
+        "short": "Visuals",
+        "focus": "Create visual briefs, assets, alt text, and licensing metadata.",
+        "primary": "Generate visuals",
+    },
+    "aesthetic_ordering_visual_composition": {
+        "short": "Layout",
+        "focus": "Assign layouts, check slot compliance, and refine visual hierarchy.",
+        "primary": "Compose layout",
+    },
+    "technical_review": {
+        "short": "Technical",
+        "focus": "Review technical accuracy, terminology, and unsupported claims.",
+        "primary": "Refresh technical queue",
+    },
+    "pedagogical_review": {
+        "short": "Pedagogy",
+        "focus": "Review objective coverage, learning progression, examples, and teachability.",
+        "primary": "Refresh pedagogy queue",
+    },
+    "aesthetic_review": {
+        "short": "Aesthetic",
+        "focus": "Review readability, accessibility, visual consistency, and template fit.",
+        "primary": "Refresh aesthetic queue",
+    },
+    "final_render_export": {
+        "short": "Export",
+        "focus": "Run export preflight, resolve blockers, and produce the final deck artifact.",
+        "primary": "Final render",
+    },
+    "audit_log_version_history": {
+        "short": "Audit",
+        "focus": "Inspect audit events, prompt runs, semantic diffs, and candidate versions.",
+        "primary": "Inspect history",
+    },
+}
+
+
+def _safe_stage_id(stage_id: str | None) -> str:
+    return stage_id if stage_id in STAGE_IDS else STAGE_IDS[0]
+
+
+def _short_stage_label(stage_id: str) -> str:
+    return STAGE_UI_CONFIG[stage_id]["short"]
+
+
+def _escape(value: object) -> str:
+    return html.escape("" if value is None else str(value), quote=True)
+
+
+def _is_unresolved_issue(issue) -> bool:
+    return issue.status not in RESOLVED_ISSUE_STATUSES and not issue.resolved
+
+
+def _unresolved_blocker_count(state, stage_id: str | None = None) -> int:
+    return sum(
+        1
+        for issue in state.issues.values()
+        if issue.severity == IssueSeverity.BLOCKER
+        and _is_unresolved_issue(issue)
+        and (stage_id is None or issue.stage_id == stage_id)
+    )
+
+
+def _stage_status_key(stage_id: str, state) -> str:
+    stage = state.stages[stage_id]
+    artifact = get_current_stage_artifact(stage_id, state)
+    if artifact and artifact.status in COMPLETED_ARTIFACT_STATUSES:
+        return "complete"
+    if stage.is_stale:
+        return "stale"
+    if _unresolved_blocker_count(state, stage_id) > 0:
+        return "blocked"
+    if artifact is None:
+        return "pending"
+    if stage.score is None or stage.score < PASSING_STAGE_SCORE:
+        return "review"
+    if can_unlock_next_stage(stage_id, state):
+        return "ready"
+    if get_stage_lock_reasons(stage_id, state):
+        return "review"
+    return "ready"
+
+
+def workflow_progress_summary(state) -> dict[str, Any]:
+    total = len(STAGE_IDS)
+    complete = 0
+    scored_values: list[int] = []
+    stale = 0
+    for stage_id in STAGE_IDS:
+        stage = state.stages[stage_id]
+        artifact = get_current_stage_artifact(stage_id, state)
+        if artifact and artifact.status in COMPLETED_ARTIFACT_STATUSES:
+            complete += 1
+        if stage.score is not None:
+            scored_values.append(stage.score)
+        if stage.is_stale:
+            stale += 1
+    percent = round((complete / total) * 100) if total else 0
+    return {
+        "complete": complete,
+        "total": total,
+        "percent": percent,
+        "stale": stale,
+        "unresolved_blockers": _unresolved_blocker_count(state),
+        "average_stage_score": round(sum(scored_values) / len(scored_values)) if scored_values else None,
+    }
+
+
+def stage_score_rows(state, active_stage_id: str) -> list[dict[str, Any]]:
+    active_stage_id = _safe_stage_id(active_stage_id)
+    rows = []
+    for index, stage_id in enumerate(STAGE_IDS, start=1):
+        stage = state.stages[stage_id]
+        rows.append(
+            {
+                "index": index,
+                "stage_id": stage_id,
+                "label": STAGE_LABELS[stage_id],
+                "short_label": _short_stage_label(stage_id),
+                "score": stage.score,
+                "status": _stage_status_key(stage_id, state),
+                "active": stage_id == active_stage_id,
+            }
+        )
+    return rows
+
+
+def render_workflow_header(state, active_stage_id: str) -> str:
+    active_stage_id = _safe_stage_id(active_stage_id)
+    summary = workflow_progress_summary(state)
+    config = STAGE_UI_CONFIG[active_stage_id]
+    average_score = summary["average_stage_score"]
+    score_label = "No scores yet" if average_score is None else f"{average_score}/100"
+    percent = summary["percent"]
+    return f"""
+<div class="workflow-shell">
+  <div class="workflow-title-row">
+    <div>
+      <div class="workflow-kicker">Course Slide Factory</div>
+      <h2>{_escape(STAGE_LABELS[active_stage_id])}</h2>
+      <p>{_escape(config["focus"])}</p>
+    </div>
+    <div class="workflow-progress-card">
+      <strong>{summary["percent"]}%</strong>
+      <span>{summary["complete"]}/{summary["total"]} stages complete</span>
+    </div>
+  </div>
+  <div class="workflow-progress-track">
+    <div class="workflow-progress-fill" style="width: {percent}%"></div>
+  </div>
+  <div class="workflow-metrics">
+    <div class="workflow-metric"><span>Average stage score</span><strong>{_escape(score_label)}</strong></div>
+    <div class="workflow-metric"><span>Unresolved blockers</span><strong>{summary["unresolved_blockers"]}</strong></div>
+    <div class="workflow-metric"><span>Stale stages</span><strong>{summary["stale"]}</strong></div>
+    <div class="workflow-metric"><span>Current action</span><strong>{_escape(config["primary"])}</strong></div>
+  </div>
+</div>
+"""
+
+
+def render_stage_score_strip(state, active_stage_id: str) -> str:
+    chips = []
+    for row in stage_score_rows(state, active_stage_id):
+        score = "No score" if row["score"] is None else f"{row['score']}/100"
+        classes = ["stage-score-chip", row["status"]]
+        if row["active"]:
+            classes.append("active")
+        chips.append(
+            f"""
+<div class="{_escape(" ".join(classes))}">
+  <div class="stage-chip-top">
+    <span class="stage-chip-number">{row["index"]:02d}</span>
+    <span class="stage-chip-score">{_escape(score)}</span>
+  </div>
+  <div class="stage-chip-label">{_escape(row["short_label"])}</div>
+  <div class="stage-chip-state">{_escape(row["status"].replace("_", " "))}</div>
+</div>
+"""
+        )
+    return f'<div class="stage-score-grid">{"".join(chips)}</div>'
+
+
+def stage_visibility_updates(active_stage_id: str):
+    active_stage_id = _safe_stage_id(active_stage_id)
+    return tuple(gr.update(visible=stage_id == active_stage_id) for stage_id in STAGE_IDS)
+
+
+def workspace_visibility_updates(active_stage_id: str):
+    active_stage_id = _safe_stage_id(active_stage_id)
+    return (
+        gr.update(visible=active_stage_id in ARTIFACT_WORKSPACE_STAGES),
+        gr.update(visible=active_stage_id in REVIEW_WORKSPACE_STAGES),
+        gr.update(visible=active_stage_id in FINAL_WORKSPACE_STAGES),
+        gr.update(visible=active_stage_id in AUDIT_WORKSPACE_STAGES),
+        gr.update(visible=active_stage_id in HISTORY_WORKSPACE_STAGES),
+    )
+
+
+def stage_step_button_updates(active_stage_id: str):
+    active_stage_id = _safe_stage_id(active_stage_id)
+    return tuple(
+        gr.update(
+            value=f"{index + 1}. {_short_stage_label(stage_id)}",
+            variant="primary" if stage_id == active_stage_id else "secondary",
+        )
+        for index, stage_id in enumerate(STAGE_IDS)
+    )
+
+
+def _render_chrome_outputs(state, active_stage_id: str):
+    active_stage_id = _safe_stage_id(active_stage_id)
+    return (
+        render_workflow_header(state, active_stage_id),
+        render_stage_score_strip(state, active_stage_id),
+        *stage_visibility_updates(active_stage_id),
+        *workspace_visibility_updates(active_stage_id),
+        *stage_step_button_updates(active_stage_id),
+    )
+
+
+def _stage_nav_defaults(stage_id: str) -> tuple[str, str]:
+    return REVIEW_STAGE_DEFAULTS.get(stage_id, ("all", "general_reviewer"))
+
 
 def _has_file(file_value) -> bool:
     if not file_value:
@@ -178,6 +621,7 @@ def _render_outputs(
     change_set_id: str = "",
     prompt_run_id: str = "",
 ):
+    stage_id = _safe_stage_id(stage_id)
     lock_reasons = "\n".join(get_stage_lock_reasons(stage_id, state)) or "Unlocked"
     role_summary = review_mode_summary_text(state, review_role)
     review_queue = review_queue_table(
@@ -222,6 +666,7 @@ def _render_outputs(
         prompt_runs,
         prompt_detail,
         metrics,
+        *_render_chrome_outputs(state, stage_id),
     )
 
 
@@ -355,9 +800,22 @@ def handle_export(state_data, stage_id):
     return _render_outputs(state, stage_id, message)
 
 
-def handle_stage_change(state_data, stage_id):
+def handle_stage_nav(state_data, target_stage_id):
+    target_stage_id = _safe_stage_id(target_stage_id)
     state = state_from_dict(state_data)
-    return _render_outputs(state, stage_id, f"Selected {STAGE_LABELS[stage_id]}.")
+    queue_stage, review_role = _stage_nav_defaults(target_stage_id)
+    return (
+        target_stage_id,
+        queue_stage,
+        review_role,
+        *_render_outputs(
+            state,
+            target_stage_id,
+            f"Selected {STAGE_LABELS[target_stage_id]}.",
+            review_role=review_role,
+            queue_stage=queue_stage,
+        ),
+    )
 
 
 def _constraints_from_inputs(
@@ -644,377 +1102,393 @@ def build_app() -> gr.Blocks:
         ("Suggest layout switch", "suggest_layout_switch"),
         ("Add alt text", "add_alt_text"),
     ]
+    initial_state = build_empty_state(deck_title="Course Slide Deck", source_url="", template_url="mock://template/course")
+
     with gr.Blocks(title="Course Slide Factory") as demo:
         state_store = gr.State()
-
-        gr.Markdown("## Course Slide Factory")
-        with gr.Row():
-            with gr.Column(scale=1, min_width=320):
-                deck_title = gr.Textbox(label="Deck title", value="Course Slide Deck")
-                gr.Markdown("### Start path")
-                with gr.Row():
-                    instructions_path = gr.Button("Instructions file")
-                    outline_path = gr.Button("Input outline")
-                    draft_path = gr.Button("Draft deck")
-                start_mode = gr.Textbox(value="instructions_file", visible=False)
-                selected_start_path = gr.Markdown(START_PATH_SUMMARIES["instructions_file"])
-                with gr.Group(visible=True) as instructions_panel:
-                    material_files = gr.File(
-                        label="Instructions file",
-                        file_count="multiple",
-                        file_types=[".txt", ".md", ".csv", ".json", ".pdf", ".docx", ".pptx"],
-                        type="filepath",
-                    )
-                    source_url = gr.Textbox(label="Material URL", value="")
-                with gr.Group(visible=False) as outline_panel:
-                    outline_text = gr.Textbox(
-                        label="Outline",
-                        lines=8,
-                        placeholder="Opening hook\nCore concept\nWorked example\nPractice prompt\nWrap-up",
-                    )
-                    source_text = gr.Textbox(
-                        label="Input information",
-                        lines=6,
-                        placeholder="Audience, prerequisites, source notes, constraints, examples, or must-cover points.",
+        stage_id = gr.Textbox(value=STAGE_IDS[0], visible=False)
+
+        with gr.Group(elem_classes=["workflow-topbar"]):
+            workflow_header = gr.Markdown(render_workflow_header(initial_state, STAGE_IDS[0]))
+            with gr.Row(elem_classes=["stage-nav-row"]):
+                stage_nav_buttons = [
+                    gr.Button(
+                        f"{index + 1}. {_short_stage_label(nav_stage_id)}",
+                        variant="primary" if nav_stage_id == STAGE_IDS[0] else "secondary",
+                        size="sm",
                     )
-                with gr.Group(visible=False) as draft_panel:
-                    draft_file = gr.File(
-                        label="Draft input required (.pptx, .pdf, or image)",
-                        file_count="single",
-                        file_types=[".pptx", ".pdf", ".png", ".jpg", ".jpeg", ".webp"],
-                        type="filepath",
-                    )
-                template_url = gr.Textbox(label="Template URL", value="mock://template/course")
-                output_folder_id = gr.Textbox(label="Output folder ID", value="")
-                mutation_target_url = gr.Textbox(label="Mutation target URL", value="")
-                with gr.Row():
-                    dry_run = gr.Checkbox(label="Dry run", value=True)
-                    production_export_requested = gr.Checkbox(label="Production export", value=False)
-                objectives_text = gr.Textbox(
-                    label="Learning objectives",
-                    lines=5,
-                    placeholder="obj_1: Explain the core course concept.\nobj_2: Apply the concept to a worked example.",
-                    value="",
-                )
-                update_setup = gr.Button("Save Setup", variant="secondary")
+                    for index, nav_stage_id in enumerate(STAGE_IDS)
+                ]
+            stage_score_strip = gr.Markdown(render_stage_score_strip(initial_state, STAGE_IDS[0]))
 
+        with gr.Row():
             with gr.Column(scale=2):
-                stage_id = gr.Dropdown(
-                    label="Workflow stage",
-                    choices=stage_choices,
-                    value=STAGE_IDS[0],
-                    interactive=True,
-                )
-                with gr.Row():
-                    generate = gr.Button("Generate", variant="primary")
-                    grade = gr.Button("Grade")
-                    improve = gr.Button("Improve with AI")
-                    approve = gr.Button("Approve & Continue", variant="primary")
-                with gr.Row():
-                    preflight = gr.Button("Run Preflight")
-                    export = gr.Button("Final Render & Export", variant="stop")
                 status = gr.Markdown()
-                lock_reasons = gr.Textbox(label="Lock reasons", lines=4, interactive=False)
-
-                with gr.Tabs():
-                    with gr.Tab("Artifact"):
-                        artifact_editor = gr.Textbox(
-                            label="Current artifact / human edit",
-                            lines=16,
-                            interactive=True,
-                        )
-                        with gr.Row():
-                            reviewer_name = gr.Textbox(label="Reviewer", value="human_reviewer")
-                            reviewer_summary = gr.Textbox(label="Reviewer summary")
-                        requested_changes_json = gr.Textbox(
-                            label="Requested changes JSON",
-                            lines=6,
-                            value="[]",
-                        )
-                        save_edits = gr.Button("Save Human Edits")
-                        artifact_diff = gr.Textbox(label="Artifact diff", lines=12, interactive=False)
-                    with gr.Tab("Deck Health"):
-                        deck_health = gr.Dataframe(
-                            headers=["Metric", "Value"],
-                            interactive=False,
-                            elem_classes=["compact-panel"],
-                        )
-                    with gr.Tab("Slide Inventory"):
-                        slide_inventory = gr.Dataframe(
-                            headers=[
-                                "Slide #",
-                                "Title",
-                                "Role",
-                                "Objectives",
-                                "Claims",
-                                "Visuals",
-                                "Aggregate",
-                                "Technical",
-                                "Pedagogical",
-                                "Aesthetic",
-                                "Status",
-                                "Issues",
-                                "Stale?",
-                            ],
-                            interactive=False,
-                            elem_classes=["compact-panel"],
-                        )
-                    with gr.Tab("Objectives"):
-                        objective_matrix = gr.Dataframe(
-                            headers=[
-                                "Objective ID",
-                                "Objective",
-                                "Mapped Slides",
-                                "Coverage Score",
-                                "Coverage Status",
-                                "Evidence Count",
-                                "Issues",
-                            ],
-                            interactive=False,
-                            elem_classes=["compact-panel"],
-                        )
-                    with gr.Tab("Preflight"):
-                        preflight_results = gr.Dataframe(
-                            headers=["Field", "Value"],
-                            interactive=False,
-                            elem_classes=["compact-panel"],
-                        )
-                    with gr.Tab("Stages"):
-                        stage_status = gr.Dataframe(
-                            headers=[
-                                "#",
-                                "Stage",
-                                "Score",
-                                "Artifact",
-                                "Artifact Status",
-                                "Stale?",
-                                "Can Unlock Next?",
-                                "Lock Reasons",
-                            ],
-                            interactive=False,
-                            elem_classes=["compact-panel"],
-                        )
-                    with gr.Tab("Issues"):
-                        issues = gr.Dataframe(
-                            headers=[
-                                "Issue ID",
-                                "Type",
-                                "Severity",
-                                "Stage",
-                                "Slide",
-                                "Message",
-                                "Resolved?",
-                            ],
-                            interactive=False,
-                            elem_classes=["compact-panel"],
-                        )
-                    with gr.Tab("Review Workbench"):
-                        with gr.Row():
-                            review_role = gr.Dropdown(
-                                label="Review role",
-                                choices=review_role_options,
-                                value="general_reviewer",
-                                interactive=True,
-                            )
-                            queue_stage = gr.Dropdown(
-                                label="Stage filter",
-                                choices=queue_stage_choices,
-                                value="all",
-                                interactive=True,
-                            )
-                            queue_severity = gr.Dropdown(
-                                label="Severity filter",
-                                choices=severity_choices,
-                                value="all",
-                                interactive=True,
-                            )
-                        with gr.Row():
-                            queue_status = gr.Dropdown(
-                                label="Status filter",
-                                choices=status_choices,
-                                value="all",
-                                interactive=True,
-                            )
-                            queue_issue_type = gr.Dropdown(
-                                label="Issue type filter",
-                                choices=issue_type_choices,
-                                value="all",
-                                interactive=True,
-                            )
-                            assigned_filter = gr.Textbox(label="Assigned reviewer filter")
-                        role_summary = gr.Textbox(label="Review mode", lines=3, interactive=False)
-                        refresh_review = gr.Button("Refresh Review Workbench")
-                        review_queue = gr.Dataframe(
-                            headers=[
-                                "Severity",
-                                "Priority",
-                                "Status",
-                                "Stage",
-                                "Slide",
-                                "Role",
-                                "Issue Type",
-                                "Message",
-                                "Suggested Fix",
-                                "Assigned To",
-                                "Created At",
-                                "Issue ID",
-                            ],
-                            interactive=False,
-                            elem_classes=["compact-panel"],
-                        )
-                        with gr.Row():
-                            selected_issue_id = gr.Textbox(label="Issue ID")
-                            issue_action = gr.Dropdown(
-                                label="Triage action",
-                                choices=[
-                                    ("Acknowledge", "acknowledge"),
-                                    ("Mark in progress", "in_progress"),
-                                    ("Resolve", "resolve"),
-                                    ("Waive", "waive"),
-                                    ("Won't fix", "wont_fix"),
-                                    ("Reopen", "reopen"),
-                                    ("Assign", "assign"),
-                                ],
-                                value="acknowledge",
-                            )
-                            triage_note = gr.Textbox(label="Reason or note")
-                        with gr.Row():
-                            assigned_role = gr.Dropdown(
-                                label="Assign role",
-                                choices=[("No role", "all"), *review_role_options],
-                                value="all",
-                            )
-                            assigned_to = gr.Textbox(label="Assign reviewer")
-                            triage_issue = gr.Button("Apply Triage")
-                            generate_issue_fix = gr.Button("Generate Suggested Fix")
-                        suggested_fixes = gr.Dataframe(
-                            headers=[
-                                "Fix ID",
-                                "Type",
-                                "Stage",
-                                "Slides",
-                                "Issues",
-                                "Risk",
-                                "Description",
-                            ],
-                            interactive=False,
-                            elem_classes=["compact-panel"],
-                        )
-                        with gr.Row():
-                            fast_generate_grade = gr.Button("Generate + Grade Current Stage")
-                            fast_draft_ahead = gr.Button("Draft Ahead Until Review Needed")
-                        with gr.Row():
-                            preserve_slide_order = gr.Checkbox(label="Preserve slide order", value=True)
-                            preserve_slide_titles = gr.Checkbox(label="Preserve slide titles", value=False)
-                            preserve_technical_claims = gr.Checkbox(label="Preserve technical claims", value=True)
-                        with gr.Row():
-                            preserve_objective_mappings = gr.Checkbox(
-                                label="Preserve objective mappings",
-                                value=True,
-                            )
-                            preserve_visual_assets = gr.Checkbox(label="Preserve visual assets", value=False)
-                            preserve_layout_ids = gr.Checkbox(label="Preserve layout IDs", value=False)
-                        with gr.Row():
-                            constraint_slide_ids = gr.Textbox(label="Selected slide IDs")
-                            allowed_fields = gr.Textbox(label="Allowed fields")
-                            blocked_fields = gr.Textbox(label="Blocked fields")
-                        reviewer_instruction = gr.Textbox(label="Reviewer instruction", lines=2)
-                        with gr.Row():
-                            propose_with_constraints = gr.Button("Critique + Propose Changes")
-                            targeted_slide_ids = gr.Textbox(label="Target slide IDs")
-                            targeted_action = gr.Dropdown(
-                                label="Selected slide action",
-                                choices=targeted_action_choices,
-                                value="rewrite_visible_text",
-                            )
-                            targeted_improvement = gr.Button("Create Targeted Changes")
-                        critique_output = gr.Textbox(label="Latest critique", lines=8, interactive=False)
-                        proposed_change_sets = gr.Dataframe(
-                            headers=[
-                                "Change Set ID",
-                                "Stage",
-                                "Status",
-                                "Artifact",
-                                "Changes",
-                                "Summary",
-                                "Created At",
-                            ],
-                            interactive=False,
-                            elem_classes=["compact-panel"],
-                        )
-                        with gr.Row():
-                            selected_change_set_id = gr.Textbox(label="Change set ID")
-                            selected_change_ids = gr.Textbox(label="Selected change IDs")
-                            apply_changes = gr.Button("Apply Selected Proposed Changes", variant="primary")
-                            reject_changes = gr.Button("Reject Change Set")
-                        proposed_changes = gr.Dataframe(
-                            headers=[
-                                "Change Set",
-                                "Change ID",
-                                "Target Type",
-                                "Target ID",
-                                "Field",
-                                "Before",
-                                "After",
-                                "Rationale",
-                                "Issues",
-                                "Risk",
-                            ],
-                            interactive=False,
-                            elem_classes=["compact-panel"],
+            with gr.Column(scale=1, min_width=240):
+                reviewer_name = gr.Textbox(label="Reviewer", value="human_reviewer")
+
+        stage_screens: list[Any] = []
+
+        with gr.Group(visible=True, elem_classes=["screen-card"]) as setup_screen:
+            gr.Markdown(
+                "### Setup & Inputs\n"
+                "Choose how the deck starts, collect the source material, and save the operating settings."
+            )
+            with gr.Row():
+                with gr.Column(scale=1, min_width=320):
+                    deck_title = gr.Textbox(label="Deck title", value="Course Slide Deck")
+                    gr.Markdown("#### Start path")
+                    with gr.Row():
+                        instructions_path = gr.Button("Instructions file")
+                        outline_path = gr.Button("Input outline")
+                        draft_path = gr.Button("Draft deck")
+                    start_mode = gr.Textbox(value="instructions_file", visible=False)
+                    selected_start_path = gr.Markdown(START_PATH_SUMMARIES["instructions_file"])
+                    with gr.Group(visible=True) as instructions_panel:
+                        material_files = gr.File(
+                            label="Instructions file",
+                            file_count="multiple",
+                            file_types=[".txt", ".md", ".csv", ".json", ".pdf", ".docx", ".pptx"],
+                            type="filepath",
                         )
-                        semantic_compare = gr.Button("Compare Latest Versions")
-                        semantic_diff = gr.Textbox(label="Semantic diff", lines=10, interactive=False)
-                        with gr.Row():
-                            packet_stage_ids = gr.Textbox(label="Packet stage IDs")
-                            packet_slide_ids = gr.Textbox(label="Packet slide IDs")
-                            packet_format = gr.Radio(
-                                label="Packet format",
-                                choices=[("Markdown", "markdown"), ("JSON", "json")],
-                                value="markdown",
-                            )
-                            create_packet = gr.Button("Create Review Packet")
-                        with gr.Row():
-                            restore_artifact_id = gr.Textbox(label="Artifact version ID")
-                            restore_candidate = gr.Button("Restore as Candidate")
-                        prompt_runs = gr.Dataframe(
-                            headers=[
-                                "Prompt Run ID",
-                                "Created At",
-                                "Stage",
-                                "Provider",
-                                "Model",
-                                "Template",
-                                "Inputs",
-                                "Output",
-                                "Settings",
-                            ],
-                            interactive=False,
-                            elem_classes=["compact-panel"],
+                        source_url = gr.Textbox(label="Material URL", value="")
+                    with gr.Group(visible=False) as outline_panel:
+                        outline_text = gr.Textbox(
+                            label="Outline",
+                            lines=8,
+                            placeholder="Opening hook\nCore concept\nWorked example\nPractice prompt\nWrap-up",
                         )
-                        prompt_run_id = gr.Textbox(label="Prompt run ID")
-                        prompt_detail = gr.Textbox(label="Prompt run detail", lines=8, interactive=False)
-                        reviewer_metrics = gr.Dataframe(
-                            headers=["Metric", "Value"],
-                            interactive=False,
-                            elem_classes=["compact-panel"],
+                        source_text = gr.Textbox(
+                            label="Input information",
+                            lines=6,
+                            placeholder="Audience, prerequisites, source notes, constraints, examples, or must-cover points.",
                         )
-                    with gr.Tab("Audit"):
-                        audit = gr.Dataframe(
-                            headers=[
-                                "Event ID",
-                                "Type",
-                                "Timestamp",
-                                "Stage",
-                                "Slide",
-                                "Issue",
-                                "Reason",
-                            ],
-                            interactive=False,
-                            elem_classes=["compact-panel"],
+                    with gr.Group(visible=False) as draft_panel:
+                        draft_file = gr.File(
+                            label="Draft input required (.pptx, .pdf, or image)",
+                            file_count="single",
+                            file_types=[".pptx", ".pdf", ".png", ".jpg", ".jpeg", ".webp"],
+                            type="filepath",
                         )
-                    with gr.Tab("State JSON"):
-                        state_json = gr.Textbox(label="State", lines=18, interactive=False)
+                with gr.Column(scale=1, min_width=320):
+                    template_url = gr.Textbox(label="Template URL", value="mock://template/course")
+                    output_folder_id = gr.Textbox(label="Output folder ID", value="")
+                    mutation_target_url = gr.Textbox(label="Mutation target URL", value="")
+                    with gr.Row():
+                        dry_run = gr.Checkbox(label="Dry run", value=True)
+                        production_export_requested = gr.Checkbox(label="Production export", value=False)
+                    objectives_text = gr.Textbox(
+                        label="Learning objectives",
+                        lines=8,
+                        placeholder="obj_1: Explain the core course concept.\nobj_2: Apply the concept to a worked example.",
+                        value="",
+                    )
+                    with gr.Row(elem_classes=["action-strip"]):
+                        update_setup = gr.Button("Save Setup", variant="primary")
+                        setup_preflight = gr.Button("Run Preflight")
+                        setup_generate = gr.Button("Create Setup Candidate")
+        stage_screens.append(setup_screen)
+
+        with gr.Group(visible=False, elem_classes=["screen-card"]) as source_screen:
+            gr.Markdown("### Source Extraction / Objective Mapping\nExtract source chunks and map them to learning objectives.")
+            with gr.Row(elem_classes=["action-strip"]):
+                source_generate = gr.Button("Generate Mapping", variant="primary")
+                source_grade = gr.Button("Grade Mapping")
+                source_approve = gr.Button("Approve Mapping", variant="primary")
+            objective_matrix = gr.Dataframe(
+                headers=[
+                    "Objective ID",
+                    "Objective",
+                    "Mapped Slides",
+                    "Coverage Score",
+                    "Coverage Status",
+                    "Evidence Count",
+                    "Issues",
+                ],
+                interactive=False,
+                elem_classes=["compact-panel"],
+            )
+        stage_screens.append(source_screen)
+
+        with gr.Group(visible=False, elem_classes=["screen-card"]) as outline_screen:
+            gr.Markdown("### Slide Outline & Order\nCreate the slide sequence, inspect slide roles, and check coverage.")
+            with gr.Row(elem_classes=["action-strip"]):
+                outline_generate = gr.Button("Build Outline", variant="primary")
+                outline_grade = gr.Button("Grade Outline")
+                outline_approve = gr.Button("Approve Outline", variant="primary")
+            slide_inventory = gr.Dataframe(
+                headers=[
+                    "Slide #",
+                    "Title",
+                    "Role",
+                    "Objectives",
+                    "Claims",
+                    "Visuals",
+                    "Aggregate",
+                    "Technical",
+                    "Pedagogical",
+                    "Aesthetic",
+                    "Status",
+                    "Issues",
+                    "Stale?",
+                ],
+                interactive=False,
+                elem_classes=["compact-panel"],
+            )
+        stage_screens.append(outline_screen)
+
+        with gr.Group(visible=False, elem_classes=["screen-card"]) as title_screen:
+            gr.Markdown("### Title Generation\nDraft, review, edit, and approve slide titles.")
+            with gr.Row(elem_classes=["action-strip"]):
+                title_generate = gr.Button("Generate Titles", variant="primary")
+                title_grade = gr.Button("Grade Titles")
+                title_save_edits = gr.Button("Save Title Edits")
+                title_approve = gr.Button("Approve Titles", variant="primary")
+        stage_screens.append(title_screen)
+
+        with gr.Group(visible=False, elem_classes=["screen-card"]) as text_screen:
+            gr.Markdown("### Text Generation\nDraft visible slide text and speaker notes, then improve or approve the result.")
+            with gr.Row(elem_classes=["action-strip"]):
+                text_generate = gr.Button("Generate Slide Text", variant="primary")
+                text_improve = gr.Button("Improve Text with AI")
+                text_save_edits = gr.Button("Save Text Edits")
+                text_grade = gr.Button("Grade Text")
+                text_approve = gr.Button("Approve Text", variant="primary")
+        stage_screens.append(text_screen)
+
+        with gr.Group(visible=False, elem_classes=["screen-card"]) as image_screen:
+            gr.Markdown("### Image / Visual Asset Generation\nGenerate visual asset plans, alt text, and asset readiness metadata.")
+            with gr.Row(elem_classes=["action-strip"]):
+                image_generate = gr.Button("Generate Visuals", variant="primary")
+                image_improve = gr.Button("Improve Visual Plan")
+                image_grade = gr.Button("Grade Visuals")
+                image_approve = gr.Button("Approve Visuals", variant="primary")
+        stage_screens.append(image_screen)
+
+        with gr.Group(visible=False, elem_classes=["screen-card"]) as layout_screen:
+            gr.Markdown(
+                "### Aesthetic Ordering / Visual Composition\n"
+                "Assign layouts, inspect composition, and compare the latest candidate versions."
+            )
+            with gr.Row(elem_classes=["action-strip"]):
+                layout_generate = gr.Button("Compose Layout", variant="primary")
+                layout_improve = gr.Button("Improve Composition")
+                layout_compare = gr.Button("Compare Layout Versions")
+                layout_grade = gr.Button("Grade Layout")
+                layout_approve = gr.Button("Approve Layout", variant="primary")
+        stage_screens.append(layout_screen)
+
+        with gr.Group(visible=False, elem_classes=["screen-card"]) as technical_screen:
+            gr.Markdown("### Technical Review\nFocus on technical accuracy, terminology, unsupported claims, and blocking issues.")
+            with gr.Row(elem_classes=["action-strip"]):
+                technical_refresh = gr.Button("Refresh Technical Queue", variant="primary")
+                technical_fix = gr.Button("Generate Technical Fix")
+                technical_approve = gr.Button("Approve Technical Review", variant="primary")
+        stage_screens.append(technical_screen)
+
+        with gr.Group(visible=False, elem_classes=["screen-card"]) as pedagogical_screen:
+            gr.Markdown("### Pedagogical Review\nFocus on objective coverage, teaching flow, examples, and speaker notes.")
+            with gr.Row(elem_classes=["action-strip"]):
+                pedagogical_refresh = gr.Button("Refresh Pedagogy Queue", variant="primary")
+                pedagogical_fix = gr.Button("Generate Pedagogy Fix")
+                pedagogical_approve = gr.Button("Approve Pedagogical Review", variant="primary")
+        stage_screens.append(pedagogical_screen)
+
+        with gr.Group(visible=False, elem_classes=["screen-card"]) as aesthetic_screen:
+            gr.Markdown("### Aesthetic Review\nFocus on readability, accessibility, brand/template compliance, and layout consistency.")
+            with gr.Row(elem_classes=["action-strip"]):
+                aesthetic_refresh = gr.Button("Refresh Aesthetic Queue", variant="primary")
+                aesthetic_fix = gr.Button("Generate Aesthetic Fix")
+                aesthetic_approve = gr.Button("Approve Aesthetic Review", variant="primary")
+        stage_screens.append(aesthetic_screen)
+
+        with gr.Group(visible=False, elem_classes=["screen-card"]) as final_screen:
+            gr.Markdown("### Final Render & Export\nRun the final readiness checks and export the completed deck.")
+            with gr.Row(elem_classes=["action-strip"]):
+                final_preflight = gr.Button("Run Export Preflight", variant="primary")
+                export = gr.Button("Final Render & Export", variant="stop")
+        stage_screens.append(final_screen)
+
+        with gr.Group(visible=False, elem_classes=["screen-card"]) as audit_screen:
+            gr.Markdown("### Audit Log / Version History\nInspect prompt runs, state, semantic diffs, and candidate versions.")
+            with gr.Row(elem_classes=["action-strip"]):
+                audit_compare = gr.Button("Compare Latest Versions", variant="primary")
+                restore_candidate = gr.Button("Restore Candidate")
+        stage_screens.append(audit_screen)
+
+        with gr.Group(visible=False, elem_classes=["screen-card"]) as artifact_workspace:
+            gr.Markdown("### Current Stage Artifact")
+            with gr.Row():
+                with gr.Column(scale=2):
+                    artifact_editor = gr.Textbox(label="Current artifact / human edit", lines=16, interactive=True)
+                    artifact_diff = gr.Textbox(label="Artifact diff", lines=10, interactive=False)
+                with gr.Column(scale=1, min_width=320):
+                    lock_reasons = gr.Textbox(label="Lock reasons", lines=5, interactive=False)
+                    reviewer_summary = gr.Textbox(label="Reviewer summary")
+                    requested_changes_json = gr.Textbox(label="Requested changes JSON", lines=6, value="[]")
+            with gr.Accordion("AI revision controls", open=False):
+                with gr.Row():
+                    preserve_slide_order = gr.Checkbox(label="Preserve slide order", value=True)
+                    preserve_slide_titles = gr.Checkbox(label="Preserve slide titles", value=False)
+                    preserve_technical_claims = gr.Checkbox(label="Preserve technical claims", value=True)
+                with gr.Row():
+                    preserve_objective_mappings = gr.Checkbox(label="Preserve objective mappings", value=True)
+                    preserve_visual_assets = gr.Checkbox(label="Preserve visual assets", value=False)
+                    preserve_layout_ids = gr.Checkbox(label="Preserve layout IDs", value=False)
+                with gr.Row():
+                    constraint_slide_ids = gr.Textbox(label="Selected slide IDs")
+                    allowed_fields = gr.Textbox(label="Allowed fields")
+                    blocked_fields = gr.Textbox(label="Blocked fields")
+                reviewer_instruction = gr.Textbox(label="Reviewer instruction", lines=2)
+                with gr.Row():
+                    propose_with_constraints = gr.Button("Critique + Propose Changes")
+                    targeted_slide_ids = gr.Textbox(label="Target slide IDs")
+                    targeted_action = gr.Dropdown(
+                        label="Selected slide action",
+                        choices=targeted_action_choices,
+                        value="rewrite_visible_text",
+                    )
+                    targeted_improvement = gr.Button("Create Targeted Changes")
+                critique_output = gr.Textbox(label="Latest critique", lines=7, interactive=False)
+                proposed_change_sets = gr.Dataframe(
+                    headers=["Change Set ID", "Stage", "Status", "Artifact", "Changes", "Summary", "Created At"],
+                    interactive=False,
+                    elem_classes=["compact-panel"],
+                )
+                with gr.Row():
+                    selected_change_set_id = gr.Textbox(label="Change set ID")
+                    selected_change_ids = gr.Textbox(label="Selected change IDs")
+                    apply_changes = gr.Button("Apply Selected Proposed Changes", variant="primary")
+                    reject_changes = gr.Button("Reject Change Set")
+                proposed_changes = gr.Dataframe(
+                    headers=[
+                        "Change Set",
+                        "Change ID",
+                        "Target Type",
+                        "Target ID",
+                        "Field",
+                        "Before",
+                        "After",
+                        "Rationale",
+                        "Issues",
+                        "Risk",
+                    ],
+                    interactive=False,
+                    elem_classes=["compact-panel"],
+                )
+        with gr.Group(visible=False, elem_classes=["screen-card"]) as review_workspace:
+            gr.Markdown("### Review Workbench")
+            with gr.Row():
+                review_role = gr.Dropdown(label="Review role", choices=review_role_options, value="general_reviewer", interactive=True)
+                queue_stage = gr.Dropdown(label="Stage filter", choices=queue_stage_choices, value="all", interactive=True)
+                queue_severity = gr.Dropdown(label="Severity filter", choices=severity_choices, value="all", interactive=True)
+            with gr.Row():
+                queue_status = gr.Dropdown(label="Status filter", choices=status_choices, value="all", interactive=True)
+                queue_issue_type = gr.Dropdown(label="Issue type filter", choices=issue_type_choices, value="all", interactive=True)
+                assigned_filter = gr.Textbox(label="Assigned reviewer filter")
+            role_summary = gr.Textbox(label="Review mode", lines=3, interactive=False)
+            refresh_review = gr.Button("Refresh Review Workbench")
+            review_queue = gr.Dataframe(
+                headers=[
+                    "Severity",
+                    "Priority",
+                    "Status",
+                    "Stage",
+                    "Slide",
+                    "Role",
+                    "Issue Type",
+                    "Message",
+                    "Suggested Fix",
+                    "Assigned To",
+                    "Created At",
+                    "Issue ID",
+                ],
+                interactive=False,
+                elem_classes=["compact-panel"],
+            )
+            with gr.Row():
+                selected_issue_id = gr.Textbox(label="Issue ID")
+                issue_action = gr.Dropdown(
+                    label="Triage action",
+                    choices=[
+                        ("Acknowledge", "acknowledge"),
+                        ("Mark in progress", "in_progress"),
+                        ("Resolve", "resolve"),
+                        ("Waive", "waive"),
+                        ("Won't fix", "wont_fix"),
+                        ("Reopen", "reopen"),
+                        ("Assign", "assign"),
+                    ],
+                    value="acknowledge",
+                )
+                triage_note = gr.Textbox(label="Reason or note")
+            with gr.Row():
+                assigned_role = gr.Dropdown(label="Assign role", choices=[("No role", "all"), *review_role_options], value="all")
+                assigned_to = gr.Textbox(label="Assign reviewer")
+                triage_issue = gr.Button("Apply Triage")
+                generate_issue_fix = gr.Button("Generate Suggested Fix")
+            suggested_fixes = gr.Dataframe(
+                headers=["Fix ID", "Type", "Stage", "Slides", "Issues", "Risk", "Description"],
+                interactive=False,
+                elem_classes=["compact-panel"],
+            )
+            with gr.Row():
+                fast_generate_grade = gr.Button("Generate + Grade Current Stage")
+                fast_draft_ahead = gr.Button("Draft Ahead Until Review Needed")
+            with gr.Row():
+                packet_stage_ids = gr.Textbox(label="Packet stage IDs")
+                packet_slide_ids = gr.Textbox(label="Packet slide IDs")
+                packet_format = gr.Radio(label="Packet format", choices=[("Markdown", "markdown"), ("JSON", "json")], value="markdown")
+                create_packet = gr.Button("Create Review Packet")
+            reviewer_metrics = gr.Dataframe(headers=["Metric", "Value"], interactive=False, elem_classes=["compact-panel"])
+            issues = gr.Dataframe(
+                headers=["Issue ID", "Type", "Severity", "Stage", "Slide", "Message", "Resolved?"],
+                interactive=False,
+                elem_classes=["compact-panel"],
+            )
+
+        with gr.Group(visible=False, elem_classes=["screen-card"]) as final_workspace:
+            gr.Markdown("### Export Readiness")
+            deck_health = gr.Dataframe(headers=["Metric", "Value"], interactive=False, elem_classes=["compact-panel"])
+            preflight_results = gr.Dataframe(headers=["Field", "Value"], interactive=False, elem_classes=["compact-panel"])
+            stage_status = gr.Dataframe(
+                headers=["#", "Stage", "Score", "Artifact", "Artifact Status", "Stale?", "Can Unlock Next?", "Lock Reasons"],
+                interactive=False,
+                elem_classes=["compact-panel"],
+            )
+
+        with gr.Group(visible=False, elem_classes=["screen-card"]) as audit_workspace:
+            gr.Markdown("### Audit & Version Details")
+            with gr.Row():
+                restore_artifact_id = gr.Textbox(label="Artifact version ID")
+            audit = gr.Dataframe(
+                headers=["Event ID", "Type", "Timestamp", "Stage", "Slide", "Issue", "Reason"],
+                interactive=False,
+                elem_classes=["compact-panel"],
+            )
+            state_json = gr.Textbox(label="State", lines=18, interactive=False)
+
+        with gr.Group(visible=False, elem_classes=["screen-card"]) as history_workspace:
+            gr.Markdown("### Version History")
+            semantic_compare = gr.Button("Compare Latest Versions")
+            semantic_diff = gr.Textbox(label="Semantic diff", lines=8, interactive=False)
+            prompt_runs = gr.Dataframe(
+                headers=[
+                    "Prompt Run ID",
+                    "Created At",
+                    "Stage",
+                    "Provider",
+                    "Model",
+                    "Template",
+                    "Inputs",
+                    "Output",
+                    "Settings",
+                ],
+                interactive=False,
+                elem_classes=["compact-panel"],
+            )
+            prompt_run_id = gr.Textbox(label="Prompt run ID")
+            prompt_detail = gr.Textbox(label="Prompt run detail", lines=8, interactive=False)
 
         outputs = [
             state_store,
@@ -1040,6 +1514,15 @@ def build_app() -> gr.Blocks:
             prompt_runs,
             prompt_detail,
             reviewer_metrics,
+            workflow_header,
+            stage_score_strip,
+            *stage_screens,
+            artifact_workspace,
+            review_workspace,
+            final_workspace,
+            audit_workspace,
+            history_workspace,
+            *stage_nav_buttons,
         ]
         setup_inputs = [
             state_store,
@@ -1113,44 +1596,62 @@ def build_app() -> gr.Blocks:
             blocked_fields,
             reviewer_instruction,
         ]
-        start_path_outputs = [
-            start_mode,
-            selected_start_path,
-            instructions_panel,
-            outline_panel,
-            draft_panel,
-        ]
+        start_path_outputs = [start_mode, selected_start_path, instructions_panel, outline_panel, draft_panel]
+        nav_outputs = [stage_id, queue_stage, review_role, *outputs]
 
-        demo.load(
-            handle_update_setup,
-            inputs=setup_inputs,
-            outputs=outputs,
-            show_progress="hidden",
-        )
+        def _nav_handler(target_stage_id):
+            def _handle(state_data):
+                return handle_stage_nav(state_data, target_stage_id)
+
+            return _handle
+
+        demo.load(handle_update_setup, inputs=setup_inputs, outputs=outputs, show_progress="hidden")
         instructions_path.click(select_instructions_path, inputs=[], outputs=start_path_outputs)
         outline_path.click(select_outline_path, inputs=[], outputs=start_path_outputs)
         draft_path.click(select_draft_path, inputs=[], outputs=start_path_outputs)
+
+        for button, target_stage_id in zip(stage_nav_buttons, STAGE_IDS, strict=True):
+            button.click(_nav_handler(target_stage_id), inputs=[state_store], outputs=nav_outputs, show_progress="hidden")
+
         update_setup.click(handle_update_setup, inputs=setup_inputs, outputs=outputs)
-        generate.click(handle_generate, inputs=setup_inputs, outputs=outputs)
-        grade.click(handle_grade, inputs=[state_store, stage_id], outputs=outputs)
-        save_edits.click(
-            handle_save_edits,
-            inputs=[
-                state_store,
-                stage_id,
-                artifact_editor,
-                reviewer_name,
-                reviewer_summary,
-                requested_changes_json,
-            ],
-            outputs=outputs,
-        )
-        improve.click(handle_improve, inputs=[state_store, stage_id], outputs=outputs)
-        approve.click(handle_approve, inputs=[state_store, stage_id, reviewer_name, review_role], outputs=outputs)
-        preflight.click(handle_preflight, inputs=[state_store, stage_id], outputs=outputs)
+        for button in [
+            setup_generate,
+            source_generate,
+            outline_generate,
+            title_generate,
+            text_generate,
+            image_generate,
+            layout_generate,
+        ]:
+            button.click(handle_generate, inputs=setup_inputs, outputs=outputs)
+        for button in [source_grade, outline_grade, title_grade, text_grade, image_grade, layout_grade]:
+            button.click(handle_grade, inputs=[state_store, stage_id], outputs=outputs)
+        for button in [text_improve, image_improve, layout_improve]:
+            button.click(handle_improve, inputs=[state_store, stage_id], outputs=outputs)
+        for button in [
+            source_approve,
+            outline_approve,
+            title_approve,
+            text_approve,
+            image_approve,
+            layout_approve,
+            technical_approve,
+            pedagogical_approve,
+            aesthetic_approve,
+        ]:
+            button.click(handle_approve, inputs=[state_store, stage_id, reviewer_name, review_role], outputs=outputs)
+        for button in [title_save_edits, text_save_edits]:
+            button.click(
+                handle_save_edits,
+                inputs=[state_store, stage_id, artifact_editor, reviewer_name, reviewer_summary, requested_changes_json],
+                outputs=outputs,
+            )
+        for button in [setup_preflight, final_preflight]:
+            button.click(handle_preflight, inputs=[state_store, stage_id], outputs=outputs)
         export.click(handle_export, inputs=[state_store, stage_id], outputs=outputs)
-        stage_id.change(handle_stage_change, inputs=[state_store, stage_id], outputs=outputs)
-        refresh_review.click(handle_review_refresh, inputs=review_filter_inputs, outputs=outputs)
+
+        for button in [refresh_review, technical_refresh, pedagogical_refresh, aesthetic_refresh]:
+            button.click(handle_review_refresh, inputs=review_filter_inputs, outputs=outputs)
         for filter_component in [
             review_role,
             queue_stage,
@@ -1161,28 +1662,15 @@ def build_app() -> gr.Blocks:
             selected_change_set_id,
             prompt_run_id,
         ]:
-            filter_component.change(
-                handle_review_refresh,
-                inputs=review_filter_inputs,
-                outputs=outputs,
-                show_progress="hidden",
-            )
+            filter_component.change(handle_review_refresh, inputs=review_filter_inputs, outputs=outputs, show_progress="hidden")
         triage_issue.click(handle_triage_issue, inputs=triage_inputs, outputs=outputs)
-        generate_issue_fix.click(handle_suggested_fix, inputs=suggested_fix_inputs, outputs=outputs)
-        propose_with_constraints.click(
-            handle_propose_with_constraints,
-            inputs=[state_store, stage_id, *constraint_inputs],
-            outputs=outputs,
-        )
+        for button in [generate_issue_fix, technical_fix, pedagogical_fix, aesthetic_fix]:
+            button.click(handle_suggested_fix, inputs=suggested_fix_inputs, outputs=outputs)
+
+        propose_with_constraints.click(handle_propose_with_constraints, inputs=[state_store, stage_id, *constraint_inputs], outputs=outputs)
         targeted_improvement.click(
             handle_targeted_improvement,
-            inputs=[
-                state_store,
-                stage_id,
-                targeted_slide_ids,
-                targeted_action,
-                *constraint_inputs,
-            ],
+            inputs=[state_store, stage_id, targeted_slide_ids, targeted_action, *constraint_inputs],
             outputs=outputs,
         )
         apply_changes.click(
@@ -1195,27 +1683,13 @@ def build_app() -> gr.Blocks:
             inputs=[state_store, stage_id, selected_change_set_id, reviewer_name, triage_note],
             outputs=outputs,
         )
-        fast_generate_grade.click(
-            handle_fast_generate_grade,
-            inputs=[state_store, stage_id],
-            outputs=outputs,
-        )
-        fast_draft_ahead.click(
-            handle_fast_draft_ahead,
-            inputs=[state_store, stage_id],
-            outputs=outputs,
-        )
-        semantic_compare.click(handle_semantic_compare, inputs=[state_store, stage_id], outputs=outputs)
+        for button in [semantic_compare, layout_compare, audit_compare]:
+            button.click(handle_semantic_compare, inputs=[state_store, stage_id], outputs=outputs)
+        fast_generate_grade.click(handle_fast_generate_grade, inputs=[state_store, stage_id], outputs=outputs)
+        fast_draft_ahead.click(handle_fast_draft_ahead, inputs=[state_store, stage_id], outputs=outputs)
         create_packet.click(
             handle_review_packet,
-            inputs=[
-                state_store,
-                stage_id,
-                review_role,
-                packet_stage_ids,
-                packet_slide_ids,
-                packet_format,
-            ],
+            inputs=[state_store, stage_id, review_role, packet_stage_ids, packet_slide_ids, packet_format],
             outputs=outputs,
         )
         restore_candidate.click(

tests/test_app_ui.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from app import render_stage_score_strip, stage_score_rows, workflow_progress_summary
+from course_slide_factory.constants import STAGE_IDS
+from course_slide_factory.models import IssueSeverity, IssueType
+from course_slide_factory.quality import approve_current_artifact, upsert_issue
+from course_slide_factory.workflow import build_empty_state, generate_stage
+
+
+def test_workflow_progress_summary_starts_empty():
+    state = build_empty_state(deck_title="UI Test", source_url="mock://source")
+
+    summary = workflow_progress_summary(state)
+    rows = stage_score_rows(state, "setup_inputs")
+
+    assert summary["complete"] == 0
+    assert summary["total"] == len(STAGE_IDS)
+    assert summary["percent"] == 0
+    assert rows[0]["stage_id"] == "setup_inputs"
+    assert rows[0]["active"]
+    assert rows[0]["score"] is None
+    assert rows[0]["status"] == "pending"
+
+
+def test_stage_score_rows_track_complete_review_stale_and_blockers():
+    state = build_empty_state(deck_title="UI Test", source_url="mock://source")
+    state, _message = generate_stage(state, "setup_inputs")
+    state.stages["setup_inputs"].score = 92
+    approve_current_artifact(state, "setup_inputs")
+
+    state, _message = generate_stage(state, "text_generation")
+    state.stages["text_generation"].score = 72
+    state.stages["title_generation"].is_stale = True
+    upsert_issue(
+        state,
+        IssueType.TECHNICAL_INACCURACY,
+        IssueSeverity.BLOCKER,
+        "Blocking issue",
+        stage_id="technical_review",
+    )
+    state.stages["technical_review"].is_stale = False
+
+    summary = workflow_progress_summary(state)
+    rows = {row["stage_id"]: row for row in stage_score_rows(state, "text_generation")}
+    score_strip = render_stage_score_strip(state, "text_generation")
+
+    assert summary["complete"] == 1
+    assert summary["percent"] == round(1 / len(STAGE_IDS) * 100)
+    assert summary["unresolved_blockers"] >= 1
+    assert rows["setup_inputs"]["status"] == "complete"
+    assert rows["text_generation"]["status"] == "review"
+    assert rows["text_generation"]["active"]
+    assert rows["title_generation"]["status"] == "stale"
+    assert rows["technical_review"]["status"] == "blocked"
+    assert "Text" in score_strip
+    assert "72/100" in score_strip