evals-lab 0.6.0 → 0.8.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,14 @@ 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 lab's own workflow platforms and wizards, kept apart so the mirror can be
+# rebuilt from them as plugins come and go (Plugins.apply), and so a plugin is
+# refused the id of one the lab ships (#303). Wizards are a page concept; the
+# server holds only their ids, to refuse two plugins claiming one.
+BUILTIN_WORKFLOW_PLATFORMS = {k: dict(v) for k, v in WORKFLOW_PLATFORMS.items()}
+BUILTIN_WIZARD_IDS = {"test-workflow"}
 
 # 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 +639,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 +694,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 +731,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 +861,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,13 +900,372 @@ 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
 
+    # ---- shared-by-choice connections (docs/workspaces.md) ------------------
+    # A Target profile or an Account (kind "profile"/"account", id the
+    # profile's or the account's) is usable in a workspace by its share set in
+    # `connection_shares`: a row for that workspace, or the SHARE_ALL sentinel.
+    # No row at all is the migration and new-connection default -- shared with
+    # every workspace, so nothing stops running the moment workspaces exist
+    # (open question 2, resolved All); narrowing a connection is adding the
+    # rows that say where it may be used. SHARE_NEW is never read here: a
+    # workspace created after a SHARE_NEW share was set has it materialised into
+    # a concrete row at creation (Workspaces.create), so "New workspaces" is
+    # exactly the future ones and not the ones that already existed. The server
+    # is the only writer and the only enforcer -- the key a share gates is
+    # never served (#258), so neither the page nor the worker could enforce it.
+
+    def shared(self, kind: str, cid: str, ws) -> bool:
+        with self.lock, closing(sqlite3.connect(self.path)) as db:
+            rows = {r[0] for r in db.execute(
+                "SELECT workspace FROM connection_shares WHERE kind = ? AND id = ?", (kind, cid))}
+        return not rows or SHARE_ALL in rows or ws in rows
+
+    def shares(self) -> dict:
+        """Every connection's share set, for the Connections menus: keyed by
+        "<kind>:<id>", the workspace values as stored (workspace ids and the
+        sentinels). A connection with no row is absent, which the page reads as
+        shared with All. No key is anywhere in this (#258)."""
+        out: dict = {}
+        with self.lock, closing(sqlite3.connect(self.path)) as db:
+            for kind, cid, ws in db.execute("SELECT kind, id, workspace FROM connection_shares"):
+                out.setdefault(f"{kind}:{cid}", []).append(ws)
+        return out
+
+    def set_shares(self, kind: str, cid: str, workspaces) -> None:
+        """Replace a connection's share set. SHARE_ALL means every workspace,
+        so it is kept alone; only the sentinels and live workspace ids are let
+        in, so a stale id cannot linger in the table."""
+        with self.lock, closing(sqlite3.connect(self.path)) as db, db:
+            valid = {r[0] for r in db.execute("SELECT id FROM workspaces WHERE trash IS NULL")}
+            chosen = [w for w in dict.fromkeys(workspaces or [])
+                      if w in (SHARE_ALL, SHARE_NEW) or w in valid]
+            if SHARE_ALL in chosen:
+                chosen = [SHARE_ALL]
+            db.execute("DELETE FROM connection_shares WHERE kind = ? AND id = ?", (kind, cid))
+            db.executemany("INSERT INTO connection_shares (kind, id, workspace) VALUES (?, ?, ?)",
+                           [(kind, cid, w) for w in chosen])
+
+    def share_with(self, kind: str, cid: str, ws, on: bool) -> None:
+        """Add or remove one workspace from a connection's share set -- the Run
+        bar's Share link and its Undo (docs/workspaces.md). The link is offered
+        only where the connection is actually narrowed, so adding a row is what
+        grants the blocked workspace its use and Undo takes it back."""
+        with self.lock, closing(sqlite3.connect(self.path)) as db, db:
+            if on:
+                db.execute("INSERT OR IGNORE INTO connection_shares (kind, id, workspace) "
+                           "VALUES (?, ?, ?)", (kind, cid, ws))
+            else:
+                db.execute("DELETE FROM connection_shares WHERE kind = ? AND id = ? AND workspace = ?",
+                           (kind, cid, ws))
+
+    def workspace_name(self, ws) -> str:
+        """A workspace's name, for the refusal sentence the Run bar shows."""
+        with self.lock, closing(sqlite3.connect(self.path)) as db:
+            row = db.execute("SELECT name FROM workspaces WHERE id = ?", (ws,)).fetchone()
+        return row[0] if row else "this workspace"
+
+    def profile_name(self, pid: str) -> str:
+        """A Target profile's display name, by id, from the global profiles
+        document -- for the refusal sentence. The id itself when none is held."""
+        with self.lock, closing(sqlite3.connect(self.path)) as db:
+            row = db.execute("SELECT body FROM docs WHERE name = 'promptlab.profiles' "
+                             "AND workspace IS NULL").fetchone()
+        try:
+            for p in (json.loads(row[0]) or {}).get("list", []) if row and row[0] else []:
+                if isinstance(p, dict) and str(p.get("id") or "") == pid:
+                    return p.get("name") or pid
+        except (ValueError, TypeError):
+            pass
+        return pid
+
+
+# A workspace's name is one line, capped like a dataset's or a prompt's.
+WORKSPACE_NAME_MAX = 80
+
+
+class Workspaces:
+    """
+    The workspace registry (docs/workspaces.md): the lab-wide list the
+    Setup › Workspaces table manages. Phase 2 is the registry and its UI; the
+    active workspace stays the flagged default (switching is phase 3), so a
+    workspace created here is reached by its address only once that lands.
+
+    Create, rename, archive, unarchive, Regenerate (a new slug from the name),
+    and a server trash like the others: delete puts a workspace into the trash
+    with an undo window, restore brings it back, and a lazy sweep purges it
+    after TRASH_SECONDS -- taking its scoped data with it (its pipelines, runs,
+    datasets, prompts, Sources, packs and documents), since that is what a
+    permanent delete means. The child tables co-scope through their parent id.
+
+    The slug is kept through a rename; only Regenerate changes it. The last
+    active workspace cannot be archived, so a flag-holder always exists;
+    archiving or deleting the flagged default moves the flag to the most
+    recently used other active workspace (docs/workspaces.md, decision 7).
+    """
+
+    def __init__(self, store: Store):
+        self.store = store
+        self.dir = store.path.parent
+
+    def _connect(self):
+        return closing(sqlite3.connect(self.store.path))
+
+    @staticmethod
+    def _slugify(raw) -> str:
+        s = re.sub(r"[^a-z0-9]+", "-", str(raw or "").lower()).strip("-")[:SLUG_MAX].strip("-")
+        return s or "workspace"
+
+    @staticmethod
+    def _unique(base: str, taken: set) -> str:
+        if base not in taken:
+            return base
+        n = 2
+        while True:
+            suffix = f"-{n}"
+            cand = (base[:SLUG_MAX - len(suffix)].strip("-") or "workspace") + suffix
+            if cand not in taken:
+                return cand
+            n += 1
+
+    @staticmethod
+    def _row(r, pipes, runs) -> dict:
+        return {"id": r[0], "slug": r[1], "name": r[2], "archived": bool(r[3]),
+                "isDefault": bool(r[4]), "lastUsed": r[5], "createdAt": r[6],
+                "pipelines": pipes.get(r[0], 0), "runs": runs.get(r[0], 0)}
+
+    def list(self) -> list:
+        """Every workspace not in the trash, with how many pipelines and runs
+        it holds -- the two counts the Manage table shows (docs/other-tabs.md).
+        Active first, then archived, each by name."""
+        with self.store.lock, self._connect() as db:
+            rows = db.execute(
+                "SELECT id, slug, name, archived, is_default, last_used, created_at "
+                "FROM workspaces WHERE trash IS NULL "
+                "ORDER BY archived, name COLLATE NOCASE").fetchall()
+            runs = {w: n for w, n in db.execute(
+                "SELECT workspace, COUNT(*) FROM queue GROUP BY workspace")}
+            pipes = {}
+            for w, body in db.execute(
+                    "SELECT workspace, body FROM docs WHERE name = 'promptlab.workflows'"):
+                try:
+                    pipes[w] = len((json.loads(body) or {}).get("list", [])) if body else 0
+                except (ValueError, TypeError):
+                    pipes[w] = 0
+        return [self._row(r, pipes, runs) for r in rows]
+
+    def get(self, wid: str) -> dict:
+        """One workspace by id, with its counts, or None."""
+        return next((w for w in self.list() if w["id"] == wid), None)
+
+    def create(self, name, slug=None, shares=None) -> tuple:
+        """A new, active workspace; its slug is minted from the name (or a slug
+        asked for), unique across every workspace including the trash, since
+        the column is unique. Returns (id, None) or (None, error). The demo
+        pack is the Handler's to install, since that reaches Packs.
+
+        Shared-by-choice connections (docs/workspaces.md): `shares` is the
+        New-workspace dialog's Connections picker -- a list of {kind, id} the
+        workspace may use, each written as a concrete row. With none given
+        (the plain Add workspace, the CLI), every connection shared with New
+        workspaces (SHARE_NEW) is materialised into a concrete row instead, so
+        "New workspaces" resolves for this one though it was created after the
+        share was set."""
+        name = (name or "").strip()
+        if not name:
+            return None, (400, "a workspace needs a name")
+        if len(name) > WORKSPACE_NAME_MAX:
+            return None, (400, f"a name is at most {WORKSPACE_NAME_MAX} characters")
+        wid = secrets.token_hex(6)
+        now = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+        with self.store.lock, self._connect() as db, db:
+            taken = {r[0] for r in db.execute("SELECT slug FROM workspaces")}
+            s = self._unique(self._slugify(slug or name), taken)
+            db.execute("INSERT INTO workspaces (id, slug, name, archived, is_default, last_used, created_at) "
+                       "VALUES (?, ?, ?, 0, 0, ?, ?)", (wid, s, name, now, now))
+            grant = ([(c.get("kind"), c.get("id")) for c in shares if isinstance(c, dict)]
+                     if isinstance(shares, list)
+                     else list(db.execute("SELECT kind, id FROM connection_shares WHERE workspace = ?",
+                                           (SHARE_NEW,))))
+            db.executemany("INSERT OR IGNORE INTO connection_shares (kind, id, workspace) VALUES (?, ?, ?)",
+                           [(k, i, wid) for k, i in grant if k and i])
+        return wid, None
+
+    def rename(self, wid, name) -> tuple:
+        """A new name; the slug is kept, so an old bookmark still resolves
+        (docs/workspaces.md). Returns (id, None) or (None, error)."""
+        name = (name or "").strip()
+        if not name:
+            return None, (400, "a workspace needs a name")
+        if len(name) > WORKSPACE_NAME_MAX:
+            return None, (400, f"a name is at most {WORKSPACE_NAME_MAX} characters")
+        with self.store.lock, self._connect() as db, db:
+            if db.execute("SELECT 1 FROM workspaces WHERE id = ? AND trash IS NULL", (wid,)).fetchone() is None:
+                return None, (404, "no such workspace")
+            db.execute("UPDATE workspaces SET name = ? WHERE id = ?", (name, wid))
+        return wid, None
+
+    def regenerate(self, wid) -> tuple:
+        """A new slug minted from the current name -- the one write that
+        changes an address (docs/workspaces.md). It does not redirect: that is
+        the warning the dialog carries. Returns (id, None) or (None, error)."""
+        with self.store.lock, self._connect() as db, db:
+            row = db.execute("SELECT name FROM workspaces WHERE id = ? AND trash IS NULL", (wid,)).fetchone()
+            if row is None:
+                return None, (404, "no such workspace")
+            taken = {r[0] for r in db.execute("SELECT slug FROM workspaces WHERE id != ?", (wid,))}
+            db.execute("UPDATE workspaces SET slug = ? WHERE id = ?",
+                       (self._unique(self._slugify(row[0]), taken), wid))
+        return wid, None
+
+    def archive(self, wid) -> tuple:
+        """Into the archive, at once; Undo unarchives it. The last active
+        workspace cannot be archived; archiving the flagged default moves the
+        flag to the most recently used other active workspace, keeping the
+        server's cached default in step. Returns (id, None) or (None, error)."""
+        with self.store.lock, self._connect() as db, db:
+            row = db.execute("SELECT archived, is_default FROM workspaces WHERE id = ? AND trash IS NULL",
+                             (wid,)).fetchone()
+            if row is None:
+                return None, (404, "no such workspace")
+            if row[0]:
+                return wid, None
+            others = db.execute(
+                "SELECT id FROM workspaces WHERE archived = 0 AND trash IS NULL AND id != ? "
+                "ORDER BY last_used DESC, created_at DESC", (wid,)).fetchall()
+            if not others:
+                return None, (409, "the last active workspace cannot be archived")
+            db.execute("UPDATE workspaces SET archived = 1 WHERE id = ?", (wid,))
+            if row[1]:
+                db.execute("UPDATE workspaces SET is_default = 0 WHERE id = ?", (wid,))
+                db.execute("UPDATE workspaces SET is_default = 1 WHERE id = ?", (others[0][0],))
+                self.store.default_ws = others[0][0]
+        return wid, None
+
+    def set_default(self, wid) -> tuple:
+        """Make [wid] the flagged default -- the workspace the CLI and an
+        address with no /w/ prefix resolve to (docs/workspaces.md). Only an
+        active workspace can be the default. Returns (id, None) or
+        (None, error)."""
+        with self.store.lock, self._connect() as db, db:
+            row = db.execute("SELECT archived FROM workspaces WHERE id = ? AND trash IS NULL",
+                             (wid,)).fetchone()
+            if row is None:
+                return None, (404, "no such workspace")
+            if row[0]:
+                return None, (409, "an archived workspace cannot be the default")
+            db.execute("UPDATE workspaces SET is_default = 0 WHERE is_default = 1")
+            db.execute("UPDATE workspaces SET is_default = 1 WHERE id = ?", (wid,))
+            self.store.default_ws = wid
+        return wid, None
+
+    def unarchive(self, wid) -> tuple:
+        with self.store.lock, self._connect() as db, db:
+            if db.execute("SELECT 1 FROM workspaces WHERE id = ? AND trash IS NULL", (wid,)).fetchone() is None:
+                return None, (404, "no such workspace")
+            db.execute("UPDATE workspaces SET archived = 0 WHERE id = ?", (wid,))
+        return wid, None
+
+    def remove(self, wid) -> tuple:
+        """Into the trash, at once; Undo restores it. An active workspace is
+        archived first (the Manage menu offers Delete only on an archived one),
+        so a trashed workspace is never the flagged default. Returns
+        (token, None) or (None, error)."""
+        token = secrets.token_hex(6)
+        with self.store.lock, self._connect() as db, db:
+            row = db.execute("SELECT archived FROM workspaces WHERE id = ? AND trash IS NULL",
+                             (wid,)).fetchone()
+            if row is None:
+                return None, (404, "no such workspace")
+            if not row[0]:
+                return None, (409, "archive a workspace before deleting it")
+            db.execute("UPDATE workspaces SET trash = ?, trashed_at = ? WHERE id = ?",
+                       (token, time.time(), wid))
+        return token, None
+
+    def restore(self, token) -> tuple:
+        """A trashed workspace back, archived as it was. Returns (id, None) or
+        (None, error)."""
+        with self.store.lock, self._connect() as db, db:
+            row = db.execute("SELECT id FROM workspaces WHERE trash = ?", (str(token),)).fetchone()
+            if row is None:
+                return None, (404, "no such trash entry")
+            db.execute("UPDATE workspaces SET trash = NULL, trashed_at = NULL WHERE id = ?", (row[0],))
+        return row[0], None
+
+    def _purge(self, db, ids) -> tuple:
+        """Delete each workspace in `ids` and all its scoped data -- the rows
+        across every scopable table and its documents -- returning the Source
+        and run ids whose on-disk directories the caller then removes. The
+        child tables co-scope through their parent id (docs/workspaces.md)."""
+        sids, rids = [], []
+        for ws in ids:
+            sids += [r[0] for r in db.execute(
+                "SELECT id FROM sources WHERE workspace = ? AND system = 0", (ws,))]
+            rids += [r[0] for r in db.execute("SELECT id FROM queue WHERE workspace = ?", (ws,))]
+            db.execute("DELETE FROM source_files WHERE source IN "
+                       "(SELECT id FROM sources WHERE workspace = ? AND system = 0)", (ws,))
+            db.execute("DELETE FROM source_definitions WHERE source IN "
+                       "(SELECT id FROM sources WHERE workspace = ? AND system = 0)", (ws,))
+            db.execute("DELETE FROM sources WHERE workspace = ? AND system = 0", (ws,))
+            db.execute("DELETE FROM eval_group_versions WHERE group_id IN "
+                       "(SELECT id FROM datasets WHERE workspace = ?)", (ws,))
+            db.execute("DELETE FROM dataset_rules_archive WHERE dataset_id IN "
+                       "(SELECT id FROM datasets WHERE workspace = ?)", (ws,))
+            db.execute("DELETE FROM dataset_body_archive WHERE dataset_id IN "
+                       "(SELECT id FROM datasets WHERE workspace = ?)", (ws,))
+            db.execute("DELETE FROM datasets WHERE workspace = ?", (ws,))
+            db.execute("DELETE FROM prompt_uses WHERE prompt_id IN "
+                       "(SELECT id FROM prompts WHERE workspace = ?)", (ws,))
+            db.execute("DELETE FROM prompt_versions WHERE prompt_id IN "
+                       "(SELECT id FROM prompts WHERE workspace = ?)", (ws,))
+            db.execute("DELETE FROM prompts WHERE workspace = ?", (ws,))
+            db.execute("DELETE FROM pack_items WHERE workspace = ?", (ws,))
+            db.execute("DELETE FROM packs WHERE workspace = ?", (ws,))
+            db.execute("DELETE FROM queue WHERE workspace = ?", (ws,))
+            db.execute("DELETE FROM runs WHERE workspace = ?", (ws,))
+            db.execute("DELETE FROM docs WHERE workspace = ?", (ws,))
+            db.execute("DELETE FROM connection_shares WHERE workspace = ?", (ws,))
+            db.execute("DELETE FROM workspaces WHERE id = ?", (ws,))
+        return sids, rids
+
+    def _rmdirs(self, sids, rids):
+        for sid in sids:
+            shutil.rmtree(self.dir / "sources" / sid, ignore_errors=True)
+        for rid in rids:
+            shutil.rmtree(self.dir / "runs" / rid, ignore_errors=True)
+
+    def lazy_trash(self):
+        """A /api/workspaces request purges what has been trashed longer than
+        TRASH_SECONDS, lazily as the other trashes do."""
+        with self.store.lock, self._connect() as db, db:
+            gone = [r[0] for r in db.execute(
+                "SELECT id FROM workspaces WHERE trash IS NOT NULL AND trashed_at < ?",
+                (time.time() - TRASH_SECONDS,))]
+            sids, rids = self._purge(db, gone)
+        self._rmdirs(sids, rids)
+
+    def empty_trash(self):
+        """The startup sweep: a restart has nothing to undo."""
+        with self.store.lock, self._connect() as db, db:
+            gone = [r[0] for r in db.execute("SELECT id FROM workspaces WHERE trash IS NOT NULL")]
+            sids, rids = self._purge(db, gone)
+        self._rmdirs(sids, rids)
+
 
 # A filename, the target filesystem's view rather than the caller's: a
 # basename is all that survives, restricted to characters that filesystem
@@ -781,6 +1339,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,8 +1395,9 @@ 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, created_at 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,
@@ -821,17 +1408,24 @@ class Sources:
                                          (r["id"],)).fetchone()
                     # When it last changed: made, or a file added -- what a
                     # picker orders its recent Sources by.
-                    out.append({"id": r["id"], "name": r["name"], "system": False,
-                                "type": r["type"], "files": n, "bytes": r["bytes"],
-                                "changed": max(filter(None, (r["created_at"], last)))})
+                    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"]:
@@ -878,14 +1472,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
@@ -896,8 +1494,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()
@@ -923,10 +1521,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
@@ -956,10 +1554,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;
@@ -975,7 +1578,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]:
@@ -988,8 +1591,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]:
@@ -1004,7 +1608,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
@@ -1017,7 +1621,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]:
@@ -1072,19 +1676,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) "
@@ -1100,7 +1707,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]:
@@ -1171,14 +1779,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
@@ -1267,7 +1876,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]:
@@ -1284,7 +1893,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]:
@@ -1350,7 +1959,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"]:
@@ -1382,7 +1992,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]:
@@ -1455,22 +2065,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")
@@ -1508,7 +2119,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:
@@ -1575,7 +2186,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."""
@@ -1584,8 +2195,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
@@ -1596,24 +2242,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):
@@ -1785,6 +2435,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.
@@ -1799,9 +2456,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):
@@ -1840,7 +2497,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:
@@ -1850,7 +2508,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"])
@@ -1862,10 +2521,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
@@ -1880,7 +2540,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
@@ -1896,13 +2557,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
@@ -2000,7 +2661,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
 
@@ -2032,7 +2693,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"],))
@@ -2084,6 +2746,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
@@ -2139,8 +2807,11 @@ class Datasets:
         newest one's number, which a pin may name, and 1 before any is kept,
         the row's body being version 1 in waiting."""
         parsed = upgrade_body(json.loads(r["body"]))
+        # The grader rides in the summary: a run carries the profile each
+        # linked group asks, and the page resolves a run from the list.
         out = {"id": r["id"], "name": r["name"], "cases": len(parsed.get("cases") or []),
-               "version": r["version"], "versions": versions, "updated": r["updated_at"]}
+               "version": r["version"], "versions": versions, "updated": r["updated_at"],
+               "grader": parsed.get("grader")}
         if body:
             out["body"] = parsed
         return out
@@ -2158,17 +2829,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:
@@ -2198,11 +2872,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):
@@ -2316,8 +2990,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):
@@ -2387,7 +3062,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"]))
@@ -2423,8 +3099,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]}
 
@@ -2682,11 +3358,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)
@@ -2696,12 +3401,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:
@@ -2721,7 +3429,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
@@ -2760,9 +3469,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"])
@@ -2857,22 +3568,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)
@@ -2897,8 +3609,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
@@ -2918,13 +3630,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
 
@@ -2935,7 +3648,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())
@@ -2975,7 +3689,7 @@ PLUGIN_VERSIONS = (1,)
 PLUGIN_CAP = int(os.environ.get("PLUGIN_CAP", str(16 * 1024 ** 2)))
 PLUGIN_VERSION_TEXT = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]{0,63}")
 PLUGIN_FILE = re.compile(r"(?:[A-Za-z0-9_-][A-Za-z0-9._-]*/)*[A-Za-z0-9_-][A-Za-z0-9._-]*\.(?:js|mjs|json|map)")
-REGISTRIES = ("outputKinds", "modifiers", "evalTypes", "connectionTypes")
+REGISTRIES = ("outputKinds", "modifiers", "evalTypes", "connectionTypes", "workflowPlatforms", "wizards")
 # evalTypes as a manifest written before pipeline version 11 spells it: a
 # plugin's own file, which the lab cannot upgrade, so it is read for good.
 OLD_REGISTRIES = {"testTypes": "evalTypes"}
@@ -3029,7 +3743,7 @@ def read_plugin(data: bytes):
     reg = m.get("registers") or {}
     if not isinstance(reg, dict) or any(k not in REGISTRIES and k not in OLD_REGISTRIES for k in reg):
         return None, f"a plugin's registers are {', '.join(REGISTRIES)}"
-    for k in ("outputKinds", "modifiers", "evalTypes", *OLD_REGISTRIES):
+    for k in ("outputKinds", "modifiers", "evalTypes", "wizards", *OLD_REGISTRIES):
         if not isinstance(reg.get(k, []), list) or not all(isinstance(x, str) and x for x in reg.get(k, [])):
             return None, f"registers.{k} is a list of ids"
     conns = reg.get("connectionTypes", [])
@@ -3044,6 +3758,25 @@ def read_plugin(data: bytes):
                 or c.get("auth", "bearer") not in AUTH_WAYS):
             return None, ("a connection type the plugin registers is { id, settings, chatPath, "
                           f"auth }}, auth one of {', '.join(AUTH_WAYS)}")
+    # A workflow platform (#303): the generic `workflow` kind drives it, and the
+    # server reads only the data it enforces -- the files it takes, whether it
+    # keeps a definition, and the sign-in it is made with. The sign-in must be
+    # one this lab already has (or none): a platform needing a new server-held
+    # OAuth grant is server code and a secret store a plugin cannot ship, so it
+    # stays lab-only (docs/workflow-sources.md phase 7).
+    platforms = reg.get("workflowPlatforms", [])
+    if not isinstance(platforms, list):
+        return None, "registers.workflowPlatforms is a list"
+    for p in platforms:
+        uploads = p.get("uploads", {}) if isinstance(p, dict) else None
+        if (not isinstance(p, dict) or not isinstance(p.get("id"), str) or not p["id"]
+                or not isinstance(uploads, dict)
+                or not all(isinstance(e, str) and e.startswith(".") and isinstance(t, str)
+                           for e, t in uploads.items())
+                or not isinstance(p.get("keepsDefinition", False), bool)
+                or (p.get("signIn") is not None and p.get("signIn") not in SIGN_INS)):
+            return None, ("a workflow platform the plugin registers is { id, uploads, "
+                          "keepsDefinition, signIn }, signIn null or a sign-in the lab has")
     why = pack_requires_problem({"requires": {"lab": (m.get("requires") or {}).get("lab")}}, set())
     if why:
         return None, why.replace("the pack", "the plugin")
@@ -3053,8 +3786,9 @@ def read_plugin(data: bytes):
 def registered_ids(manifest: dict) -> set:
     """(registry, id) for everything a plugin's manifest says it registers."""
     reg = plugin_registers(manifest)
-    out = {(k, x) for k in ("outputKinds", "modifiers", "evalTypes") for x in reg.get(k, [])}
-    return out | {("connectionTypes", c["id"]) for c in reg.get("connectionTypes", [])}
+    out = {(k, x) for k in ("outputKinds", "modifiers", "evalTypes", "wizards") for x in reg.get(k, [])}
+    out |= {("connectionTypes", c["id"]) for c in reg.get("connectionTypes", [])}
+    return out | {("workflowPlatforms", p["id"]) for p in reg.get("workflowPlatforms", [])}
 
 
 # ---- Connections: the lab's grants to outside services (#127) --------------
@@ -3385,20 +4119,35 @@ class Plugins:
             return [dict(r) for r in db.execute("SELECT * FROM plugins ORDER BY id")]
 
     def apply(self):
-        """The server's connection-type mirror: the built-in types and every
-        installed plugin's, rebuilt in place so every reader sees the same."""
+        """The server's connection-type and workflow-platform mirrors: the
+        built-in entries and every installed plugin's, rebuilt in place so every
+        reader sees the same."""
         types, paths, auth = dict(BUILTIN_CONNECTION_TYPES), dict(BUILTIN_CHAT_PATHS), dict(BUILTIN_AUTH)
         local = set(BUILTIN_LOCAL)
+        platforms = {k: dict(v) for k, v in BUILTIN_WORKFLOW_PLATFORMS.items()}
         for r in self._rows():
-            for c in (json.loads(r["manifest"]).get("registers") or {}).get("connectionTypes", []):
+            reg = json.loads(r["manifest"]).get("registers") or {}
+            for c in reg.get("connectionTypes", []):
                 types[c["id"]] = tuple(c.get("settings", []))
                 paths[c["id"]] = c.get("chatPath", "/chat/completions")
                 auth[c["id"]] = c.get("auth", "bearer")
                 if c.get("local") is True:
                     local.add(c["id"])
+            # A plugin platform's enforcement data, read from the manifest: the
+            # files it takes, checked and redacted by the generic record
+            # redactor like any flow's (take_record), whether it keeps a
+            # definition, and the sign-in (none, or one the lab has) a Source of
+            # it is made with. Its code -- api, stepsOf, evaluate … -- is the
+            # page's and the runner's; this server never runs it.
+            for p in reg.get("workflowPlatforms", []):
+                platforms[p["id"]] = {"label": p.get("label", p["id"]), "take": take_record,
+                                      "uploads": p.get("uploads") or {},
+                                      "definition": bool(p.get("keepsDefinition")),
+                                      "signIn": p.get("signIn")}
         LOCAL_CONNECTIONS.clear()
         LOCAL_CONNECTIONS.update(local)
-        for table, value in ((CONNECTION_TYPES, types), (CONNECTION_CHAT_PATHS, paths), (CONNECTION_AUTH, auth)):
+        for table, value in ((CONNECTION_TYPES, types), (CONNECTION_CHAT_PATHS, paths),
+                             (CONNECTION_AUTH, auth), (WORKFLOW_PLATFORMS, platforms)):
             table.clear()
             table.update(value)
 
@@ -3448,9 +4197,13 @@ class Plugins:
             if same and same["sha256"] == plugin["sha256"]:
                 return {"plugin": m["id"], "installed": False}, None
             mine = registered_ids(m)
+            builtin = {"connectionTypes": (BUILTIN_CONNECTION_TYPES, "connection type"),
+                       "workflowPlatforms": (BUILTIN_WORKFLOW_PLATFORMS, "workflow platform"),
+                       "wizards": (BUILTIN_WIZARD_IDS, "wizard")}
             for (reg, x) in mine:
-                if reg == "connectionTypes" and x in BUILTIN_CONNECTION_TYPES:
-                    return None, (400, f"the plugin registers the connection type {x}, which the lab has already")
+                have, what = builtin.get(reg, (None, None))
+                if have is not None and x in have:
+                    return None, (400, f"the plugin registers the {what} {x}, which the lab has already")
             for r in rows:
                 if r["id"] == m["id"]:
                     continue
@@ -3704,6 +4457,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 -----------------------------------------------------------
 
@@ -3713,7 +4474,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
@@ -3729,6 +4490,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
@@ -3741,14 +4503,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):
@@ -3760,7 +4528,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)
@@ -3791,13 +4559,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:
@@ -3963,12 +4731,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)
@@ -4364,12 +5135,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
@@ -4505,10 +5283,40 @@ def build_bundle(payload):
     return buf.getvalue(), None
 
 
+# Shared-by-choice enforcement (docs/workspaces.md): the one sentence the Run
+# bar turns into a Share link, and the profiles that earn it -- the run's
+# Target profiles not shared with workspace `ws`. A local profile reaches
+# nothing, so sharing does not gate it. Keyed by the run's profiles table,
+# whose keys are the profile ids the share set is written against.
+def not_shared_sentence(names, wsname: str) -> str:
+    verb = "is" if len(names) == 1 else "are"
+    return f"{', '.join(names)} {verb} not shared with {wsname}."
+
+
+def unshared_profiles(run: dict, ws):
+    table = run.get("profiles") if isinstance(run, dict) else None
+    if not isinstance(table, dict) or STORE is None:
+        return []
+    out = []
+    for pid, conn in table.items():
+        if isinstance(conn, dict) and conn.get("type") in LOCAL_CONNECTIONS:
+            continue
+        if not STORE.shared("profile", pid, ws):
+            out.append({"id": pid, "name": (isinstance(conn, dict) and conn.get("name")) or pid})
+    return out
+
+
 def worker_destinations(run: dict):
     table = run.get("profiles") if isinstance(run, dict) else None
     if not isinstance(table, dict):
         return None, "a run document carries its profiles as an object of id → connection"
+    # The run grades in the workspace the thread is bound to -- the request's
+    # at submit, the run's at dequeue/re-run (docs/workspaces.md). A profile
+    # not shared with it is refused here, the seam every run path passes.
+    ws = workspace_of(STORE) if STORE is not None else None
+    bad = unshared_profiles(run, ws)
+    if bad:
+        return None, not_shared_sentence([b["name"] for b in bad], STORE.workspace_name(ws))
     stored = []
     if STORE is not None:
         doc = STORE.all().get("promptlab.profiles") or {}
@@ -4920,6 +5728,7 @@ def run_problems(run):
 # there was a store, and it stays usable without one being asked for.
 if DATA_DIR:
     STORE = Store(Path(DATA_DIR) / "lab.db")
+    WORKSPACES = Workspaces(STORE)
     SOURCES = Sources(STORE)
     PROMPTS = Prompts(STORE)
     DATASETS = Datasets(STORE, PROMPTS)
@@ -4931,7 +5740,7 @@ if DATA_DIR:
     QUEUE = Queue(STORE)
     QUEUE.prompts = PROMPTS
 else:
-    STORE = SOURCES = PROMPTS = DATASETS = PACKS = PLUGINS = CONNECTIONS = MICROSOFT = GOOGLE = QUEUE = None
+    STORE = WORKSPACES = SOURCES = PROMPTS = DATASETS = PACKS = PLUGINS = CONNECTIONS = MICROSOFT = GOOGLE = QUEUE = None
 
 
 class NoRedirects(urllib.request.HTTPRedirectHandler):
@@ -5058,7 +5867,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
@@ -5082,9 +5891,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,
@@ -5120,7 +5959,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":
@@ -5139,7 +5978,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:
@@ -5153,13 +5992,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
@@ -5175,6 +6014,13 @@ class Handler(BaseHTTPRequestHandler):
             if PLUGINS is None:
                 return self._send(404, b"not found", "text/plain")
             return self._json(200, {"plugins": PLUGINS.list(), "cap": PLUGIN_CAP})
+        if path == "/api/connections/shares":
+            # Which workspaces may use each Target profile and Account
+            # (docs/workspaces.md): the share sets the Connections menus read.
+            # Keyed by "<kind>:<id>", workspace ids and the sentinels, no key.
+            if STORE is None:
+                return self._send(404, b"not found", "text/plain")
+            return self._json(200, {"shares": STORE.shares()})
         if path == "/api/connections":
             if CONNECTIONS is None:
                 return self._send(404, b"not found", "text/plain")
@@ -5199,6 +6045,11 @@ class Handler(BaseHTTPRequestHandler):
             if PACKS is None:
                 return self._send(404, b"not found", "text/plain")
             return self._json(200, {"packs": PACKS.list(), "cap": PACK_CAP})
+        if path == "/api/workspaces":
+            if WORKSPACES is None:
+                return self._send(404, b"not found", "text/plain")
+            WORKSPACES.lazy_trash()
+            return self._json(200, {"workspaces": WORKSPACES.list()})
         if path.startswith("/api/samples/thumbs/") or path.startswith("/api/samples/zoom/"):
             # The sample-library tiles, store-independent: baked into the
             # image (or absent on a checkout), and read by the library strip,
@@ -5303,6 +6154,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":
@@ -5326,6 +6178,14 @@ class Handler(BaseHTTPRequestHandler):
             if err:
                 return self._json(err[0], {"error": err[1]})
             return self._json(200, {"trash": token})
+        if path.startswith("/api/workspaces/"):
+            parts = path.split("/")
+            if WORKSPACES is None or len(parts) != 4:
+                return self._send(404, b"not found", "text/plain")
+            token, err = WORKSPACES.remove(parts[3])
+            if err:
+                return self._json(err[0], {"error": err[1]})
+            return self._json(200, {"trash": token})
         if path.startswith("/api/datasets/"):
             parts = path.split("/")
             if DATASETS is None or len(parts) != 4:
@@ -5371,6 +6231,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":
@@ -5392,18 +6253,37 @@ 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
                 return self._json(code, {"error": message})
             return self._json(200, run)
+        if parts[2] == "workspaces" and WORKSPACES is not None:
+            payload = self._payload() or {}
+            wid, err = WORKSPACES.rename(parts[3], payload.get("name"))
+            if err:
+                return self._json(err[0], {"error": err[1]})
+            return self._json(200, {"workspace": WORKSPACES.get(wid), "workspaces": WORKSPACES.list()})
         return self._send(404, b"not found", "text/plain")
 
     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 parts == ["", "api", "connections", "shares"] and STORE is not None:
+            # A connection's whole share set, replaced (docs/workspaces.md): the
+            # Connections checkbox menu's All / list / New workspaces. The reply
+            # is the whole map, so every menu redraws from one response.
+            payload = self._payload() or {}
+            target = self._share_target(payload)
+            if target is None:
+                return self._json(400, {"error": "a share names a kind (profile or account) and an id"})
+            STORE.set_shares(target[0], target[1], payload.get("workspaces") or [])
+            return self._json(200, {"shares": STORE.shares()})
         if len(parts) == 4 and parts[:3] == ["", "api", "prompts"] and PROMPTS is not None:
             return self._prompts_put(parts[3])
         if parts == ["", "api", "google"] and GOOGLE is not None:
@@ -5465,6 +6345,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":
@@ -5477,8 +6358,22 @@ class Handler(BaseHTTPRequestHandler):
             return self._datasets_post(path)
         if path == "/api/packs" or path.startswith("/api/packs/"):
             return self._packs_post(path)
+        if path == "/api/workspaces" or path.startswith("/api/workspaces/"):
+            return self._workspaces_post(path)
         if path == "/api/plugins" or path.startswith("/api/plugins/"):
             return self._plugins_post(path)
+        if path == "/api/connections/share":
+            # The Run bar's Share link, and its Undo (docs/workspaces.md): the
+            # current workspace into (or, undo, out of) a connection's share
+            # set, at once. The reply is the whole map, as the menu's PUT is.
+            if STORE is None:
+                return self._send(404, b"not found", "text/plain")
+            payload = self._payload() or {}
+            target = self._share_target(payload)
+            if target is None:
+                return self._json(400, {"error": "a share names a kind (profile or account) and an id"})
+            STORE.share_with(target[0], target[1], self.ws, payload.get("undo") is not True)
+            return self._json(200, {"shares": STORE.shares()})
         if path == "/api/connections/google/start":
             return self._google_start()
         if path == "/api/prompts" or path.startswith("/api/prompts/"):
@@ -5500,6 +6395,51 @@ class Handler(BaseHTTPRequestHandler):
             return self._models_ask(payload)
         return self._send(404, b"not found", "text/plain")
 
+    def _workspaces_post(self, path):
+        """Create, archive, unarchive, Regenerate, set the default and restore,
+        as the registry API (docs/other-tabs.md). Each mutation answers with the affected
+        workspace and the whole list, so the Manage table and its counts
+        redraw from one response; delete is a DELETE and answers with a trash
+        token for Undo."""
+        if WORKSPACES is None:
+            return self._send(404, b"not found", "text/plain")
+        parts = path.split("/")
+        said = lambda wid: self._json(200, {"workspace": WORKSPACES.get(wid), "workspaces": WORKSPACES.list()})
+        if len(parts) == 3:
+            payload = self._payload() or {}
+            # The New-workspace dialog's Connections picker (docs/workspaces.md):
+            # the connections the new workspace may use, each written a concrete
+            # share row; with none named, the SHARE_NEW set is materialised.
+            shares = payload.get("connections") if isinstance(payload.get("connections"), list) else None
+            wid, err = WORKSPACES.create(payload.get("name"), payload.get("slug"), shares)
+            if err:
+                return self._json(err[0], {"error": err[1]})
+            # Starting content (docs/workspaces.md): the demo pack lands in the
+            # new workspace, not the one the request is in, so bind the thread
+            # to it for the install and bind it back after.
+            if payload.get("content") == "demo" and PACKS is not None:
+                set_workspace(wid)
+                try:
+                    PACKS.install(demo_pack())
+                finally:
+                    set_workspace(self.ws)
+            return said(wid)
+        if len(parts) == 6 and parts[3] == "trash" and parts[5] == "restore":
+            self._payload()
+            wid, err = WORKSPACES.restore(parts[4])
+            if err:
+                return self._json(err[0], {"error": err[1]})
+            return said(wid)
+        if len(parts) == 5 and parts[4] in ("archive", "unarchive", "regenerate", "default"):
+            self._payload()
+            act = {"archive": WORKSPACES.archive, "unarchive": WORKSPACES.unarchive,
+                   "regenerate": WORKSPACES.regenerate, "default": WORKSPACES.set_default}[parts[4]]
+            wid, err = act(parts[3])
+            if err:
+                return self._json(err[0], {"error": err[1]})
+            return said(wid)
+        return self._send(404, b"not found", "text/plain")
+
     def _packs_post(self, path):
         if PACKS is None:
             return self._send(404, b"not found", "text/plain")
@@ -5561,7 +6501,44 @@ class Handler(BaseHTTPRequestHandler):
             return self._json(err[0], {"error": err[1]})
         return self._json(201 if got["installed"] else 200, got)
 
+    def _share_target(self, payload):
+        """(kind, id) when `payload` names a shareable connection (kind profile
+        or account, a non-empty id), else None -- the caller answers 400. The
+        two kinds are the ones that carry a Workspaces field (docs/workspaces.md)."""
+        kind, cid = payload.get("kind"), payload.get("id")
+        return (kind, cid) if kind in ("profile", "account") and isinstance(cid, str) and cid else None
+
+    def _unshared(self, payload):
+        """A saved Target profile a relayed request names by its held key, not
+        shared with this request's workspace (docs/workspaces.md): (id, name),
+        else None. Only a held key (KEY_HELD<id>) names a stored profile; a key
+        typed into the Setup form is a connection not yet saved, so nothing
+        gates it. This is the relay/Test seam, beside worker_destinations' run
+        seam -- the two places a connection resolves to a key, so the two
+        places sharing is enforced. The caller writes the 403: a helper that
+        answers here would send the body and still fall through to the proxy."""
+        if STORE is None:
+            return None
+        raw = str((payload or {}).get("key") or "")
+        if not held(raw):
+            return None
+        pid = raw[len(KEY_HELD):]
+        if STORE.shared("profile", pid, self.ws):
+            return None
+        return pid, STORE.profile_name(pid)
+
+    def _refuse_unshared(self, payload):
+        """The 403 a relay seam answers when `payload` names an unshared
+        profile, else None (nothing written)."""
+        u = self._unshared(payload)
+        if u is None:
+            return False
+        return self._json(403, {"error": not_shared_sentence([u[1]], STORE.workspace_name(self.ws)),
+                                "unshared": [{"kind": "profile", "id": u[0], "name": u[1]}]}) or True
+
     def _models_list(self, payload):
+        if self._refuse_unshared(payload):
+            return
         base = api_base(str(payload.get("url") or "")) or api_base(OLLAMA)
         key = relay_key(payload)
         ctype = str(payload.get("type") or "")
@@ -5613,6 +6590,8 @@ class Handler(BaseHTTPRequestHandler):
         # (evals-core.ts's connectionRequest); the server decides where it goes
         # and how the key travels, per the type -- the same mirror the models
         # list uses, so a client cannot point the relay at a path of its own.
+        if self._refuse_unshared(payload):
+            return
         base = api_base(str(payload.get("url") or "")) or api_base(OLLAMA)
         key = relay_key(payload)
         if not header_safe(key):
@@ -5647,7 +6626,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
@@ -5686,6 +6665,14 @@ class Handler(BaseHTTPRequestHandler):
                 if revs[name] is None:
                     return self._json(400, {"error": f"{name!r} is not in that Source"})
             content["revs"] = revs
+        # A profile not shared with this workspace blocks the run with the
+        # sentence the Run bar shows and the connections it names, so its Share
+        # link can grant them at once (docs/workspaces.md).
+        ws = workspace_of(STORE) if STORE is not None else None
+        bad = unshared_profiles(run, ws)
+        if bad:
+            return self._json(403, {"error": not_shared_sentence([b["name"] for b in bad], STORE.workspace_name(ws)),
+                                    "unshared": [{"kind": "profile", **b} for b in bad]})
         _, why = worker_destinations(run)
         if why:
             return self._json(403, {"error": why})
@@ -5887,6 +6874,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":
@@ -6011,9 +7002,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"})
@@ -6163,6 +7155,9 @@ def main():
         missing.append("no ImageMagick")
     runs = "ready" if not missing else "CANNOT RUN: " + ", ".join(missing)
     print(f"runs:      {runs}", flush=True)
+    if WORKSPACES is not None:
+        # The workspace trash's undo window is per-session, like the others.
+        WORKSPACES.empty_trash()
     if DATASETS is not None:
         # A new lab starts with none: the Datasets tab offers New and Import.
         DATASETS.empty_trash()