Drawn mockups instead of recorded demos; delete conversations; drop Llama; fix the weights cache re-downloading

distinct_agent/README.md

@@ -61,7 +61,7 @@ whole PC. Unsupported and failed measurements contain `available: false` and
 ## Models and runner
 
 Discovery recognizes local GGUF files for OLMoE-1B-7B-0924-Instruct,
-OLMo-2-1124-7B-Instruct and Llama-2-7B-Chat. It performs no download and
+OLMo-2-1124-7B-Instruct. It performs no download and
 executes no remote model code. `LlamaCppRunner` invokes an installed
 `llama-cli` with an argument array and `shell=False`.
 
@@ -71,10 +71,8 @@ model-specific assessment of its training, recorded with its primary source in
 offered, because measured and disclosed environmental cost is the only claim
 this project makes. The two OLMo entries are first party end to end -- Ai2
 trained the models, measured the training, quantised the weights and published
-the digests -- and both are pinned by repository, revision and SHA-256. Llama 2
-is listed and withheld: Meta publish no GGUF and the source repository is
-gated, so there is no digest to pin, and the worker names it as unavailable on
-every start rather than dropping it silently.
+the digests -- and both are pinned by repository, revision and SHA-256.
+
 
 An explicit deterministic smoke test is:
 

distinct_agent/cli.py

@@ -124,6 +124,50 @@ class ConsoleTransport:
         self.done.set()
 
 
+def _runner_problem(args) -> str:
+    """Why this machine cannot run a model yet, in words, or empty if it can.
+
+    Written as an instruction rather than a diagnosis. "llama-server was not
+    found. Supply --llama-server" told somebody who had just waited out a nine
+    gigabyte download the name of a flag, not where to get the program that
+    flag points at, and read as though the flag took no value — which it does,
+    so the next thing they saw was an argparse usage dump.
+    """
+
+    if args.llama_cli and not args.llama_server:
+        from shutil import which
+
+        if which(args.llama_cli) or Path(args.llama_cli).is_file():
+            return ""
+        return (
+            f"llama-cli was not found at {args.llama_cli!r}. Give the path to the "
+            "binary, or run with --demo-runner to start without a model."
+        )
+    if args.llama_server and args.llama_server is not True:
+        if Path(str(args.llama_server)).is_file():
+            return ""
+        return (
+            f"llama-server was not found at {str(args.llama_server)!r}. Give the "
+            "path to the binary, or run with --demo-runner to start without a model."
+        )
+    if _find_llama_server():
+        return ""
+    return (
+        "This worker has no llama.cpp to run a model with.\n"
+        "\n"
+        "  llama.cpp is a separate program, not part of this project. Get a build\n"
+        "  from https://github.com/ggml-org/llama.cpp/releases, unzip it, and either\n"
+        "  put llama-server on your PATH or point at it:\n"
+        "\n"
+        "    --llama-server C:\\path\\to\\llama-server.exe\n"
+        "\n"
+        "  Or start without a model. The worker still pairs and still runs every\n"
+        "  tool and skill in the library; only the model's own replies are absent:\n"
+        "\n"
+        "    --demo-runner\n"
+    )
+
+
 def _find_llama_server() -> str:
     """Look in runtime/ first, then PATH."""
 
@@ -315,6 +359,8 @@ def build_parser() -> argparse.ArgumentParser:
     )
     parser.add_argument(
         "--llama-server",
+        nargs="?",
+        const=True,
         help=(
             "path to llama-server. This is the default runner: clean output, "
             "real token counts, streaming, and a resident model across queued "
@@ -323,6 +369,8 @@ def build_parser() -> argparse.ArgumentParser:
     )
     parser.add_argument(
         "--llama-cli",
+        nargs="?",
+        const=True,
         help="legacy per-request runner. Only used when --llama-server is absent.",
     )
     parser.add_argument("--queue-capacity", type=int, default=4)
@@ -929,6 +977,19 @@ def main(
     # else's request, on a worker that advertised itself as ready, and if it
     # fails it fails as a failed run rather than as a worker that could not
     # start.
+    # CHECK FOR THE THING THAT RUNS THE MODEL BEFORE FETCHING THE MODEL.
+    #
+    # The runner was resolved after this block, so a machine without
+    # llama.cpp downloaded nine gigabytes of weights, verified both digests,
+    # printed its sandbox report, and only then said it had nothing to run
+    # them with. Every second of that was avoidable: whether `llama-server`
+    # exists is knowable before the first byte.
+    if not (args.demo_runner or args.demo_prompt is not None):
+        problem = _runner_problem(args)
+        if problem:
+            print(problem, file=sys.stderr)
+            return 2
+
     if pending and not args.fetch_on_demand and not (args.demo_runner or args.demo_prompt is not None):
         print(
             f"Fetching {len(pending)} model(s) now: {', '.join(pending)}. "
@@ -1045,6 +1106,11 @@ def main(
     if demo_runner:
         runner = DeterministicDemoRunner()
     elif args.llama_server or not args.llama_cli:
+        # `--llama-server` with no value means "look for it"; the finder is
+        # what a bare flag asks for, and passing True into a path would have
+        # been a confusing failure two screens later.
+        if args.llama_server is True:
+            args.llama_server = ""
         # llama-server is the default. It returns clean output with no chat
         # furniture, reports real token counts, streams, keeps the model
         # resident across a queue, and speaks the OpenAI-compatible protocol
@@ -1062,7 +1128,7 @@ def main(
             )
             return 2
     else:
-        runner = LlamaCppRunner(args.llama_cli)
+        runner = LlamaCppRunner("" if args.llama_cli is True else args.llama_cli)
         if not runner.available:
             print(
                 "llama-cli was not found; supply --llama-cli or use --demo-runner.",
@@ -1404,7 +1470,18 @@ def _run_with_dashboard(
     """
 
     from .dashboard import ActivityLog, WorkerView
-    from .tui import DashboardApp
+
+    try:
+        from .tui import DashboardApp
+    except ImportError as exc:  # pragma: no cover - only without the dependency
+        # A traceback about a module nobody asked for is not an answer. The
+        # worker itself does not need Textual, so this is the one place its
+        # absence matters and the one place worth explaining it.
+        raise SystemExit(
+            f"The live status screen needs the 'textual' package ({exc}). "
+            "Install this project's dependencies with `pip install -e .` in the "
+            "folder you cloned, or drop --dashboard to run with a scrolling log."
+        ) from exc
 
     log = getattr(sys.stderr, "_distinct_activity_log", None)
     if log is None:

distinct_agent/models.py

@@ -44,7 +44,17 @@ class UnpinnedModelError(ModelVerificationError):
 # pending, and an empty digest is an unanswered question rather than a passing
 # check; `discover_models(verify_hashes=True)` refuses them loudly.
 #
-# WHAT AN UNPINNED ENTRY NOW MEANS. Weights are fetched on demand rather than
+# EVERY ENTRY HERE IS RUNNABLE.
+#
+# There was one that was not: Llama 2 7B Chat, kept to be named rather than
+# run, because Meta publish no GGUF and the source repository is gated, so
+# there was no file to pin and the worker withheld it on every start. It has
+# been removed. A catalogue whose entries can all be fetched and verified is
+# easier to reason about than one carrying a permanent exception, and nothing
+# was lost from the assessment surface: describing what a publisher did or did
+# not disclose never required shipping their weights.
+#
+# WHAT AN UNPINNED ENTRY WOULD MEAN. Weights are fetched on demand rather than
 # placed on disk by the operator, so a manifest is only usable when its
 # repository, revision *and* digest are all recorded: without a revision there
 # is no exact file to fetch, and without a digest there is no way to say what
@@ -126,31 +136,10 @@ KNOWN_MODEL_MANIFESTS: tuple[ModelManifest, ...] = (
         source_revision="410e0069f64869e4b1d17d8de04810b881fd824b",
         context_length=4096,
     ),
-    # Kept as the contrast case: the only non-Ai2 release in this catalogue with
-    # a published model-specific figure, and a partial one. Meta published
-    # GPU-hours and a modelled 31.22 tCO2e; no energy, no water, no materials.
-    #
-    # Still unpinned, and for two reasons that are worth keeping visible rather
-    # than resolving quietly. Meta publish no GGUF, so any file would be a third
-    # party's, which the publisher policy above rules out. And the source
-    # repository is gated, so there is no unauthenticated revision to pin even
-    # if that policy changed. ``fetchable_manifests`` therefore withholds it and
-    # the worker says so on every start. It is here to be named, not run.
-    ModelManifest(
-        id="llama-2-7b-chat",
-        label="Llama 2 7B Chat · Meta · gated licence",
-        filename="llama-2-7b-chat.Q4_K_M.gguf",
-        min_ram_gb=8.0,
-        context_length=4096,
-    ),
 )
 
 
 _FILENAME_ALIASES: Mapping[str, tuple[str, ...]] = {
-    "llama-2-7b-chat": (
-        "llama-2-7b-chat.Q4_K_M.gguf",
-        "Llama-2-7B-Chat.Q4_K_M.gguf",
-    ),
     "olmoe-1b-7b-0924-instruct": (
         "olmoe-1b-7b-0924-instruct-q4_k_m.gguf",
         "OLMoE-1B-7B-0924-Instruct-Q4_K_M.gguf",

distinct_agent/weights.py

@@ -134,7 +134,21 @@ def _weights_opener() -> Callable[..., Any]:
 
 #: Default cache ceiling. Small enough to be a polite default on a volunteer's
 #: machine, large enough to hold the models in the shipped catalogue.
-DEFAULT_CACHE_GB = 8.0
+#: The cache ceiling, in gigabytes.
+#:
+#: A DEFAULT SMALLER THAN THE CATALOGUE IS A DEFAULT THAT THRASHES.
+#:
+#: This was 8, and the two models this project ships come to about nine
+#: together. So a worker offering both downloaded the first, evicted it to fit
+#: the second, and re-downloaded it on the next start — five gigabytes over
+#: the wire, every run, for ever, on a project whose entire subject is the
+#: energy cost of running models. Nothing reported it, because eviction was
+#: silent and the usage line only counted the models that run offered.
+#:
+#: Sized to hold the shipped catalogue with room for one more, so the common
+#: case never evicts anything. An operator with a small disk lowers it and is
+#: told what that costs.
+DEFAULT_CACHE_GB = 16.0
 
 #: Anything above this is almost certainly a typo rather than an intention.
 MAX_CACHE_GB = 512.0
@@ -357,18 +371,45 @@ class WeightsCache:
         ]
         return [root / name for root in roots for name in names]
 
-    def usage(self) -> CacheUsage:
-        used = 0
-        present: list[str] = []
-        for model_id, manifest in self.manifests.items():
-            path = self.path_for(manifest)
+    def _cached_entries(self) -> list[tuple[str, Path, int]]:
+        """Everything actually in the cache, as ``(model_id, path, bytes)``.
+
+        THE CACHE IS ON DISK, NOT IN THIS RUN'S ARGUMENTS.
+
+        This used to be derived from ``self.manifests``, which is only the
+        models the current invocation offers. A worker started with
+        ``--models olmoe`` therefore reported an empty cache while several
+        gigabytes of another model sat right there in it — the operator was
+        told "0.00 GB used, ready: none" about a directory that was nearly
+        full — and the eviction arithmetic below inherited the same blind
+        spot, so it believed there was room it did not have.
+        """
+
+        entries: list[tuple[str, Path, int]] = []
+        try:
+            folders = sorted(self.directory.iterdir())
+        except OSError:
+            return entries
+        for folder in folders:
+            if not folder.is_dir():
+                continue
             try:
-                if path.is_file():
-                    used += path.stat().st_size
-                    present.append(model_id)
+                for path in folder.iterdir():
+                    # `.part` files are downloads in flight; they occupy space
+                    # but they are not a cached model and must never be counted
+                    # as one, or an interrupted fetch looks like a hit.
+                    if not path.is_file() or path.suffix == ".part":
+                        continue
+                    entries.append((folder.name, path, path.stat().st_size))
             except OSError:
                 continue
-        return CacheUsage(used, self.limit_bytes, tuple(sorted(present)))
+        return entries
+
+    def usage(self) -> CacheUsage:
+        entries = self._cached_entries()
+        used = sum(size for _, _, size in entries)
+        present = sorted({model_id for model_id, _, size in entries if size > 0})
+        return CacheUsage(used, self.limit_bytes, tuple(present))
 
     def installed(self) -> tuple[DiscoveredModel, ...]:
         """Cached models, each verified against its digest.
@@ -449,7 +490,19 @@ class WeightsCache:
             with self._opener(request, timeout=60) as response:
                 declared = _content_length(response)
                 if declared:
-                    self._make_room(declared, keep=manifest.id)
+                    evicted = self._make_room(declared, keep=manifest.id)
+                    if evicted and progress is not None:
+                        # Deleting gigabytes somebody already waited for is
+                        # not a detail. Silent, it looks like the download
+                        # simply never persisted, which is exactly how it was
+                        # reported to us.
+                        progress(
+                            0.0,
+                            "Evicted from the weights cache to make room: "
+                            + ", ".join(evicted)
+                            + f" — raise --model-cache-gb above {_gb(self.limit_bytes):.0f}"
+                            " to keep them",
+                        )
                 with part.open("wb") as handle:
                     while True:
                         if cancel_event is not None and cancel_event.is_set():
@@ -520,9 +573,12 @@ class WeightsCache:
             usage = self.usage()
             if usage.used_bytes + needed_bytes <= self.limit_bytes:
                 return evicted
+            # Any model in the cache is a candidate, not only the ones this
+            # run happens to offer: they take up the same disk either way, and
+            # a run that could not see them could not free them.
             candidates = [
-                (self._last_used(self.path_for(self.manifests[model_id])), model_id)
-                for model_id in usage.model_ids
+                (self._last_used(path), model_id)
+                for model_id, path, _ in self._cached_entries()
                 if model_id != keep
             ]
             if not candidates:

distinct_server/catalog.py

@@ -245,13 +245,6 @@ MODEL_CATALOG: dict[str, ModelManifest] = {
         min_ram_gb=8.0,
         context_length=4_096,
     ),
-    "llama-2-7b-chat": ModelManifest(
-        id="llama-2-7b-chat",
-        label="Llama 2 7B Chat · Meta · gated licence",
-        filename="llama-2-7b-chat.Q4_K_M.gguf",
-        min_ram_gb=8.0,
-        context_length=4_096,
-    ),
 }
 
 
@@ -273,12 +266,14 @@ MODEL_CATALOG: dict[str, ModelManifest] = {
 # This structure is the in-catalogue record: enough to be correct on its own if
 # that file is absent, never the fuller surface.
 #
-# WHAT IS STILL FORBIDDEN. Llama 2's energy area stays Missing even though Meta
-# disclosed 184,320 GPU-hours at 400 W, because GPU-hours are not joules and the
-# multiplication is ours, not Meta's. Naming the disclosure in the note is the
-# honest handling; converting it is not.
+# WHAT IS STILL FORBIDDEN. GPU-hours are not energy. A publisher who reports
+# hours on hardware of a stated wattage has not reported a measurement, and
+# multiplying the two here would be this surface inventing the number it
+# exists to report. An area with no published figure stays Missing.
+
+#: The document each Ai2 figure is quoted from. Named once so a citation can
+#: never drift from the number beside it.
 _AI2_ASSESSMENT = "https://arxiv.org/abs/2503.05804"
-_LLAMA2_ASSESSMENT = "https://arxiv.org/abs/2307.09288"
 
 _NO_LAND = AreaResult(
     AreaStatus.MISSING,
@@ -419,60 +414,6 @@ RELEASE_ASSESSMENT: dict[str, ReleaseAssessment] = {
             {"label": "Published assessment", "url": _AI2_ASSESSMENT},
         ),
     ),
-    "llama-2-7b-chat": ReleaseAssessment(
-        model_id="llama-2-7b-chat",
-        coverage="Partial",
-        covers=(
-            "Llama 2 7B pretraining. This Chat checkpoint is a post-trained variant; Meta "
-            "report fine-tuning compute inside the family total without breaking it out."
-        ),
-        summary=(
-            "The only non-Ai2 release here with a published model-specific figure, and a "
-            "thin one: carbon and nothing else, modelled from rated chip wattage rather "
-            "than measured draw. It is a different kind of number from the two above and "
-            "should not be lined up beside them. Meta also report a second carbon column "
-            "reading zero on the grounds that they buy matching renewable electricity "
-            "annually; that is an accounting position, not a physical one, and the figure "
-            "shown here is what the grid actually delivered."
-        ),
-        reason="unpinned: Meta publish no GGUF and the source repository is gated",
-        areas={
-            "energy": AreaResult(
-                AreaStatus.MISSING,
-                note=(
-                    "Meta disclosed 184,320 A100-80GB GPU-hours at 400 W rated draw but "
-                    "published no energy figure. Multiplying those out would be an estimate "
-                    "this catalogue invented, so the area stays Missing and the disclosure "
-                    "is named instead."
-                ),
-            ),
-            "climate": AreaResult(
-                AreaStatus.MODELLED,
-                value="31.22",
-                unit="tCO2e",
-                note=(
-                    "Modelled by Meta from GPU-hours and rated device power. Location-based. "
-                    "Meta separately report it as fully offset, which nets to zero on paper "
-                    "but not on the grid."
-                ),
-                source_url=_LLAMA2_ASSESSMENT,
-            ),
-            "water": AreaResult(AreaStatus.MISSING, note="Not disclosed."),
-            "land": _NO_LAND,
-            "materials": AreaResult(
-                AreaStatus.MISSING,
-                note="Not disclosed. Embodied hardware impact is absent from Meta's accounting.",
-            ),
-            "pollution": AreaResult(AreaStatus.MISSING, note="Not disclosed."),
-        },
-        links=(
-            {
-                "label": "Model card",
-                "url": "https://huggingface.co/meta-llama/Llama-2-7b-chat-hf",
-            },
-            {"label": "Published assessment", "url": _LLAMA2_ASSESSMENT},
-        ),
-    ),
 }
 
 

distinct_server/control_plane.py

@@ -226,6 +226,22 @@ class ControlPlane:
             self._cleanup_pairing_codes_locked(current)
             if len(self._pairing_codes) >= self.limits.max_pairing_codes:
                 raise CapacityError("too many active pairing codes")
+            # THE GLOBAL CAP PROTECTS NOBODY ON ITS OWN.
+            #
+            # Filling it is cheap — one signed-in account asking in a loop —
+            # and the codes live ten minutes, so the pool can be held full and
+            # every other person on this server is then unable to pair a
+            # worker at all. A per-owner share makes that account spend only
+            # its own allowance. Counted after the expiry sweep above, so the
+            # number is codes still alive rather than codes ever asked for.
+            mine = sum(
+                1 for record in self._pairing_codes.values() if record.owner_id == owner_id
+            )
+            if mine >= self.limits.max_pairing_codes_per_owner:
+                raise CapacityError(
+                    "you already have the maximum number of unused pairing codes; "
+                    "use one, or wait for them to expire"
+                )
             while True:
                 code = new_pairing_code()
                 digest = pairing_code_digest(code, self._pairing_pepper)
@@ -600,6 +616,53 @@ class ControlPlane:
                 self._children.pop(job_id, None)
             return len(job_ids)
 
+    def delete_conversation(
+        self,
+        session_id: str,
+        conversation_id: str,
+        *,
+        now: Optional[float] = None,
+    ) -> int:
+        """Remove one conversation and the jobs it held. Returns how many.
+
+        The same erasure :meth:`delete_session` performs, narrowed to a single
+        conversation, because a person wanting one exchange gone should not
+        have to take the whole session with it.
+
+        A job still in flight is cancelled rather than merely forgotten. Its
+        worker is holding it and will come back for it, so the cancellation is
+        left where that worker will find it on its next poll; dropping the
+        record alone would leave the machine working on an answer for a
+        conversation that no longer exists.
+
+        Unknown ids are not an error. A conversation whose runs have all
+        finished is cleaned up on its own, so a browser asking to delete one
+        that has already gone is asking for a state that already holds.
+        """
+
+        with self._lock:
+            current = self._now(now)
+            session = self._sessions.get(session_id)
+            if session is None:
+                return 0
+            conversation = self._conversations.pop((session_id, conversation_id), None)
+            if conversation is None:
+                return 0
+            if conversation_id in session.conversation_ids:
+                session.conversation_ids.remove(conversation_id)
+            job_ids = set(conversation.job_ids)
+            for children in self._children.values():
+                children.difference_update(job_ids)
+            for job_id in job_ids:
+                job = self._jobs.pop(job_id, None)
+                if job is not None and job.status not in _TERMINAL_STATUSES:
+                    self._orphan_cancellations.setdefault(
+                        job.spec.target_agent_id,
+                        {},
+                    )[job_id] = current + self.limits.job_ttl_seconds
+                self._children.pop(job_id, None)
+            return len(job_ids)
+
     def create_conversation(
         self,
         session_id: str,

distinct_server/models.py

@@ -59,6 +59,14 @@ class ControlPlaneLimits:
     max_jobs: int = 50_000
     max_jobs_per_conversation: int = 1_024
     max_pairing_codes: int = 1_024
+    #: And how many of that global pool any one identity may hold at once.
+    #:
+    #: The global cap alone is not a limit on anybody, it is a limit on
+    #: everybody: one signed-in account minting in a loop fills all 1024
+    #: slots, and since they live ten minutes it can hold them full, so
+    #: nobody else on the server can pair a worker. A per-owner share turns
+    #: that from an outage into one account wasting its own allowance.
+    max_pairing_codes_per_owner: int = 8
     max_nonces_per_agent: int = 2_048
     max_models_per_agent: int = 64
     max_tools_per_agent: int = 64
@@ -81,6 +89,7 @@ class ControlPlaneLimits:
             "max_jobs",
             "max_jobs_per_conversation",
             "max_pairing_codes",
+            "max_pairing_codes_per_owner",
             "max_nonces_per_agent",
             "max_models_per_agent",
             "max_tools_per_agent",

distinct_server/presentation.py

@@ -95,42 +95,11 @@ HEAD = """
 <script>
 (function(){
   function card(el){return el && el.closest ? el.closest('.c-libcard') : null;}
-  function mediaOf(c){return c ? c.querySelector('.c-libcard__media') : null;}
-  function show(m){
-    if(!m || m.classList.contains('is-playing')) return;
-    var src = m.getAttribute('data-gif');
-    if(!src) return;
-    var img = document.createElement('img');
-    img.src = src; img.alt='';
-    m.appendChild(img); m.classList.add('is-playing');
-  }
-  function hide(m){
-    if(!m) return;
-    m.classList.remove('is-playing');
-    m.querySelectorAll('img').forEach(function(i){i.remove();});
-  }
-  /* Hover previews, scoped to the media block so sweeping the grid does not
-     start twenty GIFs at once. */
-  document.addEventListener('mouseover', function(e){
-    var m = e.target.closest ? e.target.closest('.c-libcard__media') : null; show(m);
-  });
-  document.addEventListener('mouseout', function(e){
-    var m = e.target.closest ? e.target.closest('.c-libcard__media') : null;
-    if(m && !m.contains(e.relatedTarget)) hide(m);
-  });
-  /* Press-and-hold anywhere on the card previews on a phone; a plain tap is
-     the selection. The two must not fire together, hence the flag. */
-  var holdTimer=null, held=false;
-  document.addEventListener('touchstart', function(e){
-    var c = card(e.target); if(!c) return;
-    held=false;
-    holdTimer = setTimeout(function(){held=true; show(mediaOf(c));}, 350);
-  }, {passive:true});
-  ['touchend','touchcancel'].forEach(function(name){
-    document.addEventListener(name, function(e){
-      clearTimeout(holdTimer); hide(mediaOf(card(e.target)));
-    }, {passive:true});
-  });
+  /* The preview machinery that lived here — hover to swap in a GIF, press and
+     hold to do the same on a phone, plus the flag that stopped a long press
+     also counting as a tap — went with the GIFs. Each card now draws what its
+     member makes, so there is nothing to reveal and nothing to time. */
+
   /* THE CARD IS THE CONTROL, and the way it saves is by forwarding its click
      to the framework's own box for that member. Writing a hidden field's
      value and dispatching an input event was tried first: it updates the DOM
@@ -152,7 +121,6 @@ HEAD = """
   document.addEventListener('click', function(e){
     var c = card(e.target);
     if(!c || !c.hasAttribute('data-ref')) return;
-    if(held){held=false; return;}
     if(e.target.closest && e.target.closest('a')) return;
     var box = boxFor(c.getAttribute('data-ref'));
     if(!box) return;   /* no transport, no pretend selection */
@@ -168,6 +136,61 @@ HEAD = """
     if(!c || e.target !== c) return;
     e.preventDefault(); c.click();
   });
+  /* COPY BUTTONS ON THE SETUP COMMANDS.
+     The text comes out of the <pre> the button sits with, never out of an
+     attribute written by the server. Two copies of a command line, one to
+     read and one to copy, is one escaping mistake away from a clipboard that
+     disagrees with the screen, and a command that looks right and pastes
+     wrong is worse than no button at all. */
+  function commandOf(btn){
+    var block = btn.closest ? btn.closest('.c-cmd') : null;
+    var src = block ? block.querySelector('pre, code') : null;
+    return src ? (src.textContent || '').trim() : '';
+  }
+  /* execCommand is deprecated and is still the only thing that copies on a
+     page that is not on a secure origin, which is where this panel is read:
+     a worker joins a server on 192.168.x.x over plain http, and there
+     navigator.clipboard does not exist. */
+  function legacyCopy(text){
+    var box = document.createElement('textarea');
+    box.value = text; box.setAttribute('readonly','');
+    box.style.position='fixed'; box.style.top='0'; box.style.opacity='0';
+    document.body.appendChild(box);
+    box.select(); box.setSelectionRange(0, text.length);
+    var ok = false;
+    try{ ok = document.execCommand('copy'); }catch(err){ ok = false; }
+    box.remove();
+    return ok;
+  }
+  /* A press that copied and a press that did nothing look identical unless
+     the button says which happened, so it says, and it says "Copy failed"
+     when it did rather than claiming a clipboard it never wrote. The command
+     stays selectable by hand either way. */
+  function flash(btn, word){
+    var slot = btn.querySelector('.c-cmd__word') || btn;
+    if(!btn.hasAttribute('data-word')) btn.setAttribute('data-word', slot.textContent);
+    slot.textContent = word;
+    btn.classList.add('is-copied');
+    clearTimeout(btn.copyTimer);
+    btn.copyTimer = setTimeout(function(){
+      slot.textContent = btn.getAttribute('data-word');
+      btn.classList.remove('is-copied');
+    }, 1600);
+  }
+  document.addEventListener('click', function(e){
+    var btn = e.target.closest ? e.target.closest('.c-cmd__copy') : null;
+    if(!btn) return;
+    e.preventDefault();
+    var text = commandOf(btn);
+    if(!text) return;
+    if(navigator.clipboard && navigator.clipboard.writeText){
+      navigator.clipboard.writeText(text).then(
+        function(){ flash(btn, 'Copied'); },
+        function(){ flash(btn, legacyCopy(text) ? 'Copied' : 'Copy failed'); });
+    } else {
+      flash(btn, legacyCopy(text) ? 'Copied' : 'Copy failed');
+    }
+  });
 })();
 </script>
 """
@@ -1326,6 +1349,58 @@ details[open] .c-libhelp__toggle::after{content:" -";}
 .c-join__note .c-join__code{display:inline-block; padding:2px 8px;
                             font-size:11.5px; margin-top:4px;}
 
+/* ONE COMMAND PER BLOCK, AND A BUTTON THAT COPIES THAT ONE COMMAND.
+   `cd distinct` and the install line used to share a <pre>. A <pre> is copied
+   whole or not at all, so taking one of the two meant selecting a line by
+   hand, which is fiddly with a mouse and impossible with a thumb. Each
+   command is now its own block with its own button, and the bar above the
+   command carries the button plus, where the command differs by platform, the
+   name of the platform it is for. */
+.c-cmd{display:flex; flex-direction:column; gap:4px;}
+.c-cmd__bar{display:flex; align-items:center; gap:var(--s2); min-height:24px;}
+.c-cmd__for{font-size:var(--t-micro); font-weight:650; letter-spacing:.01em;
+            color:var(--c-text-2) !important;}
+.c-cmd__copy{margin-left:auto; flex:none; cursor:pointer; appearance:none;
+             font-family:var(--font) !important; font-size:var(--t-micro) !important;
+             font-weight:600 !important; line-height:1.5 !important;
+             padding:3px 10px !important; border-radius:var(--r-md) !important;
+             background:var(--c-surface) !important; color:var(--c-text-2) !important;
+             border:1px solid var(--c-border) !important;}
+.c-cmd__copy:hover{border-color:var(--c-accent) !important;
+                   color:var(--c-sage-deep) !important;}
+/* The confirmation is the button itself for a moment. A toast somewhere else
+   on the page is a second thing to find, and the question being answered
+   ("did that press do anything?") is asked about this button. */
+.c-cmd__copy.is-copied{background:var(--c-mint) !important;
+                       border-color:var(--c-sage-dark) !important;
+                       color:var(--c-sage-deep) !important;}
+
+/* WHICH MACHINE, AS TWO RADIOS AND NO SCRIPT.
+   Neither is checked when the panel renders, so both platforms' commands are
+   visible and labelled until somebody chooses. A checked default would be
+   silently wrong for half the readers, and a volunteer pasting a Windows
+   command into a Mac terminal is exactly the failure this switch exists to
+   prevent. Choosing hides the other platform's blocks. */
+.c-os{display:flex; flex-wrap:wrap; align-items:center; gap:var(--s2);}
+.c-os__ask{font-size:var(--t-micro); color:var(--c-muted) !important;}
+.c-os__radio{position:absolute; width:1px; height:1px; opacity:0;
+             margin:0; pointer-events:none;}
+.c-os__tab{display:inline-flex; align-items:center; cursor:pointer;
+           padding:4px 12px; border-radius:var(--r-pill);
+           border:1px solid var(--c-border); background:var(--c-surface);
+           font-size:var(--t-micro); font-weight:600;
+           color:var(--c-text-2) !important;}
+.c-os__tab:hover{border-color:var(--c-accent);}
+#distinct-os-win:checked ~ .c-os label[for="distinct-os-win"],
+#distinct-os-nix:checked ~ .c-os label[for="distinct-os-nix"]{
+  background:var(--c-mint); border-color:var(--c-sage-dark);
+  color:var(--c-sage-deep) !important;}
+#distinct-os-win:focus-visible ~ .c-os label[for="distinct-os-win"],
+#distinct-os-nix:focus-visible ~ .c-os label[for="distinct-os-nix"]{
+  outline:3px solid var(--c-focus); outline-offset:2px;}
+#distinct-os-win:checked ~ .c-steps-num .c-cmd--nix,
+#distinct-os-nix:checked ~ .c-steps-num .c-cmd--win{display:none;}
+
 /* SETTING UP A WORKER, AS NUMBERED STEPS.
    Three things happen in order and each can fail on its own, so each is
    drawn as its own step with its own command. Told as one paragraph, a
@@ -1546,31 +1621,19 @@ details[open] .c-libhelp__toggle::after{content:" -";}
 .c-libcard.is-on .c-libcard__check::before{content:"✓";}
 .c-libcard__media{margin:calc(var(--s4)*-1) calc(var(--s4)*-1) var(--s2);
                   aspect-ratio:16/9; border-radius:calc(var(--r-lg) - 2px) calc(var(--r-lg) - 2px) 0 0;
-                  background:var(--c-fill) center/cover no-repeat;
+                  background:var(--c-fill);
                   display:flex; align-items:center; justify-content:center;
                   overflow:hidden; position:relative;}
+/* The drawing of what this member makes. It sits still and says its piece;
+   there is nothing to hover, nothing to wait for, and nothing to fetch. */
+.c-libcard__mock{width:100%; height:100%; display:block;}
+.c-libcard.is-on .c-libcard__media{background:color-mix(in srgb, var(--c-mint) 55%, var(--c-fill));}
 .c-libcard__media img{width:100%; height:100%; object-fit:cover;
                       object-position:top center; display:block;
                       position:absolute; inset:0;}
 /* The still is the run's own result. It sits under the animation, and it is
    what the card shows on a phone, where nothing hovers. */
-.c-libcard__poster{z-index:0;}
-.c-libcard__media.is-playing .c-libcard__poster{opacity:0;}
-.c-libcard__play{position:relative; z-index:1;
-                 display:inline-flex; align-items:center; gap:6px;
-                 font-size:var(--t-micro); color:var(--c-text-2) !important;
-                 background:color-mix(in srgb, var(--c-surface) 92%, transparent);
-                 border:1px solid var(--c-hairline) !important; backdrop-filter:blur(3px);
-                 border-radius:999px; padding:4px 10px; opacity:0;
-                 transition:opacity .15s ease;}
-.c-libcard__play::before{content:"▶"; font-size:9px; color:var(--c-sage-deep) !important;}
-/* The invitation appears on approach and never sits permanently over the
-   result it is inviting you to watch. Always visible where there is no
-   poster to obscure, since then it is the only thing in the frame. */
-.c-libcard:hover .c-libcard__play,
-.c-libcard:focus-visible .c-libcard__play{opacity:1;}
-.c-libcard__media:not(:has(.c-libcard__poster)) .c-libcard__play{opacity:1;}
-.c-libcard__media.is-playing .c-libcard__play{display:none;}
+
 .c-libcard__head{display:flex; align-items:center; gap:var(--s2); padding-right:28px;}
 .c-libcard__kind{font-size:var(--t-micro); letter-spacing:.06em; text-transform:uppercase;
                  padding:2px 8px; border-radius:999px; background:var(--c-fill);
@@ -1586,6 +1649,17 @@ details[open] .c-libhelp__toggle::after{content:" -";}
 .c-libcard__ref{margin-top:auto; padding-top:var(--s2); font-family:var(--mono);
                 font-size:11px; color:var(--c-muted) !important;}
 
+/* Deleting a conversation is a quiet control, not a red one. It sits under
+   the list it acts on, at the size of the thing it removes, and says which
+   conversation it means by acting on the selected one. */
+.c-rail__delete button,button.c-rail__delete{
+  width:100% !important; margin-top:var(--s2) !important;
+  background:transparent !important; border:1px solid var(--c-hairline) !important;
+  color:var(--c-muted) !important; font-size:var(--t-micro) !important;
+  font-weight:550 !important; padding:5px 10px !important; min-height:0 !important;}
+.c-rail__delete button:hover,button.c-rail__delete:hover{
+  border-color:var(--c-border) !important; color:var(--c-text-2) !important;}
+
 /* ---- Navigation, in the header band -----------------------------------
    A button (the library, which navigates) beside a link (a section of this
    page). They must look like one row of controls, so the button is styled to

distinct_server/render.py

@@ -177,6 +177,67 @@ def no_tools_note(notice_text: str) -> str:
     )
 
 
+_PLATFORM_LABELS = {"win": "Windows", "nix": "macOS or Linux"}
+
+
+def _command_block(command: str, *, platform: str = "") -> str:
+    """One command, drawn as its own block with its own copy button.
+
+    Two commands used to share a ``<pre>``. A block holding two lines can only
+    be copied whole, and on a phone it cannot even be dragged apart, so
+    somebody following the panel had to retype half of it. A block now holds
+    one command and nothing else, and the button beside it copies that one.
+
+    The button carries no copy of the text. The handler in
+    :data:`distinct_server.presentation.HEAD` reads it out of the ``<pre>`` at
+    click time, which makes the clipboard equal to the screen by construction.
+    A second copy of the command in a ``data-`` attribute would be a second
+    string to escape and a second string to get wrong.
+
+    ``platform`` labels a command that differs between Windows and everything
+    else. The label sits on the block, not only on the switch above it,
+    because the switch starts on neither platform: nobody is shown a command
+    for a machine that may not be theirs without the block saying whose it is.
+    """
+
+    label = _PLATFORM_LABELS.get(platform, "")
+    tag = f'<span class="c-cmd__for">{esc(label)}</span>' if label else ""
+    variant = f" c-cmd--{esc(platform)}" if label else ""
+    whose = f'<span class="c-visually-hidden"> the {esc(label)} command</span>' if label else ""
+    return (
+        f'<div class="c-cmd{variant}">'
+        f'<div class="c-cmd__bar">{tag}'
+        '<button type="button" class="c-cmd__copy">'
+        f'<span class="c-cmd__word">Copy</span>{whose}</button></div>'
+        f'<pre class="c-join__cmd">{esc(command)}</pre>'
+        "</div>"
+    )
+
+
+# WHICH MACHINE, ASKED BEFORE THE COMMANDS RATHER THAN AFTER THEM.
+#
+# Neither radio is checked, so both platforms' commands are on screen until
+# somebody picks one. That is deliberate: a default would be right for one
+# half of the readers and silently wrong for the other, and being silently
+# wrong is the whole failure this panel is being rebuilt to stop. Picking
+# hides the other platform; picking nothing costs a few extra lines, each of
+# them labelled.
+#
+# The switch is two radios and CSS, with no script behind it, because this
+# function returns a plain HTML string that has to work wherever it is
+# rendered. The copy buttons need JavaScript and cannot avoid it; the choice
+# of what a person reads should not.
+_OS_SWITCH = (
+    '<input class="c-os__radio" type="radio" name="distinct-os" id="distinct-os-win">'
+    '<input class="c-os__radio" type="radio" name="distinct-os" id="distinct-os-nix">'
+    '<div class="c-os">'
+    '<span class="c-os__ask">Which machine are you on?</span>'
+    '<label class="c-os__tab" for="distinct-os-win">Windows</label>'
+    '<label class="c-os__tab" for="distinct-os-nix">macOS or Linux</label>'
+    "</div>"
+)
+
+
 def join_this_server(
     *, addresses, code: str, qr: str = "", tools: str = "local", source: str = ""
 ) -> str:
@@ -189,6 +250,23 @@ def join_this_server(
     the three steps in between, so those are what this says: get the code,
     install it, run it.
 
+    THE COMMANDS ARE PER-PLATFORM BECAUSE THE FOOTNOTE VERSION DID NOT WORK.
+
+    The install step used to read ``python -m pip install -e .`` with
+    a line underneath saying to use something else on Windows. People paste
+    the command; they do not paste the footnote. On Windows the bare
+    ``python`` is routinely an old interpreter that arrived with some other
+    program, and the first volunteer to follow this panel got two failures in
+    a row from it: pip 20.2.3 refusing an editable install of a project with
+    no ``setup.py``, then the worker refusing to start on Python 3.9. Both
+    were the panel's fault, not theirs. So the command a person copies is now
+    the correct one for the machine they say they are on, and the caveat that
+    used to live underneath is spelled ``py -3`` inside the command itself.
+
+    ``py -3`` and not ``py -3.12``: the launcher picks the newest installed
+    Python 3, and naming a minor version asserts something about a machine
+    this server has never seen.
+
     ``source`` is where the code lives — this Space's own repository when the
     server knows it. Absent, the step says so plainly instead of guessing at
     a URL, because sending somebody to a repository that may not exist is
@@ -219,11 +297,12 @@ def join_this_server(
     )
 
     # STEP ONE: the code. A git clone, because a Space is a git repository and
-    # a clone is the one form that also updates later with `git pull`.
+    # a clone is the one form that also updates later with `git pull`. Same
+    # command everywhere, so it carries no platform label.
     if source:
         get_it = (
-            f'<pre class="c-join__cmd">git clone {esc(source)} distinct</pre>'
-            '<p class="c-join__note">Or use "Download repository" on the Files tab '
+            _command_block(f"git clone {source} distinct")
+            + '<p class="c-join__note">Or use "Download repository" on the Files tab '
             "and unzip it. Either way you end up with a folder of Python.</p>"
         )
     else:
@@ -234,10 +313,27 @@ def join_this_server(
 
     # STEP TWO: the install. `-e` so the worker runs from the folder that was
     # cloned, which is also the folder `git pull` updates.
+    #
+    # THE PIP UPGRADE IS A STEP, NOT ADVICE. `py -3` fixes the interpreter and
+    # not the pip inside it: Python 3.10.0 shipped pip 21.2, PEP 660 editable
+    # installs landed in pip 21.3, and an old pip meeting a project with no
+    # `setup.py` stops with a message about setup.py that reads as though the
+    # repository is broken. One line ahead of the install turns that into a
+    # non-event, so it is a line people can copy rather than a warning they
+    # get to read after it has already failed.
     install = (
-        '<pre class="c-join__cmd">cd distinct\npython -m pip install -e ".[agent]"</pre>'
-        '<p class="c-join__note">Python 3.10 or newer. On Windows use '
-        "<code>py -3.12 -m pip</code> if <code>python</code> is an older one.</p>"
+        _command_block("cd distinct")
+        + _command_block("py -3 -m pip install --upgrade pip", platform="win")
+        + _command_block("python3 -m pip install --upgrade pip", platform="nix")
+        + _command_block('py -3 -m pip install -e .', platform="win")
+        + _command_block('python3 -m pip install -e .', platform="nix")
+        + '<p class="c-join__note">The worker needs Python 3.10 or newer. On Windows '
+        "<code>py -3</code> runs the newest Python 3 on the machine, which is why the "
+        "commands use it: the bare <code>python</code> there is usually whichever old "
+        "one arrived with some other program, and it fails on its own version rather "
+        "than on anything you did. Run the pip line even if pip looks current: pip "
+        "older than 21.3 cannot do the install below at all, and says so by asking for "
+        "a <code>setup.py</code> this project does not have.</p>"
     )
 
     # STEP THREE: the run, with this server's address and this browser's own
@@ -246,20 +342,25 @@ def join_this_server(
         f'<p class="c-join__note">Pairing code, one use and ten minutes: '
         f'<code class="c-join__code">{esc(code)}</code></p>'
         if code
-        else '<p class="c-join__note">Generate a pairing code below, then run the '
-        "command with it in place of YOUR-CODE.</p>"
+        else '<p class="c-join__note">Sign in at the top of this page and a pairing '
+        "code appears here. Until then the command below is complete apart from "
+        "that one value.</p>"
     )
     # One line on purpose. The previous form used backslash continuations,
     # which are bash syntax: pasted into PowerShell they became stray
     # arguments and the command half-ran. A single line pastes correctly
     # into every shell anybody actually uses.
-    command = (
-        f"python -m distinct_agent --server {first} "
+    arguments = (
+        f"-m distinct_agent --server {first} "
         f"--pair {code or 'YOUR-CODE'} --models olmoe-1b-7b-0924-instruct --tools {tools or 'local'}"
     )
+    run_it = _command_block(f"py -3 {arguments}", platform="win") + _command_block(
+        f"python3 {arguments}", platform="nix"
+    )
     picture = f'<div class="c-join__qr">{qr}</div>' if qr else ""
     return (
         '<div class="c-join">'
+        f"{_OS_SWITCH}"
         '<ol class="c-steps-num">'
         '<li class="c-step-num"><span class="c-step-num__n">1</span>'
         '<div class="c-step-num__body"><p class="c-step-num__head">Get the code</p>'
@@ -270,7 +371,7 @@ def join_this_server(
         '<li class="c-step-num"><span class="c-step-num__n">3</span>'
         '<div class="c-step-num__body"><p class="c-step-num__head">Point it at this server</p>'
         f'<code class="c-join__address">{esc(first)}</code>{alternates}{code_note}'
-        f'<pre class="c-join__cmd">{esc(command)}</pre>'
+        f"{run_it}"
         f"{picture}</div></li>"
         # STEP FOUR EXISTS BECAUSE PEOPLE ASK FOR IT AFTER READING STEP THREE.
         #
@@ -927,6 +1028,51 @@ STEP_LEAD = {
 #: this is the backstop that keeps a surprise out of the render path.
 _PREVIEW_READ_CAP = 400_000
 
+#: How much a compressed member may be allowed to become, and how much of a
+#: whole file may be inflated across all its members.
+#:
+#: THE FILE ON THE WIRE IS NOT THE FILE IN MEMORY. A worker is somebody
+#: else's machine, and the protocol caps what it may send, not what that
+#: expands to: a 300 KB archive of compressible bytes inflates to 300 MB, and
+#: a run may carry eight of them. Read whole, that is 2.4 GB and half a minute
+#: of CPU inside the one process every viewer of this server shares — a worker
+#: could stop the service for everybody by answering a question.
+#:
+#: A preview needs the first few paragraphs, rows or slides, so these are
+#: generous by the standard of what is actually read and mean the arithmetic
+#: cannot run away.
+_MAX_INFLATED_MEMBER = 2 * 1024 * 1024
+_MAX_INFLATED_TOTAL = 8 * 1024 * 1024
+
+
+class _InflationRefused(Exception):
+    """A member claimed, or turned out to be, more than a preview may inflate."""
+
+
+def _read_member(archive, name: str, budget: list[int]) -> bytes:
+    """One zip member, refused rather than inflated when it is too large.
+
+    Two checks, because either alone is defeated. The header's ``file_size``
+    is what the archive claims and can simply lie; reading one byte past the
+    limit is what actually happened. ``budget`` is the file's remaining total,
+    mutated as members are read, so many merely-large members cannot add up to
+    the same attack that one huge one would.
+    """
+
+    try:
+        info = archive.getinfo(name)
+    except KeyError as exc:
+        raise _InflationRefused(f"no member {name!r}") from exc
+    allowed = min(_MAX_INFLATED_MEMBER, budget[0])
+    if info.file_size > allowed:
+        raise _InflationRefused(f"{name} declares {info.file_size} bytes")
+    with archive.open(name) as handle:
+        data = handle.read(allowed + 1)
+    if len(data) > allowed:
+        raise _InflationRefused(f"{name} is larger than it declared")
+    budget[0] -= len(data)
+    return data
+
 _TEXT_SUFFIXES = {
     ".txt", ".css", ".json", ".mermaid", ".py", ".js", ".html", ".svg",
     ".yaml", ".yml", ".toml", ".xml",
@@ -958,7 +1104,7 @@ def _docx_preview(blob: bytes) -> Optional[Mapping[str, object]]:
 
     try:
         with _zipfile.ZipFile(_io.BytesIO(blob)) as archive:
-            document = archive.read("word/document.xml")
+            document = _read_member(archive, "word/document.xml", [_MAX_INFLATED_TOTAL])
     except Exception:
         return None
     paragraphs: list[str] = []
@@ -977,12 +1123,13 @@ def _xlsx_preview(blob: bytes) -> Optional[Mapping[str, object]]:
     import re as _re
     import zipfile as _zipfile
 
+    budget = [_MAX_INFLATED_TOTAL]
     try:
         with _zipfile.ZipFile(_io.BytesIO(blob)) as archive:
-            sheet = archive.read("xl/worksheets/sheet1.xml")
+            sheet = _read_member(archive, "xl/worksheets/sheet1.xml", budget)
             try:
-                shared = archive.read("xl/sharedStrings.xml")
-            except KeyError:
+                shared = _read_member(archive, "xl/sharedStrings.xml", budget)
+            except (KeyError, _InflationRefused):
                 shared = b""
     except Exception:
         return None
@@ -1039,8 +1186,13 @@ def _pptx_preview(blob: bytes) -> Optional[Mapping[str, object]]:
                 if _re.fullmatch(r"ppt/slides/slide\d+\.xml", name)
             )
             slides: list[Mapping[str, str]] = []
+            budget = [_MAX_INFLATED_TOTAL]
             for name in names[:8]:
-                texts = _xml_texts(archive.read(name), r"<a:t>(.*?)</a:t>")
+                try:
+                    member = _read_member(archive, name, budget)
+                except _InflationRefused:
+                    continue
+                texts = _xml_texts(member, r"<a:t>(.*?)</a:t>")
                 texts = [text for text in (t.strip() for t in texts) if text]
                 if texts:
                     slides.append({"title": texts[0][:120]})
@@ -1061,11 +1213,20 @@ def _pdf_preview(blob: bytes) -> Optional[Mapping[str, object]]:
     # Streams that will not inflate are skipped rather than guessed at, and a
     # PDF nobody can read still reports its page count, which is a fact.
     chunks = [blob]
+    budget = _MAX_INFLATED_TOTAL
     for raw in _re.findall(rb"stream\r?\n(.*?)\r?\nendstream", blob, _re.S):
+        if budget <= 0:
+            break
         try:
-            chunks.append(_zlib.decompress(raw))
+            # Bounded inflation: `decompress(data, max_length)` stops at the
+            # limit instead of returning however many gigabytes the stream
+            # encodes. What is left in the decompressor is dropped with it.
+            allowed = min(_MAX_INFLATED_MEMBER, budget)
+            piece = _zlib.decompressobj().decompress(raw, allowed)
         except Exception:
             continue
+        budget -= len(piece)
+        chunks.append(piece)
     lines: list[str] = []
     seen: set[str] = set()
     for chunk in chunks:
@@ -1604,32 +1765,231 @@ def _energy_block(lines: Sequence[str], *, measured: bool, quiet: bool = False)
 # Library cards
 # --------------------------------------------------------------------------
 
-_DEMO_DIR = (Path(__file__).resolve().parent.parent / "assets" / "library-demos")
-_DEMO_BASE = f"/gradio_api/file={_DEMO_DIR.as_posix()}"
 
 
-def _demo_media(ref: str) -> tuple[str, str]:
-    """``(poster, gif)`` URLs for a member's demonstration, either may be empty.
+#: What a member leaves behind, keyed by reference. Drawn on its card as a
+#: small picture of that kind of thing.
+#:
+#: A RECORDING WAS THE WRONG ANSWER TO "WHAT IS THIS FOR".
+#:
+#: These cards used to carry a filmed demonstration: a GIF per member, with a
+#: still of the run's own output underneath, 2.5 MB of them in the repository.
+#: They were honest — every frame was a real run — and they answered the wrong
+#: question. Somebody scanning a shelf of thirty members wants to know what
+#: each one *makes*, at a glance, before deciding which to look at closely; a
+#: recording only answers that after it has played, one card at a time, and
+#: not at all on a phone where nothing hovers.
+#:
+#: A drawing of the artifact answers it instantly and identically for every
+#: member, weighs a few hundred bytes, needs no recording pass to stay true
+#: when a skill changes, and reads the same on any screen.
+_MEMBER_OUTPUT: Mapping[str, str] = {
+    "create_pdf": "page",
+    "create_docx": "page",
+    "create_deck": "deck",
+    "create_xlsx": "sheet",
+    "csv_table": "sheet",
+    "frontend_design": "web",
+    "theme_factory": "palette",
+    "make_plan": "list",
+    "todo": "list",
+    "review_checklist": "list",
+    "skill_scaffold": "note",
+    "status_update": "note",
+    "scratchpad": "note",
+    "search_document": "find",
+    "extract_from_text": "find",
+    "verify_quote": "find",
+    "calculate": "value",
+    "calculate_date": "value",
+    "convert_units": "value",
+}
+
+#: Everything driven by ``tailored_guide`` writes a guide in markdown, so it
+#: is one shape rather than nineteen near-identical entries above.
+_GUIDE_OUTPUT = "guide"
+
+#: The palette the drawings use. Deliberately the page's own tokens rather
+#: than fixed colours, so a card follows the theme instead of sitting in a
+#: little rectangle of last year's palette.
+_MOCK_INK = "var(--c-text-2)"
+_MOCK_FAINT = "var(--c-hairline)"
+_MOCK_ACCENT = "var(--c-accent)"
+
+
+def _member_output(ref: str) -> str:
+    """Which drawing belongs to a member, from its reference."""
+
+    tool_id = ref.split("@", 1)[0]
+    if tool_id in _MEMBER_OUTPUT:
+        return _MEMBER_OUTPUT[tool_id]
+    try:
+        from distinct_tools.skills import REPOSITORY_SKILLS
+
+        for skill in REPOSITORY_SKILLS:
+            if skill.tool_id == tool_id and getattr(skill, "handler", "") == "tailored_guide":
+                return _GUIDE_OUTPUT
+    except Exception:
+        pass
+    return "generic"
+
 
-    Both are looked for on disk at render time so a card never promises a
-    demonstration the repository does not carry. Slug: the ref with ``@`` and
-    ``.`` flattened, which is how the recorder names them.
+def _rows(count: int, *, x: float, y: float, gap: float, width: float, short: int = -1) -> str:
+    """Horizontal rules standing in for lines of text.
 
-    The poster is the recording's last frame — the artifact the run produced —
-    so a card at rest already shows what the member makes. That matters most
-    on a phone, where there is no hover and the GIF is a deliberate act.
+    ``short`` is the index drawn at two thirds width. A block of identical
+    full-width bars reads as a barcode; one ragged edge is what makes it read
+    as writing.
     """
 
-    slug = ref.replace("@", "-").replace(".", "-")
-    poster = f"{_DEMO_BASE}/{slug}.webp" if (_DEMO_DIR / f"{slug}.webp").is_file() else ""
-    gif = f"{_DEMO_BASE}/{slug}.gif" if (_DEMO_DIR / f"{slug}.gif").is_file() else ""
-    return poster, gif
+    bars = []
+    for index in range(count):
+        length = width * (0.62 if index == short else 1.0)
+        bars.append(
+            f'<rect x="{x}" y="{y + index * gap:.1f}" width="{length:.1f}" height="2" '
+            f'rx="1" fill="{_MOCK_FAINT}"/>'
+        )
+    return "".join(bars)
 
 
-def _demo_gif(ref: str) -> str:
-    """The demo GIF's URL for a library member, or nothing."""
+def _mockup(kind: str) -> str:
+    """One small drawing of the thing a member produces.
 
-    return _demo_media(ref)[1]
+    Inline SVG rather than an image file: it is a few hundred bytes, it is
+    sharp at any size, it takes the page's colours, and there is no asset to
+    fetch, cache, forget to ship, or let drift out of date.
+    """
+
+    body = {
+        # A page of writing: a heading, a rule, and paragraphs.
+        "page": (
+            f'<rect x="34" y="8" width="92" height="88" rx="3" fill="var(--c-surface)" '
+            f'stroke="{_MOCK_FAINT}"/>'
+            f'<rect x="44" y="20" width="46" height="5" rx="2" fill="{_MOCK_ACCENT}"/>'
+            + _rows(6, x=44, y=34, gap=9, width=72, short=5)
+        ),
+        # Slides: one wide frame, two beneath it.
+        "deck": (
+            f'<rect x="26" y="10" width="108" height="46" rx="3" fill="var(--c-surface)" '
+            f'stroke="{_MOCK_FAINT}"/>'
+            f'<rect x="36" y="22" width="42" height="5" rx="2" fill="{_MOCK_ACCENT}"/>'
+            f'<rect x="36" y="34" width="66" height="2" rx="1" fill="{_MOCK_FAINT}"/>'
+            f'<rect x="26" y="62" width="50" height="32" rx="3" fill="var(--c-surface)" '
+            f'stroke="{_MOCK_FAINT}"/>'
+            f'<rect x="84" y="62" width="50" height="32" rx="3" fill="var(--c-surface)" '
+            f'stroke="{_MOCK_FAINT}"/>'
+        ),
+        # A grid, with the header row filled in.
+        "sheet": (
+            f'<rect x="26" y="16" width="108" height="72" rx="3" fill="var(--c-surface)" '
+            f'stroke="{_MOCK_FAINT}"/>'
+            f'<rect x="26" y="16" width="108" height="16" fill="var(--c-fill)"/>'
+            + "".join(
+                f'<line x1="{26 + column * 36}" y1="16" x2="{26 + column * 36}" y2="88" '
+                f'stroke="{_MOCK_FAINT}"/>'
+                for column in (1, 2)
+            )
+            + "".join(
+                f'<line x1="26" y1="{16 + row * 18}" x2="134" y2="{16 + row * 18}" '
+                f'stroke="{_MOCK_FAINT}"/>'
+                for row in (1, 2, 3)
+            )
+            + "".join(
+                f'<rect x="{34 + column * 36}" y="22" width="18" height="4" rx="2" '
+                f'fill="{_MOCK_ACCENT}"/>'
+                for column in (0, 1, 2)
+            )
+        ),
+        # A browser: chrome, a hero block, two columns.
+        "web": (
+            f'<rect x="20" y="14" width="120" height="76" rx="4" fill="var(--c-surface)" '
+            f'stroke="{_MOCK_FAINT}"/>'
+            f'<rect x="20" y="14" width="120" height="14" rx="4" fill="var(--c-fill)"/>'
+            + "".join(
+                f'<circle cx="{30 + dot * 9}" cy="21" r="2.4" fill="{_MOCK_FAINT}"/>'
+                for dot in range(3)
+            )
+            + f'<rect x="30" y="38" width="54" height="6" rx="3" fill="{_MOCK_ACCENT}"/>'
+            + _rows(2, x=30, y=52, gap=8, width=80, short=1)
+            + '<rect x="30" y="72" width="46" height="10" rx="3" fill="var(--c-mint)"/>'
+            + '<rect x="84" y="72" width="46" height="10" rx="3" fill="var(--c-fill)"/>'
+        ),
+        # A set of colours, which is what a theme is.
+        "palette": (
+            "".join(
+                f'<rect x="{24 + column * 30}" y="{22 + row * 30}" width="24" height="24" '
+                f'rx="4" fill="{fill}" stroke="{_MOCK_FAINT}"/>'
+                for row, fills in enumerate(
+                    (
+                        (_MOCK_ACCENT, "var(--c-sage)", "var(--c-mint)", "var(--c-fill)"),
+                        ("var(--c-text)", "var(--c-text-2)", "var(--c-muted)", "var(--c-surface)"),
+                    )
+                )
+                for column, fill in enumerate(fills)
+            )
+        ),
+        # Numbered steps.
+        "list": (
+            f'<rect x="30" y="10" width="100" height="84" rx="3" fill="var(--c-surface)" '
+            f'stroke="{_MOCK_FAINT}"/>'
+            + "".join(
+                f'<circle cx="44" cy="{26 + row * 20}" r="5" fill="none" '
+                f'stroke="{_MOCK_ACCENT}" stroke-width="1.5"/>'
+                f'<rect x="56" y="{24 + row * 20}" width="{58 - row * 10}" height="3" rx="1.5" '
+                f'fill="{_MOCK_FAINT}"/>'
+                for row in range(4)
+            )
+        ),
+        # A short note, torn from a pad.
+        "note": (
+            f'<path d="M40 12 h80 v66 l-12 12 h-68 z" fill="var(--c-surface)" '
+            f'stroke="{_MOCK_FAINT}"/>'
+            f'<path d="M120 78 h-12 v12 z" fill="var(--c-fill)" stroke="{_MOCK_FAINT}"/>'
+            f'<rect x="50" y="26" width="38" height="5" rx="2" fill="{_MOCK_ACCENT}"/>'
+            + _rows(4, x=50, y=40, gap=9, width=60, short=3)
+        ),
+        # A guide: a heading and bulleted method.
+        "guide": (
+            f'<rect x="32" y="8" width="96" height="88" rx="3" fill="var(--c-surface)" '
+            f'stroke="{_MOCK_FAINT}"/>'
+            f'<rect x="42" y="20" width="52" height="5" rx="2" fill="{_MOCK_ACCENT}"/>'
+            + "".join(
+                f'<circle cx="45" cy="{40 + row * 14}" r="2" fill="{_MOCK_ACCENT}"/>'
+                f'<rect x="53" y="{38 + row * 14}" width="{62 - row * 8}" height="3" rx="1.5" '
+                f'fill="{_MOCK_FAINT}"/>'
+                for row in range(4)
+            )
+        ),
+        # Looking through a document for something.
+        "find": (
+            f'<rect x="30" y="10" width="86" height="80" rx="3" fill="var(--c-surface)" '
+            f'stroke="{_MOCK_FAINT}"/>'
+            + _rows(5, x=40, y=26, gap=12, width=62, short=4)
+            + '<rect x="40" y="48" width="40" height="7" rx="2" fill="var(--c-mint)"/>'
+            + f'<circle cx="112" cy="70" r="17" fill="var(--c-surface)" stroke="{_MOCK_ACCENT}" '
+            f'stroke-width="2.5"/>'
+            + f'<line x1="124" y1="82" x2="134" y2="92" stroke="{_MOCK_ACCENT}" '
+            f'stroke-width="2.5" stroke-linecap="round"/>'
+        ),
+        # An answer, which is what a calculation gives back.
+        "value": (
+            f'<rect x="34" y="24" width="92" height="52" rx="6" fill="var(--c-surface)" '
+            f'stroke="{_MOCK_FAINT}"/>'
+            f'<rect x="46" y="36" width="26" height="4" rx="2" fill="{_MOCK_FAINT}"/>'
+            f'<rect x="46" y="48" width="52" height="12" rx="3" fill="{_MOCK_ACCENT}"/>'
+        ),
+        "generic": (
+            f'<rect x="38" y="12" width="84" height="80" rx="3" fill="var(--c-surface)" '
+            f'stroke="{_MOCK_FAINT}"/>' + _rows(5, x=50, y=30, gap=11, width=60, short=4)
+        ),
+    }.get(kind)
+    if body is None:
+        body = ""
+    return (
+        '<svg class="c-libcard__mock" viewBox="0 0 160 104" role="img" '
+        'aria-hidden="true" preserveAspectRatio="xMidYMid meet">'
+        f"{body}</svg>"
+    )
 
 
 def library_cards(rows: Sequence[Mapping[str, object]], chosen: Sequence[str]) -> str:
@@ -1655,23 +2015,15 @@ def library_cards(rows: Sequence[Mapping[str, object]], chosen: Sequence[str]) -
         name = str(row.get("name", ref))
         author = str(row.get("author", "distinct"))
         description = str(row.get("description", ""))
-        poster, gif = _demo_media(ref)
-        media = ""
-        if poster or gif:
-            still = (
-                f'<img class="c-libcard__poster" src="{esc(poster)}" alt="" loading="lazy">'
-                if poster
-                else ""
-            )
-            media = (
-                f'<figure class="c-libcard__media" data-gif="{esc(gif)}">'
-                f"{still}"
-                '<span class="c-libcard__play">watch it work</span>'
-                '<figcaption class="c-visually-hidden">'
-                "Hover, or press and hold, to play this member's demonstration"
-                "</figcaption>"
-                "</figure>"
-            )
+        # Every card carries one, because a shelf where some members have a
+        # picture and some do not reads as a shelf where some are broken.
+        output = _member_output(ref)
+        media = (
+            f'<figure class="c-libcard__media c-libcard__media--{esc(output)}">'
+            f"{_mockup(output)}"
+            f'<figcaption class="c-visually-hidden">Makes a {esc(output)}</figcaption>'
+            "</figure>"
+        )
         on = ref in picked
         # The card itself is the control: role, state and keyboard focus are
         # its own, and the check mark is drawn by the stylesheet from the

distinct_server/ui.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import logging
 import math
 import os
 import time
@@ -65,14 +66,18 @@ from .presentation import PALETTE
 from .ui_state import (
     active_conversation,
     add_conversation,
+    adopt_saved_state,
     append_job,
     conversation_choices,
     conversation_turns,
     new_session,
     record_answer,
+    remove_conversation,
     select_conversation,
 )
 
+_LOG = logging.getLogger(__name__)
+
 # The composer's library choices are not a constant. They are derived, per
 # refresh, from what the connected agents actually advertise, by the same
 # route the model dropdown and the agent filter already use. A hardcoded empty
@@ -87,6 +92,28 @@ NO_TOOLS_NOTICE = (
     "the model on its own."
 )
 
+#: What obfuscates the transcript in localStorage, and why it is written down.
+#:
+#: `gr.BrowserState` encrypts what it stores, and left to itself it invents a
+#: sixteen-character key at start-up — which it then ships to the browser in
+#: the page's own configuration, where anybody can read it. So the key is not
+#: a secret and never was; what it is is a *version stamp on the stored data*,
+#: and a random one means a new stamp on every process.
+#:
+#: The consequence was the whole of the persistence this product promises.
+#: Every restart of the Space — every push, every wake from sleep — made the
+#: saved transcript undecryptable, so gradio logged "Error reading from
+#: localStorage" to the console and silently replaced the user's entire
+#: history with the default value. The privacy notice says the user holds
+#: their own history; in practice they held it until the next deploy.
+#:
+#: A written-down constant is the honest form of a key that is published in
+#: the page anyway, and it is what makes the stored copy survive a restart.
+#: The suffix is a data-format version: change it only to deliberately
+#: abandon every transcript in every browser, which
+#: `ui_state.adopt_saved_state` exists so that a shape change never needs.
+BROWSER_STATE_SECRET = "distinct-transcript-v1"
+
 #: What an empty transcript says. A module constant rather than a literal
 #: buried in the layout, because it is the only instruction on a page that has
 #: nothing else on it, and because the previous version pointed at the wrong
@@ -1105,13 +1132,6 @@ ASSESSMENT_ASSIGNMENT: Mapping[str, Mapping[str, Any]] = {
             "checkpoint is not separately costed in the source."
         ),
     },
-    "llama-2-7b-chat": {
-        "record": "llama-2-7b",
-        "note": (
-            "Figures cover Llama 2 7B pretraining; Meta report fine-tuning compute inside "
-            "the family total without breaking it out per checkpoint."
-        ),
-    },
 }
 
 
@@ -1794,9 +1814,8 @@ class DistinctUI:
 
     # Authentication/session helpers ----------------------------------
 
-    def _authorize(
+    def _viewer(
         self,
-        state: Mapping[str, Any],
         profile: Optional[Mapping[str, Any]],
         request: Optional[Any] = None,
     ) -> str:
@@ -1816,10 +1835,46 @@ class DistinctUI:
         user_id = _identity_from_request(request)
         if user_id is None:
             user_id = user_id_from_profile(profile)
-        session_id = str(state.get("session_id", ""))
+        return user_id
+
+    def _authorize(
+        self,
+        state: Mapping[str, Any],
+        profile: Optional[Mapping[str, Any]],
+        request: Optional[Any] = None,
+    ) -> str:
+        """Who is asking, and this browser's session made real on the server.
+
+        A HANDLER WITH NO SESSION STATE MUST NOT INVENT ONE.
+
+        This used to pass `str(state.get("session_id", ""))` straight to
+        `create_session`, and that call reads an empty id as "mint me a new
+        one". `refresh_agents` is wired without the session state, so its
+        `state` is always `{}` — which meant every change of the model
+        dropdown, every tick of a library box and every change of mode minted
+        a fresh server-side session that nothing would ever delete, since
+        `cleanup_expired` does not reap sessions.
+
+        Two thousand and forty-eight of those and the registry is full. The
+        failure is not local to the handler that filled it: `create_session`
+        then raises `CapacityError` for *every* caller of this method, so
+        `load_session` fails on every page load and the two-second timer fails
+        on every tick, for everybody on the server at once. That is the
+        "random errors" this was hunted for — it takes a while to build up and
+        then it arrives everywhere.
+
+        Identity does not need a session, so a caller without one gets the
+        identity and nothing else is touched.
+        """
+
+        state = _as_mapping(state)
+        user_id = self._viewer(profile, request)
+        session_id = str(state.get("session_id", "") or "")
+        if not session_id:
+            return user_id
         self.sessions.bind(session_id, user_id)
         self.control.create_session(session_id)
-        for conversation_id in state.get("conversations", {}):
+        for conversation_id in state.get("conversations") or {}:
             self.control.create_conversation(session_id, str(conversation_id))
         return user_id
 
@@ -1849,13 +1904,17 @@ class DistinctUI:
         # the session and conversations server-side (in _authorize) and keeps
         # every answer the browser already holds. This is the persistence the
         # privacy notice promises: the user holds their own history.
-        if (
-            isinstance(saved_state, Mapping)
-            and isinstance(saved_state.get("session_id"), str)
-            and isinstance(saved_state.get("conversations"), Mapping)
-            and saved_state.get("active_conversation_id") in saved_state["conversations"]
-        ):
-            state = dict(saved_state)
+        #
+        # Rebuilt rather than believed. See `ui_state.adopt_saved_state`: the
+        # four top-level checks that used to stand here trusted everything one
+        # level down, and a transcript written by an older build could make
+        # this handler raise on every page load.
+        #
+        # The live state is put through the same rebuild, and a fresh session
+        # is the last resort. This is the one handler that runs before any
+        # other, so the shape it settles on is the shape every handler after
+        # it can rely on — which is why none of them repeat this work.
+        state = adopt_saved_state(saved_state) or adopt_saved_state(state) or new_session()
         updated = dict(state)
         messages: list[dict[str, str]] = []
         energy = _session_energy_markdown(())
@@ -1881,6 +1940,25 @@ class DistinctUI:
             )
             activity = gr.HTML(value="", visible=False)
             user_id = None
+        except (ControlPlaneError, ValueError) as exc:
+            # THE PAGE HAS TO OPEN.
+            #
+            # This runs on every load, and anything that escapes it is a red
+            # toast on arrival with no control to press and no way to guess
+            # what went wrong. The one that actually happened was
+            # `CapacityError: session registry is full`, which is a fact about
+            # the server and not about this visitor, and it greeted every
+            # visitor at once. The session is left un-materialised, the
+            # transcript still draws from the browser's own copy, and the
+            # reason goes to the log where somebody can act on it.
+            _LOG.exception("load_session could not prepare this session")
+            identity = _identity_html("")
+            status = _status_html(
+                "This server could not open a session just now. Your "
+                f"conversation is safe in this browser. Reason: {exc}"
+            )
+            activity = gr.HTML(value="", visible=False)
+            user_id = None
         states = self._conversation_states(updated)
         choices = conversation_choices(updated, states)
         selected = updated["active_conversation_id"]
@@ -2198,16 +2276,23 @@ class DistinctUI:
         selected_agent: str,
         mode: str = MODE_SIMPLE,
         state: Optional[Mapping[str, Any]] = None,
-        profile: Optional[Mapping[str, Any]] = None,
+        profile: "gr.OAuthProfile | None" = None,
         request: "gr.Request | None" = None,
     ) -> tuple:
         # Declared, because it is used two lines down. It was not, and the
         # handler raised NameError on every change of the model dropdown, the
         # library checkboxes or the mode: a live crash on three of the most
         # common interactions in the interface, in a handler no test called.
-        # Nothing else here has changed. Gradio fills this from the annotation
-        # and pads the arguments it was not wired for with None, which is why
-        # `state` and `profile` arrive empty and are written to tolerate it.
+        #
+        # `profile` was annotated `Optional[Mapping[str, Any]]`, and Gradio
+        # injects a profile only into a parameter annotated with its own
+        # `OAuthProfile`. On a Space that is the *only* way anybody is
+        # identified, so this handler saw a signed-out visitor no matter who
+        # was using it, and the worker table emptied itself every time
+        # somebody picked a model. The annotation is now the one Gradio
+        # matches on, and the session state is wired in beside it, so this
+        # authorises against the same session as every other handler instead
+        # of against `{}`.
         #
         # Re-checked here rather than trusted from the last render. A hidden
         # component is still callable through the API, so every handler that
@@ -2260,6 +2345,61 @@ class DistinctUI:
         except (ControlPlaneError, LoginRequired, ValueError) as exc:
             raise gr.Error(str(exc)) from exc
 
+    def delete_conversation(
+        self,
+        state: Mapping[str, Any],
+        profile: gr.OAuthProfile | None,
+        request: gr.Request | None = None,
+    ) -> tuple:
+        """Erase the conversation on screen, here and on the server.
+
+        There was no way to do this at all: a conversation could be started and
+        never removed, so the rail only ever grew, and "Clear my data" — the one
+        control that erased anything — took the whole session with it. Wanting
+        one exchange gone is not the same as wanting everything gone.
+
+        No confirmation step. What it erases is already erasable by design and
+        gone from the server within a run's lifetime anyway, and a dialog in
+        front of every deletion is how people learn to dismiss dialogs. The row
+        disappearing is the feedback.
+        """
+
+        try:
+            self._authorize(state, profile, request)
+            removed = str(state.get("active_conversation_id") or "")
+            updated = remove_conversation(state, removed)
+            # The browser's copy is gone; tell the server so anything it still
+            # holds for that conversation goes with it rather than ageing out.
+            try:
+                self.control.delete_conversation(updated["session_id"], removed)
+            except (ControlPlaneError, ValueError):
+                # It may already have gone: a conversation whose runs all
+                # finished is cleaned up on its own. Nothing here depends on
+                # it still being there.
+                pass
+            if removed in updated["conversations"]:
+                # The last one was emptied rather than removed, so the server
+                # needs it to exist again for the next run in it.
+                self.control.create_conversation(updated["session_id"], removed)
+            updated, messages, status, energy, activity = self._render(updated)
+            states = self._conversation_states(updated)
+            return (
+                updated,
+                updated,
+                gr.Radio(
+                    choices=conversation_choices(updated, states),
+                    value=updated["active_conversation_id"],
+                ),
+                render.conversation_tones(states),
+                messages,
+                _status_html("Conversation deleted."),
+                energy,
+                activity,
+                self._outputs_component(updated),
+            )
+        except (ControlPlaneError, LoginRequired, ValueError) as exc:
+            raise gr.Error(str(exc)) from exc
+
     def change_conversation(
         self,
         state: Mapping[str, Any],
@@ -2360,6 +2500,12 @@ class DistinctUI:
         except (ControlPlaneError, LoginRequired, ValueError) as exc:
             raise gr.Error(str(exc)) from exc
 
+    #: One `gr.skip()` per output the timer is wired to, for a tick that could
+    #: not run at all. Asserted against the wiring in :meth:`build`, because a
+    #: length that drifts from the outputs list would make the safety net
+    #: itself the error it exists to prevent.
+    TIMER_OUTPUTS = 13
+
     def refresh_session(
         self,
         state: Mapping[str, Any],
@@ -2369,6 +2515,37 @@ class DistinctUI:
         mode: str,
         profile: gr.OAuthProfile | None,
         request: gr.Request | None = None,
+    ) -> tuple:
+        """One tick of the two-second refresh, which can never fail loudly.
+
+        Everything below degrades in place: a failure inside the render is
+        caught where it happens and the rest of the tick still runs. This
+        outermost guard is for the failure nobody predicted, and it is a bare
+        `Exception` on purpose. A user-initiated handler should be loud,
+        because somebody is standing there having just pressed something and a
+        toast tells them what happened. Nobody presses this. It runs unwatched
+        thirty times a minute in every open tab, so a raise here is not an
+        error message, it is an error message repeating forever, and the
+        person reading it did nothing to cause it and can do nothing about it.
+        """
+
+        try:
+            return self._refresh_session(
+                state, model_id, tool_values, selected_agent, mode, profile, request
+            )
+        except Exception:  # noqa: BLE001 - see the docstring; the log keeps it visible
+            _LOG.exception("refresh_session skipped a tick")
+            return tuple(gr.skip() for _ in range(self.TIMER_OUTPUTS))
+
+    def _refresh_session(
+        self,
+        state: Mapping[str, Any],
+        model_id: str,
+        tool_values: Sequence[str],
+        selected_agent: str,
+        mode: str,
+        profile: gr.OAuthProfile | None,
+        request: gr.Request | None = None,
     ) -> tuple:
         updated = dict(state)
         try:
@@ -2380,6 +2557,26 @@ class DistinctUI:
             messages, status = [], _status_html("Sign in to run a model.")
             energy = _session_energy_html(())
             activity = gr.HTML(value="", visible=False)
+        except (ControlPlaneError, ValueError):
+            # THE TRANSCRIPT IS LEFT ALONE, AND THE REST OF THE TICK RUNS.
+            #
+            # `LoginRequired` was caught here and `ControlPlaneError` was not,
+            # and the one that actually arrived was `CapacityError: session
+            # registry is full` from inside `_authorize` — a fact about the
+            # server, raised for every user of it at the same instant, on a
+            # handler that fires every two seconds. That is the shape of the
+            # "random errors" this was hunted for.
+            #
+            # Skipping these four outputs leaves what is on screen exactly as
+            # it is, which is right: the transcript is the browser's own copy
+            # and the server has nothing to add this tick. The worker table
+            # below still refreshes, so a server that recovers is visible
+            # without a reload.
+            _LOG.exception("refresh_session could not render this tick")
+            viewer_id = None
+            messages, status = gr.skip(), gr.skip()
+            energy = gr.skip()
+            activity = gr.skip()
         rows, choices, value, narrowed = self._agent_components(
             model_id, tool_values, selected_agent, mode, viewer_id=viewer_id
         )
@@ -2493,6 +2690,15 @@ class DistinctUI:
         A signed-out caller now gets a fresh blank state and touches nothing,
         which is the honest answer to "erase my data" from somebody who has no
         data here.
+
+        **"Touches nothing" was still a sentence rather than the code.** The
+        authorisation was added and the `create_session` under it was left
+        unconditional, so the second half of the hole described above was
+        never actually closed: a signed-out caller looping this handler filled
+        the session registry exactly as before, and a full registry makes
+        every other handler on the server raise. The fresh session is now
+        materialised only for somebody the server knows, and a signed-out
+        caller gets the blank state and no server-side trace at all.
         """
 
         try:
@@ -2502,14 +2708,21 @@ class DistinctUI:
             )
         except LoginRequired:
             session_id = ""
+        fresh = new_session()
         if session_id:
             self.sessions.release(session_id)
             self.control.delete_session(session_id)
             self._delete_outputs(session_id)
-        fresh = new_session()
-        self.control.create_session(fresh["session_id"])
-        for conversation_id in fresh["conversations"]:
-            self.control.create_conversation(fresh["session_id"], conversation_id)
+            # One out, one in. The replacement is materialised only when
+            # there was something to replace, so this handler cannot add a
+            # session to the registry however many times it is called — the
+            # hole the docstring above describes and the code left open.
+            # A caller with no session gets the blank state and no
+            # server-side trace, and the next timer tick creates the session
+            # for them if they ever need one.
+            self.control.create_session(fresh["session_id"])
+            for conversation_id in fresh["conversations"]:
+                self.control.create_conversation(fresh["session_id"], conversation_id)
         library, library_note = self._library_components(())
         fresh_states = self._conversation_states(fresh)
         return (
@@ -3066,22 +3279,86 @@ class DistinctUI:
         state: Mapping[str, Any],
         profile: gr.OAuthProfile | None,
         request: gr.Request | None = None,
-    ) -> str:
+        *,
+        force: bool = False,
+    ) -> tuple:
+        """The code for this browser: the one it already has, or a new one.
+
+        MINTING ON EVERY OPEN WAS BOTH A BUG AND AN OUTAGE.
+
+        The bug: a person opens the panel, copies the code, opens it again to
+        re-read the command, and is now looking at a different code from the
+        one in their clipboard.
+
+        The outage: opening a section is cheap and scriptable, the pool of
+        live codes is shared by everybody on this server, and they last ten
+        minutes — so a loop over this handler fills the pool and stops anyone
+        else pairing a worker. The control plane now caps codes per owner as
+        well, which contains the damage; not minting one that nobody asked
+        for is what stops it starting.
+
+        The plaintext lives in this browser's own state and nowhere else. The
+        server keeps only a digest, deliberately, so this is the sole copy —
+        which is exactly the right place for it, since this browser is the
+        only party entitled to read it.
+
+        OPENING A SECTION IS NAVIGATION, SO IT CANNOT FAIL.
+
+        This raised `gr.Error`, and the accordion that opens the panel is
+        wired straight to it, so a signed-out visitor who clicked "Run a
+        community agent" — the ordinary way to find out what running one
+        involves — got a red toast and a five hundred in the log for reading
+        a page. The other way in was the per-owner cap: eight live codes is
+        eight opens in a browser with no saved code, and the ninth open
+        refused with a toast rather than a sentence.
+
+        Nothing here is worth a toast. The panel already reads correctly with
+        no code in it — it is four steps, and the code belongs to one of them —
+        so the reason a code was not minted is written into the panel, where
+        the person is already looking, and the section opens either way.
+        """
+
+        updated = dict(state) if isinstance(state, Mapping) else {}
         try:
             user_id = self._authorize(state, profile, request)
+        except LoginRequired:
+            return (
+                updated,
+                updated,
+                _status_html(
+                    "Sign in with Hugging Face to get a pairing code. The rest of "
+                    "the setup is the same either way, so it is all here to read "
+                    "first."
+                )
+                + self._join_panel("", updated),
+            )
+        existing = str(updated.get("pairing_code") or "")
+        expires = updated.get("pairing_expires")
+        alive = (
+            existing
+            and isinstance(expires, (int, float))
+            # A minute's margin: a code that expires while somebody is
+            # pasting it is worse than one re-minted slightly early.
+            and expires - 60 > time.time()
+        )
+        if alive and not force:
+            return updated, updated, self._join_panel(existing, updated)
+        try:
             value = self.control.create_pairing_code(user_id)
-            return self._join_panel(value.code, state)
-        except (ControlPlaneError, LoginRequired, ValueError) as exc:
-            raise gr.Error(str(exc)) from exc
-
-    # The worker is Python, distributed as this repository's own source, so
-    # there is no build artifact to serve and no `download_agent` handler any
-    # more. The setup panel says where the code is and how to install it; see
-    # `render.join_this_server`. If frozen builds ever ship, they belong on a
-    # releases page, not behind a control that fails silently when the page
-    # for this revision was never built.
+        except (ControlPlaneError, ValueError) as exc:
+            return (
+                updated,
+                updated,
+                _status_html(f"No new pairing code just now: {exc}")
+                + self._join_panel(existing, updated),
+            )
+        updated["pairing_code"] = value.code
+        updated["pairing_expires"] = value.expires_at
+        return updated, updated, self._join_panel(value.code, updated)
 
-    # Component graph --------------------------------------------------
+    # `new_pairing_code` lived here to serve a "New code" button that no
+    # longer exists. Opening the panel mints one when the held code has
+    # expired, which is the only moment a second one was ever wanted.
 
     def build(self) -> gr.Blocks:
         # ``head`` belongs to launch() in Gradio 6, not to the constructor; the
@@ -3109,7 +3386,9 @@ class DistinctUI:
             # delivery; the user holds their own history, and Clear my data
             # erases this copy too.
             browser_state = gr.BrowserState(
-                default_value=None, storage_key="distinct-transcript"
+                default_value=None,
+                storage_key="distinct-transcript",
+                secret=BROWSER_STATE_SECRET,
             )
             # One artwork per page load. Chosen here, once, and handed to both
             # the splash and the in-app credit, so the two can never show
@@ -3225,6 +3504,21 @@ class DistinctUI:
                                 container=False,
                                 elem_classes="c-convlist",
                             )
+                            # DELETING THE ONE YOU ARE LOOKING AT.
+                            #
+                            # A per-row control would be the obvious design and
+                            # is not available: the list is a Radio, and a radio
+                            # group gives no per-option hook to hang a button
+                            # on. One control acting on the selected
+                            # conversation is the same gesture in two steps, and
+                            # it is the step order people already use — you open
+                            # a conversation, then decide it can go.
+                            delete_conversation_button = gr.Button(
+                                "Delete this conversation",
+                                size="sm",
+                                variant="secondary",
+                                elem_classes="c-rail__delete",
+                            )
 
                     with gr.Column(elem_classes="c-side", min_width=0):
                         gr.HTML(render.section_heading("Run setup"))
@@ -3492,29 +3786,25 @@ class DistinctUI:
                         # is Python and always was; the panel above now says
                         # so, and the only control left is the one that mints
                         # the code those instructions need.
-                        # NO BUTTON TO ASK FOR THE CODE. IT IS THERE WHEN YOU LOOK.
+                        # NO BUTTON IN HERE AT ALL.
                         #
-                        # Nobody opens this panel for any reason other than to
-                        # attach a worker, so making them press a button to
-                        # request the one thing the panel exists to give was
-                        # ceremony rather than consent. Opening the section
-                        # mints it, the way a router has its password printed
-                        # on the box instead of a button to request one.
+                        # There were two, and both were ceremony. "Generate
+                        # pairing code" asked a person to request the one thing
+                        # the panel exists to give, and nobody opens this panel
+                        # for another reason. "New code" survived it for a
+                        # while on the theory that somebody would want to
+                        # replace a code that had expired or been used — but
+                        # opening the panel already does exactly that: the code
+                        # is reused while it is alive and reminted when it is
+                        # not, so the button could only ever mint one that was
+                        # about to be minted anyway.
                         #
-                        # It stays SERVER-issued, and that part is not
-                        # ceremony: this code is what proves an arriving
-                        # worker was invited by whoever owns this server. A
-                        # code the worker invented would prove nothing, and
-                        # anyone could then attach a machine to anyone's
-                        # server. The code the *worker* makes is the other
-                        # one — the access code it prints once paired, which
-                        # is what you hand to the people you want to let use
-                        # your machine, and which any number of them can
-                        # redeem.
-                        refresh_code = gr.Button(
-                            "New code", size="sm", variant="secondary", scale=0,
-                            elem_classes="c-join__refresh",
-                        )
+                        # The code stays SERVER-issued, which is not ceremony:
+                        # it is what proves an arriving worker was invited by
+                        # whoever owns this server. The code the *worker*
+                        # makes is the other one — the access code it prints
+                        # once paired, which is what you give to the people you
+                        # want to let use your machine.
 
                     with gr.Accordion("Model assessments and their sources", open=False):
                         gr.HTML(
@@ -3676,6 +3966,23 @@ class DistinctUI:
                 api_visibility="private",
                 js=_scroll_top,
             )
+            delete_conversation_button.click(
+                self.delete_conversation,
+                inputs=[session_state],
+                outputs=[
+                    session_state,
+                    browser_state,
+                    conversation,
+                    rail_tones,
+                    chat,
+                    run_status,
+                    energy_total,
+                    activity_panel,
+                    outputs_files,
+                ],
+                queue=False,
+                api_visibility="private",
+            )
             new_conversation_button.click(
                 self.new_conversation,
                 inputs=[session_state],
@@ -3721,7 +4028,12 @@ class DistinctUI:
             for component in (model, tools, mode):
                 component.input(
                     self.refresh_agents,
-                    inputs=[model, tools, agent, mode],
+                    # The session travels with it. Without it the handler
+                    # authorised against an empty state, and an empty session
+                    # id is the one `create_session` reads as "mint a new
+                    # one" — one leaked session per model change, until the
+                    # registry filled and the whole server started erroring.
+                    inputs=[model, tools, agent, mode, session_state],
                     outputs=[agent_table, agent, tools, library_note],
                     queue=False,
                     api_visibility="private",
@@ -3821,14 +4133,10 @@ class DistinctUI:
                 inputs=[session_state],
                 # Into the panel, so the address and the code appear in one
                 # command rather than in two places the reader has to join up.
-                outputs=[join_panel],
-                queue=False,
-                api_visibility="private",
-            )
-            refresh_code.click(
-                self.pairing_code,
-                inputs=[session_state],
-                outputs=[join_panel],
+                # The state travels with it because the code itself is kept
+                # in this browser: the server has only a digest, so re-opening
+                # can show the same code rather than mint another.
+                outputs=[session_state, browser_state, join_panel],
                 queue=False,
                 api_visibility="private",
             )
@@ -3837,24 +4145,30 @@ class DistinctUI:
             # every five seconds reads as a stall. The refresh is in-memory
             # and unqueued; the worker's own poll cadence is unchanged.
             timer = gr.Timer(2, active=True)
+            timer_outputs = [
+                session_state,
+                browser_state,
+                chat,
+                run_status,
+                energy_total,
+                agent_table,
+                agent,
+                tools,
+                library_note,
+                outputs_files,
+                activity_panel,
+                conversation,
+                rail_tones,
+            ]
+            # A skipped tick returns one `gr.skip()` per output, and a count
+            # that disagreed with this list would raise inside the guard whose
+            # whole job is to stop the timer raising. Checked here, where both
+            # halves are visible, rather than trusted to stay in step.
+            assert len(timer_outputs) == self.TIMER_OUTPUTS
             timer.tick(
                 self.refresh_session,
                 inputs=[session_state, model, tools, agent, mode],
-                outputs=[
-                    session_state,
-                    browser_state,
-                    chat,
-                    run_status,
-                    energy_total,
-                    agent_table,
-                    agent,
-                    tools,
-                    library_note,
-                    outputs_files,
-                    activity_panel,
-                    conversation,
-                    rail_tones,
-                ],
+                outputs=timer_outputs,
                 queue=False,
                 api_visibility="private",
             )

distinct_server/ui_state.py

@@ -42,6 +42,167 @@ def new_session() -> Dict[str, Any]:
     }
 
 
+#: The longest identifier the control plane will accept. Anything longer is
+#: refused there with a `ValidationError`, and a browser holding one would
+#: turn every page load into a five-hundred.
+_MAX_ID = 128
+
+
+def _identifier(value: Any) -> str:
+    """``value`` if it can be a session or conversation id, else empty."""
+
+    if not isinstance(value, str):
+        return ""
+    text = value.strip()
+    if not text or len(text) > _MAX_ID or any(c in text for c in "\r\n"):
+        return ""
+    return text
+
+
+def _string_list(value: Any, *, limit: int) -> List[str]:
+    if not isinstance(value, (list, tuple)):
+        return []
+    return [str(item) for item in value if isinstance(item, str)][:limit]
+
+
+def _mapping_list(value: Any, *, limit: int) -> List[Dict[str, Any]]:
+    if not isinstance(value, (list, tuple)):
+        return []
+    return [dict(item) for item in value if isinstance(item, Mapping)][:limit]
+
+
+#: How much of one browser's history is worth carrying forward. A transcript
+#: is per-browser and unbounded otherwise, and the whole of it is re-rendered
+#: on a two-second timer.
+_MAX_CONVERSATIONS = 128
+_MAX_TURNS = 512
+
+
+def _number(value: Any) -> float | None:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    return float(value)
+
+
+def _adopt_answer(value: Any) -> Dict[str, Any] | None:
+    """One kept answer, rebuilt to the shape `DistinctUI._answer_payload` writes.
+
+    Every field is here, and each is the type the renderer indexes into: the
+    receipt walks `trace` and `steps` as mappings, the transcript walks `made`
+    as mappings, and the estimator reads `duration_seconds` as a number. An
+    older build that spelled any of them differently turned the transcript
+    into a `TypeError` on every render — which is to say on every page load
+    and every timer tick. Anything not listed here is dropped, because a key
+    nothing reads is a key nothing can be broken by.
+    """
+
+    if not isinstance(value, Mapping):
+        return None
+    answer: Dict[str, Any] = {
+        "output": str(value.get("output", "")),
+        "agent": str(value.get("agent", "")),
+        "model": str(value.get("model", "")),
+        "mode": str(value.get("mode", "")),
+        "tools": [item for item in _mapping_list(value.get("tools"), limit=64) if "id" in item],
+        "steps": _mapping_list(value.get("steps"), limit=64),
+        "trace": _mapping_list(value.get("trace"), limit=64),
+        "made": _mapping_list(value.get("made"), limit=32),
+        "artifacts": _string_list(value.get("artifacts"), limit=64),
+        "energy": dict(value["energy"]) if isinstance(value.get("energy"), Mapping) else {},
+        "guard": dict(value["guard"]) if isinstance(value.get("guard"), Mapping) else {},
+        "tool_calls": int(_number(value.get("tool_calls")) or 0),
+    }
+    duration = _number(value.get("duration_seconds"))
+    if duration is not None:
+        answer["duration_seconds"] = duration
+    return answer
+
+
+def adopt_saved_state(saved: Any) -> Dict[str, Any] | None:
+    """Today's shape, rebuilt from whatever an older build left in the browser.
+
+    THE BROWSER'S COPY IS INPUT, NOT STATE.
+
+    It is JSON written by some earlier version of this file, kept in
+    localStorage across every deploy since, and editable by anyone with a
+    developer console. `load_session` used to check four facts about the top
+    level of it — an id, a conversations mapping, an active id inside that
+    mapping — and then hand the rest straight to the renderer. Everything one
+    level down was trusted: a conversation that was a string, a conversation
+    with no `title`, an answer that was a string, an answer whose `made` was
+    not a list. Each of those raised out of `load_session`, which runs on
+    every single page load, so the app opened on a red error toast and stayed
+    that way until the person cleared their site data — and they had no way
+    to know that was the fix.
+
+    So the saved copy is rebuilt here field by field instead of inspected.
+    What cannot be read is dropped rather than carried, and a transcript with
+    nothing readable left in it returns None, which the caller reads as "start
+    fresh". Dropping an unreadable turn loses something; refusing to load the
+    page loses everything.
+    """
+
+    if not isinstance(saved, Mapping):
+        return None
+    conversations: Dict[str, Any] = {}
+    raw = saved.get("conversations")
+    if not isinstance(raw, Mapping):
+        return None
+    for key, value in list(raw.items())[:_MAX_CONVERSATIONS]:
+        conversation_id = _identifier(key)
+        if not conversation_id or not isinstance(value, Mapping):
+            continue
+        job_ids = _string_list(value.get("job_ids"), limit=_MAX_TURNS)
+        prompts = _string_list(value.get("prompts"), limit=_MAX_TURNS)
+        # Padded rather than trimmed to the shorter of the two. A prompt list
+        # that fell behind its job list is an older bug's leftovers, and the
+        # turn is still worth showing with an empty question attached.
+        prompts += [""] * max(0, len(job_ids) - len(prompts))
+        answers: Dict[str, Any] = {}
+        raw_answers = value.get("answers")
+        if isinstance(raw_answers, Mapping):
+            for job_id, answer in raw_answers.items():
+                if not isinstance(job_id, str) or job_id not in job_ids:
+                    continue
+                adopted = _adopt_answer(answer)
+                if adopted is not None:
+                    answers[job_id] = adopted
+        title = value.get("title")
+        conversations[conversation_id] = {
+            "title": str(title) if isinstance(title, str) and title.strip() else UNTITLED,
+            "job_ids": job_ids,
+            "prompts": prompts[: len(job_ids)],
+            "answers": answers,
+        }
+    if not conversations:
+        return None
+    active = _identifier(saved.get("active_conversation_id"))
+    if active not in conversations:
+        active = next(iter(conversations))
+    state: Dict[str, Any] = {
+        # A session id this server would refuse is worse than no session id:
+        # it fails at the control plane, inside the handler, rather than here.
+        "session_id": _identifier(saved.get("session_id")) or _id("session"),
+        "active_conversation_id": active,
+        "conversations": conversations,
+        "created_at": saved.get("created_at")
+        if isinstance(saved.get("created_at"), (int, float))
+        else time.time(),
+    }
+    defaults = _string_list(saved.get("library_defaults"), limit=256)
+    if defaults:
+        state["library_defaults"] = defaults
+    # The pairing code is browser-owned and worth keeping: dropping it makes
+    # the next open of the setup panel mint another, and a person only gets
+    # eight live codes before the control plane refuses.
+    code = saved.get("pairing_code")
+    expires = saved.get("pairing_expires")
+    if isinstance(code, str) and code and isinstance(expires, (int, float)):
+        state["pairing_code"] = code
+        state["pairing_expires"] = float(expires)
+    return state
+
+
 def _validated_copy(state: Mapping[str, Any]) -> Dict[str, Any]:
     value = copy.deepcopy(dict(state))
     if not isinstance(value.get("session_id"), str):
@@ -70,6 +231,43 @@ def select_conversation(state: Mapping[str, Any], conversation_id: str) -> Dict[
     return value
 
 
+def remove_conversation(state: Mapping[str, Any], conversation_id: str) -> Dict[str, Any]:
+    """Drop a conversation and everything it held, choosing the next active one.
+
+    THE LAST ONE IS EMPTIED RATHER THAN REMOVED. A session with no conversation
+    has no valid ``active_conversation_id``, and every renderer downstream reads
+    that key; deleting the only one would leave the state in a shape the rest of
+    this module is entitled to assume cannot happen. Emptying it gives the
+    person what they asked for — the transcript is gone — without inventing a
+    state nothing else can render.
+
+    The jobs are dropped from this state, which is the browser's copy and the
+    only durable one: the server erases a prompt when its run ends and the
+    answer once it has been collected. The caller is responsible for telling
+    the control plane, which owns anything still in flight.
+    """
+
+    value = _validated_copy(state)
+    if conversation_id not in value["conversations"]:
+        raise ValueError("conversation does not belong to this session")
+
+    if len(value["conversations"]) == 1:
+        fresh = _new_conversation()
+        value["conversations"] = {conversation_id: fresh}
+        value["active_conversation_id"] = conversation_id
+        return value
+
+    order = list(value["conversations"])
+    position = order.index(conversation_id)
+    del value["conversations"][conversation_id]
+    if value["active_conversation_id"] == conversation_id:
+        # The neighbour, preferring the one above, which is where the eye
+        # already is after a row disappears.
+        remaining = list(value["conversations"])
+        value["active_conversation_id"] = remaining[max(0, position - 1)]
+    return value
+
+
 def append_job(
     state: Mapping[str, Any],
     *,

model_assessments.json

@@ -13,7 +13,7 @@
     "Cradle to release. Never added to, never averaged with, and never compared against the use-phase energy this network measures per run."
   ],
   "website_display": {
-    "warning": "These figures are comparable within a lab and rarely between labs. The two Ai2 releases below were measured by the same team, on the same clusters, with the same method and the same boundary, so the difference between them is real. Nothing here is comparable with the Llama 2 figure, which Meta modelled from GPU-hours on different hardware in a different country. Every number covers the final pretraining run only: Ai2's own follow-up work found that development and failed runs accounted for 82.2% of total GPU-hours, so every figure on this page is a floor.",
+    "warning": "These figures are comparable within a lab and rarely between labs. The two Ai2 releases below were measured by the same team, on the same clusters, with the same method and the same boundary, so the difference between them is real. Every number covers the final pretraining run only: Ai2's own follow-up work found that development and failed runs accounted for 82.2% of total GPU-hours, so every figure on this page is a floor.",
     "further_reading": [
       {
         "label": "Ai2 and CMU on measuring a model's footprint (ICLR 2025)",
@@ -148,54 +148,6 @@
             "url": "https://arxiv.org/abs/2503.05804"
           }
         ]
-      },
-      {
-        "model_id": "llama-2-7b",
-        "name": "Llama 2 7B",
-        "publisher": "Meta",
-        "covers": "Llama 2 7B pretraining. The Chat checkpoint is a post-trained variant; Meta reports fine-tuning compute inside the family total without breaking it out per checkpoint.",
-        "coverage": "Partial",
-        "summary": "Kept because it is the only non-Ai2 release in this catalogue with a published, model-specific figure, and because it shows what a partial disclosure looks like next to a full one. Meta published GPU-hours and a carbon estimate, and nothing else: no energy, no water, no materials. The estimate is modelled from rated chip wattage rather than measured draw, so it is a different kind of number from the two above and should not be lined up against them. Meta also reports a second carbon column reading zero, on the grounds that they buy enough renewable electricity annually to match what they used. That is an accounting position, not a physical one; the figure shown here is the electricity the grid actually delivered.",
-        "categories": {
-          "energy": {
-            "state": "missing",
-            "note": "Meta disclosed 184,320 A100-80GB GPU-hours at 400 W rated draw, but published no energy figure. Multiplying those out here would be an estimate this catalogue invented, so the area stays Missing and the disclosure is named instead."
-          },
-          "climate": {
-            "state": "reported",
-            "status": "Modelled",
-            "value": "31.22",
-            "unit": "tCO2e",
-            "note": "Modelled by Meta from GPU-hours and rated device power. Location-based. Meta separately reports the figure as fully offset, which nets to zero on paper but not on the grid.",
-            "source_url": "https://arxiv.org/abs/2307.09288"
-          },
-          "water": {
-            "state": "missing",
-            "note": "Not disclosed."
-          },
-          "land": {
-            "state": "missing",
-            "note": "Not disclosed. No published per-model land figure exists for any model, from any lab."
-          },
-          "materials": {
-            "state": "missing",
-            "note": "Not disclosed. Embodied hardware impact is absent from Meta's accounting."
-          },
-          "pollution": {
-            "state": "missing",
-            "note": "Not disclosed."
-          }
-        },
-        "links": [
-          {
-            "label": "Model card",
-            "url": "https://huggingface.co/meta-llama/Llama-2-7b-chat-hf"
-          },
-          {
-            "label": "Published assessment",
-            "url": "https://arxiv.org/abs/2307.09288"
-          }
-        ]
       }
     ]
   }

pyproject.toml

@@ -7,16 +7,24 @@ name = "distinct-server"
 version = "0.1.0"
 description = "Session-only Gradio control plane for community-run open-weight LLM agents"
 requires-python = ">=3.10"
-dependencies = ["gradio[oauth]==6.24.0"]
-
-[project.optional-dependencies]
-agent = [
+# WHAT A PLAIN `pip install -e .` HAS TO GIVE YOU: A WORKING WORKER.
+#
+# These were all behind the `[agent]` extra, which meant `pip install -e .`
+# produced a worker that paired, ran, and then died the first time somebody
+# asked for its dashboard — an ImportError for a package the install had
+# quietly decided was optional. Optional to whom? Everybody who installs this
+# repository outside the Space is installing it to run a worker.
+#
+# Costing the server nothing is what makes this free: HuggingFace Spaces
+# installs `requirements.txt` and the SDK version in README.md, and never
+# runs `pip install .` at all, so nothing here reaches the deployment.
+dependencies = [
+    "gradio[oauth]==6.24.0",
     # Ed25519, for the detached snapshot signature. A direct requirement, not
     # a transitive one: `distinct_protocol.handshake` imports it and refuses
-    # to fall back to HMAC, so an agent install that happens to miss it fails
-    # at the moment it pairs rather than at install time.
+    # to fall back to HMAC, so an install that happens to miss it fails at the
+    # moment a worker pairs rather than at install time.
     "cryptography>=42",
-    "dspy[deno]==3.3.0",
     "gradio_client==2.6.0",
     "pyRAPL==0.2.3.1; sys_platform == 'linux'",
     # The worker's own screen. Pinned rather than ranged because the frozen
@@ -25,6 +33,14 @@ agent = [
     # this repository would catch.
     "textual==8.2.8",
 ]
+
+[project.optional-dependencies]
+# The DSPy RLM harness only. It is a large install and the worker degrades to
+# the structured harness without it, saying so on start, so it is the one
+# thing here that is genuinely optional.
+agent = [
+    "dspy[deno]==3.3.0",
+]
 dev = [
     "pytest==8.4.2",
     "ruff==0.12.11",

scripts/test_library_members.py

@@ -0,0 +1,326 @@
+"""Test every library member through the real stack.
+
+For each member: a fresh conversation, a request carrying the deterministic
+``[[demo-call:...]]`` directive, a real queue, a real worker executing the
+real handler, and a real artifact back. Every member of the library is
+exercised end to end, and one that cannot produce its artifact fails the run.
+
+THIS USED TO FILM EACH MEMBER AND IT NO LONGER DOES.
+
+The frames became a GIF on each library card. The cards now draw what their
+member makes, which answers "what is this for" at a glance and on a phone,
+where a hover-to-play recording answered nothing. The GIFs are gone and so is
+the capture; the run they were evidence of is the part worth keeping, so this
+is now a plain test.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import subprocess
+import sys
+import threading
+import time
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(REPO_ROOT))
+sys.path.insert(0, str(REPO_ROOT / "scripts"))
+
+from live_e2e import (  # noqa: E402
+    CLIENT_ID,
+    CLIENT_SECRET,
+    enter_the_app,
+    free_port,
+    generate_pairing_code,
+    redeem,
+    sign_in,
+    start_provider,
+    wait_for,
+)
+
+#: ref -> (spoken request, directive arguments). The spoken half is what a
+#: person would type; the directive half is what the deterministic runner
+#: turns into the real tool call. Together they are the test.
+CASES: dict[str, tuple[str, dict]] = {
+    "create_pdf@1": (
+        "Turn these notes into a PDF please",
+        {"title": "Field notes", "body": "Open weights on lent machines.\n\nEnergy read off a meter, never guessed."},
+    ),
+    "make_plan@1": (
+        "Write up a plan for the community launch",
+        {"goal": "Launch the community worker network",
+         "steps": ["Pair two volunteer workers", "Run the smoke suite", "Open sign-ups"]},
+    ),
+    "create_docx@1": (
+        "I need that as a Word document",
+        {"title": "Quarterly note", "body": "# Summary\nRevenue rose.\nCosts fell."},
+    ),
+    "create_xlsx@1": (
+        "Make me a spreadsheet of the inventory",
+        {"text": "item | qty | price\nWidget | 4 | 9.50\nBolt, large | 12 | 0.35"},
+    ),
+    "create_deck@1": (
+        "Turn this outline into slides",
+        {"slides": "distinct :: measured energy; open weights\nHow it works :: pair a worker; queue a run; read the meter"},
+    ),
+    "csv_table@1": (
+        "Give me that table as a CSV",
+        {"text": "name | role\nAda | analysis\nGrace | systems"},
+    ),
+    "status_update@1": (
+        "Draft this week's status update",
+        {"team": "Worker network", "period": "This week",
+         "progress": "Two new volunteer machines paired.",
+         "plans": "Add the GPU meter to the ladder.",
+         "problems": "One worker reports no usable counter."},
+    ),
+    "review_checklist@1": (
+        "Make a review checklist for the energy patch",
+        {"subject": "Energy meter patch",
+         "claims": ["The GPU figure is measured, not modelled",
+                    "Scopes are never summed",
+                    "A missing reading never counts as zero"]},
+    ),
+    "skill_scaffold@1": (
+        "Scaffold a new skill for meeting notes",
+        {"name": "meeting-notes",
+         "description": "Turn raw meeting notes into a clean summary document.",
+         "steps": ["Collect the raw notes", "Group them by decision", "Write the summary"]},
+    ),
+    "frontend_design@1": (
+        "Build me a landing page for the project",
+        {"title": "distinct", "sections": "What it is :: Small models on lent machines.\nWhy :: The meter is the product."},
+    ),
+    "web_artifacts_builder@1": (
+        "Plan the interactive dashboard artifact",
+        {"subject": "Energy dashboard artifact", "context": "Live joules per worker, one HTML file."},
+    ),
+    "theme_factory@1": (
+        "Make a CSS theme in sage tones",
+        {"name": "Sage", "colors": "primary: #2E5E43\nsurface: #FAF9F5\nink: #203127"},
+    ),
+    "brand_guidelines@1": (
+        "Apply our brand to the new deck",
+        {"subject": "Launch deck", "context": "Sage green on cream, Georgia headings."},
+    ),
+    "mcp_builder@1": (
+        "Plan an MCP server for our metrics API",
+        {"subject": "Metrics API MCP server", "context": "Read-only REST API, token auth."},
+    ),
+    "webapp_testing@1": (
+        "Write the browser test plan for sign-in",
+        {"subject": "Sign-in flow", "context": "OAuth redirect, then the app shell loads."},
+    ),
+    "claude_api@1": (
+        "Plan the Claude API integration",
+        {"subject": "Support inbox triage bot", "context": "Python, low volume, cost matters."},
+    ),
+    "algorithmic_art@1": (
+        "Plan a generative art piece about rivers",
+        {"subject": "River braiding", "context": "Blues and sand, seeded, printable."},
+    ),
+    "canvas_design@1": (
+        "Design a poster for the meetup",
+        {"subject": "Community compute meetup", "context": "A2 poster, evening light mood."},
+    ),
+    "academy_guide@1": (
+        "Build me a learning path for local LLMs",
+        {"subject": "Running local LLMs", "context": "Knows Python, has a gaming PC, 4 weeks."},
+    ),
+    "discernment_nudge@1": (
+        "Give me a discernment nudge on this rollout",
+        {"subject": "Shipping the worker auto-update", "context": "Team is eager; rollback story unclear."},
+    ),
+    "slack_gif_creator@1": (
+        "Plan a celebration GIF for the release",
+        {"subject": "v1 shipped", "context": "Confetti over the wordmark, two seconds."},
+    ),
+}
+
+
+def record(page, ref: str, spoken: str, arguments: dict) -> None:
+    """One member: request in, run through, artifact out.
+
+    The assertion at the end is the point of the whole script. Every member of
+    this library exists to produce something, so a run that completes without
+    an artifact card in the transcript has not demonstrated the member — it has
+    demonstrated the plumbing around it.
+    """
+
+    page.get_by_role("button", name=re.compile("^New conversation$", re.I)).click(timeout=15000)
+    page.wait_for_timeout(900)
+
+    prompt = f"{spoken}\n[[demo-call:{ref} {json.dumps(arguments)}]]"
+    box = page.get_by_label(re.compile("Your request", re.I))
+    box.fill(prompt, timeout=15000)
+
+    # Exactly one member selected: the one under test. A job carries at most
+    # sixteen selections, and a run that selects the whole shelf has not tested
+    # anything in particular.
+    wanted = ref.split("@", 1)[0].replace("_", " ")
+    picker = page.locator(".c-composer-tools input[type=checkbox]")
+    for index in range(picker.count()):
+        member = picker.nth(index)
+        if member.is_checked():
+            member.uncheck(timeout=5000, force=True)
+    page.wait_for_timeout(250)
+    target = page.locator(".c-composer-tools label", has_text=f"{wanted} ·")
+    if target.count() == 0:
+        raise RuntimeError(f"{ref}: not offered in the composer")
+    target.first.locator("input[type=checkbox]").check(timeout=5000, force=True)
+    page.wait_for_timeout(400)
+    page.get_by_role(
+        "checkbox", name=re.compile("plaintext to a community-operated worker", re.I)
+    ).check(timeout=15000)
+    page.wait_for_timeout(200)
+    page.get_by_role("button", name=re.compile("^Queue run$", re.I)).click(timeout=15000)
+
+    deadline = time.monotonic() + 45
+    done = False
+    while time.monotonic() < deadline:
+        if "requested library call" in page.inner_text("body"):
+            done = True
+            break
+        page.wait_for_timeout(1000)
+    if not done:
+        raise RuntimeError(f"{ref}: the run did not complete in time")
+    page.wait_for_timeout(1500)
+
+    if "requested library call" not in page.inner_text("body"):
+        raise RuntimeError(f"{ref}: the answer does not show the tool ran")
+    made = page.locator("figure.c-madecard")
+    if made.count() == 0:
+        raise RuntimeError(f"{ref}: the run produced no artifact")
+    summary = " | ".join(made.first.inner_text().split("\n"))[:70]
+    print(f"  {ref:26s} PASS  {summary}")
+
+
+def main() -> int:
+    import os
+
+    from playwright.sync_api import sync_playwright
+
+    provider_url, provider = start_provider()
+    port = free_port()
+    server_url = f"http://127.0.0.1:{port}"
+    environment = {
+        **os.environ,
+        "DISTINCT_OAUTH_CLIENT_ID": CLIENT_ID,
+        "DISTINCT_OAUTH_CLIENT_SECRET": CLIENT_SECRET,
+        "DISTINCT_OAUTH_REDIRECT_URI": f"{server_url}/auth/callback",
+        "DISTINCT_OAUTH_PROVIDER_URL": provider_url,
+        "DISTINCT_SESSION_SECRET": "a-fixed-secret-so-this-run-is-repeatable",
+        "DISTINCT_BIND_HOST": "127.0.0.1",
+        "PORT": str(port),
+        "PYTHONPATH": str(REPO_ROOT),
+    }
+    environment.pop("DISTINCT_DEV_AUTH", None)
+    server_log = open("/tmp/record-server.log", "w")
+    server = subprocess.Popen(
+        [sys.executable, str(REPO_ROOT / "app.py")],
+        cwd=str(REPO_ROOT), env=environment,
+        stdout=server_log, stderr=subprocess.STDOUT, text=True,
+    )
+    workers: list[subprocess.Popen] = []
+    failures: list[str] = []
+    try:
+        wait_for(server_url)
+        with sync_playwright() as playwright:
+            browser = playwright.chromium.launch()
+            context = browser.new_context(viewport={"width": 1280, "height": 860})
+            page = context.new_page()
+            page.goto(server_url, wait_until="load")
+            sign_in(page, server_url, "alice")
+            enter_the_app(page)
+            pairing = generate_pairing_code(page)
+
+            tool_refs = ",".join(sorted(CASES))
+            worker_environment = {
+                **environment,
+                # The worker advertises what its operator policy names, not
+                # what --tools asks for: without this the registry is empty
+                # and the composer shows "no tools installed" forever.
+                "DISTINCT_APPROVED_TOOLS": tool_refs,
+            }
+            process = subprocess.Popen(
+                [
+                    sys.executable, "-m", "distinct_agent",
+                    "--server", server_url, "--pair", pairing,
+                    "--name", "demo-recorder", "--approve", "--demo-runner",
+                    "--tools", tool_refs,
+                ],
+                cwd=str(REPO_ROOT), env=worker_environment,
+                stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
+            )
+            workers.append(process)
+            access = None
+            deadline = time.monotonic() + 120
+            while time.monotonic() < deadline and access is None:
+                line = process.stdout.readline()
+                if not line:
+                    if process.poll() is not None:
+                        raise RuntimeError("worker exited before printing an access code")
+                    continue
+                found = re.search(r"\b([A-Z0-9]{5}(?:-[A-Z0-9]{4,5}){5,8})\b", line)
+                if found:
+                    access = found.group(1)
+            if access is None:
+                raise RuntimeError("no access code appeared")
+            threading.Thread(
+                target=lambda: [None for _ in process.stdout], daemon=True
+            ).start()
+
+            page.reload(wait_until="load")
+            enter_the_app(page)
+            page.wait_for_timeout(2500)
+            redeem(page, access)
+            page.wait_for_timeout(4000)
+
+            # Wait for the worker's advertised members to reach the
+            # composer picker: they enter snapshots only after approval, so
+            # the first load can race them.
+            for _ in range(10):
+                if page.locator(".c-composer-tools input[type=checkbox]").count() > 0:
+                    break
+                page.wait_for_timeout(1500)
+                page.reload(wait_until="load")
+                enter_the_app(page)
+                page.wait_for_timeout(2000)
+            offered = page.locator(".c-composer-tools input[type=checkbox]").count()
+            print(f"  composer offers {offered} member(s)")
+            if offered == 0:
+                raise RuntimeError("the composer picker never populated")
+
+            for ref in sorted(CASES):
+                spoken, arguments = CASES[ref]
+                try:
+                    record(page, ref, spoken, arguments)
+                except Exception as exc:  # noqa: BLE001 - report and continue
+                    failures.append(f"{ref}: {exc}")
+                    print(f"  {ref:26s} FAIL  {exc}")
+            browser.close()
+    finally:
+        for process in workers:
+            if process.poll() is None:
+                process.terminate()
+                try:
+                    process.wait(timeout=10)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+        server.terminate()
+        try:
+            server.wait(timeout=15)
+        except subprocess.TimeoutExpired:
+            server.kill()
+        provider.shutdown()
+    if failures:
+        print(f"\n{len(failures)} member(s) failed; no GIF was written for them.")
+        return 1
+    print(f"\nAll {len(CASES)} members produced their artifact.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())