benchflow 0.7.2.dev1994__py3-none-any.whl → 0.7.2.dev2000__py3-none-any.whl

benchflow/cli/_traj_upload_ui.py

@@ -20,10 +20,29 @@ from rich.progress import (
 from rich.table import Table
 from rich.text import Text
 
-from benchflow.publish.redact import REDACTED
+from benchflow.publish.redact import REDACTED, format_redaction_breakdown
 from benchflow.publish.traj_capture import StagedFile
 from benchflow.publish.traj_report import PREVIEW_WORD_LIMIT, TrajectoryReport
 
+# Redaction-transparency copy shown with the masked-value count. The wording is
+# deliberately honest: redaction is a local structural pass (no agents, no
+# token spend), and the server independently rescans staged artifacts.
+NO_MASKING_NEEDED_COPY = (
+    "No secrets or personal identifiers detected — nothing needed masking."
+)
+REDACTION_REASSURANCE_COPY = (
+    "Redaction ran locally before anything was staged; "
+    "the server independently rescans and rejects any survivor."
+)
+
+
+def masked_for_you_line(report: TrajectoryReport) -> str:
+    """Itemized ``Masked for you`` copy for a report with masked values."""
+    breakdown = format_redaction_breakdown(dict(report.masked_categories))
+    if not breakdown:  # category data unavailable — fall back to the total
+        breakdown = f"{report.masked_values} secret-like values"
+    return f"{breakdown} — originals never leave this machine"
+
 
 def render_trajectory_report(report: TrajectoryReport, *, console: Console) -> None:
     """Render upload facts and a bounded, already-redacted trajectory preview."""
@@ -43,8 +62,17 @@ def render_trajectory_report(report: TrajectoryReport, *, console: Console) -> N
         "API keys / secrets masked",
         Text(str(report.masked_values), style="bold green"),
     )
+    if report.masked_values:
+        facts.add_row(
+            "Masked for you",
+            Text(masked_for_you_line(report), style="green"),
+        )
+    else:
+        facts.add_row("Masked for you", Text(NO_MASKING_NEEDED_COPY, style="dim"))
     facts.add_row("Safe replacement", Text(REDACTED))
     console.print(Panel(facts, title="Trajectory report", border_style="cyan"))
+    if report.masked_values:
+        console.print(f"[dim]{REDACTION_REASSURANCE_COPY}[/dim]")
 
     if not report.preview:
         return

benchflow/cli/main.py

@@ -1239,11 +1239,25 @@ def eval_view(
             ),
         ),
     ] = False,
+    redaction_summary: Annotated[
+        str | None,
+        typer.Option(
+            "--redaction-summary",
+            help=(
+                "Masked-secret breakdown shown in the --confirm bar, e.g. "
+                "'2 API keys, 1 bearer token' (lift it from "
+                "`bench traj upload PATH --dry-run`). Display-only; no effect "
+                "without --confirm."
+            ),
+        ),
+    ] = None,
 ) -> None:
     """View a trial or session trajectory in the browser."""
     from benchflow.trajectories import viewer
 
-    decision = viewer.serve(str(rollout_dir), port, confirm=confirm)
+    decision = viewer.serve(
+        str(rollout_dir), port, confirm=confirm, redaction_summary=redaction_summary
+    )
     # Exit-code contract for --confirm: 0 approved, 3 rejected. 3 is chosen
     # so a rejection never collides with the CLI's existing error exits
     # (1 = errors, 2 = Typer usage errors).

benchflow/cli/traj.py

@@ -23,6 +23,7 @@ from benchflow.cli._traj_upload_ui import (
     render_trajectory_report,
     upload_progress,
 )
+from benchflow.publish.redact import format_redaction_breakdown
 from benchflow.publish.traj_capture import (
     StagedCapture,
     default_source_id,
@@ -291,17 +292,23 @@ def register_traj(app: typer.Typer) -> None:
 def _run_upload(options: _UploadOptions) -> None:
     prompted = options.path is None
     path = options.path or _prompt_for_path()
-    repo_slug: str | None = None
+    detected: _DetectedRepo | None = None
     if options.source_id is not None:
         source_id = options.source_id
     else:
         if options.repo:
-            repo_slug = _detect_repo_slug(path)
-        source_id = f"repo/{repo_slug}" if repo_slug else default_source_id(path)
-    if repo_slug:
-        # Contributor-visible metadata: surface the tag so private-repo
-        # sessions can opt out before anything leaves the machine.
-        console.print(f"Repo: {repo_slug} (use --no-repo to omit)")
+            detected = _detect_repo_slug(path)
+        source_id = f"repo/{detected.slug}" if detected else default_source_id(path)
+    if detected:
+        # Contributor-visible metadata: surface the tag and where it came
+        # from so private-repo sessions can opt out before anything leaves
+        # the machine. The local path stays terminal-only; the uploaded
+        # source id is just repo/<owner>/<name>. Plain print keeps the line
+        # one physical line (no Rich wrapping) so the path stays selectable.
+        print(
+            f"Repo: {detected.slug} "
+            f"(from session cwd {detected.session_cwd}; use --no-repo to omit)"
+        )
     destination = _resolve_destination(options)
 
     with (
@@ -314,6 +321,7 @@ def _run_upload(options: _UploadOptions) -> None:
             artifacts.files,
             masked_values=artifacts.redaction_replacements,
             preview_steps=options.preview_steps,
+            masked_categories=artifacts.redaction_categories,
         )
         status.stop()
         render_trajectory_report(report, console=console)
@@ -417,25 +425,35 @@ def _infer_email() -> str:
 _SESSION_CWD_SCAN_LINES = 50
 
 
-def _detect_repo_slug(path: Path) -> str | None:
+@dataclass(frozen=True)
+class _DetectedRepo:
+    slug: str
+    session_cwd: Path
+
+
+def _detect_repo_slug(path: Path) -> _DetectedRepo | None:
     """Best-effort ``owner/name`` for the repository the session was about.
 
     Reads the working directory the session recorded (Claude events carry a
-    ``cwd`` field; Codex ``session_meta`` payloads do too), asks that
-    directory's git for the ``origin`` remote, and falls back to the
-    invocation directory. Every failure is silent — repo tagging must never
-    break an upload — and local-path remotes never produce a tag, so no
-    local absolute path can leak into the manifest.
+    ``cwd`` field; Codex ``session_meta`` payloads do too) and asks that
+    directory's git for the ``origin`` remote. The trajectory's own recorded
+    cwd is the ONLY provenance source: there is deliberately no fallback to
+    the upload invocation directory, which mis-attributed sessions recorded
+    outside a repo to whatever checkout the contributor happened to upload
+    from. No session cwd, a missing directory, or no GitHub remote all mean
+    no tag. Every failure is silent — repo tagging must never break an
+    upload — and local-path remotes never produce a tag, so no local
+    absolute path can leak into the manifest.
     """
-    for candidate in (_session_cwd(path), Path.cwd()):
-        if candidate is None or not candidate.is_dir():
-            continue
-        remote = _command_stdout(
-            "git", "-C", str(candidate), "remote", "get-url", "origin"
-        )
-        slug = _repo_slug_from_remote(remote) if remote else None
-        if slug:
-            return slug
+    session_cwd = _session_cwd(path)
+    if session_cwd is None or not session_cwd.is_dir():
+        return None
+    remote = _command_stdout(
+        "git", "-C", str(session_cwd), "remote", "get-url", "origin"
+    )
+    slug = _repo_slug_from_remote(remote) if remote else None
+    if slug:
+        return _DetectedRepo(slug=slug, session_cwd=session_cwd)
     return None
 
 
@@ -633,6 +651,13 @@ def _print_dry_run(staged: StagedCapture) -> None:
     if staged.ignored:
         console.print(f"Ignored: {escape(', '.join(staged.ignored))}")
     console.print(f"Redactions: {staged.redaction_replacements}")
+    # One plain, greppable line so the upload skill can lift the breakdown into
+    # the viewer's confirm bar (bench eval view --redaction-summary "...").
+    breakdown = format_redaction_breakdown(dict(staged.artifact_redaction_categories))
+    if breakdown:
+        print(f"Masked for you: {breakdown}")
+    else:
+        print("Masked for you: nothing — no secrets detected")
 
 
 def _print_contributor_prompt() -> None:

benchflow/publish/redact.py

@@ -4,10 +4,19 @@ from __future__ import annotations
 
 import re
 import shlex
+from collections import Counter
 from collections.abc import Mapping, Sequence
 from typing import Any, NamedTuple
 
-from benchflow.trajectories.types import redact_trajectory_text_with_count
+from benchflow.trajectories.types import (
+    REDACTION_CATEGORY_API_KEY,
+    REDACTION_CATEGORY_BEARER_TOKEN,
+    REDACTION_CATEGORY_CREDENTIAL_FIELD,
+    REDACTION_CATEGORY_PASSWORD,
+    REDACTION_CATEGORY_PRIVATE_KEY,
+    REDACTION_CATEGORY_URL_CREDENTIAL,
+    redact_trajectory_text_with_categories,
+)
 
 REDACTED = "<XXX-benchflow-key-values-XXX>"
 _CANONICAL_REDACTED = "***REDACTED***"
@@ -67,23 +76,81 @@ COMPACT_SENSITIVE_KEY_SUFFIXES = tuple(
 class RedactionPattern(NamedTuple):
     pattern: re.Pattern[str]
     replacement: str
+    category: str
 
 
 VALUE_PATTERNS = (
     # Google AI Studio's newer token format is not covered by the canonical
     # trajectory redactor yet.
-    RedactionPattern(re.compile(r"AQ\.[0-9A-Za-z_-]{20,}"), REDACTED),
+    RedactionPattern(
+        re.compile(r"AQ\.[0-9A-Za-z_-]{20,}"), REDACTED, REDACTION_CATEGORY_API_KEY
+    ),
     RedactionPattern(
         re.compile(r"Bearer\s+[A-Za-z0-9._~+/=-]{16,}", re.IGNORECASE),
         f"Bearer {REDACTED}",
+        REDACTION_CATEGORY_BEARER_TOKEN,
     ),
 )
 
+# Display order and pluralized labels for the per-category breakdown shown to
+# contributors ("Masked for you: 2 API keys, 1 bearer token"). Keys are the
+# canonical category names from ``benchflow.trajectories.types``; the taxonomy
+# names what the redaction rules actually detect — nothing more.
+REDACTION_CATEGORY_LABELS: tuple[tuple[str, str], ...] = (
+    (REDACTION_CATEGORY_API_KEY, "API keys"),
+    (REDACTION_CATEGORY_BEARER_TOKEN, "bearer tokens"),
+    (REDACTION_CATEGORY_PRIVATE_KEY, "private key blocks"),
+    (REDACTION_CATEGORY_PASSWORD, "passwords"),
+    (REDACTION_CATEGORY_URL_CREDENTIAL, "URL credentials"),
+    (REDACTION_CATEGORY_CREDENTIAL_FIELD, "credential-bearing field values"),
+)
+
+
+def redaction_breakdown(counts: Mapping[str, int]) -> tuple[tuple[str, int], ...]:
+    """Return non-zero category counts in canonical display order."""
+    ordered = [
+        (category, counts[category])
+        for category, _ in REDACTION_CATEGORY_LABELS
+        if counts.get(category)
+    ]
+    # Unknown categories cannot arise from this module's own accumulation, but
+    # persisted/forwarded counts must never be dropped silently.
+    ordered.extend(
+        (category, count)
+        for category, count in counts.items()
+        if count and category not in dict(REDACTION_CATEGORY_LABELS)
+    )
+    return tuple(ordered)
+
+
+def format_redaction_breakdown(counts: Mapping[str, int]) -> str:
+    """Render category counts as prose, e.g. ``2 API keys, 1 bearer token``."""
+    plurals = dict(REDACTION_CATEGORY_LABELS)
+    parts = []
+    for category, count in redaction_breakdown(counts):
+        label = category if count == 1 else plurals.get(category, f"{category}s")
+        parts.append(f"{count} {label}")
+    return ", ".join(parts)
 
-def redact_value(value: Any, *, field_name: str | None = None) -> tuple[Any, int]:
-    """Return a structurally redacted JSON value and replacement count."""
+
+def redact_value(
+    value: Any,
+    *,
+    field_name: str | None = None,
+    categories: Counter[str] | None = None,
+) -> tuple[Any, int]:
+    """Return a structurally redacted JSON value and replacement count.
+
+    When *categories* is given, every replacement also increments the matching
+    per-category counter (see ``REDACTION_CATEGORY_LABELS``); the counter's
+    total always equals the returned replacement count.
+    """
     if field_name is not None and _is_sensitive_key(field_name):
-        return (value, 0) if _is_redacted_value(value) else (REDACTED, 1)
+        if _is_redacted_value(value):
+            return value, 0
+        if categories is not None:
+            categories[_field_category(field_name)] += 1
+        return REDACTED, 1
 
     if isinstance(value, Mapping):
         redacted: dict[Any, Any] = {}
@@ -104,7 +171,7 @@ def redact_value(value: Any, *, field_name: str | None = None) -> tuple[Any, int
         for key, item in value.items():
             clean_key = key
             if isinstance(key, str):
-                _, key_replacements = _redact_text(key)
+                _, key_replacements = _redact_text(key, categories=categories)
                 if key_replacements:
                     secret_key_index += 1
                     clean_key = f"***REDACTED_KEY_{secret_key_index}***"
@@ -122,73 +189,102 @@ def redact_value(value: Any, *, field_name: str | None = None) -> tuple[Any, int
                     if isinstance(key, str)
                     else None
                 ),
+                categories=categories,
             )
             redacted[clean_key] = clean
             replacements += count
         return redacted, replacements
 
     if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
-        return _redact_argv(value, redact_other_values=True)
+        return _redact_argv(value, redact_other_values=True, categories=categories)
 
     if not isinstance(value, str):
         return value, 0
 
-    return _redact_text(value)
+    return _redact_text(value, categories=categories)
 
 
-def redact_value_to_stability(value: Any) -> tuple[Any, int]:
+def redact_value_to_stability(
+    value: Any, *, categories: Counter[str] | None = None
+) -> tuple[Any, int]:
     """Redact until another server-side pass would make no replacements."""
     redacted = value
     replacements = 0
     for _ in range(_MAX_REDACTION_PASSES):
-        redacted, count = redact_value(redacted)
+        redacted, count = redact_value(redacted, categories=categories)
         replacements += count
         if count == 0:
             return redacted, replacements
     raise ValueError("trajectory secret redaction did not converge")
 
 
-def _redact_text(value: str) -> tuple[str, int]:
+def _redact_text(
+    value: str, *, categories: Counter[str] | None = None
+) -> tuple[str, int]:
     # The canonical carrier patterns intentionally ignore their asterisk marker.
     # Protect our public-upload marker with that value during the scan so a second
     # client/server pass is idempotent even inside text such as ``API_KEY=...``.
     protected = value.replace(REDACTED, _CANONICAL_REDACTED)
-    redacted_text, replacements = redact_trajectory_text_with_count(protected)
+    redacted_text, text_categories = redact_trajectory_text_with_categories(protected)
+    replacements = sum(text_categories.values())
+    if categories is not None:
+        categories.update(text_categories)
     redacted_text = redacted_text.replace(_CANONICAL_REDACTED, REDACTED)
-    for pattern, replacement in VALUE_PATTERNS:
+    for pattern, replacement, category in VALUE_PATTERNS:
         redacted_text, count = pattern.subn(replacement, redacted_text)
         replacements += count
-    cli_redacted, cli_replacements = _redact_cli_text(redacted_text)
+        if count and categories is not None:
+            categories[category] += count
+    cli_redacted, cli_replacements = _redact_cli_text(
+        redacted_text, categories=categories
+    )
     redacted_text = cli_redacted
     replacements += cli_replacements
     return redacted_text, replacements
 
 
-def _redact_cli_text(value: str) -> tuple[str, int]:
+def _redact_cli_text(
+    value: str, *, categories: Counter[str] | None = None
+) -> tuple[str, int]:
     if "--" not in value:
         return value, 0
     try:
         argv = shlex.split(value)
     except ValueError:
         return value, 0
-    redacted, replacements = _redact_argv(argv, redact_other_values=False)
-    return (shlex.join(redacted), replacements) if replacements else (value, 0)
+    # Count categories only for the accepted result: a zero-replacement parse
+    # returns the original text, so nothing may be attributed for it.
+    argv_categories: Counter[str] | None = None if categories is None else Counter()
+    redacted, replacements = _redact_argv(
+        argv, redact_other_values=False, categories=argv_categories
+    )
+    if not replacements:
+        return value, 0
+    if categories is not None and argv_categories is not None:
+        categories.update(argv_categories)
+    return shlex.join(redacted), replacements
 
 
 def _redact_argv(
-    values: Sequence[Any], *, redact_other_values: bool
+    values: Sequence[Any],
+    *,
+    redact_other_values: bool,
+    categories: Counter[str] | None = None,
 ) -> tuple[list[Any], int]:
     redacted: list[Any] = []
     replacements = 0
-    redact_next = False
+    sensitive_option: str | None = None
     for item in values:
-        if redact_next:
+        if sensitive_option is not None:
+            option = sensitive_option
+            sensitive_option = None
             if _is_redacted_value(item):
                 redacted.append(item)
             else:
                 redacted.append(REDACTED)
                 replacements += 1
-            redact_next = False
+                if categories is not None:
+                    categories[_field_category(option)] += 1
             continue
 
         if isinstance(item, str) and item.startswith("-"):
@@ -200,13 +296,16 @@ def _redact_argv(
                     else:
                         redacted.append(f"{option}={REDACTED}")
                         replacements += 1
+                        if categories is not None:
+                            categories[_field_category(option)] += 1
                 else:
                     redacted.append(item)
-                    redact_next = not separator
+                    if not separator:
+                        sensitive_option = option
                 continue
 
         if redact_other_values:
-            clean, count = redact_value(item)
+            clean, count = redact_value(item, categories=categories)
             redacted.append(clean)
             replacements += count
         else:
@@ -220,6 +319,22 @@ def _is_redacted_value(value: Any) -> bool:
     )
 
 
+def _field_category(field_name: str) -> str:
+    """Categorize a masked value by the credential-bearing name that matched.
+
+    Structural redaction fires on the field/option NAME, so the name is the
+    only honest signal for what kind of secret the value was.
+    """
+    compact = _normalize_key(field_name).replace("_", "")
+    if compact.endswith(("password", "passwd")):
+        return REDACTION_CATEGORY_PASSWORD
+    if compact.endswith("apikey"):
+        return REDACTION_CATEGORY_API_KEY
+    if compact.endswith("authorization") or "bearertoken" in compact:
+        return REDACTION_CATEGORY_BEARER_TOKEN
+    return REDACTION_CATEGORY_CREDENTIAL_FIELD
+
+
 def _is_sensitive_key(field_name: str) -> bool:
     normalized = _normalize_key(field_name)
     return (

benchflow/publish/traj_capture.py

@@ -7,6 +7,7 @@ import json
 import re
 import shutil
 import tempfile
+from collections import Counter
 from collections.abc import Iterator, Mapping
 from contextlib import contextmanager
 from dataclasses import dataclass
@@ -15,7 +16,11 @@ from pathlib import Path
 from typing import Any, Never
 
 from benchflow import __version__
-from benchflow.publish.redact import redact_value, redact_value_to_stability
+from benchflow.publish.redact import (
+    redact_value,
+    redact_value_to_stability,
+    redaction_breakdown,
+)
 
 MAX_FILE_BYTES = 128 * 1024**2
 MAX_ARTIFACTS = 8
@@ -81,6 +86,10 @@ class StagedTrajectoryArtifacts:
     _metadata_dir: Path | None
     _staging_dir: Path
     _redact: bool
+    # Per-category artifact replacement counts in display order (display-only:
+    # the manifest/server contract stays untouched). Sums to
+    # ``redaction_replacements``.
+    redaction_categories: tuple[tuple[str, int], ...] = ()
 
 
 @dataclass(frozen=True)
@@ -92,6 +101,8 @@ class StagedCapture:
     ignored: tuple[str, ...]
     artifact_redaction_replacements: int
     redaction_replacements: int
+    # Display-only per-category counts for the artifact replacements.
+    artifact_redaction_categories: tuple[tuple[str, int], ...] = ()
 
 
 @dataclass(frozen=True)
@@ -199,12 +210,15 @@ def stage_trajectory_artifacts(
         staging_dir = Path(temp_name)
         payloads: list[StagedFile] = []
         replacement_count = 0
+        replacement_categories: Counter[str] = Counter()
         for source in resolved.files:
             relname = validate_artifact_name(f"trajectory/{source.name}")
             target = staging_dir / relname
             target.parent.mkdir(parents=True, exist_ok=True)
             if redact:
-                replacements = _redact_jsonl(source, target)
+                replacements = _redact_jsonl(
+                    source, target, categories=replacement_categories
+                )
                 replacement_count += replacements
             else:
                 shutil.copyfile(source, target)
@@ -240,6 +254,7 @@ def stage_trajectory_artifacts(
             _metadata_dir=resolved.metadata_dir,
             _staging_dir=staging_dir,
             _redact=redact,
+            redaction_categories=redaction_breakdown(replacement_categories),
         )
 
 
@@ -305,6 +320,7 @@ def finalize_trajectory_capture(
         ignored=artifacts.ignored,
         artifact_redaction_replacements=artifacts.redaction_replacements,
         redaction_replacements=replacement_count,
+        artifact_redaction_categories=artifacts.redaction_categories,
     )
 
 
@@ -430,7 +446,9 @@ def _validate_jsonl(path: Path) -> None:
         raise ValueError(f"trajectory JSONL has no records: {path}")
 
 
-def _redact_jsonl(source: Path, target: Path) -> int:
+def _redact_jsonl(
+    source: Path, target: Path, *, categories: Counter[str] | None = None
+) -> int:
     replacements = 0
     with (
         source.open(encoding="utf-8", newline="") as input_stream,
@@ -443,7 +461,9 @@ def _redact_jsonl(source: Path, target: Path) -> int:
                 continue
             value = strict_json_loads(body)
             try:
-                redacted, count = redact_value_to_stability(value)
+                redacted, count = redact_value_to_stability(
+                    value, categories=categories
+                )
             except RecursionError as exc:  # defense in depth after complexity gate
                 raise ValueError(
                     f"{source}: line {line_number}: trajectory JSONL nesting "

benchflow/publish/traj_report.py

@@ -54,9 +54,20 @@ class TrajectoryReport:
     created_at_source: str
     masked_values: int
     preview: tuple[TrajectoryPreviewStep, ...]
+    # Per-category masked-value counts, display order, summing to
+    # ``masked_values``. Display-only: the manifest ``trajectory_report``
+    # contract (``TrajectoryReportInfo``, ``extra="forbid"``, exact
+    # recompute-equality on the server) must not gain fields, so
+    # ``as_manifest_metadata`` deliberately excludes this.
+    masked_categories: tuple[tuple[str, int], ...] = ()
 
     def as_manifest_metadata(self) -> dict[str, Any]:
-        """Serialize every displayed report field for the upload manifest."""
+        """Serialize every displayed report field for the upload manifest.
+
+        ``masked_categories`` is intentionally absent: the server validates
+        ``trajectory_report`` with ``extra="forbid"`` and an exact equality
+        check against its own recomputation, so new fields would be rejected.
+        """
         return {
             "primary_file": self.primary_file,
             "format": self.format.value,
@@ -133,6 +144,7 @@ def build_trajectory_report(
     *,
     masked_values: int,
     preview_steps: int = DEFAULT_PREVIEW_STEPS,
+    masked_categories: tuple[tuple[str, int], ...] = (),
 ) -> TrajectoryReport:
     """Summarize one canonical trajectory view from staged, redacted artifacts."""
     if not artifacts:
@@ -183,6 +195,7 @@ def build_trajectory_report(
         created_at_source=created_at_source,
         masked_values=masked_values,
         preview=tuple(analysis.preview),
+        masked_categories=masked_categories,
     )
 
 

benchflow/trajectories/types.py

@@ -179,6 +179,18 @@ def _exchange_token_usage(exchange: "LLMExchange") -> TokenUsage:
     )
 
 
+# Human-facing redaction categories. Every canonical pattern below is tagged
+# with the kind of secret its rule actually detects, so the upload preview can
+# tell contributors WHAT was masked ("2 API keys, 1 bearer token") instead of
+# only how many values. The taxonomy names the real rules — there is no
+# PII/email detection, so no such category exists.
+REDACTION_CATEGORY_API_KEY = "API key"
+REDACTION_CATEGORY_BEARER_TOKEN = "bearer token"
+REDACTION_CATEGORY_PRIVATE_KEY = "private key block"
+REDACTION_CATEGORY_PASSWORD = "password"
+REDACTION_CATEGORY_URL_CREDENTIAL = "URL credential"
+REDACTION_CATEGORY_CREDENTIAL_FIELD = "credential-bearing field value"
+
 # Quote atom for the header/key-value carriers below: a run of 0-8 optional
 # backslashes followed by an optional quote. This makes every carrier fire on raw
 # text (``"k": "v"``), Python dict-repr (``'k': 'v'``), AND json.dumps-escaped
@@ -202,7 +214,7 @@ _SECVAL = r"[^\"'\s,}\\*&]+"
 # ``{0,64}`` makes each match attempt O(1) → overall O(n) (#830 ReDoS fix).
 _NAME = r"[A-Za-z0-9_]{0,64}"
 
-_REDACTION_PATTERNS: list[tuple[re.Pattern[str], str]] = [
+_REDACTION_PATTERNS: list[tuple[re.Pattern[str], str, str]] = [
     # PEM private-key blocks (GCP/Vertex service-account JSON, RSA keys). Redact
     # the whole armored block incl. the base64 body; the carriers below stop at
     # the first space and would leave the key material. Lazy + length-capped body
@@ -214,17 +226,23 @@ _REDACTION_PATTERNS: list[tuple[re.Pattern[str], str]] = [
             r"-----END [A-Z0-9 ]{0,40}PRIVATE KEY-----"
         ),
         "***REDACTED***",
+        REDACTION_CATEGORY_PRIVATE_KEY,
     ),
     # --- Token families: redacted WHOLE (prefix included) so the v0.5 leak audit
     # greps (``AIzaSy``/``dtn_``…) see no live-key shape (#537/#585). ---
     # Anthropic: sk-ant-api03-...
-    (re.compile(r"sk-ant-[a-zA-Z0-9_-]{12,}"), "***REDACTED***"),
+    (
+        re.compile(r"sk-ant-[a-zA-Z0-9_-]{12,}"),
+        "***REDACTED***",
+        REDACTION_CATEGORY_API_KEY,
+    ),
     # BenchFlow proxy master key (sk-benchflow-<token_urlsafe(24)>), OpenAI service
     # account (sk-svcacct-), OpenRouter (sk-or-v1-): rare labels that won't appear
     # in a normal kebab slug, so the hyphen-permitting entropy class is safe here.
     (
         re.compile(r"sk-(?:benchflow|svcacct|or-v1)-[A-Za-z0-9_-]{12,}"),
         "***REDACTED***",
+        REDACTION_CATEGORY_API_KEY,
     ),
     # OpenAI org-scoped sk-proj-/sk-admin-: `proj`/`admin` ARE common identifier
     # words, so a bare hyphen class would redact kebab slugs like
@@ -236,33 +254,58 @@ _REDACTION_PATTERNS: list[tuple[re.Pattern[str], str]] = [
             r"sk-(?:proj|admin)-(?=[A-Za-z0-9_-]{0,200}[A-Z])[A-Za-z0-9_-]{12,}"
         ),
         "***REDACTED***",
+        REDACTION_CATEGORY_API_KEY,
     ),
     # OpenAI / generic sk- (alphanumeric only — widening to include `-` would
     # match common slugs like `task-sk-us-east-1-...`)
-    (re.compile(r"sk-[a-zA-Z0-9]{12,}"), "***REDACTED***"),
+    (re.compile(r"sk-[a-zA-Z0-9]{12,}"), "***REDACTED***", REDACTION_CATEGORY_API_KEY),
     # Google AI / Gemini: AIzaSy... (≥20 char suffix avoids matching `AIzaSy`
     # alone). Prefix is redacted too so the audit grep for `AIzaSy` is clean.
-    (re.compile(r"AIzaSy[A-Za-z0-9_-]{20,}"), "***REDACTED***"),
+    (
+        re.compile(r"AIzaSy[A-Za-z0-9_-]{20,}"),
+        "***REDACTED***",
+        REDACTION_CATEGORY_API_KEY,
+    ),
     # AWS access keys: AKIA/ASIA + exactly 16 chars; length anchor avoids
     # matching English words like "ASIAPACIFIC".
-    (re.compile(r"(?:AKIA|ASIA)[A-Z0-9]{16}(?![A-Z0-9])"), "***REDACTED***"),
+    (
+        re.compile(r"(?:AKIA|ASIA)[A-Z0-9]{16}(?![A-Z0-9])"),
+        "***REDACTED***",
+        REDACTION_CATEGORY_API_KEY,
+    ),
     # Daytona SDK tokens: dtn_... — ≥16 char suffix avoids short ids (`dtn_v2`).
-    (re.compile(r"dtn_[A-Za-z0-9_]{16,}"), "***REDACTED***"),
+    (
+        re.compile(r"dtn_[A-Za-z0-9_]{16,}"),
+        "***REDACTED***",
+        REDACTION_CATEGORY_API_KEY,
+    ),
     # GitHub tokens: PATs / OAuth / app / refresh (ghp_/gho_/ghu_/ghs_/ghr_) and
     # fine-grained PATs (github_pat_...). ≥20 char suffix avoids short slugs.
-    (re.compile(r"(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}"), "***REDACTED***"),
-    (re.compile(r"github_pat_[A-Za-z0-9_]{20,}"), "***REDACTED***"),
+    (
+        re.compile(r"(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}"),
+        "***REDACTED***",
+        REDACTION_CATEGORY_API_KEY,
+    ),
+    (
+        re.compile(r"github_pat_[A-Za-z0-9_]{20,}"),
+        "***REDACTED***",
+        REDACTION_CATEGORY_API_KEY,
+    ),
     # Slack tokens: bot/user/app/refresh/legacy (xoxb-/xoxp-/xoxa-/xoxr-/xoxs-).
-    (re.compile(r"xox[baprs]-[A-Za-z0-9-]{10,}"), "***REDACTED***"),
+    (
+        re.compile(r"xox[baprs]-[A-Za-z0-9-]{10,}"),
+        "***REDACTED***",
+        REDACTION_CATEGORY_API_KEY,
+    ),
     # Other provider key families with distinctive prefixes — caught here for the
     # bare-token-in-prose form that no NAME=value carrier sees (a provider
     # exception that echoes the key). Groq gsk_, xAI xai-, Replicate r8_,
     # HuggingFace hf_, Fireworks fw_. ≥20-char anchors avoid short ids (#830).
-    (re.compile(r"gsk_[A-Za-z0-9]{20,}"), "***REDACTED***"),
-    (re.compile(r"xai-[A-Za-z0-9]{20,}"), "***REDACTED***"),
-    (re.compile(r"r8_[A-Za-z0-9]{20,}"), "***REDACTED***"),
-    (re.compile(r"hf_[A-Za-z0-9]{20,}"), "***REDACTED***"),
-    (re.compile(r"fw_[A-Za-z0-9]{20,}"), "***REDACTED***"),
+    (re.compile(r"gsk_[A-Za-z0-9]{20,}"), "***REDACTED***", REDACTION_CATEGORY_API_KEY),
+    (re.compile(r"xai-[A-Za-z0-9]{20,}"), "***REDACTED***", REDACTION_CATEGORY_API_KEY),
+    (re.compile(r"r8_[A-Za-z0-9]{20,}"), "***REDACTED***", REDACTION_CATEGORY_API_KEY),
+    (re.compile(r"hf_[A-Za-z0-9]{20,}"), "***REDACTED***", REDACTION_CATEGORY_API_KEY),
+    (re.compile(r"fw_[A-Za-z0-9]{20,}"), "***REDACTED***", REDACTION_CATEGORY_API_KEY),
     # JSON Web Tokens (session/bearer creds): three base64url segments split by
     # dots. The ``eyJ`` prefix is base64url of ``{"`` — a JWT header. The 3rd
     # (signature) segment requires ≥20 chars (real HS256/RS256 sigs are 43+) so
@@ -275,6 +318,7 @@ _REDACTION_PATTERNS: list[tuple[re.Pattern[str], str]] = [
             r"eyJ[A-Za-z0-9_-]{10,512}\.[A-Za-z0-9_-]{6,512}\.[A-Za-z0-9_-]{20,512}"
         ),
         "***REDACTED***",
+        REDACTION_CATEGORY_BEARER_TOKEN,
     ),
     # --- URL credentials ---
     # Credentials in a URL's userinfo (scheme://user:pass@host) for KNOWN
@@ -293,6 +337,7 @@ _REDACTION_PATTERNS: list[tuple[re.Pattern[str], str]] = [
             r"[^\s/?#:@]{0,256}:[^\s/?#]{0,256}@"
         ),
         r"\1***REDACTED***@",
+        REDACTION_CATEGORY_URL_CREDENTIAL,
     ),
     # Secrets carried as URL query params. Curated EXACT param names (anchored to
     # `?`/`&` with `=` right after the name) so non-secret params (`?page=`,
@@ -317,6 +362,7 @@ _REDACTION_PATTERNS: list[tuple[re.Pattern[str], str]] = [
             re.IGNORECASE,
         ),
         r"\1***REDACTED***",
+        REDACTION_CATEGORY_URL_CREDENTIAL,
     ),
     # Azure SAS `?sig=<token>` — bare `sig` is excluded from the curated list above
     # (a `?sig=v2` scheme-version flag is a common non-secret), so gate on a
@@ -326,6 +372,7 @@ _REDACTION_PATTERNS: list[tuple[re.Pattern[str], str]] = [
     (
         re.compile(r"([?&]sig=)[^&\s\"'*]{16,}", re.IGNORECASE),
         r"\1***REDACTED***",
+        REDACTION_CATEGORY_URL_CREDENTIAL,
     ),
     # --- Header / key-value secret carriers ---
     # Match `name: value` / `name=value` in raw, JSON, Python dict-repr
@@ -340,6 +387,7 @@ _REDACTION_PATTERNS: list[tuple[re.Pattern[str], str]] = [
             re.IGNORECASE,
         ),
         r"\1***REDACTED***",
+        REDACTION_CATEGORY_API_KEY,
     ),
     # Underscore form `api_key`. No leading boundary: namespaced env dumps like
     # `GEMINI_API_KEY=secret` / JSON keys such as `"openai_api_key"` must redact
@@ -349,6 +397,7 @@ _REDACTION_PATTERNS: list[tuple[re.Pattern[str], str]] = [
             rf"({_ESCQ}api_key{_ESCQ}\s*[:=]\s*{_ESCQ}){_SECVAL}", re.IGNORECASE
         ),
         r"\1***REDACTED***",
+        REDACTION_CATEGORY_API_KEY,
     ),
     # `master_key`/`master-key` and `private_key`/`private-key` carriers — the
     # BenchFlow proxy master key and GCP/Vertex service-account private-key field
@@ -359,6 +408,7 @@ _REDACTION_PATTERNS: list[tuple[re.Pattern[str], str]] = [
             re.IGNORECASE,
         ),
         r"\1***REDACTED***",
+        REDACTION_CATEGORY_CREDENTIAL_FIELD,
     ),
     # Bearer-token env vars whose NAME has BEARER_TOKEN in the MIDDLE, e.g.
     # `AWS_BEARER_TOKEN_BEDROCK=` — the secret-suffix rule below anchors its marker
@@ -371,6 +421,7 @@ _REDACTION_PATTERNS: list[tuple[re.Pattern[str], str]] = [
             re.IGNORECASE,
         ),
         r"\1***REDACTED***",
+        REDACTION_CATEGORY_BEARER_TOKEN,
     ),
     # Generic secret-NAME-suffix carriers: names ending in TOKEN/SECRET/PASSWORD or
     # a specific *secret* key suffix (ACCESS_KEY/SECRET_KEY/ACCOUNT_KEY/…). The KEY
@@ -388,6 +439,7 @@ _REDACTION_PATTERNS: list[tuple[re.Pattern[str], str]] = [
             re.IGNORECASE,
         ),
         r"\1***REDACTED***",
+        REDACTION_CATEGORY_CREDENTIAL_FIELD,
     ),
     # authorization header WITH a scheme (Bearer/Token/Basic/…): keep scheme.
     (
@@ -397,6 +449,7 @@ _REDACTION_PATTERNS: list[tuple[re.Pattern[str], str]] = [
             re.IGNORECASE,
         ),
         r"\1***REDACTED***",
+        REDACTION_CATEGORY_BEARER_TOKEN,
     ),
     # authorization header with a bare value (no recognized scheme). The negative
     # lookahead skips scheme-prefixed values already handled above, so
@@ -409,6 +462,7 @@ _REDACTION_PATTERNS: list[tuple[re.Pattern[str], str]] = [
             re.IGNORECASE,
         ),
         r"\1***REDACTED***",
+        REDACTION_CATEGORY_BEARER_TOKEN,
     ),
 ]
 
@@ -428,11 +482,25 @@ def redact_trajectory_text(text: str) -> str:
 
 def redact_trajectory_text_with_count(text: str) -> tuple[str, int]:
     """Apply the canonical patterns and report how many matches were replaced."""
-    replacements = 0
-    for pattern, replacement in _REDACTION_PATTERNS:
+    text, categories = redact_trajectory_text_with_categories(text)
+    return text, sum(categories.values())
+
+
+def redact_trajectory_text_with_categories(text: str) -> tuple[str, dict[str, int]]:
+    """Apply the canonical patterns and report replacements per category.
+
+    Categories name the kind of secret each rule actually detects (API key,
+    bearer token, private key block, URL credential, credential-bearing field
+    value) so upload previews can itemize what was masked without inventing
+    detection that does not exist. The total replacement count is the sum of
+    the returned values.
+    """
+    categories: dict[str, int] = {}
+    for pattern, replacement, category in _REDACTION_PATTERNS:
         text, count = pattern.subn(replacement, text)
-        replacements += count
-    return text, replacements
+        if count:
+            categories[category] = categories.get(category, 0) + count
+    return text, categories
 
 
 def redact_trajectory_obj(obj: Any) -> Any:

benchflow/trajectories/viewer.py

@@ -97,9 +97,11 @@ body { padding-bottom: 104px; }
 .confirm-btn.approve:hover { background: #262626; }
 .confirm-btn.reject { background: var(--card); color: var(--ink); border: 1px solid var(--rule-strong); }
 .confirm-btn.reject:hover { background: var(--secondary); }
+.confirm-note { flex-basis: 100%; font-size: 12.5px; color: var(--muted); }
 </style>
 <div class="confirm-bar">
 <div class="confirm-inner" id="confirm-inner">
+<!--BENCHFLOW-REDACTION-NOTE-->
 <span class="confirm-question">Submit this trajectory to the BenchFlow eval prize?</span>
 <div class="confirm-actions">
 <button class="confirm-btn approve" onclick="__benchDecide('approve')">Approve &amp; submit</button>
@@ -124,11 +126,33 @@ async function __benchDecide(choice) {
 """
 
 
-def _inject_confirm_bar(page: str) -> str:
+_REDACTION_NOTE_MARKER = "<!--BENCHFLOW-REDACTION-NOTE-->"
+
+
+def _confirm_bar_html(redaction_summary: str | None) -> str:
+    """Confirm-bar snippet, optionally carrying the redaction-summary note.
+
+    The note is presentation-only text the caller composed (the upload skill
+    lifts it from ``bench traj upload --dry-run``); the viewer itself never
+    redacts, so without a summary the bar is byte-identical to the plain
+    ``--confirm`` bar.
+    """
+    note = ""
+    if redaction_summary:
+        note = (
+            '<div class="confirm-note">Before upload, BenchFlow masks: '
+            f"{html.escape(redaction_summary)}. "
+            "Originals never leave this machine.</div>"
+        )
+    return _CONFIRM_BAR_HTML.replace(_REDACTION_NOTE_MARKER, note, 1)
+
+
+def _inject_confirm_bar(page: str, redaction_summary: str | None = None) -> str:
     """Append the confirm bar just before </body> (or at the end as fallback)."""
+    bar = _confirm_bar_html(redaction_summary)
     if "</body>" in page:
-        return page.replace("</body>", f"{_CONFIRM_BAR_HTML}</body>", 1)
-    return page + _CONFIRM_BAR_HTML
+        return page.replace("</body>", f"{bar}</body>", 1)
+    return page + bar
 
 
 # Small BenchFlow wordmark header (inline SVG logo from the site's icon set —
@@ -407,26 +431,18 @@ def render_rollout(rollout_dir: Path, prompts: list[str] | None = None) -> str:
     while len(prompts) < len(turn_files):
         prompts.append("")
 
-    first_events = _parse_jsonl(turn_files[0].read_text())
-    sys_event = next((e for e in first_events if e.get("type") == "system"), {})
-    total_cost = 0
-    total_turns_count = 0
-
+    all_events: list[dict] = []
     all_blocks = []
     for i, tf in enumerate(turn_files):
         events = _parse_jsonl(tf.read_text())
+        all_events.extend(events)
         all_blocks.append(render_turn(events, i + 1, prompts[i]))
-        for e in events:
-            if e.get("type") == "result":
-                total_cost += e.get("total_cost_usd", 0)
-                total_turns_count += e.get("num_turns", 0)
-
-    # `or "?"` (not just a .get default): a present-but-null value in the
-    # stream-json (e.g. "session_id": null) bypasses the default and would crash
-    # html.escape() / the [:16] slice below with a raw TypeError.
-    session_id = str(sys_event.get("session_id") or "?")
-    model = str(sys_event.get("model") or "?")
-    version = str(sys_event.get("claude_code_version") or "?")
+
+    badges = _stream_header_badges(all_events)
+    badges.append(("turns", str(len(turn_files))))
+    total_cost = _result_cost(all_events)
+    if total_cost is not None:
+        badges.append(("total cost", f"${total_cost:.4f}"))
 
     return f"""<!DOCTYPE html>
 <html>
@@ -440,14 +456,7 @@ def render_rollout(rollout_dir: Path, prompts: list[str] | None = None) -> str:
 <div class="header">
 {_WORDMARK_HTML}
 <h1>{html.escape(rollout_dir.name)}</h1>
-<div class="meta">
-<span>model: {html.escape(model)}</span>
-<span>session: {html.escape(session_id[:16])}...</span>
-<span>claude code: {html.escape(version)}</span>
-<span>turns: {len(turn_files)}</span>
-<span>total cost: ${total_cost:.4f}</span>
-</div>
-</div>
+{_meta_badges_html(badges)}</div>
 {_join_with_divider(all_blocks)}
 </body>
 </html>"""
@@ -648,18 +657,89 @@ def render_jsonl_file(path: Path) -> str:
     body = render_turn(events, 1, "")
     if not body.strip():
         return _NO_TRAJECTORIES_HTML
-    return _stream_json_page(path.name, events, [body])
+    return _stream_json_page(path.name, events, [body], session_fallback=path.stem)
+
+
+def _stream_header_badges(
+    events: list[dict], *, session_fallback: str | None = None
+) -> list[tuple[str, str]]:
+    """Header badges derivable from what the stream actually contains.
+
+    ``claude -p`` stream-json carries a ``type: system`` init event
+    (``session_id`` / ``model`` / ``claude_code_version``); real ``~/.claude``
+    session files don't — their metadata lives per event (``sessionId``,
+    ``version``) and on assistant events (``message.model``). Pull from
+    whichever is present and omit anything unknown: a header of ``?`` badges
+    at the approve moment reads as a broken viewer, not as missing data.
+    Truthiness (not ``.get`` defaults) also swallows present-but-null values
+    like ``"session_id": null``, which previously needed an explicit guard to
+    avoid a TypeError.
+    """
+    sys_event = next((e for e in events if e.get("type") == "system"), {})
 
+    def _first(values) -> object | None:
+        return next((value for value in values if value), None)
 
-def _stream_json_page(title: str, events: list[dict], turn_blocks: list[str]) -> str:
-    sys_event = next((e for e in events if e.get("type") == "system"), {})
-    total_cost = 0.0
+    model = sys_event.get("model") or _first(
+        event["message"].get("model")
+        for event in events
+        if event.get("type") == "assistant" and isinstance(event.get("message"), dict)
+    )
+    session_id = (
+        sys_event.get("session_id")
+        or _first(event.get("sessionId") for event in events)
+        or session_fallback
+    )
+    version = sys_event.get("claude_code_version") or _first(
+        event.get("version") for event in events
+    )
+
+    badges: list[tuple[str, str]] = []
+    if model:
+        badges.append(("model", str(model)))
+    if session_id:
+        sid = str(session_id)
+        badges.append(("session", sid[:16] + ("..." if len(sid) > 16 else "")))
+    if version:
+        badges.append(("claude code", str(version)))
+    return badges
+
+
+def _result_cost(events: list[dict]) -> float | None:
+    """Total cost summed from result events, or ``None`` when no event
+    carries cost data — so the header can hide the badge instead of
+    asserting a fictional ``$0.0000``."""
+    total = 0.0
+    seen = False
     for event in events:
-        if event.get("type") == "result":
-            total_cost += float(event.get("total_cost_usd") or 0)
-    session_id = str(sys_event.get("session_id") or "?")
-    model = str(sys_event.get("model") or "?")
-    version = str(sys_event.get("claude_code_version") or "?")
+        if event.get("type") == "result" and event.get("total_cost_usd") is not None:
+            total += float(event.get("total_cost_usd") or 0)
+            seen = True
+    return total if seen else None
+
+
+def _meta_badges_html(badges: list[tuple[str, str]]) -> str:
+    """The header's ``.meta`` badge row; empty string when nothing is known."""
+    if not badges:
+        return ""
+    spans = "\n".join(
+        f"<span>{html.escape(label)}: {html.escape(value)}</span>"
+        for label, value in badges
+    )
+    return f'<div class="meta">\n{spans}\n</div>\n'
+
+
+def _stream_json_page(
+    title: str,
+    events: list[dict],
+    turn_blocks: list[str],
+    *,
+    session_fallback: str | None = None,
+) -> str:
+    badges = _stream_header_badges(events, session_fallback=session_fallback)
+    total_cost = _result_cost(events)
+    if total_cost is not None:
+        badges.append(("total cost", f"${total_cost:.4f}"))
     return f"""<!DOCTYPE html>
 <html>
 <head>
@@ -672,13 +752,7 @@ def _stream_json_page(title: str, events: list[dict], turn_blocks: list[str]) ->
 <div class="header">
 {_WORDMARK_HTML}
 <h1>{html.escape(title)}</h1>
-<div class="meta">
-<span>model: {html.escape(model)}</span>
-<span>session: {html.escape(session_id[:16])}...</span>
-<span>claude code: {html.escape(version)}</span>
-<span>total cost: ${total_cost:.4f}</span>
-</div>
-</div>
+{_meta_badges_html(badges)}</div>
 {_join_with_divider(turn_blocks)}
 </body>
 </html>"""
@@ -689,6 +763,7 @@ def serve(
     port: int = 8888,
     prompts: list[str] | None = None,
     confirm: bool = False,
+    redaction_summary: str | None = None,
 ) -> str | None:
     """Serve a trial directory or a session JSONL file as a web page.
 
@@ -698,6 +773,11 @@ def serve(
     machine-readable ``DECISION: <value>`` line to stdout. Without it the
     server runs until Ctrl+C and the return value is ``None`` — exactly the
     pre-confirm behavior (no bar, no POST endpoint).
+
+    ``redaction_summary`` is an optional caller-composed line (e.g. ``"2 API
+    keys, 1 bearer token"``) rendered inside the confirm bar so the reviewer
+    sees what upload-time redaction would mask. Presentation-only; it has no
+    effect without ``confirm=True``.
     """
     import threading
     from http.server import HTTPServer, SimpleHTTPRequestHandler
@@ -723,7 +803,7 @@ def serve(
         # interaction against this live server, not part of the artifact.
         (path / "trajectory.html").write_text(html_content)
     if confirm:
-        html_content = _inject_confirm_bar(html_content)
+        html_content = _inject_confirm_bar(html_content, redaction_summary)
 
     print(f"Trajectory viewer: http://localhost:{port}")
     print(f"Trial: {path}")

{benchflow-0.7.2.dev1994.dist-info → benchflow-0.7.2.dev2000.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: benchflow
-Version: 0.7.2.dev1994
+Version: 0.7.2.dev2000
 Summary: Multi-turn agent benchmarking with ACP — run any agent, any model, any provider.
 Project-URL: Homepage, https://github.com/benchflow-ai/benchflow
 Project-URL: Repository, https://github.com/benchflow-ai/benchflow

{benchflow-0.7.2.dev1994.dist-info → benchflow-0.7.2.dev2000.dist-info}/RECORD

@@ -100,7 +100,7 @@ benchflow/cli/_hosted_env.py,sha256=RUwmeITDiDCNl2zimyHJwENOcFkt12uPTmWAYbPL3a4,
 benchflow/cli/_live_progress.py,sha256=tjvU8jjp6AxsJ7qXomk6Jach_nWitYFjO4nw79tjMeE,18707
 benchflow/cli/_options.py,sha256=dG2R5-jjNzvAj513Dscj1TFbH5ukM_ONxYg9vELnE7M,1237
 benchflow/cli/_shared.py,sha256=gE1sCuTUw0SzIK3H3Unpirvs9Rt28fDaVPAyS6Oyhdk,11744
-benchflow/cli/_traj_upload_ui.py,sha256=XjCAeNhbgy3xpaH7OKOc7Stm4WnKw4axss8TuiCbdG4,4895
+benchflow/cli/_traj_upload_ui.py,sha256=2mewoumFvlKGPIz6fR_RNqyPKxmqiGRnpBlc3DBfSa0,6173
 benchflow/cli/adopt.py,sha256=HbsTrQPfxlfnq88lO3MZj1iQzwhjzor8XHoHOUDnyj0,7259
 benchflow/cli/agent.py,sha256=B4X36VIN-KUZSOKVveoJBIm2dsVx9D142CnC0ClIfLM,3547
 benchflow/cli/continue_cmd.py,sha256=I93JosVb3HJitDFMJLOhb7_jihz3UFzTvpbkf1y-kKQ,10098
@@ -108,7 +108,7 @@ benchflow/cli/environment.py,sha256=q3G8G2i0rs_wqGIWzULnnc6Nt8TlJLO12zuYlro-5-A,
 benchflow/cli/eval_artifacts.py,sha256=4CbS8aIaynCk2PUeWA4Qo31F8SH7_rxtwB7po8_O3v4,11275
 benchflow/cli/eval_lift.py,sha256=0Tyn9ZVIzAIeZ9vm0T7onBLre48gliKf0K8NrD7m1j0,3072
 benchflow/cli/hub.py,sha256=uX5O-q_9CMRb9VlW06HkA5EbKUa6xORnNNTNmMM2H_0,7029
-benchflow/cli/main.py,sha256=gjsxz90nwHaYq-SMpfzFG-zSbAzvxW6GZAy6JCbiWe4,48319
+benchflow/cli/main.py,sha256=NQwSGLDGDttzcllFP7z3hY3KojnnelXk_49xd2aghoc,48795
 benchflow/cli/monitor.py,sha256=-0C4OzZqgUj7Lvi5obJVsK-M81OZwaZNEpis71Kqyj4,3427
 benchflow/cli/review.py,sha256=ysR6No9oFu0TgcbucNG9YmXY5FkMUHobdr6F4rHQmQw,7892
 benchflow/cli/sandbox.py,sha256=QrLASbsfzPGVosW_s5XxE3_mcXqTzbU2ZnnC9MADpXM,9849
@@ -116,7 +116,7 @@ benchflow/cli/skills.py,sha256=2Apv1iqvmstWEhY6O-PRdxKc8RYwR6f7MvbYfl2dWm0,7497
 benchflow/cli/tasks.py,sha256=b1XP1EZ79ZtK_1shF65qZyv27EcKKFZYV35M4DzxYKI,18534
 benchflow/cli/trace_import.py,sha256=NHDieFdiKQ-2Sr1-GF8Z5EDcbGsz2qq_kFE0rXacC2o,14705
 benchflow/cli/train.py,sha256=MIP_JxptitH348bWWURpcWt-TmDAw1s8d-RUU7jBaIg,23635
-benchflow/cli/traj.py,sha256=tX4mtAXbEwEhbwegUTHl_IBIFoxKtVlrwrlv8MPf764,24290
+benchflow/cli/traj.py,sha256=uisYWo-f_R_e06sKJPMObYbvDAPJac0zzyU4byGHU7U,25515
 benchflow/continue_run/__init__.py,sha256=dWidng7kJphVUtbP1a1Ma0Lyjxj5yLgQZIApaKCJUew,1479
 benchflow/continue_run/batch.py,sha256=8BNSInyp_Ol6Fcrg4ezBJdi3cBS12nC8mf963_x4fIg,4146
 benchflow/continue_run/orchestrator.py,sha256=wYoseBNE_rZ0EjNwWDyqfave54xNRe43sCd_O4VJjyk,27676
@@ -159,9 +159,9 @@ benchflow/publish/_progress.py,sha256=TWkIH5CVtBj7TL0eqCX57_asrqoHzIYeSLn86NtueB
 benchflow/publish/azure_blob.py,sha256=CpjRdmWc2XGb2q8j8hj2G0hCEoAvHUK8-wmoUU4uZm4,5583
 benchflow/publish/broker.py,sha256=DkJPe8btYMJi5AJZmuQduUh4d9DvTloNsvtiH74VKgk,8842
 benchflow/publish/huggingface.py,sha256=V34xuQYFmL7DPi9W62LESKgzPFmTBdlJxLTZxGmpGBM,3772
-benchflow/publish/redact.py,sha256=SxHfCL6f7cPc5jqFp38yqvIRmKE2mfA4h1NwpiMEciA,7622
-benchflow/publish/traj_capture.py,sha256=hp7Ia4vFqEcqIO9we3vX11Sl7VhQtxzI6gjICsIAo4g,21968
-benchflow/publish/traj_report.py,sha256=3GEjrxqNkXfmJ3G_ve8GLbMTXP7UKmW0TsqJWlEefBw,24829
+benchflow/publish/redact.py,sha256=spO8zTd0Q5PZ3BAs5ZYqhdNiGKUtC8NouaDO1RfDMKI,12153
+benchflow/publish/traj_capture.py,sha256=Z8rBDsUf0Hyv2e6AL9RhGVLV1IxERk97hTEa5ghM-mw,22797
+benchflow/publish/traj_report.py,sha256=2iYeipPrfQcTlAeNhDhWk-vbBTdA5RdXCjcWdEi_VWo,25559
 benchflow/review/__init__.py,sha256=vl7jnLnHGG9aKBux2F9Ni5rf_EPsC-tvauHL-QnyRa4,2080
 benchflow/review/config.py,sha256=WGxH4dRd-qCQVf8hDf4AwXKKGVPx2zkPpna6dgwxFMk,9002
 benchflow/review/default-rubric.json,sha256=Ed5cTrt_q3e7TGERWbjJgNWrrhkTsB_ToP0UMn1vobg,1843
@@ -290,10 +290,10 @@ benchflow/trajectories/results.py,sha256=VAHktYYwMN8ikjSr2OlAgP8IsDpDJp5AJiZGrYi
 benchflow/trajectories/sessions.py,sha256=u_6x1WyT8YtKUVOb6b3myTCHhqn58a8NHCLAvQqKP_Y,4437
 benchflow/trajectories/tree.py,sha256=c0jyoP9OurDQq-zRtPc66edzWUvLGwQQz0jgtyqSw2U,5576
 benchflow/trajectories/trl_sft_tokenization.py,sha256=-Ef0bP9cuzfzOz5nIv2mEF3taQIEw68h6SM1YO-Mwn4,8643
-benchflow/trajectories/types.py,sha256=aSJclec3dOCUlfFNDL8GfzvkAcBo5r-dvlHE0MnGdMo,27554
-benchflow/trajectories/viewer.py,sha256=4V7HMjJtUt8_HE1dStZwzF9W_3yefHNas7R3Y1iZmvY,34760
-benchflow-0.7.2.dev1994.dist-info/METADATA,sha256=BZC_LqHIgXKHtV4fMAqIDeaodQRbu2iDK2awvDuJ3fI,15565
-benchflow-0.7.2.dev1994.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-benchflow-0.7.2.dev1994.dist-info/entry_points.txt,sha256=qPMBVtH4qz3P4nMALEAdTbvpxvsVch9RhqshZKQn1dE,84
-benchflow-0.7.2.dev1994.dist-info/licenses/LICENSE,sha256=ohnbHkuBylrTtOvaZJk9Hz7dRwmaEEGAb5ZcBV4Xuhw,10779
-benchflow-0.7.2.dev1994.dist-info/RECORD,,
+benchflow/trajectories/types.py,sha256=EG_TDTh0JveXk5WJX4YMcEDBjfe3526lC7JjDvQmiw8,30067
+benchflow/trajectories/viewer.py,sha256=L-tMiR15qdGBaTlVNgY4dOS1pIrf4PB24MvNic6lj4s,37715
+benchflow-0.7.2.dev2000.dist-info/METADATA,sha256=IYq47CWBBGAdRObAxld55c_Nbt_mma-kzn0JFrADhbw,15565
+benchflow-0.7.2.dev2000.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+benchflow-0.7.2.dev2000.dist-info/entry_points.txt,sha256=qPMBVtH4qz3P4nMALEAdTbvpxvsVch9RhqshZKQn1dE,84
+benchflow-0.7.2.dev2000.dist-info/licenses/LICENSE,sha256=ohnbHkuBylrTtOvaZJk9Hz7dRwmaEEGAb5ZcBV4Xuhw,10779
+benchflow-0.7.2.dev2000.dist-info/RECORD,,