paratext-cli 0.2.4__tar.gz → 0.3.0__tar.gz

{paratext_cli-0.2.4 → paratext_cli-0.3.0}/.helical/tasks/PTX-4 genericise-the-defaults-away-from-local-inference-servers.md

@@ -4,11 +4,10 @@ title: Genericise the defaults away from local inference servers
 status: done
 horizon: now
 flow: clear
-priority: high
 labels:
   - docs
 created: '2026-06-28'
-updated: '2026-09-02'
+updated: '2026-09-03'
 ---
 
 Defaults naming Lemonade and LM Studio make the framework look like it only runs against one person's setup.

{paratext_cli-0.2.4 → paratext_cli-0.3.0}/AGENTS.md

@@ -267,35 +267,39 @@ alongside `_api_export_catalogue`.
 - **Bump `schema_version`** when a schema changes.
 - **Commits:** short messages, no Co-Authored-By trailer.
 
-## Backlog tasks are public
+## Tasks in this repo are public
 
-This repository is public, and `backlog/` is committed with it. Task titles,
+This repository is public, and `.helical/` is committed with it. Task titles,
 descriptions and notes are visible to anyone.
 
 Keep repo tasks to engineering work. Anything naming NLS internals, staff,
 suppliers, unannounced plans or licensing negotiations belongs in the
-`paratext-nls` backlog or the roadmap at `/opt/backlog` instead.
+`paratext-nls` board or the `admin` project instead.
 
-<!-- BACKLOG.MD GUIDELINES START -->
-<!-- backlog.md-instructions-version: 1.50.1 -->
-<CRITICAL_INSTRUCTION>
+<!-- HELICAL START -->
+## Tasks
 
-## Backlog.md Workflow
+This project's tasks live in `.helical/tasks/` and are managed with the `helical`
+command. Read them before starting, and record what you find.
 
-This project uses Backlog.md for task and project management.
-
-**For every user request in this project, run `backlog instructions overview` before answering or taking action.**
-
-Use the overview to decide whether to search, read, create, or update Backlog tasks.
+```bash
+helical ls -p <project>              # open work here
+helical show <ID>                    # one task in full
+helical set <ID> --status doing      # todo | doing | done
+helical set <ID> --horizon next      # now | next | future
+helical set <ID> --flow waiting --blocker "why"
+helical new "Title" -p <project> --horizon next
+```
 
-Before task lifecycle actions, read the matching detailed guide:
-- `backlog instructions task-creation` before creating or splitting tasks
-- `backlog instructions task-execution` before planning, changing status or assignee, adding a plan or implementation notes, or implementing task work
-- `backlog instructions task-finalization` before checking acceptance criteria, writing final summaries, or moving tasks to terminal statuses
+`--json` works on every command. A task carries both a **status** (how far along)
+and a **horizon** (when it matters); the routemap across all projects is built from
+horizons, so set one deliberately.
 
-Use `backlog <command> --help` before running unfamiliar commands. Help shows options, fields, and examples.
+**Flow** says who can unstick a task: `waiting` sits with someone else and needs
+chasing, `blocked` sits with us and needs a decision. Neither is accepted without
+`--blocker` explaining it.
 
-Do not edit Backlog task, draft, document, decision, or milestone markdown files directly. Use the `backlog` CLI so metadata, relationships, and history stay consistent.
+Labels come from a fixed vocabulary; `helical new --help` lists it.
 
-</CRITICAL_INSTRUCTION>
-<!-- BACKLOG.MD GUIDELINES END -->
+Boards: <https://helical.ai.nls.uk> · read-only <https://projects.ai.nls.uk>
+<!-- HELICAL END -->

{paratext_cli-0.2.4 → paratext_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: paratext-cli
-Version: 0.2.4
+Version: 0.3.0
 Summary: Modular, project-based metadata extraction from digitised library/archive collections with a multimodal model
 License-Expression: Apache-2.0
 License-File: LICENSE

{paratext_cli-0.2.4 → paratext_cli-0.3.0}/pyproject.toml

@@ -3,7 +3,7 @@
 # the plain name on PyPI belongs to an unrelated project, so the distribution
 # carries the `-cli` suffix.
 name = "paratext-cli"
-version = "0.2.4"
+version = "0.3.0"
 description = "Modular, project-based metadata extraction from digitised library/archive collections with a multimodal model"
 readme = "README.md"
 # Core is pure-Python + numpy/pillow/pydantic. The [detector] extra needs

{paratext_cli-0.2.4 → paratext_cli-0.3.0}/src/paratext/__init__.py

@@ -1,3 +1,3 @@
 """paratext — metadata extraction from digitised collections with a multimodal model."""
 
-__version__ = "0.2.4"
+__version__ = "0.3.0"

{paratext_cli-0.2.4 → paratext_cli-0.3.0}/src/paratext/cli.py

@@ -439,6 +439,7 @@ def _cmd_review(args: argparse.Namespace) -> int:
         # A missing default root means "nothing run yet", not a mistake — serve
         # anyway so Projects and the homepage guidance are reachable.
         allow_empty=args.data_dir == REVIEW_ROOT,
+        workshop=args.workshop,
     )
     return 0
 
@@ -779,6 +780,10 @@ def _build_parser() -> tuple[
                          "nginx; use 0.0.0.0 to expose directly on the network)")
     rv.add_argument("--db", type=Path, default=None,
                     help="Annotations SQLite path (default: <data_dir>/annotations.db)")
+    rv.add_argument("--workshop", metavar="DIR", default=None,
+                    help="Workshop mode: give each browser its own workspace under DIR "
+                         "(prompt, fields, rounds and verdicts), seeded with the rounds "
+                         "served here")
     rv.add_argument("--no-open", action="store_true", help="Don't open a browser")
     rv.set_defaults(func=_cmd_review)
 

{paratext_cli-0.2.4 → paratext_cli-0.3.0}/src/paratext/review/server.py

@@ -18,6 +18,7 @@ import io
 import json
 import logging
 import webbrowser
+from http.cookies import SimpleCookie
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
 from urllib.parse import parse_qs, unquote, urlparse
@@ -32,6 +33,7 @@ from ..datasets import (
     schema_history,
 )
 from ..store import Store, default_db_path
+from .sessions import COOKIE_NAME, Sessions
 
 logger = logging.getLogger(__name__)
 
@@ -67,18 +69,60 @@ _MIME = {
 
 
 class Handler(BaseHTTPRequestHandler):
-    data_dir: Path
-    store: Store
+    # The single-tenant defaults. In workshop mode `data_dir` and `store` below
+    # resolve per request instead, so one container serves a room of people
+    # without them overwriting each other.
+    base_data_dir: Path
+    base_store: Store
+    sessions: Sessions | None = None
 
     def log_message(self, *a):  # quiet by default
         pass
 
+    # -- per-request session --
+    def _session(self):
+        """The caller's workshop session, creating one on first request. None
+        outside workshop mode, where the server is single-tenant."""
+        if self.sessions is None:
+            return None
+        if getattr(self, "_session_cache", None) is None:
+            cookie = SimpleCookie(self.headers.get("cookie") or "")
+            morsel = cookie.get(COOKIE_NAME)
+            session, created = self.sessions.get_or_create(morsel.value if morsel else None)
+            self._session_cache = session
+            self._set_cookie = created
+        return self._session_cache
+
+    @property
+    def data_dir(self) -> Path:
+        session = self._session()
+        return session.data_dir if session else type(self).base_data_dir
+
+    @property
+    def store(self) -> Store:
+        session = self._session()
+        if not session:
+            return type(self).base_store
+        if getattr(self, "_store_cache", None) is None:
+            self._store_cache = session.store()
+        return self._store_cache
+
+    def _session_headers(self) -> None:
+        """Hand the browser its session on the response that created it."""
+        if getattr(self, "_set_cookie", False):
+            self.send_header(
+                "set-cookie",
+                f"{COOKIE_NAME}={self._session_cache.id}; Path=/; SameSite=Lax; Max-Age=86400",
+            )
+            self._set_cookie = False
+
     # -- helpers --
     def _json(self, obj, status=200):
         body = json.dumps(obj).encode()
         self.send_response(status)
         self.send_header("content-type", "application/json")
         self.send_header("content-length", str(len(body)))
+        self._session_headers()
         self.end_headers()
         self.wfile.write(body)
 
@@ -88,6 +132,7 @@ class Handler(BaseHTTPRequestHandler):
         self.send_header("content-length", str(len(body)))
         for k, v in (headers or {}).items():
             self.send_header(k, v)
+        self._session_headers()
         self.end_headers()
         self.wfile.write(body)
 
@@ -630,6 +675,7 @@ def serve(
     host: str = "127.0.0.1",
     db_path: Path | None = None,
     allow_empty: bool = False,
+    workshop: Path | str | None = None,
 ) -> None:
     """Serve the review UI over ``data_dir``.
 
@@ -648,11 +694,20 @@ def serve(
                 f"or pass a dataset directory: paratext review <dir>"
             )
         data_dir.mkdir(parents=True, exist_ok=True)
-    Handler.data_dir = data_dir
+    Handler.base_data_dir = data_dir
     # Default the annotation store to <data_dir>/annotations.db; --db can point it
     # elsewhere (e.g. an existing DB when swapping in for another review app).
-    Handler.store = Store(default_db_path(data_dir, Path(db_path).resolve() if db_path else None))
+    Handler.base_store = Store(
+        default_db_path(data_dir, Path(db_path).resolve() if db_path else None)
+    )
     datasets = discover_datasets(data_dir)
+    # Workshop mode: every browser gets its own workspace, seeded with the rounds
+    # shipped here so an attendee's own runs sit beside the worked example.
+    Handler.sessions = (
+        Sessions(Path(workshop).resolve(), examples=[d["dir"] for d in datasets])
+        if workshop
+        else None
+    )
     httpd = ThreadingHTTPServer((host, port), Handler)
     # When bound to all interfaces there's no single canonical URL; show
     # localhost for clicking and note the bind address.
@@ -663,6 +718,8 @@ def serve(
     print(
         f"  data dir: {data_dir}  ({len(datasets)} dataset(s): {names})"
     )
+    if workshop:
+        print(f"  workshop mode: per-session workspaces under {Handler.sessions.root}")
     if open_browser:
         try:
             webbrowser.open(url)

paratext_cli-0.3.0/src/paratext/review/sessions.py

@@ -0,0 +1,125 @@
+"""Per-attendee workspaces for workshop mode.
+
+A Space is one container shared by everyone looking at it, so without this a
+room full of people editing one prompt overwrite each other. Each browser gets
+a session: its own prompt and fields, its own rounds, its own verdicts.
+
+Sessions are disposable. They live under a root the caller chooses (``/tmp`` in
+a Space), and losing them costs a workshop exercise, not data.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import secrets
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+from ..store import Store
+
+# A session id comes back from a cookie, i.e. from the client. It is used to
+# build a path, so it is matched against this and rejected otherwise — never
+# sanitised and used anyway.
+SESSION_ID = re.compile(r"^[A-Za-z0-9_-]{16,64}$")
+COOKIE_NAME = "pt_session"
+
+
+def new_session_id() -> str:
+    return secrets.token_urlsafe(18)
+
+
+def valid_session_id(sid: str | None) -> bool:
+    return bool(sid and SESSION_ID.match(sid))
+
+
+@dataclass
+class Session:
+    id: str
+    dir: Path
+
+    @property
+    def data_dir(self) -> Path:
+        """Where this attendee's rounds live — the review root for them."""
+        return self.dir / "review"
+
+    @property
+    def db_path(self) -> Path:
+        return self.dir / "annotations.db"
+
+    @property
+    def state_path(self) -> Path:
+        return self.dir / "state.json"
+
+    def store(self) -> Store:
+        return Store(self.db_path)
+
+    def read_state(self) -> dict:
+        try:
+            return json.loads(self.state_path.read_text())
+        except (OSError, json.JSONDecodeError):
+            return {}
+
+    def write_state(self, state: dict) -> None:
+        self.dir.mkdir(parents=True, exist_ok=True)
+        self.state_path.write_text(json.dumps(state, indent=1))
+
+
+class Sessions:
+    """Creates and finds session workspaces under one root."""
+
+    def __init__(self, root: Path, examples: list[Path] | None = None):
+        self.root = Path(root)
+        self.examples = list(examples or [])
+
+    def path_for(self, sid: str) -> Path:
+        return self.root / sid
+
+    def exists(self, sid: str) -> bool:
+        return valid_session_id(sid) and self.path_for(sid).is_dir()
+
+    def get(self, sid: str | None) -> Session | None:
+        if not valid_session_id(sid) or not self.path_for(sid).is_dir():
+            return None
+        return Session(id=sid, dir=self.path_for(sid))
+
+    def create(self, sid: str | None = None) -> Session:
+        sid = sid if valid_session_id(sid) else new_session_id()
+        session = Session(id=sid, dir=self.path_for(sid))
+        session.data_dir.mkdir(parents=True, exist_ok=True)
+        self._seed_examples(session)
+        return session
+
+    def get_or_create(self, sid: str | None) -> tuple[Session, bool]:
+        """Returns the session and whether it was just created (so the caller
+        knows to set the cookie)."""
+        found = self.get(sid)
+        if found:
+            return found, False
+        return self.create(), True
+
+    def _seed_examples(self, session: Session) -> None:
+        """Symlink the shipped rounds in, so every attendee starts with the same
+        worked example beside their own work. Symlinked, not copied: the rounds
+        are read-only and their images are the bulk of the image."""
+        for src in self.examples:
+            dest = session.data_dir / src.name
+            if dest.exists() or not src.is_dir():
+                continue
+            try:
+                dest.symlink_to(src.resolve(), target_is_directory=True)
+            except OSError:
+                shutil.copytree(src, dest)
+
+    def reset(self, sid: str) -> bool:
+        """Delete one session's workspace. Used by the facilitator reset."""
+        if not self.exists(sid):
+            return False
+        shutil.rmtree(self.path_for(sid))
+        return True
+
+    def all_ids(self) -> list[str]:
+        if not self.root.is_dir():
+            return []
+        return sorted(p.name for p in self.root.iterdir() if p.is_dir())

{paratext_cli-0.2.4 → paratext_cli-0.3.0}/src/paratext/review/static/app.js

@@ -286,8 +286,8 @@ function renderPicker() {
          review round under <code>review/</code>, then reload — or point
          <code>paratext review</code> at a directory that contains one.</p>
     <p class="page-foot">
-      <a href="#/projects">Project configuration</a> — the fields, prompt and
-      source options each installed project runs with.
+      <code>paratext inspect</code> shows the fields, prompt and source options
+      each installed project runs with.
     </p>`;
     return;
   }
@@ -339,8 +339,8 @@ function renderPicker() {
     <h2>Choose a dataset to review</h2>
     <div style="max-width:32rem;">${cards}</div>
     <p class="page-foot">
-      <a href="#/projects">Project configuration</a> — the fields, prompt and
-      source options each installed project runs with.
+      <code>paratext inspect</code> shows the fields, prompt and source options
+      each installed project runs with.
     </p>
   `;
   document.querySelectorAll("[data-dataset]").forEach((btn) => {
@@ -1140,17 +1140,45 @@ function renderFieldsPanel(rounds) {
   </details>`;
 }
 
+
+// ── Prompt drift ──────────────────────────────────────────────────────
+// The one diagnostic the Projects page carried that nothing else does: does
+// the *installed* prompt still match what this round was run with? Silent when
+// no matching project is installed — reviewing a packaged round on a machine
+// that never ran it is normal.
+function renderDriftPanel(projects, schema) {
+  const p = (projects ?? []).find((x) => x.name === schema);
+  if (!p) return "";
+  const lr = p.latest_round;
+  const audit = (p.audit ?? []).length ? auditPill(p.audit) : "";
+  if (!lr) return audit ? `<p class="mt-2">${audit}</p>` : "";
+  const label = `round ${escapeHtml(String(lr.round))}`;
+  if (lr.matches_installed) {
+    return `<p class="text-light" style="font-size:.875rem;">
+      Prompt matches the installed project ${audit}</p>`;
+  }
+  return `<div class="mt-2">
+    <p class="bad"><strong>Prompt differs</strong> from ${label}
+      (<code>${escapeHtml(lr.dataset)}</code>) — a new run will not reproduce it. ${audit}</p>
+    <details class="mt-2"><summary>Diff — ${label} → installed</summary>
+      <pre class="mt-2" style="font-size:.8125rem;">${renderDiff(lr.prompt, p.prompt)}</pre>
+    </details>
+  </div>`;
+}
+
 async function renderStats() {
-  const [statsRes, tableRes, promptsRes, schemaRes] = await Promise.all([
+  const [statsRes, tableRes, promptsRes, schemaRes, projectsRes] = await Promise.all([
     fetch(api("api/stats")),
     fetch(api("api/table")),
     fetch(api("api/prompts")),
     fetch(api("api/schema")),
+    fetch("api/projects"),
   ]);
   const s = await statsRes.json();
   const rows = await tableRes.json();
   const promptsData = await promptsRes.json();
   const schemaData = await schemaRes.json();
+  const projects = await projectsRes.json().catch(() => []);
   document.getElementById("progress").textContent = "";
 
   const badge = (v) => {
@@ -1194,11 +1222,19 @@ async function renderStats() {
       <div class="field-row"><dt>Needs tweaks</dt><dd class="warn">${s.model.needs_tweaks}</dd></div>
       <div class="field-row"><dt>Not accurate</dt><dd class="bad">${s.model.not_accurate}</dd></div>
       ${hasFlag ? `<div class="field-row"><dt>Flagged</dt><dd>${s.flagged_marc}</dd></div>` : ""}
-      <div class="field-row"><dt>Eval gold set</dt><dd><strong>${s.eval_gold ?? s.model.good_enough}</strong>
-        <small class="text-light">(${s.model.good_enough} good-enough + ${s.corrected ?? 0} human-corrected ·
-        <a href="#/eval">build →</a>)</small></dd></div>
     </dl>
 
+    <div class="eval-cta">
+      <a href="#/eval" class="button primary gold-cta">
+        Build eval set
+        <span class="gold-count">${s.eval_gold ?? s.model.good_enough}</span>
+      </a>
+      <p class="text-light eval-cta-note">${s.model.good_enough} good-enough +
+        ${s.corrected ?? 0} human-corrected — the records that ship as gold.</p>
+    </div>
+
+    ${renderDriftPanel(projects, s.schema)}
+
     ${renderFieldsPanel(schemaData.rounds ?? [])}
 
     ${renderPromptsPanel(promptsData.prompts ?? [])}
@@ -1270,124 +1306,6 @@ async function renderStats() {
   });
 }
 
-// ── Projects (read-only inspector) ────────────────────────────────────
-// Describes the *installed* projects. Read-only: editing a project means
-// editing a Python package, and this server may be shared.
-// Styling is Oat's (.card / .badge / .table); only grid layout is local.
-function fieldTypeDetail(f) {
-  if (f.options)
-    return `<span class="text-light">{ ${f.options.map(escapeHtml).join(" | ")} }</span>`;
-  if (f.item_fields)
-    return `<span class="text-light">[ ${f.item_fields
-      .map((i) => escapeHtml(i.key))
-      .join(", ")} ]</span>`;
-  return "";
-}
-
-// Audit is green almost always, so it reads as a pill. Only a failure earns
-// detail — and then it earns all of it.
-function auditPill(problems) {
-  if (!problems.length) return `<span class="badge" data-variant="success">Audit ok</span>`;
-  return `<span class="badge" data-variant="danger">Audit failed</span>
-    <ul class="mt-2">${problems.map((a) => `<li class="bad">${escapeHtml(a)}</li>`).join("")}</ul>`;
-}
-
-function projectCard(p) {
-  if (p.error) {
-    return `<article class="card proj mb-4">
-      <h3>${escapeHtml(p.name)}</h3>
-      <p class="bad">Failed to load: ${escapeHtml(p.error)}</p>
-    </article>`;
-  }
-  const ep = p.entry_point || {};
-  const src = p.source || {};
-  const srcOpts = Object.entries(src)
-    .filter(([k]) => k !== "kind" && k !== "exts")
-    .map(([k, v]) => `${escapeHtml(k)}=${escapeHtml(String(v))}`)
-    .join(", ");
-
-  const fields = (p.view.panels || [])
-    .flatMap((panel) => panel.fields || [])
-    .map(
-      (f) => `<tr>
-        <td><code>${escapeHtml(f.key)}</code></td>
-        <td>${escapeHtml(f.type)} ${fieldTypeDetail(f)}</td>
-        <td class="text-light">${f.collapsed ? "collapsed" : ""}</td>
-      </tr>`,
-    )
-    .join("");
-
-  // One line per fact rather than a label/value grid — the labels were doing
-  // less work than the space they took.
-  const meta = [
-    `<code>${escapeHtml(ep.value || "?")}</code>`,
-    `${escapeHtml(ep.package || "")} ${escapeHtml(ep.version || "")}`.trim(),
-    `${escapeHtml(src.kind || "custom")}${srcOpts ? ` (${srcOpts})` : ""}`,
-    `images ${escapeHtml(String(p.images.max_size))}px q${escapeHtml(
-      String(p.images.quality),
-    )}`,
-    `prompt <code>${escapeHtml(p.prompt_hash)}</code> · ${p.prompt.split("\n").length} lines`,
-  ]
-    .filter(Boolean)
-    .join(" · ");
-
-  const lr = p.latest_round;
-  const roundLabel = (r) =>
-    `round ${escapeHtml(String(r.round))}` +
-    (r.prompt_hash ? ` <code>${escapeHtml(r.prompt_hash)}</code>` : "");
-  let drift = "";
-  if (lr && !lr.matches_installed) {
-    drift = `<p class="bad mt-2"><strong>Prompt differs</strong> from ${roundLabel(lr)}
-        (<code>${escapeHtml(lr.dataset)}</code>) — a new run will not reproduce it.</p>
-      <details class="mt-2"><summary>Diff — ${roundLabel(lr)} → installed</summary>
-        <pre class="mt-2" style="font-size:.8125rem;">${renderDiff(
-          lr.prompt,
-          p.prompt,
-        )}</pre>
-      </details>`;
-  } else if (lr) {
-    drift = `<p class="text-light mt-2">Prompt matches ${roundLabel(lr)}.</p>`;
-  }
-
-  return `<article class="card proj mb-4">
-    <h3>${escapeHtml(p.name)}
-      <span class="badge outline">${escapeHtml(p.schema_version)}</span>
-      ${auditPill(p.audit)}</h3>
-    <p class="proj-meta text-light">${meta}</p>
-    ${drift}
-    <div class="table"><table><thead><tr><th>Field</th><th>Type</th><th></th></tr></thead>
-      <tbody>${fields}</tbody></table></div>
-    <details class="mt-4"><summary>Prompt</summary>
-      <pre class="prompt-text">${escapeHtml(p.prompt)}</pre></details>
-  </article>`;
-}
-
-async function renderProjects() {
-  const el = document.getElementById("view");
-  el.innerHTML = `<p class="text-light">Loading projects…</p>`;
-  let projects;
-  try {
-    // Relative path, no dataset param: this endpoint is about what's installed,
-    // and the prefix must survive being served behind /verify/.
-    const res = await fetch("api/projects");
-    if (!res.ok) throw new Error(`HTTP ${res.status}`);
-    projects = await res.json();
-  } catch (e) {
-    el.innerHTML = `<p class="bad">Could not load projects: ${escapeHtml(String(e))}</p>`;
-    return;
-  }
-
-  if (!projects.length) {
-    el.innerHTML = `<h2>Project configuration</h2>
-      <p>No projects installed. Scaffold one with <code>paratext new</code>.</p>`;
-    return;
-  }
-
-  el.innerHTML = `<h2>Project configuration</h2>
-    ${projects.map(projectCard).join("")}
-    <p class="mt-4"><a href="#/select" class="button outline small">← Back to datasets</a></p>`;
-}
-
 // ── Export modal ──────────────────────────────────────────────────────
 // A native <dialog> (Oat-styled) over the /api/export/* endpoints. Format-first
 // tabs; a records-scope row (verdict-coloured dots) that governs MARC/DC/JSONL;
@@ -1748,7 +1666,6 @@ async function openExportModal() {
 function currentRoute() {
   if (location.hash === "#/select") return "select";
   if (location.hash === "#/stats") return "stats";
-  if (location.hash === "#/projects") return "projects";
   if (location.hash === "#/eval" || location.hash.startsWith("#/eval/")) return "eval";
   return "review";
 }
@@ -1762,14 +1679,6 @@ async function route() {
     await loadDatasets();
   }
 
-  // Projects describes what's installed, not what's been run — so it must not
-  // sit behind dataset selection (a fresh install has no datasets at all).
-  if (currentRoute() === "projects") {
-    renderHeader();
-    await renderProjects();
-    return;
-  }
-
   // Resolve the current dataset:
   // - 0 datasets → handled by renderPicker (shows guidance).
   // - 1 dataset  → auto-select.

{paratext_cli-0.2.4 → paratext_cli-0.3.0}/src/paratext/review/static/index.html

@@ -114,6 +114,31 @@
       .proj-meta { margin: .25rem 0 .75rem; font-size: .8125rem; word-break: break-word; }
       .prompt-text { white-space: pre-wrap; font-size: .8125rem; max-height: 30rem;
         overflow-y: auto; }
+      /* Eval-set call to action. The gold set is the point of reviewing, so it
+         is a button, not a statistic. The hover ring is a conic gradient rotated
+         through a registered @property — a plain gradient can't be animated. */
+      .eval-cta { margin: 1.25rem 0 1.5rem; }
+      .eval-cta-note { font-size: var(--text-8); margin: .5rem 0 0; }
+      .gold-cta { position: relative; font-size: 1rem; padding: .6875rem 1.25rem;
+        display: inline-flex; align-items: center; gap: .625rem; }
+      .gold-cta .gold-count { font-variant-numeric: tabular-nums; font-weight: 700;
+        background: rgb(255 255 255 / .18); border-radius: var(--radius, .375rem);
+        padding: .0625rem .5rem; }
+      @property --gold-angle { syntax: "<angle>"; initial-value: 0deg; inherits: false; }
+      .gold-cta::before {
+        content: ""; position: absolute; inset: -2px; border-radius: inherit; z-index: -1;
+        background: conic-gradient(from var(--gold-angle),
+          transparent 0turn .45turn, #b8860b .62turn, #ffd76e .75turn,
+          #fff3c4 .8turn, #ffd76e .85turn, #b8860b .95turn, transparent 1turn);
+        opacity: 0; transition: opacity .18s ease;
+      }
+      .gold-cta:hover::before, .gold-cta:focus-visible::before {
+        opacity: 1; animation: gold-sweep 2.2s linear infinite;
+      }
+      @keyframes gold-sweep { to { --gold-angle: 1turn; } }
+      @media (prefers-reduced-motion: reduce) {
+        .gold-cta:hover::before, .gold-cta:focus-visible::before { animation: none; }
+      }
       /* Export modal. Oat styles the dialog (pads > header / > div / > footer, the
          body div scrolls) plus inputs, selects, switches and tables. Inline CSS is
          UNLAYERED and beats Oat's @layer rules, so this stays narrow: the bespoke