evals-lab 0.5.0 → 0.7.0

package/lab/server.py

@@ -298,23 +298,53 @@ FILE_TYPES = {
 }
 
 # The kinds of Source, mirrored from evals-core.ts's SOURCE_TYPES: Python
-# cannot load TypeScript, so the server keeps what it enforces -- the id a
-# row may carry and the files a Source of that type takes. A type is a
-# registry entry, never a branch on its id.
+# cannot load TypeScript, so the server keeps what it enforces. A kind is a
+# registry entry, never a branch on its id. The row's `type` is the kind; a
+# workflow kind's enforcement comes from the platform its `config.platform`
+# names (WORKFLOW_PLATFORMS below), a kind marked `platforms`.
 SOURCE_TYPES = {
     "files": {"label": "File Library", "uploads": FILE_TYPES},
-    # A Power Automate cloud flow (docs/power-automate.md): no uploads yet --
-    # its records arrive with a later phase -- and a definition, kept as a
-    # versioned snapshot beside the row.
-    #
-    # `uploads` are the files it takes; `take`, when there is one, checks and
-    # rewrites each before it is kept; `signIn` is the sign-in it is made with,
-    # without which the lab cannot make one; `definition` means it keeps one.
-    "power-automate": {"label": "Power Automate workflow", "definition": True, "signIn": "microsoft",
-                       "uploads": {".json": "application/json; charset=utf-8"}},
+    "workflow": {"label": "Workflow", "platforms": True},
 }
 DEFAULT_SOURCE_TYPE = "files"
 
+# The workflow platforms, mirrored from evals-core.ts's WORKFLOW_PLATFORMS: the
+# flow engine a workflow Source speaks to, named in its `config.platform`. A
+# workflow kind's enforcement is the platform's, not the kind's.
+#
+# `uploads` are the files it takes; `take`, when there is one, checks and
+# rewrites each before it is kept; `signIn` is the sign-in it is made with,
+# without which the lab cannot make one; `definition` means it keeps one.
+WORKFLOW_PLATFORMS = {
+    "power-automate": {"label": "Power Automate flow", "definition": True, "signIn": "microsoft",
+                       "uploads": {".json": "application/json; charset=utf-8"}},
+}
+
+
+def _config_platform(config):
+    """The platform a Source's stored config (a JSON string or None) names,
+    or None -- what the page labels a workflow by."""
+    try:
+        cfg = json.loads(config) if config else None
+    except ValueError:
+        return None
+    platform = cfg.get("platform") if isinstance(cfg, dict) else None
+    return platform if isinstance(platform, str) else None
+
+
+def source_entry(ptype, config):
+    """The enforcement entry for a Source of type [ptype] and [config] (a
+    dict or None): its kind's, or, for a workflow kind, the platform its
+    config names. None for an unknown kind, or a workflow whose platform the
+    lab does not know. A reader asks the entry, never the id."""
+    kind = SOURCE_TYPES.get(ptype)
+    if kind is None:
+        return None
+    if kind.get("platforms"):
+        platform = config.get("platform") if isinstance(config, dict) else None
+        return WORKFLOW_PLATFORMS.get(platform)
+    return kind
+
 # The Entra app the page signs in to Microsoft 365 with (docs/power-automate.md
 # § Registering the app). A single-page app has no secret, so both are public
 # and served to the page; the token it gets stays in the browser, and the
@@ -481,7 +511,7 @@ def take_record(name, data):
     return json.dumps(kept, indent=2).encode("utf-8"), None
 
 
-SOURCE_TYPES["power-automate"]["take"] = take_record
+WORKFLOW_PLATFORMS["power-automate"]["take"] = take_record
 
 # The sign-ins a Source type may be made with, and whether this lab has each:
 # a type naming one this lab lacks cannot be made.
@@ -602,6 +632,45 @@ def hide_keys(docs: dict) -> dict:
     return out
 
 
+# ---- workspaces (docs/workspaces.md) -------------------------------------
+# A workspace is the lab's first tenant dimension: a row in `workspaces` and a
+# filter on every scopable table. Phase 1 is invisible -- a request that names
+# no workspace resolves to the flagged default, so the existing page and CI
+# keep working. It is isolation, not access control: until multi-user lands, a
+# workspace is a filter, not a permission boundary (AGENTS.md).
+#
+# The workspace the current thread's db work is scoped to is held here, bound
+# per request by the Handler and per run by the queue worker; unset, a scoped
+# read falls back to the store's flagged default, which keeps direct callers
+# (startup, a check's own calls) on the default workspace.
+_WS = threading.local()
+
+
+def set_workspace(ws):
+    """Bind the current thread to workspace `ws` for its db work; None clears
+    it, so scoped reads fall back to the store's default workspace."""
+    _WS.ws = ws
+
+
+def workspace_of(store) -> str:
+    ws = getattr(_WS, "ws", None)
+    return ws if ws else store.default_ws
+
+
+# The `connection_shares` sentinels (phase 4 fills and enforces the table;
+# phase 1 only creates it empty): every workspace, and future ones.
+SHARE_ALL = "*all"
+SHARE_NEW = "*new"
+
+# How the `docs` table scopes by key (docs/workspaces.md): workflows are
+# per-workspace, profiles/tokens global, and promptlab.versions is split --
+# its pipeline/dataset slices per-workspace, its profile slice global, because
+# profiles are global so their Restore must be too. served()/write() route
+# each key by these; any other key is per-workspace.
+DOC_GLOBAL = ("promptlab.profiles", "promptlab.tokens")
+DOC_SPLIT = "promptlab.versions"
+
+
 class Store:
     """
     Documents by name, each with a version that goes up by one per write.
@@ -618,17 +687,36 @@ class Store:
         self.path = path
         self.lock = threading.Lock()
         with self.lock, closing(sqlite3.connect(path)) as db, db:
-            db.execute("CREATE TABLE IF NOT EXISTS docs (name TEXT PRIMARY KEY, "
-                       "version INTEGER NOT NULL, body TEXT, updated_at TEXT NOT NULL)")
+            # The workspace registry and the share table come first:
+            # everything else is scoped to a workspace, and the flagged default
+            # must exist before any backfill can assign rows to it.
+            db.execute("CREATE TABLE IF NOT EXISTS workspaces ("
+                       "id TEXT PRIMARY KEY, slug TEXT UNIQUE, name TEXT NOT NULL, "
+                       "archived INTEGER NOT NULL DEFAULT 0, is_default INTEGER NOT NULL DEFAULT 0, "
+                       "last_used TEXT, created_at TEXT, trash TEXT, trashed_at REAL)")
+            # Shared-by-choice connections (profiles, Accounts): phase 4 fills
+            # and enforces this; phase 1 only creates it empty.
+            db.execute("CREATE TABLE IF NOT EXISTS connection_shares ("
+                       "kind TEXT NOT NULL, id TEXT NOT NULL, workspace TEXT NOT NULL, "
+                       "PRIMARY KEY (kind, id, workspace))")
+            self.default_ws = self._ensure_default(db)
             db.execute("CREATE TABLE IF NOT EXISTS runs (at TEXT PRIMARY KEY, body TEXT NOT NULL)")
             # The key of a profile a write took out, by id, for TRASH_SECONDS:
             # Undo puts the profile back holding KEY_HELD, and this is what
-            # it holds.
+            # it holds. Profiles are global, so the ring is too.
             db.execute("CREATE TABLE IF NOT EXISTS dropped_keys (id TEXT PRIMARY KEY, "
                        "key TEXT NOT NULL, at REAL NOT NULL)")
+            # The docs table keys documents by (name, workspace): a store from
+            # before workspaces keyed them by name alone and is rebuilt once,
+            # the global keys moved under NULL and promptlab.versions split.
+            # Idempotent: a later open finds the workspace column and leaves it.
+            cols = {r[1] for r in db.execute("PRAGMA table_info(docs)")}
+            if not cols:
+                self._create_docs(db)
             # History was a document, capped at what a browser could hold. The
             # first start with the table moves what that document had into it,
-            # once, and drops the document so the page stops carrying it.
+            # once, and drops the document so the page stops carrying it. It
+            # reads name/body, so it runs on either docs schema.
             old = db.execute("SELECT body FROM docs WHERE name = 'promptlab.runs'").fetchone()
             if old and not db.execute("SELECT 1 FROM runs LIMIT 1").fetchone():
                 for run in json.loads(old[0] or "null") or []:
@@ -636,20 +724,118 @@ class Store:
                         db.execute("INSERT OR IGNORE INTO runs (at, body) VALUES (?, ?)",
                                    (run["at"], json.dumps(run)))
             db.execute("DELETE FROM docs WHERE name = 'promptlab.runs'")
+            # The run history is the queue table now; this `runs` table holds
+            # only what the pre-queue history document migrated into it, and is
+            # served from nowhere. It carries the workspace column all the same,
+            # so the scopable-table set is whole and anything that ever reads it
+            # inherits the filter (docs/workspaces.md).
+            if "workspace" not in {r[1] for r in db.execute("PRAGMA table_info(runs)")}:
+                db.execute("ALTER TABLE runs ADD COLUMN workspace TEXT")
+            db.execute("UPDATE runs SET workspace = ? WHERE workspace IS NULL", (self.default_ws,))
+            if cols and "workspace" not in cols:
+                self._rebuild_docs(db)
+
+    def _ensure_default(self, db) -> str:
+        """The flagged default workspace's id, seeding "Default" (/w/default,
+        is_default = 1) on a store that has none. Defined by the flag, not its
+        name or slug, so a later rename never moves it (docs/workspaces.md)."""
+        row = db.execute("SELECT id FROM workspaces WHERE is_default = 1").fetchone()
+        if row:
+            return row[0]
+        wid = secrets.token_hex(6)
+        now = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+        db.execute("INSERT INTO workspaces (id, slug, name, archived, is_default, last_used, created_at) "
+                   "VALUES (?, 'default', 'Default', 0, 1, ?, ?)", (wid, now, now))
+        return wid
+
+    def workspace(self, slug: str) -> str:
+        """The id of the workspace at /w/<slug>, or None. An unknown slug is
+        None; the Handler falls back to the default so a stale address still
+        reaches a working lab until the page's Gone state lands (phase 3)."""
+        with self.lock, closing(sqlite3.connect(self.path)) as db:
+            row = db.execute("SELECT id FROM workspaces WHERE slug = ?", (slug,)).fetchone()
+        return row[0] if row else None
 
-    def _rows(self, db):
-        return {name: {"version": version, "body": None if body is None else json.loads(body)}
-                for name, version, body in db.execute("SELECT name, version, body FROM docs")}
+    @staticmethod
+    def _create_docs(db):
+        db.execute("CREATE TABLE docs (name TEXT NOT NULL, workspace TEXT, "
+                   "version INTEGER NOT NULL, body TEXT, updated_at TEXT NOT NULL)")
+        # NULLs are distinct in a UNIQUE index, so the global keys cannot rely
+        # on one PRIMARY KEY for their one-row-per-name rule: two partial
+        # indexes, scoped rows keyed by (name, workspace) and global rows by
+        # name, give each its own uniqueness and its own upsert target.
+        db.execute("CREATE UNIQUE INDEX docs_scoped ON docs(name, workspace) WHERE workspace IS NOT NULL")
+        db.execute("CREATE UNIQUE INDEX docs_global ON docs(name) WHERE workspace IS NULL")
+
+    def _rebuild_docs(self, db):
+        rows = db.execute("SELECT name, version, body, updated_at FROM docs").fetchall()
+        db.execute("ALTER TABLE docs RENAME TO docs_old")
+        self._create_docs(db)
+        put = lambda name, ws, version, body, at: db.execute(
+            "INSERT INTO docs (name, workspace, version, body, updated_at) VALUES (?, ?, ?, ?, ?)",
+            (name, ws, version, body, at))
+        for name, version, body, at in rows:
+            if name in DOC_GLOBAL:
+                put(name, None, version, body, at)
+            elif name == DOC_SPLIT:
+                parsed = json.loads(body) if body else {}
+                put(name, self.default_ws, version, None if body is None else json.dumps(
+                    {"pipeline": parsed.get("pipeline", {}), "dataset": parsed.get("dataset", {})}), at)
+                put(name, None, version, None if body is None else json.dumps(
+                    {"profile": parsed.get("profile", {})}), at)
+            else:
+                put(name, self.default_ws, version, body, at)
+        db.execute("DROP TABLE docs_old")
+
+    def _doc_rows(self, db, ws: str) -> dict:
+        """The logical document set a workspace reads: its scoped rows, the
+        global rows (profiles, tokens), and promptlab.versions reassembled from
+        its per-workspace pipeline/dataset slice and the global profile slice,
+        carrying the per-workspace slice's version so the page's one version
+        per key still arbitrates pipeline/dataset Restore."""
+        parse = lambda b: None if b is None else json.loads(b)
+        scoped = {name: (version, body) for name, version, body in db.execute(
+            "SELECT name, version, body FROM docs WHERE workspace = ?", (ws,))}
+        glob = {name: (version, body) for name, version, body in db.execute(
+            "SELECT name, version, body FROM docs WHERE workspace IS NULL")}
+        out = {name: {"version": v, "body": parse(b)}
+               for name, (v, b) in scoped.items() if name != DOC_SPLIT}
+        for name in DOC_GLOBAL:
+            if name in glob:
+                v, b = glob[name]
+                out[name] = {"version": v, "body": parse(b)}
+        sv, gv = scoped.get(DOC_SPLIT), glob.get(DOC_SPLIT)
+        if sv is not None or gv is not None:
+            sver, sbody = sv if sv is not None else (0, None)
+            sbody, gbody = parse(sbody) or {}, parse(gv[1]) if gv is not None else {}
+            out[DOC_SPLIT] = {"version": sver, "body": {
+                "pipeline": sbody.get("pipeline", {}), "dataset": sbody.get("dataset", {}),
+                "profile": (gbody or {}).get("profile", {})}}
+        return out
 
-    def all(self) -> dict:
+    def all(self, ws=None) -> dict:
         with self.lock, closing(sqlite3.connect(self.path)) as db:
-            return self._rows(db)
-
-    def served(self) -> dict:
-        """What a browser is handed: the SYNCED documents only, so a retired
-        key's rows stay in the store without reaching a page again, and no
-        profile's key (KEY_HELD)."""
-        return hide_keys({n: d for n, d in self.all().items() if n in SYNCED})
+            return self._doc_rows(db, ws or workspace_of(self))
+
+    def served(self, ws=None) -> dict:
+        """What a browser is handed for its workspace: the SYNCED documents
+        only, so a retired key's rows stay in the store without reaching a page
+        again, and no profile's key (KEY_HELD)."""
+        return hide_keys({n: d for n, d in self.all(ws).items() if n in SYNCED})
+
+    def _put(self, db, name, ws, version, body, at):
+        text = None if body is None else json.dumps(body)
+        if ws is None:
+            db.execute(
+                "INSERT INTO docs (name, workspace, version, body, updated_at) VALUES (?, NULL, ?, ?, ?) "
+                "ON CONFLICT(name) WHERE workspace IS NULL DO UPDATE SET version = excluded.version, "
+                "body = excluded.body, updated_at = excluded.updated_at", (name, version, text, at))
+        else:
+            db.execute(
+                "INSERT INTO docs (name, workspace, version, body, updated_at) VALUES (?, ?, ?, ?, ?) "
+                "ON CONFLICT(name, workspace) WHERE workspace IS NOT NULL DO UPDATE SET "
+                "version = excluded.version, body = excluded.body, updated_at = excluded.updated_at",
+                (name, ws, version, text, at))
 
     def _keyring(self, db, now: dict) -> dict:
         """Each profile id's key as the store holds it: its profile's, else a
@@ -668,18 +854,24 @@ class Store:
         return ring
 
     def held_key(self, key: str) -> str:
-        """The key KEY_HELD stands for, or "" when the store holds none."""
+        """The key KEY_HELD stands for, or "" when the store holds none.
+        Profiles are global, so the ring is read under the default workspace."""
         with self.lock, closing(sqlite3.connect(self.path)) as db, db:
-            return self._keyring(db, self._rows(db)).get(key[len(KEY_HELD):], "")
+            return self._keyring(db, self._doc_rows(db, self.default_ws)).get(key[len(KEY_HELD):], "")
 
-    def write(self, docs: dict):
+    def write(self, docs: dict, ws=None):
         """
-        `docs` is {name: {"version": the version it began from, "body": ...}}.
-        Returns ({name: new version}, None), or (None, {name: current}) for
-        every document that has moved on, with nothing written.
+        `docs` is {name: {"version": the version it began from, "body": ...}},
+        written into workspace `ws` (the current thread's, by default). Each
+        key is routed by scope: workflows and the rest per-workspace, profiles
+        and tokens global, promptlab.versions split (pipeline/dataset
+        per-workspace, profile global). Returns ({name: new version}, None), or
+        (None, {name: current}) for every document that has moved on, with
+        nothing written.
         """
+        ws = ws or workspace_of(self)
         with self.lock, closing(sqlite3.connect(self.path)) as db:
-            now = self._rows(db)
+            now = self._doc_rows(db, ws)
             have = lambda n: now.get(n, {"version": 0, "body": None})
             stale = {n: have(n) for n, d in docs.items() if d["version"] != have(n)["version"]}
             if stale:
@@ -701,11 +893,19 @@ class Store:
                          for p in profiles_in("promptlab.profiles", have("promptlab.profiles")["body"])
                          if str(p.get("id") or "") not in kept and isinstance(p.get("key"), str) and p["key"]])
                 for n, d in docs.items():
-                    db.execute(
-                        "INSERT INTO docs (name, version, body, updated_at) VALUES (?, ?, ?, ?) "
-                        "ON CONFLICT(name) DO UPDATE SET version = excluded.version, "
-                        "body = excluded.body, updated_at = excluded.updated_at",
-                        (n, have(n)["version"] + 1, None if d["body"] is None else json.dumps(d["body"]), at))
+                    version, body = have(n)["version"] + 1, d["body"]
+                    if n == DOC_SPLIT:
+                        parsed = body if isinstance(body, dict) else {}
+                        self._put(db, n, ws, version, None if body is None else {
+                            "pipeline": parsed.get("pipeline", {}), "dataset": parsed.get("dataset", {})}, at)
+                        # The profile slice is global, on its own version
+                        # counter: profiles are shared, so their Restore is too.
+                        gv = db.execute("SELECT version FROM docs WHERE name = ? AND workspace IS NULL",
+                                        (n,)).fetchone()
+                        self._put(db, n, None, (gv[0] if gv else 0) + 1,
+                                  None if body is None else {"profile": parsed.get("profile", {})}, at)
+                    else:
+                        self._put(db, n, None if n in DOC_GLOBAL else ws, version, body, at)
             return {n: have(n)["version"] + 1 for n in docs}, None
 
 
@@ -781,6 +981,34 @@ class Sources:
                            f"DEFAULT '{DEFAULT_SOURCE_TYPE}'")
             if "config" not in have:
                 db.execute("ALTER TABLE sources ADD COLUMN config TEXT")
+            # The workspace a Source belongs to (docs/workspaces.md). A store
+            # from before workspaces gains the column; every user Source with
+            # none -- a pre-workspace row, or one left unscoped by any edge --
+            # backfills to the default on open, idempotently, while the system
+            # samples row stays workspace-agnostic (NULL) so it shows in every
+            # workspace.
+            if "workspace" not in have:
+                db.execute("ALTER TABLE sources ADD COLUMN workspace TEXT")
+            db.execute("UPDATE sources SET workspace = ? WHERE workspace IS NULL AND system = 0",
+                       (store.default_ws,))
+            # A Power Automate Source was its own kind once (type
+            # "power-automate", docs/power-automate.md); it is now the generic
+            # workflow kind, the platform named in its config
+            # (docs/sources-tab.md). Converted here, once and idempotently: a
+            # later open finds none left. remove()/restore_trash keep a row's
+            # type and config, so Undo brings a converted Source back exactly,
+            # still speaking to Power Automate.
+            for sid, config in db.execute(
+                    "SELECT id, config FROM sources WHERE type = 'power-automate'").fetchall():
+                try:
+                    cfg = json.loads(config) if config else {}
+                except ValueError:
+                    cfg = {}
+                if not isinstance(cfg, dict):
+                    cfg = {}
+                cfg["platform"] = "power-automate"
+                db.execute("UPDATE sources SET type = 'workflow', config = ? WHERE id = ?",
+                           (json.dumps(cfg), sid))
             # A flow's definition, one row per version: a snapshot the page
             # took and redacted, redacted again here.
             db.execute("CREATE TABLE IF NOT EXISTS source_definitions ("
@@ -809,26 +1037,37 @@ class Sources:
         out = []
         with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
             db.row_factory = sqlite3.Row
-            for r in db.execute("SELECT id, name, system, bytes, type FROM sources "
-                                "ORDER BY system DESC, name COLLATE NOCASE"):
+            for r in db.execute("SELECT id, name, system, bytes, type, config, created_at FROM sources "
+                                "WHERE workspace = ? OR system = 1 "
+                                "ORDER BY system DESC, name COLLATE NOCASE", (workspace_of(self.store),)):
                 if r["system"]:
                     files = self._sample_files()
                     out.append({"id": r["id"], "name": r["name"], "system": True,
                                 "type": r["type"],
                                 "files": len(files), "bytes": sum(f["bytes"] for f in files)})
                 else:
-                    n = db.execute("SELECT COUNT(*) FROM source_files WHERE source = ?",
-                                   (r["id"],)).fetchone()[0]
-                    out.append({"id": r["id"], "name": r["name"], "system": False,
-                                "type": r["type"], "files": n, "bytes": r["bytes"]})
+                    n, last = db.execute("SELECT COUNT(*), MAX(at) FROM source_files WHERE source = ?",
+                                         (r["id"],)).fetchone()
+                    # When it last changed: made, or a file added -- what a
+                    # picker orders its recent Sources by.
+                    row = {"id": r["id"], "name": r["name"], "system": False,
+                           "type": r["type"], "files": n, "bytes": r["bytes"],
+                           "changed": max(filter(None, (r["created_at"], last)))}
+                    # A workflow's platform is how the page labels it; nothing
+                    # else of its config rides in the summary.
+                    platform = _config_platform(r["config"])
+                    if platform is not None:
+                        row["platform"] = platform
+                    out.append(row)
         return out
 
     def get(self, sid) -> dict:
         """One Source with its file list, or None."""
         with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
             db.row_factory = sqlite3.Row
-            r = db.execute("SELECT id, name, system, bytes, type, config FROM sources WHERE id = ?",
-                           (sid,)).fetchone()
+            r = db.execute("SELECT id, name, system, bytes, type, config FROM sources "
+                           "WHERE id = ? AND (workspace = ? OR system = 1)",
+                           (sid, workspace_of(self.store))).fetchone()
             if r is None:
                 return None
             if r["system"]:
@@ -875,14 +1114,18 @@ class Sources:
             return None, (400, "that name is too long")
         if not isinstance(kind, str) or kind not in SOURCE_TYPES:
             return None, (400, f"the lab has no Source type {kind!r}")
+        # A workflow kind needs a platform the lab knows, named in its config.
+        if source_entry(kind, config) is None:
+            return None, (400, "the lab has no such Source platform")
         kept, err = self._config(config)
         if err:
             return None, err
         sid = secrets.token_hex(6)
         with self.store.lock, closing(sqlite3.connect(self.store.path)) as db, db:
-            db.execute("INSERT INTO sources (id, name, system, bytes, created_at, type, config) "
-                       "VALUES (?, ?, 0, 0, ?, ?, ?)",
-                       (sid, name, time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), kind, kept))
+            db.execute("INSERT INTO sources (id, name, system, bytes, created_at, type, config, workspace) "
+                       "VALUES (?, ?, 0, 0, ?, ?, ?, ?)",
+                       (sid, name, time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), kind, kept,
+                        workspace_of(self.store)))
         (self.dir / sid).mkdir(parents=True, exist_ok=True)
         return {"id": sid, "name": name, "system": False, "type": kind,
                 "config": json.loads(kept) if kept else None, "files": [], "bytes": 0}, None
@@ -893,8 +1136,8 @@ class Sources:
         """A Source's newest definition and the versions kept, or None for a
         Source that is not there or keeps none."""
         with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
-            r = db.execute("SELECT type FROM sources WHERE id = ?", (sid,)).fetchone()
-            if r is None or not (SOURCE_TYPES.get(r[0]) or {}).get("definition"):
+            r = db.execute("SELECT type, config FROM sources WHERE id = ? AND (workspace = ? OR system = 1)", (sid, workspace_of(self.store))).fetchone()
+            if r is None or not (source_entry(r[0], json.loads(r[1]) if r[1] else None) or {}).get("definition"):
                 return None
             rows = db.execute("SELECT version, body, at FROM source_definitions WHERE source = ? "
                               "ORDER BY version DESC", (sid,)).fetchall()
@@ -920,10 +1163,10 @@ class Sources:
             return None, (413, "that definition is over the cap")
         now = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
         with self.store.lock, closing(sqlite3.connect(self.store.path)) as db, db:
-            r = db.execute("SELECT type FROM sources WHERE id = ?", (sid,)).fetchone()
+            r = db.execute("SELECT type, config FROM sources WHERE id = ? AND (workspace = ? OR system = 1)", (sid, workspace_of(self.store))).fetchone()
             if r is None:
                 return None, (404, "no such source")
-            if not (SOURCE_TYPES.get(r[0]) or {}).get("definition"):
+            if not (source_entry(r[0], json.loads(r[1]) if r[1] else None) or {}).get("definition"):
                 return None, (400, "a Source of that type keeps no definition")
             current = db.execute("SELECT MAX(version) FROM source_definitions WHERE source = ?",
                                  (sid,)).fetchone()[0] or 0
@@ -953,10 +1196,15 @@ class Sources:
                     db.execute("DELETE FROM source_definitions WHERE source = ?", (sid,))
 
     def type_of(self, sid):
-        """A Source's type's entry in SOURCE_TYPES; None for no such Source."""
+        """A Source's enforcement entry -- its kind's, or its workflow
+        platform's (source_entry); None for no such Source. {} for a known
+        Source whose platform the lab does not know, so a reader asks the
+        entry rather than the id."""
         with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
-            r = db.execute("SELECT type FROM sources WHERE id = ?", (sid,)).fetchone()
-        return None if r is None else (SOURCE_TYPES.get(r[0]) or {})
+            r = db.execute("SELECT type, config FROM sources WHERE id = ? AND (workspace = ? OR system = 1)", (sid, workspace_of(self.store))).fetchone()
+        if r is None:
+            return None
+        return source_entry(r[0], json.loads(r[1]) if r[1] else None) or {}
 
     def uploads(self, sid):
         """The files a Source takes, by extension, as its type declares them;
@@ -972,7 +1220,7 @@ class Sources:
         if len(name) > 80:
             return None, (400, "that name is too long")
         with self.store.lock, closing(sqlite3.connect(self.store.path)) as db, db:
-            r = db.execute("SELECT system FROM sources WHERE id = ?", (sid,)).fetchone()
+            r = db.execute("SELECT system FROM sources WHERE id = ? AND (workspace = ? OR system = 1)", (sid, workspace_of(self.store))).fetchone()
             if r is None:
                 return None, (404, "no such source")
             if r[0]:
@@ -985,8 +1233,9 @@ class Sources:
         Undo can restore it; the system Source is undeletable. Returns
         (token, None), or (None, error)."""
         with self.store.lock, closing(sqlite3.connect(self.store.path)) as db, db:
-            r = db.execute("SELECT system, name, created_at, type, config FROM sources "
-                           "WHERE id = ?", (sid,)).fetchone()
+            r = db.execute("SELECT system, name, created_at, type, config, workspace FROM sources "
+                           "WHERE id = ? AND (workspace = ? OR system = 1)",
+                           (sid, workspace_of(self.store))).fetchone()
             if r is None:
                 return None, (404, "no such source")
             if r[0]:
@@ -1001,7 +1250,7 @@ class Sources:
         entry.mkdir(parents=True, exist_ok=True)
         (entry / "manifest.json").write_text(json.dumps({
             "kind": "source", "source": sid, "name": r[1], "created": r[2],
-            "type": r[3], "config": r[4], "at": time.time(), "files": files}))
+            "type": r[3], "config": r[4], "workspace": r[5], "at": time.time(), "files": files}))
         if (self.dir / sid).is_dir():
             shutil.move(str(self.dir / sid), str(entry / sid))
         return token, None
@@ -1014,7 +1263,7 @@ class Sources:
             return None, (400, "no files named")
         names = list(dict.fromkeys(names))
         with self.store.lock, closing(sqlite3.connect(self.store.path)) as db, db:
-            r = db.execute("SELECT system FROM sources WHERE id = ?", (sid,)).fetchone()
+            r = db.execute("SELECT system FROM sources WHERE id = ? AND (workspace = ? OR system = 1)", (sid, workspace_of(self.store))).fetchone()
             if r is None:
                 return None, (404, "no such source")
             if r[0]:
@@ -1069,19 +1318,22 @@ class Sources:
             sid, name = m.get("source"), m.get("name")
             if not isinstance(sid, str) or not isinstance(name, str):
                 return None, (404, "no such trash entry")
+            # Back into the workspace it was trashed from (an older trash entry
+            # has none: the default). A name is unique within a workspace.
+            ws = m.get("workspace") or self.store.default_ws
             with self.store.lock, closing(sqlite3.connect(self.store.path)) as db, db:
                 if db.execute("SELECT 1 FROM sources WHERE name = ? COLLATE NOCASE "
-                              "AND system = 0", (name,)).fetchone():
+                              "AND system = 0 AND workspace = ?", (name, ws)).fetchone():
                     return None, (409, f"{name!r} has been taken since, so nothing was restored")
                 with db:
                     kind = m.get("type")
                     db.execute("INSERT INTO sources (id, name, system, bytes, created_at, "
-                               "type, config) VALUES (?, ?, 0, ?, ?, ?, ?)",
+                               "type, config, workspace) VALUES (?, ?, 0, ?, ?, ?, ?, ?)",
                                (sid, name, sum(f.get("bytes", 0) for f in m["files"]),
                                 m.get("created", time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())),
                                 # As it was: a restore puts the row back, not a guess at it.
                                 kind if isinstance(kind, str) else DEFAULT_SOURCE_TYPE,
-                                m.get("config") if isinstance(m.get("config"), str) else None))
+                                m.get("config") if isinstance(m.get("config"), str) else None, ws))
                     for f in m["files"]:
                         if isinstance(f, dict) and isinstance(f.get("name"), str):
                             db.execute("INSERT INTO source_files (source, name, bytes, at) "
@@ -1097,7 +1349,8 @@ class Sources:
             return None, (404, "no such trash entry")
         total = sum(f.get("bytes", 0) for f in files)
         with self.store.lock, closing(sqlite3.connect(self.store.path)) as db, db:
-            r = db.execute("SELECT system, bytes FROM sources WHERE id = ?", (sid,)).fetchone()
+            r = db.execute("SELECT system, bytes FROM sources WHERE id = ? AND (workspace = ? OR system = 1)",
+                           (sid, workspace_of(self.store))).fetchone()
             if r is None:
                 return None, (409, "the Source that held these files is gone, so nothing was restored")
             if r[0]:
@@ -1168,14 +1421,15 @@ class Sources:
         names = list(dict.fromkeys(names))
         with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
             db.row_factory = sqlite3.Row
-            dest = db.execute("SELECT system, bytes, type FROM sources WHERE id = ?",
-                              (sid,)).fetchone()
+            ws = workspace_of(self.store)
+            dest = db.execute("SELECT system, bytes, type FROM sources WHERE id = ? AND (workspace = ? OR system = 1)",
+                              (sid, ws)).fetchone()
             if dest is None:
                 return None, (404, "no such source")
             if dest["system"]:
                 return None, (403, "the sample library cannot be written to")
-            src = db.execute("SELECT system, type FROM sources WHERE id = ?",
-                             (from_sid,)).fetchone()
+            src = db.execute("SELECT system, type FROM sources WHERE id = ? AND (workspace = ? OR system = 1)",
+                             (from_sid, ws)).fetchone()
             if src is None:
                 return None, (404, "no such source")
             # A file means what its Source's type says it means, so it only
@@ -1264,7 +1518,7 @@ class Sources:
         """Every file of a Source, as (name, path on disk) in its own order,
         or None when there is no such Source."""
         with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
-            r = db.execute("SELECT system FROM sources WHERE id = ?", (sid,)).fetchone()
+            r = db.execute("SELECT system FROM sources WHERE id = ? AND (workspace = ? OR system = 1)", (sid, workspace_of(self.store))).fetchone()
             if r is None:
                 return None
             if r[0]:
@@ -1281,7 +1535,7 @@ class Sources:
                 or not all(isinstance(n, str) for n in names):
             return None, (400, "the names are needed")
         with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
-            r = db.execute("SELECT system FROM sources WHERE id = ?", (sid,)).fetchone()
+            r = db.execute("SELECT system FROM sources WHERE id = ? AND (workspace = ? OR system = 1)", (sid, workspace_of(self.store))).fetchone()
             if r is None:
                 return None, (404, "no such source")
             if r[0]:
@@ -1347,7 +1601,8 @@ class Sources:
         """
         with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
             db.row_factory = sqlite3.Row
-            r = db.execute("SELECT system, bytes FROM sources WHERE id = ?", (sid,)).fetchone()
+            r = db.execute("SELECT system, bytes FROM sources WHERE id = ? AND (workspace = ? OR system = 1)",
+                           (sid, workspace_of(self.store))).fetchone()
             if r is None:
                 return None, (404, "no such source")
             if r["system"]:
@@ -1379,7 +1634,7 @@ class Sources:
     def file_path(self, sid: str, name: str) -> Path:
         """The on-disk path of a stored file, or None. `name` is already clean."""
         with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
-            r = db.execute("SELECT system FROM sources WHERE id = ?", (sid,)).fetchone()
+            r = db.execute("SELECT system FROM sources WHERE id = ? AND (workspace = ? OR system = 1)", (sid, workspace_of(self.store))).fetchone()
             if r is None:
                 return None
             if r[0]:
@@ -1452,22 +1707,23 @@ class Sources:
 # it is left where it is, and nothing reads it.
 
 DATASET_FIELDS = ("version", "source", "scoring", "grader", "every", "run", "cases")
-# A body's own version: evals-core.ts's DATASET_BODY_VERSION. Version 7 is an
+# A body's own version: evals-core.ts's DATASET_BODY_VERSION. Version 8 reads
+# the recorded-reply metric ids under their new names (#299); version 7 is an
 # eval group (docs/pipeline-model.md §17), version 6 its cases alone; version
 # 5 was told by its `source` alone, and earlier ones by neither.
-DATASET_BODY_VERSION = 7
+DATASET_BODY_VERSION = 8
 DATASET_NAME_MAX = 80
 # The file forms Export writes and Import reads. Export writes an eval group
-# at version 7 (docs/pipeline-model.md §17); Import reads that, and a dataset
-# file of versions 1 to 7, upgraded, and refuses anything else, as a pipeline
+# at version 8 (docs/pipeline-model.md §17); Import reads that, and a dataset
+# file of versions 1 to 8, upgraded, and refuses anything else, as a pipeline
 # of another version is refused. Versions 1 to 3 carried a prompt, which an
 # import gives to the Prompt library.
 EXPORT_ONE = "evals-lab/eval-group"
 EXPORT_ALL = "evals-lab/eval-groups"
 DATASET_ONE = "evals-lab/dataset"
 DATASET_ALL = "evals-lab/datasets"
-EXPORT_VERSION = 7
-IMPORT_VERSIONS = (1, 2, 3, 4, 5, 6, 7)
+EXPORT_VERSION = 8
+IMPORT_VERSIONS = (1, 2, 3, 4, 5, 6, 7, 8)
 # Each file form, and the key its one entry or its list sits under.
 EXPORT_KEYS = {EXPORT_ONE: "group", EXPORT_ALL: "groups", DATASET_ONE: "dataset", DATASET_ALL: "datasets"}
 SCORING_MODES = ("all", "weighted")
@@ -1505,7 +1761,7 @@ def _term_in(items, term) -> bool:
 def case_metrics(c: dict) -> list:
     """A version-4 case's expectations as the metrics that say the same:
     evals-core.ts's caseMetrics, in Python, and held to it by proxy-check.py
-    through fixtures/dataset-v7.json."""
+    through fixtures/dataset-v8.json."""
     def strs(v):
         return [x for x in v if isinstance(x, str)] if isinstance(v, list) else []
     if c.get("discarded") is True:
@@ -1572,7 +1828,7 @@ def case_of_v5(c):
 
 
 def group_of_v6(body: dict) -> dict:
-    """A version-6 body as a version-7 eval group: evals-core.ts's
+    """A version-6 body as a version-8 eval group: evals-core.ts's
     groupOfV6. Scored All, the lab's grader, and no metrics of its own for
     every item or the whole run -- what a Metrics eval naming the dataset with
     none of its own graded."""
@@ -1581,8 +1837,43 @@ def group_of_v6(body: dict) -> dict:
             "grader": None, "every": [], "run": [], **rest}
 
 
+# The recorded-reply metric ids renamed at version 8: evals-core.ts's
+# RECORDED_IDS. Stored tokens inside eval group bodies and a pipeline's private
+# group, so they are mapped wherever a body is read (#299).
+RECORDED_IDS = {
+    "equals-production": "same-as-recorded",
+    "fields-equal-production": "fields-equal-recorded",
+    "same-parse-outcome": "same-parse-as-recorded",
+}
+
+
+def _rename_metric(m):
+    return {**m, "type": RECORDED_IDS[m["type"]]} if isinstance(m, dict) and m.get("type") in RECORDED_IDS else m
+
+
+def _rename_metrics(lst):
+    return [_rename_metric(m) for m in lst] if isinstance(lst, list) else lst
+
+
+def recorded_ids_v7(body):
+    """A version-7 body (or a freshly made version-8 one) with its
+    recorded-reply metric ids read under their version-8 names, at version 8:
+    evals-core.ts's recordedIdsV7."""
+    out = dict(body)
+    out["version"] = DATASET_BODY_VERSION
+    if isinstance(body.get("every"), list):
+        out["every"] = _rename_metrics(body["every"])
+    if isinstance(body.get("run"), list):
+        out["run"] = _rename_metrics(body["run"])
+    if isinstance(body.get("cases"), list):
+        out["cases"] = [{**c, "metrics": _rename_metrics(c["metrics"])}
+                        if isinstance(c, dict) and isinstance(c.get("metrics"), list) else c
+                        for c in body["cases"]]
+    return out
+
+
 def upgrade_body(body):
-    """An earlier body as today's (version 7): evals-core.ts's
+    """An earlier body as today's (version 8): evals-core.ts's
     upgradeDatasetBody, in Python. Version 1's `imageCases` are `cases`, and
     its `replays` and `conformance` go (fixtures/replays.json holds the
     parser's tests). Version 2's `rules` go -- they clean a job's answer, so
@@ -1593,24 +1884,28 @@ def upgrade_body(body):
     needs the rules or the prompt takes them first (`body_rules`,
     `body_prompt`). A body naming its Source is version 5, whose Contains
     metrics each come to say Ignore case (`case_of_v5`). Version 6 gains a
-    group's scoring, grader, Every item and Whole run (`group_of_v6`). A body
-    saying it is version 7 comes back as it was; so does anything that is
-    not a body."""
+    group's scoring, grader, Every item and Whole run (`group_of_v6`); version
+    7 reads its recorded-reply metric ids under their version-8 names
+    (`recorded_ids_v7`). A body saying it is version 8 comes back as it was;
+    so does anything that is not a body."""
     if not isinstance(body, dict) or body.get("version") == DATASET_BODY_VERSION:
         return body
-    # A body saying any other version is one this lab does not read, and is
-    # left for dataset_problem to refuse.
     if "version" in body:
-        return group_of_v6(body) if body["version"] == 6 else body
+        # Version 7 reads its recorded-reply metric ids under their version-8
+        # names; version 6 is its cases alone. Any other version is one this
+        # lab does not read, left for dataset_problem to refuse.
+        if body["version"] == 7:
+            return recorded_ids_v7(body)
+        return recorded_ids_v7(group_of_v6(body)) if body["version"] == 6 else body
     if "source" in body:
         up = dict(body)
         if isinstance(body.get("cases"), list):
             up["cases"] = [case_of_v5(c) for c in body["cases"]]
-        return group_of_v6(up)
+        return recorded_ids_v7(group_of_v6(up))
     cases = body.get("cases") if isinstance(body.get("cases"), list) else body.get("imageCases")
     if not isinstance(cases, list):
         return body
-    return group_of_v6({"source": None, "cases": [case_of_v5(case_of_v4(c)) for c in cases]})
+    return recorded_ids_v7(group_of_v6({"source": None, "cases": [case_of_v5(case_of_v4(c)) for c in cases]}))
 
 
 def body_prompt(body):
@@ -1754,7 +2049,7 @@ def scenario_ref(sc, i):
     what version 4's upgrade gives one, by position."""
     sid = sc.get("id") if isinstance(sc, dict) else None
     name = (sc.get("name") or "").strip() if isinstance(sc, dict) and isinstance(sc.get("name"), str) else ""
-    return (sid if isinstance(sid, str) and sid else f"s{i + 1}"), (name or f"Target {i + 1}")
+    return (sid if isinstance(sid, str) and sid else f"s{i + 1}"), (name or f"Target {chr(65 + i) if i < 26 else i + 1}")
 
 
 class Prompts:
@@ -1782,6 +2077,13 @@ class Prompts:
             cols = {r[1] for r in db.execute("PRAGMA table_info(prompt_uses)")}
             if "chain" in cols and "job" not in cols:
                 db.execute("ALTER TABLE prompt_uses RENAME COLUMN chain TO job")
+            # The workspace a prompt belongs to (docs/workspaces.md): the
+            # Default is per-workspace, so is_default is scoped too. Children
+            # (versions, uses) co-scope through the prompt id. A store from
+            # before workspaces backfills every prompt to the default.
+            if "workspace" not in {r[1] for r in db.execute("PRAGMA table_info(prompts)")}:
+                db.execute("ALTER TABLE prompts ADD COLUMN workspace TEXT")
+            db.execute("UPDATE prompts SET workspace = ? WHERE workspace IS NULL", (store.default_ws,))
             # One-off facts about the library: that the runs from before it
             # have been read into it, so a restart does not read them again
             # and bring back a prompt someone has since deleted.
@@ -1796,9 +2098,9 @@ class Prompts:
         db.row_factory = sqlite3.Row
         return closing(db)
 
-    @staticmethod
-    def _live(db, pid):
-        return db.execute("SELECT * FROM prompts WHERE id = ? AND trash IS NULL", (pid,)).fetchone()
+    def _live(self, db, pid):
+        return db.execute("SELECT * FROM prompts WHERE id = ? AND trash IS NULL AND workspace = ?",
+                          (pid, workspace_of(self.store))).fetchone()
 
     @staticmethod
     def _head(db, pid):
@@ -1837,7 +2139,8 @@ class Prompts:
     def list(self) -> list:
         with self.store.lock, self._connect() as db:
             return [self._summary(db, r) for r in db.execute(
-                "SELECT * FROM prompts WHERE trash IS NULL ORDER BY updated_at DESC, id")]
+                "SELECT * FROM prompts WHERE trash IS NULL AND workspace = ? ORDER BY updated_at DESC, id",
+                (workspace_of(self.store),))]
 
     def get(self, pid):
         with self.store.lock, self._connect() as db:
@@ -1847,7 +2150,8 @@ class Prompts:
     def default(self):
         """The Default's newest version, {id, name, version, text}, or None."""
         with self.store.lock, self._connect() as db:
-            r = db.execute("SELECT * FROM prompts WHERE is_default = 1 AND trash IS NULL").fetchone()
+            r = db.execute("SELECT * FROM prompts WHERE is_default = 1 AND trash IS NULL AND workspace = ?",
+                           (workspace_of(self.store),)).fetchone()
             if r is None:
                 return None
             head = self._head(db, r["id"])
@@ -1859,10 +2163,11 @@ class Prompts:
     def _insert(self, db, name, text, default=False):
         pid = secrets.token_hex(6)
         now = self._now()
+        ws = workspace_of(self.store)
         if default:
-            db.execute("UPDATE prompts SET is_default = 0")
-        db.execute("INSERT INTO prompts (id, name, is_default, created_at, updated_at) VALUES (?, ?, ?, ?, ?)",
-                   (pid, name, 1 if default else 0, now, now))
+            db.execute("UPDATE prompts SET is_default = 0 WHERE workspace = ?", (ws,))
+        db.execute("INSERT INTO prompts (id, name, is_default, created_at, updated_at, workspace) "
+                   "VALUES (?, ?, ?, ?, ?, ?)", (pid, name, 1 if default else 0, now, now, ws))
         db.execute("INSERT INTO prompt_versions (prompt_id, version, text, created_at, edited_at) "
                    "VALUES (?, 1, ?, ?, ?)", (pid, text, now, time.time()))
         return pid
@@ -1877,7 +2182,8 @@ class Prompts:
         return version
 
     def _has_default(self, db):
-        return db.execute("SELECT 1 FROM prompts WHERE is_default = 1 AND trash IS NULL").fetchone() is not None
+        return db.execute("SELECT 1 FROM prompts WHERE is_default = 1 AND trash IS NULL AND workspace = ?",
+                          (workspace_of(self.store),)).fetchone() is not None
 
     def adopt(self, db, text, name="", default=False):
         """A prompt reading [text]: the live one that already does, or a new
@@ -1893,13 +2199,13 @@ class Prompts:
             db.execute("UPDATE prompts SET is_default = 1 WHERE id = ?", (pid,))
         return pid
 
-    @staticmethod
-    def _matching(db, text):
-        """The newest version of any live prompt reading exactly [text]."""
+    def _matching(self, db, text):
+        """The newest version of any live prompt in this workspace reading
+        exactly [text]."""
         return db.execute("SELECT v.prompt_id, v.version FROM prompt_versions v "
-                          "JOIN prompts p ON p.id = v.prompt_id AND p.trash IS NULL "
+                          "JOIN prompts p ON p.id = v.prompt_id AND p.trash IS NULL AND p.workspace = ? "
                           "WHERE v.text = ? ORDER BY v.created_at DESC, v.version DESC LIMIT 1",
-                          (text,)).fetchone()
+                          (workspace_of(self.store), text)).fetchone()
 
     def record(self, db, rid, run, at):
         """A run's uses, one per scenario per job, linked by the rules in
@@ -1997,7 +2303,7 @@ class Prompts:
         with self.store.lock, self._connect() as db, db:
             if self._live(db, pid) is None:
                 return None, (404, "no such prompt")
-            db.execute("UPDATE prompts SET is_default = 0")
+            db.execute("UPDATE prompts SET is_default = 0 WHERE workspace = ?", (workspace_of(self.store),))
             db.execute("UPDATE prompts SET is_default = 1 WHERE id = ?", (pid,))
             return self._detail(db, self._live(db, pid)), None
 
@@ -2029,7 +2335,8 @@ class Prompts:
 
     def restore(self, token):
         with self.store.lock, self._connect() as db, db:
-            r = db.execute("SELECT * FROM prompts WHERE trash = ?", (str(token),)).fetchone()
+            r = db.execute("SELECT * FROM prompts WHERE trash = ? AND workspace = ?",
+                           (str(token), workspace_of(self.store))).fetchone()
             if r is None:
                 return None, (404, "no such trash entry")
             db.execute("UPDATE prompts SET trash = NULL, trashed_at = NULL WHERE id = ?", (r["id"],))
@@ -2081,6 +2388,12 @@ class Datasets:
                        "group_id TEXT NOT NULL, n INTEGER NOT NULL, body TEXT NOT NULL, "
                        "created_at TEXT NOT NULL, edited_at REAL NOT NULL, "
                        "ran INTEGER NOT NULL DEFAULT 0, PRIMARY KEY (group_id, n))")
+            # The workspace a dataset belongs to (docs/workspaces.md); its
+            # group versions and archives co-scope through the dataset id. A
+            # store from before workspaces backfills every row to the default.
+            if "workspace" not in {r[1] for r in db.execute("PRAGMA table_info(datasets)")}:
+                db.execute("ALTER TABLE datasets ADD COLUMN workspace TEXT")
+            db.execute("UPDATE datasets SET workspace = ? WHERE workspace IS NULL", (store.default_ws,))
             # Rows from an earlier version are converted once, in place: a
             # dataset is typed in by hand and costly to re-enter, so it is
             # upgraded rather than hidden (AGENTS.md's one exception). The
@@ -2155,17 +2468,20 @@ class Datasets:
         return closing(db)
 
     def _live(self, db, did):
-        return db.execute("SELECT * FROM datasets WHERE id = ? AND trash IS NULL", (did,)).fetchone()
+        return db.execute("SELECT * FROM datasets WHERE id = ? AND trash IS NULL AND workspace = ?",
+                          (did, workspace_of(self.store))).fetchone()
 
     def _names(self, db, but=None):
-        return {r[0] for r in db.execute("SELECT name FROM datasets WHERE trash IS NULL AND id IS NOT ?",
-                                         (but,))}
+        return {r[0] for r in db.execute(
+            "SELECT name FROM datasets WHERE trash IS NULL AND id IS NOT ? AND workspace = ?",
+            (but, workspace_of(self.store)))}
 
     def list(self) -> list:
         with self.store.lock, self._connect() as db:
             counts = self._counts(db)
             return [self._doc(r, False, counts.get(r["id"], 1)) for r in db.execute(
-                "SELECT * FROM datasets WHERE trash IS NULL ORDER BY name COLLATE NOCASE, id")]
+                "SELECT * FROM datasets WHERE trash IS NULL AND workspace = ? ORDER BY name COLLATE NOCASE, id",
+                (workspace_of(self.store),))]
 
     def get(self, did):
         with self.store.lock, self._connect() as db:
@@ -2195,11 +2511,11 @@ class Datasets:
                    "VALUES (?, 1, ?, ?, ?)", (r["id"], r["body"], r["updated_at"], edited))
         return self._head(db, r["id"])
 
-    @staticmethod
-    def _pins(db) -> set:
+    def _pins(self, db) -> set:
         """Every (group, version) a stored pipeline pins, read in the caller's
-        transaction from the docs table the page writes them to."""
-        row = db.execute("SELECT body FROM docs WHERE name = 'promptlab.workflows'").fetchone()
+        transaction from this workspace's workflows document."""
+        row = db.execute("SELECT body FROM docs WHERE name = 'promptlab.workflows' AND workspace = ?",
+                         (workspace_of(self.store),)).fetchone()
         return pins_in(json.loads(row[0])) if row and row[0] else set()
 
     def _cut(self, db, did, text):
@@ -2313,8 +2629,9 @@ class Datasets:
     def _insert(self, db, name, body):
         did = secrets.token_hex(6)
         now = self._now()
-        db.execute("INSERT INTO datasets (id, name, version, body, created_at, updated_at) "
-                   "VALUES (?, ?, 1, ?, ?, ?)", (did, name, json.dumps(body), now, now))
+        db.execute("INSERT INTO datasets (id, name, version, body, created_at, updated_at, workspace) "
+                   "VALUES (?, ?, 1, ?, ?, ?, ?)",
+                   (did, name, json.dumps(body), now, now, workspace_of(self.store)))
         return did
 
     def create(self, name, body=None):
@@ -2384,7 +2701,8 @@ class Datasets:
         """A trashed dataset back, under a new ` (2)` name if its own has been
         taken since. Returns (DatasetDoc, None)."""
         with self.store.lock, self._connect() as db, db:
-            r = db.execute("SELECT * FROM datasets WHERE trash = ?", (str(token),)).fetchone()
+            r = db.execute("SELECT * FROM datasets WHERE trash = ? AND workspace = ?",
+                           (str(token), workspace_of(self.store))).fetchone()
             if r is None:
                 return None, (404, "no such trash entry")
             name = unique_dataset_name(r["name"], self._names(db, but=r["id"]))
@@ -2420,8 +2738,8 @@ class Datasets:
 
     def export_all(self):
         with self.store.lock, self._connect() as db:
-            rows = db.execute("SELECT * FROM datasets WHERE trash IS NULL "
-                              "ORDER BY name COLLATE NOCASE, id").fetchall()
+            rows = db.execute("SELECT * FROM datasets WHERE trash IS NULL AND workspace = ? "
+                              "ORDER BY name COLLATE NOCASE, id", (workspace_of(self.store),)).fetchall()
         return {"format": EXPORT_ALL, "version": EXPORT_VERSION,
                 "groups": [{"name": r["name"], "body": upgrade_body(json.loads(r["body"]))} for r in rows]}
 
@@ -2679,11 +2997,40 @@ class Packs:
         self.trash = {}
         with store.lock, closing(sqlite3.connect(store.path)) as db, db:
             db.execute("CREATE TABLE IF NOT EXISTS packs ("
-                       "id TEXT PRIMARY KEY, name TEXT NOT NULL, version TEXT NOT NULL, "
-                       "manifest TEXT NOT NULL, presets TEXT NOT NULL, installed_at TEXT NOT NULL)")
+                       "id TEXT NOT NULL, name TEXT NOT NULL, version TEXT NOT NULL, "
+                       "manifest TEXT NOT NULL, presets TEXT NOT NULL, installed_at TEXT NOT NULL, "
+                       "workspace TEXT NOT NULL DEFAULT '', PRIMARY KEY (id, workspace))")
             db.execute("CREATE TABLE IF NOT EXISTS pack_items ("
                        "pack TEXT NOT NULL, kind TEXT NOT NULL, key TEXT NOT NULL, item TEXT NOT NULL, "
-                       "PRIMARY KEY (pack, kind, key))")
+                       "workspace TEXT NOT NULL DEFAULT '', PRIMARY KEY (pack, workspace, kind, key))")
+            # A pack's id is its manifest's, not globally unique, so two
+            # workspaces can hold the same pack: the workspace is part of both
+            # keys (docs/workspaces.md). A store from before workspaces keyed
+            # packs by id alone; it is rebuilt once, every row to the default.
+            if "workspace" not in {r[1] for r in db.execute("PRAGMA table_info(packs)")}:
+                self._rebuild(db, store.default_ws, "packs",
+                              "id, name, version, manifest, presets, installed_at",
+                              "id TEXT NOT NULL, name TEXT NOT NULL, version TEXT NOT NULL, "
+                              "manifest TEXT NOT NULL, presets TEXT NOT NULL, installed_at TEXT NOT NULL, "
+                              "workspace TEXT NOT NULL DEFAULT '', PRIMARY KEY (id, workspace)")
+            if "workspace" not in {r[1] for r in db.execute("PRAGMA table_info(pack_items)")}:
+                self._rebuild(db, store.default_ws, "pack_items", "pack, kind, key, item",
+                              "pack TEXT NOT NULL, kind TEXT NOT NULL, key TEXT NOT NULL, item TEXT NOT NULL, "
+                              "workspace TEXT NOT NULL DEFAULT '', PRIMARY KEY (pack, workspace, kind, key)")
+
+    @staticmethod
+    def _rebuild(db, ws, table, cols, schema):
+        """A table keyed without a workspace, rebuilt with one its old rows
+        take: SQLite cannot add to a PRIMARY KEY, so the rows move through a
+        fresh table (the sources `type`/`config` migration's shape)."""
+        rows = db.execute(f"SELECT {cols} FROM {table}").fetchall()
+        db.execute(f"ALTER TABLE {table} RENAME TO {table}_old")
+        db.execute(f"CREATE TABLE {table} ({schema})")
+        names = cols.split(", ")
+        ph = ", ".join("?" * (len(names) + 1))
+        for r in rows:
+            db.execute(f"INSERT INTO {table} ({cols}, workspace) VALUES ({ph})", (*r, ws))
+        db.execute(f"DROP TABLE {table}_old")
 
     def _connect(self):
         db = sqlite3.connect(self.store.path)
@@ -2693,12 +3040,15 @@ class Packs:
     def _items(self, pid):
         with self.store.lock, self._connect() as db:
             return {(r["kind"], r["key"]): r["item"]
-                    for r in db.execute("SELECT kind, key, item FROM pack_items WHERE pack = ?", (pid,))}
+                    for r in db.execute("SELECT kind, key, item FROM pack_items WHERE pack = ? AND workspace = ?",
+                                        (pid, workspace_of(self.store)))}
 
     def list(self) -> list:
         with self.store.lock, self._connect() as db:
-            packs = db.execute("SELECT * FROM packs ORDER BY name COLLATE NOCASE").fetchall()
-            items = db.execute("SELECT pack, kind, item FROM pack_items").fetchall()
+            ws = workspace_of(self.store)
+            packs = db.execute("SELECT * FROM packs WHERE workspace = ? ORDER BY name COLLATE NOCASE",
+                               (ws,)).fetchall()
+            items = db.execute("SELECT pack, kind, item FROM pack_items WHERE workspace = ?", (ws,)).fetchall()
         workflows = {w.get("id"): w.get("name") for w in self._doc("promptlab.workflows")[1].get("list", [])}
         out = []
         for p in packs:
@@ -2718,7 +3068,8 @@ class Packs:
     def presets(self) -> list:
         """Every installed pack's Setup presets, each marked with its pack."""
         with self.store.lock, self._connect() as db:
-            rows = db.execute("SELECT id, presets FROM packs ORDER BY name COLLATE NOCASE").fetchall()
+            rows = db.execute("SELECT id, presets FROM packs WHERE workspace = ? ORDER BY name COLLATE NOCASE",
+                              (workspace_of(self.store),)).fetchall()
         return [{**p, "pack": r["id"]} for r in rows for p in json.loads(r["presets"])]
 
     # The page's documents are the server's to write here too, through the
@@ -2757,9 +3108,11 @@ class Packs:
         why = pack_requires_problem(m, set(plugins))
         if why:
             return None, (400, why)
+        ws = workspace_of(self.store)
         with self.lock:
             with self.store.lock, self._connect() as db:
-                have = db.execute("SELECT version FROM packs WHERE id = ?", (m["id"],)).fetchone()
+                have = db.execute("SELECT version FROM packs WHERE id = ? AND workspace = ?",
+                                  (m["id"], ws)).fetchone()
             if have and have["version"] == m["packVersion"]:
                 return {"pack": m["id"], "installed": False}, None
             owned = self._items(m["id"])
@@ -2854,22 +3207,23 @@ class Packs:
                 self._write_doc("promptlab.versions", keep)
             now = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
             with self.store.lock, self._connect() as db, db:
-                db.execute("INSERT INTO packs (id, name, version, manifest, presets, installed_at) "
-                           "VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET name = excluded.name, "
-                           "version = excluded.version, manifest = excluded.manifest, "
+                db.execute("INSERT INTO packs (id, name, version, manifest, presets, installed_at, workspace) "
+                           "VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT(id, workspace) DO UPDATE SET "
+                           "name = excluded.name, version = excluded.version, manifest = excluded.manifest, "
                            "presets = excluded.presets, installed_at = excluded.installed_at",
                            (m["id"], m["name"].strip(), m["packVersion"], json.dumps(m),
-                            json.dumps(pack["presets"]), now))
+                            json.dumps(pack["presets"]), now, ws))
                 for (kind, key), item in made.items():
-                    db.execute("INSERT OR REPLACE INTO pack_items (pack, kind, key, item) VALUES (?, ?, ?, ?)",
-                               (m["id"], kind, key, item))
+                    db.execute("INSERT OR REPLACE INTO pack_items (pack, kind, key, item, workspace) "
+                               "VALUES (?, ?, ?, ?, ?)", (m["id"], kind, key, item, ws))
         return {"pack": m["id"], "installed": True}, None
 
     def remove(self, pid):
         """What the pack made, into the trash, at once. Returns (token, None)."""
+        ws = workspace_of(self.store)
         with self.lock:
             with self.store.lock, self._connect() as db:
-                row = db.execute("SELECT * FROM packs WHERE id = ?", (pid,)).fetchone()
+                row = db.execute("SELECT * FROM packs WHERE id = ? AND workspace = ?", (pid, ws)).fetchone()
             if row is None:
                 return None, (404, "no such pack")
             items = self._items(pid)
@@ -2894,8 +3248,8 @@ class Packs:
             if gone:
                 self._write_doc("promptlab.workflows", drop)
             with self.store.lock, self._connect() as db, db:
-                db.execute("DELETE FROM pack_items WHERE pack = ?", (pid,))
-                db.execute("DELETE FROM packs WHERE id = ?", (pid,))
+                db.execute("DELETE FROM pack_items WHERE pack = ? AND workspace = ?", (pid, ws))
+                db.execute("DELETE FROM packs WHERE id = ? AND workspace = ?", (pid, ws))
             token = secrets.token_hex(6)
             self.trash[token] = entry
             return token, None
@@ -2915,13 +3269,14 @@ class Packs:
                 self._write_doc("promptlab.workflows",
                                 lambda body: {**body, "list": [*body.get("list", []), *entry["pipelines"]]})
             r = entry["row"]
+            ws = r.get("workspace", self.store.default_ws)
             with self.store.lock, self._connect() as db, db:
-                db.execute("INSERT OR REPLACE INTO packs (id, name, version, manifest, presets, installed_at) "
-                           "VALUES (?, ?, ?, ?, ?, ?)",
-                           (r["id"], r["name"], r["version"], r["manifest"], r["presets"], r["installed_at"]))
+                db.execute("INSERT OR REPLACE INTO packs (id, name, version, manifest, presets, installed_at, workspace) "
+                           "VALUES (?, ?, ?, ?, ?, ?, ?)",
+                           (r["id"], r["name"], r["version"], r["manifest"], r["presets"], r["installed_at"], ws))
                 for kind, key, item in entry["items"]:
-                    db.execute("INSERT OR REPLACE INTO pack_items (pack, kind, key, item) VALUES (?, ?, ?, ?)",
-                               (r["id"], kind, key, item))
+                    db.execute("INSERT OR REPLACE INTO pack_items (pack, kind, key, item, workspace) "
+                               "VALUES (?, ?, ?, ?, ?)", (r["id"], kind, key, item, ws))
             del self.trash[token]
             return {"pack": r["id"]}, None
 
@@ -2932,7 +3287,8 @@ class Packs:
         removed it and has datasets of its own is left alone. Returns what
         happened, or None where nothing was tried."""
         with self.store.lock, self._connect() as db:
-            have = db.execute("SELECT version FROM packs WHERE id = 'demo'").fetchone()
+            have = db.execute("SELECT version FROM packs WHERE id = 'demo' AND workspace = ?",
+                              (workspace_of(self.store),)).fetchone()
         if have is None and DATASETS.list():
             return None
         got, err = self.install(demo_pack())
@@ -3701,6 +4057,14 @@ class Queue:
             # `dataset` column, read as its one group.
             if "groups" not in cols:
                 db.execute("ALTER TABLE queue ADD COLUMN groups TEXT")
+            # The workspace a run belongs to (docs/workspaces.md): History is
+            # per-workspace, so the list and every id-keyed read filter by it.
+            # The worker loop is the one global reader -- it grades every
+            # workspace's runs by id. A store from before workspaces backfills
+            # to the default.
+            if "workspace" not in cols:
+                db.execute("ALTER TABLE queue ADD COLUMN workspace TEXT")
+            db.execute("UPDATE queue SET workspace = ? WHERE workspace IS NULL", (store.default_ws,))
 
     # ---- rows -----------------------------------------------------------
 
@@ -3710,7 +4074,7 @@ class Queue:
     # the order ALTER TABLE added them in is no order _row can count on.
     SELECT = ("SELECT q.id, q.status, q.cancel, q.submitted_at, q.started_at, "
               "q.finished_at, q.snapshot, q.results, q.progress, q.totals, q.error, "
-              "q.rerun_of, q.verdict, q.verdicts, o.submitted_at FROM queue q "
+              "q.rerun_of, q.verdict, q.verdicts, o.submitted_at, q.workspace FROM queue q "
               "LEFT JOIN queue o ON o.id = q.rerun_of")
 
     @staticmethod
@@ -3726,6 +4090,7 @@ class Queue:
             "rerunOf": r[11], "rerunOfAt": r[14],
             "verdict": r[12],
             "verdicts": json.loads(r[13]) if r[13] else None,
+            "workspace": r[15],
         }
 
     # A row from before run documents has no version, and nothing here can
@@ -3738,14 +4103,20 @@ class Queue:
     def _readable(row):
         return row is not None and (row["snapshot"] or {}).get("version") in READABLE_VERSIONS
 
-    def _all(self, db):
-        return [row for row in (self._row(r) for r in db.execute(self.SELECT))
+    def _all(self, db, ws=None):
+        """Every readable run; a workspace's when `ws` is given, else the lot --
+        the worker and startup's prompt backfill read across every workspace."""
+        sql = self.SELECT + (" WHERE q.workspace = ?" if ws else "")
+        return [row for row in (self._row(r) for r in db.execute(sql, (ws,) if ws else ()))
                 if self._readable(row)]
 
-    def get(self, rid):
+    def get(self, rid, ws=None):
+        """One run by id, or None. `ws` scopes the lookup so a workspace cannot
+        read another's run by id (docs/workspaces.md); the worker reads
+        unscoped, by the globally unique id."""
+        sql = self.SELECT + " WHERE q.id = ?" + (" AND q.workspace = ?" if ws else "")
         with self.lock, closing(sqlite3.connect(self.store.path)) as db:
-            row = self._row(db.execute(self.SELECT + " WHERE q.id = ?",
-                                       (rid,)).fetchone())
+            row = self._row(db.execute(sql, (rid, ws) if ws else (rid,)).fetchone())
         return row if self._readable(row) else None
 
     def list(self, limit=RUNS_PAGE, before=None, before_id=None, full=False):
@@ -3757,7 +4128,7 @@ class Queue:
         second (#238). `before` alone stops at the second. Each row is
         brief_row's unless `full` asks for the whole of it."""
         with self.lock, closing(sqlite3.connect(self.store.path)) as db:
-            rows = self._all(db)
+            rows = self._all(db, workspace_of(self.store))
         key = lambda r: (r["submittedAt"], r["id"])
         rows = [r for r in rows if before is None or key(r) < (before, before_id or "")]
         rows.sort(key=key, reverse=True)
@@ -3788,13 +4159,13 @@ class Queue:
         total = len(run_items(run))
         with self.lock, closing(sqlite3.connect(self.store.path)) as db, db:
             db.execute("INSERT INTO queue (id, status, cancel, submitted_at, "
-                       "snapshot, results, progress, totals, dataset, rerun_of, groups) "
-                       "VALUES (?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?)",
+                       "snapshot, results, progress, totals, dataset, rerun_of, groups, workspace) "
+                       "VALUES (?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
                        (rid, "queued", now, json.dumps(run), "[]",
                         json.dumps({"current": None, "n": 0, "total": total}),
                         json.dumps({"ran": 0, "passed": 0, "found": 0, "of": 0}),
                         None if dataset is None else json.dumps(dataset), rerun_of,
-                        None if groups is None else json.dumps(groups)))
+                        None if groups is None else json.dumps(groups), workspace_of(self.store)))
             # Its prompts' uses, in the same transaction: a run is in the
             # library the moment it is queued, or not queued at all.
             if self.prompts is not None:
@@ -3882,6 +4253,27 @@ class Queue:
         (rundir / "dataset.json").write_text(json.dumps(body))
         return ["--dataset", str(rundir / "dataset.json")], None
 
+    def _grading_args(self, run, rundir):
+        """The worker's eval group bodies: --dataset for a run that grades
+        against one group, which keeps its single-body path and old-row
+        pinning, and --groups for a run that links several (#233) -- every body
+        it kept, by `<id>@<n>`, written beside the run document. Returns
+        (args, None) or (None, why)."""
+        refs = [eval_group_ref(t) for t in run["snapshot"].get("evals", []) or []]
+        keys = {group_key(r) for r in refs if r is not None}
+        if len(keys) <= 1:
+            return self._dataset_args(run, rundir)
+        kept = self.groups(run["id"], raw=True)
+        if kept is None:
+            return None, "the run kept no eval group bodies"
+        missing = sorted({(r.get("name") or r.get("id")) for r in refs
+                          if r is not None and group_key(r) not in kept})
+        if missing:
+            return None, f"the run kept no body of the eval group {', '.join(missing)}"
+        rundir.mkdir(parents=True, exist_ok=True)
+        (rundir / "groups.json").write_text(json.dumps(kept))
+        return ["--groups", str(rundir / "groups.json")], None
+
     def _behind(self, rid):
         """How many submissions stand between this one and the worker, by
         submit time -- what a waiting form names when it says what it is
@@ -3939,12 +4331,15 @@ class Queue:
         return self.get(rid), None
 
     def clear(self):
-        """Empty the queue: every run, in every browser. The materialised
-        item files go too, so a cleared run leaves nothing behind to be
-        re-dequeued by a stray worker."""
+        """Empty this workspace's History: its runs, in every browser. The
+        materialised item files go too, so a cleared run leaves nothing behind
+        to be re-dequeued by a stray worker. Another workspace's runs stay."""
+        ws = workspace_of(self.store)
         with self.lock, closing(sqlite3.connect(self.store.path)) as db, db:
-            n = db.execute("DELETE FROM queue").rowcount
-        for d in self.dir.iterdir():
+            gone = [r[0] for r in db.execute("SELECT id FROM queue WHERE workspace = ?", (ws,))]
+            n = db.execute("DELETE FROM queue WHERE workspace = ?", (ws,)).rowcount
+        for rid in gone:
+            d = self.dir / rid
             if d.is_dir():
                 (d / "cancel").unlink(missing_ok=True)
                 shutil.rmtree(d, ignore_errors=True)
@@ -4020,7 +4415,7 @@ class Queue:
             return None, (403, err)
         if NODE is None:
             return None, (500, "node is not installed, so nothing can run")
-        dataset, err = self._dataset_args(run, rundir)
+        dataset, err = self._grading_args(run, rundir)
         if err:
             return None, (409, err)
         plugins, err = self._plugin_args(run)
@@ -4086,7 +4481,7 @@ class Queue:
             return None, (500, "node is not installed, so nothing can run")
         rundir = self.dir / run["id"]
         rundir.mkdir(parents=True, exist_ok=True)
-        dataset, err = self._dataset_args(run, rundir)
+        dataset, err = self._grading_args(run, rundir)
         if err:
             return None, (409, err)
         plugins, err = self._plugin_args(run)
@@ -4202,7 +4597,7 @@ class Queue:
             return self._finish(rid, "failed", error=err)
         if NODE is None:
             return self._finish(rid, "failed", error="node is not installed, so nothing can run")
-        dataset, err = self._dataset_args(run, rundir)
+        dataset, err = self._grading_args(run, rundir)
         if err:
             return self._finish(rid, "failed", error=err)
         plugins, err = self._plugin_args(run)
@@ -4340,12 +4735,19 @@ class Queue:
             if run is None:
                 self._stop.wait(QUEUE_WAIT)
                 continue
+            # The worker grades every workspace's runs; while it grades this
+            # one, the thread is bound to the run's workspace, so any dataset
+            # or Source it resolves (a legacy row's pinned body) reads from
+            # there, not the default (docs/workspaces.md).
+            set_workspace(run.get("workspace"))
             try:
                 self._execute(run)
             except Exception as e:
                 # The type, never the message -- the relay's rule, for the
                 # relay's reason: an exception message can carry a key.
                 self._finish(run["id"], "failed", error=f"the worker failed: {type(e).__name__}")
+            finally:
+                set_workspace(None)
 
     def _dequeue(self):
         """The oldest queued run this server can read. One it cannot is never
@@ -5034,7 +5436,7 @@ class Handler(BaseHTTPRequestHandler):
             # Runs now execute on the server and nowhere else, so the page
             # says what this one is missing, instead of a request failing
             # oddly mid-run.
-            head += carried("labstate", {"docs": STORE.served(),
+            head += carried("labstate", {"docs": STORE.served(self.ws),
                                          "runs": {"queue": QUEUE is not None, "node": NODE is not None,
                                                   "convert": CONVERT is not None}})
         # The page marks where the carried data goes (web/index.html); the
@@ -5058,9 +5460,39 @@ class Handler(BaseHTTPRequestHandler):
         if self.grouped:
             self.path = "/api/datasets" + self.path[len(self.GROUPS_ROUTE):]
 
+    # The workspace a request is in (docs/workspaces.md), the default when it
+    # names none. Set it to the store's flagged default even with no store, so
+    # the None-store guards below read a harmless value.
+    ws = None
+
+    def _scope(self):
+        """Resolve and bind the request's workspace: the `/w/<slug>` path
+        prefix, else the `X-Workspace` header, else the flagged default. The
+        prefix is stripped from self.path so every route below is addressed the
+        same way inside a workspace or out of it -- `/w/<slug>` becomes `/`,
+        which serves the SPA shell, and `/w/<slug>/api/...` becomes `/api/...`.
+        An unknown slug falls back to the default; the page's Gone state for a
+        vanished workspace is phase 3. The slug is a bookmarkable address, not a
+        secret: isolation here is a filter, not access control."""
+        raw = self.path
+        qpos = raw.find("?")
+        path, query = (raw[:qpos], raw[qpos:]) if qpos >= 0 else (raw, "")
+        slug = None
+        if path == "/w" or path.startswith("/w/"):
+            slug, sep, tail = path[3:].partition("/")
+            self.path = ("/" + tail if sep or tail else "/") + query
+        ws = None
+        if STORE is not None:
+            named = slug or self.headers.get("X-Workspace")
+            ws = STORE.workspace(named) if named else None
+            ws = ws or STORE.default_ws
+        self.ws = ws
+        set_workspace(ws)
+
     def do_GET(self):
         if not self._authorised():
             return
+        self._scope()
         self._alias()
         path = self.path.split("?", 1)[0]
         # The lab is one page: a Connection and an Input make a scenario,
@@ -5096,7 +5528,7 @@ class Handler(BaseHTTPRequestHandler):
         if path == "/api/state":
             if STORE is None:
                 return self._send(404, b"not found", "text/plain")
-            return self._json(200, {"docs": STORE.served()})
+            return self._json(200, {"docs": STORE.served(self.ws)})
         # The run queue (#530): a run is a row the server owns, and History
         # reads the server. One run, or the list.
         if path == "/api/queue":
@@ -5115,7 +5547,7 @@ class Handler(BaseHTTPRequestHandler):
             # The bodies of the eval groups a run grades with, by `<id>@<n>`
             # (§17); null for a run that kept none, as /dataset answers.
             run_id = path.split("/")[3]
-            if QUEUE is None or QUEUE.get(run_id) is None:
+            if QUEUE is None or QUEUE.get(run_id, self.ws) is None:
                 return self._send(404, b"not found", "text/plain")
             return self._json(200, QUEUE.groups(run_id))
         if path.startswith("/api/queue/") and path.endswith("/dataset") and path.count("/") == 4:
@@ -5129,13 +5561,13 @@ class Handler(BaseHTTPRequestHandler):
             # time such a run was opened, which is the console people are
             # told to watch for real faults. A run that is not there is 404.
             run_id = path.split("/")[3]
-            if QUEUE is None or QUEUE.get(run_id) is None:
+            if QUEUE is None or QUEUE.get(run_id, self.ws) is None:
                 return self._send(404, b"not found", "text/plain")
             return self._json(200, QUEUE.dataset(run_id))
         if path.startswith("/api/queue/"):
             if QUEUE is None:
                 return self._send(404, b"not found", "text/plain")
-            run = QUEUE.get(path[len("/api/queue/"):])
+            run = QUEUE.get(path[len("/api/queue/"):], self.ws)
             if run is None:
                 return self._send(404, b"not found", "text/plain")
             # How far back in the queue this submission sits, for the form's
@@ -5279,6 +5711,7 @@ class Handler(BaseHTTPRequestHandler):
     def do_DELETE(self):
         if not self._authorised() or not self._from_this_page():
             return
+        self._scope()
         self._alias()
         path = self.path.split("?", 1)[0]
         if path == "/api/connections/google":
@@ -5347,6 +5780,7 @@ class Handler(BaseHTTPRequestHandler):
     def do_PATCH(self):
         if not self._authorised() or not self._from_this_page():
             return
+        self._scope()
         self._alias()
         parts = self.path.split("?", 1)[0].split("/")
         if len(parts) != 4 or parts[1] != "api":
@@ -5368,6 +5802,8 @@ class Handler(BaseHTTPRequestHandler):
             return self._json(200, source)
         if parts[2] == "queue" and QUEUE is not None:
             payload = self._payload() or {}
+            if QUEUE.get(parts[3], self.ws) is None:
+                return self._send(404, b"not found", "text/plain")
             run, err = QUEUE.set_comment(parts[3], payload.get("comment"))
             if err:
                 code, message = err
@@ -5378,6 +5814,7 @@ class Handler(BaseHTTPRequestHandler):
     def do_PUT(self):
         if not self._authorised() or not self._from_this_page():
             return
+        self._scope()
         self._alias()
         parts = self.path.split("?", 1)[0].split("/")
         if len(parts) == 4 and parts[:3] == ["", "api", "prompts"] and PROMPTS is not None:
@@ -5441,6 +5878,7 @@ class Handler(BaseHTTPRequestHandler):
             return self._json(500, {"error": f"the relay failed: {type(e).__name__}"})
 
     def _post(self):
+        self._scope()
         self._alias()
         path = self.path.split("?", 1)[0]
         if path == "/api/state":
@@ -5623,7 +6061,7 @@ class Handler(BaseHTTPRequestHandler):
             if len(json.dumps(d.get("body"))) > MAX_DOC:
                 return self._json(413, {"error": f"{name} is too large"})
         versions, stale = STORE.write({n: {"version": d["version"], "body": d.get("body")}
-                                       for n, d in docs.items()})
+                                       for n, d in docs.items()}, self.ws)
         if stale is not None:
             return self._json(409, {"stale": stale})
         # A pin names a group's version, so the group keeps that version from
@@ -5687,10 +6125,8 @@ class Handler(BaseHTTPRequestHandler):
                 return self._json(400, {"error": f"the run cannot be queued: {body}"})
             ref["n"], ref["version"] = n, fingerprint(body)
             groups[group_key(ref)] = body
-        # The worker is handed one body until it reads one per group (#233).
-        if len(groups) > 1:
-            return self._json(400, {"error": "the run cannot be queued: its evals grade against "
-                                             "one version of one Library eval group at a time"})
+        # The worker reads a body per group now (#233), so a run may link
+        # several; each body is kept with the row under `<id>@<n>`.
         return self._json(201, {"run": QUEUE.submit(run, groups=groups)})
 
     # ---- Datasets ----------------------------------------------------------
@@ -5865,6 +6301,10 @@ class Handler(BaseHTTPRequestHandler):
         parts = path.split("/")
         rid = parts[3]
         action = parts[4] if len(parts) > 4 else ""
+        # A run is reachable only from its own workspace: an id from another is
+        # a run this workspace does not have (docs/workspaces.md).
+        if QUEUE.get(rid, self.ws) is None:
+            return self._send(404, b"not found", "text/plain")
         if action == "cancel":
             run, err = QUEUE.cancel(rid)
         elif action == "resume":
@@ -5989,9 +6429,10 @@ class Handler(BaseHTTPRequestHandler):
         if len(parts) == 3:
             payload = self._payload() or {}
             kind = payload.get("type", DEFAULT_SOURCE_TYPE)
-            # A type made with a sign-in (a flow, with Microsoft's) cannot be
-            # made in a lab without that sign-in.
-            sign_in = (SOURCE_TYPES.get(kind) or {}).get("signIn")
+            # A platform made with a sign-in (Power Automate, with Microsoft's)
+            # cannot be made in a lab without that sign-in; an unknown kind or
+            # platform is refused by create() below with its own sentence.
+            sign_in = (source_entry(kind, payload.get("config")) or {}).get("signIn")
             if sign_in and not SIGN_INS.get(sign_in, lambda: False)():
                 return self._json(400, {"error": "this lab has no Microsoft app to sign in with (Setup › Connections)"
                                          if sign_in == "microsoft" else f"this lab has no {sign_in} sign-in"})