reprompt-cli 1.7.1__tar.gz → 1.8.1__tar.gz

{reprompt_cli-1.7.1 → reprompt_cli-1.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reprompt-cli
-Version: 1.7.1
+Version: 1.8.1
 Summary: Discover, analyze, and optimize your prompts from AI coding sessions
 Project-URL: Homepage, https://github.com/reprompt-dev/reprompt
 Project-URL: Repository, https://github.com/reprompt-dev/reprompt
@@ -185,7 +185,7 @@ reprompt install-hook               # adds post-session hook to Claude Code
 
 Capture prompts from ChatGPT, Claude.ai, and Gemini directly in your browser:
 
-1. **Install the extension** from [Chrome Web Store](https://chromewebstore.google.com/detail/reprompt/ojdccpagaanchmkninlbgbgemdcjckhn)
+1. **Install the extension** from [Chrome Web Store](https://chromewebstore.google.com/detail/reprompt/ojdccpagaanchmkninlbgbgemdcjckhn) or [Firefox Add-ons](https://addons.mozilla.org/addon/reprompt-cli/)
 2. **Connect to the CLI:** `reprompt install-extension`
 3. **Verify:** `reprompt extension-status`
 
@@ -236,6 +236,7 @@ reprompt lint --json                # machine-readable output
 
 - **Website:** [getreprompt.dev](https://getreprompt.dev)
 - **Chrome Extension:** [Chrome Web Store](https://chromewebstore.google.com/detail/reprompt/ojdccpagaanchmkninlbgbgemdcjckhn)
+- **Firefox Add-on:** [Firefox Add-ons](https://addons.mozilla.org/addon/reprompt-cli/)
 - **PyPI:** [reprompt-cli](https://pypi.org/project/reprompt-cli/)
 - **Changelog:** [CHANGELOG.md](CHANGELOG.md)
 - **Privacy:** [getreprompt.dev/privacy](https://getreprompt.dev/privacy)

{reprompt_cli-1.7.1 → reprompt_cli-1.8.1}/README.md

@@ -140,7 +140,7 @@ reprompt install-hook               # adds post-session hook to Claude Code
 
 Capture prompts from ChatGPT, Claude.ai, and Gemini directly in your browser:
 
-1. **Install the extension** from [Chrome Web Store](https://chromewebstore.google.com/detail/reprompt/ojdccpagaanchmkninlbgbgemdcjckhn)
+1. **Install the extension** from [Chrome Web Store](https://chromewebstore.google.com/detail/reprompt/ojdccpagaanchmkninlbgbgemdcjckhn) or [Firefox Add-ons](https://addons.mozilla.org/addon/reprompt-cli/)
 2. **Connect to the CLI:** `reprompt install-extension`
 3. **Verify:** `reprompt extension-status`
 
@@ -191,6 +191,7 @@ reprompt lint --json                # machine-readable output
 
 - **Website:** [getreprompt.dev](https://getreprompt.dev)
 - **Chrome Extension:** [Chrome Web Store](https://chromewebstore.google.com/detail/reprompt/ojdccpagaanchmkninlbgbgemdcjckhn)
+- **Firefox Add-on:** [Firefox Add-ons](https://addons.mozilla.org/addon/reprompt-cli/)
 - **PyPI:** [reprompt-cli](https://pypi.org/project/reprompt-cli/)
 - **Changelog:** [CHANGELOG.md](CHANGELOG.md)
 - **Privacy:** [getreprompt.dev/privacy](https://getreprompt.dev/privacy)

{reprompt_cli-1.7.1 → reprompt_cli-1.8.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reprompt-cli"
-version = "1.7.1"
+version = "1.8.1"
 description = "Discover, analyze, and optimize your prompts from AI coding sessions"
 readme = "README.md"
 license = { text = "MIT" }

{reprompt_cli-1.7.1 → reprompt_cli-1.8.1}/src/reprompt/__init__.py

@@ -1,6 +1,6 @@
 """reprompt — Discover, analyze, and evolve your best prompts from AI coding sessions."""
 
-__version__ = "1.7.0"
+__version__ = "1.8.1"
 
 __all__ = [
     "__version__",

{reprompt_cli-1.7.1 → reprompt_cli-1.8.1}/src/reprompt/cli.py

@@ -1474,6 +1474,7 @@ def insights(
     from reprompt.config import Settings
     from reprompt.core.insights import (
         compute_insights,
+        get_cross_session_repetition_insight,
         get_effectiveness_insight,
         get_similar_prompts_insight,
     )
@@ -1487,12 +1488,14 @@ def insights(
     # Expanded sections
     eff_data = get_effectiveness_insight(db, source=source)
     sim_data = get_similar_prompts_insight(db, source=source)
+    rep_data = get_cross_session_repetition_insight(db, source=source)
 
     if json_output:
         import json as json_mod
 
         result["effectiveness"] = eff_data
         result["similar_prompts"] = sim_data
+        result["cross_session_repetition"] = rep_data
         typer.echo(json_mod.dumps(result, indent=2))
     else:
         from reprompt.core.suggestions import get_suggestion
@@ -1516,6 +1519,15 @@ def insights(
                 '  [dim]\u2192 Try: reprompt template save "..." (reuse instead of rewrite)[/dim]'
             )
 
+        if rep_data:
+            rate_pct = f"{rep_data['repetition_rate'] * 100:.0f}%"
+            n = rep_data["total_recurring_topics"]
+            console.print("\n  [bold]Cross-Session Repetition[/bold]")
+            console.print(f"  {rate_pct} of prompts recur across sessions ({n} topics)")
+            for t in rep_data["top_topics"]:
+                console.print(f'    "{t["canonical_text"]}" \u2014 {t["session_count"]} sessions')
+            console.print("  [dim]\u2192 Try: reprompt repetition (full analysis)[/dim]")
+
         hint = get_suggestion("insights")
         if hint:
             console.print(f"\n  [dim]\u2192 Try: {hint}[/dim]")
@@ -1525,6 +1537,7 @@ def insights(
 
         result["effectiveness"] = eff_data
         result["similar_prompts"] = sim_data
+        result["cross_session_repetition"] = rep_data
         _copy_to_clip(json_mod.dumps(result, indent=2), quiet=json_output)
 
 
@@ -1856,7 +1869,7 @@ def _create_host_wrapper() -> Path:
     # Find the Python executable that has reprompt installed
     python_path = sys_mod.executable
 
-    wrapper_path.write_text(f"#!/bin/sh\nexec {python_path} -u -m reprompt.bridge.host\n")
+    wrapper_path.write_text(f'#!/bin/sh\nexec "{python_path}" -u -m reprompt.bridge.host\n')
     wrapper_path.chmod(wrapper_path.stat().st_mode | stat.S_IEXEC)
     return wrapper_path
 
@@ -1916,6 +1929,102 @@ def extension_status() -> None:
         console.print("  Last sync:         never")
 
 
+@app.command(rich_help_panel="Analyze")
+def sessions(
+    last: int = typer.Option(10, "--last", help="Show N most recent sessions"),
+    source: str = typer.Option(
+        None, "--source", "-s", help="Filter by source (e.g. claude-code, cursor)"
+    ),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    detail: str = typer.Option(None, "--detail", help="Deep-dive into a session ID"),
+    copy: bool = typer.Option(False, "--copy", help="Copy result to clipboard"),
+) -> None:
+    """Session quality overview: composite scores, frustration signals, trends."""
+    import json as json_mod
+
+    from reprompt.config import Settings
+    from reprompt.output.sessions_terminal import render_session_detail, render_sessions_table
+    from reprompt.storage.db import PromptDB
+
+    settings = Settings()
+    db = PromptDB(settings.db_path)
+
+    if detail:
+        # Single session detail view
+        all_sessions = db.get_sessions_with_quality(limit=500)
+        match = next((s for s in all_sessions if s.get("session_id") == detail), None)
+        if not match:
+            # Try prefix match
+            match = next(
+                (s for s in all_sessions if (s.get("session_id") or "").startswith(detail)),
+                None,
+            )
+        if not match:
+            typer.echo(f"Session '{detail}' not found.")
+            raise typer.Exit(1)
+        if json_output:
+            typer.echo(json_mod.dumps(match, indent=2, default=str))
+        else:
+            typer.echo(render_session_detail(match), nl=False)
+    else:
+        data = db.get_sessions_with_quality(limit=last, source=source)
+        if json_output:
+            typer.echo(json_mod.dumps(data, indent=2, default=str))
+        else:
+            typer.echo(render_sessions_table(data), nl=False)
+
+            from reprompt.core.suggestions import get_suggestion
+
+            hint = get_suggestion("sessions")
+            if hint:
+                console.print(f"\n  [dim]\u2192 Try: {hint}[/dim]")
+
+    if copy:
+        if detail:
+            copy_text = json_mod.dumps(match, indent=2, default=str)  # type: ignore[possibly-undefined]
+        else:
+            copy_text = json_mod.dumps(data, indent=2, default=str)  # type: ignore[possibly-undefined]
+        _copy_to_clip(copy_text, quiet=json_output)
+
+
+@app.command(rich_help_panel="Analyze")
+def repetition(
+    last: int = typer.Option(500, "--last", help="Analyze N most recent unique prompts"),
+    source: str = typer.Option(
+        None, "--source", "-s", help="Filter by source (e.g. claude-code, cursor)"
+    ),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    copy: bool = typer.Option(False, "--copy", help="Copy result to clipboard"),
+) -> None:
+    """Detect recurring prompts across different sessions."""
+    import json as json_mod
+    from dataclasses import asdict
+
+    from reprompt.config import Settings
+    from reprompt.core.repetition import analyze_repetition
+    from reprompt.output.repetition_terminal import render_repetition_report
+    from reprompt.storage.db import PromptDB
+
+    settings = Settings()
+    db = PromptDB(settings.db_path)
+    report = analyze_repetition(db, source=source, limit=last)
+
+    if json_output:
+        typer.echo(json_mod.dumps(asdict(report), indent=2, default=str))
+    else:
+        typer.echo(render_repetition_report(report), nl=False)
+
+        from reprompt.core.suggestions import get_suggestion
+
+        hint = get_suggestion("repetition")
+        if hint:
+            console.print(f"\n  [dim]\u2192 Try: {hint}[/dim]")
+
+    if copy:
+        copy_text = json_mod.dumps(asdict(report), indent=2, default=str)
+        _copy_to_clip(copy_text, quiet=json_output)
+
+
 @app.command(rich_help_panel="Analyze")
 def agent(
     last: int = typer.Option(5, "--last", help="Analyze N most recent sessions"),

{reprompt_cli-1.7.1 → reprompt_cli-1.8.1}/src/reprompt/core/insights.py

@@ -293,3 +293,29 @@ def get_similar_prompts_insight(
         "total_clusters": len(clusters),
         "total_clustered_prompts": sum(c["size"] for c in clusters),
     }
+
+
+def get_cross_session_repetition_insight(
+    db: PromptDB,
+    source: str | None = None,
+) -> dict[str, Any] | None:
+    """Return cross-session repetition summary, or None if no recurring topics."""
+    from reprompt.core.repetition import analyze_repetition
+
+    report = analyze_repetition(db, source=source, limit=500)
+
+    if not report.recurring_topics:
+        return None
+
+    return {
+        "repetition_rate": report.repetition_rate,
+        "top_topics": [
+            {
+                "canonical_text": t.canonical_text[:80],
+                "session_count": t.session_count,
+                "total_matches": t.total_matches,
+            }
+            for t in report.recurring_topics[:3]
+        ],
+        "total_recurring_topics": len(report.recurring_topics),
+    }

{reprompt_cli-1.7.1 → reprompt_cli-1.8.1}/src/reprompt/core/pipeline.py

@@ -185,6 +185,105 @@ def run_scan(
             except Exception:
                 logger.debug("Session metadata extraction failed for %s", file_path, exc_info=True)
 
+    # Compute session quality scores
+    from datetime import datetime
+
+    from reprompt.core.agent import analyze_session
+    from reprompt.core.conversation import Conversation
+    from reprompt.core.distill import distill_conversation
+    from reprompt.core.session_quality import score_session
+
+    quality_failures = 0
+    for file_path, adapter_name in scanned_files:
+        try:
+            matched = next((a for a in adapters if a.name == adapter_name), None)
+            if not matched:
+                continue
+
+            # parse_conversation returns list[ConversationTurn], wrap into Conversation
+            turns = matched.parse_conversation(Path(file_path))
+            if not turns:
+                continue
+
+            session_id = Path(file_path).stem
+            start_time = None
+            end_time = None
+            duration = None
+            timestamps = [t.timestamp for t in turns if t.timestamp]
+            if len(timestamps) >= 2:
+                start_time = timestamps[0]
+                end_time = timestamps[-1]
+                try:
+                    start_dt = datetime.fromisoformat(start_time.replace("Z", "+00:00"))
+                    end_dt = datetime.fromisoformat(end_time.replace("Z", "+00:00"))
+                    duration = int((end_dt - start_dt).total_seconds())
+                except (ValueError, TypeError):
+                    pass
+
+            project = None
+            if hasattr(matched, "_project_from_path"):
+                project = matched._project_from_path(file_path)
+
+            conversation = Conversation(
+                session_id=session_id,
+                source=adapter_name,
+                project=project,
+                turns=turns,
+                start_time=start_time,
+                end_time=end_time,
+                duration_seconds=duration,
+            )
+
+            # Agent analysis (efficiency, error loops)
+            agent_report = None
+            try:
+                agent_report = analyze_session(conversation)
+            except Exception:
+                logger.warning("Agent analysis failed for %s", file_path, exc_info=True)
+
+            # Distill analysis (focus/retention)
+            distill_result = None
+            try:
+                distill_result = distill_conversation(conversation)
+            except Exception:
+                logger.warning("Distill analysis failed for %s", file_path, exc_info=True)
+
+            # Avg prompt score from stored features
+            avg_prompt_score = None
+            scores = db.get_prompt_scores_for_session(session_id)
+            if scores:
+                avg_prompt_score = sum(scores) / len(scores)
+
+            # Effectiveness score from session_meta
+            effectiveness = db.get_effectiveness_for_session(session_id)
+
+            quality = score_session(
+                conversation,
+                agent_report=agent_report,
+                distill_result=distill_result,
+                effectiveness_score=effectiveness,
+                avg_prompt_score=avg_prompt_score,
+            )
+            db.upsert_session_quality(
+                session_id=quality.session_id,
+                quality_score=quality.quality_score,
+                prompt_quality_score=quality.prompt_quality,
+                efficiency_score=quality.efficiency,
+                focus_score=quality.focus,
+                outcome_score=quality.outcome,
+                has_abandonment=quality.frustration.abandonment,
+                has_escalation=quality.frustration.escalation,
+                stall_turns=quality.frustration.stall_turns,
+                session_type=quality.session_type,
+                quality_insight=quality.insight,
+            )
+        except Exception:
+            quality_failures += 1
+            logger.warning("Session quality scoring failed for %s", file_path, exc_info=True)
+
+    if quality_failures:
+        logger.warning("Quality scoring failed for %d session(s)", quality_failures)
+
     # Mark sessions processed only after successful dedup+store
     for file_path, adapter_name in scanned_files:
         db.mark_session_processed(file_path, source=adapter_name)

reprompt_cli-1.8.1/src/reprompt/core/repetition.py

@@ -0,0 +1,128 @@
+"""Cross-session prompt repetition detection.
+
+Identifies recurring topics asked across different AI coding sessions
+using TF-IDF + containment similarity clustering. All analysis is
+rule-based (zero LLM).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from reprompt.storage.db import PromptDB
+
+
+@dataclass
+class RecurringTopic:
+    """A topic that recurs across multiple sessions."""
+
+    canonical_text: str
+    session_count: int
+    total_matches: int
+    session_ids: list[str] = field(default_factory=list)
+    earliest: str = ""
+    latest: str = ""
+
+
+@dataclass
+class RepetitionReport:
+    """Result of cross-session repetition analysis."""
+
+    total_prompts_analyzed: int = 0
+    cross_session_matches: int = 0
+    repetition_rate: float = 0.0  # cross_session_matches / total
+    recurring_topics: list[RecurringTopic] = field(default_factory=list)
+    total_sessions: int = 0
+
+
+def analyze_repetition(
+    db: PromptDB,
+    source: str | None = None,
+    limit: int = 500,
+    threshold: float = 0.75,
+) -> RepetitionReport:
+    """Detect recurring prompts across different sessions.
+
+    Reuses merge_view.build_clusters() for similarity, then filters
+    to clusters spanning 2+ distinct sessions.
+    """
+    from reprompt.core.merge_view import build_clusters
+
+    all_prompts = db.get_all_prompts(source=source)
+
+    # Filter to unique prompts only
+    unique = [p for p in all_prompts if p.get("duplicate_of") is None]
+
+    if not unique:
+        return RepetitionReport()
+
+    # Limit to most recent N (by id desc), then reverse for chronological
+    unique.sort(key=lambda p: p.get("id", 0), reverse=True)
+    unique = unique[:limit]
+    unique.reverse()
+
+    # Build lookup: text → prompt dict (safe due to hash uniqueness)
+    text_to_prompt: dict[str, dict[str, Any]] = {}
+    for p in unique:
+        text_to_prompt[p["text"]] = p
+
+    texts = [p["text"] for p in unique]
+    timestamps = [p.get("timestamp", "") for p in unique]
+    all_session_ids = {p.get("session_id") or "unknown" for p in unique}
+
+    # Build clusters using existing infrastructure
+    clusters = build_clusters(texts, timestamps, threshold=threshold)
+
+    # Filter to cross-session clusters
+    recurring: list[RecurringTopic] = []
+    total_cross_matches = 0
+
+    for cluster in clusters:
+        # Collect all texts in cluster (canonical + members)
+        cluster_texts = [cluster["canonical"]["text"]]
+        cluster_texts.extend(m["text"] for m in cluster["members"])
+
+        # Map to session_ids
+        sids: list[str] = []
+        cluster_timestamps: list[str] = []
+        for t in cluster_texts:
+            prompt = text_to_prompt.get(t)
+            if prompt:
+                sids.append(prompt.get("session_id") or "unknown")
+                cluster_timestamps.append(prompt.get("timestamp", ""))
+
+        distinct_sessions = sorted(set(sids))
+        if len(distinct_sessions) < 2:
+            continue
+
+        # Build timestamps for range
+        valid_ts = sorted(t for t in cluster_timestamps if t)
+        earliest = valid_ts[0] if valid_ts else ""
+        latest = valid_ts[-1] if valid_ts else ""
+
+        recurring.append(
+            RecurringTopic(
+                canonical_text=cluster["canonical"]["text"],
+                session_count=len(distinct_sessions),
+                total_matches=len(cluster_texts),
+                session_ids=distinct_sessions,
+                earliest=earliest,
+                latest=latest,
+            )
+        )
+        total_cross_matches += len(cluster_texts)
+
+    # Sort by session_count desc, then total_matches desc
+    recurring.sort(key=lambda t: (-t.session_count, -t.total_matches))
+
+    total = len(unique)
+    rate = total_cross_matches / total if total > 0 else 0.0
+
+    return RepetitionReport(
+        total_prompts_analyzed=total,
+        cross_session_matches=total_cross_matches,
+        repetition_rate=round(rate, 3),
+        recurring_topics=recurring,
+        total_sessions=len(all_session_ids),
+    )

reprompt_cli-1.8.1/src/reprompt/core/session_quality.py

@@ -0,0 +1,201 @@
+"""Session-level quality metrics — composite scoring + frustration detection.
+
+Combines prompt quality, agent efficiency, distill focus, and outcome
+into a single 0-100 session score. All analysis is rule-based (zero LLM, <1ms).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from reprompt.core.agent import AgentReport
+from reprompt.core.conversation import Conversation, ConversationTurn, DistillResult
+
+# ---------------------------------------------------------------------------
+# Component weights (must sum to 1.0)
+# ---------------------------------------------------------------------------
+
+DEFAULT_WEIGHTS: dict[str, float] = {
+    "prompt_quality": 0.30,
+    "efficiency": 0.30,
+    "focus": 0.20,
+    "outcome": 0.20,
+}
+
+
+# ---------------------------------------------------------------------------
+# Dataclasses
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class FrustrationSignals:
+    """Frustration indicators detected from conversation turns."""
+
+    abandonment: bool = False  # Last 3+ assistant turns all have errors
+    escalation: bool = False  # Error rate in second half > first half * 1.5
+    stall_turns: int = 0  # Assistant turns with 0 tool calls and <50 chars
+
+
+@dataclass
+class SessionQuality:
+    """Composite session quality report."""
+
+    session_id: str
+    quality_score: float  # 0-100 composite
+    prompt_quality: float | None = None  # 0-100
+    efficiency: float | None = None  # 0-100
+    focus: float | None = None  # 0-100
+    outcome: float | None = None  # 0-100
+    frustration: FrustrationSignals = field(default_factory=FrustrationSignals)
+    session_type: str | None = None
+    insight: str = ""
+    components_available: int = 0
+
+
+# ---------------------------------------------------------------------------
+# Frustration detection
+# ---------------------------------------------------------------------------
+
+
+def _detect_frustration(turns: list[ConversationTurn]) -> FrustrationSignals:
+    """Detect frustration signals from conversation turns."""
+    asst_turns = [t for t in turns if t.role == "assistant"]
+
+    if not asst_turns:
+        return FrustrationSignals()
+
+    # Abandonment: last 3+ assistant turns all have errors
+    abandonment = False
+    if len(asst_turns) >= 3:
+        last_three = asst_turns[-3:]
+        abandonment = all(t.has_error for t in last_three)
+
+    # Escalation: error rate in second half > first half * 1.5
+    escalation = False
+    if len(asst_turns) >= 4:
+        mid = len(asst_turns) // 2
+        first_half = asst_turns[:mid]
+        second_half = asst_turns[mid:]
+        first_rate = sum(1 for t in first_half if t.has_error) / len(first_half)
+        second_rate = sum(1 for t in second_half if t.has_error) / len(second_half)
+        escalation = second_rate > first_rate * 1.5 and second_rate > 0.2
+
+    # Stall turns: assistant turns with no tool calls and short text
+    stall_turns = sum(1 for t in asst_turns if t.tool_calls == 0 and len(t.text.strip()) < 50)
+
+    return FrustrationSignals(
+        abandonment=abandonment,
+        escalation=escalation,
+        stall_turns=stall_turns,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Insight generation
+# ---------------------------------------------------------------------------
+
+
+def _generate_insight(quality: SessionQuality) -> str:
+    """Generate a one-line insight from quality metrics (priority order)."""
+    f = quality.frustration
+
+    if f.abandonment:
+        return "Ended with unresolved errors"
+
+    if f.escalation:
+        return "Errors escalated through session"
+
+    if f.stall_turns >= 5:
+        return f"{f.stall_turns} stall turns detected"
+
+    if quality.efficiency is not None and quality.efficiency < 50:
+        return "Low efficiency (error loops)"
+
+    score = quality.quality_score
+    if score >= 80:
+        return "Focused session"
+    if score >= 60:
+        return "Solid session"
+    if score >= 40:
+        return "Room for improvement"
+    return "Rough session"
+
+
+# ---------------------------------------------------------------------------
+# Main scoring function
+# ---------------------------------------------------------------------------
+
+
+def score_session(
+    conversation: Conversation,
+    *,
+    agent_report: AgentReport | None = None,
+    distill_result: DistillResult | None = None,
+    effectiveness_score: float | None = None,
+    avg_prompt_score: float | None = None,
+) -> SessionQuality:
+    """Compute composite session quality score (0-100).
+
+    Components (weighted average of available inputs):
+    - prompt_quality (30%): avg overall_score from prompt features
+    - efficiency (30%): productive_ratio from agent analysis
+    - focus (20%): retention_ratio from distill
+    - outcome (20%): effectiveness_score
+
+    When a component is unavailable, its weight redistributes proportionally.
+    """
+    components: dict[str, float] = {}
+
+    # Prompt quality: already 0-100
+    if avg_prompt_score is not None:
+        components["prompt_quality"] = max(0.0, min(100.0, avg_prompt_score))
+
+    # Efficiency: productive_ratio is 0-1
+    if agent_report is not None:
+        ratio = agent_report.efficiency.productive_ratio
+        components["efficiency"] = max(0.0, min(100.0, ratio * 100))
+
+    # Focus: retention_ratio is 0-1
+    if distill_result is not None:
+        ratio = distill_result.stats.retention_ratio
+        components["focus"] = max(0.0, min(100.0, ratio * 100))
+
+    # Outcome: effectiveness_score is 0-1
+    if effectiveness_score is not None:
+        components["outcome"] = max(0.0, min(100.0, effectiveness_score * 100))
+
+    # Compute weighted average with weight redistribution
+    if components:
+        available_weights = {k: DEFAULT_WEIGHTS[k] for k in components}
+        weight_sum = sum(available_weights.values())
+        normalized = {k: w / weight_sum for k, w in available_weights.items()}
+        quality_score = sum(components[k] * normalized[k] for k in components)
+    else:
+        quality_score = 0.0
+
+    quality_score = round(max(0.0, min(100.0, quality_score)), 1)
+
+    # Frustration detection
+    frustration = _detect_frustration(conversation.turns)
+
+    # Session type
+    session_type_str: str | None = None
+    if agent_report is not None and agent_report.efficiency.session_type is not None:
+        session_type_str = agent_report.efficiency.session_type
+
+    quality = SessionQuality(
+        session_id=conversation.session_id,
+        quality_score=quality_score,
+        prompt_quality=components.get("prompt_quality"),
+        efficiency=components.get("efficiency"),
+        focus=components.get("focus"),
+        outcome=components.get("outcome"),
+        frustration=frustration,
+        session_type=session_type_str,
+        components_available=len(components),
+    )
+
+    quality.insight = _generate_insight(quality)
+
+    return quality