evals-lab 0.7.0 → 0.8.0

package/lab/server.py

@@ -513,6 +513,13 @@ def take_record(name, data):
 
 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.
 SIGN_INS = {"microsoft": lambda: microsoft_config() is not None}
@@ -908,6 +915,357 @@ class Store:
                         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
@@ -2449,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
@@ -3328,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"}
@@ -3382,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", [])
@@ -3397,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")
@@ -3406,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) --------------
@@ -3738,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)
 
@@ -3801,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
@@ -4883,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 {}
@@ -5298,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)
@@ -5309,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):
@@ -5583,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")
@@ -5607,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,
@@ -5735,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:
@@ -5809,6 +6260,12 @@ class Handler(BaseHTTPRequestHandler):
                 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):
@@ -5817,6 +6274,16 @@ class Handler(BaseHTTPRequestHandler):
         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:
@@ -5891,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/"):
@@ -5914,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")
@@ -5975,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 "")
@@ -6027,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):
@@ -6100,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})
@@ -6582,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()