agentloop-profiler 0.1.0__py3-none-any.whl

dashboard/app.py

@@ -0,0 +1,922 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pandas as pd
+import streamlit as st
+
+from agentloop.ci import build_ci_report, ci_report_to_markdown
+from agentloop.costs import format_cost_usd
+from agentloop.demo import run_baseline, run_langgraph_style, run_optimized, run_proof_pair
+from agentloop.findings import build_diagnosis
+from agentloop.issues import build_issue_drafts, issue_drafts_to_markdown
+from agentloop.operations import operation_kind
+from agentloop.optimizer import build_optimization_plan
+from agentloop.patches import RepositoryPathError, build_patch_plan
+from agentloop.quality import (
+    QualityValidationError,
+    build_quality_report,
+    parse_quality_fixtures,
+    quality_report_to_markdown,
+)
+from agentloop.ranking import SORT_FIELDS, sort_ranked
+from agentloop.replay import ReplayGates, build_replay_report
+from agentloop.store import (
+    ALLOWED_FINDING_TRANSITIONS,
+    FindingNotFoundError,
+    FindingTransitionError,
+    get_store,
+)
+from agentloop.tracer import AgentTrace
+from agentloop.value import build_value_report
+
+try:
+    from dashboard.trace_upload import TraceUploadError, parse_uploaded_trace
+    from dashboard.value_view import assumption_inputs, percentage, render_value_report
+except ModuleNotFoundError:
+    from trace_upload import TraceUploadError, parse_uploaded_trace
+    from value_view import assumption_inputs, percentage, render_value_report
+
+st.set_page_config(page_title="AgentLoop Dashboard", layout="wide")
+
+runs_dir = Path("runs")
+runs_dir.mkdir(parents=True, exist_ok=True)
+
+
+@st.cache_resource
+def load_store():
+    db = get_store()
+    db.init()
+    return db
+
+
+def money(value: float | None) -> str:
+    return "unavailable" if value is None else f"${float(value):,.4f}"
+
+
+def seconds(ms: float | None) -> str:
+    return "unavailable" if ms is None else f"{float(ms) / 1000:,.2f}s"
+
+
+def render_estimate_details(item: dict) -> None:
+    if item.get("evidence_level"):
+        st.write(f"Evidence level: {item['evidence_level']}")
+    estimate = item.get("estimate")
+    if estimate:
+        calibration = "calibrated" if estimate.get("calibrated") is True else "uncalibrated"
+        st.write(
+            f"Estimator: {estimate['estimator_id']} version {estimate['estimator_version']} "
+            f"({estimate['method']}, {calibration}; predicted savings)"
+        )
+        st.write("Assumptions: " + "; ".join(estimate.get("assumptions", [])))
+        st.caption(estimate["formula"])
+        st.json(
+            {"parameters": estimate.get("parameters", {}), "inputs": estimate.get("inputs", {})}
+        )
+    elif item.get("evidence_level"):
+        st.write("Assumptions: " + "; ".join(item.get("assumptions", [])))
+        st.caption(item.get("estimate_formula") or item.get("savings", {}).get("formula", ""))
+
+
+def load_trace_for_project(run_id: str, project_id: str) -> AgentTrace | None:
+    return load_store().get_trace(run_id=run_id, project_id=project_id)
+
+
+def select_trace(traces: list[dict], label: str = "Choose trace") -> AgentTrace | None:
+    labels = {f"{t['name']} · {t['run_id']}": t["run_id"] for t in traces}
+    selected_label = st.selectbox(label, list(labels.keys()))
+    return load_trace_for_project(labels[selected_label], project_id)
+
+
+def trace_options(traces: list[dict]) -> dict[str, str]:
+    return {f"{t['name']} - {t['run_id']}": t["run_id"] for t in traces}
+
+
+def selected_trace_from_options(traces: list[dict], label: str) -> AgentTrace | None:
+    options = trace_options(traces)
+    selected = st.selectbox(label, list(options.keys()))
+    return load_trace_for_project(options[selected], project_id)
+
+
+def render_gate_table(results: list[dict]) -> None:
+    rows = [
+        {
+            "gate": item["name"],
+            "status": "pass" if item["passed"] else "fail",
+            "detail": item["detail"],
+        }
+        for item in results
+    ]
+    st.dataframe(pd.DataFrame(rows), width="stretch", hide_index=True)
+
+
+st.sidebar.title("AgentLoop")
+st.sidebar.caption("Execution profiling and evidence")
+
+project_id = st.sidebar.text_input("Project", value=st.session_state.get("project_id", "default"))
+st.session_state["project_id"] = project_id
+
+page = st.sidebar.radio(
+    "Navigate",
+    [
+        "Overview",
+        "Traces",
+        "Optimization Queue",
+        "Optimization",
+        "Diagnosis",
+        "Patch Plan",
+        "Replay Proof",
+        "Quality Gates",
+        "Value & Pricing",
+        "API Keys",
+        "Ingest",
+        "Setup",
+    ],
+)
+
+store = load_store()
+
+st.title("AgentLoop Dashboard")
+st.caption("Cost, latency, and execution-graph optimization for production AI agents")
+
+if page == "Overview":
+    summary = store.usage_summary(project_id=project_id)
+    traces = store.list_traces(project_id=project_id)
+
+    c1, c2, c3, c4 = st.columns(4)
+    c1.metric("Runs", int(summary.get("run_count", 0)))
+    c2.metric("Total runtime", seconds(summary.get("total_runtime_ms", 0)))
+    c3.metric(
+        "Estimated LLM cost",
+        format_cost_usd(summary.get("estimated_cost_usd"), summary.get("cost_status", "complete")),
+    )
+    c4.metric("Retries", int(summary.get("retry_count", 0)))
+
+    c5, c6, c7, c8 = st.columns(4)
+    c5.metric("Input tokens", int(summary.get("input_tokens", 0)))
+    c6.metric("Output tokens", int(summary.get("output_tokens", 0)))
+    c7.metric("Model calls", int(summary.get("model_call_count", 0)))
+    c8.metric("Tool calls", int(summary.get("tool_call_count", 0)))
+
+    st.subheader("Recent runs")
+    if traces:
+        df = pd.DataFrame(traces)
+        st.dataframe(df, width="stretch")
+
+        chart_df = df[["name", "total_runtime_ms"]].copy()
+        chart_df["runtime_s"] = chart_df["total_runtime_ms"] / 1000
+        st.subheader("Runtime by run")
+        st.bar_chart(chart_df, x="name", y="runtime_s")
+    else:
+        st.info(
+            "No stored traces yet. Use the Ingest page or run "
+            "`uv run agentloop store-trace --path TRACE.json`."
+        )
+
+elif page == "Traces":
+    st.subheader("Stored traces")
+
+    cursor_key = f"traces_cursor_stack::{project_id}"
+    if cursor_key not in st.session_state:
+        st.session_state[cursor_key] = [None]  # cursor to fetch the *current* page
+
+    page_index = len(st.session_state[cursor_key]) - 1
+    page_size = st.number_input("Page size", min_value=5, max_value=200, value=25, step=5)
+    page = store.list_traces_page(
+        project_id=project_id, limit=int(page_size), cursor=st.session_state[cursor_key][-1]
+    )
+    traces = page["items"]
+
+    nav_cols = st.columns([1, 1, 6])
+    if nav_cols[0].button("◀ Previous", disabled=page_index == 0):
+        st.session_state[cursor_key].pop()
+        st.rerun()
+    if nav_cols[1].button("Next ▶", disabled=page["next_cursor"] is None):
+        st.session_state[cursor_key].append(page["next_cursor"])
+        st.rerun()
+    st.caption(f"Page {page_index + 1}")
+
+    if not traces:
+        st.info("No traces stored for this project yet.")
+    else:
+        df = pd.DataFrame(traces)
+        st.dataframe(df, width="stretch")
+        selected_run = st.selectbox("Open run", df["run_id"].tolist())
+        trace = load_trace_for_project(selected_run, project_id)
+        if trace is not None:
+            report = trace.report()
+            st.markdown(f"### {trace.name}")
+            if report.get("execution") is not None:
+                execution = report["execution"]
+                st.caption(
+                    f"Workflow {execution.get('workflow_id', 'unknown')} · version {execution.get('version', 'unknown')} · {execution.get('status', 'unknown')}"
+                )
+                with st.expander("Workflow references"):
+                    st.json(execution)
+            c1, c2, c3, c4 = st.columns(4)
+            c1.metric("Runtime", seconds(report["total_runtime_ms"]))
+            c2.metric(
+                "Recorded model cost" if "execution" in report else "Cost",
+                format_cost_usd(report["estimated_cost_usd"], report.get("cost_status")),
+            )
+            c3.metric("Model calls", report["model_call_count"])
+            c4.metric("Tool calls", report["tool_call_count"])
+
+            events = pd.DataFrame(report["events"])
+            st.subheader("Event timeline")
+            if not events.empty:
+                cols = [
+                    "event_type",
+                    "name",
+                    "duration_ms",
+                    "model",
+                    "input_tokens",
+                    "output_tokens",
+                    "status",
+                ]
+                if "execution" in report or "stages" in report:
+                    events["operation_kind"] = [operation_kind(event) for event in trace.events]
+                    summaries = [
+                        report.get("stages", {}).get(event.event_id, {}) for event in trace.events
+                    ]
+                    stage_columns = {
+                        "Stage": "stage_id",
+                        "Stage kind": "kind",
+                        "Stage version": "version",
+                        "Input schema": "input_schema_ref",
+                        "Output schema": "output_schema_ref",
+                        "Input reference": "input_ref",
+                        "Output reference": "output_ref",
+                        "Outcome": "outcome",
+                        "Dependencies": "depends_on",
+                    }
+                    for label, key in stage_columns.items():
+                        events[label] = [value.get(key) for value in summaries]
+                    cols = [
+                        "operation_kind",
+                        "Stage",
+                        "Stage kind",
+                        "Stage version",
+                        "parent_id",
+                        *cols,
+                        "Input schema",
+                        "Output schema",
+                        "Input reference",
+                        "Output reference",
+                        "Outcome",
+                        "Dependencies",
+                    ]
+                for col in cols:
+                    if col not in events.columns:
+                        events[col] = None
+                st.dataframe(events[cols], width="stretch")
+
+            st.download_button(
+                "Download trace JSON",
+                data=json.dumps(trace.to_dict(), indent=2),
+                file_name=f"{trace.run_id}.json",
+                mime="application/json",
+            )
+
+elif page == "Optimization Queue":
+    st.subheader("Optimization queue")
+    dimension = st.selectbox(
+        "Sort investigations by", SORT_FIELDS, format_func=lambda value: value.replace("_", " ")
+    )
+    queue = sort_ranked(store.optimization_queue(project_id=project_id), dimension)
+    findings = store.list_findings(project_id=project_id)
+
+    c1, c2, c3, c4 = st.columns(4)
+    c1.metric("Open opportunities", len(queue))
+    c2.metric("Persisted findings", len(findings))
+    c3.metric("Patchable findings", sum(1 for finding in findings if finding["patchable"]))
+    c4.metric(
+        "Estimated latency savings",
+        seconds(
+            None
+            if any(item["estimated_latency_savings_ms"] is None for item in queue)
+            else sum(item["estimated_latency_savings_ms"] for item in queue)
+        ),
+    )
+
+    if not queue:
+        st.info(
+            "No optimization opportunities have been persisted yet. Store traces or run diagnosis first."
+        )
+    else:
+        queue_df = pd.DataFrame(queue)
+        queue_df["readiness"] = [item["ranking"]["status"].replace("_", " ") for item in queue]
+        visible_cols = [
+            "priority_score",
+            "readiness",
+            "severity",
+            "type",
+            "title",
+            "occurrence_count",
+            "run_count",
+            "patchable_count",
+            "quality_risk",
+            "requires_scorer",
+            "safe_to_auto_patch",
+            "estimated_latency_savings_ms",
+            "estimated_cost_savings_usd",
+        ]
+        st.dataframe(queue_df[visible_cols], width="stretch", hide_index=True)
+
+        selected_title = st.selectbox("Open queue item", queue_df["title"].tolist())
+        item = next(row for row in queue if row["title"] == selected_title)
+        st.markdown(f"### {item['title']}")
+        c5, c6, c7, c8 = st.columns(4)
+        c5.metric("Investigation rank", item["ranking"]["priority_rank"])
+        c6.metric("Severity", item["severity"])
+        c7.metric("Affected runs", item["run_count"])
+        c8.metric("Patchable", item["patchable_count"])
+        st.write(f"Type: `{item['type']}`")
+        st.write(f"Status: `{item['status']}`")
+        st.write(f"Quality risk: `{item['quality_risk']}`")
+        st.write("Test readiness: " + item["ranking"]["status"].replace("_", " "))
+        with st.expander("Ranking inputs and provenance"):
+            st.json(item["ranking"])
+        st.write(f"Requires scorer: `{item['requires_scorer']}`")
+        st.write(f"Safe to auto-patch: `{item['safe_to_auto_patch']}`")
+        st.write(
+            f"Estimated savings: {seconds(item['estimated_latency_savings_ms'])} / {money(item['estimated_cost_savings_usd'])}"
+        )
+        st.write("Affected runs")
+        st.code("\n".join(item["affected_runs"]), language="text")
+
+        item_findings = [
+            finding
+            for finding in findings
+            if finding["type"] == item["type"] and finding["title"] == item["title"]
+        ]
+        if item_findings:
+            st.subheader("Finding instances")
+            st.dataframe(pd.DataFrame(item_findings), width="stretch", hide_index=True)
+
+            st.markdown("**Update finding status**")
+            finding_labels = {
+                f"{f['run_id']} · {f['finding_id']} (currently {f['status']})": f
+                for f in item_findings
+            }
+            selected_finding_label = st.selectbox(
+                "Finding", list(finding_labels.keys()), key=f"finding_select_{item['queue_id']}"
+            )
+            selected_finding = finding_labels[selected_finding_label]
+            allowed_targets = sorted(
+                ALLOWED_FINDING_TRANSITIONS.get(selected_finding["status"], ())
+            )
+            if allowed_targets:
+                new_status = st.selectbox(
+                    "New status", allowed_targets, key=f"status_select_{item['queue_id']}"
+                )
+                if st.button("Apply transition", key=f"apply_transition_{item['queue_id']}"):
+                    try:
+                        store.update_finding_status(
+                            project_id,
+                            selected_finding["run_id"],
+                            selected_finding["finding_id"],
+                            new_status,
+                        )
+                    except (FindingNotFoundError, FindingTransitionError) as exc:
+                        st.error(str(exc))
+                    else:
+                        st.success(f"{selected_finding['finding_id']} is now {new_status}")
+                        st.rerun()
+            else:
+                st.caption(f"No transitions available from '{selected_finding['status']}'.")
+
+        st.download_button(
+            "Download optimization queue JSON",
+            data=json.dumps({"project_id": project_id, "queue": queue}, indent=2),
+            file_name="agentloop_optimization_queue.json",
+            mime="application/json",
+        )
+
+        st.subheader("GitHub issue drafts")
+        drafts = build_issue_drafts(queue)
+        if not drafts:
+            st.info("No patchable queue items available for issue drafts.")
+        else:
+            selected_issue = st.selectbox(
+                "Preview issue draft", [draft["title"] for draft in drafts]
+            )
+            draft = next(item for item in drafts if item["title"] == selected_issue)
+            st.write(f"Labels: `{', '.join(draft['labels'])}`")
+            st.code(draft["body"], language="markdown")
+            st.download_button(
+                "Download issue drafts Markdown",
+                data=issue_drafts_to_markdown(drafts),
+                file_name="agentloop_issue_drafts.md",
+                mime="text/markdown",
+            )
+
+elif page == "Optimization":
+    traces = store.list_traces(project_id=project_id)
+    st.subheader("Optimization plans")
+    if not traces:
+        st.info("No traces stored for this project yet.")
+    else:
+        trace = select_trace(traces)
+        if trace is not None:
+            report = trace.report()
+            plan = build_optimization_plan(trace, report)
+            if (
+                plan.get("savings_aggregation", {}).get("latency_estimate_complete") is False
+                or plan.get("savings_aggregation", {}).get("cost_estimate_complete") is False
+            ):
+                st.caption("Some savings are unavailable; totals cover modeled candidates only.")
+            current = plan["current"]
+            after = plan["estimated_after"]
+
+            c1, c2, c3, c4 = st.columns(4)
+            c1.metric("Current runtime", seconds(current["runtime_ms"]))
+            c2.metric("Estimated runtime", seconds(after["runtime_ms"]))
+            c3.metric("Latency reduction", f"{after['latency_reduction_pct']:.1f}%")
+            c4.metric("Cost reduction", percentage(after["cost_reduction_pct"]))
+
+            with st.expander("Show value and pricing estimate", expanded=False):
+                rpm, rate, incident_cost = assumption_inputs("optimization_")
+                value = build_value_report(
+                    trace,
+                    runs_per_month=rpm,
+                    engineer_hourly_rate_usd=rate,
+                    incident_cost_usd=incident_cost,
+                )
+                render_value_report(value, show_download=False)
+
+            st.subheader("Optimization cards")
+            if plan.get("rule_errors"):
+                st.warning(
+                    "Analysis incomplete; failed rules: "
+                    + ", ".join(error["rule_id"] for error in plan["rule_errors"])
+                )
+            cards = plan["optimization_cards"]
+            if not cards:
+                st.info("No major optimization cards detected yet.")
+            for card in cards:
+                with st.expander(
+                    f"{card['title']} · confidence: {card['confidence']}", expanded=True
+                ):
+                    st.write(card["why"])
+                    render_estimate_details(card)
+                    st.code(card["rewrite_hint"])
+                    st.write(
+                        f"Estimated latency savings: {seconds(card['estimated_latency_savings_ms'])}"
+                    )
+                    st.write(f"Estimated cost savings: {money(card['estimated_cost_savings_usd'])}")
+
+            st.subheader("Execution graph")
+            graph = plan["graph"]
+            if graph.get("execution") is not None:
+                st.json(graph["execution"])
+            if graph.get("dependency_evidence") is not None:
+                st.json(graph["dependency_evidence"])
+            st.write("Bottlenecks")
+            st.dataframe(pd.DataFrame(graph["bottlenecks"]), width="stretch")
+            st.write("Parallelization candidates")
+            if graph["parallelizable_groups"]:
+                st.dataframe(pd.DataFrame(graph["parallelizable_groups"]), width="stretch")
+            else:
+                st.info(
+                    "No repeated tool-call groups currently qualify as parallelization candidates."
+                )
+            st.write("Edges")
+            st.dataframe(pd.DataFrame(graph["edges"]), width="stretch")
+
+            st.download_button(
+                "Download optimization plan JSON",
+                data=json.dumps(plan, indent=2),
+                file_name="agentloop_optimization_plan.json",
+                mime="application/json",
+            )
+
+elif page == "Diagnosis":
+    traces = store.list_traces(project_id=project_id)
+    st.subheader("Machine-actionable diagnosis")
+    if not traces:
+        st.info("No traces stored for this project yet.")
+    else:
+        trace = selected_trace_from_options(traces, "Choose trace for diagnosis")
+        if trace is not None:
+            dimension = st.selectbox(
+                "Sort findings by", SORT_FIELDS, format_func=lambda value: value.replace("_", " ")
+            )
+            diagnosis = build_diagnosis(trace, sort_by=dimension)
+            if diagnosis.get("rule_errors"):
+                st.warning(
+                    "Analysis incomplete; failed rules: "
+                    + ", ".join(error["rule_id"] for error in diagnosis["rule_errors"])
+                )
+            summary = diagnosis["summary"]
+            c1, c2, c3, c4 = st.columns(4)
+            c1.metric("Findings", summary["finding_count"])
+            c2.metric("High severity", summary["high_severity_count"])
+            c3.metric("Patchable", summary["patchable_count"])
+            c4.metric("Latency reduction", f"{summary['estimated_latency_reduction_pct']:.1f}%")
+
+            findings = diagnosis.get("findings", [])
+            if not findings:
+                st.info("No machine-actionable findings detected for this trace.")
+            for finding in findings:
+                label = f"{finding['severity'].upper()} - {finding['title']} ({finding['type']})"
+                with st.expander(label, expanded=finding["severity"] == "high"):
+                    st.write(finding["metadata"].get("why", ""))
+                    render_estimate_details(finding)
+                    st.write("Test readiness: " + finding["ranking"]["status"].replace("_", " "))
+                    st.json(finding["ranking"])
+                    st.write(f"Finding ID: `{finding['finding_id']}`")
+                    st.write(f"Confidence: `{finding['confidence']}`")
+                    st.write(f"Affected spans: `{', '.join(finding['affected_spans'])}`")
+                    st.write(f"Rewrite: {finding['rewrite']['hint']}")
+                    st.write(f"Validation: {finding['validation']['acceptance_criteria']}")
+                    st.write(
+                        "Estimated savings: "
+                        f"{seconds(finding['savings']['estimated_latency_savings_ms'])}, "
+                        f"{money(finding['savings']['estimated_cost_savings_usd'])}"
+                    )
+                    if finding["evidence"]:
+                        st.dataframe(
+                            pd.DataFrame(finding["evidence"]), width="stretch", hide_index=True
+                        )
+
+            st.download_button(
+                "Download diagnosis JSON",
+                data=json.dumps(diagnosis, indent=2),
+                file_name="agentloop_diagnosis.json",
+                mime="application/json",
+            )
+
+elif page == "Patch Plan":
+    traces = store.list_traces(project_id=project_id)
+    st.subheader("Trace-to-patch planning")
+    if not traces:
+        st.info("No traces stored for this project yet.")
+    else:
+        trace = selected_trace_from_options(traces, "Choose trace for patch planning")
+        repo_path = st.text_input("Repository path", value=str(Path.cwd()))
+        if trace is not None:
+            try:
+                plan = build_patch_plan(trace, repo_path=repo_path)
+            except RepositoryPathError as exc:
+                # The path is free text re-read on every rerun, so a half-typed one
+                # reaches build_patch_plan before the operator has finished editing.
+                # Only the path error is caught: anything else planning raises is a
+                # bug in planning, and swallowing it here would hide it.
+                st.error(f"Fix the repository path: {exc}.")
+                st.stop()
+            summary = plan["summary"]
+            c1, c2, c3 = st.columns(3)
+            c1.metric("Patch plans", summary["patch_count"])
+            c2.metric("Unsupported", summary["unsupported_finding_count"])
+            c3.metric("Frameworks", ", ".join(summary["frameworks_detected"]) or "none")
+
+            for item in plan.get("patch_plans", []):
+                with st.expander(f"{item['patch_id']} - {item['title']}", expanded=True):
+                    st.write(f"Type: `{item['type']}`")
+                    st.write(f"Risk: `{item['risk']}`")
+                    st.write(f"Framework: `{item['framework']}`")
+                    st.write(f"Finding: `{item['finding_id']}`")
+                    st.write(f"Before pattern: {item['before_pattern']}")
+                    st.write(f"Proposed rewrite: {item['proposed_rewrite']}")
+                    st.code(item["suggested_diff"], language="text")
+                    st.write(f"Validation command: `{item['validation_command']}`")
+                    st.write(f"Acceptance: {item['acceptance_criteria']}")
+                    if item["files"]:
+                        st.dataframe(pd.DataFrame(item["files"]), width="stretch", hide_index=True)
+                    if item["notes"]:
+                        for note in item["notes"]:
+                            st.write(f"- {note}")
+
+            if plan.get("unsupported_findings"):
+                st.subheader("Unsupported findings")
+                st.dataframe(
+                    pd.DataFrame(plan["unsupported_findings"]), width="stretch", hide_index=True
+                )
+
+            st.download_button(
+                "Download patch plan JSON",
+                data=json.dumps(plan, indent=2),
+                file_name="agentloop_patch_plan.json",
+                mime="application/json",
+            )
+
+elif page == "Replay Proof":
+    traces = store.list_traces(project_id=project_id)
+    st.subheader("Before/after replay proof")
+    if len(traces) < 2:
+        st.info("Store at least two traces to compare a baseline and candidate.")
+    else:
+        options = trace_options(traces)
+        labels = list(options.keys())
+        baseline_label = st.selectbox("Baseline trace", labels, index=0)
+        candidate_label = st.selectbox("Candidate trace", labels, index=1 if len(labels) > 1 else 0)
+        baseline = load_trace_for_project(options[baseline_label], project_id)
+        candidate = load_trace_for_project(options[candidate_label], project_id)
+
+        st.markdown("#### Gates")
+        g1, g2, g3, g4 = st.columns(4)
+        min_latency = g1.number_input("Min latency improvement %", min_value=0.0, value=20.0)
+        min_cost = g2.number_input("Min cost improvement %", min_value=0.0, value=5.0)
+        require_schema = g3.checkbox("Require schema valid", value=False)
+        min_quality = g4.number_input("Min quality score", min_value=0.0, max_value=1.0, value=0.0)
+        quality_threshold = min_quality if min_quality > 0 else None
+
+        if baseline is not None and candidate is not None:
+            gates = ReplayGates(
+                min_latency_improvement_pct=min_latency,
+                min_cost_improvement_pct=min_cost,
+                require_schema_valid=require_schema,
+                min_quality_score=quality_threshold,
+            )
+            replay = build_replay_report(baseline, candidate, gates=gates)
+            ci_report = build_ci_report(baseline, candidate, gates=gates)
+            status = "passed" if replay["gates"]["passed"] else "failed"
+            c1, c2, c3, c4 = st.columns(4)
+            c1.metric("Status", status)
+            c2.metric("Latency improvement", f"{replay['deltas']['latency_improvement_pct']:.1f}%")
+            cost_improvement = replay["deltas"]["cost_improvement_pct"]
+            c3.metric("Cost improvement", percentage(cost_improvement))
+            c4.metric("Retry delta", replay["deltas"]["retry_count_delta"])
+
+            st.subheader("Gate results")
+            render_gate_table(replay["gates"]["results"])
+
+            st.subheader("Metric deltas")
+            metric_rows = [
+                {"metric": key, "value": value}
+                for key, value in replay["deltas"].items()
+                if key.endswith("_delta") or key.endswith("_pct")
+            ]
+            st.dataframe(pd.DataFrame(metric_rows), width="stretch", hide_index=True)
+
+            st.subheader("PR comment preview")
+            st.code(
+                "Trace in. Rewrite plan out. Replay proof in the PR.\n\n"
+                + ci_report_to_markdown(ci_report)
+            )
+
+            col_json, col_md = st.columns(2)
+            col_json.download_button(
+                "Download replay JSON",
+                data=json.dumps(replay, indent=2),
+                file_name="agentloop_replay_report.json",
+                mime="application/json",
+            )
+            col_md.download_button(
+                "Download PR Markdown",
+                data=ci_report_to_markdown(ci_report),
+                file_name="agentloop_ci.md",
+                mime="text/markdown",
+            )
+
+elif page == "Quality Gates":
+    traces = store.list_traces(project_id=project_id)
+    st.subheader("Quality gates")
+    st.caption(
+        "Compare caller-defined quality criteria alongside recorded cost and latency. "
+        "Legacy scorers and versioned structured decision, multilabel, numeric, extraction and matching scorers are supported. Custom Python scorers are trusted local code."
+    )
+    if len(traces) < 2:
+        st.info("Store at least two traces to score baseline and candidate quality.")
+    else:
+        options = trace_options(traces)
+        labels = list(options.keys())
+        default_fixture = [
+            {
+                "id": "required_summary_fields",
+                "input": "Summarize one source.",
+                "candidate_output": {
+                    "summary": "AgentLoop proves rewrites.",
+                    "sources": ["source-a"],
+                },
+                "baseline_output": {
+                    "summary": "AgentLoop proves rewrites.",
+                    "sources": ["source-a"],
+                },
+                "scorer": {"type": "required_fields", "required": ["summary", "sources"]},
+            }
+        ]
+        with st.form("quality_gate_form"):
+            baseline_label = st.selectbox("Baseline trace", labels, index=0, key="quality_baseline")
+            candidate_label = st.selectbox(
+                "Candidate trace",
+                labels,
+                index=1 if len(labels) > 1 else 0,
+                key="quality_candidate",
+            )
+            min_score = st.number_input(
+                "Minimum candidate quality score", min_value=0.0, max_value=1.0, value=0.9
+            )
+            uploaded = st.file_uploader(
+                "Upload quality fixture JSON", type=["json"], key="quality_fixture_upload"
+            )
+            fixtures_text = st.text_area(
+                "Fixture JSON",
+                value=json.dumps({"fixtures": default_fixture}, indent=2),
+                height=260,
+            )
+            submitted = st.form_submit_button("Run quality gate")
+
+        if submitted:
+            try:
+                raw_fixtures = (
+                    uploaded.read().decode("utf-8") if uploaded is not None else fixtures_text
+                )
+                fixtures = parse_quality_fixtures(json.loads(raw_fixtures))
+                baseline = load_trace_for_project(options[baseline_label], project_id)
+                candidate = load_trace_for_project(options[candidate_label], project_id)
+                if baseline is None or candidate is None:
+                    raise QualityValidationError(
+                        "selected baseline or candidate trace is unavailable"
+                    )
+                quality = build_quality_report(
+                    fixtures,
+                    baseline_trace=baseline,
+                    candidate_trace=candidate,
+                    min_score=min_score,
+                )
+            except json.JSONDecodeError as exc:
+                st.error(
+                    "Fix the quality fixture JSON: "
+                    f"{exc.msg} at line {exc.lineno}, column {exc.colno}."
+                )
+            except (UnicodeError, QualityValidationError) as exc:
+                st.error(f"Fix the quality fixture JSON: {exc}.")
+            else:
+                status = "passed" if quality["passed"] else "failed"
+                c1, c2, c3, c4 = st.columns(4)
+                c1.metric("Status", status)
+                c2.metric(
+                    "Candidate score",
+                    "unavailable"
+                    if quality["candidate_score"] is None
+                    else str(quality["candidate_score"])
+                    if quality.get("schema_version") == "2.0"
+                    else f"{quality['candidate_score']:.4f}",
+                )
+                c3.metric(
+                    "Quality delta",
+                    "unavailable"
+                    if quality["quality_delta"] is None
+                    else str(quality["quality_delta"])
+                    if quality.get("schema_version") == "2.0"
+                    else f"{quality['quality_delta']:.4f}",
+                )
+                c4.metric("Failed cases", quality["failed_case_count"])
+                if quality.get("schema_version") == "2.0":
+                    st.caption(
+                        f"Indeterminate cases: {quality['indeterminate_case_count']}; incomplete evidence cannot pass the quality gate."
+                    )
+                    with st.expander("Quality denominators and classification metrics"):
+                        st.json(
+                            {
+                                "summaries": quality["summaries"],
+                                "classification": quality["classification"],
+                            }
+                        )
+                st.dataframe(pd.DataFrame(quality["cases"]), width="stretch", hide_index=True)
+                st.download_button(
+                    "Download quality report JSON",
+                    data=json.dumps(quality, indent=2),
+                    file_name="agentloop_quality_report.json",
+                    mime="application/json",
+                )
+                st.download_button(
+                    "Download quality report Markdown",
+                    data=quality_report_to_markdown(quality),
+                    file_name="agentloop_quality_report.md",
+                    mime="text/markdown",
+                )
+
+elif page == "Value & Pricing":
+    traces = store.list_traces(project_id=project_id)
+    st.subheader("Value report and pricing scenario")
+    st.caption(
+        "Turn an agent trace into operational value, reliability risk, and a configurable pricing scenario."
+    )
+    if not traces:
+        st.info(
+            "No traces stored for this project yet. Generate demo traces from the Ingest page first."
+        )
+    else:
+        trace = select_trace(traces, label="Choose trace for value report")
+        if trace is not None:
+            st.markdown("#### Assumptions")
+            rpm, rate, incident_cost = assumption_inputs("value_page_")
+            value = build_value_report(
+                trace,
+                runs_per_month=rpm,
+                engineer_hourly_rate_usd=rate,
+                incident_cost_usd=incident_cost,
+            )
+            render_value_report(value)
+            st.subheader("CLI command")
+            st.code(
+                "uv run agentloop value-report --path runs/research_agent_baseline.json "
+                f"--runs-per-month {rpm} "
+                f"--engineer-hourly-rate-usd {rate} "
+                f"--incident-cost-usd {incident_cost} "
+                "--out runs/value_report.json",
+                language="bash",
+            )
+
+elif page == "API Keys":
+    st.subheader("Create project API key")
+    st.warning("API keys are only shown once. Copy the generated key before leaving this page.")
+    key_name = st.text_input("Key name", value="local-dev")
+    if st.button("Create API key"):
+        created = store.create_api_key(project_id=project_id, name=key_name)
+        st.success(f"Created key for project `{project_id}`")
+        st.code(created["api_key"])
+
+    st.subheader("Use this key")
+    st.code(
+        "uv run agentloop upload --path runs/research_agent_baseline.json "
+        "--api-url http://127.0.0.1:8000 --api-key YOUR_KEY",
+        language="bash",
+    )
+
+elif page == "Ingest":
+    st.subheader("Generate or upload traces")
+    col_a, col_b, col_c, col_d = st.columns(4)
+    generated_path: Path | None = None
+    if col_a.button("Generate baseline"):
+        generated_path = run_baseline(runs_dir)
+    if col_b.button("Generate optimized"):
+        generated_path = run_optimized(runs_dir)
+    if col_c.button("Generate LangGraph-style"):
+        generated_path = run_langgraph_style(runs_dir)
+    if col_d.button("Generate all"):
+        proof_baseline, proof_candidate = run_proof_pair(runs_dir)
+        for path in [
+            run_baseline(runs_dir),
+            run_optimized(runs_dir),
+            run_langgraph_style(runs_dir),
+            proof_baseline,
+            proof_candidate,
+        ]:
+            store.save_trace(AgentTrace.from_json(path), project_id=project_id)
+        st.success(f"Generated and stored all demo traces under project `{project_id}`")
+
+    if st.button("Generate proof demo pair"):
+        proof_baseline, proof_candidate = run_proof_pair(runs_dir)
+        for path in [proof_baseline, proof_candidate]:
+            store.save_trace(AgentTrace.from_json(path), project_id=project_id)
+        st.success(f"Generated and stored proof demo traces under project `{project_id}`")
+
+    if generated_path is not None:
+        trace = AgentTrace.from_json(generated_path)
+        store.save_trace(trace, project_id=project_id)
+        st.success(f"Generated and stored `{trace.name}` as `{trace.run_id}`")
+
+    uploaded = st.file_uploader("Upload AgentLoop trace JSON", type=["json"])
+    if uploaded is not None:
+        try:
+            trace = parse_uploaded_trace(uploaded.read())
+        except TraceUploadError as exc:
+            st.error(f"Fix the uploaded trace: {exc}.")
+        else:
+            if st.button("Store uploaded trace"):
+                store.save_trace(trace, project_id=project_id)
+                st.success(f"Stored uploaded trace `{trace.run_id}` under project `{project_id}`")
+
+    st.subheader("CLI ingest")
+    st.code(
+        "uv run agentloop demo-all\n"
+        f"uv run agentloop store-trace --path runs/research_agent_baseline.json --project-id {project_id}\n"
+        f"uv run agentloop list-stored-traces --project-id {project_id}",
+        language="bash",
+    )
+
+elif page == "Setup":
+    st.subheader("Local development")
+    st.code(
+        "uv sync --locked --all-extras --dev\n"
+        "uv run agentloop init-store\n"
+        "uv run agentloop demo-all\n"
+        f"uv run agentloop store-trace --path runs/research_agent_baseline.json --project-id {project_id}\n"
+        "uv run streamlit run dashboard/app.py",
+        language="bash",
+    )
+
+    st.subheader("Hosted API")
+    st.code(
+        "uv run agentloop create-api-key --project-id acme --name local-dev\n"
+        "uv run agentloop server --host 127.0.0.1 --port 8000\n"
+        "uv run agentloop upload --path runs/research_agent_baseline.json "
+        "--api-url http://127.0.0.1:8000 --api-key al_xxx\n"
+        "uv run agentloop remote-usage --api-url http://127.0.0.1:8000 --api-key al_xxx",
+        language="bash",
+    )
+
+    st.subheader("Postgres deployment")
+    st.code(
+        "uv sync --locked --extra server --extra postgres --no-dev\n"
+        "export AGENTLOOP_STORE_BACKEND=postgres\n"
+        "export AGENTLOOP_DATABASE_URL=postgresql://agentloop:agentloop@localhost:5432/agentloop\n"
+        "uv run agentloop init-store\n"
+        "uv run agentloop server --host 0.0.0.0 --port 8000",
+        language="bash",
+    )