create-workframe 0.1.14 → 0.1.15

package/workframe-api/handler_modules/handler_auth.py

@@ -16,6 +16,7 @@ from typing import Any
 import auth_rate_limit
 import google_auth
 import stack_config
+import zk_auth as _zk
 from email_sender import APP_BASE_URL
 
 
@@ -188,6 +189,13 @@ class AuthRoutesMixin:
             self._log_audit("login_denied_private", "user", email, str(deny_meta.get("error") or ""))
             self._json(403, {"ok": False, **deny_meta})
             return
+        import install_api
+
+        install_allowed, install_deny = install_api.install_auth_email_allowed(email)
+        if not install_allowed:
+            self._log_audit("login_denied_install", "user", email, str(install_deny.get("error") or ""))
+            self._json(403, {"ok": False, **install_deny})
+            return
         try:
             base = APP_BASE_URL.strip().lower()
             loopback = base.startswith("http://127.0.0.1") or base.startswith("http://localhost")
@@ -230,6 +238,13 @@ class AuthRoutesMixin:
             self._log_audit("login_denied_private", "user", email, str(deny_meta.get("error") or ""))
             self._json(403, {"ok": False, **deny_meta})
             return
+        import install_api
+
+        install_allowed, install_deny = install_api.install_auth_email_allowed(email)
+        if not install_allowed:
+            self._log_audit("login_denied_install", "user", email, str(install_deny.get("error") or ""))
+            self._json(403, {"ok": False, **install_deny})
+            return
         try:
             result = _zk.verify_email_code(email, code)
         except ValueError as exc:
@@ -246,6 +261,28 @@ class AuthRoutesMixin:
         self._ensure_user(result["user_id"], email, email)
         if srv._install_window_open():
             stack_config.mark_install_admin_verified(email)
+            try:
+                conn = srv._workframe_db()
+                ws = conn.execute(
+                    """
+                    SELECT id FROM workspaces
+                    WHERE slug = 'default' AND deleted_at IS NULL
+                    LIMIT 1
+                    """,
+                ).fetchone()
+                if ws:
+                    ws_id = str(ws["id"])
+                    srv._promote_workspace_owner_if_unclaimed(conn, ws_id, result["user_id"])
+                    conn.execute(
+                        "UPDATE users SET role = 'owner', updated_at = ? WHERE id = ?",
+                        (str(int(time.time())), result["user_id"]),
+                    )
+                    conn.commit()
+                conn.close()
+                if not ws:
+                    self._first_owner_bootstrap(result["user_id"], email, email)
+            except Exception:
+                pass
         self._log_audit("login", "session", result["session_id"],
                         f"user={result['user_id']} new={result['is_new_user']}")
         me_payload = srv._session_profile_payload(result["user_id"])
@@ -384,53 +421,58 @@ class AuthRoutesMixin:
             srv._log_handler_error("GET /api/auth/google/callback", exc)
             self._json(401, {"ok": False, "error": str(exc)})
 
+    def _redirect_provider_connect(self, provider: str, *, ok: bool, message: str = "") -> None:
+        status = "ok" if ok else "error"
+        detail = message or ("connected" if ok else "failed")
+        location = (
+            f"{APP_BASE_URL.rstrip('/')}/?provider_connect={urllib.parse.quote(provider)}"
+            f"&status={status}&message={urllib.parse.quote(detail)}"
+        )
+        self.send_response(302)
+        self.send_header("Location", location)
+        self.end_headers()
+
     def _route_get_oauth_github_callback(self, qs: dict[str, list[str]]) -> None:
         srv = _srv()
         user_id = str(getattr(self, "auth_user", "") or "")
         if not user_id:
-            self._json(401, {"ok": False, "error": "no_session"})
+            self._redirect_provider_connect("github", ok=False, message="no_session")
             return
         code = qs.get("code", [""])[0]
         state = qs.get("state", [""])[0]
         result = srv._complete_github_oauth(user_id, str(code or ""), str(state or ""))
-        status = "ok" if result.get("ok") else "error"
-        message = urllib.parse.quote(str(result.get("error") or "connected"))
-        location = f"{APP_BASE_URL.rstrip('/')}/?provider_connect=github&status={status}&message={message}"
-        self.send_response(302)
-        self.send_header("Location", location)
-        self.end_headers()
+        if result.get("ok"):
+            self._redirect_provider_connect("github", ok=True)
+            return
+        self._redirect_provider_connect("github", ok=False, message=str(result.get("error") or "failed"))
 
     def _route_get_oauth_discord_callback(self, qs: dict[str, list[str]]) -> None:
         srv = _srv()
         user_id = str(getattr(self, "auth_user", "") or "")
         if not user_id:
-            self._json(401, {"ok": False, "error": "no_session"})
+            self._redirect_provider_connect("discord", ok=False, message="no_session")
             return
         code = qs.get("code", [""])[0]
         state = qs.get("state", [""])[0]
         result = srv._complete_discord_oauth(user_id, str(code or ""), str(state or ""))
-        status = "ok" if result.get("ok") else "error"
-        message = urllib.parse.quote(str(result.get("error") or "connected"))
-        location = f"{APP_BASE_URL.rstrip('/')}/?provider_connect=discord&status={status}&message={message}"
-        self.send_response(302)
-        self.send_header("Location", location)
-        self.end_headers()
+        if result.get("ok"):
+            self._redirect_provider_connect("discord", ok=True)
+            return
+        self._redirect_provider_connect("discord", ok=False, message=str(result.get("error") or "failed"))
 
     def _route_get_oauth_stripe_callback(self, qs: dict[str, list[str]]) -> None:
         srv = _srv()
         user_id = str(getattr(self, "auth_user", "") or "")
         if not user_id:
-            self._json(401, {"ok": False, "error": "no_session"})
+            self._redirect_provider_connect("stripe", ok=False, message="no_session")
             return
         code = qs.get("code", [""])[0]
         state = qs.get("state", [""])[0]
         result = srv._complete_stripe_oauth(user_id, str(code or ""), str(state or ""))
-        status = "ok" if result.get("ok") else "error"
-        message = urllib.parse.quote(str(result.get("error") or "connected"))
-        location = f"{APP_BASE_URL.rstrip('/')}/?provider_connect=stripe&status={status}&message={message}"
-        self.send_response(302)
-        self.send_header("Location", location)
-        self.end_headers()
+        if result.get("ok"):
+            self._redirect_provider_connect("stripe", ok=True)
+            return
+        self._redirect_provider_connect("stripe", ok=False, message=str(result.get("error") or "failed"))
 
     def _route_get_me(self, qs: dict[str, list[str]]) -> None:
         srv = _srv()
@@ -475,6 +517,9 @@ class AuthRoutesMixin:
         if not user_id:
             self._json(401, {"ok": False, "error": "no_session"})
             return
+        if not srv._role_allows(self, srv.OWNER_ADMIN_ROLES):
+            self._json(403, {"ok": False, "error": "native_agent_identity_owner_only"})
+            return
         native_slug = str(srv.NATIVE_PROFILE or "workframe-agent")
         runtime = srv._runtime_profile_slug(user_id, native_slug)
         soul = (

package/workframe-api/handler_modules/handler_chat.py

@@ -223,6 +223,17 @@ class ChatRoutesMixin:
             self._json(400, {"error": "model required"})
             return
         billing_provider = str(body.get("billing_provider", "")).strip()
+        # A member may tune the model used by their proxy, but cannot mutate
+        # the shared agent template.  The template remains the default model
+        # owned by the agent; this maps ordinary member writes to u-* runtime.
+        if profile and not selection_only and not srv._is_runtime_profile_slug(profile):
+            if not srv._role_allows(self, srv.OWNER_ADMIN_ROLES):
+                if not workspace_id:
+                    workspaces = srv._get_user_workspaces(user_id)
+                    current = srv._resolve_current_workspace(user_id, workspaces)
+                    workspace_id = str((current or {}).get("id") or (workspaces[0] or {}).get("id") or "")
+                profile = srv._runtime_profile_slug(user_id, profile)
+                srv.ensure_runtime_profile(profile, srv._runtime_template_slug(profile), user_id, workspace_id)
         self._json(
             200,
             hermes_model_set(
@@ -256,6 +267,14 @@ class ChatRoutesMixin:
         chain = body.get("chain", [])
         selection_only = bool(body.get("selection_only"))
         user_id = str(getattr(self, "auth_user", "") or "")
+        if profile and not selection_only and not srv._is_runtime_profile_slug(profile):
+            if not srv._role_allows(self, srv.OWNER_ADMIN_ROLES):
+                if not workspace_id:
+                    workspaces = srv._get_user_workspaces(user_id)
+                    current = srv._resolve_current_workspace(user_id, workspaces)
+                    workspace_id = str((current or {}).get("id") or (workspaces[0] or {}).get("id") or "")
+                profile = srv._runtime_profile_slug(user_id, profile)
+                srv.ensure_runtime_profile(profile, srv._runtime_template_slug(profile), user_id, workspace_id)
         if not isinstance(chain, list):
             self._json(400, {"error": "chain must be a list"})
             return
@@ -417,6 +436,9 @@ class ChatRoutesMixin:
             self._json(400, {"error": "name required"})
             return
         model = str(body.get("model") or "").strip()
+        if not model:
+            self._json(400, {"error": "model_required"})
+            return
         description = str(body.get("description") or "").strip()
         clone_from = str(body.get("clone_from") or "").strip()
         soul = str(body.get("soul") or "").strip()
@@ -524,6 +546,9 @@ class ChatRoutesMixin:
             return
         template = resolve_validated_profile(profile_bootstrap_post.group(1))
         user_id = str(getattr(self, "auth_user", "") or "").strip()
+        if srv._is_native_profile(template) and not srv._role_allows(self, srv.OWNER_ADMIN_ROLES):
+            self._json(403, {"ok": False, "error": "native_agent_identity_owner_only"})
+            return
         workspace_id = str(body.get("workspace_id") or "").strip()
         if not workspace_id and user_id:
             workspaces = srv._get_user_workspaces(user_id)

package/workframe-api/handler_modules/handler_install.py

@@ -3,11 +3,13 @@
 from __future__ import annotations
 
 import base64
+import sqlite3
 from typing import Any
 
 import install_api
 import site_meta
 import stack_config
+import zk_auth as _zk
 from supervisor_client import _maybe_sync_compose_public_url, _supervisor_ready, _supervisor_request
 
 
@@ -58,6 +60,49 @@ class InstallRoutesMixin:
         url = (qs.get("url") or [""])[0] or stack_config.get_stack_config().get("app_base_url") or ""
         self._json(200, install_api.publish_hints_payload(str(url)))
 
+    def _route_post_install_register_admin(self, body: dict) -> None:
+        srv = _srv()
+        if not srv._install_window_open():
+            self._json(403, {"ok": False, "error": "install_closed"})
+            return
+        if stack_config.install_admin_verified():
+            self._json(409, {"ok": False, "error": "already_verified"})
+            return
+        email = str(body.get("email") or "").strip().lower()
+        if not email or "@" not in email:
+            self._json(400, {"ok": False, "error": "email_required"})
+            return
+        display = str(body.get("display_name") or "").strip() or email.split("@", 1)[0]
+        stack_config.patch_stack_config({"smtp": {"admin_email": email}, "wizard_step": "welcome"})
+        allowed, deny_meta = install_api.install_auth_email_allowed(email)
+        if not allowed:
+            self._json(403, {"ok": False, **deny_meta})
+            return
+        try:
+            result = _zk.create_session_for_email(email)
+        except (RuntimeError, OSError, sqlite3.Error) as exc:
+            srv._log_handler_error("POST /api/install/register-admin", exc)
+            self._json(500, {"ok": False, "error": str(exc)})
+            return
+        user_id = str(result["user_id"])
+        self.auth_user = user_id
+        self._ensure_user(user_id, display, email)
+        self._first_owner_bootstrap(user_id, display, email)
+        use_secure = srv._session_cookie_secure()
+        cookie_val = _zk.session_cookie_value(result["session_id"], secure=use_secure)
+        me_payload = srv._session_profile_payload(user_id)
+        self._json(
+            200,
+            {
+                "ok": True,
+                "user_id": user_id,
+                "session_id": result["session_id"],
+                "refresh_token": result["refresh_token"],
+                **(me_payload or {}),
+            },
+            extra_headers=[("Set-Cookie", cookie_val)],
+        )
+
     def _route_post_install_email_test(self, body: dict) -> None:
         srv = _srv()
         if not srv._install_window_open():

package/workframe-api/handler_modules/handler_provider.py

@@ -190,6 +190,7 @@ class ProviderRoutesMixin:
         except sqlite3.Error as exc:
             self._json(500, {"ok": False, "error": f"db_error: {exc}"})
             return
+        srv._invalidate_user_llm_picker_cache(user_id)
         self._log_audit("credential_stored", "credential_binding", cred_id, f"provider={provider}")
         health: dict[str, Any] = {}
         if provider == "openrouter":

package/workframe-api/handler_modules/handler_workspace.py

@@ -13,6 +13,7 @@ import urllib.parse
 import uuid
 
 import activity_feed
+import api_errors
 import chat_bind
 from email_sender import APP_BASE_URL, send_branded_invite_email
 
@@ -402,14 +403,13 @@ class WorkspaceRoutesMixin:
             return
         try:
             self._json(200, srv.room_chat_bind(rid, body, user_id))
-        except ValueError as exc:
-            err = str(exc)
-            if "not_found" in err:
-                self._json(404, {"ok": False, "error": err})
-            elif "denied" in err or "forbidden" in err:
-                self._json(403, {"ok": False, "error": err})
-            else:
-                self._json(400, {"ok": False, "error": err})
+        except (ValueError, OSError) as exc:
+            payload = api_errors.public_api_error_payload(exc, context="room_bind")
+            status = api_errors.http_status_for_code(str(payload.get("error") or ""))
+            self._json(status, {"ok": False, **payload})
+        except Exception as exc:  # noqa: BLE001 — urllib.URLError etc.
+            payload = api_errors.public_api_error_payload(exc, context="room_bind")
+            self._json(500, {"ok": False, **payload})
 
     def _route_pattern_post_room_sessions_activate(self, path: str, body: dict) -> None:
         srv = _srv()
@@ -437,13 +437,9 @@ class WorkspaceRoutesMixin:
                 binding_version=binding_version,
             )
         except ValueError as exc:
-            err = str(exc)
-            if "not_found" in err:
-                self._json(404, {"ok": False, "error": err})
-            elif "denied" in err:
-                self._json(403, {"ok": False, "error": err})
-            else:
-                self._json(400, {"ok": False, "error": err})
+            payload = api_errors.public_api_error_payload(exc, context="room_session_activate")
+            status = api_errors.http_status_for_code(str(payload.get("error") or ""))
+            self._json(status, {"ok": False, **payload})
             return
         self._json(200, payload)
 
@@ -1024,6 +1020,13 @@ class WorkspaceRoutesMixin:
                 conn.close()
                 self._json(404, {"ok": False, "error": "invite_not_found_or_expired"})
                 return
+            invite_email = str(inv["email"] or "").strip().lower()
+            user_row = conn.execute("SELECT email FROM users WHERE id = ?", (user_id,)).fetchone()
+            user_email = str(user_row["email"] or "").strip().lower() if user_row else ""
+            if not user_email or user_email != invite_email:
+                conn.close()
+                self._json(403, {"ok": False, "error": "invite_email_mismatch"})
+                return
             if int(inv["expires_at"]) < int(time.time()):
                 conn.close()
                 self._json(410, {"ok": False, "error": "invite_expired"})
@@ -1048,6 +1051,15 @@ class WorkspaceRoutesMixin:
                              (user_id, now_ts, now_ts, inv["id"]))
                 conn.commit()
                 conn.close()
+                # Re-acceptance is also a repair path.  Do not leave an existing
+                # member without the per-user Hermes proxy runtimes.
+                try:
+                    if not srv._provision_invited_member_agent_runtimes(wid, user_id):
+                        self._json(500, {"ok": False, "error": "runtime_provision_failed"})
+                        return
+                except Exception as exc:  # noqa: BLE001
+                    self._json(500, {"ok": False, "error": f"runtime_provision_failed: {exc}"})
+                    return
                 srv._set_user_current_workspace(user_id, wid)
                 self._json(200, {"ok": True, "already_member": True, "workspace_id": wid, "room": room_join, "dm_room": dm_room})
                 return
@@ -1069,7 +1081,9 @@ class WorkspaceRoutesMixin:
         except sqlite3.Error as exc:
             self._json(500, {"error": f"db_error: {exc}"})
             return
-        srv._provision_invited_member_agent_runtimes(wid, user_id)
+        if not srv._provision_invited_member_agent_runtimes(wid, user_id):
+            self._json(500, {"ok": False, "error": "runtime_provision_failed"})
+            return
         srv._set_user_current_workspace(user_id, wid)
         self._log_audit("invite_accepted", "workspace_invite", inv["id"], f"workspace={wid} user={user_id}")
         self._json(

package/workframe-api/hermes_admin.py

@@ -232,7 +232,7 @@ def _resolve_command(token: str) -> dict[str, Any] | None:
         return None
     needle = token if token.startswith("/") else f"/{token}"
     for entry in HERMES_COMMANDS:
-        if entry.get("wip", False):
+        if entry.get("wip", False) or entry.get("dispatch") in {"gateway", "client:noOp"}:
             continue
         if entry["name"] == needle or needle in entry.get("aliases", []):
             return entry
@@ -653,7 +653,14 @@ def hermes_commands_catalog() -> dict[str, Any]:
     they aren't returned here. The UI never sees a half-implemented
     command; either it's wired end-to-end or it's invisible.
     """
-    visible = [e for e in HERMES_COMMANDS if not e.get("wip", False)]
+    # One-shot gateway execution is not equivalent to Hermes' interactive TUI
+    # command loop. Only expose commands with a native Workframe handler; add a
+    # gateway command after an end-to-end test proves its behavior here.
+    visible = [
+        entry for entry in HERMES_COMMANDS
+        if not entry.get("wip", False)
+        and entry.get("dispatch") not in {"gateway", "client:noOp"}
+    ]
     grouped: dict[str, list[dict[str, Any]]] = {}
     for entry in visible:
         grouped.setdefault(entry["category"], []).append(

package/workframe-api/hermes_profiles.py

@@ -53,19 +53,31 @@ def _hermes_data_uid_gid() -> tuple[int, int]:
     try:
         st = _srv().HERMES_DATA.stat()
         return int(st.st_uid), int(st.st_gid)
-    except OSError:
+    except (AttributeError, OSError):
         return 10000, 10000
 
 
+def _ensure_profiles_dir_ready() -> None:
+    """Gateway creates runtime profiles — parent dir must be writable by hermes uid."""
+    profiles = _srv().HERMES_DATA / "profiles"
+    profiles.mkdir(parents=True, exist_ok=True)
+    uid, gid = _hermes_data_uid_gid()
+    try:
+        os.chown(profiles, uid, gid)
+    except (AttributeError, OSError):
+        pass
+
+
 def _chown_profile_tree(prof_dir: Path) -> None:
     """Gateway runs as the Agents volume owner — seeded files must match."""
+    _ensure_profiles_dir_ready()
     uid, gid = _hermes_data_uid_gid()
     prof_dir.mkdir(parents=True, exist_ok=True)
     (prof_dir / "logs").mkdir(parents=True, exist_ok=True)
     for path in [prof_dir, *prof_dir.rglob("*")]:
         try:
             os.chown(path, uid, gid)
-        except OSError:
+        except (AttributeError, OSError):
             pass
 
 
@@ -461,9 +473,13 @@ def _profile_identity_overlay(profile: str) -> str:
     prof = _srv().safe_profile_slug(profile)
     if _srv()._is_runtime_profile_slug(prof):
         template = _runtime_template_slug(prof)
-        reg = {**_srv()._agent_registry_row(template), **_srv()._agent_registry_row(prof)}
+        # Keep runtime-local instructions separate from shared display
+        # identity.  Name/role/tagline/avatar must come from the template.
+        reg = _srv()._agent_registry_row(template)
+        runtime_reg = _srv()._agent_registry_row(prof)
     else:
         reg = _srv()._agent_registry_row(prof)
+        runtime_reg = {}
     blocks: list[str] = []
     identity_lines: list[str] = []
     display = str(reg.get("display_name") or "").strip()
@@ -477,7 +493,7 @@ def _profile_identity_overlay(profile: str) -> str:
         identity_lines.append(f"- **Tagline:** {tagline}")
     if identity_lines:
         blocks.append("## User identity\n" + "\n".join(identity_lines))
-    user_soul = str(reg.get("user_soul") or "").strip()
+    user_soul = str(runtime_reg.get("user_soul") or reg.get("user_soul") or "").strip()
     if user_soul:
         blocks.append("## Additional instructions\n" + user_soul)
     return "\n\n".join(blocks).strip()
@@ -735,6 +751,9 @@ def _agent_db_display_name(template_slug: str, workspace_id: str = "") -> str:
             ).fetchone()
         if row and str(row["display_name"] or "").strip():
             return str(row["display_name"]).strip()
+    except sqlite3.Error:
+        # Native profile seeding can precede schema creation on a clean install.
+        return ""
     finally:
         conn.close()
     return ""
@@ -1105,6 +1124,7 @@ def profile_create(
                 results["steps"].extend(lane.get("steps") or [])
             except Exception as exc:
                 results["steps"].append({"step": "bootstrap_dm_lane", "ok": False, "error": str(exc)})
+                results["ok"] = False
         return results
     
     prof = _srv().safe_profile_slug(name)
@@ -1242,7 +1262,7 @@ def profile_create(
         except Exception as exc:
             results["steps"].append({"step": "bootstrap_dm_lane", "ok": False, "error": str(exc)})
 
-    results["ok"] = True
+    results["ok"] = not any(step.get("ok") is False for step in results["steps"])
     return results
 
 

package/workframe-api/install_api.py

@@ -66,6 +66,31 @@ def install_window_open(db_path: str) -> bool:
     return not bool(stack_config.get_stack_config().get("install_complete"))
 
 
+def install_auth_email_allowed(email: str) -> tuple[bool, dict[str, Any]]:
+    """During install, only the configured admin email may register until verified."""
+    normalized = str(email or "").strip().lower()
+    if not normalized or "@" not in normalized:
+        return False, {"error": "email required"}
+    if not install_window_open(""):
+        return True, {}
+    smtp = stack_config.get_stack_config().get("smtp") or {}
+    configured = str(smtp.get("admin_email") or "").strip().lower()
+    verified_admin = str(smtp.get("admin_email") or "").strip().lower() if stack_config.install_admin_verified() else ""
+    if verified_admin:
+        if normalized == verified_admin:
+            return True, {}
+        return False, {
+            "error": "install_admin_email_required",
+            "message": "Sign in with the admin email for this install.",
+        }
+    if configured and normalized != configured:
+        return False, {
+            "error": "install_admin_email_required",
+            "message": "Use the admin email entered at the start of setup.",
+        }
+    return True, {}
+
+
 def install_owner_claimed(db_path: str) -> bool:
     """True once the first install admin has verified and owns the default workspace."""
     try:
@@ -119,12 +144,19 @@ def _wizard_step_index(step: str) -> int:
 
 def _derive_install_wizard_step(db_path: str) -> str:
     cfg = stack_config.get_stack_config()
+    smtp = cfg.get("smtp") if isinstance(cfg.get("smtp"), dict) else {}
+    if not str(smtp.get("admin_email") or "").strip():
+        return "intro"
+    if not install_owner_claimed(db_path):
+        return "intro"
     mode = str(cfg.get("deployment_mode") or "").strip()
     if not mode:
         return "welcome"
     if mode == "public_multi_user" and not str(cfg.get("app_base_url") or "").strip():
         return "publish"
-    if mode != "single_user_local" and not stack_config.install_admin_verified() and not install_owner_claimed(db_path):
+    if mode != "single_user_local" and not stack_config.install_admin_verified():
+        if stack_config.smtp_setup_complete():
+            return "admin_auth"
         return "smtp"
 
     settings = _default_workspace_settings(db_path)
@@ -142,16 +174,18 @@ def resolve_install_wizard_step(db_path: str) -> str:
     raw = stack_config.read_stack_raw()
     saved = str(raw.get("wizard_step") or "").strip()
     if saved in INSTALL_WIZARD_STEPS:
-        if _wizard_step_index(derived) > _wizard_step_index(saved):
+        derived_idx = _wizard_step_index(derived)
+        saved_idx = _wizard_step_index(saved)
+        # Never resume ahead of incomplete gates (e.g. saved smtp before deployment).
+        if derived_idx >= 0 and saved_idx >= 0 and saved_idx != derived_idx:
             return derived
         return saved
     return derived
 
 
 def install_wizard_public_payload(db_path: str) -> dict[str, Any]:
-    admin_verified = stack_config.install_admin_verified() or install_owner_claimed(db_path)
     return {
-        "admin_verified": admin_verified,
+        "admin_verified": stack_config.install_admin_verified(),
         "resume_step": resolve_install_wizard_step(db_path),
         "owner_claimed": install_owner_claimed(db_path),
     }

package/workframe-api/lane_bindings.py

@@ -76,6 +76,21 @@ def _binding_session_for(profile: str, source_id: str, client_id: str, binding_v
     row = _binding_row_for(profile, source_id, client_id, binding_version)
     return str((row or {}).get("session_id") or "").strip()
 
+
+def _ensure_profile_api_for_session_create(
+    profile: str,
+    user_id: str,
+    workspace_id: str,
+) -> dict[str, Any]:
+    """WF-034: bind skips provider bootstrap; POST /api/sessions still needs a live gateway."""
+    return _srv().ensure_profile_api(
+        profile,
+        user_id,
+        workspace_id,
+        bootstrap_providers=False,
+    )
+
+
 def profile_chat_session(profile: str, payload: dict[str, Any], user_id: str = "") -> dict[str, Any]:
     source_id = str(payload.get("source_id") or "ui").strip() or "ui"
     client_id = str(payload.get("client_id") or "default").strip() or "default"
@@ -167,6 +182,13 @@ def profile_chat_session(profile: str, payload: dict[str, Any], user_id: str = "
                 sid = str(existing_row["session_id"]).strip()
                 if not sid:
                     existing_row = None
+            if existing_row and _srv()._is_space_room(str(room["room_type"]), room["agent_profile_id"]):
+                # Legacy room mentions could have created one session per
+                # user's private runtime. Shared rooms must converge on the
+                # template/native Hermes profile before reusing a row.
+                gateway_sid = str(existing_row["gateway_session_id"] or "").strip()
+                if not gateway_sid.startswith(f"api:{hermes_prof}:"):
+                    existing_row = None
             if existing_row:
                 sid = str(existing_row["session_id"]).strip()
                 gateway_sid = str(existing_row["gateway_session_id"] or f"api:{hermes_prof}:{sid}").strip()
@@ -211,6 +233,7 @@ def profile_chat_session(profile: str, payload: dict[str, Any], user_id: str = "
                 }
             new_id = f"wf_room_{room_id[:8]}_{int(time.time())}_{uuid.uuid4().hex[:6]}"
             requested_title = str(payload.get("title") or "").strip() or _srv()._default_session_title(template_prof)
+            lifecycle = _ensure_profile_api_for_session_create(hermes_prof, payer, workspace_id)
             status, data, session_title = _srv()._create_profile_session_via_api(hermes_prof, new_id, requested_title)
             if status >= 300:
                 raise ValueError(f"create session failed: {data}")
@@ -265,6 +288,7 @@ def profile_chat_session(profile: str, payload: dict[str, Any], user_id: str = "
         }
     new_id = f"wf_{source_id}_{client_id}_{int(time.time())}_{uuid.uuid4().hex[:6]}"
     requested_title = str(payload.get("title") or "").strip() or _srv()._default_session_title(template_prof)
+    lifecycle = _ensure_profile_api_for_session_create(hermes_prof, payer, workspace_id)
     status, data, session_title = _srv()._create_profile_session_via_api(hermes_prof, new_id, requested_title)
     if status >= 300:
         raise ValueError(f"create session failed: {data}")