fluxloop-cli 0.2.26__py3-none-any.whl → 0.2.28__py3-none-any.whl

fluxloop_cli/__init__.py

@@ -2,7 +2,7 @@
 FluxLoop CLI - Command-line interface for running agent simulations.
 """
 
-__version__ = "0.2.26"
+__version__ = "0.2.28"
 
 from .main import app
 

fluxloop_cli/commands/parse.py

@@ -75,6 +75,9 @@ class TraceSummary:
     duration_ms: float
     success: bool
     raw: dict
+    conversation: Optional[List[Dict[str, Any]]] = None
+    conversation_state: Optional[Dict[str, Any]] = None
+    termination_reason: Optional[str] = None
 
     def to_payload(self) -> dict:
         """Return a JSON-serialisable representation of the summary entry."""
@@ -88,6 +91,9 @@ class TraceSummary:
             "duration_ms": self.duration_ms,
             "success": self.success,
             "raw": self.raw,
+            "conversation": self.conversation,
+            "conversation_state": self.conversation_state,
+            "termination_reason": self.termination_reason,
         }
 
 
@@ -164,6 +170,9 @@ def _load_trace_summaries(path: Path) -> Iterable[TraceSummary]:
                 output_text=payload.get("output"),
                 duration_ms=payload.get("duration_ms", 0.0),
                 success=payload.get("success", False),
+                conversation=payload.get("conversation"),
+                conversation_state=payload.get("conversation_state"),
+                termination_reason=payload.get("termination_reason"),
                 raw=payload,
             )
 
@@ -214,6 +223,30 @@ def _format_markdown(
         f"{_format_json_block({'output': trace.output_text})}\n\n"
     )
 
+    conversation_section = ""
+    if trace.conversation:
+        conversation_lines = ["## Conversation\n"]
+        for entry in trace.conversation:
+            role = (entry.get("role") or "unknown").capitalize()
+            content = entry.get("content") or ""
+            source = entry.get("source")
+            metadata = entry.get("metadata") or {}
+            meta_bits: List[str] = []
+            if source:
+                meta_bits.append(f"source={source}")
+            actions = metadata.get("actions") or []
+            if actions:
+                meta_bits.append("actions=" + ", ".join(actions))
+            if metadata.get("closing"):
+                meta_bits.append("closing=true")
+            persona = metadata.get("persona")
+            if persona:
+                meta_bits.append(f"persona={persona}")
+            meta_suffix = f" _({' ; '.join(meta_bits)})_" if meta_bits else ""
+            conversation_lines.append(f"- **{role}**: {content}{meta_suffix}")
+        conversation_lines.append("")
+        conversation_section = "\n".join(conversation_lines)
+
     timeline_lines = ["## Timeline\n"]
 
     for index, obs in enumerate(observations_sorted, start=1):
@@ -238,7 +271,7 @@ def _format_markdown(
     if not observations_sorted:
         timeline_lines.append("(no observations recorded)\n")
 
-    return header + summary_section + "".join(timeline_lines)
+    return header + summary_section + conversation_section + "".join(timeline_lines)
 
 
 def _sort_observations(
@@ -278,12 +311,40 @@ def _build_structured_record(
         "success": summary_payload["success"],
         "summary": summary_payload,
         "timeline": timeline,
+        "conversation": trace.conversation or summary_payload.get("conversation") or [],
     }
 
+    def _maybe_decode_content(value: Any) -> Any:
+        if isinstance(value, str):
+            text = value.strip()
+            if text and text[0] in "{[" and text[-1] in "}]" and len(text) >= 2:
+                try:
+                    return json.loads(text)
+                except (json.JSONDecodeError, TypeError):
+                    return value
+        return value
+
     record["metrics"] = {
         "observation_count": len(timeline),
     }
 
+    if trace.conversation_state:
+        record["conversation_state"] = trace.conversation_state
+    if trace.termination_reason:
+        record["termination_reason"] = trace.termination_reason
+    if not record["conversation"] and trace.raw.get("conversation"):
+        record["conversation"] = trace.raw.get("conversation")
+    if record["conversation"]:
+        normalized_conversation: List[Dict[str, Any]] = []
+        for entry in record["conversation"]:
+            if not isinstance(entry, dict):
+                normalized_conversation.append(entry)
+                continue
+            normalized_entry = dict(entry)
+            normalized_entry["content"] = _maybe_decode_content(entry.get("content"))
+            normalized_conversation.append(normalized_entry)
+        record["conversation"] = normalized_conversation
+
     return record
 
 

fluxloop_cli/commands/run.py

@@ -3,6 +3,7 @@ Run command for executing experiments and simulations.
 """
 
 import asyncio
+import json
 import sys
 from pathlib import Path
 from typing import Optional
@@ -27,6 +28,16 @@ app = typer.Typer()
 console = Console()
 
 
+def _emit_progress_event(event: str, **payload: object) -> None:
+    """Emit a structured progress event to stderr for machine consumption."""
+    data = {"event": event, **payload}
+    try:
+        print(json.dumps(data, default=str), file=sys.stderr, flush=True)
+    except Exception:
+        # Fall back to repr if serialization fails
+        print({"event": event, **{k: repr(v) for k, v in payload.items()}}, file=sys.stderr, flush=True)
+
+
 @app.command()
 def experiment(
     config_file: Path = typer.Option(
@@ -227,9 +238,20 @@ def experiment(
     summary.add_row("Output", config.output_directory)
     
     console.print(summary)
+
+    _emit_progress_event(
+        "experiment_summary",
+        name=config.name,
+        iterations=config.iterations,
+        personas=len(config.personas),
+        total_runs=total_runs,
+        multi_turn_enabled=bool(config.multi_turn and config.multi_turn.enabled),
+        output_dir=config.output_directory,
+    )
     
     if dry_run:
         console.print("\n[yellow]Dry run mode - no execution will occur[/yellow]")
+        _emit_progress_event("experiment_status", status="dry_run", name=config.name)
         return
     
     # Confirm execution
@@ -243,13 +265,22 @@ def experiment(
             f"\nThis will execute {total_runs} runs."
         )
 
+    _emit_progress_event(
+        "experiment_ready",
+        name=config.name,
+        total_runs=total_runs,
+    )
+
     if not typer.confirm("Continue?"):
+        _emit_progress_event("experiment_status", status="aborted", reason="user_declined", name=config.name)
         raise typer.Abort()
     
     # Create runner
     # Run experiment with progress tracking
     console.print("\n[bold green]▶️ Starting experiment...[/bold green]\n")
 
+    _emit_progress_event("experiment_started", name=config.name, total_runs=total_runs)
+
     with Progress(
         SpinnerColumn(),
         TextColumn("[progress.description]{task.description}"),
@@ -277,6 +308,14 @@ def experiment(
 
         def _progress_callback():
             progress.advance(main_task)
+            task = progress.tasks[main_task]
+            _emit_progress_event(
+                "run_progress",
+                completed=int(task.completed),
+                total=int(task.total or 0),
+                description=task.description,
+                experiment=config.name,
+            )
 
         def _turn_progress_callback(
             current_turn: int,
@@ -295,6 +334,13 @@ def experiment(
                     description=description,
                     visible=False,
                 )
+                _emit_progress_event(
+                    "turn_progress",
+                    state="complete",
+                    current=min(clamped_turn, total),
+                    total=total,
+                experiment=config.name,
+                )
                 return
 
             if not progress.tasks[turn_task].visible:
@@ -313,6 +359,14 @@ def experiment(
                 completed=completed,
                 description=description,
             )
+            _emit_progress_event(
+                "turn_progress",
+                state="in_progress",
+                current=clamped_turn,
+                total=total,
+                preview=preview,
+                experiment=config.name,
+            )
 
         # Run experiment
         try:
@@ -324,12 +378,14 @@ def experiment(
             )
         except KeyboardInterrupt:
             console.print("\n[yellow]Experiment interrupted by user[/yellow]")
+            _emit_progress_event("experiment_status", status="interrupted", name=config.name)
             raise typer.Exit(1)
         except Exception as e:
             console.print(f"\n[red]Error during experiment:[/red] {e}")
             # Debug mode - show full traceback
             if "--debug" in sys.argv:
                 console.print_exception()
+            _emit_progress_event("experiment_status", status="error", error=str(e), name=config.name)
             raise typer.Exit(1)
     
     config.set_resolved_input_count(results.get("input_count", config.get_input_count()))
@@ -343,6 +399,15 @@ def experiment(
         )
 
     _display_results(results)
+    _emit_progress_event(
+        "experiment_status",
+        status="completed",
+        name=config.name,
+        total_runs=results.get("total_runs", total_runs),
+        successful=results.get("successful"),
+        failed=results.get("failed"),
+        success_rate=results.get("success_rate"),
+    )
 
 
 @app.command()

fluxloop_cli/evaluation/engine/core.py

@@ -217,6 +217,12 @@ def _write_per_trace(results: List[TraceOutcome], path: Path) -> None:
                     if outcome.trace.get(key) is not None
                 },
             }
+            if outcome.trace.get("conversation") is not None:
+                payload["conversation"] = outcome.trace.get("conversation")
+            if outcome.trace.get("conversation_state") is not None:
+                payload["conversation_state"] = outcome.trace.get("conversation_state")
+            if outcome.trace.get("termination_reason") is not None:
+                payload["termination_reason"] = outcome.trace.get("termination_reason")
             handle.write(json.dumps(payload, ensure_ascii=False) + "\n")
 
 

fluxloop_cli/evaluation/engine/reporting/html.py

@@ -14,6 +14,39 @@ if TYPE_CHECKING:
     from ...config import EvaluationConfig
 
 
+FLUXLOOP_LOGO_DATA_URI = (
+    "data:image/png;base64,"
+    "iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAIRlWElmTU0AKgAAAAgABQESAAMAAAABAAEAAAEaAAUA"
+    "AAABAAAASgEbAAUAAAABAAAAUgEoAAMAAAABAAIAAIdpAAQAAAABAAAAWgAAAAAAAABIAAAAAQAAAEgAAAABAAOgAQADAAAAAQABAACgAgAE"
+    "AAAAAQAAABigAwAEAAAAAQAAABgAAAAAEQ8YrgAAAAlwSFlzAAALEwAACxMBAJqcGAAAAVlpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADx4"
+    "OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IlhNUCBDb3JlIDYuMC4wIj4KICAgPHJkZjpSREYgeG1sbnM6cmRm"
+    "PSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9"
+    "IiIKICAgICAgICAgICAgeG1sbnM6dGlmZj0iaHR0cDovL25zLmFkb2JlLmNvbS90aWZmLzEuMC8iPgogICAgICAgICA8dGlmZjpPcmllbnRh"
+    "dGlvbj4xPC90aWZmOk9yaWVudGF0aW9uPgogICAgICA8L3JkZjpEZXNjcmlwdGlvbj4KICAgPC9yZGY6UkRGPgo8L3g6eG1wbWV0YT4KGV7h"
+    "BwAABlJJREFUSA2VVQtwlFcVPvf+99/9N9lHsnlsaCAh4VEmkKAmhqZMcKmTzuAA6jhbYXA6RpxAHWxt61jHQbtapY8o1VHbxk6xltJaGK1a"
+    "rDC1Ztu0IzAkpSVmAIEAee5uNg92N/v4/3uP9266gdpSxzOze+8959zvO/ec+58L8L8k2M0g8C8bBJHOuwZQWyl1ATnO6/7vyUG5+XrQGwAE"
+    "Agc19buBGchHGrpQhx3EVLaF7efWmIJswYxoBhOdxORx3cSMkRWnjKz5u/6exveUX2PjSb23tym3R63z8mGCIDIIEqvyvuHlPGu9iOD+FM7E"
+    "YpDlo2hBnYaGxpLxw4aJixxQuJpl4iGXSb725onVg35/NwuF1lt5cDVey6tavQ/u+8GVL1su91kOJAkzk/WR/ctKIy+taPCaE8WEpw4QRhs0"
+    "K/VFkp6sJwg1nBkX/c0nv6DAFYmCysu1E7yfFt8jI5sQHX+BmcRDbiPz09kULaLZcHT48VtT+U1LNvRf1rO84Mzrq8uUbm1L35tOWtYK6dGN"
+    "R3vX/PX6dM2dQBVT5rzm6bAPbfQlxFQUHcR/lXtmuF5xOZOtmPVtP//Q0qWv2hWggfy7Tkdl6afX9W5Ta4fGvyrMGOio/WnLqjcWqVrkC59P"
+    "UW5MIvwQKiocqNExpOQ1IszNIhNrlxhv0ZIluxMttfsVoKBkhIoUMMQqtaYFtrCG5tsGaEyjtkeULhoty2VHFlRGL4ta80LYFzfZDpgOv119"
+    "YWR9728+cCOerWg/u0tzLf5l+bb+tUYkS5jDAZSSmAKDdMZLCCmjIv2YAfSeu+p7vv9kqPViEJAyqBtQRcnOIm4EpwtIZnqXAvd1jpdzindi"
+    "0myjs9wiafMZnBgcsAvawZmGAtOgJZKvKHxqadsZxSWMiCcMQnbqoG2W6p/DygFGYaoOlZNgpFWkpsaiHeWnyg5ElpkeOE0qKjophWaOxGdx"
+    "8rywQ5Uu+CbQyBYrE9va07tu7LbWk18v1MseZIK//MI7ay8XAo47EZsU5qiRkukZC+UIZLSLkOIZZcgAhoSdldPYlc3R3VXFVZVjv3IXJTTd"
+    "zp023V6sExx2CNF427q+syWs6mmeGj/nAtip9roFT7tBlKj5Ta64JPiMX80BCRKi4WTx78PbiMd7U5FIfzJ8d/Urm549em+p2/bbYiP5TqUt"
+    "gR6YiVHOB3UhvlXIuQeTg4+tSEVuee7EmlhjY5fuEbDExTGRA5V/DKIDuRtECP5bUjRxEF9xJCIHLrUvPHXXHw7XMmLtnb46+FS1aYukHLoT"
+    "U66FDoF/2/eP1rY8SH7clVxxv9dWUTiVHT6tdHXRqCxy7VwNGIOjWQHtlONECbHuCUuHpTDU5pKFH8Whzkr0PgA2K35yov7RFcU1P3u4uafJ"
+    "za0nspSNOlMZpxO1ewWKQNoKgwHZY4pgyqiVKWqEXO8ocGdepZoIa273giL11UippeHK5bMDEKweHGomfe9+zjh3S7Bl3YsTF4bvX+xwby1n"
+    "pT0LOL2w2OF7l1C+uoBYR2xkdozWT7+u9u/obbIoyNxAN7JL62vSRON7tNJCsDSRuwUL+ESsjp6H4TPnfA2xrudL+T/BIC1//Mnplr1b32jw"
+    "oDX0DR3ie4YmJz+7wLjy+SJj9ksFLNV5x6E7eJesh+TIXSA54HxPKvnzxWMNRy4pUic+B4X8cBsm9q38jorI/HHlffiL5Zh64BNn8XuwSumU"
+    "4Deh7L22zsnjtz7Tl1sDyKjnMOdaRe4Uc10wpmkb4iI+viEVmiKL+wpg4rVvMyv7I+z0leu7R/bCdOROnUV8yFednr27+cTU9tuP8/iuiN2Y"
+    "SHv5kF8RQOAgJYpDSr4XAayXfbxbkmysnhr0GjcbItn3KO+PHHHurJQtuh9tpAf3lKwhD07v18zRRYIOdTB9xF3kTTRPmVf+7iVv3bzsePBq"
+    "tz/IiEyRAlcyn5q5JYBfkoQUmZTHX364ozE9EKxL9haX0HEDMhwwZqUxK98Ji9p5xj5spj2dhb8+v0/5owIPBT/w4HyIQDmCfI8xAEI2sNwx"
+    "J59cudaTHm+g2Wy1kO8A5TRipbVj7MJMNzkEuWgxENDIoUPzkedwPvZPFr6rq0PdhI8VDPqZjOKjA5U7b2i4HlWBAISu1WvOKEhw7hu63ve/"
+    "5/8B6E/qF9KU55kAAAAASUVORK5CYII="
+)
+
+
 def serialize_trace_outcome(outcome: "TraceOutcome") -> Dict[str, Any]:
     return {
         "trace_id": outcome.trace.get("trace_id"),
@@ -25,6 +58,9 @@ def serialize_trace_outcome(outcome: "TraceOutcome") -> Dict[str, Any]:
         "final_score": outcome.final_score,
         "pass": outcome.passed,
         "reasons": outcome.reasons,
+        "conversation": outcome.trace.get("conversation"),
+        "conversation_state": outcome.trace.get("conversation_state"),
+        "termination_reason": outcome.trace.get("termination_reason"),
     }
 
 
@@ -40,6 +76,7 @@ DEFAULT_TEMPLATE = r"""<!DOCTYPE html>
 <head>
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="report:generated_at" content="[[DATE]]" />
   <title>[[TITLE]]</title>
   <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/tailwindcss@2.2.19/dist/tailwind.min.css">
   <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.1/dist/chart.umd.min.js"></script>
@@ -47,14 +84,29 @@ DEFAULT_TEMPLATE = r"""<!DOCTYPE html>
 <body class="bg-slate-950 text-slate-100">
   <main class="max-w-6xl mx-auto p-8 space-y-6">
     <header class="space-y-6">
+      <div class="flex flex-col gap-4 md:flex-row md:items-center md:justify-between">
+        <div class="flex items-center gap-3">
+          <img src="[[LOGO_DATA_URI]]" alt="FluxLoop logo" class="h-12 w-12 rounded-full border border-sky-400/40 bg-slate-900/80 p-1.5 shadow-md shadow-sky-900/60" />
       <div>
       <h1 class="text-3xl font-bold">[[TITLE]]</h1>
-      <p class="text-sm text-slate-300">Generated at [[DATE]]</p>
+            <p class="text-sm text-slate-300">[[SUBTITLE]]</p>
+          </div>
+        </div>
+        <a
+          href="https://fluxloop.io/"
+          class="inline-flex items-center gap-2 self-start rounded-full border border-sky-400 px-4 py-2 text-sm font-semibold text-sky-200 transition hover:bg-sky-500/10 focus:outline-none focus:ring-2 focus:ring-sky-400 focus:ring-offset-2 focus:ring-offset-slate-950"
+          target="_blank"
+          rel="noopener noreferrer"
+        >
+          <img src="[[LOGO_DATA_URI]]" alt="" aria-hidden="true" class="h-5 w-5 rounded-full border border-sky-400/50 bg-slate-950/70 p-0.5" />
+          <span>Built with FluxLoop</span>
+        </a>
       </div>
       <nav class="flex flex-wrap gap-2" role="tablist" aria-label="Report sections">
         <button class="tab-button px-4 py-2 rounded-full bg-sky-500/20 border border-sky-400 text-sky-200 font-semibold" data-tab-button="summary">Executive Summary</button>
         <button class="tab-button px-4 py-2 rounded-full bg-slate-800 border border-slate-700" data-tab-button="personas">Persona Insights</button>
         <button class="tab-button px-4 py-2 rounded-full bg-slate-800 border border-slate-700" data-tab-button="analysis">Deep Analysis</button>
+        <button class="tab-button px-4 py-2 rounded-full bg-slate-800 border border-slate-700" data-tab-button="conversation">Conversation View</button>
         <button class="tab-button px-4 py-2 rounded-full bg-slate-800 border border-slate-700" data-tab-button="traces">Trace Explorer</button>
       </nav>
     </header>
@@ -62,6 +114,11 @@ DEFAULT_TEMPLATE = r"""<!DOCTYPE html>
     <section data-tab-panel="summary" class="tab-panel space-y-6">
       <div id="summaryCards" class="grid gap-4 md:grid-cols-2 xl:grid-cols-4"></div>
 
+      <section class="space-y-4">
+        <h2 class="text-xl font-semibold">Evaluation Goal</h2>
+        <div id="evaluationGoal" class="whitespace-pre-wrap rounded-xl border border-slate-800 bg-slate-900 p-4 text-sm text-slate-300"></div>
+      </section>
+
       <section class="space-y-4">
         <h2 class="text-xl font-semibold">Success Criteria</h2>
         <div id="criteriaList" class="space-y-3"></div>
@@ -95,6 +152,22 @@ DEFAULT_TEMPLATE = r"""<!DOCTYPE html>
       <div id="analysisContent" class="space-y-4"></div>
     </section>
 
+    <section data-tab-panel="conversation" class="tab-panel hidden space-y-4">
+      <div class="flex flex-col gap-4 md:flex-row md:items-end md:justify-between">
+        <div class="w-full md:w-1/2">
+          <label for="conversationTraceSelect" class="block text-sm text-slate-300 font-medium mb-1">Select Trace</label>
+          <select id="conversationTraceSelect" class="w-full bg-slate-900 border border-slate-700 rounded px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-sky-400">
+            <option value="">Choose a trace</option>
+          </select>
+        </div>
+        <div class="text-xs text-slate-400">
+          Messages are ordered chronologically. Expand each turn to view captured actions.
+        </div>
+      </div>
+      <div id="conversationSummary" class="text-sm text-slate-300"></div>
+      <div id="conversationTimeline" class="space-y-3"></div>
+    </section>
+
     <section data-tab-panel="traces" class="tab-panel hidden space-y-4">
       <div class="flex flex-col md:flex-row md:items-end md:justify-between gap-4">
         <div>
@@ -136,6 +209,7 @@ DEFAULT_TEMPLATE = r"""<!DOCTYPE html>
     const state = {
       activeTab: "summary",
       personaFilter: "all",
+      conversationTraceId: (Array.isArray(perTrace) && perTrace.length > 0 && (perTrace[0].trace_id ?? perTrace[0].iteration ?? null)) || null,
     };
 
     function setActiveTab(tab) {
@@ -214,6 +288,240 @@ DEFAULT_TEMPLATE = r"""<!DOCTYPE html>
         .join("");
     }
 
+    function initConversationSelect() {
+      const select = document.getElementById("conversationTraceSelect");
+      if (!select) return;
+      const options = Array.isArray(perTrace) ? perTrace : [];
+      if (!options.length) {
+        select.innerHTML = `<option value="">No traces available</option>`;
+        select.disabled = true;
+        return;
+      }
+      select.innerHTML = options
+        .map((trace) => {
+          const label = trace.trace_id || `Iteration ${trace.iteration ?? ""}` || "Trace";
+          const value = trace.trace_id || `iteration-${trace.iteration ?? 0}`;
+          return `<option value="${value}">${label}</option>`;
+        })
+        .join("");
+      if (state.conversationTraceId) {
+        select.value = state.conversationTraceId;
+      } else {
+        state.conversationTraceId = options[0].trace_id || `iteration-${options[0].iteration ?? 0}`;
+        select.value = state.conversationTraceId;
+      }
+      select.addEventListener("change", (event) => {
+        state.conversationTraceId = event.target.value || null;
+        renderConversationTimeline();
+      });
+      renderConversationTimeline();
+    }
+
+    function escapeHtml(value) {
+      return String(value).replace(/[&<>"']/g, (char) => {
+        switch (char) {
+          case "&":
+            return "&amp;";
+          case "<":
+            return "&lt;";
+          case ">":
+            return "&gt;";
+          case '"':
+            return "&quot;";
+          case "'":
+            return "&#39;";
+          default:
+            return char;
+        }
+      });
+    }
+
+    function formatPlainText(value) {
+      return escapeHtml(value || "").replace(/\n/g, "<br>");
+    }
+
+    function tryParseJson(text) {
+      if (typeof text !== "string") return text;
+      const trimmed = text.trim();
+      if (
+        !trimmed ||
+        ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+          (trimmed.startsWith("[") && trimmed.endsWith("]"))) === false
+      ) {
+        return text;
+      }
+      try {
+        return JSON.parse(trimmed);
+      } catch (error) {
+        return text;
+      }
+    }
+
+    function renderTranscriptObject(obj) {
+      const transcript = Array.isArray(obj.transcript) ? obj.transcript : [];
+      if (!transcript.length) {
+        return `
+          <pre class="mt-3 bg-slate-900/70 border border-slate-800 rounded-lg p-3 text-xs text-slate-300 whitespace-pre-wrap">${escapeHtml(JSON.stringify(obj, null, 2))}</pre>
+        `;
+      }
+      const threadId = obj.thread_id ? `<p class="text-xs text-slate-400">Thread: ${escapeHtml(obj.thread_id)}</p>` : "";
+      const provider = obj.provider ? `<p class="text-xs text-slate-400">Provider: ${escapeHtml(obj.provider)}</p>` : "";
+      const exchanges = transcript
+        .map((turn, index) => {
+          const user = turn.user
+            ? `<p class="text-sm text-slate-200"><span class="font-semibold">Human:</span> ${formatPlainText(turn.user)}</p>`
+            : "";
+          const assistant = turn.assistant
+            ? `<p class="text-sm text-sky-200 mt-2"><span class="font-semibold">AI:</span> ${formatPlainText(
+                turn.assistant
+              )}</p>`
+            : "";
+          return `
+            <div class="rounded-lg border border-slate-800 bg-slate-900/70 p-3 space-y-2">
+              <p class="text-xs text-slate-400 uppercase tracking-wide">Exchange ${index + 1}</p>
+              ${user}
+              ${assistant}
+            </div>
+          `;
+        })
+        .join("");
+      return `
+        <div class="mt-3 space-y-3">
+          ${threadId}
+          ${provider}
+          <div class="space-y-3">${exchanges}</div>
+        </div>
+      `;
+    }
+
+    function formatConversationContent(rawContent) {
+      if (rawContent == null) return "";
+      let value = rawContent;
+      if (typeof value === "string") {
+        value = tryParseJson(value);
+      }
+      if (typeof value === "string") {
+        return `<p class="text-sm text-slate-200 whitespace-pre-wrap">${formatPlainText(value)}</p>`;
+      }
+      if (Array.isArray(value)) {
+        return `
+          <pre class="mt-3 bg-slate-900/70 border border-slate-800 rounded-lg p-3 text-xs text-slate-300 whitespace-pre-wrap">${escapeHtml(
+            JSON.stringify(value, null, 2)
+          )}</pre>
+        `;
+      }
+      if (typeof value === "object") {
+        if (value && Array.isArray(value.transcript)) {
+          return renderTranscriptObject(value);
+        }
+        return `
+          <pre class="mt-3 bg-slate-900/70 border border-slate-800 rounded-lg p-3 text-xs text-slate-300 whitespace-pre-wrap">${escapeHtml(
+            JSON.stringify(value, null, 2)
+          )}</pre>
+        `;
+      }
+      return `<p class="text-sm text-slate-200">${escapeHtml(String(value))}</p>`;
+    }
+
+    function formatTraceSummary(trace) {
+      if (!trace) return "";
+      const parts = [];
+      if (trace.trace_id) parts.push(`Trace ID: ${trace.trace_id}`);
+      if (trace.iteration != null) parts.push(`Iteration: ${trace.iteration}`);
+      if (trace.persona) parts.push(`Persona: ${trace.persona}`);
+      const termination = trace.termination_reason;
+      if (termination) parts.push(`Termination: ${termination}`);
+      return parts.join(" · ");
+    }
+
+    function renderConversationTimeline() {
+      const container = document.getElementById("conversationTimeline");
+      const summaryEl = document.getElementById("conversationSummary");
+      if (!container) return;
+      container.innerHTML = "";
+      if (!Array.isArray(perTrace) || !perTrace.length || !state.conversationTraceId) {
+        if (summaryEl) summaryEl.textContent = "No conversation data available.";
+        return;
+      }
+      const trace = perTrace.find(
+        (item) =>
+          item.trace_id === state.conversationTraceId ||
+          `iteration-${item.iteration ?? 0}` === state.conversationTraceId
+      );
+      if (!trace) {
+        if (summaryEl) summaryEl.textContent = "Conversation data not found for the selected trace.";
+        return;
+      }
+      if (summaryEl) {
+        summaryEl.textContent = formatTraceSummary(trace);
+      }
+      const conversation = Array.isArray(trace.conversation) ? trace.conversation : [];
+      if (!conversation.length) {
+        container.innerHTML = `<p class="text-sm text-slate-400">No conversation recorded for this trace.</p>`;
+        return;
+      }
+      conversation.forEach((entry, index) => {
+        const role = entry.role || "unknown";
+        const isAssistant = role === "assistant";
+        const isUser = role === "user";
+        const bubbleClasses = [
+          "rounded-xl",
+          "p-4",
+          "border",
+          "shadow-inner",
+          isAssistant ? "bg-sky-500/10 border-sky-400/40" : "bg-slate-900 border-slate-800",
+        ].join(" ");
+        const roleLabel = isAssistant ? "AI" : isUser ? "Human" : role.toUpperCase();
+        const source = entry.source ? `<span class="text-xs uppercase tracking-wide text-slate-400">${escapeHtml(entry.source)}</span>` : "";
+        const metadata = entry.metadata || {};
+        const actions = Array.isArray(metadata.actions) ? metadata.actions.map((action) => escapeHtml(action)) : [];
+        const closing = metadata.closing ? " • Closing turn" : "";
+        const persona = metadata.persona ? ` • Persona: ${escapeHtml(metadata.persona)}` : "";
+        const detailLabel = actions.length ? actions.join(", ") : "No recorded actions for this turn.";
+        const detailContent = actions.length
+          ? actions.map((item) => `<li>${item}</li>`).join("")
+          : "";
+        const formattedContent = formatConversationContent(entry.content);
+        const detailsMarkup = `
+          <details class="mt-3 bg-slate-900/60 border border-slate-800 rounded-lg">
+            <summary class="cursor-pointer text-xs text-slate-300 px-3 py-2">Turn details</summary>
+            <div class="px-4 py-3 text-xs text-slate-300">
+              <p>${detailLabel}</p>
+              ${actions.length ? `<ul class="list-disc list-inside mt-2 space-y-1 text-slate-400">${detailContent}</ul>` : ""}
+            </div>
+          </details>
+        `;
+        container.innerHTML += `
+          <article class="${bubbleClasses}">
+            <header class="flex items-center justify-between gap-2 mb-2">
+              <div class="flex items-center gap-2">
+                <span class="text-sm font-semibold">${roleLabel}</span>
+                ${source}
+              </div>
+              <span class="text-xs text-slate-400">Turn ${entry.turn_index ?? index + 1}${closing}${persona}</span>
+            </header>
+            ${formattedContent}
+            ${detailsMarkup}
+          </article>
+        `;
+      });
+    }
+
+    function renderEvaluationGoal() {
+      const container = document.getElementById("evaluationGoal");
+      if (!container) return;
+      const goal = summary?.evaluation_goal;
+      if (!goal) {
+        container.textContent = "No evaluation goal provided.";
+        container.classList.remove("text-slate-300");
+        container.classList.add("text-slate-400");
+        return;
+      }
+      container.classList.remove("text-slate-400");
+      container.classList.add("text-slate-300");
+      container.textContent = goal;
+    }
+
     function renderCriteria() {
       const container = document.getElementById("criteriaList");
       if (!container || !criteria || !Object.keys(criteria).length) {
@@ -458,12 +766,14 @@ DEFAULT_TEMPLATE = r"""<!DOCTYPE html>
 
     initTabs();
     renderSummaryCards();
+    renderEvaluationGoal();
     renderCriteria();
     renderRecommendations();
     renderScoreChart();
     renderTopReasons();
     renderPersonaSummary();
     renderAnalysisContent();
+    initConversationSelect();
     initTraceFilter();
   </script>
 </body>
@@ -471,6 +781,45 @@ DEFAULT_TEMPLATE = r"""<!DOCTYPE html>
 """
 
 
+def _resolve_experiment_label(summary: Dict[str, Any], output_path: Path) -> Optional[str]:
+    def _stringify(value: Any) -> Optional[str]:
+        if value is None:
+            return None
+        if isinstance(value, (list, tuple, set)):
+            parts = [str(item) for item in value if item not in (None, "")]
+            if not parts:
+                return None
+            return ", ".join(parts)
+        if isinstance(value, str):
+            return value.strip() or None
+        return str(value)
+
+    for key in ("experiment_id", "experiment_name"):
+        candidate = _stringify(summary.get(key))
+        if candidate:
+            return candidate
+
+    experiment_meta = summary.get("experiment")
+    if isinstance(experiment_meta, dict):
+        for key in ("name", "id", "label"):
+            candidate = _stringify(experiment_meta.get(key))
+            if candidate:
+                return candidate
+
+    output_dir = output_path.parent
+    if output_dir != output_path:
+        experiment_dir = output_dir.parent
+        if experiment_dir and experiment_dir != output_dir:
+            candidate = _stringify(experiment_dir.name)
+            if candidate:
+                return candidate
+        candidate = _stringify(output_dir.name)
+        if candidate:
+            return candidate
+
+    return None
+
+
 def select_html_template(options: "EvaluationOptions", config: "EvaluationConfig") -> Tuple[str, Optional[str]]:
     if options.report_template:
         template_text = load_template_from_path(options.report_template)
@@ -497,9 +846,20 @@ def write_html_report(
     success_criteria = summary.get("success_criteria_results") or {}
     analysis = summary.get("analysis") or {}
 
+    generated_at = datetime.now(UTC)
+    generated_iso = generated_at.isoformat(timespec="seconds").replace("+00:00", "Z")
+    human_readable = generated_at.strftime("%Y-%m-%d %H:%M:%SZ")
+    experiment_label = _resolve_experiment_label(summary, output_path)
+    subtitle_parts = [f"Generated on {human_readable}"]
+    if experiment_label:
+        subtitle_parts.append(f"Experiment: {experiment_label}")
+    subtitle = " · ".join(subtitle_parts)
+
     replacements = {
-        "[[TITLE]]": summary.get("evaluation_goal") or "FluxLoop Evaluation Report",
-        "[[DATE]]": datetime.now(UTC).isoformat(timespec="seconds").replace("+00:00", "Z"),
+        "[[TITLE]]": "FluxLoop Evaluation Report",
+        "[[DATE]]": generated_iso,
+        "[[SUBTITLE]]": subtitle,
+        "[[LOGO_DATA_URI]]": FLUXLOOP_LOGO_DATA_URI,
         "[[SUMMARY_JSON]]": json.dumps(summary, ensure_ascii=False),
         "[[PER_TRACE_JSON]]": json.dumps(per_trace_payload, ensure_ascii=False),
         "[[CRITERIA_JSON]]": json.dumps(success_criteria, ensure_ascii=False),
@@ -515,6 +875,7 @@ def write_html_report(
 
 __all__ = [
     "DEFAULT_TEMPLATE",
+    "FLUXLOOP_LOGO_DATA_URI",
     "serialize_trace_outcome",
     "load_template_from_path",
     "select_html_template",

fluxloop_cli/evaluation/rules.py

@@ -189,6 +189,172 @@ def _evaluate_latency_under(context: RuleContext, definition: RuleDefinition) ->
     return RuleResult(rule=definition, score=score, reason=reason)
 
 
+def _coerce_usage_values(data: Dict[str, Any]) -> Dict[str, float]:
+    usage: Dict[str, float] = {}
+    for key in ("prompt_tokens", "completion_tokens", "total_tokens"):
+        value = data.get(key)
+        if isinstance(value, (int, float)):
+            usage[key] = float(value)
+    return usage
+
+
+def _usage_from_candidate(candidate: Any) -> Dict[str, float]:
+    if not isinstance(candidate, dict):
+        return {}
+    direct = _coerce_usage_values(candidate)
+    if direct:
+        return direct
+    token_usage = candidate.get("token_usage")
+    if isinstance(token_usage, dict):
+        values = _coerce_usage_values(token_usage)
+        if values:
+            return values
+    nested = candidate.get("usage")
+    if isinstance(nested, dict):
+        return _coerce_usage_values(nested)
+    return {}
+
+
+def _entry_token_usage(entry: Dict[str, Any]) -> Dict[str, float]:
+    candidates = [entry]
+    output = entry.get("output")
+    if isinstance(output, dict):
+        candidates.append(output)
+        messages = output.get("messages")
+        if isinstance(messages, dict):
+            candidates.append(messages)
+            response_metadata = messages.get("response_metadata")
+            if isinstance(response_metadata, dict):
+                candidates.append(response_metadata)
+    raw = entry.get("raw")
+    if isinstance(raw, dict):
+        candidates.append(raw)
+        raw_output = raw.get("output")
+        if isinstance(raw_output, dict):
+            candidates.append(raw_output)
+            response_metadata = raw_output.get("response_metadata")
+            if isinstance(response_metadata, dict):
+                candidates.append(response_metadata)
+            messages = raw_output.get("messages")
+            if isinstance(messages, dict):
+                candidates.append(messages)
+                response_metadata = messages.get("response_metadata")
+                if isinstance(response_metadata, dict):
+                    candidates.append(response_metadata)
+        metadata = raw.get("metadata")
+        if isinstance(metadata, dict):
+            candidates.append(metadata)
+        response_metadata = raw.get("response_metadata")
+        if isinstance(response_metadata, dict):
+            candidates.append(response_metadata)
+    for candidate in candidates:
+        usage = _usage_from_candidate(candidate)
+        if usage:
+            return usage
+    return {}
+
+
+def _collect_token_usage(trace: Dict[str, Any]) -> Optional[Dict[str, float]]:
+    totals = {"prompt_tokens": 0.0, "completion_tokens": 0.0, "total_tokens": 0.0}
+    found = False
+
+    summary = trace.get("summary")
+    if isinstance(summary, dict):
+        summary_usage = {}
+        if isinstance(summary.get("token_usage"), dict):
+            summary_usage = _usage_from_candidate(summary["token_usage"])
+        if not summary_usage:
+            raw = summary.get("raw")
+            if isinstance(raw, dict) and isinstance(raw.get("token_usage"), dict):
+                summary_usage = _usage_from_candidate(raw["token_usage"])
+        if summary_usage:
+            found = True
+            for key, value in summary_usage.items():
+                totals[key] += value
+
+    timeline = trace.get("timeline")
+    if isinstance(timeline, list):
+        for entry in timeline:
+            if not isinstance(entry, dict):
+                continue
+            usage = _entry_token_usage(entry)
+            if not usage:
+                continue
+            found = True
+            for key, value in usage.items():
+                totals[key] += value
+
+    if not found:
+        return None
+
+    prompt = totals["prompt_tokens"]
+    completion = totals["completion_tokens"]
+    total = totals["total_tokens"]
+    if total <= 0:
+        total = prompt + completion
+    return {
+        "prompt": prompt,
+        "completion": completion,
+        "total": total,
+    }
+
+
+def _coerce_budget_value(value: Any, label: str) -> Optional[float]:
+    if value is None:
+        return None
+    try:
+        budget = float(value)
+    except (TypeError, ValueError) as exc:  # noqa: BLE001
+        raise ValueError(f"token_usage_under {label} must be numeric") from exc
+    if budget <= 0:
+        raise ValueError(f"token_usage_under {label} must be greater than 0")
+    return budget
+
+
+def _evaluate_token_usage_under(context: RuleContext, definition: RuleDefinition) -> RuleResult:
+    usage = _collect_token_usage(context.trace)
+    if usage is None:
+        return RuleResult(
+            rule=definition,
+            score=0.0,
+            reason="token usage data not available",
+        )
+
+    max_total = _coerce_budget_value(definition.params.get("max_total_tokens"), "max_total_tokens")
+    max_prompt = _coerce_budget_value(
+        definition.params.get("max_prompt_tokens"),
+        "max_prompt_tokens",
+    )
+    max_completion = _coerce_budget_value(
+        definition.params.get("max_completion_tokens"),
+        "max_completion_tokens",
+    )
+
+    if max_total is None and max_prompt is None and max_completion is None:
+        raise ValueError("token_usage_under requires at least one max_*_tokens parameter")
+
+    score = 1.0
+    reasons: List[str] = []
+
+    def apply_budget(actual: float, budget: Optional[float], label: str) -> None:
+        nonlocal score
+        if budget is None:
+            return
+        if actual <= budget:
+            return
+        ratio = budget / actual if actual > 0 else 0.0
+        ratio = max(0.0, min(1.0, ratio))
+        score = min(score, ratio)
+        reasons.append(f"{label} {actual:.0f} exceeds budget {budget:.0f}")
+
+    apply_budget(usage["total"], max_total, "total tokens")
+    apply_budget(usage["prompt"], max_prompt, "prompt tokens")
+    apply_budget(usage["completion"], max_completion, "completion tokens")
+
+    reason = "; ".join(reasons) if reasons else None
+    return RuleResult(rule=definition, score=score, reason=reason)
+
+
 def _evaluate_similarity(context: RuleContext, definition: RuleDefinition) -> RuleResult:
     target = definition.params.get("target", "output")
     expected_path = definition.params.get("expected_path")
@@ -233,6 +399,7 @@ RULE_DISPATCH = {
     "not_contains": _evaluate_not_contains,
     "matches_regex": _evaluate_matches_regex,
     "latency_under": _evaluate_latency_under,
+    "token_usage_under": _evaluate_token_usage_under,
     "similarity": _evaluate_similarity,
     "success": _evaluate_success_flag,
 }

fluxloop_cli/runner.py

@@ -13,7 +13,7 @@ import os
 import time
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Sequence
+from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Tuple
 
 import fluxloop
 import yaml
@@ -375,6 +375,8 @@ class ExperimentRunner:
             if trace_id:
                 observations = self._load_observations_for_trace(trace_id)
 
+            seen_observation_keys: Set[Tuple[Optional[str], Optional[str], Optional[str]]] = set()
+
             final_output = self._extract_final_output(callback_messages, observations)
             if final_output is not None:
                 result = final_output
@@ -413,6 +415,38 @@ class ExperimentRunner:
             if observations:
                 trace_entry["observation_count"] = len(observations)
 
+            # Build normalized conversation transcript
+            conversation: List[Dict[str, Any]] = []
+            turn_index = 1
+            conversation.append(
+                self._make_conversation_entry(
+                    turn_index=turn_index,
+                    role="user",
+                    content=input_text,
+                    source="input",
+                    persona=persona.name if persona else None,
+                )
+            )
+            actions = self._summarize_observation_actions(observations, seen_observation_keys)
+            assistant_text = self._ensure_text(result)
+            trace_entry["output"] = assistant_text
+            conversation.append(
+                self._make_conversation_entry(
+                    turn_index=turn_index,
+                    role="assistant",
+                    content=assistant_text,
+                    source="agent",
+                    actions=actions or None,
+                )
+            )
+            trace_entry["conversation"] = conversation
+            trace_entry["conversation_state"] = {
+                "turns": [
+                    {"role": "user", "content": input_text},
+                    {"role": "assistant", "content": assistant_text},
+                ]
+            }
+
             self.results["traces"].append(trace_entry)
             
         except Exception as e:
@@ -490,6 +524,19 @@ class ExperimentRunner:
             "context": {},
         }
 
+        normalized_conversation: List[Dict[str, Any]] = []
+        turn_index = 1
+        normalized_conversation.append(
+            self._make_conversation_entry(
+                turn_index=turn_index,
+                role="user",
+                content=input_text,
+                source="input",
+                persona=persona.name if persona else None,
+            )
+        )
+        seen_observation_keys: Set[Tuple[Optional[str], Optional[str], Optional[str]]] = set()
+
         trace_name = f"{self.config.name}_iter{iteration}"
         if persona:
             trace_name += f"_persona_{persona.name}"
@@ -569,14 +616,29 @@ class ExperimentRunner:
                         assistant_output if isinstance(assistant_output, str) else str(assistant_output),
                     )
 
-                    final_output = assistant_output
+                    assistant_text = self._ensure_text(assistant_output)
+                    final_output = assistant_text
 
                     conversation_state["turns"].append(
                         {
                             "role": "assistant",
-                            "content": assistant_output,
+                            "content": assistant_text,
                         }
                     )
+                    new_actions = self._summarize_observation_actions(
+                        observations,
+                        seen_observation_keys,
+                    )
+                    normalized_conversation.append(
+                        self._make_conversation_entry(
+                            turn_index=turn_index,
+                            role="assistant",
+                            content=assistant_text,
+                            source="agent",
+                            actions=new_actions or None,
+                        )
+                    )
+                    turn_index += 1
 
                     turn_count += 1
                     ctx.add_metadata("turn_count", turn_count)
@@ -606,13 +668,24 @@ class ExperimentRunner:
                             decision.termination_reason or "supervisor_terminate"
                         )
                         if decision.closing_user_message:
+                            closing_text = self._ensure_text(decision.closing_user_message)
                             conversation_state["turns"].append(
                                 {
                                     "role": "user",
-                                    "content": decision.closing_user_message,
+                                    "content": closing_text,
                                     "closing": True,
                                 }
                             )
+                            normalized_conversation.append(
+                                self._make_conversation_entry(
+                                    turn_index=turn_index,
+                                    role="user",
+                                    content=closing_text,
+                                    source="supervisor",
+                                    persona=persona.name if persona else None,
+                                    closing=True,
+                                )
+                            )
                         ctx.add_metadata("termination_reason", termination_reason)
                         break
 
@@ -627,12 +700,22 @@ class ExperimentRunner:
                         type(next_user_message).__name__,
                         next_user_message if isinstance(next_user_message, str) else str(next_user_message),
                     )
+                    next_user_text = self._ensure_text(next_user_message)
                     conversation_state["turns"].append(
                         {
                             "role": "user",
-                            "content": next_user_message,
+                            "content": next_user_text,
                         }
                     )
+                    normalized_conversation.append(
+                        self._make_conversation_entry(
+                            turn_index=turn_index,
+                            role="user",
+                            content=next_user_text,
+                            source="supervisor" if decision.raw_response else "user",
+                            persona=persona.name if persona else None,
+                        )
+                    )
                     current_user_input = next_user_message
 
                 EventBuffer.get_instance().flush()
@@ -664,7 +747,8 @@ class ExperimentRunner:
                 "duration_ms": duration_ms,
                 "success": True,
                 "termination_reason": termination_reason,
-                "conversation": conversation_state,
+                "conversation": normalized_conversation,
+                "conversation_state": conversation_state,
             }
             if last_decision and last_decision.raw_response:
                 trace_entry["supervisor_response"] = last_decision.raw_response
@@ -969,6 +1053,75 @@ class ExperimentRunner:
             "kwargs": kwargs,
         }
 
+    @staticmethod
+    def _ensure_text(value: Any) -> str:
+        """Best-effort conversion of arbitrary values into displayable text."""
+        if value is None:
+            return ""
+        if isinstance(value, str):
+            return value
+        try:
+            return json.dumps(value, ensure_ascii=False)
+        except (TypeError, ValueError):
+            return str(value)
+
+    @staticmethod
+    def _make_conversation_entry(
+        *,
+        turn_index: int,
+        role: str,
+        content: Any,
+        source: str,
+        persona: Optional[str] = None,
+        closing: bool = False,
+        actions: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """Compose a normalized conversation entry."""
+        entry: Dict[str, Any] = {
+            "turn_index": turn_index,
+            "role": role,
+            "content": ExperimentRunner._ensure_text(content),
+            "source": source,
+        }
+        metadata: Dict[str, Any] = {}
+        if persona:
+            metadata["persona"] = persona
+        if closing:
+            metadata["closing"] = True
+        if actions:
+            metadata["actions"] = actions
+
+        entry["metadata"] = metadata
+        return entry
+
+    @staticmethod
+    def _summarize_observation_actions(
+        observations: Sequence[Dict[str, Any]],
+        seen: Set[Tuple[Optional[str], Optional[str], Optional[str]]],
+    ) -> List[str]:
+        """Return new action descriptors discovered in observations, tracking seen items."""
+        actions: List[str] = []
+        for obs in sorted(
+            observations,
+            key=lambda item: (
+                item.get("start_time") or "",
+                item.get("end_time") or "",
+                item.get("name") or "",
+            ),
+        ):
+            key = (
+                obs.get("id"),
+                obs.get("start_time"),
+                obs.get("name"),
+            )
+            if key in seen:
+                continue
+            seen.add(key)
+            obs_type = obs.get("type") or "event"
+            obs_name = obs.get("name") or obs_type
+            actions.append(f"{obs_type}:{obs_name}")
+        return actions
+
     async def _coerce_result_to_text(self, value: Any) -> Optional[str]:
         """Best-effort conversion of agent result into text for summaries.
 
@@ -1035,20 +1188,22 @@ class ExperimentRunner:
 
         with summary_path.open("w", encoding="utf-8") as summary_file:
             for trace in self.results["traces"]:
-                summary_file.write(
-                    json.dumps(
-                        {
-                            "trace_id": trace.get("trace_id"),
-                            "iteration": trace.get("iteration"),
-                            "persona": trace.get("persona"),
-                            "input": trace.get("input"),
-                            "output": trace.get("output"),
-                            "duration_ms": trace.get("duration_ms"),
-                            "success": trace.get("success"),
-                        }
-                    )
-                    + "\n"
-                )
+                summary_payload = {
+                    "trace_id": trace.get("trace_id"),
+                    "iteration": trace.get("iteration"),
+                    "persona": trace.get("persona"),
+                    "input": trace.get("input"),
+                    "output": trace.get("output"),
+                    "duration_ms": trace.get("duration_ms"),
+                    "success": trace.get("success"),
+                }
+                if trace.get("conversation") is not None:
+                    summary_payload["conversation"] = trace.get("conversation")
+                if trace.get("conversation_state") is not None:
+                    summary_payload["conversation_state"] = trace.get("conversation_state")
+                if trace.get("termination_reason") is not None:
+                    summary_payload["termination_reason"] = trace.get("termination_reason")
+                summary_file.write(json.dumps(summary_payload) + "\n")
 
     def _save_experiment_observations(self) -> None:
         """Copy matching observations from the offline store into the experiment directory."""

fluxloop_cli/templates.py

@@ -216,13 +216,13 @@ def create_evaluation_config() -> str:
             rules:
               - check: output_not_empty
 
-          - name: latency_budget
+          - name: token_budget
             type: rule_based
             enabled: true
             weight: 0.2
             rules:
-              - check: latency_under
-                budget_ms: 1500
+              - check: token_usage_under
+                max_total_tokens: 4000
 
           - name: keyword_quality
             type: rule_based
@@ -340,7 +340,7 @@ def create_evaluation_config() -> str:
           performance:
             all_traces_successful: true
             avg_response_time:
-              enabled: true
+              enabled: false
               threshold_ms: 2000
             max_response_time:
               enabled: false

{fluxloop_cli-0.2.26.dist-info → fluxloop_cli-0.2.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fluxloop-cli
-Version: 0.2.26
+Version: 0.2.28
 Summary: FluxLoop CLI for running agent simulations
 Author-email: FluxLoop Team <team@fluxloop.dev>
 License: Apache-2.0

{fluxloop_cli-0.2.26.dist-info → fluxloop_cli-0.2.28.dist-info}/RECORD

@@ -1,4 +1,4 @@
-fluxloop_cli/__init__.py,sha256=DsDXIug3R14X0dB0kmPUgVsLwOunKnreu4hhfdoJ0Ts,143
+fluxloop_cli/__init__.py,sha256=Yy0ysK8xslb79WaB0apu48ZBwviey964qWc5uDat8Mc,143
 fluxloop_cli/arg_binder.py,sha256=6-i81kK6kmR8inNvIp0GeGY51M5Jere-hAdignMl2bE,12765
 fluxloop_cli/config_loader.py,sha256=PYy0CfGVbU8jpPbx4sJzOu7i3BbrkQMNaRiSOp_uX9g,10307
 fluxloop_cli/config_schema.py,sha256=JZJRcMFun5hp3vKLAyek7W3NvISyzRzZt0BZAeSU38I,2415
@@ -9,9 +9,9 @@ fluxloop_cli/input_generator.py,sha256=ldlVdPSDfGsP9zO2RALk7QmZjkIvUzTaxDgwOjuPB
 fluxloop_cli/llm_generator.py,sha256=SosP5DeZuhBLEM6bj7BDp-7mckvVhtNJMEk2ZgV143M,12894
 fluxloop_cli/main.py,sha256=apLSNIgXv-V269ttKvd-t5za2UUjePswmR5KZGhOLPE,2772
 fluxloop_cli/project_paths.py,sha256=FoHp-g3aY1nytxGys85Oy3wJ6gmiKU6FVOwkgTtlHNA,4128
-fluxloop_cli/runner.py,sha256=jzXbI0TSxOrzX37I3d7MAmYyPBm0Uqi9P8M3p8HZ3Kk,43936
+fluxloop_cli/runner.py,sha256=ee-ue9wmN7X3VKuIk1Sg3z_vYiKwypWkKxFsTccH6rA,50199
 fluxloop_cli/target_loader.py,sha256=ACCu2izqGKoOrEiNnAajH0FgLZcw3j1pWn5rAhEuWFU,5528
-fluxloop_cli/templates.py,sha256=pC02dyK62YBATf2QYtuj_WgAaIKsUvP3gCItHgfu9UQ,19267
+fluxloop_cli/templates.py,sha256=SvJrz0xqZ7VxkXnQ4FgffiClLuno3tMAG5qNJF4SwKc,19277
 fluxloop_cli/validators.py,sha256=_bLXmxUSzVrDtLjqyTba0bDqamRIaOUHhV4xZ7K36Xw,1155
 fluxloop_cli/commands/__init__.py,sha256=i8xTg7uE9B6ExA0EP_j2h9DZWhD-eC94a-7khXIzRwo,243
 fluxloop_cli/commands/config.py,sha256=9moP68pcNBnJYGMcptgdU1UW-6WlI-Nan6eykPdwl8I,12121
@@ -19,21 +19,21 @@ fluxloop_cli/commands/doctor.py,sha256=svoz9wbLv5Byj9G1Y9GI5lYpVdoG2e7IzfG7tZxuM
 fluxloop_cli/commands/evaluate.py,sha256=itxb3TyfqV44DaCczC3oC94cJ2rmz2cIpY-794eXhvQ,7229
 fluxloop_cli/commands/generate.py,sha256=6tBanI8gj5Zzwz2cv1YeW60bYiO7iWivD0AgOcJ-GUU,7172
 fluxloop_cli/commands/init.py,sha256=eugHrsOTaXQmX5jxRNGSO3C3SpRVI5BCSqP9GqmGHPQ,8156
-fluxloop_cli/commands/parse.py,sha256=GIBkkcwyW-nyjJe_V64jGjickkyKQbR09gERlaqAGy4,12493
+fluxloop_cli/commands/parse.py,sha256=5dgoHt6x2h7SBf6AOlbafoIWz3psEBrJdZyErIvgSgw,15417
 fluxloop_cli/commands/record.py,sha256=IfoXdFAentyerBrIdQeweYr_kM7DjGks2aoKjjqCZ9Q,5139
-fluxloop_cli/commands/run.py,sha256=lqiZ5qGh_PbFdtlBq3BIqm0oc2DFhfg3yWEjergvoTk,14345
+fluxloop_cli/commands/run.py,sha256=OMT9XrDBDZACyQ_8tlUiqSIRq6QROH25Uc1PHZoEHyU,16849
 fluxloop_cli/commands/status.py,sha256=ERZrWoSP3V7dz5A_TEE5b8E0nGwsPggP4nXw4tLOzxE,7841
 fluxloop_cli/evaluation/__init__.py,sha256=voMYkA4S5Gb3GyvpTU8JnKu0novOyZBEag1cYEqYi1Q,759
 fluxloop_cli/evaluation/artifacts.py,sha256=zDVB-SSQZ1JYWLPHwrfz5AuCv46pUFZfEfFY_5doAjQ,2176
 fluxloop_cli/evaluation/config.py,sha256=r_rBpx9uYNZtdJVbJnsgohIATHTaqKX03hg4Vb051KM,24656
 fluxloop_cli/evaluation/llm.py,sha256=-0jHKPbaZTF5obO8x0zmKXnLWLg5zDqK4ryM0IDMVuE,14769
-fluxloop_cli/evaluation/rules.py,sha256=OwB0SqXMroKAYmys-Tb7VGIlwixYWqpFqB6ztSJb5Hs,8412
+fluxloop_cli/evaluation/rules.py,sha256=CflbgpqHnguxy6YBBpIHwiS-3SyU0HAxU3obKbawQi4,14372
 fluxloop_cli/evaluation/engine/__init__.py,sha256=08untLwO5PlFSdqqsupsXAnFBcCEUaw22wcVBVZlJxA,145
 fluxloop_cli/evaluation/engine/analysis.py,sha256=dESfsHBSfL9jcEFVcnD7UMxU_G_cozqsx_adAfZmjk4,15432
-fluxloop_cli/evaluation/engine/core.py,sha256=PK71zEm277q55LpDqtDGeDqX4m6sEN0HTg1p9jtaSfc,13226
+fluxloop_cli/evaluation/engine/core.py,sha256=kS8-yqMwF57hycITdKjrmLy3sbBOv-bDzj1QhM5AQTA,13676
 fluxloop_cli/evaluation/engine/success.py,sha256=BVPi-W-RJtymGXhzOfS2x0VF3UTAaoZ44LEoIy2flIQ,10930
 fluxloop_cli/evaluation/engine/reporting/__init__.py,sha256=1e-lBuUuZ5n4fFnNTN-eyeHI-W0XGNaSCUb1kLzeIYs,1634
-fluxloop_cli/evaluation/engine/reporting/html.py,sha256=vv4uhnZiEAVFCP8LPJ0GOPZ1Ttdy2dybdNJdX_F2Uno,20409
+fluxloop_cli/evaluation/engine/reporting/html.py,sha256=xG4l5wIXF4_T9Wjt9mcjOdp-yE1y3EADij4IPpyndSQ,37387
 fluxloop_cli/evaluation/engine/reporting/markdown.py,sha256=HSe15m6_rPCnd-4QNKDVy0qlqfzgHOPgyQzrkXzXDfI,7296
 fluxloop_cli/evaluation/prompts/__init__.py,sha256=0pQGcZkZXM4ZgZU4B1Lvdc6W2ii0KUNr5g0vcns8F8k,1326
 fluxloop_cli/evaluation/prompts/base.py,sha256=SL-wYCwCdfFr2VqgaXVQB6pR2PcVSf9O-aHhJ3mrtoI,1319
@@ -41,8 +41,8 @@ fluxloop_cli/evaluation/prompts/information_completeness.py,sha256=BjZ-wEIANWWBQ
 fluxloop_cli/evaluation/prompts/intent_recognition.py,sha256=QlroUq1y0wwWsT2qcS1NXdo7OwNqUu4Tw2xx7Frr50Q,1572
 fluxloop_cli/evaluation/prompts/response_clarity.py,sha256=1OYyx39UfS-YR__VdqhLejHNxH1NBVFm7Bha3MuMN9Y,1418
 fluxloop_cli/evaluation/prompts/response_consistency.py,sha256=tyO3Wsf2J_CvErCuNc2bw-UQWqRW_BupaBj3CS66_Yk,1550
-fluxloop_cli-0.2.26.dist-info/METADATA,sha256=dlH0AMgT0745fO--U4immDQl7tPP0K27B0pJYj1lsuM,6329
-fluxloop_cli-0.2.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fluxloop_cli-0.2.26.dist-info/entry_points.txt,sha256=NxOEMku4yLMY5kp_Qcd3JcevfXP6A98FsSf9xHcwkyE,51
-fluxloop_cli-0.2.26.dist-info/top_level.txt,sha256=ahLkaxzwhmVU4z-YhkmQVzAbW3-wez9cKnwPiDK7uKM,13
-fluxloop_cli-0.2.26.dist-info/RECORD,,
+fluxloop_cli-0.2.28.dist-info/METADATA,sha256=Vs5b3XsEL5irrC2_8DzahTy1bfD-O3JznpzTqB5hxsY,6329
+fluxloop_cli-0.2.28.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fluxloop_cli-0.2.28.dist-info/entry_points.txt,sha256=NxOEMku4yLMY5kp_Qcd3JcevfXP6A98FsSf9xHcwkyE,51
+fluxloop_cli-0.2.28.dist-info/top_level.txt,sha256=ahLkaxzwhmVU4z-YhkmQVzAbW3-wez9cKnwPiDK7uKM,13
+fluxloop_cli-0.2.28.dist-info/RECORD,,