world-model-optimizer 0.2.0__py3-none-any.whl

wmo/retrieval/retriever.py

@@ -0,0 +1,173 @@
+"""Retrieval over the trace replay buffer (DreamGym Eq. 4).
+
+At each step the world model retrieves the top-k past steps whose (state, action) is most similar to
+the current one, by cosine similarity of an embedding `phi`:
+
+    {d_j} = Topk( cos( phi(s_t, a_t), phi(s_i, a_i) ) )
+
+The buffer is initialized offline from ingested traces (`index`) and enriched online as the agent
+steps (`add`).
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Literal, Protocol, runtime_checkable
+
+import numpy as np
+from numpy.typing import NDArray
+
+from wmo.core.render import encode_action, encode_state_action
+from wmo.core.types import Action, EnvState, Observation, Step, Trace
+from wmo.providers.base import Embedder
+
+# What text phi embeds per step: the full (state, action) summary, or the command-only action.
+RetrievalKey = Literal["state_action", "action"]
+
+# A placeholder observation for query-only encoding: topk embeds (state, action), never the result.
+_EMPTY_OBS = Observation(content="")
+
+
+@runtime_checkable
+class Retriever(Protocol):
+    def index(self, traces: list[Trace]) -> None:
+        """Build phase: embed every step's (state, action) and store it in the buffer."""
+        ...
+
+    def topk(self, state: EnvState, action: Action, k: int) -> list[Step]:
+        """Runtime: return the k most similar prior steps to (state, action)."""
+        ...
+
+    def add(self, step: Step) -> None:
+        """Online enrichment: add a freshly generated step to the buffer."""
+        ...
+
+    def sample(self, n: int) -> list[Step]:
+        """Return up to `n` steps from the buffer (e.g. to seed `wmo play` action suggestions)."""
+        ...
+
+
+class EmbeddingRetriever:
+    """Default Retriever: dense cosine similarity using a provider's embedding model.
+
+    The replay buffer is an in-memory embedding matrix (rows = steps) kept parallel to a
+    ``list[Step]``. ``index`` embeds the whole corpus in one batched ``provider.embed`` call;
+    ``add`` embeds a single step for online enrichment. ``topk`` ranks by cosine similarity,
+    matching DreamGym Eq. 4's ``Topk(cos(phi(s_t,a_t), phi(s_i,a_i)))``.
+    """
+
+    def __init__(self, provider: Embedder, *, key_mode: RetrievalKey = "state_action") -> None:
+        self._provider = provider
+        # What text phi embeds per step: "state_action" (the full (state, action) summary, default)
+        # or "action" (command-only — no STATE/ACTION scaffolding, concentrating the signal for
+        # stateless traces). Index and query use the SAME mode, so the buffer stays self-consistent.
+        if key_mode not in ("state_action", "action"):
+            raise ValueError(f"key_mode must be 'state_action' or 'action', got {key_mode!r}")
+        self._key_mode = key_mode
+        # Parallel structures: row i of `_matrix` is the embedding of `_steps[i]`.
+        self._steps: list[Step] = []
+        self._matrix: NDArray[np.float64] | None = None
+
+    def _key_text(self, step: Step) -> str:
+        if self._key_mode == "action":
+            return encode_action(step.action)
+        return encode_state_action(step.state_before, step.action)
+
+    def _embed_steps(self, steps: list[Step]) -> NDArray[np.float64]:
+        # phi embeds the canonical step text from wmo.core.render — the same text the engine and
+        # GEPA render, so an embedded step and a shown demo match. `key_mode` selects which text.
+        texts = [self._key_text(s) for s in steps]
+        vectors = self._provider.embed(texts)
+        return np.asarray(vectors, dtype=np.float64)
+
+    def index(self, traces: list[Trace]) -> None:
+        """Embed every step of every trace and (re)build the buffer from scratch."""
+        steps = [step for trace in traces for step in trace.steps]
+        self._steps = steps
+        if not steps:
+            self._matrix = None
+            return
+        self._matrix = self._embed_steps(steps)
+
+    def topk(self, state: EnvState, action: Action, k: int) -> list[Step]:
+        """Return the up-to-k most similar prior steps by cosine similarity."""
+        if k <= 0 or self._matrix is None or not self._steps:
+            return []
+        query = self._embed_steps(
+            [Step(action=action, observation=_EMPTY_OBS, state_before=state)]
+        )[0]
+        if query.shape[0] != self._matrix.shape[1]:
+            raise ValueError(
+                f"embedder produces dim {query.shape[0]} but the indexed buffer has dim "
+                f"{self._matrix.shape[1]}; load the same embedder (embed_dim) used at build time"
+            )
+        scores = _cosine(query, self._matrix)
+        # argsort ascending, take the tail, reverse for descending-similarity order.
+        count = min(k, len(self._steps))
+        top = np.argsort(scores)[-count:][::-1]
+        return [self._steps[int(i)] for i in top]
+
+    def add(self, step: Step) -> None:
+        """Append a freshly generated step to the buffer for online enrichment."""
+        vector = self._embed_steps([step])
+        self._steps.append(step)
+        if self._matrix is None:
+            self._matrix = vector
+        else:
+            self._matrix = np.vstack([self._matrix, vector])
+
+    def sample(self, n: int) -> list[Step]:
+        """Return the first up-to-`n` steps from the buffer (deterministic; no RNG needed)."""
+        return self._steps[: max(0, n)]
+
+    def save(self, index_dir: str | Path) -> None:
+        """Persist the buffer (embedding matrix + parallel steps) under `index_dir`.
+
+        `wmo build` writes this; `wmo serve` / `WorldModel.load` reloads it without re-embedding.
+        """
+        path = Path(index_dir)
+        path.mkdir(parents=True, exist_ok=True)
+        matrix = self._matrix if self._matrix is not None else np.empty((0, 0), dtype=np.float64)
+        np.save(path / _MATRIX_FILE, matrix)
+        with (path / _STEPS_FILE).open("w", encoding="utf-8") as fh:
+            for step in self._steps:
+                fh.write(step.model_dump_json() + "\n")
+        # Persist key_mode: the matrix was embedded from this mode's key text, so a reload MUST
+        # query in the same mode or it cosine-compares mismatched embedding spaces (no dim error,
+        # just near-random neighbours). Without this, a reloaded index reverts to state_action.
+        (path / _META_FILE).write_text(json.dumps({"key_mode": self._key_mode}), encoding="utf-8")
+
+    def load(self, index_dir: str | Path) -> None:
+        """Reload a buffer previously written by `save`, replacing any current contents."""
+        path = Path(index_dir)
+        matrix = np.load(path / _MATRIX_FILE)
+        steps = [
+            Step.model_validate_json(line)
+            for line in (path / _STEPS_FILE).read_text(encoding="utf-8").splitlines()
+            if line.strip()
+        ]
+        self._steps = steps
+        self._matrix = matrix if matrix.size and steps else None
+        # Restore the mode the matrix was built with (older indexes predate meta.json -> default).
+        meta_path = path / _META_FILE
+        if meta_path.exists():
+            mode = json.loads(meta_path.read_text(encoding="utf-8")).get("key_mode", "state_action")
+            if mode not in ("state_action", "action"):
+                raise ValueError(f"index meta has invalid key_mode {mode!r}")
+            self._key_mode = mode
+
+
+_MATRIX_FILE = "embeddings.npy"
+_STEPS_FILE = "steps.jsonl"
+_META_FILE = "meta.json"
+
+
+def _cosine(query: NDArray[np.float64], matrix: NDArray[np.float64]) -> NDArray[np.float64]:
+    """Cosine similarity of `query` against each row of `matrix`. Zero vectors score 0."""
+    query_norm = float(np.linalg.norm(query))
+    row_norms = np.linalg.norm(matrix, axis=1)
+    denom = row_norms * query_norm
+    dots = matrix @ query
+    # Avoid divide-by-zero: where either vector is zero, similarity is 0.
+    return np.divide(dots, denom, out=np.zeros_like(dots), where=denom > 0)

wmo/scenarios/__init__.py

@@ -0,0 +1,58 @@
+"""Scenario-set construction: distill a trace corpus into a representative eval scenario set.
+
+The pipeline (Clio-style facets -> embed -> cluster -> select -> synthesize -> verify), organized
+as one subpackage per stage — `mining/`, `synthesis/`, `verification/` — with `builder` on top:
+
+    facets = FacetExtractor(provider).extract_all(traces)
+    scenario_set = build_scenario_set(traces, facets, provider, embedder, config)
+    verdicts = verify_scenarios(scenario_set, traces, world_model, agent, judge_provider)
+
+Exposed via `wmo scenarios build` / `wmo scenarios verify` on the CLI.
+"""
+
+from wmo.scenarios.builder import ScenarioBuildConfig, build_scenario_set
+from wmo.scenarios.mining import (
+    FacetExtractor,
+    Outcome,
+    SelectedTrace,
+    TraceCluster,
+    TraceFacet,
+    cluster_facets,
+    hybrid_select,
+    name_clusters,
+    semdedup_keep,
+    tool_signature,
+    trace_digest,
+)
+from wmo.scenarios.synthesis import EvalScenario, ScenarioSet, ScenarioSynthesizer
+from wmo.scenarios.verification import (
+    ChecklistJudge,
+    ChecklistResult,
+    ScenarioVerdict,
+    VerificationReport,
+    verify_scenarios,
+)
+
+__all__ = [
+    "ChecklistJudge",
+    "ChecklistResult",
+    "EvalScenario",
+    "FacetExtractor",
+    "Outcome",
+    "ScenarioBuildConfig",
+    "ScenarioSet",
+    "ScenarioSynthesizer",
+    "ScenarioVerdict",
+    "SelectedTrace",
+    "TraceCluster",
+    "TraceFacet",
+    "VerificationReport",
+    "build_scenario_set",
+    "cluster_facets",
+    "hybrid_select",
+    "name_clusters",
+    "semdedup_keep",
+    "tool_signature",
+    "trace_digest",
+    "verify_scenarios",
+]

wmo/scenarios/builder.py

@@ -0,0 +1,152 @@
+"""The scenario-set build pipeline behind `wmo scenarios build`.
+
+facets -> embed -> cluster -> name -> select -> synthesize -> coverage. One entry point,
+`build_scenario_set`, that takes already-extracted facets so callers (research runs, tests) can
+cache or substitute them; `wmo scenarios build` extracts them fresh.
+"""
+
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor
+
+import numpy as np
+from pydantic import BaseModel
+
+from wmo.core.types import Trace
+from wmo.providers.base import Embedder, Provider
+from wmo.scenarios.mining.clustering import cluster_facets, name_clusters, normalize_rows
+from wmo.scenarios.mining.facets import TraceFacet
+from wmo.scenarios.mining.selection import (
+    DEDUP_THRESHOLD,
+    PROPORTIONAL_FRACTION,
+    SelectedTrace,
+    hybrid_select,
+)
+from wmo.scenarios.synthesis import EvalScenario, ScenarioSet, ScenarioSynthesizer
+from wmo.scenarios.verification import ChecklistJudge
+
+
+class ScenarioBuildConfig(BaseModel):
+    """Knobs for one scenario-set build."""
+
+    budget: int = 20  # scenarios to construct
+    k: int | None = None  # cluster count; default sqrt(n)
+    seed: int = 0
+    validate_checklists: bool = True  # back-agreement gate inside the build (drop on repeat fail)
+    dedup_threshold: float = DEDUP_THRESHOLD
+    proportional_fraction: float = PROPORTIONAL_FRACTION
+    coverage_tau: float = 0.7  # facet counts as covered when cosine-within-tau of a selection
+    # LLM calls in the build (facet extraction, synthesis + back-agreement) are independent
+    # per trace/selection: run them on a small thread pool, order-preserving. 1 = sequential.
+    concurrency: int = 8
+
+
+def build_scenario_set(
+    traces: list[Trace],
+    facets: list[TraceFacet],
+    provider: Provider,
+    embedder: Embedder,
+    config: ScenarioBuildConfig,
+    *,
+    judge_provider: Provider | None = None,
+) -> ScenarioSet:
+    """Construct a representative scenario set from a facet-annotated trace corpus.
+
+    `provider` drives cluster naming and scenario synthesis; `embedder` embeds facet summaries.
+    `judge_provider` backs the inline checklist validation (defaults to `provider`) — pass a
+    different model to keep synthesis and validation families separate. Raises when traces/facets
+    are empty or misaligned.
+    """
+    if not traces or not facets:
+        raise ValueError("need a non-empty trace corpus and facets to build a scenario set")
+    if len(traces) != len(facets):
+        raise ValueError(f"{len(traces)} traces but {len(facets)} facets")
+
+    embeddings = np.asarray(embedder.embed([facet.embed_text() for facet in facets]))
+    labels, clusters = cluster_facets(facets, embeddings, k=config.k, seed=config.seed)
+    name_clusters(provider, clusters, facets)
+
+    selections = hybrid_select(
+        facets,
+        embeddings,
+        labels,
+        config.budget,
+        proportional_fraction=config.proportional_fraction,
+        dedup_threshold=config.dedup_threshold,
+    )
+
+    traces_by_id = {trace.trace_id: trace for trace in traces}
+    facets_by_id = {facet.trace_id: facet for facet in facets}
+    cluster_names = {cluster.cluster_id: cluster.name for cluster in clusters}
+    synthesizer = ScenarioSynthesizer(provider)
+    judge = ChecklistJudge(judge_provider or provider) if config.validate_checklists else None
+
+    def _synthesize_one(selection: SelectedTrace) -> EvalScenario | None:
+        source = traces_by_id[selection.trace_id]
+        scenario = synthesizer.synthesize(source, facets_by_id[selection.trace_id])
+        if judge is not None:
+            # A generated checklist must correctly grade the very episode it was distilled
+            # from; one that misgrades its own source can't be trusted on new trajectories.
+            # One regeneration retry, then drop — an invalid scenario never leaves the build.
+            if not _checklist_agrees(judge, scenario, source):
+                scenario = synthesizer.synthesize(source, facets_by_id[selection.trace_id])
+                if not _checklist_agrees(judge, scenario, source):
+                    return None
+        scenario.cluster_name = cluster_names.get(selection.cluster_id, "")
+        scenario.weight = selection.weight
+        if selection.pinned_failure is not None:
+            scenario.failure_category = selection.pinned_failure
+        return scenario
+
+    # Selections are independent (synthesis + back-agreement are per-trace LLM round trips), so
+    # they run on a small thread pool; `pool.map` preserves selection order, keeping the built
+    # set (and its weight renormalization) deterministic. concurrency=1 is the sequential loop.
+    if config.concurrency > 1 and len(selections) > 1:
+        with ThreadPoolExecutor(max_workers=min(config.concurrency, len(selections))) as pool:
+            maybe_scenarios = list(pool.map(_synthesize_one, selections))
+    else:
+        maybe_scenarios = [_synthesize_one(selection) for selection in selections]
+    scenarios = [scenario for scenario in maybe_scenarios if scenario is not None]
+    dropped = sum(1 for scenario in maybe_scenarios if scenario is None)
+
+    selected_ids = {scenario.provenance[0] for scenario in scenarios}
+    coverage = _corpus_coverage(facets, embeddings, selected_ids, tau=config.coverage_tau)
+    total_weight = sum(scenario.weight for scenario in scenarios)
+    if dropped and total_weight > 0:  # dropped scenarios must not leave weights summing < 1
+        for scenario in scenarios:
+            scenario.weight /= total_weight
+    return ScenarioSet(
+        scenarios=scenarios,
+        clusters=clusters,
+        corpus_traces=len(traces),
+        corpus_coverage=coverage,
+        coverage_tau=config.coverage_tau,
+    )
+
+
+def _checklist_agrees(judge: ChecklistJudge, scenario: EvalScenario, source: Trace) -> bool:
+    """Back-agreement: the judge's verdict on the SOURCE trajectory must match its recorded
+    outcome. Traces without a recorded outcome can't disagree, so they pass."""
+    if not scenario.checklist:
+        return False
+    reward = source.metadata.get("reward")
+    if not isinstance(reward, int | float):
+        return True
+    verdict = judge.score(scenario.task, scenario.checklist, source.steps)
+    return verdict.success == (float(reward) >= 1.0)
+
+
+def _corpus_coverage(
+    facets: list[TraceFacet],
+    embeddings: np.ndarray,
+    selected_ids: set[str],
+    *,
+    tau: float,
+) -> float:
+    """Fraction of corpus facets within cosine `tau` of at least one selected facet."""
+    selected_rows = [i for i, facet in enumerate(facets) if facet.trace_id in selected_ids]
+    if not selected_rows:
+        return 0.0
+    matrix = normalize_rows(embeddings)
+    similarities = matrix @ matrix[np.asarray(selected_rows)].T
+    return float((similarities.max(axis=1) >= tau).mean())

wmo/scenarios/mining/__init__.py

@@ -0,0 +1,27 @@
+"""Mining: reduce raw traces to facets, cluster them, and select representative source traces."""
+
+from wmo.scenarios.mining.clustering import TraceCluster, cluster_facets, name_clusters
+from wmo.scenarios.mining.facets import (
+    FacetExtractor,
+    Outcome,
+    TraceFacet,
+    tool_signature,
+    trace_digest,
+    trace_domain,
+)
+from wmo.scenarios.mining.selection import SelectedTrace, hybrid_select, semdedup_keep
+
+__all__ = [
+    "FacetExtractor",
+    "Outcome",
+    "SelectedTrace",
+    "TraceCluster",
+    "TraceFacet",
+    "cluster_facets",
+    "hybrid_select",
+    "name_clusters",
+    "semdedup_keep",
+    "tool_signature",
+    "trace_digest",
+    "trace_domain",
+]

wmo/scenarios/mining/clustering.py

@@ -0,0 +1,171 @@
+"""Clustering of facet embeddings: numpy k-means (cosine) + LLM cluster naming.
+
+k-means over L2-normalized facet embeddings (so squared-euclidean ranks like cosine), kmeans++
+init, deterministic under a seed. Cluster naming is the Clio step: an LLM reads a sample of each
+cluster's task summaries and writes a short name + description, which is what makes the resulting
+scenario set auditable ("8 scenarios about baggage claims" instead of "cluster 3").
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from pydantic import BaseModel, ValidationError
+
+from wmo.core.parsing import extract_json_object
+from wmo.providers.base import Message, Provider
+from wmo.scenarios.mining.facets import TraceFacet
+
+_KMEANS_ITERS = 50
+_NAME_SAMPLE = 10
+
+
+class TraceCluster(BaseModel):
+    """One discovered intent cluster over the facet corpus."""
+
+    cluster_id: int
+    name: str = ""
+    description: str = ""
+    member_trace_ids: list[str]
+
+
+def default_k(n: int) -> int:
+    """Heuristic base-layer cluster count: sqrt(n), clamped to [2, n]."""
+    if n <= 2:
+        return max(1, n)
+    return min(n, max(2, round(float(np.sqrt(n)))))
+
+
+def normalize_rows(embeddings: np.ndarray) -> np.ndarray:
+    """L2-normalize rows (zero rows stay zero) so euclidean k-means ranks like cosine."""
+    matrix = np.asarray(embeddings, dtype=np.float64)
+    norms = np.linalg.norm(matrix, axis=1, keepdims=True)
+    norms[norms == 0.0] = 1.0
+    return matrix / norms
+
+
+def kmeans_labels(embeddings: np.ndarray, k: int, *, seed: int = 0) -> np.ndarray:
+    """Deterministic k-means (kmeans++ init, Lloyd iterations) over unit-normalized rows.
+
+    Returns an int label per row. Empty clusters are re-seeded on the farthest point from its
+    centroid so exactly `k` non-empty clusters come back whenever `k <= n_distinct_rows`.
+    """
+    matrix = normalize_rows(embeddings)
+    n = matrix.shape[0]
+    if k < 1:
+        raise ValueError(f"k must be >= 1, got {k}")
+    if k >= n:
+        return np.arange(n, dtype=np.int64)
+    rng = np.random.default_rng(seed)
+    centroids = _kmeans_pp_init(matrix, k, rng)
+    labels = np.full(n, -1, dtype=np.int64)  # impossible sentinel: never false-converges on iter 1
+    for _ in range(_KMEANS_ITERS):
+        distances = _sq_distances(matrix, centroids)
+        new_labels = distances.argmin(axis=1)
+        for cluster in range(k):
+            members = matrix[new_labels == cluster]
+            if len(members) > 0:
+                centroids[cluster] = members.mean(axis=0)
+            else:
+                # Re-seed an empty cluster on the point farthest from its current centroid.
+                farthest = int(np.argmax(distances.min(axis=1)))
+                centroids[cluster] = matrix[farthest]
+                new_labels[farthest] = cluster
+        if np.array_equal(new_labels, labels):
+            break
+        labels = new_labels
+    return labels
+
+
+def _kmeans_pp_init(matrix: np.ndarray, k: int, rng: np.random.Generator) -> np.ndarray:
+    """kmeans++ seeding: spread initial centroids proportionally to squared distance."""
+    n = matrix.shape[0]
+    centroids = np.empty((k, matrix.shape[1]), dtype=np.float64)
+    centroids[0] = matrix[rng.integers(n)]
+    closest = _sq_distances(matrix, centroids[:1]).min(axis=1)
+    for i in range(1, k):
+        total = float(closest.sum())
+        if total <= 0.0:  # all remaining points coincide with a centroid
+            centroids[i:] = centroids[0]
+            break
+        probabilities = closest / total
+        centroids[i] = matrix[rng.choice(n, p=probabilities)]
+        closest = np.minimum(closest, _sq_distances(matrix, centroids[i : i + 1]).min(axis=1))
+    return centroids
+
+
+def _sq_distances(matrix: np.ndarray, centroids: np.ndarray) -> np.ndarray:
+    """Squared euclidean distance from every row to every centroid, shape (n, k)."""
+    diff = matrix[:, None, :] - centroids[None, :, :]
+    return np.einsum("nkd,nkd->nk", diff, diff)
+
+
+def cluster_facets(
+    facets: list[TraceFacet],
+    embeddings: np.ndarray,
+    *,
+    k: int | None = None,
+    seed: int = 0,
+) -> tuple[np.ndarray, list[TraceCluster]]:
+    """Cluster the facet corpus; returns (labels per facet, clusters ordered by descending size)."""
+    if len(facets) != len(embeddings):
+        raise ValueError(f"{len(facets)} facets but {len(embeddings)} embeddings")
+    if not facets:
+        return np.empty(0, dtype=np.int64), []
+    chosen_k = k if k is not None else default_k(len(facets))
+    labels = kmeans_labels(embeddings, chosen_k, seed=seed)
+    clusters: list[TraceCluster] = []
+    for cluster_id in sorted(set(labels.tolist())):
+        member_ids = [facets[i].trace_id for i in np.flatnonzero(labels == cluster_id)]
+        clusters.append(TraceCluster(cluster_id=int(cluster_id), member_trace_ids=member_ids))
+    clusters.sort(key=lambda c: len(c.member_trace_ids), reverse=True)
+    return labels, clusters
+
+
+NAMING_SYSTEM = """You name one cluster of related AI-agent tasks. You see a sample of short task
+summaries that all landed in the same cluster.
+
+Respond with ONLY a JSON object, no prose around it:
+{"name": "<2-5 word noun phrase naming the shared task intent>",
+ "description": "<one sentence describing what these tasks have in common>"}"""
+
+
+class _RawName(BaseModel):
+    name: str
+    description: str = ""
+
+
+def name_clusters(
+    provider: Provider,
+    clusters: list[TraceCluster],
+    facets: list[TraceFacet],
+    *,
+    sample_size: int = _NAME_SAMPLE,
+) -> None:
+    """Fill in `name`/`description` on every cluster via one LLM call each (mutates in place)."""
+    by_id = {facet.trace_id: facet for facet in facets}
+    for cluster in clusters:
+        summaries = [
+            by_id[trace_id].task_summary
+            for trace_id in cluster.member_trace_ids[:sample_size]
+            if trace_id in by_id
+        ]
+        prompt = "TASK SUMMARIES:\n" + "\n".join(f"- {s}" for s in summaries)
+        completion = provider.complete(
+            NAMING_SYSTEM,
+            [Message(role="user", content=prompt)],
+            temperature=0.0,
+            max_tokens=256,
+        )
+        raw = extract_json_object(completion.text)
+        parsed: _RawName | None = None
+        if raw is not None:
+            try:
+                parsed = _RawName.model_validate_json(raw)
+            except ValidationError:
+                parsed = None
+        if parsed is not None and parsed.name.strip():
+            cluster.name = parsed.name.strip()
+            cluster.description = parsed.description.strip()
+        else:
+            cluster.name = f"cluster {cluster.cluster_id}"
+            cluster.description = summaries[0] if summaries else ""