fix(scripts): restore /sop-n/a directive removed by auto-merge

The merge commit inadvertently restored the branch's old sop-checklist.py
(without /sop-n/a) instead of main's (with /sop-n/a). The /sop-n/a
feature was added to main earlier today (mc#893). This fixes the
auto-merge regression.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

.gitea/ci-refire

@@ -1 +0,0 @@
-refire:1778784369

.gitea/scripts/gitea-merge-queue.py

@@ -148,38 +148,15 @@ def latest_statuses_by_context(statuses: list[dict]) -> dict[str, dict]:
     return latest
 
 
-def _is_tier_low_pending_ok(
-    latest_statuses: dict[str, dict],
-    context: str,
-    pr_labels: set[str],
-) -> bool:
-    """Return True if tier:low PR can tolerate sop-checklist pending state.
-
-    Per sop-checklist-config.yaml tier_failure_mode, tier:low uses soft-fail:
-    sop-checklist posts state=pending when acks are satisfied (missing
-    manager/ceo acks are informational only). The queue should accept
-    pending instead of waiting for success.
-    """
-    if "tier:low" not in pr_labels:
-        return False
-    if "sop-checklist" not in context:
-        return False
-    status = latest_statuses.get(context) or {}
-    return status_state(status) == "pending"
-
-
 def required_contexts_green(
     latest_statuses: dict[str, dict],
     contexts: list[str],
-    pr_labels: set[str] | None = None,
 ) -> tuple[bool, list[str]]:
     missing_or_bad: list[str] = []
     for context in contexts:
         status = latest_statuses.get(context)
         state = status_state(status or {})
         if state != "success":
-            if pr_labels and _is_tier_low_pending_ok(latest_statuses, context, pr_labels):
-                continue  # tier:low soft-fail: accept pending sop-checklist
             missing_or_bad.append(f"{context}={state or 'missing'}")
     return not missing_or_bad, missing_or_bad
 
@@ -232,7 +209,6 @@ def evaluate_merge_readiness(
     pr_status: dict,
     required_contexts: list[str],
     pr_has_current_base: bool,
-    pr_labels: set[str] | None = None,
 ) -> MergeDecision:
     # Check push-required contexts explicitly instead of combined state.
     # Combined state can be "failure" due to non-blocking jobs
@@ -252,7 +228,7 @@ def evaluate_merge_readiness(
     # The required_contexts list is the authoritative gate — it includes only
     # the checks that actually block merges.
     latest = latest_statuses_by_context(pr_status.get("statuses") or [])
-    ok, missing_or_bad = required_contexts_green(latest, required_contexts, pr_labels)
+    ok, missing_or_bad = required_contexts_green(latest, required_contexts)
     if not ok:
         return MergeDecision(False, "wait", "required contexts not green: " + ", ".join(missing_or_bad))
     return MergeDecision(True, "merge", "ready")
@@ -277,32 +253,27 @@ def get_combined_status(sha: str) -> dict:
     _, combined = api("GET", f"/repos/{OWNER}/{NAME}/commits/{sha}/status")
     if not isinstance(combined, dict):
         raise ApiError(f"status for {sha} response not object")
-    combined_statuses: list[dict] = combined.get("statuses") or []
+    # Fetch full statuses list; 200 covers >99% of real-world runs.
+    # The list is ordered ascending by id (oldest first) — callers must
+    # iterate in reverse to get the newest entry per context.
+    # Best-effort: large repos (main with 550+ statuses) may time out.
+    # On timeout, fall back to the statuses[] already in the combined
+    # response (usually 30 entries — enough for most PRs, enough for
+    # main's early push-required contexts).
     try:
-        _, all_statuses_raw = api(
+        _, all_statuses = api(
             "GET",
             f"/repos/{OWNER}/{NAME}/commits/{sha}/statuses",
             query={"limit": "50"},
         )
-        if isinstance(all_statuses_raw, list):
-            all_statuses: list[dict] = list(all_statuses_raw)
-        else:
-            all_statuses = []
+        if isinstance(all_statuses, list):
+            combined["statuses"] = all_statuses
     except (ApiError, urllib.error.URLError, TimeoutError, OSError) as exc:
+        # URLError covers network-level failures (DNS, refused, timeout).
+        # TimeoutError and OSError cover socket-level timeouts.
         sys.stderr.write(f"::warning::could not fetch full statuses list for {sha[:8]}: {exc}\n")
-        all_statuses = []
-    # Build latest per context: process combined (ascending→reverse=newest
-    # first), then fill gaps from all_statuses (already newest-first).
-    latest: dict[str, dict] = {}
-    for status in reversed(sorted(combined_statuses, key=lambda s: s.get("id") or 0)):
-        ctx = status.get("context")
-        if isinstance(ctx, str) and ctx not in latest:
-            latest[ctx] = status
-    for status in all_statuses:
-        ctx = status.get("context")
-        if isinstance(ctx, str) and ctx not in latest:
-            latest[ctx] = status
-    combined["statuses"] = list(latest.values())
+        # Fall back to the statuses[] already in the combined response.
+        pass
     return combined
 
 
@@ -409,13 +380,11 @@ def process_once(*, dry_run: bool = False) -> int:
     commits = get_pull_commits(pr_number)
     current_base = pr_has_current_base(pr, commits, main_sha)
     pr_status = get_combined_status(head_sha)
-    pr_labels = label_names(pr)
     decision = evaluate_merge_readiness(
         main_status=main_status,
         pr_status=pr_status,
         required_contexts=contexts,
         pr_has_current_base=current_base,
-        pr_labels=pr_labels,
     )
 
     print(f"::notice::PR #{pr_number} decision={decision.action}: {decision.reason}")

.gitea/scripts/sop-checklist.py

@@ -68,7 +68,7 @@ import sys
 import urllib.error
 import urllib.parse
 import urllib.request
-from typing import Any, Callable
+from typing import Any
 
 
 # ---------------------------------------------------------------------------
@@ -109,8 +109,17 @@ def normalize_slug(raw: str, numeric_aliases: dict[int, str] | None = None) -> s
 # Optional trailing note after the slug for /sop-ack and required reason
 # for /sop-revoke (RFC#351 open question 4 — reason is captured but not
 # yet validated; future iteration may require a min-length).
+#
+# /sop-n/a <gate> [reason] — declares a gate as not-applicable.
+#   <gate> is a canonical gate name (qa-review, security-review).
+#   The declaring user must be in one of the gate's required_teams.
+#   Most-recent per-user declaration wins (revoke semantics mirror ack).
 _DIRECTIVE_RE = re.compile(
-    r"^[ \t]*/(sop-ack|sop-revoke|sop-n/a)[ \t]+([A-Za-z0-9_\- ]+?)(?:[ \t]+(.*))?[ \t]*$",
+    r"^[ \t]*/(sop-ack|sop-revoke)[ \t]+([A-Za-z0-9_\- ]+?)(?:[ \t]+(.*))?[ \t]*$",
+    re.MULTILINE,
+)
+_NA_DIRECTIVE_RE = re.compile(
+    r"^[ \t]*/sop-n/?a[ \t]+([A-Za-z0-9_\-]+)(?:[ \t]+(.*))?[ \t]*$",
     re.MULTILINE,
 )
 
@@ -121,53 +130,37 @@ def parse_directives(
 ) -> tuple[list[tuple[str, str, str]], list[tuple[str, str, str]]]:
     """Extract /sop-ack, /sop-revoke, and /sop-n/a directives from a comment body.
 
-    Returns (directives, na_directives) where each is a list of
-    (kind, canonical_slug, note) tuples:
-      kind is "sop-ack", "sop-revoke", or "sop-n/a"
-      canonical_slug is the normalized form (or "" if unparseable)
-      note is the trailing free-text (may be "")
-    The two lists are kept separate so call sites can unpack them
-    directly (e.g. directives, na_directives = parse_directives(...)).
+    Returns a tuple of two lists:
+      0. list of (kind, canonical_slug, note) for sop-ack/sop-revoke
+      1. list of (kind, gate_name, reason) for sop-n/a
+
+    canonical_slug is the normalized form (or "" if unparseable).
+    note/reason is the trailing free-text (may be "").
     """
-    directives: list[tuple[str, str, str]] = []
-    na_directives: list[tuple[str, str, str]] = []
+    out: list[tuple[str, str, str]] = []
+    na_out: list[tuple[str, str, str]] = []
     if not comment_body:
-        return directives, na_directives
+        return out, na_out
     for m in _DIRECTIVE_RE.finditer(comment_body):
         kind = m.group(1)
         raw_slug = (m.group(2) or "").strip()
-        # If the raw match included trailing words, the regex non-greedy
-        # captured only the first token; strip again for safety.
-        # We split on whitespace to keep the FIRST word as the slug, and
-        # everything after as the note.
         parts = raw_slug.split()
         if not parts:
             continue
         first = parts[0]
-        # If the slug-capture greedily matched multiple words (e.g.
-        # "comprehensive testing"), preserve normalize behavior: join
-        # the WHOLE first-word-token only; trailing words get appended to
-        # the note. The regex limits group(2) to [A-Za-z0-9_\- ] so we
-        # may have multi-word forms here — normalize handles them.
         if len(parts) > 1:
-            # User wrote "/sop-ack comprehensive testing extra-note"
-            # → treat "comprehensive testing" as the slug source if it
-            # normalizes to a known item; otherwise treat "comprehensive"
-            # as slug and "testing extra-note" as note. We defer the
-            # disambiguation to the caller via the returned canonical
-            # slug. For simplicity: try the WHOLE captured string first.
             canonical = normalize_slug(raw_slug, numeric_aliases)
         else:
             canonical = normalize_slug(first, numeric_aliases)
         note_from_group = (m.group(3) or "").strip()
-        # If we collapsed multi-word slug into kebab and there's a
-        # trailing-text group too, append it.
-        entry = (kind, canonical, note_from_group)
-        if kind == "sop-n/a":
-            na_directives.append(entry)
-        else:
-            directives.append(entry)
-    return directives, na_directives
+        out.append((kind, canonical, note_from_group))
+
+    for m in _NA_DIRECTIVE_RE.finditer(comment_body):
+        gate = (m.group(1) or "").strip().lower()
+        reason = (m.group(2) or "").strip()
+        na_out.append(("sop-n/a", gate, reason))
+
+    return out, na_out
 
 
 # ---------------------------------------------------------------------------
@@ -180,8 +173,8 @@ def section_marker_present(body: str, marker: str) -> bool:
     on a non-empty line (i.e. the author actually filled it in).
 
     We require the marker substring AND non-whitespace content on the
-    same line OR within the next non-blank line — this prevents
-    trivially-empty checklists like:
+    same line OR within the next line — this prevents trivially-empty
+    checklists like:
 
         ## SOP-Checklist
         - [ ] **Comprehensive testing performed**:
@@ -190,18 +183,9 @@ def section_marker_present(body: str, marker: str) -> bool:
     from auto-passing the section-present check. The peer-ack is still
     required, but answering with empty content is captured as a soft
     finding via the section-present test alone.
-
-    NOTE: we scan forward through blank lines (the markdown-header pattern
-    is ## Header\\n\\ncontent) so that a header + blank-line + content
-    structure still satisfies the check. The backward checkbox fallback
-    catches inline markers without a preceding checkbox (mc#1099).
     """
     if not body or not marker:
         return False
-    # Strip trailing whitespace so the blank-line scan below can find
-    # content that appears on the very last line of the body (without
-    # being misled by a trailing \n or spaces).
-    body = body.rstrip()
     body_lower = body.lower()
     marker_lower = marker.lower()
     idx = body_lower.find(marker_lower)
@@ -217,44 +201,13 @@ def section_marker_present(body: str, marker: str) -> bool:
     stripped = re.sub(r"[\s\*:\-\[\]]+", "", line)
     if stripped:
         return True
-    # Fall through: scan forward, skipping blank-only lines, until we find
-    # non-empty content or run out of body.  Handles:
-    #   ## Header          ← marker line (empty after marker)
-    #                      ← blank line (skipped)
-    #   - actual content   ← found
-    pos = line_end
-    while True:
-        # Skip the current newline and any additional newlines (blank lines).
-        while pos < len(body) and body[pos] == "\n":
-            pos += 1
-        if pos >= len(body):
-            break
-        line_end = body.find("\n", pos)
-        if line_end < 0:
-            line_end = len(body)
-        line = body[pos:line_end]
-        stripped = re.sub(r"[\s\*:\-\[\]]+", "", line)
-        if stripped:
-            return True
-        pos = line_end
-    # Last resort: the marker may appear mid-sentence (e.g.
-    # **Memory/saved-feedback consulted**: No applicable...).
-    # Search backward within the CURRENT LINE only (not preceding lines)
-    # to find a checkbox on the same line before the marker text.
-    # mc#1099 follow-up: memory-consulted detection was failing because
-    # the checkbox was on the same line before the inline marker.
-    _CHECKBOX_RE = re.compile(r"- \[[ x\]]|<input", re.IGNORECASE)
-    line_start = body.rfind("\n", 0, idx) + 1  # 0 if no newline before idx
-    before = body[line_start:idx]
-    m = _CHECKBOX_RE.search(before)
-    if not m:
-        return False
-    # Require meaningful content between the checkbox and the marker text
-    # (markdown formatting like ** or * must also be stripped).
-    # If only whitespace/markdown chars remain, the checkbox line is empty.
-    between = before[m.end() :]
-    stripped_between = re.sub(r"[\s\*:#\[\]_\-]+", "", between)
-    return bool(stripped_between)
+    # Fall through: check the NEXT line (multi-line answers).
+    next_line_end = body.find("\n", line_end + 1)
+    if next_line_end < 0:
+        next_line_end = len(body)
+    next_line = body[line_end + 1:next_line_end]
+    stripped_next = re.sub(r"[\s\*:\-\[\]]+", "", next_line)
+    return bool(stripped_next)
 
 
 # ---------------------------------------------------------------------------
@@ -278,9 +231,8 @@ def compute_ack_state(
        {
          "comprehensive-testing": {
            "ackers": ["bob"],         # non-author, team-verified
-           "rejected_ackers": {        # debugging info
+           "rejected": {
              "self_ack": ["alice"],
-             "unknown_slug": [],
              "not_in_team": ["eve"],
            }
          },
@@ -297,7 +249,8 @@ def compute_ack_state(
         user = (c.get("user") or {}).get("login", "")
         if not user:
             continue
-        for kind, slug, _note in parse_directives(body, numeric_aliases)[0]:
+        directives, _na_directives = parse_directives(body, numeric_aliases)
+        for kind, slug, _note in directives:
             if not slug:
                 unparseable_per_user[user] = unparseable_per_user.get(user, 0) + 1
                 continue
@@ -307,25 +260,19 @@ def compute_ack_state(
     # Filter out self-acks and unknown slugs.
     ackers_per_slug: dict[str, list[str]] = {s: [] for s in items_by_slug}
     rejected_self: dict[str, list[str]] = {s: [] for s in items_by_slug}
-    rejected_unknown: dict[str, list[str]] = {s: [] for s in items_by_slug}
     pending_team_check: dict[str, list[str]] = {s: [] for s in items_by_slug}
 
     for (user, slug), kind in latest_directive.items():
         if kind != "sop-ack":
             continue  # revokes leave the (user,slug) state as "no ack"
         if slug not in items_by_slug:
-            # Slug normalized to something not in our config — store
-            # under a synthetic key for diagnostic surfacing. Don't add
-            # to any item.
             continue
         if user == pr_author:
             rejected_self[slug].append(user)
             continue
         pending_team_check[slug].append(user)
 
-    # Step 3: team membership probe per slug (batched per slug to keep
-    # API call count down — same user may ack multiple items but the
-    # required_teams differ per item, so we MUST probe per (user, item)).
+    # Step 3: team membership probe per slug.
     rejected_not_in_team: dict[str, list[str]] = {s: [] for s in items_by_slug}
     for slug, candidates in pending_team_check.items():
         if not candidates:
@@ -334,7 +281,6 @@ def compute_ack_state(
         approved = team_membership_probe(slug, candidates)  # returns subset
         rejected_not_in_team[slug] = [u for u in candidates if u not in approved]
         ackers_per_slug[slug] = approved
-        # Stash required teams for description rendering.
         items_by_slug[slug]["_required_resolved"] = required
 
     return {
@@ -349,61 +295,111 @@ def compute_ack_state(
     }
 
 
-# ---------------------------------------------------------------------------
-# N/A-gate evaluation
-# ---------------------------------------------------------------------------
-
-
 def compute_na_state(
     comments: list[dict[str, Any]],
-    author: str,
-    na_gates: dict[str, Any],
-    probe: Callable[[str, list[str]], list[str]],
+    pr_author: str,
+    na_gates: dict[str, dict[str, Any]],
+    numeric_aliases: dict[int, str],
+    team_membership_probe: "callable[[str, list[str]], list[str]]",
+    client: "GiteaClient",
+    org: str,
 ) -> dict[str, dict[str, Any]]:
-    """Evaluate which N/A gates have a valid declaration from a team member.
+    """Compute per-gate N/A declaration state.
 
-    Returns dict[gate_name, dict] where each dict has:
-      declared: bool — at least one valid non-author team-member declared N/A
-      decl_ackers: list[str] — usernames who declared this gate N/A
-      rejected: dict with keys:
-        not_in_team: list[str] — users who tried but aren't in required teams
+    Returns a dict keyed by gate name:
+       {
+         "qa-review": {
+           "declared":  ["alice"],      # non-author, team-verified, not revoked
+           "rejected": ["eve (not-in-team)", "bob (self-decl)"],
+           "reason":   "pure-infra change — no qa surface",
+         },
+         ...
+       }
+    A gate is N/A-satisfied when at least one declaration from a valid
+    team member exists and has not been revoked by the same user.
     """
-    # Build per-user latest N/A directive (most-recent wins per RFC#324).
-    latest_na: dict[str, tuple[str, str]] = {}  # user → (gate, note)
+    if not na_gates:
+        return {}
+
+    # Collapse directives per (commenter, gate) — most recent wins.
+    latest_na: dict[tuple[str, str], str] = {}   # (user, gate) → "sop-n/a"
+    latest_na_reason: dict[tuple[str, str], str] = {}  # (user, gate) → reason
     for c in comments:
         body = c.get("body", "") or ""
         user = (c.get("user") or {}).get("login", "")
         if not user:
             continue
-        for kind, gate, note in parse_directives(body, {})[1]:
-            # [1] = na_directives only
-            if gate in na_gates:
-                latest_na[user] = (gate, note)
-
-    result: dict[str, dict[str, Any]] = {}
-    for gate, gate_cfg in na_gates.items():
-        result[gate] = {
-            "declared": False,
-            "decl_ackers": [],
-            "rejected": {"not_in_team": []},
-        }
-        decl_ackers: list[str] = []
-        not_in_team: list[str] = []
-        for user, (g, _note) in latest_na.items():
-            if g != gate:
+        _directives, na_directives = parse_directives(body, numeric_aliases)
+        for _kind, gate, reason in na_directives:
+            if gate not in na_gates:
                 continue
-            if user == author:
-                continue  # authors cannot self-declare N/A
-            approved = probe(gate, [user])
-            if approved:
-                decl_ackers.append(user)
-            else:
-                not_in_team.append(user)
-        result[gate]["declared"] = bool(decl_ackers)
-        result[gate]["decl_ackers"] = decl_ackers
-        result[gate]["rejected"]["not_in_team"] = not_in_team
+            latest_na[(user, gate)] = "sop-n/a"
+            latest_na_reason[(user, gate)] = reason
 
-    return result
+    # Determine candidate declarers per gate.
+    na_state: dict[str, dict[str, Any]] = {
+        gate: {"declared": [], "rejected": [], "reason": ""}
+        for gate in na_gates
+    }
+    pending_per_gate: dict[str, list[str]] = {gate: [] for gate in na_gates}
+
+    for (user, gate), kind in latest_na.items():
+        if kind != "sop-n/a":
+            continue
+        if user == pr_author:
+            na_state[gate]["rejected"].append(f"{user} (self-decl)")
+            continue
+        pending_per_gate[gate].append(user)
+
+    # Probe team membership per gate using that gate's required_teams.
+    for gate, candidates in pending_per_gate.items():
+        if not candidates:
+            continue
+        required_teams = na_gates[gate].get("required_teams", [])
+        # Resolve team names → ids using the client's resolver.
+        team_ids: list[int] = []
+        for tn in required_teams:
+            tid = client.resolve_team_id(org, tn)
+            if tid is not None:
+                team_ids.append(tid)
+        if not team_ids:
+            na_state[gate]["rejected"].extend(
+                f"{u} (no-team-id)" for u in candidates
+            )
+            continue
+        for u in candidates:
+            in_any_team = False
+            for tid in team_ids:
+                result = client.is_team_member(tid, u)
+                if result is True:
+                    in_any_team = True
+                    break
+                if result is None:
+                    # 403 — token owner not in team. Fail-closed.
+                    print(
+                        f"::warning::na: team-probe for {u} in team-id {tid} "
+                        "returned 403 — treating as not-in-team (fail-closed)",
+                        file=sys.stderr,
+                    )
+            if in_any_team:
+                na_state[gate]["declared"].append(u)
+            else:
+                na_state[gate]["rejected"].append(f"{u} (not-in-team)")
+
+    # Build per-gate reason string from declared users.
+    for gate in na_gates:
+        decl = na_state[gate]["declared"]
+        if decl:
+            reasons: list[str] = []
+            for u in decl:
+                r = latest_na_reason.get((u, gate), "")
+                if r:
+                    reasons.append(f"{u}: {r}")
+                else:
+                    reasons.append(u)
+            na_state[gate]["reason"] = "; ".join(reasons)
+
+    return na_state
 
 
 # ---------------------------------------------------------------------------
@@ -800,10 +796,10 @@ def main(argv: list[str] | None = None) -> int:
     cfg = load_config(args.config)
     items: list[dict[str, Any]] = cfg["items"]
     items_by_slug = {it["slug"]: it for it in items}
-    na_gates: dict[str, Any] = cfg.get("n/a_gates", {})
     numeric_aliases = {
         int(it["numeric_alias"]): it["slug"] for it in items if it.get("numeric_alias")
     }
+    na_gates: dict[str, dict[str, Any]] = cfg.get("n/a_gates") or {}
 
     client = GiteaClient(args.gitea_host, token) if token else None
     if not client:
@@ -823,6 +819,8 @@ def main(argv: list[str] | None = None) -> int:
         print("::error::PR payload missing user.login or head.sha", file=sys.stderr)
         return 1
 
+    target_url = f"https://{args.gitea_host}/{args.owner}/{args.repo}/pulls/{args.pr}"
+
     comments = client.get_issue_comments(args.owner, args.repo, args.pr)
 
     # Build team-membership probe closure that caches results per
@@ -880,6 +878,47 @@ def main(argv: list[str] | None = None) -> int:
     ack_state = compute_ack_state(comments, author, items_by_slug, numeric_aliases, probe)
     body_state = {it["slug"]: section_marker_present(body, it["pr_section_marker"]) for it in items}
 
+    # --- N/A gate state (RFC#324 §N/A follow-up) ---
+    na_state: dict[str, dict[str, Any]] = {}
+    if na_gates:
+        na_state = compute_na_state(
+            comments, author, na_gates, numeric_aliases,
+            probe, client, args.owner,
+        )
+        # Post N/A declarations status (read by review-check.sh).
+        na_satisfied = [g for g, s in na_state.items() if s["declared"]]
+        na_missing   = [g for g, s in na_state.items() if not s["declared"]]
+        if na_satisfied:
+            na_desc = f"N/A: {', '.join(na_satisfied)}"
+            na_post_state = "success"
+        elif na_missing:
+            na_desc = f"awaiting /sop-n/a declaration for: {', '.join(na_missing)}"
+            na_post_state = "pending"
+        else:
+            # Configured but no declarations yet.
+            na_desc = "no /sop-n/a declarations yet"
+            na_post_state = "pending"
+        na_context = "sop-checklist / na-declarations (pull_request)"
+        print(f"::notice::na-declarations status: {na_post_state} — {na_desc}")
+        if not args.dry_run:
+            client.post_status(
+                args.owner, args.repo, head_sha,
+                state=na_post_state, context=na_context,
+                description=na_desc,
+                target_url=target_url,
+            )
+            print(f"::notice::na-declarations status posted: {na_context} → {na_post_state}")
+        # Log per-gate diagnostics.
+        for gate in na_gates:
+            s = na_state.get(gate, {})
+            if s.get("declared"):
+                print(f"::notice::  [PASS] gate={gate} — N/A declared by {','.join(s['declared'])}"
+                      + (f" ({s['reason']})" if s.get("reason") else ""))
+            else:
+                extra = f" — rejected: {', '.join(s.get('rejected', []))}" if s.get("rejected") else ""
+                print(f"::notice::  [WAIT] gate={gate} — no valid N/A declaration yet{extra}")
+
+
     state, description = render_status(items, ack_state, body_state)
     mode = get_tier_mode(pr, cfg)
     if mode == "soft":
@@ -914,53 +953,12 @@ def main(argv: list[str] | None = None) -> int:
             return 0 if state in ("success", "pending") else 1
         return 0
 
-    target_url = f"https://{args.gitea_host}/{args.owner}/{args.repo}/pulls/{args.pr}"
     client.post_status(
         args.owner, args.repo, head_sha,
         state=state, context=args.status_context,
         description=description, target_url=target_url,
     )
     print(f"::notice::status posted: {args.status_context} → {state}")
-
-    # --- N/A gate status (RFC#324 §N/A follow-up) ---
-    # Post a separate status so review-check.sh can discover N/A declarations
-    # and waive the Gitea-approve requirement for that gate.
-    na_state: dict[str, dict[str, Any]] = {}
-    if na_gates:
-        na_state = compute_na_state(comments, author, na_gates, probe)
-
-        na_descs: list[str] = []
-        for gate, s in na_state.items():
-            if s["declared"]:
-                na_descs.append(gate)
-            decl = s["decl_ackers"]
-            rej = s["rejected"]["not_in_team"]
-            if decl:
-                print(f"::notice::  [N/A OK] {gate} — declared by {','.join(decl)}")
-            if rej:
-                print(
-                    f"::notice::  [N/A REJ] {gate} — not-in-team: {','.join(rej)}",
-                    file=sys.stderr,
-                )
-
-        na_desc = ", ".join(sorted(na_descs)) if na_descs else "(none)"
-        na_status_state = "success" if na_descs else "pending"
-        # review-check.sh reads the description to discover which gates are N/A.
-        # Include the gate names so it can grep for them.
-        na_description = f"N/A: {na_desc}" if na_descs else "N/A: (none)"
-
-        if not args.dry_run:
-            client.post_status(
-                args.owner, args.repo, head_sha,
-                state=na_status_state,
-                context="sop-checklist / na-declarations (pull_request)",
-                description=na_description,
-                target_url=target_url,
-            )
-            print(
-                f"::notice::na-declarations status → {na_status_state}: {na_description}"
-            )
-
     # By default exit 0 — the POSTed status IS the gate, NOT the job
     # conclusion. If the job exits 1 BP will see TWO failure signals
     # (one from the job's auto-status, one from our POST), making the

.gitea/scripts/tests/test_sop_checklist.py

@@ -551,55 +551,3 @@ class TestEndToEndAckFlow(unittest.TestCase):
 
 if __name__ == "__main__":
     unittest.main(verbosity=2)
-
-
-# ---------------------------------------------------------------------------
-# compute_na_state
-# ---------------------------------------------------------------------------
-
-
-class TestComputeNaState(unittest.TestCase):
-    """Tests for /sop-n/a directive evaluation."""
-
-    def test_no_na_declarations(self):
-        cfg = sop.load_config(CONFIG_PATH)
-        na_gates = cfg.get("n/a_gates", {})
-        comments = []
-        na_state = sop.compute_na_state(comments, "alice", na_gates, lambda *_: [])
-        self.assertFalse(na_state["qa-review"]["declared"])
-        self.assertFalse(na_state["security-review"]["declared"])
-
-    def test_na_declared_by_authorized_user(self):
-        cfg = sop.load_config(CONFIG_PATH)
-        na_gates = cfg.get("n/a_gates", {})
-        comments = [_comment("bob", "/sop-n/a qa-review N/A: pure tooling change")]
-        na_state = sop.compute_na_state(comments, "alice", na_gates, lambda g, u: u)
-        self.assertTrue(na_state["qa-review"]["declared"])
-        self.assertEqual(na_state["qa-review"]["decl_ackers"], ["bob"])
-
-    def test_na_declared_by_unauthorized_user_rejected(self):
-        cfg = sop.load_config(CONFIG_PATH)
-        na_gates = cfg.get("n/a_gates", {})
-        comments = [_comment("mallory", "/sop-n/a qa-review N/A: not real team")]
-        na_state = sop.compute_na_state(comments, "alice", na_gates, lambda g, u: [])
-        self.assertFalse(na_state["qa-review"]["declared"])
-        self.assertEqual(na_state["qa-review"]["rejected"]["not_in_team"], ["mallory"])
-
-    def test_author_cannot_self_declare_na(self):
-        cfg = sop.load_config(CONFIG_PATH)
-        na_gates = cfg.get("n/a_gates", {})
-        comments = [_comment("alice", "/sop-n/a qa-review N/A: I am the author")]
-        na_state = sop.compute_na_state(comments, "alice", na_gates, lambda g, u: u)
-        self.assertFalse(na_state["qa-review"]["declared"])
-
-    def test_parse_directives_separates_na_from_ack(self):
-        directives, na_directives = sop.parse_directives(
-            "/sop-ack comprehensive-testing\n/sop-n/a qa-review N/A: no surface",
-            {},
-        )
-        self.assertEqual(len(directives), 1)
-        self.assertEqual(directives[0][0], "sop-ack")
-        self.assertEqual(len(na_directives), 1)
-        self.assertEqual(na_directives[0][0], "sop-n/a")
-        self.assertEqual(na_directives[0][1], "qa-review")
-        self.assertIn("no surface", na_directives[0][2])

.gitea/workflows/ci.yml

@@ -133,6 +133,7 @@ jobs:
   # the name match works on PRs that don't touch workspace-server/).
   platform-build:
     name: Platform (Go)
+    needs: changes
     runs-on: ubuntu-latest
     # mc#774 (closed 2026-05-14): Phase 4 flip of the platform-build job.
     # Phase 4 (#656) originally flipped this to continue-on-error: false based on
@@ -153,29 +154,29 @@ jobs:
       run:
         working-directory: workspace-server
     steps:
-      - if: false
+      - if: needs.changes.outputs.platform != 'true'
         working-directory: .
         run: echo "No platform/** changes — skipping real build steps; this job always runs to satisfy the required-check name on branch protection."
-      - if: always()
+      - if: needs.changes.outputs.platform == 'true'
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-      - if: always()
+      - if: needs.changes.outputs.platform == 'true'
         uses: actions/setup-go@40f1582b2485089dde7abd97c1529aa768e1baff # v5
         with:
           go-version: 'stable'
-      - if: always()
+      - if: needs.changes.outputs.platform == 'true'
         run: go mod download
-      - if: always()
+      - if: needs.changes.outputs.platform == 'true'
         run: go build ./cmd/server
       # CLI (molecli) moved to standalone repo: git.moleculesai.app/molecule-ai/molecule-cli
-      - if: always()
+      - if: needs.changes.outputs.platform == 'true'
         run: go vet ./...
-      - if: always()
+      - if: needs.changes.outputs.platform == 'true'
         name: Install golangci-lint
         run: go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.12.2
-      - if: always()
+      - if: needs.changes.outputs.platform == 'true'
         name: Run golangci-lint
         run: $(go env GOPATH)/bin/golangci-lint run --timeout 3m ./...
-      - if: always()
+      - if: needs.changes.outputs.platform == 'true'
         name: Diagnostic — per-package verbose 60s
         run: |
           set +e
@@ -191,7 +192,7 @@ jobs:
           echo "::endgroup::"
         # mc#774: pre-existing continue-on-error mask; root-fix and remove, do not renew silently.
         continue-on-error: true
-      - if: always()
+      - if: needs.changes.outputs.platform == 'true'
         name: Run tests with race detection and coverage
         # Explicit timeout: cold runner cache causes OOM kills at ~4m39s on the
         # full ./... suite with race detection + coverage. A 10m per-step timeout
@@ -199,7 +200,7 @@ jobs:
         # instead of OOM-killing. The job-level timeout (15m) is a backstop.
         run: go test -race -timeout 10m -coverprofile=coverage.out ./...
 
-      - if: always()
+      - if: needs.changes.outputs.platform == 'true'
         name: Per-file coverage report
         # Advisory — lists every source file with its coverage so reviewers
         # can see at-a-glance where gaps are. Sorted ascending so the worst
@@ -213,7 +214,7 @@ jobs:
                    END {for (f in s) printf "%6.1f%%  %s\n", s[f]/c[f], f}' \
             | sort -n
 
-      - if: always()
+      - if: needs.changes.outputs.platform == 'true'
         name: Check coverage thresholds
         # Enforces two gates from #1823 Layer 1:
         #   1. Total floor (25% — ratchet plan in COVERAGE_FLOOR.md).
@@ -301,6 +302,7 @@ jobs:
   # siblings — verified empirically on PR #2314).
   canvas-build:
     name: Canvas (Next.js)
+    needs: changes
     runs-on: ubuntu-latest
     timeout-minutes: 20
     # Phase 4 (RFC #219 §1): confirmed green on main 2026-05-12.
@@ -309,20 +311,20 @@ jobs:
       run:
         working-directory: canvas
     steps:
-      - if: false
+      - if: needs.changes.outputs.canvas != 'true'
         working-directory: .
         run: echo "No canvas/** changes — skipping real build steps; this job always runs to satisfy the required-check name on branch protection."
-      - if: always()
+      - if: needs.changes.outputs.canvas == 'true'
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-      - if: always()
+      - if: needs.changes.outputs.canvas == 'true'
         uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
         with:
           node-version: '22'
-      - if: always()
+      - if: needs.changes.outputs.canvas == 'true'
         run: rm -f package-lock.json && npm install
-      - if: always()
+      - if: needs.changes.outputs.canvas == 'true'
         run: npm run build
-      - if: always()
+      - if: needs.changes.outputs.canvas == 'true'
         name: Run tests with coverage
         # Coverage instrumentation is configured in canvas/vitest.config.ts
         # (provider: v8, reporters: text + html + json-summary). Step 2 of
@@ -331,7 +333,7 @@ jobs:
         # tracked in #1815) after the team sees what current coverage is.
         run: npx vitest run --coverage
       - name: Upload coverage summary as artifact
-        if: always()
+        if: needs.changes.outputs.canvas == 'true' && always()
         # Pinned to v3 for Gitea act_runner v0.6 compatibility — v4+ uses
         # the GHES 3.10+ artifact protocol that Gitea 1.22.x does NOT
         # implement, surfacing as `GHESNotSupportedError: @actions/artifact
@@ -348,15 +350,16 @@ jobs:
   # Shellcheck (E2E scripts) — required check, always runs.
   shellcheck:
     name: Shellcheck (E2E scripts)
+    needs: changes
     runs-on: ubuntu-latest
     # Phase 4 (RFC #219 §1): confirmed green on main 2026-05-12.
     continue-on-error: false
     steps:
-      - if: false
+      - if: needs.changes.outputs.scripts != 'true'
         run: echo "No tests/e2e/ or infra/scripts/ changes — skipping real shellcheck; this job always runs to satisfy the required-check name on branch protection."
-      - if: always()
+      - if: needs.changes.outputs.scripts == 'true'
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-      - if: always()
+      - if: needs.changes.outputs.scripts == 'true'
         name: Run shellcheck on tests/e2e/*.sh and infra/scripts/*.sh
         # shellcheck is pre-installed on ubuntu-latest runners (via apt).
         # infra/scripts/ is included because setup.sh + nuke.sh gate the
@@ -367,16 +370,16 @@ jobs:
           find tests/e2e infra/scripts -type f -name '*.sh' -print0 \
             | xargs -0 shellcheck --severity=warning
 
-      - if: always()
+      - if: needs.changes.outputs.scripts == 'true'
         name: Lint cleanup-trap hygiene (RFC #2873)
         run: bash tests/e2e/lint_cleanup_traps.sh
 
-      - if: always()
+      - if: needs.changes.outputs.scripts == 'true'
         name: Run E2E bash unit tests (no live infra)
         run: |
           bash tests/e2e/test_model_slug.sh
 
-      - if: always()
+      - if: needs.changes.outputs.scripts == 'true'
         name: Test ECR promote-tenant-image script (mock-driven, no live infra)
         # Covers scripts/promote-tenant-image.sh — the codified
         # :staging-latest → :latest ECR promote + tenant fleet redeploy
@@ -386,7 +389,7 @@ jobs:
         run: |
           bash scripts/test-promote-tenant-image.sh
 
-      - if: always()
+      - if: needs.changes.outputs.scripts == 'true'
         name: Shellcheck promote-tenant-image script
         # scripts/ is excluded from the bulk shellcheck pass above (legacy
         # SC3040/SC3043 cleanup pending). Run shellcheck explicitly on
@@ -397,8 +400,6 @@ jobs:
             scripts/promote-tenant-image.sh \
             scripts/test-promote-tenant-image.sh
 
-  # mc#959 root-fix (sre)
-
   canvas-deploy-reminder:
     name: Canvas Deploy Reminder
     runs-on: ubuntu-latest
@@ -406,9 +407,9 @@ jobs:
     # ci_job_names() detects this as github.ref-gated and skips it from F1.
     # The step-level exit 0 handles the "not main push" case; the job-level
     # `if:` makes the gating explicit so the drift script sees it.
-    # Runs on both main and staging pushes; step exits 0 when not applicable.
-    if: ${{ github.ref == 'refs/heads/main' || github.ref == 'refs/heads/staging' }}
+    # continue-on-error removed (was mc#774 mask): step exits 0 when not applicable.
     needs: [changes, canvas-build]
+    if: ${{ github.ref == 'refs/heads/main' }}
     steps:
       - name: Write deploy reminder to step summary
         env:
@@ -458,6 +459,7 @@ jobs:
   # Python Lint & Test — required check, always runs.
   python-lint:
     name: Python Lint & Test
+    needs: changes
     runs-on: ubuntu-latest
     # Phase 4 (RFC #219 §1): confirmed green on main 2026-05-12.
     continue-on-error: false
@@ -467,25 +469,25 @@ jobs:
       run:
         working-directory: workspace
     steps:
-      - if: false
+      - if: needs.changes.outputs.python != 'true'
         working-directory: .
         run: echo "No workspace/** changes — skipping real lint+test; this job always runs to satisfy the required-check name on branch protection."
-      - if: always()
+      - if: needs.changes.outputs.python == 'true'
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-      - if: always()
+      - if: needs.changes.outputs.python == 'true'
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: '3.11'
           cache: pip
           cache-dependency-path: workspace/requirements.txt
-      - if: always()
+      - if: needs.changes.outputs.python == 'true'
         run: pip install -r requirements.txt pytest pytest-asyncio pytest-cov sqlalchemy>=2.0.0
       # Coverage flags + fail-under floor moved into workspace/pytest.ini
       # (issue #1817) so local `pytest` and CI use identical config.
-      - if: always()
+      - if: needs.changes.outputs.python == 'true'
         run: python -m pytest --tb=short
 
-      - if: always()
+      - if: needs.changes.outputs.python == 'true'
         name: Per-file critical-path coverage (MCP / inbox / auth)
         # MCP-critical Python files have a per-file floor on top of the
         # 86% total floor in pytest.ini. See issue #2790 for full rationale.
@@ -550,104 +552,86 @@ jobs:
     # red silently merged through. See internal#286 for the three concrete
     # tonight-of-2026-05-11 incidents that prompted the emergency bump.
     #
-    # This job deliberately has no `needs:`. Gitea 1.22/act_runner can mark a
-    # job-level `if: always()` + `needs:` sentinel as skipped before upstream
-    # jobs settle, leaving branch protection with a permanent pending
-    # `CI / all-required` context. Instead, this independent sentinel polls the
-    # required commit-status contexts for this SHA and fails if any fail, skip,
-    # or never emit.
+    # Three properties of this job each close a failure mode:
     #
-    # canvas-deploy-reminder is intentionally NOT included in all-required.needs.
-    # It is an informational main-push reminder, not a PR quality gate. Keeping
-    # it in this dependency list lets a skipped reminder skip the required
-    # sentinel before the `always()` guard can emit a branch-protection status.
+    #  1. `if: always()` — runs even when an upstream fails. Without it the
+    #     sentinel is `skipped` and protection treats that as missing → merge
+    #     ungated.
     #
+    #  2. Assertion is `result == "success"` per dep, NOT `!= "failure"`.
+    #     A `skipped` upstream (job gated by `if:` evaluating false, matrix
+    #     entry that couldn't run) must NOT silently pass through.
+    #     `skipped`-as-green is exactly the failure mode this gate closes.
+    #
+    #  3. `needs:` is the canonical list of "what counts as required."
+    #     status_check_contexts will reference only `ci/all-required` (Step 5
+    #     follow-up — branch-protection PATCH is Owners-tier per
+    #     `feedback_never_admin_merge_bypass`, separate PR); a new job is
+    #     added simply by listing it in `needs:` here.
+    #     `.gitea/workflows/ci-required-drift.yml` files a [ci-drift] issue
+    #     hourly if this list diverges from status_check_contexts or from
+    #     audit-force-merge.yml's REQUIRED_CHECKS env (RFC §4 + §6).
+    #
+    # canvas-deploy-reminder IS now included in all-required.needs (mc#958 root-fix):
+    # added job-level `if: github.ref == 'refs/heads/main'` so ci-required-drift.py's
+    # ci_job_names() detects it as github.ref-gated and skips it from F1.
+    # The step-level `if: ... || REF_NAME != refs/heads/main` exits 0 when not main,
+    # so the job succeeds (not skipped) on non-main pushes — sentinel treats as green.
+    #
+    # Phase 3 (RFC #219 §1) safety: underlying build jobs carry
+    # continue-on-error: true so their failures are masked to null (2026-05-12: re-enabled mc#774 interim)
+    # (Gitea suppresses status reporting for CoE jobs). This sentinel
+    # runs with continue-on-error: false so it always reports its
+    # result to the API — without this, the required-status entry
+    # (CI / all-required (pull_request)) is never created, which
+    # blocks PR merges. When Phase 3 ends, flip underlying jobs to
+    # continue-on-error: false; this sentinel can then be flipped to
+    # continue-on-error: true if a Phase-4 regression requires it.
     continue-on-error: false
     runs-on: ubuntu-latest
-    timeout-minutes: 45
+    timeout-minutes: 1
+    needs:
+      - changes
+      - platform-build
+      - canvas-build
+      - shellcheck
+      - python-lint
+      - canvas-deploy-reminder
+    if: ${{ always() }}
     steps:
-      - name: Wait for required CI contexts
-        env:
-          GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          API_ROOT: ${{ github.server_url }}/api/v1
-          REPOSITORY: ${{ github.repository }}
-          COMMIT_SHA: ${{ github.sha }}
-          EVENT_NAME: ${{ github.event_name }}
+      - name: Assert every required dependency succeeded
         run: |
           set -euo pipefail
-          python3 - <<'PY'
-          import json
-          import os
-          import sys
-          import time
-          import urllib.error
-          import urllib.request
-
-          token = os.environ["GITEA_TOKEN"]
-          api_root = os.environ["API_ROOT"].rstrip("/")
-          repo = os.environ["REPOSITORY"]
-          sha = os.environ["COMMIT_SHA"]
-          event = os.environ["EVENT_NAME"]
-          required = [
-              f"CI / Detect changes ({event})",
-              f"CI / Platform (Go) ({event})",
-              f"CI / Canvas (Next.js) ({event})",
-              f"CI / Shellcheck (E2E scripts) ({event})",
-              f"CI / Python Lint & Test ({event})",
-          ]
-          terminal_bad = {"failure", "error"}
-          deadline = time.time() + 40 * 60
-          last_summary = None
-
-          def fetch_statuses():
-              statuses = []
-              for page in range(1, 6):
-                  url = f"{api_root}/repos/{repo}/commits/{sha}/statuses?page={page}&limit=100"
-                  req = urllib.request.Request(url, headers={"Authorization": f"token {token}"})
-                  with urllib.request.urlopen(req, timeout=10) as resp:
-                      chunk = json.load(resp)
-                  if not chunk:
-                      break
-                  statuses.extend(chunk)
-              latest = {}
-              for item in statuses:
-                  ctx = item.get("context")
-                  if not ctx:
-                      continue
-                  prev = latest.get(ctx)
-                  if prev is None or (item.get("updated_at") or item.get("created_at") or "") >= (prev.get("updated_at") or prev.get("created_at") or ""):
-                      latest[ctx] = item
-              return latest
-
-          while True:
-              try:
-                  latest = fetch_statuses()
-              except (TimeoutError, OSError, urllib.error.URLError) as exc:
-                  if time.time() >= deadline:
-                      print(f"FAIL: status polling did not recover before deadline: {exc}", file=sys.stderr)
-                      sys.exit(1)
-                  print(f"WARN: status poll failed, retrying: {exc}", flush=True)
-                  time.sleep(15)
-                  continue
-              states = {ctx: (latest.get(ctx) or {}).get("status") or (latest.get(ctx) or {}).get("state") or "missing" for ctx in required}
-              summary = ", ".join(f"{ctx}={state}" for ctx, state in states.items())
-              if summary != last_summary:
-                  print(summary, flush=True)
-                  last_summary = summary
-              bad = {ctx: state for ctx, state in states.items() if state in terminal_bad}
-              if bad:
-                  print("FAIL: required CI context failed:", file=sys.stderr)
-                  for ctx, state in bad.items():
-                      desc = (latest.get(ctx) or {}).get("description") or ""
-                      print(f"  - {ctx}: {state} {desc}", file=sys.stderr)
-                  sys.exit(1)
-              if all(state == "success" for state in states.values()):
-                  print(f"OK: all {len(required)} required CI contexts succeeded")
-                  sys.exit(0)
-              if time.time() >= deadline:
-                  print("FAIL: timed out waiting for required CI contexts:", file=sys.stderr)
-                  for ctx, state in states.items():
-                      print(f"  - {ctx}: {state}", file=sys.stderr)
-                  sys.exit(1)
-              time.sleep(15)
-          PY
+          # `needs.*.result` is one of: success | failure | cancelled | skipped | null.
+          # We assert success per dep (not != failure) — see RFC §2 reasoning above.
+          # Null results are skipped: they come from Phase 3 (continue-on-error: true
+          # suppresses status) or from jobs still in-flight. The sentinel succeeds
+          # rather than blocking PRs on Phase 3 noise.
+          results='${{ toJSON(needs) }}'
+          echo "$results"
+          echo "$results" | python3 -c '
+          import json, sys
+          ns = json.load(sys.stdin)
+          # Phase 3 masked: jobs with continue-on-error: true may report "failure"
+          # Remove when mc#774 handler test failures are resolved.
+          PHASE3_MASKED = {"platform-build"}
+          # Exclude null (Phase 3 suppressed / in-flight) from the bad list.
+          bad = [(k, v.get("result")) for k, v in ns.items()
+                 if v.get("result") not in ("success", None, "cancelled", "skipped") and k not in PHASE3_MASKED]
+          if bad:
+              print(f"FAIL: jobs not green:", file=sys.stderr)
+              for k, r in bad:
+                  print(f"  - {k}: {r}", file=sys.stderr)
+              sys.exit(1)
+          pending = [(k, v.get("result")) for k, v in ns.items()
+                     if v.get("result") is None]
+          cancelled = [(k, v.get("result")) for k, v in ns.items()
+                       if v.get("result") == "cancelled"]
+          if pending:
+              print(f"WARN: {len(pending)} job(s) still in-flight (result=null): " +
+                    ", ".join(k for k, _ in pending), file=sys.stderr)
+          if cancelled:
+              print(f"INFO: {len(cancelled)} job(s) masked by continue-on-error: " +
+                    ", ".join(k for k, _ in cancelled), file=sys.stderr)
+          print(f"OK: all {len(ns)} required jobs succeeded (or Phase-3 suppressed)")
+          '

.gitea/workflows/e2e-api.yml

@@ -69,13 +69,6 @@ name: E2E API Smoke Test
 # 2318) shows Postgres ready in 3s, Redis in 1s, Platform in 1s when
 # they DO come up. Timeouts are not the bottleneck; not bumped.
 #
-# Item #1046 (fixed 2026-05-14): Stale platform-server from cancelled runs
-#   lingers on :8080 after "Stop platform" step is skipped (workflow cancelled
-#   before reaching line 335). Added a pre-start "Kill stale platform-server"
-#   step (line 286) that scans /proc for zombie platform-server processes
-#   and kills them before the port probe or bind. Makes the ephemeral port
-#   probe + start sequence deterministic.
-#
 # Item explicitly NOT fixed here: failing test `Status back online`
 # fails because the platform's langgraph workspace template image
 # (ghcr.io/molecule-ai/workspace-template-langgraph:latest) returns
@@ -290,35 +283,6 @@ jobs:
           echo "PORT=${PLATFORM_PORT}" >> "$GITHUB_ENV"
           echo "BASE=http://127.0.0.1:${PLATFORM_PORT}" >> "$GITHUB_ENV"
           echo "Platform host port: ${PLATFORM_PORT}"
-      - name: Kill stale platform-server before start (issue #1046)
-        if: needs.detect-changes.outputs.api == 'true'
-        run: |
-          # Concurrent runs on the same host-network act_runner can leave a
-          # zombie platform-server from a cancelled/timeout run. Cancelled
-          # runs never reach the "Stop platform" step (line 335), so the
-          # old process lingers. Kill it before the ephemeral port probe
-          # or start so the port is definitively free.
-          #
-          # /proc scan — works on any Linux without pkill/lsof/ss.
-          # comm field is truncated to 15 chars: "platform-serve" matches
-          # "platform-server". Verify with cmdline to avoid false positives.
-          killed=0
-          for pid in $(grep -l "platform-serve" /proc/[0-9]*/comm 2>/dev/null); do
-            kpid="${pid%/comm}"
-            kpid="${kpid##*/}"
-            cmdline=$(cat "/proc/${kpid}/cmdline" 2>/dev/null | tr '\0' ' ')
-            if echo "$cmdline" | grep -q "platform-server"; then
-              echo "Killing stale platform-server pid ${kpid}: ${cmdline}"
-              kill "$kpid" 2>/dev/null || true
-              killed=$((killed + 1))
-            fi
-          done
-          if [ "$killed" -gt 0 ]; then
-            sleep 2
-            echo "Killed $killed stale process(es); port(s) released."
-          else
-            echo "No stale platform-server found."
-          fi
       - name: Start platform (background)
         if: needs.detect-changes.outputs.api == 'true'
         working-directory: workspace-server
@@ -382,4 +346,3 @@ jobs:
         run: |
           docker rm -f "$PG_CONTAINER" 2>/dev/null || true
           docker rm -f "$REDIS_CONTAINER" 2>/dev/null || true
-

.gitea/workflows/e2e-chat.yml

@@ -1,288 +0,0 @@
-name: E2E Chat
-
-# Comprehensive Playwright E2E for the unified chat stack (desktop
-# ChatTab + mobile MobileChat). Runs on every PR that touches canvas,
-# workspace-server, or this workflow file.
-#
-# Architecture:
-#   1. Ephemeral Postgres + Redis (docker, unique container names)
-#   2. workspace-server built from source, started with
-#      MOLECULE_ENV=development (fail-open auth)
-#   3. canvas dev server (npm run dev) on :3000
-#   4. Playwright tests create workspaces via API, point them at an
-#      in-process echo runtime, and exercise the full send/receive
-#      round-trip through the browser.
-#
-# Parallel-safety: same pattern as e2e-api.yml — per-run container names
-# and ephemeral host ports so concurrent jobs on the host-network runner
-# don't collide.
-
-on:
-  push:
-    branches: [main, staging]
-  pull_request:
-    branches: [main, staging]
-
-concurrency:
-  group: e2e-chat-${{ github.event.pull_request.head.sha || github.sha }}
-  cancel-in-progress: false
-
-env:
-  GITHUB_SERVER_URL: https://git.moleculesai.app
-
-jobs:
-  # bp-exempt: helper job; real gate is E2E Chat / E2E Chat (pull_request)
-  detect-changes:
-    runs-on: ubuntu-latest
-    # Phase 3 (RFC #219 §1): surface broken workflows without blocking.
-    # mc#774: pre-existing continue-on-error mask; root-fix and remove, do not renew silently.
-    continue-on-error: true
-    outputs:
-      chat: ${{ steps.decide.outputs.chat }}
-    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          fetch-depth: 0
-      - id: decide
-        run: |
-          BASE="${GITHUB_BASE_REF:-${{ github.event.before }}}"
-          if [ "${{ github.event_name }}" = "pull_request" ] && [ -n "${{ github.event.pull_request.base.sha }}" ]; then
-            BASE="${{ github.event.pull_request.base.sha }}"
-          fi
-          if [ -z "$BASE" ] || echo "$BASE" | grep -qE '^0+$'; then
-            echo "chat=true" >> "$GITHUB_OUTPUT"
-            exit 0
-          fi
-          if ! git cat-file -e "$BASE" 2>/dev/null; then
-            git fetch --depth=1 origin "$BASE" 2>/dev/null || true
-          fi
-          if ! git cat-file -e "$BASE" 2>/dev/null; then
-            echo "chat=true" >> "$GITHUB_OUTPUT"
-            exit 0
-          fi
-          CHANGED=$(git diff --name-only "$BASE" HEAD)
-          if echo "$CHANGED" | grep -qE '^(canvas/|workspace-server/|\.gitea/workflows/e2e-chat\.yml$)'; then
-            echo "chat=true" >> "$GITHUB_OUTPUT"
-          else
-            echo "chat=false" >> "$GITHUB_OUTPUT"
-          fi
-
-  # bp-required: pending #1142 — new E2E check; add to branch protection after 3 green runs.
-  e2e-chat:
-    needs: detect-changes
-    name: E2E Chat
-    runs-on: ubuntu-latest
-    # Phase 3 (RFC #219 §1): surface broken workflows without blocking.
-    # mc#774: pre-existing continue-on-error mask; root-fix and remove, do not renew silently.
-    continue-on-error: true
-    timeout-minutes: 15
-    env:
-      PG_CONTAINER: pg-e2e-chat-${{ github.run_id }}-${{ github.run_attempt }}
-      REDIS_CONTAINER: redis-e2e-chat-${{ github.run_id }}-${{ github.run_attempt }}
-    steps:
-      - name: No-op pass (paths filter excluded this commit)
-        if: needs.detect-changes.outputs.chat != 'true'
-        run: |
-          echo "No canvas / workspace-server / workflow changes — E2E Chat gate satisfied without running tests."
-          echo "::notice::E2E Chat no-op pass (paths filter excluded this commit)."
-
-      - if: needs.detect-changes.outputs.chat == 'true'
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-
-      - if: needs.detect-changes.outputs.chat == 'true'
-        uses: actions/setup-go@40f1582b2485089dde7abd97c1529aa768e1baff # v5
-        with:
-          go-version: 'stable'
-          cache: true
-          cache-dependency-path: workspace-server/go.sum
-
-      - if: needs.detect-changes.outputs.chat == 'true'
-        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
-        with:
-          node-version: '22'
-          cache: 'npm'
-          cache-dependency-path: canvas/package-lock.json
-
-      - name: Start Postgres (docker)
-        if: needs.detect-changes.outputs.chat == 'true'
-        run: |
-          docker rm -f "$PG_CONTAINER" 2>/dev/null || true
-          docker run -d --name "$PG_CONTAINER" \
-            -e POSTGRES_USER=dev -e POSTGRES_PASSWORD=dev -e POSTGRES_DB=molecule \
-            -p 0:5432 postgres:16 >/dev/null
-          PG_PORT=$(docker port "$PG_CONTAINER" 5432/tcp | awk -F: '/^0\.0\.0\.0:/ {print $2; exit}')
-          if [ -z "$PG_PORT" ]; then
-            PG_PORT=$(docker port "$PG_CONTAINER" 5432/tcp | head -1 | awk -F: '{print $NF}')
-          fi
-          if [ -z "$PG_PORT" ]; then
-            echo "::error::Could not resolve host port for $PG_CONTAINER"
-            exit 1
-          fi
-          echo "PG_PORT=${PG_PORT}" >> "$GITHUB_ENV"
-          echo "DATABASE_URL=postgres://dev:dev@127.0.0.1:${PG_PORT}/molecule?sslmode=disable" >> "$GITHUB_ENV"
-          echo "E2E_DATABASE_URL=postgres://dev:dev@127.0.0.1:${PG_PORT}/molecule?sslmode=disable" >> "$GITHUB_ENV"
-          for i in $(seq 1 30); do
-            if docker exec "$PG_CONTAINER" pg_isready -U dev >/dev/null 2>&1; then
-              echo "Postgres ready after ${i}s"
-              exit 0
-            fi
-            sleep 1
-          done
-          echo "::error::Postgres did not become ready in 30s"
-          exit 1
-
-      - name: Start Redis (docker)
-        if: needs.detect-changes.outputs.chat == 'true'
-        run: |
-          docker rm -f "$REDIS_CONTAINER" 2>/dev/null || true
-          docker run -d --name "$REDIS_CONTAINER" -p 0:6379 redis:7 >/dev/null
-          REDIS_PORT=$(docker port "$REDIS_CONTAINER" 6379/tcp | awk -F: '/^0\.0\.0\.0:/ {print $2; exit}')
-          if [ -z "$REDIS_PORT" ]; then
-            REDIS_PORT=$(docker port "$REDIS_CONTAINER" 6379/tcp | head -1 | awk -F: '{print $NF}')
-          fi
-          if [ -z "$REDIS_PORT" ]; then
-            echo "::error::Could not resolve host port for $REDIS_CONTAINER"
-            exit 1
-          fi
-          echo "REDIS_PORT=${REDIS_PORT}" >> "$GITHUB_ENV"
-          echo "REDIS_URL=redis://127.0.0.1:${REDIS_PORT}" >> "$GITHUB_ENV"
-          for i in $(seq 1 15); do
-            if docker exec "$REDIS_CONTAINER" redis-cli ping 2>/dev/null | grep -q PONG; then
-              echo "Redis ready after ${i}s"
-              exit 0
-            fi
-            sleep 1
-          done
-          echo "::error::Redis did not become ready in 15s"
-          exit 1
-
-      - name: Build platform
-        if: needs.detect-changes.outputs.chat == 'true'
-        working-directory: workspace-server
-        run: go build -o platform-server ./cmd/server
-
-      - name: Pick platform port
-        if: needs.detect-changes.outputs.chat == 'true'
-        run: |
-          PLATFORM_PORT=$(python3 - <<'PY'
-          import socket
-          with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-              s.bind(("127.0.0.1", 0))
-              print(s.getsockname()[1])
-          PY
-          )
-          echo "PLATFORM_PORT=${PLATFORM_PORT}" >> "$GITHUB_ENV"
-          echo "E2E_PLATFORM_URL=http://127.0.0.1:${PLATFORM_PORT}" >> "$GITHUB_ENV"
-          echo "Platform host port: ${PLATFORM_PORT}"
-
-      - name: Pick canvas port
-        if: needs.detect-changes.outputs.chat == 'true'
-        run: |
-          CANVAS_PORT=$(python3 - <<'PY'
-          import socket
-          with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-              s.bind(("127.0.0.1", 0))
-              print(s.getsockname()[1])
-          PY
-          )
-          echo "CANVAS_PORT=${CANVAS_PORT}" >> "$GITHUB_ENV"
-          echo "Canvas host port: ${CANVAS_PORT}"
-
-      - name: Start platform (background)
-        if: needs.detect-changes.outputs.chat == 'true'
-        working-directory: workspace-server
-        run: |
-          export MOLECULE_ENV=development
-          export DATABASE_URL="${DATABASE_URL}"
-          export REDIS_URL="${REDIS_URL}"
-          export PORT="${PLATFORM_PORT}"
-          export CORS_ORIGINS="http://localhost:3000,http://localhost:3001,http://localhost:${CANVAS_PORT},http://127.0.0.1:${CANVAS_PORT}"
-          ./platform-server > platform.log 2>&1 &
-          echo $! > platform.pid
-
-      - name: Wait for /health
-        if: needs.detect-changes.outputs.chat == 'true'
-        run: |
-          for i in $(seq 1 30); do
-            if curl -sf "http://127.0.0.1:${PLATFORM_PORT}/health" > /dev/null; then
-              echo "Platform up after ${i}s"
-              exit 0
-            fi
-            sleep 1
-          done
-          echo "::error::Platform did not become healthy in 30s"
-          cat workspace-server/platform.log || true
-          exit 1
-
-      - name: Install canvas dependencies
-        if: needs.detect-changes.outputs.chat == 'true'
-        working-directory: canvas
-        run: npm ci
-
-      - name: Install Playwright browsers
-        if: needs.detect-changes.outputs.chat == 'true'
-        working-directory: canvas
-        run: npx playwright install --with-deps chromium
-
-      - name: Start canvas dev server (background)
-        if: needs.detect-changes.outputs.chat == 'true'
-        working-directory: canvas
-        run: |
-          export NEXT_PUBLIC_PLATFORM_URL="http://127.0.0.1:${PLATFORM_PORT}"
-          export NEXT_PUBLIC_WS_URL="ws://127.0.0.1:${PLATFORM_PORT}/ws"
-          npx next dev --turbopack -p "${CANVAS_PORT}" > canvas.log 2>&1 &
-          echo $! > canvas.pid
-          for i in $(seq 1 30); do
-            if curl -sf "http://localhost:${CANVAS_PORT}" > /dev/null 2>&1; then
-              echo "Canvas up after ${i}s"
-              exit 0
-            fi
-            sleep 1
-          done
-          echo "::error::Canvas did not start in 30s"
-          cat canvas.log || true
-          exit 1
-
-      - name: Run Playwright E2E tests
-        if: needs.detect-changes.outputs.chat == 'true'
-        working-directory: canvas
-        run: |
-          export E2E_PLATFORM_URL="http://127.0.0.1:${PLATFORM_PORT}"
-          export E2E_DATABASE_URL="${DATABASE_URL}"
-          export PLAYWRIGHT_BASE_URL="http://localhost:${CANVAS_PORT}"
-          npx playwright test e2e/chat-desktop.spec.ts e2e/chat-mobile.spec.ts
-
-      - name: Dump platform log on failure
-        if: failure() && needs.detect-changes.outputs.chat == 'true'
-        run: cat workspace-server/platform.log || true
-
-      - name: Dump canvas log on failure
-        if: failure() && needs.detect-changes.outputs.chat == 'true'
-        run: cat canvas/canvas.log || true
-
-      - name: Upload Playwright report
-        if: failure() && needs.detect-changes.outputs.chat == 'true'
-        uses: actions/upload-artifact@v3.2.2
-        with:
-          name: playwright-report-chat
-          path: canvas/playwright-report/
-
-      - name: Stop canvas
-        if: always() && needs.detect-changes.outputs.chat == 'true'
-        run: |
-          if [ -f canvas/canvas.pid ]; then
-            kill "$(cat canvas/canvas.pid)" 2>/dev/null || true
-          fi
-
-      - name: Stop platform
-        if: always() && needs.detect-changes.outputs.chat == 'true'
-        run: |
-          if [ -f workspace-server/platform.pid ]; then
-            kill "$(cat workspace-server/platform.pid)" 2>/dev/null || true
-          fi
-
-      - name: Stop service containers
-        if: always() && needs.detect-changes.outputs.chat == 'true'
-        run: |
-          docker rm -f "$PG_CONTAINER" 2>/dev/null || true
-          docker rm -f "$REDIS_CONTAINER" 2>/dev/null || true

.gitea/workflows/e2e-peer-visibility.yml

@@ -1,225 +0,0 @@
-name: E2E Peer Visibility (literal MCP list_peers)
-
-# WHY A DEDICATED WORKFLOW (not folded into e2e-staging-saas.yml)
-# --------------------------------------------------------------
-# This is the systemic fix for a real trust failure. Hermes and OpenClaw
-# were reported "fleet-verified / cascade-complete" because the *proxy*
-# signals were green (registry registration + heartbeat for Hermes; model
-# round-trip 200 for OpenClaw). A freshly-provisioned workspace asked on
-# canvas "can you see your peers" actually FAILS:
-#   - Hermes: 401 on the molecule MCP `list_peers` call
-#   - OpenClaw: native `sessions_list` fallback, sees no platform peers
-# Tasks #142/#159 were even marked "completed" under this proxy flaw.
-#
-# A dedicated workflow (vs extending e2e-staging-saas.yml) because:
-#   - It must provision MULTIPLE distinct runtimes (hermes, openclaw,
-#     claude-code) in ONE org and assert each sees the others. The
-#     full-saas script is single-runtime-per-run (E2E_RUNTIME) and folding
-#     a multi-runtime matrix into it would conflate concerns and bloat its
-#     already-45-min run.
-#   - It needs its own concurrency group so it doesn't fight full-saas /
-#     canvas for the staging org-creation quota.
-#   - It needs an independent, non-required status-context name so it can
-#     be RED today (the in-flight Hermes-401 / OpenClaw-MCP-wiring fixes
-#     have not landed) WITHOUT wedging unrelated merges — and flipped to
-#     REQUIRED in one branch-protection edit once it goes green
-#     (flip-to-required checklist: molecule-core#1296).
-#
-# THE ASSERTION IS NOT A PROXY. The driving script
-# tests/e2e/test_peer_visibility_mcp_staging.sh issues the byte-for-byte
-# JSON-RPC `tools/call name=list_peers` envelope to `POST
-# /workspaces/:id/mcp` using each workspace's OWN bearer token, through
-# the real WorkspaceAuth + MCPRateLimiter middleware chain — the exact
-# call mcp_molecule_list_peers makes from a canvas agent. It does NOT
-# read a registry row, /health, the heartbeat table, or
-# GET /registry/:id/peers.
-#
-# HONEST GATE — NO continue-on-error. Per feedback_fix_root_not_symptom a
-# fake-green mask would defeat the entire purpose. This workflow goes red
-# on today's broken behavior and green only when the root-cause fixes
-# actually land. It is intentionally NOT in branch_protections — see PR
-# body for the required-vs-not decision + flip tracking issue.
-#
-# Gitea 1.22.6 / act_runner notes honored:
-#   - No cross-repo `uses:` (feedback_gitea_cross_repo_uses_blocked). The
-#     actions/checkout SHA is the one e2e-staging-canvas.yml already uses
-#     successfully (a mirrored SHA — see #1277/PR#1292 root-cause).
-#   - Per-SHA concurrency, not global (feedback_concurrency_group_per_sha).
-#   - Workflow-level GITHUB_SERVER_URL pinned
-#     (feedback_act_runner_github_server_url).
-#   - pr-validate posts a status under the same check name so a
-#     workflow-only PR is not silently statusless and the context is
-#     flip-to-required-ready (mirrors e2e-staging-saas.yml's proven shape;
-#     real EC2-provisioning E2E is push/dispatch/cron only — it is 30+ min
-#     and cannot run per-PR-update).
-
-on:
-  push:
-    branches: [main]
-    paths:
-      - 'workspace-server/internal/handlers/mcp.go'
-      - 'workspace-server/internal/handlers/mcp_tools.go'
-      - 'workspace-server/internal/middleware/**'
-      - 'workspace-server/internal/handlers/registry.go'
-      - 'workspace-server/internal/handlers/workspace.go'
-      - 'workspace/a2a_mcp_server.py'
-      - 'workspace/platform_tools/registry.py'
-      - 'tests/e2e/test_peer_visibility_mcp_staging.sh'
-      - '.gitea/workflows/e2e-peer-visibility.yml'
-  pull_request:
-    branches: [main]
-    paths:
-      - 'workspace-server/internal/handlers/mcp.go'
-      - 'workspace-server/internal/handlers/mcp_tools.go'
-      - 'workspace-server/internal/middleware/**'
-      - 'workspace-server/internal/handlers/registry.go'
-      - 'workspace-server/internal/handlers/workspace.go'
-      - 'workspace/a2a_mcp_server.py'
-      - 'workspace/platform_tools/registry.py'
-      - 'tests/e2e/test_peer_visibility_mcp_staging.sh'
-      - '.gitea/workflows/e2e-peer-visibility.yml'
-  workflow_dispatch:
-  schedule:
-    # 07:30 UTC daily — catches AMI / template-hermes / template-openclaw
-    # drift even on quiet days. Offset 30m from e2e-staging-saas (07:00)
-    # so the two don't collide on the staging org-creation quota.
-    - cron: '30 7 * * *'
-
-concurrency:
-  # Per-SHA (feedback_concurrency_group_per_sha). A single global group
-  # would let a queued staging/main push behind a PR run get cancelled,
-  # leaving any gate that reads "completed run at SHA" stuck.
-  group: e2e-peer-visibility-${{ github.event.pull_request.head.sha || github.sha }}
-  cancel-in-progress: false
-
-env:
-  GITHUB_SERVER_URL: https://git.moleculesai.app
-
-jobs:
-  # PR path: post a real status under the required-ready check name so a
-  # workflow-only PR is never silently statusless. The actual EC2 E2E is
-  # push/dispatch/cron only (30+ min). This is NOT a fake-green mask of
-  # the real assertion — it validates the driving script's bash syntax
-  # and inline-python so a broken test script fails at PR time.
-  pr-validate:
-    name: E2E Peer Visibility
-    runs-on: ubuntu-latest
-    if: github.event_name == 'pull_request'
-    timeout-minutes: 5
-    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-      - name: Validate driving script
-        run: |
-          bash -n tests/e2e/test_peer_visibility_mcp_staging.sh
-          echo "test_peer_visibility_mcp_staging.sh — bash syntax OK"
-          echo "Real fresh-provision MCP list_peers E2E runs on push to"
-          echo "main / workflow_dispatch / daily cron (30+ min EC2 boot)."
-
-  # Real gate: provisions a throwaway org + sibling-per-runtime, drives
-  # the LITERAL list_peers MCP call per runtime, asserts 200 + expected
-  # peer set, then scoped teardown. push(main)/dispatch/cron only.
-  peer-visibility:
-    name: E2E Peer Visibility
-    runs-on: ubuntu-latest
-    if: github.event_name != 'pull_request'
-    timeout-minutes: 60
-
-    env:
-      MOLECULE_CP_URL: https://staging-api.moleculesai.app
-      MOLECULE_ADMIN_TOKEN: ${{ secrets.CP_STAGING_ADMIN_API_TOKEN }}
-      # LLM provider key so each runtime can authenticate at boot.
-      # Priority MiniMax → direct-Anthropic → OpenAI matches
-      # test_staging_full_saas.sh's secrets-injection chain.
-      E2E_MINIMAX_API_KEY: ${{ secrets.MOLECULE_STAGING_MINIMAX_API_KEY }}
-      E2E_ANTHROPIC_API_KEY: ${{ secrets.MOLECULE_STAGING_ANTHROPIC_API_KEY }}
-      E2E_OPENAI_API_KEY: ${{ secrets.MOLECULE_STAGING_OPENAI_API_KEY }}
-      E2E_RUN_ID: "${{ github.run_id }}-${{ github.run_attempt }}"
-      PV_RUNTIMES: "hermes openclaw claude-code"
-
-    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-
-      - name: Verify admin token present
-        run: |
-          if [ -z "$MOLECULE_ADMIN_TOKEN" ]; then
-            echo "::error::CP_STAGING_ADMIN_API_TOKEN secret not set (Railway staging CP_ADMIN_API_TOKEN)"
-            exit 2
-          fi
-          echo "Admin token present"
-
-      - name: Verify an LLM key present
-        run: |
-          if [ -z "${E2E_MINIMAX_API_KEY:-}" ] && [ -z "${E2E_ANTHROPIC_API_KEY:-}" ] && [ -z "${E2E_OPENAI_API_KEY:-}" ]; then
-            echo "::error::No LLM provider key set — workspaces fail at boot with 'No provider API key found'. Set MOLECULE_STAGING_MINIMAX_API_KEY (or ANTHROPIC / OPENAI)."
-            exit 2
-          fi
-          echo "LLM key present"
-
-      - name: CP staging health preflight
-        run: |
-          code=$(curl -sS -o /dev/null -w "%{http_code}" --max-time 10 "$MOLECULE_CP_URL/health")
-          if [ "$code" != "200" ]; then
-            echo "::error::Staging CP unhealthy (HTTP $code) — infra, not a workspace bug. Failing loud per feedback_fix_root_not_symptom."
-            exit 1
-          fi
-          echo "Staging CP healthy"
-
-      - name: Run fresh-provision peer-visibility E2E (literal MCP list_peers)
-        run: bash tests/e2e/test_peer_visibility_mcp_staging.sh
-
-      # Belt-and-braces scoped teardown: the script installs an EXIT/INT/
-      # TERM trap, but if the runner itself is cancelled the trap may not
-      # fire. This always() step deletes ONLY the e2e-pv-<run_id> org this
-      # run created — never a cluster-wide sweep
-      # (feedback_never_run_cluster_cleanup_tests_on_live_platform). The
-      # admin DELETE is idempotent so double-invoking is safe;
-      # sweep-stale-e2e-orgs is the final net (slug starts with 'e2e-').
-      - name: Teardown safety net (runs on cancel/failure)
-        if: always()
-        env:
-          ADMIN_TOKEN: ${{ secrets.CP_STAGING_ADMIN_API_TOKEN }}
-        run: |
-          set +e
-          orgs=$(curl -sS "$MOLECULE_CP_URL/cp/admin/orgs?limit=500" \
-            -H "Authorization: Bearer $ADMIN_TOKEN" 2>/dev/null \
-            | python3 -c "
-          import json, sys, os, datetime
-          run_id = os.environ.get('GITHUB_RUN_ID', '')
-          try:
-              d = json.load(sys.stdin)
-          except Exception:
-              print(''); sys.exit(0)
-          # ONLY sweep slugs from THIS run. e2e-pv-<YYYYMMDD>-<run_id>-...
-          # Sweep today AND yesterday's UTC date so a midnight-crossing run
-          # still matches its own slug (same bug class as the saas/canvas
-          # safety nets).
-          today = datetime.date.today()
-          yest = today - datetime.timedelta(days=1)
-          dates = (today.strftime('%Y%m%d'), yest.strftime('%Y%m%d'))
-          if run_id:
-              prefixes = tuple(f'e2e-pv-{dt}-{run_id}-' for dt in dates)
-          else:
-              prefixes = tuple(f'e2e-pv-{dt}-' for dt in dates)
-          orgs = d if isinstance(d, list) else d.get('orgs', [])
-          cands = [o['slug'] for o in orgs
-                   if any(o.get('slug','').startswith(p) for p in prefixes)
-                   and o.get('instance_status') not in ('purged',)]
-          print('\n'.join(cands))
-          " 2>/dev/null)
-          for slug in $orgs; do
-            echo "Safety-net teardown: $slug"
-            set +e
-            curl -sS -o /tmp/pv-cleanup.out -w "%{http_code}" \
-              -X DELETE "$MOLECULE_CP_URL/cp/admin/tenants/$slug" \
-              -H "Authorization: Bearer $ADMIN_TOKEN" \
-              -H "Content-Type: application/json" \
-              -d "{\"confirm\":\"$slug\"}" >/tmp/pv-cleanup.code
-            set -e
-            code=$(cat /tmp/pv-cleanup.code 2>/dev/null || echo "000")
-            if [ "$code" = "200" ] || [ "$code" = "204" ]; then
-              echo "[teardown] deleted $slug (HTTP $code)"
-            else
-              echo "::warning::pv teardown for $slug returned HTTP $code — sweep-stale-e2e-orgs will catch it within MAX_AGE_MINUTES. Body: $(head -c 300 /tmp/pv-cleanup.out 2>/dev/null)"
-            fi
-          done
-          exit 0

.gitea/workflows/gate-check-v3.yml

@@ -83,41 +83,25 @@ jobs:
           REPO: ${{ github.repository }}
         run: |
           set -euo pipefail
-          # Fetch all open PRs and run gate-check on each. This scheduled
-          # refresher is advisory; a transient Gitea list timeout must not turn
-          # main red. PR-specific gate-check runs still use normal failure
-          # semantics.
+          # Fetch all open PRs and run gate-check on each
+          # socket.setdefaulttimeout(15): defence-in-depth for missing SOP_TIER_CHECK_TOKEN.
+          # gate_check.py uses timeout=15 on every urlopen call; this catches the
+          # inline Python polling loop too (issue #603).
           pr_numbers=$(python3 <<'PY'
           import json
           import os
           import socket
-          import sys
-          import time
-          import urllib.error
           import urllib.request
 
-          socket.setdefaulttimeout(30)
+          socket.setdefaulttimeout(15)
           token = os.environ["GITEA_TOKEN"]
           repo = os.environ["REPO"]
-          url = f"https://git.moleculesai.app/api/v1/repos/{repo}/pulls?state=open&limit=100"
-          last_error = None
-          for attempt in range(1, 4):
-              req = urllib.request.Request(
-                  url,
-                  headers={"Authorization": f"token {token}", "Accept": "application/json"},
-              )
-              try:
-                  with urllib.request.urlopen(req, timeout=30) as r:
-                      prs = json.loads(r.read())
-                  break
-              except (TimeoutError, OSError, urllib.error.URLError, urllib.error.HTTPError) as exc:
-                  last_error = exc
-                  print(f"warning: PR list fetch attempt {attempt}/3 failed: {exc}", file=sys.stderr)
-                  if attempt < 3:
-                      time.sleep(2 * attempt)
-          else:
-              print(f"warning: skipped scheduled gate-check refresh; failed to list open PRs after 3 attempts: {last_error}", file=sys.stderr)
-              raise SystemExit(0)
+          req = urllib.request.Request(
+              f"https://git.moleculesai.app/api/v1/repos/{repo}/pulls?state=open&limit=100",
+              headers={"Authorization": f"token {token}", "Accept": "application/json"},
+          )
+          with urllib.request.urlopen(req) as r:
+              prs = json.loads(r.read())
           for pr in prs:
               print(pr["number"])
           PY

.gitea/workflows/handlers-postgres-integration.yml

@@ -86,11 +86,7 @@ jobs:
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
-          # A full-history checkout can exceed the runner's quiet/startup
-          # window before the path filter emits logs. Fetch the common push
-          # case cheaply; the script below fetches the exact BASE SHA if it is
-          # not present in the shallow checkout.
-          fetch-depth: 2
+          fetch-depth: 0
       - id: filter
         # Inline replacement for dorny/paths-filter — see e2e-api.yml.
         run: |

.gitea/workflows/lint-continue-on-error-tracking.yml

@@ -93,7 +93,7 @@ jobs:
   lint:
     name: lint-continue-on-error-tracking
     runs-on: ubuntu-latest
-    timeout-minutes: 20
+    timeout-minutes: 10
     # Phase 3 (RFC #219 §1): surface masked defects without blocking
     # PRs. Pre-existing continue-on-error: true directives on main
     # all violate this lint at first — intentional. Flip to false

.gitea/workflows/publish-canvas-image.yml

@@ -49,17 +49,13 @@ jobs:
   # bp-exempt: post-merge image publication side effect; CI / all-required gates source changes.
   build-and-push:
     name: Build & push canvas image
-    # Dedicated publish/release lane (internal#462 / #394 / #399). Ship
-    # path (on: push:main, canvas/**) — reserved capacity so a merged
-    # canvas fix's image build never FIFO-queues behind PR required-CI.
-    # The `publish` label resolves ONLY to the molecule-runner-publish-*
-    # sub-pool (config.publish.yaml). HARD DEPENDENCY: this MUST land
-    # AFTER the publish-lane runners are registered/advertising `publish`
-    # — the earlier #599 `docker` label attempt queued indefinitely with
-    # zero eligible runners precisely because the label was targeted
-    # before any runner advertised it (see #576). The lane is registered
-    # in this rollout (internal#462) so the precondition holds.
-    runs-on: publish
+    # REVERTED (infra/revert-docker-runner-label): `runs-on: ubuntu-latest` restored.
+    # The `docker` label is not registered on any act_runner. `runs-on: [ubuntu-latest, docker]`
+    # causes jobs to queue indefinitely with zero eligible runners — strictly worse than the
+    # pre-#599 coin-flip (50% success rate). Once the `docker` label is registered on
+    # ≥2 runners, re-apply the fix from #599 (infra/docker-runner-label).
+    # See issue #576 + infra-lead pulse ~00:30Z.
+    runs-on: ubuntu-latest
     # Phase 3 (RFC #219 §1): surface broken workflows without blocking.
     # mc#774: pre-existing continue-on-error mask; root-fix and remove, do not renew silently.
     continue-on-error: true

.gitea/workflows/publish-runtime.yml

@@ -66,10 +66,7 @@ concurrency:
 
 jobs:
   publish:
-    # Dedicated publish/release lane (internal#462 / #394 / #399). Ship
-    # path (on: push tag runtime-v*) — reserved capacity, never FIFO
-    # behind PR-CI. `publish` resolves only to molecule-runner-publish-*.
-    runs-on: publish
+    runs-on: ubuntu-latest
     outputs:
       version: ${{ steps.version.outputs.version }}
       wheel_sha256: ${{ steps.wheel_hash.outputs.wheel_sha256 }}
@@ -162,7 +159,6 @@ jobs:
             exit 1
           fi
           python -m twine upload \
-            --verbose \
             --repository pypi \
             --username __token__ \
             --password "$PYPI_TOKEN" \
@@ -170,9 +166,7 @@ jobs:
 
   cascade:
     needs: publish
-    # Publish/release lane (internal#462) — downstream of the runtime
-    # publish ship job; keep it on the reserved lane too.
-    runs-on: publish
+    runs-on: ubuntu-latest
     steps:
       - name: Wait for PyPI to propagate the new version
         env:

.gitea/workflows/publish-workspace-server-image.yml

@@ -54,14 +54,7 @@ env:
 
 jobs:
   build-and-push:
-    # Dedicated publish/release lane (internal#462 / #394 / #399). This
-    # is a post-merge ship job (on: push:main) — it must NOT FIFO-compete
-    # with PR required-CI on the shared pool (PR#1350's prod image build
-    # was delayed ~25min this way). The `publish` label resolves ONLY to
-    # the reserved molecule-runner-publish-* sub-pool (config.publish.yaml,
-    # OUTSIDE the managed 1..20 range) so a merged fix's image build
-    # starts immediately while PR-CI keeps the general pool.
-    runs-on: publish
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
@@ -188,9 +181,7 @@ jobs:
     name: Production auto-deploy
     needs: build-and-push
     if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }}
-    # Publish/release lane (internal#462) — production deploy of a merged
-    # fix; reserved capacity, never queued behind PR-CI.
-    runs-on: publish
+    runs-on: ubuntu-latest
     timeout-minutes: 75
     env:
       CP_URL: ${{ vars.PROD_CP_URL || 'https://api.moleculesai.app' }}

.gitea/workflows/redeploy-tenants-on-main.yml

@@ -68,10 +68,7 @@ jobs:
   # bp-exempt: production redeploy is a side-effect workflow, not a merge gate.
   redeploy:
     if: ${{ github.event_name == 'workflow_dispatch' }}
-    # Dedicated publish/release lane (internal#462 / #394 / #399).
-    # Production tenant redeploy — a deploy action, reserved capacity so
-    # it never queues behind PR-CI. `publish` -> molecule-runner-publish-*.
-    runs-on: publish
+    runs-on: ubuntu-latest
     # Phase 3 (RFC #219 §1): surface broken workflows without blocking.
     # mc#774: pre-existing continue-on-error mask; root-fix and remove, do not renew silently.
     continue-on-error: true

.gitea/workflows/redeploy-tenants-on-staging.yml

@@ -75,10 +75,7 @@ env:
 jobs:
   # bp-exempt: post-merge staging redeploy side effect; CI / all-required gates source changes.
   redeploy:
-    # Dedicated publish/release lane (internal#462 / #394 / #399).
-    # Post-merge staging redeploy — a deploy action, reserved capacity.
-    # `publish` -> molecule-runner-publish-* sub-pool.
-    runs-on: publish
+    runs-on: ubuntu-latest
     # Phase 3 (RFC #219 §1): surface broken workflows without blocking.
     # mc#774: pre-existing continue-on-error mask; root-fix and remove, do not renew silently.
     continue-on-error: true

.gitea/workflows/review-refire-comments.yml

@@ -18,10 +18,6 @@ permissions:
   pull-requests: read
   statuses: write
 
-concurrency:
-  group: ${{ github.repository }}-${{ github.workflow }}-${{ github.event.issue.number || github.ref }}
-  cancel-in-progress: true
-
 jobs:
   dispatch:
     runs-on: ubuntu-latest

.gitea/workflows/sop-checklist.yml

@@ -70,7 +70,7 @@ name: sop-checklist
 # Cancel any in-progress runs for the same PR to prevent
 # stale runs from overwriting newer status contexts.
 concurrency:
-  group: ${{ github.repository }}-${{ github.workflow }}-${{ github.event.pull_request.number || github.event.issue.number || github.ref }}
+  group: ${{ github.repository }}-${{ github.event.pull_request.number }}
   cancel-in-progress: true
 
 # bp-required: yes  ← emits sop-checklist / all-items-acked (pull_request)

.gitea/workflows/sop-tier-check.yml

@@ -61,10 +61,6 @@ on:
   pull_request_review:
     types: [submitted, dismissed, edited]
 
-concurrency:
-  group: ${{ github.repository }}-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
 jobs:
   tier-check:
     runs-on: ubuntu-latest

canvas/e2e/chat-desktop.spec.ts

@@ -1,173 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { startEchoRuntime } from "./fixtures/echo-runtime";
-import { seedWorkspace, startHeartbeat, cleanupWorkspace } from "./fixtures/chat-seed";
-
-
-test.describe("Desktop ChatTab", () => {
-  let cleanup: () => Promise<void> = async () => {};
-  let workspaceId = "";
-  let workspaceName = "";
-
-  test.beforeAll(async () => {
-    const echo = await startEchoRuntime();
-    const ws = await seedWorkspace(echo.baseURL);
-    workspaceId = ws.id;
-    workspaceName = ws.name;
-    const stopHeartbeat = startHeartbeat(ws.id, ws.authToken);
-
-    cleanup = async () => {
-      stopHeartbeat();
-      await echo.stop();
-    };
-  });
-
-  test.afterAll(async () => {
-    await cleanupWorkspace(workspaceId);
-    await cleanup();
-  });
-
-  test.beforeEach(async ({ page }) => {
-    await page.setViewportSize({ width: 1280, height: 800 });
-    await page.goto("/");
-    await page.waitForSelector(".react-flow__node", { timeout: 10_000 });
-    // Dismiss onboarding guide if present.
-    const skipGuide = page.getByText("Skip guide");
-    if (await skipGuide.isVisible().catch(() => false)) {
-      await skipGuide.click();
-    }
-    // Click the workspace node by its exact name label.
-    await page.getByText(workspaceName, { exact: true }).first().click();
-    // Wait for the side panel chat tab to be clickable, then click it.
-    await page.locator('#tab-chat').click();
-    await page.waitForSelector("[data-testid='chat-panel']", { timeout: 5_000 });
-    // Wait for the workspace status to flip to online and the textarea to be enabled.
-    await expect(page.locator("textarea").first()).toBeEnabled({ timeout: 15_000 });
-  });
-
-  test("chat panel loads without error", async ({ page }) => {
-    const hasEmptyState = await page.getByText("Send a message to start chatting.").isVisible().catch(() => false);
-    const hasHistory = await page.locator("[data-testid='chat-panel']").locator("div").count() > 3;
-    expect(hasEmptyState || hasHistory).toBeTruthy();
-  });
-
-  test("send text message and receive echo response", async ({ page }) => {
-    const textarea = page.locator("textarea").first();
-    await textarea.fill("What is the weather?");
-    await page.getByRole("button", { name: /Send/ }).first().click();
-
-    await expect(page.getByText("What is the weather?")).toBeVisible({ timeout: 5_000 });
-    await expect(page.getByText("Echo: What is the weather?")).toBeVisible({ timeout: 15_000 });
-  });
-
-  test("history persists across reload", async ({ page }) => {
-    const textarea = page.locator("textarea").first();
-    await textarea.fill("Persistence test");
-    await page.getByRole("button", { name: /Send/ }).first().click();
-
-    await expect(page.getByText("Echo: Persistence test")).toBeVisible({ timeout: 15_000 });
-
-    await page.reload();
-    await page.waitForSelector(".react-flow__node", { timeout: 10_000 });
-    await page.getByText(workspaceName, { exact: true }).first().click();
-    await page.locator('#tab-chat').click();
-    await page.waitForSelector("[data-testid='chat-panel']", { timeout: 5_000 });
-    // Wait for the workspace status to flip to online and the textarea to be enabled.
-    await expect(page.locator("textarea").first()).toBeEnabled({ timeout: 15_000 });
-
-    await expect(page.getByText("Persistence test", { exact: true })).toBeVisible({ timeout: 5_000 });
-    await expect(page.getByText("Echo: Persistence test")).toBeVisible({ timeout: 5_000 });
-  });
-
-  test("file attachment round-trip", async ({ page }) => {
-    const textarea = page.locator("textarea").first();
-    await textarea.fill("Please read this file");
-
-    const fileInput = page.locator("[data-testid='chat-panel'] input[type='file']").first();
-    await fileInput.setInputFiles({
-      name: "test.txt",
-      mimeType: "text/plain",
-      buffer: Buffer.from("secret content abc123"),
-    });
-
-    await expect(page.getByText("test.txt")).toBeVisible({ timeout: 3_000 });
-
-    await page.getByRole("button", { name: /Send/ }).first().click();
-
-    await expect(page.getByText("Echo: Please read this file")).toBeVisible({ timeout: 15_000 });
-  });
-
-  test("activity log appears during send", async ({ page }) => {
-    const textarea = page.locator("textarea").first();
-    await textarea.fill("Trigger activity");
-    await page.getByRole("button", { name: /Send/ }).first().click();
-
-    // Activity log container should appear during the send flow.
-    await expect(page.locator("[data-testid='activity-log']").first()).toBeVisible({ timeout: 10_000 }).catch(() => {
-      // Activity log may not be present in all layouts.
-    });
-  });
-});
-
-test.describe("Desktop ChatTab — Markdown rendering", () => {
-  let cleanup: () => Promise<void> = async () => {};
-  let workspaceId = "";
-  let workspaceName = "";
-
-  test.beforeAll(async () => {
-    const echo = await startEchoRuntime();
-    const ws = await seedWorkspace(echo.baseURL);
-    workspaceId = ws.id;
-    workspaceName = ws.name;
-    const stopHeartbeat = startHeartbeat(ws.id, ws.authToken);
-
-    cleanup = async () => {
-      stopHeartbeat();
-      await echo.stop();
-    };
-  });
-
-  test.afterAll(async () => {
-    await cleanupWorkspace(workspaceId);
-    await cleanup();
-  });
-
-  test.beforeEach(async ({ page }) => {
-    await page.setViewportSize({ width: 1280, height: 800 });
-    await page.goto("/");
-    await page.waitForSelector(".react-flow__node", { timeout: 10_000 });
-    const skipGuide2 = page.getByText("Skip guide");
-    if (await skipGuide2.isVisible().catch(() => false)) {
-      await skipGuide2.click();
-    }
-    await page.getByText(workspaceName, { exact: true }).first().click();
-    await page.locator('#tab-chat').click();
-    await page.waitForSelector("[data-testid='chat-panel']", { timeout: 5_000 });
-    // Wait for the workspace status to flip to online and the textarea to be enabled.
-    await expect(page.locator("textarea").first()).toBeEnabled({ timeout: 15_000 });
-  });
-
-  test("code block renders <pre>", async ({ page }) => {
-    const textarea = page.locator("textarea").first();
-    await textarea.fill("```js\nconst x = 1;\n```");
-    await page.getByRole("button", { name: /Send/ }).first().click();
-
-    await expect(page.getByText("Echo: ```js")).toBeVisible({ timeout: 15_000 });
-
-    const pre = page.locator("pre").first();
-    await expect(pre).toBeVisible({ timeout: 5_000 });
-    await expect(pre).toContainText("const x = 1;");
-  });
-
-  test("table renders <table>", async ({ page }) => {
-    const textarea = page.locator("textarea").first();
-    await textarea.fill("| A | B |\n|---|---|\n| 1 | 2 |");
-    await page.getByRole("button", { name: /Send/ }).first().click();
-
-    await expect(page.getByText("Echo: | A | B |")).toBeVisible({ timeout: 15_000 });
-
-    const table = page.locator("table").first();
-    await expect(table).toBeVisible({ timeout: 5_000 });
-    await expect(table).toContainText("A");
-    await expect(table).toContainText("1");
-  });
-});

canvas/e2e/chat-mobile.spec.ts

@@ -1,97 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { startEchoRuntime } from "./fixtures/echo-runtime";
-import { seedWorkspace, startHeartbeat, cleanupWorkspace } from "./fixtures/chat-seed";
-
-
-test.describe("MobileChat", () => {
-  let cleanup: () => Promise<void> = async () => {};
-  let workspaceId = "";
-
-  test.beforeAll(async () => {
-    const echo = await startEchoRuntime();
-    const ws = await seedWorkspace(echo.baseURL);
-    workspaceId = ws.id;
-    const stopHeartbeat = startHeartbeat(ws.id, ws.authToken);
-
-    cleanup = async () => {
-      stopHeartbeat();
-      await echo.stop();
-    };
-  });
-
-  test.afterAll(async () => {
-    await cleanupWorkspace(workspaceId);
-    await cleanup();
-  });
-
-  test.beforeEach(async ({ page }) => {
-    await page.setViewportSize({ width: 375, height: 812 });
-    // Navigate directly to the mobile chat view.
-    await page.goto(`/?m=chat&a=${workspaceId}`);
-    await page.waitForSelector("[data-testid='chat-panel']", { timeout: 10_000 });
-    // Wait for the workspace status to flip to online and the textarea to be enabled.
-    await expect(page.locator("textarea").first()).toBeEnabled({ timeout: 15_000 });
-    // Dismiss onboarding guide if present.
-    const skipGuide = page.getByText("Skip guide");
-    if (await skipGuide.isVisible().catch(() => false)) {
-      await skipGuide.click();
-    }
-  });
-
-  test("chat panel loads without error", async ({ page }) => {
-    const hasEmptyState = await page.getByText("Send a message to start chatting.").isVisible().catch(() => false);
-    const hasHistory = await page.locator("[data-testid='chat-panel']").locator("div").count() > 3;
-    expect(hasEmptyState || hasHistory).toBeTruthy();
-  });
-
-  test("send text message and receive echo response", async ({ page }) => {
-    const textarea = page.locator("textarea").first();
-    await textarea.fill("Mobile test message");
-    await page.getByRole("button", { name: /Send/ }).first().click();
-
-    await expect(page.getByText("Mobile test message")).toBeVisible({ timeout: 5_000 });
-    await expect(page.getByText("Echo: Mobile test message")).toBeVisible({ timeout: 15_000 });
-  });
-
-  test("history persists across reload", async ({ page }) => {
-    const textarea = page.locator("textarea").first();
-    await textarea.fill("Mobile persistence");
-    await page.getByRole("button", { name: /Send/ }).first().click();
-
-    await expect(page.getByText("Echo: Mobile persistence")).toBeVisible({ timeout: 15_000 });
-
-    await page.reload();
-    await page.waitForSelector("[data-testid='chat-panel']", { timeout: 10_000 });
-
-    await expect(page.getByText("Mobile persistence", { exact: true })).toBeVisible({ timeout: 5_000 });
-    await expect(page.getByText("Echo: Mobile persistence")).toBeVisible({ timeout: 5_000 });
-  });
-
-  test("composer auto-grows with multi-line text", async ({ page }) => {
-    const textarea = page.locator("textarea").first();
-    const initialHeight = await textarea.evaluate((el: HTMLElement) => el.offsetHeight);
-
-    await textarea.fill("Line 1\nLine 2\nLine 3\nLine 4\nLine 5");
-    await page.waitForTimeout(300);
-
-    const grownHeight = await textarea.evaluate((el: HTMLElement) => el.offsetHeight);
-    expect(grownHeight).toBeGreaterThan(initialHeight);
-  });
-
-  test("file attachment in mobile chat", async ({ page }) => {
-    const textarea = page.locator("textarea").first();
-    await textarea.fill("Mobile file test");
-
-    const fileInput = page.locator("[data-testid='chat-panel'] input[type='file']").first();
-    await fileInput.setInputFiles({
-      name: "mobile.txt",
-      mimeType: "text/plain",
-      buffer: Buffer.from("mobile secret"),
-    });
-
-    await expect(page.getByText("mobile.txt")).toBeVisible({ timeout: 3_000 });
-
-    await page.getByRole("button", { name: /Send/ }).first().click();
-    await expect(page.getByText("Echo: Mobile file test")).toBeVisible({ timeout: 15_000 });
-  });
-});

canvas/e2e/fixtures/chat-seed.ts

@@ -1,187 +0,0 @@
-/**
- * E2E seed fixture for chat tests.
- *
- * Creates an external workspace via the workspace-server API, extracts the
- * auto-minted auth token, then overrides the DB row so it appears "online"
- * with an echo-runtime URL.  External runtime is used because the health
- * sweep skips Docker checks for external workspaces; we keep the workspace
- * alive with periodic heartbeats.
- */
-
-import { randomUUID } from "node:crypto";
-
-const PLATFORM_URL = process.env.E2E_PLATFORM_URL ?? "http://localhost:8080";
-
-export interface SeededWorkspace {
-  id: string;
-  name: string;
-  agentURL: string;
-  authToken: string;
-}
-
-/**
- * Create an external workspace and wire it to the echo runtime.
- */
-export async function seedWorkspace(echoURL: string): Promise<SeededWorkspace> {
-  // 1. Create external workspace (no URL — platform will mint an auth token).
-  const runId = Math.random().toString(36).slice(2, 8);
-  const wsName = `Chat E2E Agent ${runId}`;
-  const createRes = await fetch(`${PLATFORM_URL}/workspaces`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ name: wsName, tier: 1, external: true, runtime: "external" }),
-  });
-  if (!createRes.ok) {
-    const text = await createRes.text();
-    throw new Error(`Failed to create workspace: ${createRes.status} ${text}`);
-  }
-  const ws = (await createRes.json()) as {
-    id: string;
-    name: string;
-    connection?: { auth_token?: string };
-  };
-  const authToken = ws.connection?.auth_token;
-  if (!authToken) {
-    throw new Error("Workspace created but no auth_token returned");
-  }
-
-  // 2. Direct DB update: mark online + point url at echo runtime.
-  //    The platform blocks loopback URLs at the API layer (SSRF guard),
-  //    so we bypass via psql for local E2E.
-  const dbUrl = process.env.E2E_DATABASE_URL;
-  if (!dbUrl) {
-    throw new Error("E2E_DATABASE_URL must be set for DB seeding");
-  }
-  const pgRegex = /postgres:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/([^?]+)/;
-  const m = dbUrl.match(pgRegex);
-  if (!m) {
-    throw new Error(`Cannot parse E2E_DATABASE_URL: ${dbUrl}`);
-  }
-  const [, user, pass, host, port, db] = m;
-
-  // Pre-seed a platform_inbound_secret so chat file uploads don't trigger
-  // the lazy-heal 503 "retry in 30 s" path on first use.
-  const inboundSecret = Array.from({ length: 43 }, () =>
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"[
-      Math.floor(Math.random() * 64)
-    ],
-  ).join("");
-
-  const psql = [
-    `PGPASSWORD=${pass} psql`,
-    `-h ${host} -p ${port} -U ${user} -d ${db}`,
-    `-c "UPDATE workspaces SET status = 'online', url = '${echoURL}', platform_inbound_secret = '${inboundSecret}' WHERE id = '${ws.id}'"`,
-  ].join(" ");
-
-  const { execSync } = await import("node:child_process");
-  try {
-    execSync(psql, { stdio: "pipe", timeout: 30_000 });
-  } catch (err) {
-    throw new Error(`DB update failed: ${err}`);
-  }
-
-  return { id: ws.id, name: wsName, agentURL: echoURL, authToken };
-}
-
-/**
- * Start a heartbeat interval that keeps an external workspace alive.
- * Returns a stop function.
- */
-export function startHeartbeat(
-  workspaceId: string,
-  authToken: string,
-  intervalMs = 30_000,
-): () => void {
-  const send = () => {
-    fetch(`${PLATFORM_URL}/registry/heartbeat`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${authToken}`,
-      },
-      body: JSON.stringify({
-        workspace_id: workspaceId,
-        error_rate: 0,
-        sample_error: "",
-        active_tasks: 0,
-        current_task: "",
-        uptime_seconds: 0,
-      }),
-    }).catch(() => {});
-  };
-
-  // Send immediately so the first heartbeat lands before the stale sweep.
-  send();
-  const timer = setInterval(send, intervalMs);
-
-  return () => clearInterval(timer);
-}
-
-/**
- * Seed chat-history rows for a workspace.
- */
-export async function seedChatHistory(
-  workspaceId: string,
-  messages: Array<{ role: "user" | "agent"; content: string }>,
-): Promise<void> {
-  const dbUrl = process.env.E2E_DATABASE_URL;
-  if (!dbUrl) return;
-
-  const pgRegex = /postgres:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/([^?]+)/;
-  const m = dbUrl.match(pgRegex);
-  if (!m) return;
-  const [, user, pass, host, port, db] = m;
-
-  const values = messages
-    .map(
-      (msg, i) =>
-        `('${randomUUID()}', '${workspaceId}', '${msg.role}', '${msg.content.replace(/'/g, "''")}', NOW() - INTERVAL '${messages.length - i} seconds')`,
-    )
-    .join(",");
-
-  const sql = `INSERT INTO chat_messages (id, workspace_id, role, content, created_at) VALUES ${values};`;
-
-  const { execSync } = await import("node:child_process");
-  const psql = `PGPASSWORD=${pass} psql -h ${host} -p ${port} -U ${user} -d ${db} -c "${sql}"`;
-  execSync(psql, { stdio: "pipe", timeout: 10_000 });
-}
-
-/**
- * Delete a seeded workspace row directly from the DB.
- * Uses psql (same credentials as seedWorkspace) so we bypass any
- * workspace-server side-effects (container stop, cascade cleanup, etc.)
- * that can race or 500 on external workspaces.
- */
-export async function cleanupWorkspace(workspaceId: string): Promise<void> {
-  const dbUrl = process.env.E2E_DATABASE_URL;
-  if (!dbUrl) return;
-
-  const pgRegex = /postgres:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/([^?]+)/;
-  const m = dbUrl.match(pgRegex);
-  if (!m) return;
-  const [, user, pass, host, port, db] = m;
-
-  const psql = `PGPASSWORD=${pass} psql -h ${host} -p ${port} -U ${user} -d ${db} -c "DELETE FROM workspaces WHERE id = '${workspaceId}'"`;
-
-  const { execSync } = await import("node:child_process");
-  try {
-    execSync(psql, { stdio: "pipe", timeout: 30_000 });
-  } catch {
-    // Best-effort cleanup; don't fail the test suite if the row is already gone.
-  }
-}
-
-/**
- * Mint a workspace auth token so the canvas can make authenticated API
- * calls (WorkspaceAuth middleware).
- */
-export async function mintTestToken(workspaceId: string): Promise<string> {
-  const res = await fetch(
-    `${PLATFORM_URL}/admin/workspaces/${workspaceId}/test-token`,
-  );
-  if (!res.ok) {
-    throw new Error(`Failed to mint test token: ${res.status}`);
-  }
-  const data = (await res.json()) as { auth_token: string };
-  return data.auth_token;
-}

canvas/e2e/fixtures/echo-runtime.ts

@@ -1,180 +0,0 @@
-/**
- * Minimal A2A echo runtime for E2E tests.
- *
- * Listens on an ephemeral port, receives A2A JSON-RPC `message/send`
- * requests, and returns a response with the original text echoed back.
- * Also implements the workspace-side chat upload ingest endpoint so
- * file-attachment E2E can exercise the full upload → send → echo
- * round-trip.
- *
- * Usage (inside test fixture):
- *   const echo = await startEchoRuntime();
- *   // ... seed workspace with agent_url pointing to echo.baseURL ...
- *   echo.stop();
- */
-
-import { createServer, type Server } from "node:http";
-
-export interface EchoRuntime {
-  baseURL: string;
-  stop: () => Promise<void>;
-  lastRequest: { method: string; text: string; files: unknown[] } | null;
-}
-
-/** Parse a minimal multipart body and extract the first file's name + content. */
-function parseMultipart(body: Buffer): { name: string; mimeType: string; content: Buffer } | null {
-  // Find the boundary line (first line starting with "--").
-  const str = body.toString("binary");
-  const firstDash = str.indexOf("--");
-  if (firstDash === -1) return null;
-  const eol = str.indexOf("\r\n", firstDash);
-  if (eol === -1) return null;
-  const boundary = str.slice(firstDash + 2, eol);
-  const boundaryMarker = "\r\n--" + boundary;
-
-  // Find the first part that has a filename in Content-Disposition.
-  let pos = eol + 2;
-  while (pos < str.length) {
-    const nextBoundary = str.indexOf(boundaryMarker, pos);
-    if (nextBoundary === -1) break;
-    const part = str.slice(pos, nextBoundary);
-
-    const cdMatch = part.match(/Content-Disposition:[^\r\n]*filename="([^"]+)"/i);
-    if (cdMatch) {
-      const name = cdMatch[1];
-      const ctMatch = part.match(/Content-Type:\s*([^\r\n]+)/i);
-      const mimeType = ctMatch ? ctMatch[1].trim() : "application/octet-stream";
-      // Body starts after the first double-CRLF in the part.
-      const bodyStart = part.indexOf("\r\n\r\n");
-      if (bodyStart !== -1) {
-        // Extract the raw bytes (not the string) so binary is safe.
-        const headerBytes = Buffer.byteLength(part.slice(0, bodyStart + 4), "binary");
-        const partStartInBody = Buffer.byteLength(str.slice(0, pos + bodyStart + 4), "binary");
-        const partEndInBody = Buffer.byteLength(str.slice(0, nextBoundary), "binary");
-        const content = body.subarray(partStartInBody, partEndInBody);
-        return { name, mimeType, content };
-      }
-    }
-    pos = nextBoundary + boundaryMarker.length;
-    // Skip trailing "--" (end marker) or CRLF.
-    if (str.slice(pos, pos + 2) === "--") break;
-    if (str.slice(pos, pos + 2) === "\r\n") pos += 2;
-  }
-  return null;
-}
-
-export async function startEchoRuntime(): Promise<EchoRuntime> {
-  let lastRequest: EchoRuntime["lastRequest"] = null;
-
-  const server = createServer((req, res) => {
-    // CORS: allow the canvas origin (localhost:3000) to call us.
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
-
-    if (req.method === "OPTIONS") {
-      res.writeHead(204);
-      res.end();
-      return;
-    }
-
-    const url = req.url ?? "/";
-
-    // Workspace-side chat upload ingest (RFC #2312).
-    if (url === "/internal/chat/uploads/ingest" && req.method === "POST") {
-      const chunks: Buffer[] = [];
-      req.on("data", (chunk: Buffer) => chunks.push(chunk));
-      req.on("end", () => {
-        const body = Buffer.concat(chunks);
-        const file = parseMultipart(body);
-        if (!file) {
-          res.writeHead(400);
-          res.end(JSON.stringify({ error: "no files field" }));
-          return;
-        }
-        const sanitized = file.name.replace(/[^a-zA-Z0-9._\-]/g, "_").replace(/ /g, "_");
-        const prefix = Array.from({ length: 32 }, () =>
-          Math.floor(Math.random() * 16).toString(16),
-        ).join("");
-        const response = {
-          files: [
-            {
-              uri: `workspace:/workspace/.molecule/chat-uploads/${prefix}-${sanitized}`,
-              name: sanitized,
-              mimeType: file.mimeType,
-              size: file.content.length,
-            },
-          ],
-        };
-        res.setHeader("Content-Type", "application/json");
-        res.writeHead(200);
-        res.end(JSON.stringify(response));
-      });
-      return;
-    }
-
-    // Default: A2A JSON-RPC handler.
-    let body = "";
-    req.setEncoding("utf8");
-    req.on("data", (chunk: string) => {
-      body += chunk;
-    });
-    req.on("end", () => {
-      res.setHeader("Content-Type", "application/json");
-      try {
-        const rpc = JSON.parse(body);
-        const msg = rpc.params?.message;
-        const textParts =
-          msg?.parts
-            ?.filter((p: { kind?: string; text?: string }) => p.kind === "text")
-            .map((p: { text?: string }) => p.text)
-            .filter(Boolean) ?? [];
-        const fileParts =
-          msg?.parts?.filter((p: { kind?: string }) => p.kind === "file") ?? [];
-        const text = textParts.join("\n");
-
-        lastRequest = {
-          method: rpc.method ?? "unknown",
-          text,
-          files: fileParts,
-        };
-
-        const replyText = text
-          ? `Echo: ${text}`
-          : fileParts.length > 0
-            ? "Echo: received your file(s)."
-            : "Echo: hello";
-
-        const response = {
-          jsonrpc: "2.0",
-          id: rpc.id ?? null,
-          result: {
-            parts: [{ kind: "text", text: replyText }],
-          },
-        };
-
-        res.writeHead(200);
-        res.end(JSON.stringify(response));
-      } catch {
-        res.writeHead(400);
-        res.end(JSON.stringify({ error: "invalid json" }));
-      }
-    });
-  });
-
-  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
-  const address = server.address();
-  const port = typeof address === "object" && address ? address.port : 0;
-  const baseURL = `http://127.0.0.1:${port}`;
-
-  return {
-    baseURL,
-    stop: () =>
-      new Promise((resolve) => {
-        server.close(() => resolve(undefined));
-      }),
-    get lastRequest() {
-      return lastRequest;
-    },
-  };
-}

canvas/playwright.config.ts

@@ -5,10 +5,9 @@ export default defineConfig({
   timeout: 30_000,
   expect: { timeout: 10_000 },
   fullyParallel: false,
-  workers: 1,
   retries: 0,
   use: {
-    baseURL: process.env.PLAYWRIGHT_BASE_URL || "http://localhost:3000",
+    baseURL: "http://localhost:3000",
     headless: true,
     screenshot: "only-on-failure",
   },

canvas/src/components/ThemeToggle.tsx

@@ -62,12 +62,21 @@ export function ThemeToggle({ className = "" }: { className?: string }) {
       }
       setTheme(OPTIONS[next].value);
       // Move focus to the new button so arrow-key navigation is continuous.
-      // Query is already scoped to radiogroup so no child-combinator needed;
-      // avoids accidentally focusing unrelated [role=radio] elements
+      // Use direct-child query to scope strictly to this radiogroup's buttons
+      // and avoid accidentally focusing unrelated [role=radio] elements
       // elsewhere in the DOM (e.g. React Flow canvas nodes).
+      // Guard: skip focus if the current target is no longer in the document
+      // (e.g. React StrictMode double-invokes handlers during re-render).
+      if (!e.currentTarget.isConnected) return;
       const radiogroup = e.currentTarget.closest("[role=radiogroup]") as HTMLElement | null;
-      const btns = radiogroup?.querySelectorAll<HTMLButtonElement>("[role=radio]");
-      btns?.[next]?.focus();
+      if (!radiogroup) return;
+      // Use children[] instead of querySelectorAll("> [role=radio]") to avoid
+      // jsdom's child-combinator selector parsing issues in test environments.
+      const btns = Array.from(radiogroup.children).filter(
+        (el): el is HTMLButtonElement =>
+          el.tagName === "BUTTON" && el.getAttribute("role") === "radio"
+      );
+      if (next < btns.length) btns[next]?.focus();
     },
     []
   );

canvas/src/components/mobile/MobileChat.tsx

@@ -6,21 +6,21 @@
 // attachments, no A2A topology overlay, no conversation tracing.
 
 import { useEffect, useMemo, useRef, useState } from "react";
-import ReactMarkdown from "react-markdown";
-import remarkGfm from "remark-gfm";
 
+import { api } from "@/lib/api";
 import { useCanvasStore } from "@/store/canvas";
-import { type ChatAttachment, type ChatMessage, createMessage } from "@/components/tabs/chat/types";
-import {
-  useChatHistory,
-  useChatSend,
-  useChatSocket,
-} from "@/components/tabs/chat/hooks";
 
 import { toMobileAgent } from "./components";
 import { MOBILE_FONT_MONO, MOBILE_FONT_SANS, usePalette } from "./palette";
 import { Icons, StatusDot, TierChip } from "./primitives";
 
+interface ChatMessage {
+  id: string;
+  role: "user" | "agent" | "system";
+  text: string;
+  ts: string;
+}
+
 const formatStoredTimestamp = (iso: string): string => {
   const d = new Date(iso);
   if (isNaN(d.getTime())) return "";
@@ -29,171 +29,16 @@ const formatStoredTimestamp = (iso: string): string => {
 
 type SubTab = "my" | "a2a";
 
-function MarkdownBubble({
-  children,
-  dark,
-  accent,
-}: {
-  children: string;
-  dark: boolean;
-  accent: string;
-}) {
-  const codeBg = dark ? "rgba(255,255,255,0.08)" : "rgba(0,0,0,0.06)";
-  const codeBlockBg = dark ? "#1a1a1a" : "#f5f5f0";
-  const linkColor = accent;
-  const quoteBorder = dark ? "rgba(255,250,240,0.15)" : "rgba(40,30,20,0.15)";
-
-  return (
-    <ReactMarkdown
-      remarkPlugins={[remarkGfm]}
-      components={{
-        p: ({ children }) => (
-          <div style={{ margin: "2px 0", lineHeight: "inherit" }}>{children}</div>
-        ),
-        a: ({ href, children }) => (
-          <a
-            href={href}
-            target="_blank"
-            rel="noopener noreferrer"
-            style={{ color: linkColor, textDecoration: "underline" }}
-          >
-            {children}
-          </a>
-        ),
-        pre: ({ children }) => (
-          <pre
-            style={{
-              background: codeBlockBg,
-              padding: "8px 10px",
-              borderRadius: 8,
-              overflow: "auto",
-              fontSize: 12,
-              lineHeight: 1.5,
-              fontFamily: MOBILE_FONT_MONO,
-              margin: "4px 0",
-            }}
-          >
-            {children}
-          </pre>
-        ),
-        code: ({ children, className }) => {
-          const isBlock = className != null && String(className).length > 0;
-          if (isBlock) {
-            return (
-              <code style={{ fontFamily: MOBILE_FONT_MONO, fontSize: 12 }}>
-                {children}
-              </code>
-            );
-          }
-          return (
-            <code
-              style={{
-                background: codeBg,
-                padding: "1px 4px",
-                borderRadius: 4,
-                fontSize: 13,
-                fontFamily: MOBILE_FONT_MONO,
-              }}
-            >
-              {children}
-            </code>
-          );
-        },
-        ul: ({ children }) => (
-          <ul style={{ margin: "4px 0", paddingLeft: 18, listStyle: "disc" }}>
-            {children}
-          </ul>
-        ),
-        ol: ({ children }) => (
-          <ol style={{ margin: "4px 0", paddingLeft: 18, listStyle: "decimal" }}>
-            {children}
-          </ol>
-        ),
-        li: ({ children }) => <li style={{ margin: "2px 0" }}>{children}</li>,
-        strong: ({ children }) => (
-          <strong style={{ fontWeight: 600 }}>{children}</strong>
-        ),
-        em: ({ children }) => <em style={{ fontStyle: "italic" }}>{children}</em>,
-        h1: ({ children }) => (
-          <div style={{ fontSize: 16, fontWeight: 700, margin: "4px 0" }}>{children}</div>
-        ),
-        h2: ({ children }) => (
-          <div style={{ fontSize: 15, fontWeight: 700, margin: "4px 0" }}>{children}</div>
-        ),
-        h3: ({ children }) => (
-          <div style={{ fontSize: 14, fontWeight: 700, margin: "4px 0" }}>{children}</div>
-        ),
-        h4: ({ children }) => (
-          <div style={{ fontSize: 14, fontWeight: 600, margin: "4px 0" }}>{children}</div>
-        ),
-        h5: ({ children }) => (
-          <div style={{ fontSize: 13, fontWeight: 600, margin: "4px 0" }}>{children}</div>
-        ),
-        h6: ({ children }) => (
-          <div style={{ fontSize: 13, fontWeight: 600, margin: "4px 0" }}>{children}</div>
-        ),
-        blockquote: ({ children }) => (
-          <blockquote
-            style={{
-              borderLeft: `2px solid ${quoteBorder}`,
-              margin: "4px 0",
-              paddingLeft: 8,
-              opacity: 0.85,
-            }}
-          >
-            {children}
-          </blockquote>
-        ),
-        hr: () => (
-          <hr
-            style={{
-              border: "none",
-              borderTop: `0.5px solid ${quoteBorder}`,
-              margin: "6px 0",
-            }}
-          />
-        ),
-        table: ({ children }) => (
-          <table
-            style={{
-              borderCollapse: "collapse",
-              fontSize: 13,
-              margin: "4px 0",
-              width: "100%",
-            }}
-          >
-            {children}
-          </table>
-        ),
-        thead: ({ children }) => <thead style={{ fontWeight: 600 }}>{children}</thead>,
-        th: ({ children }) => (
-          <th
-            style={{
-              border: `0.5px solid ${quoteBorder}`,
-              padding: "4px 6px",
-              textAlign: "left",
-            }}
-          >
-            {children}
-          </th>
-        ),
-        td: ({ children }) => (
-          <td
-            style={{
-              border: `0.5px solid ${quoteBorder}`,
-              padding: "4px 6px",
-            }}
-          >
-            {children}
-          </td>
-        ),
-      }}
-    >
-      {children}
-    </ReactMarkdown>
-  );
+interface A2AResponseShape {
+  result?: {
+    parts?: Array<{ kind?: string; text?: string }>;
+  };
+  error?: { message?: string };
 }
 
+const formatTime = (date: Date) =>
+  date.toLocaleTimeString([], { hour: "numeric", minute: "2-digit" });
+
 export function MobileChat({
   agentId,
   dark,
@@ -204,40 +49,37 @@ export function MobileChat({
   onBack: () => void;
 }) {
   const p = usePalette(dark);
+  // Selecting `nodes` stably avoids the `.find()` anti-pattern that
+  // creates a new return value on every store update (React error #185).
   const nodes = useCanvasStore((s) => s.nodes);
   const node = useMemo(() => nodes.find((n) => n.id === agentId), [nodes, agentId]);
+  // Bootstrap from the canvas store's per-workspace message buffer so the
+  // user sees their prior thread on entry. The store is updated by the
+  // socket → ChatTab flows the desktop runs; on mobile we read from the
+  // same buffer to keep state coherent across viewports.
+  // NOTE: selector returns undefined (stable) — do NOT use ?? [] here,
+  // that creates a new [] reference on every store update when the key is
+  // absent, causing infinite re-render (React error #185).
+  const storedMessages = useCanvasStore((s) => s.agentMessages[agentId]);
+  const [messages, setMessages] = useState<ChatMessage[]>(() =>
+    (storedMessages ?? []).map((m) => ({
+      id: m.id,
+      role: "agent",
+      text: m.content,
+      ts: formatStoredTimestamp(m.timestamp),
+    })),
+  );
   const [draft, setDraft] = useState("");
   const [tab, setTab] = useState<SubTab>("my");
+  const [sending, setSending] = useState(false);
+  const [error, setError] = useState<string | null>(null);
   const scrollRef = useRef<HTMLDivElement>(null);
+  // Synchronous re-entry guard. `setSending(true)` schedules a state
+  // update but doesn't flush before a second tap can fire send() — a ref
+  // mirrors the desktop ChatTab pattern (sendInFlightRef) and closes the
+  // double-send race a stale `sending` lets through.
+  const sendInFlightRef = useRef(false);
   const composerRef = useRef<HTMLTextAreaElement>(null);
-  const fileInputRef = useRef<HTMLInputElement>(null);
-  const [pendingFiles, setPendingFiles] = useState<File[]>([]);
-
-  const {
-    messages,
-    loading: historyLoading,
-    loadError: historyError,
-    loadInitial,
-    appendMessageDeduped,
-  } = useChatHistory(agentId);
-
-  const {
-    sending,
-    uploading,
-    sendMessage,
-    error: sendError,
-    clearError,
-    releaseSendGuards,
-  } = useChatSend(agentId, {
-    getHistoryMessages: () => messages,
-    onUserMessage: appendMessageDeduped,
-    onAgentMessage: appendMessageDeduped,
-  });
-
-  useChatSocket(agentId, {
-    onAgentMessage: appendMessageDeduped,
-    onSendComplete: releaseSendGuards,
-  });
 
   // Auto-grow the textarea: reset height to 'auto' so the scrollHeight
   // shrinks when the user deletes text, then size to scrollHeight up to
@@ -256,20 +98,6 @@ export function MobileChat({
     }
   }, [messages]);
 
-  // Consume any agent messages that arrived while history was loading.
-  const initialConsumeDoneRef = useRef(false);
-  useEffect(() => {
-    if (historyLoading || initialConsumeDoneRef.current) return;
-    initialConsumeDoneRef.current = true;
-    const consume = useCanvasStore.getState().consumeAgentMessages;
-    const msgs = consume(agentId);
-    for (const m of msgs) {
-      appendMessageDeduped(
-        createMessage("agent", m.content, m.attachments),
-      );
-    }
-  }, [historyLoading, agentId, appendMessageDeduped]);
-
   if (!node) {
     return (
       <div
@@ -291,32 +119,58 @@ export function MobileChat({
   const a = toMobileAgent(node);
   const reachable = a.status === "online" || a.status === "degraded";
 
-  const onFilesPicked = (fileList: FileList | null) => {
-    if (!fileList) return;
-    const picked = Array.from(fileList);
-    setPendingFiles((prev) => {
-      const keyed = new Set(prev.map((f) => `${f.name}:${f.size}`));
-      return [...prev, ...picked.filter((f) => !keyed.has(`${f.name}:${f.size}`))];
-    });
-    if (fileInputRef.current) fileInputRef.current.value = "";
-  };
-
-  const removePendingFile = (index: number) =>
-    setPendingFiles((prev) => prev.filter((_, i) => i !== index));
-
   const send = async () => {
     const text = draft.trim();
-    if ((!text && pendingFiles.length === 0) || sending || !reachable) return;
-    clearError();
+    if (!text || sending || !reachable) return;
+    if (sendInFlightRef.current) return;
+    sendInFlightRef.current = true;
     setDraft("");
-    const files = pendingFiles;
-    setPendingFiles([]);
-    await sendMessage(text, files);
+    setError(null);
+    setSending(true);
+    const myMsg: ChatMessage = {
+      id: crypto.randomUUID(),
+      role: "user",
+      text,
+      ts: formatTime(new Date()),
+    };
+    setMessages((m) => [...m, myMsg]);
+
+    try {
+      const res = await api.post<A2AResponseShape>(`/workspaces/${agentId}/a2a`, {
+        method: "message/send",
+        params: {
+          message: {
+            role: "user",
+            messageId: crypto.randomUUID(),
+            parts: [{ kind: "text", text }],
+          },
+        },
+      });
+      const reply =
+        res.result?.parts?.find((part) => part.kind === "text")?.text ?? "";
+      if (reply) {
+        setMessages((m) => [
+          ...m,
+          {
+            id: crypto.randomUUID(),
+            role: "agent",
+            text: reply,
+            ts: formatTime(new Date()),
+          },
+        ]);
+      } else if (res.error?.message) {
+        setError(res.error.message);
+      }
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Failed to send");
+    } finally {
+      setSending(false);
+      sendInFlightRef.current = false;
+    }
   };
 
   return (
     <div
-      data-testid="chat-panel"
       style={{
         height: "100%",
         display: "flex",
@@ -457,42 +311,7 @@ export function MobileChat({
             Agent Comms — peer-to-peer A2A traffic surfaces in the Comms tab.
           </div>
         )}
-        {tab === "my" && historyLoading && (
-          <div style={{ padding: "20px 4px", textAlign: "center", color: p.text3, fontSize: 13 }}>
-            Loading chat history…
-          </div>
-        )}
-        {tab === "my" && !historyLoading && historyError && messages.length === 0 && (
-          <div
-            role="alert"
-            style={{
-              padding: "14px 4px",
-              textAlign: "center",
-              color: p.failed,
-              fontSize: 13,
-            }}
-          >
-            <div style={{ marginBottom: 8 }}>Could not load chat history.</div>
-            <button
-              type="button"
-              onClick={() => {
-                loadInitial();
-              }}
-              style={{
-                padding: "6px 14px",
-                borderRadius: 14,
-                border: `0.5px solid ${p.failed}`,
-                background: "transparent",
-                color: p.failed,
-                fontSize: 12,
-                cursor: "pointer",
-              }}
-            >
-              Retry
-            </button>
-          </div>
-        )}
-        {tab === "my" && !historyLoading && !historyError && messages.length === 0 && (
+        {tab === "my" && messages.length === 0 && (
           <div style={{ padding: "20px 4px", textAlign: "center", color: p.text3, fontSize: 13 }}>
             Send a message to start chatting.
           </div>
@@ -521,9 +340,7 @@ export function MobileChat({
                     overflowWrap: "anywhere",
                   }}
                 >
-                  <MarkdownBubble dark={dark} accent={p.accent}>
-                    {m.content}
-                  </MarkdownBubble>
+                  {m.text}
                   <div
                     style={{
                       fontSize: 10,
@@ -532,13 +349,13 @@ export function MobileChat({
                       fontFamily: MOBILE_FONT_MONO,
                     }}
                   >
-                    {formatStoredTimestamp(m.timestamp)}
+                    {m.ts}
                   </div>
                 </div>
               </div>
             );
           })}
-        {sendError && (
+        {error && (
           <div
             role="alert"
             style={{
@@ -550,7 +367,7 @@ export function MobileChat({
               fontSize: 12,
             }}
           >
-            {sendError}
+            {error}
           </div>
         )}
       </div>
@@ -581,60 +398,6 @@ export function MobileChat({
           backdropFilter: "blur(14px)",
         }}
       >
-        {pendingFiles.length > 0 && (
-          <div
-            style={{
-              display: "flex",
-              flexWrap: "wrap",
-              gap: 6,
-              marginBottom: 8,
-              paddingLeft: 2,
-            }}
-          >
-            {pendingFiles.map((f, i) => (
-              <div
-                key={`${f.name}:${f.size}`}
-                style={{
-                  display: "flex",
-                  alignItems: "center",
-                  gap: 4,
-                  padding: "3px 8px",
-                  borderRadius: 10,
-                  background: dark ? "#2a2823" : "#ece9e0",
-                  fontSize: 12,
-                  color: p.text2,
-                  maxWidth: "100%",
-                }}
-              >
-                <span
-                  style={{
-                    overflow: "hidden",
-                    textOverflow: "ellipsis",
-                    whiteSpace: "nowrap",
-                  }}
-                >
-                  {f.name}
-                </span>
-                <button
-                  type="button"
-                  onClick={() => removePendingFile(i)}
-                  aria-label={`Remove ${f.name}`}
-                  style={{
-                    border: "none",
-                    background: "transparent",
-                    color: p.text3,
-                    cursor: "pointer",
-                    fontSize: 12,
-                    padding: 0,
-                    lineHeight: 1,
-                  }}
-                >
-                  ✕
-                </button>
-              </div>
-            ))}
-          </div>
-        )}
         <div
           style={{
             display: "flex",
@@ -646,32 +409,21 @@ export function MobileChat({
             padding: "6px 6px 6px 12px",
           }}
         >
-          <input
-            ref={fileInputRef}
-            type="file"
-            multiple
-            style={{ display: "none" }}
-            onChange={(e) => onFilesPicked(e.target.files)}
-            aria-hidden="true"
-          />
           <button
             type="button"
-            onClick={() => fileInputRef.current?.click()}
-            disabled={!reachable || sending || uploading}
             aria-label="Attach"
             style={{
               width: 32,
               height: 32,
               borderRadius: 999,
               border: "none",
-              cursor: reachable && !sending && !uploading ? "pointer" : "not-allowed",
+              cursor: "pointer",
               background: "transparent",
               color: p.text3,
               flexShrink: 0,
               display: "flex",
               alignItems: "center",
               justifyContent: "center",
-              opacity: !reachable || sending || uploading ? 0.4 : 1,
             }}
           >
             {Icons.attach({ size: 16 })}
@@ -717,32 +469,28 @@ export function MobileChat({
           <button
             type="button"
             onClick={send}
-            disabled={(!draft.trim() && pendingFiles.length === 0) || !reachable || sending || uploading}
+            disabled={!draft.trim() || !reachable || sending}
             aria-label="Send"
             style={{
               width: 36,
               height: 36,
               borderRadius: 999,
               border: "none",
-              cursor: (draft.trim() || pendingFiles.length > 0) && !sending && !uploading ? "pointer" : "not-allowed",
+              cursor: draft.trim() && !sending ? "pointer" : "not-allowed",
               flexShrink: 0,
               background:
-                (draft.trim() || pendingFiles.length > 0) && reachable && !sending && !uploading
+                draft.trim() && reachable && !sending
                   ? p.accent
                   : dark
                     ? "#2a2823"
                     : "#ece9e0",
-              color: (draft.trim() || pendingFiles.length > 0) && reachable && !sending && !uploading ? "#fff" : p.text3,
+              color: draft.trim() && reachable && !sending ? "#fff" : p.text3,
               display: "flex",
               alignItems: "center",
               justifyContent: "center",
             }}
           >
-            {uploading ? (
-              <span style={{ fontSize: 10, fontWeight: 600 }}>↑</span>
-            ) : (
-              Icons.send({ size: 16 })
-            )}
+            {Icons.send({ size: 16 })}
           </button>
         </div>
       </div>

canvas/src/components/mobile/MobileDetail.tsx

@@ -214,7 +214,6 @@ export function MobileDetail({
         <button
           type="button"
           onClick={onChat}
-          data-testid="mobile-chat-cta"
           style={{
             width: "100%",
             height: 52,

canvas/src/components/mobile/MobileSpawn.tsx

@@ -12,7 +12,6 @@ import { useEffect, useState } from "react";
 
 import { api } from "@/lib/api";
 import { type Template } from "@/lib/deploy-preflight";
-import { isSaaSTenant } from "@/lib/tenant";
 
 import { tierCode } from "./palette";
 import { MOBILE_FONT_MONO, MOBILE_FONT_SANS, type MobilePalette, usePalette } from "./palette";
@@ -27,7 +26,6 @@ const TIER_LABEL: Record<"T1" | "T2" | "T3" | "T4", string> = {
 
 export function MobileSpawn({ dark, onClose }: { dark: boolean; onClose: () => void }) {
   const p = usePalette(dark);
-  const isSaaS = isSaaSTenant();
   const [templates, setTemplates] = useState<Template[]>([]);
   const [loadingTemplates, setLoadingTemplates] = useState(true);
   const [tplId, setTplId] = useState<string | null>(null);
@@ -45,7 +43,7 @@ export function MobileSpawn({ dark, onClose }: { dark: boolean; onClose: () => v
         setTemplates(list);
         if (list.length > 0) {
           setTplId(list[0].id);
-          setTier(isSaaS ? "T4" : tierCode(list[0].tier));
+          setTier(tierCode(list[0].tier));
         }
       })
       .catch(() => {
@@ -57,7 +55,7 @@ export function MobileSpawn({ dark, onClose }: { dark: boolean; onClose: () => v
     return () => {
       cancelled = true;
     };
-  }, [isSaaS]);
+  }, []);
 
   const handleSpawn = async () => {
     if (busy || !tplId) return;
@@ -69,7 +67,7 @@ export function MobileSpawn({ dark, onClose }: { dark: boolean; onClose: () => v
       await api.post<{ id: string }>("/workspaces", {
         name: (name.trim() || chosen.name),
         template: chosen.id,
-        tier: isSaaS ? 4 : Number(tier.slice(1)),
+        tier: Number(tier.slice(1)),
         canvas: {
           x: Math.random() * 400 + 100,
           y: Math.random() * 300 + 100,
@@ -205,7 +203,7 @@ export function MobileSpawn({ dark, onClose }: { dark: boolean; onClose: () => v
             >
               {templates.map((t) => {
                 const on = tplId === t.id;
-                const tCode = isSaaS ? "T4" : tierCode(t.tier);
+                const tCode = tierCode(t.tier);
                 return (
                   <button
                     key={t.id}

canvas/src/components/mobile/__tests__/MobileChat.test.tsx

@@ -8,19 +8,11 @@
  * NOTE: No @testing-library/jest-dom — use DOM APIs.
  */
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { act, cleanup, render, waitFor } from "@testing-library/react";
+import { cleanup, render } from "@testing-library/react";
 import React from "react";
 
 import { MobileChat } from "../MobileChat";
 
-// ─── Mock API ─────────────────────────────────────────────────────────────────
-// vi.mock without a factory auto-mocks the module. In tests, we configure
-// api.get / api.post directly (they are vi.fn() from the auto-mock).
-// Tests that need specific behaviour use mockResolvedValueOnce on the
-// auto-mocked functions.
-vi.mock("@/lib/api");
-import { api } from "@/lib/api";
-
 // ─── Mock store ───────────────────────────────────────────────────────────────
 
 const mockAgentId = "ws-chat-test";
@@ -36,19 +28,12 @@ const mockStoreState = {
     height?: number;
   }>,
   agentMessages: {} as Record<string, Array<{ id: string; content: string; timestamp: string }>>,
-  consumeAgentMessages: () => [],
 };
 
 vi.mock("@/store/canvas", () => ({
   useCanvasStore: Object.assign(
-    vi.fn((sel?: (state: typeof mockStoreState) => unknown) => {
-      if (sel) return sel(mockStoreState);
-      return mockStoreState;
-    }),
-    {
-      getState: () => mockStoreState,
-      subscribe: vi.fn(() => vi.fn()),
-    },
+    vi.fn((sel) => sel(mockStoreState)),
+    { getState: () => mockStoreState },
   ),
   summarizeWorkspaceCapabilities: vi.fn((data: Record<string, unknown>) => {
     const agentCard = data.agentCard as Record<string, unknown> | null;
@@ -69,6 +54,16 @@ vi.mock("@/store/canvas", () => ({
   }),
 }));
 
+// ─── Mock API ─────────────────────────────────────────────────────────────────
+
+const { mockApiPost } = vi.hoisted(() => ({
+  mockApiPost: vi.fn().mockResolvedValue({ result: { parts: [] } }),
+}));
+
+vi.mock("@/lib/api", () => ({
+  api: { post: mockApiPost },
+}));
+
 // ─── Fixtures ────────────────────────────────────────────────────────────────
 
 const onlineNode = {
@@ -155,15 +150,7 @@ beforeEach(() => {
   mockOnBack.mockClear();
   mockStoreState.nodes = [];
   mockStoreState.agentMessages = {};
-  // Set up spies on the real api methods. Tests override these per-call.
-  const getSpy = vi.spyOn(api, "get");
-  const postSpy = vi.spyOn(api, "post");
-  getSpy.mockResolvedValue({ messages: [], reached_end: true });
-  postSpy.mockResolvedValue({ result: { parts: [] } });
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
+  mockApiPost.mockClear();
 });
 
 afterEach(() => {
@@ -279,26 +266,15 @@ describe("MobileChat — empty state", () => {
     mockStoreState.nodes = [onlineNode];
   });
 
-  it('shows "Send a message to start chatting." when no messages', async () => {
-    // History fetch resolves immediately in tests (mockResolvedValue).
-    // act() flushes the microtask queue so the component reaches its
-    // post-load state before we assert.
-    let renderResult: ReturnType<typeof renderChat>;
-    await act(async () => {
-      renderResult = renderChat(mockAgentId);
-    });
-    const { container } = renderResult!;
+  it('shows "Send a message to start chatting." when no messages', () => {
+    const { container } = renderChat(mockAgentId);
     expect(container.textContent ?? "").toContain("Send a message to start chatting.");
   });
 
-  it("shows no messages when agentMessages[agentId] is absent (undefined)", async () => {
+  it("shows no messages when agentMessages[agentId] is absent (undefined)", () => {
     // Explicitly set to empty to simulate no stored messages
     mockStoreState.agentMessages = {};
-    let renderResult: ReturnType<typeof renderChat>;
-    await act(async () => {
-      renderResult = renderChat(mockAgentId);
-    });
-    const { container } = renderResult!;
+    const { container } = renderChat(mockAgentId);
     expect(container.textContent ?? "").toContain("Send a message to start chatting.");
   });
 });
@@ -345,132 +321,3 @@ describe("MobileChat — dark mode", () => {
     expect(container.querySelector('[aria-label="Back"]')).toBeTruthy();
   });
 });
-
-// ─── Chat history loading ────────────────────────────────────────────────────
-
-describe("MobileChat — chat history", () => {
-  beforeEach(() => {
-    mockStoreState.nodes = [onlineNode];
-  });
-
-  it("calls GET /workspaces/:id/chat-history on mount", async () => {
-    await act(async () => {
-      renderChat(mockAgentId);
-    });
-    expect(api.get).toHaveBeenCalledWith(
-      expect.stringContaining(`/workspaces/${mockAgentId}/chat-history`),
-    );
-  });
-
-  it("shows loading state while history is fetching", () => {
-    // Do NOT await — check the pre-resolve state.
-    const { container } = renderChat(mockAgentId);
-    expect(container.textContent ?? "").toContain("Loading chat history…");
-  });
-
-  it("shows empty state after history resolves with no messages", async () => {
-    // beforeEach already sets api.get to resolve with empty — no override needed.
-    let renderResult: ReturnType<typeof renderChat>;
-    await act(async () => {
-      renderResult = renderChat(mockAgentId);
-    });
-    const { container } = renderResult!;
-    expect(container.textContent ?? "").toContain("Send a message to start chatting.");
-  });
-
-  it("renders messages from history response", async () => {
-    vi.spyOn(api, "get").mockResolvedValueOnce({
-      messages: [
-        {
-          id: "msg-1",
-          role: "user",
-          content: "Hello agent",
-          timestamp: "2026-04-25T10:00:00Z",
-        },
-        {
-          id: "msg-2",
-          role: "agent",
-          content: "Hello back",
-          timestamp: "2026-04-25T10:00:01Z",
-        },
-      ],
-      reached_end: true,
-    });
-    let renderResult: ReturnType<typeof renderChat>;
-    await act(async () => {
-      renderResult = renderChat(mockAgentId);
-    });
-    const { container } = renderResult!;
-    expect(container.textContent ?? "").toContain("Hello agent");
-    expect(container.textContent ?? "").toContain("Hello back");
-  });
-
-  it("maps user role from API correctly", async () => {
-    vi.spyOn(api, "get").mockResolvedValueOnce({
-      messages: [
-        {
-          id: "msg-u",
-          role: "user",
-          content: "user message",
-          timestamp: "2026-04-25T10:00:00Z",
-        },
-      ],
-      reached_end: true,
-    });
-    let renderResult: ReturnType<typeof renderChat>;
-    await act(async () => {
-      renderResult = renderChat(mockAgentId);
-    });
-    // User messages render right-aligned. The text content check is sufficient
-    // to confirm the message appeared.
-    const { container } = renderResult!;
-    expect(container.textContent ?? "").toContain("user message");
-  });
-
-  it("shows error state when history fetch fails", async () => {
-    vi.spyOn(api, "get").mockRejectedValue(new Error("Network error"));
-    let renderResult: ReturnType<typeof renderChat>;
-    await act(async () => {
-      renderResult = renderChat(mockAgentId);
-    });
-    const { container } = renderResult!;
-    expect(container.textContent ?? "").toContain("Could not load chat history.");
-    expect(container.textContent ?? "").toContain("Retry");
-  });
-
-  it("Retry button re-fetches history after error", async () => {
-    // Make the initial mount call fail so the Retry button appears, then
-    // make the retry call succeed so we can verify the full flow.
-    const getSpy = vi.spyOn(api, "get");
-    getSpy
-      .mockRejectedValueOnce(new Error("Network error"))
-      .mockResolvedValueOnce({ messages: [], reached_end: true });
-
-    let renderResult: ReturnType<typeof renderChat>;
-    await act(async () => {
-      renderResult = renderChat(mockAgentId);
-    });
-    const { container } = renderResult!;
-
-    // Error state should be shown with Retry button.
-    expect(container.textContent ?? "").toContain("Could not load chat history.");
-    expect(container.textContent ?? "").toContain("Retry");
-
-    // Click Retry — the button's onClick fires api.get again.
-    // The second mockResolvedValueOnce makes it succeed.
-    const retryBtn = Array.from(container.querySelectorAll("button")).find(
-      (b) => b.textContent?.trim() === "Retry",
-    );
-    expect(retryBtn).toBeTruthy();
-    await act(async () => {
-      retryBtn?.click();
-    });
-
-    // waitFor polls until the retry resolves and component re-renders.
-    await waitFor(() => {
-      expect(container.textContent ?? "").toContain("Send a message to start chatting.");
-    });
-    // Initial call + retry = 2.
-    expect(getSpy).toHaveBeenCalledTimes(2);
-  });
-});

canvas/src/components/mobile/components.tsx

@@ -288,7 +288,6 @@ export function AgentCard({
   return (
     <button
       type="button"
-      data-testid="workspace-card"
       aria-label={`${agent.name}, status: ${agent.status}, tier ${agent.tier}${agent.remote ? ", remote" : ""}`}
       onClick={onClick}
       style={{

canvas/src/components/tabs/ChatTab.tsx

@@ -5,19 +5,16 @@ import ReactMarkdown from "react-markdown";
 import remarkGfm from "remark-gfm";
 import { api } from "@/lib/api";
 import { useCanvasStore, type WorkspaceNodeData } from "@/store/canvas";
+import { useSocketEvent } from "@/hooks/useSocketEvent";
 import { type ChatMessage, type ChatAttachment, createMessage, appendMessageDeduped } from "./chat/types";
-import { downloadChatFile, isPlatformAttachment } from "./chat/uploads";
+import { uploadChatFiles, downloadChatFile, isPlatformAttachment } from "./chat/uploads";
 import { PendingAttachmentPill } from "./chat/AttachmentViews";
 import { AttachmentPreview } from "./chat/AttachmentPreview";
+import { extractFilesFromTask } from "./chat/message-parser";
 import { AgentCommsPanel } from "./chat/AgentCommsPanel";
 import { appendActivityLine } from "./chat/activityLog";
 import { runtimeDisplayName } from "@/lib/runtime-names";
 import { ConfirmDialog } from "@/components/ConfirmDialog";
-import { useChatHistory } from "./chat/hooks/useChatHistory";
-import { useChatSend } from "./chat/hooks/useChatSend";
-import { useChatSocket } from "./chat/hooks/useChatSocket";
-
-export { extractReplyText } from "./chat/hooks/useChatSend";
 
 interface Props {
   workspaceId: string;
@@ -26,6 +23,147 @@ interface Props {
 
 type ChatSubTab = "my-chat" | "agent-comms";
 
+// A2A response shape (subset). The full schema is in @a2a-js/sdk but we only
+// need parts/artifacts text + file extraction for the synchronous fallback.
+interface A2AFileRef {
+  name?: string;
+  mimeType?: string;
+  uri?: string;
+  bytes?: string;
+  size?: number;
+}
+// Outbound shape matches a2a-sdk's JSON-RPC `SendMessageRequest`
+// Pydantic union (TextPart | FilePart | DataPart). The flat
+// protobuf shape `{url, filename, mediaType}` is rejected at the
+// request boundary with `Field required` errors — keep this
+// outbound shape unless a2a-sdk migrates the JSON-RPC schema.
+interface A2APart {
+  kind: string;
+  text?: string;
+  file?: A2AFileRef;
+}
+interface A2AResponse {
+  result?: {
+    parts?: A2APart[];
+    artifacts?: Array<{ parts: A2APart[] }>;
+  };
+}
+
+// Internal-self-message filtering moved server-side in RFC #2945
+// PR-C/D — the platform's /chat-history endpoint applies the
+// IsInternalSelfMessage predicate before returning rows, so the
+// client no longer needs the local backstop on the history path.
+// The proper fix is still X-Workspace-ID header (source_id=workspace_id);
+// the platform-side prefix filter handles the residual cases.
+
+// extractReplyText pulls the agent's text reply out of an A2A response.
+// Concatenates ALL text parts (joined with "\n") rather than returning
+// just the first. Claude Code and other runtimes commonly emit multi-
+// part text replies for long content (markdown tables, code blocks),
+// and the prior "first part wins" implementation silently truncated
+// the rest — observed on a 15k-char Wave 1 brief that rendered only
+// the table header. Mirrors extractTextsFromParts in message-parser.ts.
+//
+// Server-side counterpart in workspace-server/internal/channels/
+// manager.go has the same single-part bug; fix that too if/when a
+// channel-delivered reply (Slack, Lark, etc.) gets truncated.
+export function extractReplyText(resp: A2AResponse): string {
+  const collect = (parts: A2APart[] | undefined): string => {
+    if (!parts) return "";
+    return parts
+      .filter((p) => p.kind === "text")
+      .map((p) => p.text ?? "")
+      .filter(Boolean)
+      .join("\n");
+  };
+  const result = resp?.result;
+  const collected: string[] = [];
+  const fromParts = collect(result?.parts);
+  if (fromParts) collected.push(fromParts);
+  // Walk artifacts even if parts had text — some producers (Hermes
+  // tool calls) emit a summary in parts AND details in artifacts.
+  // Returning early on parts dropped the artifact body silently.
+  if (result?.artifacts) {
+    for (const a of result.artifacts) {
+      const t = collect(a.parts);
+      if (t) collected.push(t);
+    }
+  }
+  return collected.join("\n");
+}
+
+// Agent-returned files live on the same response shape as text —
+// delegated to extractFilesFromTask in message-parser.ts, which also
+// walks status.message.parts (that ChatTab's legacy text extractor
+// doesn't). Single source of truth for file-part parsing across
+// live chat, activity log replay, and any future consumers.
+
+/** Initial chat history page size. The newest N messages are rendered
+ *  on first paint; older history is fetched on demand via loadOlder()
+ *  when the user scrolls the top sentinel into view. */
+const INITIAL_HISTORY_LIMIT = 10;
+/** Subsequent older-history batch size. Larger than INITIAL so a long
+ *  scroll-back doesn't fan out into many round-trips. */
+const OLDER_HISTORY_BATCH = 20;
+
+/**
+ * Load chat history from the platform's typed /chat-history endpoint.
+ *
+ * Server-side rendering of activity_logs rows into ChatMessage shape
+ * lives in workspace-server/internal/messagestore/postgres_store.go
+ * (RFC #2945 PR-C/D). The server already applies the canvas-source
+ * filter, the internal-self-message predicate, the role decision
+ * (status=error vs agent-error prefix → system), and the v0/v1
+ * file-shape extraction. Canvas just renders what it receives.
+ *
+ * Wire shape (mirrors ChatMessage exactly, no per-row mapping needed):
+ *
+ *   GET /workspaces/:id/chat-history?limit=N&before_ts=T
+ *   200 → {"messages": ChatMessage[], "reached_end": boolean}
+ *
+ * Pagination:
+ *  - Pass `limit` to bound the page size (newest-first from server).
+ *  - Pass `beforeTs` (RFC3339) to fetch rows STRICTLY OLDER than that
+ *    timestamp. Combined with limit, this yields the next-older page
+ *    when scrolling backward through history.
+ *
+ * `reachedEnd` is propagated from the server. The server computes it
+ * by comparing rowCount vs limit so a partial last page is correctly
+ * detected even when the row→bubble fan-out is non-1:1 (each row
+ * produces 1-2 bubbles).
+ */
+async function loadMessagesFromDB(
+  workspaceId: string,
+  limit: number,
+  beforeTs?: string,
+): Promise<{ messages: ChatMessage[]; error: string | null; reachedEnd: boolean }> {
+  try {
+    const params = new URLSearchParams({ limit: String(limit) });
+    if (beforeTs) params.set("before_ts", beforeTs);
+    const resp = await api.get<{ messages: ChatMessage[]; reached_end: boolean }>(
+      `/workspaces/${workspaceId}/chat-history?${params.toString()}`,
+    );
+
+    // Server emits oldest-first within the page (RFC #2945 PR-C-2
+    // post-fix: server reverses row-aware before returning so the
+    // wire is display-ready). Canvas appends/prepends without
+    // reordering — this avoids the pair-flip bug a naive flat
+    // reverse causes when each row produces a (user, agent) pair
+    // with the same timestamp.
+    return {
+      messages: resp.messages ?? [],
+      error: null,
+      reachedEnd: resp.reached_end,
+    };
+  } catch (err) {
+    return {
+      messages: [],
+      error: err instanceof Error ? err.message : "Failed to load chat history",
+      reachedEnd: true,
+    };
+  }
+}
+
 /**
  * ChatTab container — renders sub-tab bar + My Chat or Agent Comms panel.
  */
@@ -33,7 +171,7 @@ export function ChatTab({ workspaceId, data }: Props) {
   const [subTab, setSubTab] = useState<ChatSubTab>("my-chat");
 
   return (
-    <div data-testid="chat-panel" className="flex flex-col h-full">
+    <div className="flex flex-col h-full">
       {/* Sub-tab bar — role="tablist" so screen readers expose tab context */}
       <div
         role="tablist"
@@ -109,68 +247,268 @@ export function ChatTab({ workspaceId, data }: Props) {
  * MyChatPanel — user↔agent conversation (extracted from original ChatTab).
  */
 function MyChatPanel({ workspaceId, data }: Props) {
+  const [messages, setMessages] = useState<ChatMessage[]>([]);
   const [input, setInput] = useState("");
-  const [pendingFiles, setPendingFiles] = useState<File[]>([]);
-  const [activityLog, setActivityLog] = useState<string[]>([]);
+  // `sending` is strictly the "this tab kicked off a send and hasn't
+  // seen the reply yet" signal. Previously this was initialized from
+  // data.currentTask to pick up in-flight agent work on mount, but
+  // that conflated agent-busy (workspace heartbeat) with user-
+  // in-flight (local send): when the WS dropped a TASK_COMPLETE event,
+  // currentTask lingered, the component re-mounted with sending=true,
+  // and the Send button stayed disabled forever even though nothing
+  // local was in flight. For the "agent is busy, show spinner" UX,
+  // use data.currentTask directly in the render path.
+  const [sending, setSending] = useState(false);
   const [thinkingElapsed, setThinkingElapsed] = useState(0);
+  const [activityLog, setActivityLog] = useState<string[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [loadError, setLoadError] = useState<string | null>(null);
+  const currentTaskRef = useRef(data.currentTask);
+  const sendingFromAPIRef = useRef(false);
   const [agentReachable, setAgentReachable] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const [confirmRestart, setConfirmRestart] = useState(false);
-  const [dragOver, setDragOver] = useState(false);
-
+  const bottomRef = useRef<HTMLDivElement>(null);
+  // First-mount scroll-to-bottom needs `behavior: "instant"` — long
+  // conversations smooth-animate for ~300ms which any concurrent
+  // re-render can interrupt, leaving the user stuck mid-conversation
+  // when the chat tab opens. Subsequent appends (new agent messages)
+  // keep `smooth` for the visual "landing" feel. Flipped the first
+  // time messages.length goes positive, so a workspace switch (which
+  // remounts ChatTab) gets a fresh instant jump too.
+  const hasInitialScrollRef = useRef(false);
+  // Lazy-load older history on scroll-up.
+  // - containerRef = the scrollable messages viewport
+  // - topRef       = sentinel above the messages list; IO observes it
+  //                  and triggers loadOlder() when it enters view
+  // - hasMore      = false once a fetch returns < limit rows; stops IO
+  // - loadingOlder = drives the "Loading older messages…" UI label
+  // - inflightRef  = synchronous guard against double-entry of loadOlder
+  //                  when the IO callback fires twice in the same
+  //                  microtask (state-based guard would be stale until
+  //                  the next React commit)
+  // - scrollAnchorRef = saves distance-from-bottom before a prepend
+  //                  so the useLayoutEffect below can restore the
+  //                  user's exact viewport position. Without this,
+  //                  prepending older messages would jump the scroll
+  //                  position by the height of the new content.
+  // - oldestMessageRef / hasMoreRef = let the loadOlder closure read
+  //                  the latest values without taking them as deps —
+  //                  every live agent push mutates `messages`, and
+  //                  having loadOlder depend on `messages` would tear
+  //                  down + re-arm the IntersectionObserver on every
+  //                  push. Refs decouple the observer lifecycle from
+  //                  message-list updates.
   const containerRef = useRef<HTMLDivElement>(null);
   const topRef = useRef<HTMLDivElement>(null);
-  const bottomRef = useRef<HTMLDivElement>(null);
-  const hasInitialScrollRef = useRef(false);
+  const [hasMore, setHasMore] = useState(true);
+  const [loadingOlder, setLoadingOlder] = useState(false);
+  const inflightRef = useRef(false);
+  // The scroll anchor includes the first-message id as it was BEFORE
+  // the prepend — see useLayoutEffect below for why. Without this tag,
+  // a live agent push that appends WHILE loadOlder is in flight would
+  // run useLayoutEffect against the append (anchor still set), the
+  // "restore" math would scroll the user to a stale offset, AND the
+  // append's normal scroll-to-bottom would be swallowed.
+  const scrollAnchorRef = useRef<
+    { savedDistanceFromBottom: number; expectFirstIdNotEqual: string | null } | null
+  >(null);
+  const oldestMessageRef = useRef<ChatMessage | null>(null);
+  const hasMoreRef = useRef(true);
+  // Monotonic token bumped on workspace switch + on every loadOlder
+  // entry. Each fetch's .then() captures its own token; if the token
+  // has moved, the resolved messages belong to a stale workspace or a
+  // superseded fetch and we silently drop them. Without this guard, a
+  // workspace switch mid-fetch would have the in-flight promise
+  // resolve into the new workspace's setMessages — the user sees
+  // someone else's history briefly.
+  const fetchTokenRef = useRef(0);
+  // Files the user has picked but not yet sent. Cleared on send
+  // (upload success) or by the × on each pill.
+  const [pendingFiles, setPendingFiles] = useState<File[]>([]);
+  const [uploading, setUploading] = useState(false);
   const fileInputRef = useRef<HTMLInputElement>(null);
-  const dragDepthRef = useRef(0);
-  const pasteCounterRef = useRef(0);
+  // Guard against a double-click during the upload phase: React
+  // state updates from the click that started the upload haven't
+  // flushed yet, so the disabled-button logic sees `uploading=false`
+  // from the closure and lets a second `sendMessage` enter. A ref
+  // observes the latest value synchronously.
+  const sendInFlightRef = useRef(false);
+  // Monotonic token bumped on every sendMessage entry. Each .then()/
+  // .catch() captures its own token in closure and bails if a newer
+  // send has superseded it — prevents a late HTTP response for an
+  // earlier message from clobbering the flags / appending text that
+  // belong to a newer in-flight send. Race scenario the token closes:
+  // (1) send msg #1 (2) WS push for msg #1 arrives, releases guards
+  // (3) user sends msg #2 (4) HTTP for msg #1 finally lands — without
+  // the token check, .then() sees sendingFromAPIRef=true (set by
+  // msg #2's send), enters the main body, and processes msg #1's body
+  // as if it were msg #2's reply.
+  const sendTokenRef = useRef(0);
 
-  const history = useChatHistory(workspaceId, containerRef);
-  const chatSend = useChatSend(workspaceId, {
-    getHistoryMessages: () => history.messages,
-    onUserMessage: (msg) => history.setMessages((prev) => [...prev, msg]),
-    onAgentMessage: (msg) => history.setMessages((prev) => appendMessageDeduped(prev, msg)),
-  });
-  const { sending, uploading, sendMessage, error: sendError, clearError: clearSendError, releaseSendGuards, sendingFromAPIRef } = chatSend;
+  // Release every in-flight send guard at once. Used by every site
+  // that ends a send: pendingAgentMsgs WS push, ACTIVITY_LOGGED
+  // a2a_receive ok/error WS event, HTTP .then() success, and HTTP
+  // .catch() success. Keep these in lockstep — a future contributor
+  // adding a new "I saw the reply" path that only clears `sending` +
+  // `sendingFromAPIRef` (the natural pair) silently re-introduces
+  // the post-WS Send-button freeze, because the disabled-button
+  // logic can't see `sendInFlightRef` and so the visible state diverges
+  // from the synchronous re-entry guard at line 464.
+  const releaseSendGuards = useCallback(() => {
+    setSending(false);
+    sendingFromAPIRef.current = false;
+    sendInFlightRef.current = false;
+  }, []);
 
-  const displayError = error || sendError;
+  // Initial-load fetch — used by the mount effect and the "Retry"
+  // button below. Single source of truth so the two paths can't drift
+  // (e.g. INITIAL_HISTORY_LIMIT bumped in the effect but not the
+  // retry, leading to inconsistent first-paint sizes).
+  const loadInitial = useCallback(() => {
+    setLoading(true);
+    setLoadError(null);
+    setHasMore(true);
+    // Bump the token; any in-flight fetch from the previous workspace
+    // (or a previous retry) will see token != myToken in its .then()
+    // and silently bail — the late response can't clobber the new
+    // workspace's state.
+    fetchTokenRef.current += 1;
+    const myToken = fetchTokenRef.current;
+    loadMessagesFromDB(workspaceId, INITIAL_HISTORY_LIMIT).then(
+      ({ messages: msgs, error: fetchErr, reachedEnd }) => {
+        if (fetchTokenRef.current !== myToken) return;
+        setMessages(msgs);
+        setLoadError(fetchErr);
+        setHasMore(!reachedEnd);
+        setLoading(false);
+      },
+    );
+  }, [workspaceId]);
 
-  useChatSocket(workspaceId, {
-    onAgentMessage: (msg) => {
-      history.setMessages((prev) => appendMessageDeduped(prev, msg));
-      if (sendingFromAPIRef.current) {
-        releaseSendGuards();
+  // Load chat history on mount / workspace switch.
+  // Initial load is bounded to INITIAL_HISTORY_LIMIT (newest 10) — the
+  // rest streams in as the user scrolls up via loadOlder() below. Pre-
+  // 2026-05-05 this fetched the newest 50 in one shot; on a long-running
+  // workspace that meant 50× message-bubble paint + DOM cost on every
+  // tab-open even when the user only wanted to read the last few.
+  useEffect(() => {
+    loadInitial();
+  }, [loadInitial]);
+
+  // Mirror the latest oldest-message + hasMore into refs so loadOlder
+  // can read them without taking `messages` as a dep. Every live push
+  // through agentMessages would otherwise recreate loadOlder and tear
+  // down the IO observer.
+  useEffect(() => {
+    oldestMessageRef.current = messages[0] ?? null;
+  }, [messages]);
+  useEffect(() => {
+    hasMoreRef.current = hasMore;
+  }, [hasMore]);
+
+  // Fetch the next-older batch and prepend. Stable identity (deps =
+  // [workspaceId]) so the IntersectionObserver effect below doesn't
+  // re-arm on every messages update.
+  const loadOlder = useCallback(async () => {
+    // inflightRef is the load-bearing guard — synchronous, set BEFORE
+    // any await, so two IO callbacks dispatched in the same microtask
+    // can't both pass. The state checks are defensive secondary
+    // gates for the slow-scroll case.
+    if (inflightRef.current || !hasMoreRef.current) return;
+    const oldest = oldestMessageRef.current;
+    if (!oldest) return;
+    const container = containerRef.current;
+    if (!container) return;
+    inflightRef.current = true;
+    // Capture the user's distance-from-bottom BEFORE we prepend so the
+    // useLayoutEffect can restore it after the new DOM lands. The
+    // expectFirstIdNotEqual tag is what the layout effect checks
+    // against `messages[0].id` to disambiguate prepend (id changed) vs
+    // append (id unchanged → live message landed mid-fetch). Without
+    // it, an agent push during loadOlder runs the "restore" against a
+    // stale anchor — user gets yanked + the append's bottom-pin is
+    // swallowed.
+    scrollAnchorRef.current = {
+      savedDistanceFromBottom: container.scrollHeight - container.scrollTop,
+      expectFirstIdNotEqual: oldest.id,
+    };
+    fetchTokenRef.current += 1;
+    const myToken = fetchTokenRef.current;
+    setLoadingOlder(true);
+    try {
+      const { messages: older, reachedEnd } = await loadMessagesFromDB(
+        workspaceId,
+        OLDER_HISTORY_BATCH,
+        oldest.timestamp,
+      );
+      // Workspace switched (or another loadOlder bumped the token)
+      // mid-fetch — drop these results, they belong to a stale tab.
+      if (fetchTokenRef.current !== myToken) {
+        scrollAnchorRef.current = null;
+        return;
       }
-    },
-    onActivityLog: (entry) => {
-      if (!sending) return;
-      setActivityLog((prev) => appendActivityLine(prev, entry));
-    },
-    onSendComplete: () => {
-      if (sendingFromAPIRef.current) {
-        releaseSendGuards();
+      if (older.length > 0) {
+        setMessages((prev) => [...older, ...prev]);
+      } else {
+        // Nothing came back — clear the anchor so the next paint doesn't
+        // try to "restore" against a no-op prepend.
+        scrollAnchorRef.current = null;
       }
-    },
-    onSendError: (err) => {
-      if (sendingFromAPIRef.current) {
-        releaseSendGuards();
-        setError(err);
-      }
-    },
-  });
+      setHasMore(!reachedEnd);
+    } finally {
+      setLoadingOlder(false);
+      inflightRef.current = false;
+    }
+  }, [workspaceId]);
+
+  // IntersectionObserver on the top sentinel. Fires loadOlder() the
+  // moment the user scrolls within 200px of the top. AbortController
+  // unwires cleanly on workspace switch / unmount; root is the
+  // scrollable container so we observe only what's visible inside it.
+  //
+  // Dependencies:
+  //  - loadOlder    — stable per workspaceId (refs decouple it from
+  //                   message updates), so this dep is here for the
+  //                   workspace-switch case only
+  //  - hasMore      — re-run when older history runs out so we
+  //                   disconnect cleanly
+  //  - hasMessages  — load-bearing: the sentinel JSX is gated on
+  //                   `messages.length > 0`, so topRef.current is null
+  //                   on the empty-messages render. We re-arm exactly
+  //                   once when messages first land. NOT depending on
+  //                   `messages.length` (or `messages`) directly so
+  //                   each subsequent message append doesn't tear down
+  //                   + re-arm the observer.
+  const hasMessages = messages.length > 0;
+  useEffect(() => {
+    const top = topRef.current;
+    const container = containerRef.current;
+    if (!top || !container) return;
+    if (!hasMore) return; // stop observing when no older history exists
+    const ac = new AbortController();
+    const io = new IntersectionObserver(
+      (entries) => {
+        if (ac.signal.aborted) return;
+        if (entries[0]?.isIntersecting) loadOlder();
+      },
+      { root: container, rootMargin: "200px 0px 0px 0px", threshold: 0 },
+    );
+    io.observe(top);
+    ac.signal.addEventListener("abort", () => io.disconnect());
+    return () => ac.abort();
+  }, [loadOlder, hasMore, hasMessages]);
 
   // Agent reachability
   useEffect(() => {
     const reachable = data.status === "online" || data.status === "degraded";
     setAgentReachable(reachable);
-    if (reachable) {
-      setError(null);
-      clearSendError();
-    } else {
-      setError(`Agent is ${data.status}`);
-    }
-  }, [data.status, clearSendError]);
+    setError(reachable ? null : `Agent is ${data.status}`);
+  }, [data.status]);
+
+  useEffect(() => {
+    currentTaskRef.current = data.currentTask;
+  }, [data.currentTask]);
 
   // Scroll behavior across messages updates:
   //  - Prepend (loadOlder landed)  → restore the user's saved
@@ -180,24 +518,71 @@ function MyChatPanel({ workspaceId, data }: Props) {
   // paint — otherwise the user sees the page jump for one frame.
   useLayoutEffect(() => {
     const container = containerRef.current;
-    const anchor = history.scrollAnchorRef.current;
+    const anchor = scrollAnchorRef.current;
+    // Only honor the anchor when this messages-update is the prepend
+    // we expected. messages[0].id is the test:
+    //   - prepend  → messages[0] is one of the older rows → id !== expectFirstIdNotEqual
+    //   - append   → messages[0] unchanged → id === expectFirstIdNotEqual → fall through
+    // Without this check, an agent push that lands mid-loadOlder would
+    // run the restore against the append's update, yank the user's
+    // scroll, AND swallow the append's bottom-pin.
     if (
       anchor &&
       container &&
-      history.messages.length > 0 &&
-      history.messages[0].id !== anchor.expectFirstIdNotEqual
+      messages.length > 0 &&
+      messages[0].id !== anchor.expectFirstIdNotEqual
     ) {
       container.scrollTop = container.scrollHeight - anchor.savedDistanceFromBottom;
-      history.scrollAnchorRef.current = null;
+      scrollAnchorRef.current = null;
       return;
     }
-    if (!hasInitialScrollRef.current && history.messages.length > 0) {
+    // Instant on first arrival of messages — smooth-scroll on a long
+    // conversation gets interrupted by concurrent renders and leaves
+    // the user stuck in the middle. After the first jump, subsequent
+    // appends animate as before.
+    if (!hasInitialScrollRef.current && messages.length > 0) {
       hasInitialScrollRef.current = true;
       bottomRef.current?.scrollIntoView({ behavior: "instant" as ScrollBehavior });
       return;
     }
     bottomRef.current?.scrollIntoView({ behavior: "smooth" });
-  }, [history.messages, history.scrollAnchorRef]);
+  }, [messages]);
+
+  // Consume agent push messages (send_message_to_user) from global store.
+  // Runtimes like Claude Code SDK deliver their reply via a WS push rather
+  // than the /a2a HTTP response — when that happens, the push is the
+  // authoritative "reply arrived" signal for the UI, so clear `sending`
+  // here too. The HTTP .then() coordinates through sendingFromAPIRef so
+  // whichever path clears first wins.
+  const pendingAgentMsgs = useCanvasStore((s) => s.agentMessages[workspaceId]);
+  useEffect(() => {
+    if (!pendingAgentMsgs || pendingAgentMsgs.length === 0) return;
+    const consume = useCanvasStore.getState().consumeAgentMessages;
+    const msgs = consume(workspaceId);
+    for (const m of msgs) {
+      // Dedupe in case the agent proactively pushed the same text the
+      // HTTP /a2a response already delivered (observed with the Hermes
+      // runtime, which emits both a reply body and a send_message_to_user
+      // push for the same content). Attachments ride along with the
+      // message so files returned by the A2A_RESPONSE WS path render
+      // their download chips.
+      setMessages((prev) => appendMessageDeduped(prev, createMessage("agent", m.content, m.attachments)));
+    }
+    if (sendingFromAPIRef.current && msgs.length > 0) {
+      // Reply arrived via WS push (e.g. claude-code SDK). Release all
+      // three guards together — without sendInFlightRef the next
+      // sendMessage() silently no-ops at the synchronous re-entry
+      // check.
+      releaseSendGuards();
+    }
+  }, [pendingAgentMsgs, workspaceId]);
+
+  // Resolve workspace ID → name for activity display
+  const resolveWorkspaceName = useCallback((id: string) => {
+    const nodes = useCanvasStore.getState().nodes;
+    const node = nodes.find((n) => n.id === id);
+    return (node?.data as WorkspaceNodeData)?.name || id.slice(0, 8);
+  }, []);
 
   // Elapsed timer while sending
   useEffect(() => {
@@ -224,43 +609,211 @@ function MyChatPanel({ workspaceId, data }: Props) {
     setActivityLog([`Processing with ${runtimeDisplayName(data.runtime)}...`]);
   }, [sending, data.runtime]);
 
-  // IntersectionObserver on the top sentinel. Fires loadOlder() the
-  // moment the user scrolls within 200px of the top. AbortController
-  // unwires cleanly on workspace switch / unmount; root is the
-  // scrollable container so we observe only what's visible inside it.
-  const hasMessages = history.messages.length > 0;
-  useEffect(() => {
-    const top = topRef.current;
-    const container = containerRef.current;
-    if (!top || !container) return;
-    if (!history.hasMore) return;
-    const ac = new AbortController();
-    const io = new IntersectionObserver(
-      (entries) => {
-        if (ac.signal.aborted) return;
-        if (entries[0]?.isIntersecting) history.loadOlder();
-      },
-      { root: container, rootMargin: "200px 0px 0px 0px", threshold: 0 },
-    );
-    io.observe(top);
-    ac.signal.addEventListener("abort", () => io.disconnect());
-    return () => ac.abort();
-  }, [history.loadOlder, history.hasMore, hasMessages]);
+  // Subscribe to global WS via the singleton ReconnectingSocket (no
+  // per-component WebSocket — the previous pattern dropped events
+  // silently on any reconnect because each panel's raw socket had no
+  // onclose handler).
+  useSocketEvent((msg) => {
+    if (!sending) return;
+    try {
+        if (msg.event === "ACTIVITY_LOGGED") {
+          // Filter to events for THIS workspace. The platform's
+          // BroadcastOnly fires to every connected client, and
+          // without this guard a sibling workspace's a2a_send would
+          // surface as "→ Delegating to X..." inside the wrong
+          // chat panel. (workspace_id on the WS envelope is the
+          // workspace whose activity_log row we just wrote.)
+          if (msg.workspace_id !== workspaceId) return;
 
-  const handleSend = async () => {
+          const p = msg.payload || {};
+          const type = p.activity_type as string;
+          const method = (p.method as string) || "";
+          const status = (p.status as string) || "";
+          const targetId = (p.target_id as string) || "";
+          const durationMs = p.duration_ms as number | undefined;
+          const summary = (p.summary as string) || "";
+
+          let line = "";
+          if (type === "a2a_receive" && method === "message/send") {
+            const targetName = resolveWorkspaceName(targetId || msg.workspace_id);
+            if (status === "ok" && durationMs) {
+              const sec = Math.round(durationMs / 1000);
+              line = `← ${targetName} responded (${sec}s)`;
+              // The platform logs a successful a2a_receive once the workspace
+              // has fully produced its reply. That's the authoritative "done"
+              // signal for the spinner — clear it even if the reply hasn't
+              // surfaced through the store yet (it may be delivered shortly
+              // via pendingAgentMsgs or the HTTP .then()).
+              const own = (targetId || msg.workspace_id) === workspaceId;
+              if (own && sendingFromAPIRef.current) {
+                releaseSendGuards();
+              }
+            } else if (status === "error") {
+              line = `⚠ ${targetName} error`;
+              const own = (targetId || msg.workspace_id) === workspaceId;
+              if (own && sendingFromAPIRef.current) {
+                releaseSendGuards();
+                setError("Agent error (Exception) — see workspace logs for details.");
+              }
+            }
+          } else if (type === "a2a_send") {
+            const targetName = resolveWorkspaceName(targetId);
+            line = `→ Delegating to ${targetName}...`;
+          } else if (type === "task_update") {
+            if (summary) line = `⟳ ${summary}`;
+          } else if (type === "agent_log") {
+            // Per-tool-use telemetry from claude_sdk_executor's
+            // _report_tool_use. The summary already carries an icon
+            // + human-readable args (📄 Read /path, ⚡ Bash: …)
+            // so we render it verbatim. No icon prefix here — the
+            // emoji at the start of summary is the visual marker.
+            if (summary) line = summary;
+          }
+
+          if (line) {
+            setActivityLog((prev) => appendActivityLine(prev, line));
+          }
+        } else if (msg.event === "TASK_UPDATED" && msg.workspace_id === workspaceId) {
+          const task = (msg.payload?.current_task as string) || "";
+          if (task) {
+            setActivityLog((prev) => appendActivityLine(prev, `⟳ ${task}`));
+          }
+        }
+        // A2A_RESPONSE is already consumed by the store and its text is
+        // appended to messages via the pendingAgentMsgs effect above; we
+        // don't need to duplicate it here.
+    } catch { /* ignore */ }
+  });
+
+  const sendMessage = async () => {
     const text = input.trim();
-    const files = pendingFiles;
-    if ((!text && files.length === 0) || !agentReachable || sending || uploading) return;
+    const filesToSend = pendingFiles;
+    // Allow sending if EITHER text OR attachments are present — a user
+    // can drop a file with no text and the agent still receives it.
+    if ((!text && filesToSend.length === 0) || !agentReachable || sending || uploading) return;
+    // Synchronous re-entry guard — see sendInFlightRef comment.
+    if (sendInFlightRef.current) return;
+    sendInFlightRef.current = true;
+
+    // Upload attachments first so we can include URIs in the A2A
+    // message parts. Sequential-before-send: a message with references
+    // to files not yet staged would fail agent-side; staging happens
+    // synchronously via /chat/uploads before message/send dispatch.
+    let uploaded: ChatAttachment[] = [];
+    if (filesToSend.length > 0) {
+      setUploading(true);
+      try {
+        uploaded = await uploadChatFiles(workspaceId, filesToSend);
+      } catch (e) {
+        setUploading(false);
+        sendInFlightRef.current = false;
+        setError(e instanceof Error ? `Upload failed: ${e.message}` : "Upload failed");
+        return;
+      }
+      setUploading(false);
+    }
+
     setInput("");
     setPendingFiles([]);
-    clearSendError();
+    setMessages((prev) => [...prev, createMessage("user", text, uploaded)]);
+    setSending(true);
+    sendingFromAPIRef.current = true;
     setError(null);
-    await sendMessage(text, files);
+    // Capture this send's token so the .then()/.catch() callbacks can
+    // detect a newer send that may have superseded them. See the
+    // sendTokenRef declaration for the race scenario this closes.
+    const myToken = ++sendTokenRef.current;
+
+    // Build conversation history from prior messages (last 20)
+    const history = messages
+      .filter((m) => m.role === "user" || m.role === "agent")
+      .slice(-20)
+      .map((m) => ({
+        role: m.role === "user" ? "user" : "agent",
+        parts: [{ kind: "text", text: m.content }],
+      }));
+
+    // A2A parts: text part (if any) + file parts (per attachment). The
+    // agent sees both in a single turn, matching the A2A spec shape.
+    // Wire shape is v0 — see A2APart definition above.
+    const parts: A2APart[] = [];
+    if (text) parts.push({ kind: "text", text });
+    for (const att of uploaded) {
+      parts.push({
+        kind: "file",
+        file: {
+          name: att.name,
+          mimeType: att.mimeType,
+          uri: att.uri,
+          size: att.size,
+        },
+      });
+    }
+
+    // A2A calls can legitimately take minutes — LLM latency +
+    // multi-turn tool use is common on slower providers (Hermes+minimax,
+    // Claude Code invoking bash/file tools, etc.). The 15s default
+    // would silently abort the fetch here, leaving the server to
+    // complete the reply and the user staring at
+    // "agent may be unreachable". Match the upload timeout (60s × 2)
+    // for the happy-path ceiling; anything longer is genuinely stuck.
+    api.post<A2AResponse>(`/workspaces/${workspaceId}/a2a`, {
+      method: "message/send",
+      params: {
+        message: {
+          role: "user",
+          messageId: crypto.randomUUID(),
+          parts,
+        },
+        metadata: { history },
+      },
+    }, { timeoutMs: 120_000 })
+      .then((resp) => {
+        // Bail without touching any flags if a newer sendMessage has
+        // already run — its myToken bumped sendTokenRef, so this is
+        // a stale callback for an earlier message. The newer send
+        // owns the in-flight guards now.
+        if (sendTokenRef.current !== myToken) return;
+        // Skip if the WS A2A_RESPONSE event already handled this response.
+        // Both paths (WS + HTTP) check sendingFromAPIRef — whichever clears
+        // it first wins, the other becomes a no-op (no duplicate messages).
+        if (!sendingFromAPIRef.current) {
+          sendInFlightRef.current = false;
+          return;
+        }
+        const replyText = extractReplyText(resp);
+        const replyFiles = extractFilesFromTask((resp?.result ?? {}) as Record<string, unknown>);
+        if (replyText || replyFiles.length > 0) {
+          setMessages((prev) =>
+            appendMessageDeduped(prev, createMessage("agent", replyText, replyFiles)),
+          );
+        }
+        releaseSendGuards();
+      })
+      .catch(() => {
+        // Stale-callback guard — same rationale as .then().
+        if (sendTokenRef.current !== myToken) return;
+        // Same dedup guard as .then(): if a WS path (pendingAgentMsgs
+        // or ACTIVITY_LOGGED a2a_receive ok) already delivered the
+        // reply, sendingFromAPIRef is already false and there's
+        // nothing to roll back. Surfacing "Failed to send" here would
+        // contradict the agent reply the user is currently reading —
+        // exactly the false-positive observed when the HTTP request
+        // hung up (proxy idle / 502) after WS already won.
+        if (!sendingFromAPIRef.current) {
+          sendInFlightRef.current = false;
+          return;
+        }
+        releaseSendGuards();
+        setError("Failed to send message — agent may be unreachable");
+      });
   };
 
   const onFilesPicked = (fileList: FileList | null) => {
     if (!fileList) return;
     const picked = Array.from(fileList);
+    // Deduplicate against current pending set by name+size — user
+    // picking the same file twice shouldn't append it.
     setPendingFiles((prev) => {
       const keyed = new Set(prev.map((f) => `${f.name}:${f.size}`));
       return [...prev, ...picked.filter((f) => !keyed.has(`${f.name}:${f.size}`))];
@@ -271,7 +824,35 @@ function MyChatPanel({ workspaceId, data }: Props) {
   const removePendingFile = (index: number) =>
     setPendingFiles((prev) => prev.filter((_, i) => i !== index));
 
+  // Monotonic counter so two paste events within the same wall-clock
+  // second still produce distinct filenames. Without this, on
+  // Firefox (where pasted images have an empty `file.name`), two
+  // pastes ~100ms apart could yield identical synthetic names AND
+  // identical sizes, collapsing into one attachment via the
+  // `name:size` dedup in onFilesPicked.
+  const pasteCounterRef = useRef(0);
+
+  /** Paste-from-clipboard image attachment.
+   *
+   *  Browser clipboard image items arrive as `File`s whose `name` is
+   *  often a generic "image.png" (Chrome) or empty (Firefox/Safari),
+   *  so two consecutive screenshot pastes collide on the name+size
+   *  dedup the file-picker uses. Re-tag each pasted image with a
+   *  per-paste unique name so dedup keeps them apart and the upload
+   *  pipeline (which expects a non-empty filename) is happy.
+   *
+   *  Falls through to onFilesPicked via direct File[] (NOT through
+   *  the DataTransfer constructor — that throws on Safari < 14.1
+   *  and old Edge, silently aborting the paste).
+   *
+   *  Only intercepts the paste when the clipboard has at least one
+   *  image; text-only pastes fall through to the textarea's default
+   *  behaviour. */
   const mimeToExt = (mime: string): string => {
+    // Avoid raw `mime.split("/")[1]` — that yields `"svg+xml"`,
+    // `"jpeg"`, `"webp"` etc. which produce ugly filenames and may
+    // trip server-side extension allowlists. Map known types
+    // explicitly; unknown falls back to a safe default.
     if (mime === "image/svg+xml") return "svg";
     if (mime === "image/jpeg") return "jpg";
     if (mime === "image/png") return "png";
@@ -292,16 +873,26 @@ function MyChatPanel({ workspaceId, data }: Props) {
       const file = item.getAsFile();
       if (!file) continue;
       const ext = mimeToExt(file.type);
-      const stamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+      const stamp = new Date()
+        .toISOString()
+        .replace(/[:.]/g, "-")
+        .slice(0, 19);
       const seq = pasteCounterRef.current++;
       const fname = `pasted-${stamp}-${seq}-${i}.${ext}`;
       imageFiles.push(new File([file], fname, { type: file.type }));
     }
     if (imageFiles.length === 0) return;
     e.preventDefault();
+    // Reuse the picker path so file-size guards, dedup, and pending-
+    // list state all run through the same code. Build a synthetic
+    // FileList-like object to avoid the DataTransfer constructor —
+    // that's missing on Safari < 14.1 / old Edge and would silently
+    // throw, leaving the paste a no-op.
     addPastedFiles(imageFiles);
   };
 
+  // Variant of onFilesPicked that accepts a File[] directly, sidestepping
+  // the DataTransfer-FileList round-trip. Same dedup + state shape.
   const addPastedFiles = (files: File[]) => {
     setPendingFiles((prev) => {
       const keyed = new Set(prev.map((f) => `${f.name}:${f.size}`));
@@ -309,6 +900,11 @@ function MyChatPanel({ workspaceId, data }: Props) {
     });
   };
 
+  // Drag-and-drop staging. dragDepthRef counts enter vs leave events so
+  // the overlay doesn't flicker when the cursor crosses nested children
+  // (textarea, buttons) — dragenter/dragleave fire for every boundary.
+  const [dragOver, setDragOver] = useState(false);
+  const dragDepthRef = useRef(0);
   const dropEnabled = agentReachable && !sending && !uploading;
   const isFileDrag = (e: React.DragEvent) =>
     Array.from(e.dataTransfer.types || []).includes("Files");
@@ -338,6 +934,9 @@ function MyChatPanel({ workspaceId, data }: Props) {
   };
 
   const downloadAttachment = (att: ChatAttachment) => {
+    // Errors here are rare but user-visible (401 on a revoked token,
+    // 404 if the agent deleted the file). Surface via the inline
+    // error banner — the message list itself stays untouched.
     downloadChatFile(workspaceId, att).catch((e) => {
       setError(e instanceof Error ? `Download failed: ${e.message}` : "Download failed");
     });
@@ -363,54 +962,28 @@ function MyChatPanel({ workspaceId, data }: Props) {
           </div>
         </div>
       )}
-      {/* talk_to_user disabled banner — shown when the workspace has
-           talk_to_user_enabled=false. The agent cannot send canvas messages;
-           the user can re-enable the ability from here without opening settings. */}
-      {data.talkToUserEnabled === false && (
-        <div className="flex items-center gap-2 px-3 py-2 bg-surface-sunken border-b border-line/40 shrink-0">
-          <svg width="14" height="14" viewBox="0 0 16 16" fill="none" aria-hidden="true" className="shrink-0 text-ink-mid">
-            <path d="M8 1a7 7 0 1 0 0 14A7 7 0 0 0 8 1Zm0 10.5a.75.75 0 1 1 0-1.5.75.75 0 0 1 0 1.5ZM8 4a.75.75 0 0 1 .75.75v4a.75.75 0 0 1-1.5 0v-4A.75.75 0 0 1 8 4Z" fill="currentColor"/>
-          </svg>
-          <span className="text-[10px] text-ink-mid flex-1">
-            Agent is not enabled to chat with you.
-          </span>
-          <button
-            onClick={async () => {
-              try {
-                await api.patch(`/workspaces/${workspaceId}/abilities`, { talk_to_user_enabled: true });
-                useCanvasStore.getState().updateNodeData(workspaceId, { talkToUserEnabled: true });
-              } catch {
-                // ignore — user will see no change and can retry
-              }
-            }}
-            className="px-2 py-0.5 text-[10px] font-medium bg-accent/10 hover:bg-accent/20 text-accent rounded border border-accent/30 transition-colors shrink-0"
-          >
-            Enable
-          </button>
-        </div>
-      )}
       {/* Messages */}
       <div ref={containerRef} className="flex-1 overflow-y-auto p-3 space-y-3">
-        {history.loading && (
+        {loading && (
           <div className="text-xs text-ink-mid text-center py-4">Loading chat history...</div>
         )}
-        {!history.loading && history.loadError !== null && history.messages.length === 0 && (
+        {!loading && loadError !== null && messages.length === 0 && (
           <div
             role="alert"
             className="mx-2 mt-2 rounded-lg border border-red-800/50 bg-red-950/30 px-3 py-2.5"
           >
             <p className="text-[11px] text-bad mb-1.5">
-              Failed to load chat history: {history.loadError}
+              Failed to load chat history: {loadError}
             </p>
             <button
-              onClick={history.loadInitial}
+              onClick={loadInitial}
               className="text-[10px] px-2 py-0.5 rounded bg-red-800 text-red-200 hover:bg-red-700 transition-colors"
             >
               Retry
             </button>
           </div>
         )}
-        {!history.loading && history.loadError === null && history.messages.length === 0 && (
+        {!loading && loadError === null && messages.length === 0 && (
           <div className="text-xs text-ink-mid text-center py-8">
             No messages yet. Send a message to start chatting with this agent.
           </div>
@@ -428,12 +1001,12 @@ function MyChatPanel({ workspaceId, data }: Props) {
             instead of showing a "no more messages" footer — the user's
             scroll resting against the top of the conversation IS the
             signal. */}
-        {history.hasMore && history.messages.length > 0 && (
+        {hasMore && messages.length > 0 && (
           <div ref={topRef} className="text-xs text-ink-mid text-center py-1">
-            {history.loadingOlder ? "Loading older messages…" : " "}
+            {loadingOlder ? "Loading older messages…" : " "}
           </div>
         )}
-        {history.messages.map((msg) => (
+        {messages.map((msg) => (
           <div key={msg.id} className={`flex ${msg.role === "user" ? "justify-end" : "justify-start"}`}>
             <div
               className={`max-w-[85%] rounded-lg px-3 py-2 text-xs ${
@@ -593,10 +1166,10 @@ function MyChatPanel({ workspaceId, data }: Props) {
       </div>
 
       {/* Error banner */}
-      {displayError && (
+      {error && (
         <div className="px-3 py-2 bg-red-900/20 border-t border-red-800/30">
           <div className="flex items-center justify-between">
-            <span className="text-[10px] text-red-300">{displayError}</span>
+            <span className="text-[10px] text-red-300">{error}</span>
             {!isOnline && (
               <button
                 onClick={() => setConfirmRestart(true)}
@@ -664,7 +1237,7 @@ function MyChatPanel({ workspaceId, data }: Props) {
                 e.keyCode !== 229
               ) {
                 e.preventDefault();
-                handleSend();
+                sendMessage();
               }
             }}
             onPaste={onPasteIntoComposer}
@@ -674,7 +1247,7 @@ function MyChatPanel({ workspaceId, data }: Props) {
             className="flex-1 bg-surface-card border border-line rounded-lg px-3 py-2 text-xs text-ink placeholder-ink-soft dark:bg-zinc-800 dark:border-zinc-600 dark:placeholder-zinc-500 focus:outline-none focus:border-accent focus-visible:ring-2 focus-visible:ring-accent/40 resize-none disabled:opacity-50"
           />
           <button
-            onClick={handleSend}
+            onClick={sendMessage}
             disabled={(!input.trim() && pendingFiles.length === 0) || !agentReachable || sending || uploading}
             className="px-4 py-2 bg-accent-strong hover:bg-accent text-xs font-medium rounded-lg text-white disabled:opacity-30 transition-colors shrink-0"
           >

canvas/src/components/tabs/ConfigTab.tsx

@@ -176,7 +176,7 @@ export function deriveProvidersFromModels(models: ModelSpec[]): string[] {
 // exactly the point of the platform adaptor. The deep `~/.hermes/
 // config.yaml` on the container is a separate runtime-internal file,
 // not this one.
-const RUNTIMES_WITH_OWN_CONFIG = new Set<string>(["external", "kimi", "kimi-cli", "openclaw"]);
+const RUNTIMES_WITH_OWN_CONFIG = new Set<string>(["external", "kimi", "kimi-cli"]);
 
 const FALLBACK_RUNTIME_OPTIONS: RuntimeOption[] = [
   { value: "", label: "LangGraph (default)", models: [], providers: [] },

canvas/src/components/tabs/chat/hooks/index.ts

@@ -1,3 +0,0 @@
-export { useChatHistory } from "./useChatHistory";
-export { useChatSend } from "./useChatSend";
-export { useChatSocket } from "./useChatSocket";

canvas/src/components/tabs/chat/hooks/resolveWorkspaceName.ts

@@ -1,11 +0,0 @@
-"use client";
-
-import { useCanvasStore, type WorkspaceNodeData } from "@/store/canvas";
-
-/** Resolve a workspace ID to its human-readable name.
- *  Falls back to the first 8 chars of the ID. */
-export function resolveWorkspaceName(id: string): string {
-  const nodes = useCanvasStore.getState().nodes;
-  const node = nodes.find((n) => n.id === id);
-  return (node?.data as WorkspaceNodeData)?.name || id.slice(0, 8);
-}

canvas/src/components/tabs/chat/hooks/useChatHistory.ts

@@ -1,134 +0,0 @@
-"use client";
-
-import { useCallback, useEffect, useRef, useState } from "react";
-import { api } from "@/lib/api";
-import { type ChatMessage, appendMessageDeduped as appendMessageDedupedFn } from "../types";
-
-const INITIAL_HISTORY_LIMIT = 10;
-const OLDER_HISTORY_BATCH = 20;
-
-async function loadMessagesFromDB(
-  workspaceId: string,
-  limit: number,
-  beforeTs?: string,
-): Promise<{ messages: ChatMessage[]; error: string | null; reachedEnd: boolean }> {
-  try {
-    const params = new URLSearchParams({ limit: String(limit) });
-    if (beforeTs) params.set("before_ts", beforeTs);
-    const resp = await api.get<{ messages: ChatMessage[]; reached_end: boolean }>(
-      `/workspaces/${workspaceId}/chat-history?${params.toString()}`,
-    );
-    return {
-      messages: resp.messages ?? [],
-      error: null,
-      reachedEnd: resp.reached_end,
-    };
-  } catch (err) {
-    return {
-      messages: [],
-      error: err instanceof Error ? err.message : "Failed to load chat history",
-      reachedEnd: true,
-    };
-  }
-}
-
-export interface ScrollAnchor {
-  savedDistanceFromBottom: number;
-  expectFirstIdNotEqual: string | null;
-}
-
-export function useChatHistory(
-  workspaceId: string,
-  containerRef?: React.RefObject<HTMLDivElement | null>,
-) {
-  const [messages, setMessages] = useState<ChatMessage[]>([]);
-  const [loading, setLoading] = useState(true);
-  const [loadError, setLoadError] = useState<string | null>(null);
-  const [loadingOlder, setLoadingOlder] = useState(false);
-  const [hasMore, setHasMore] = useState(true);
-
-  const fetchTokenRef = useRef(0);
-  const oldestMessageRef = useRef<ChatMessage | null>(null);
-  const hasMoreRef = useRef(true);
-  const inflightRef = useRef(false);
-  const scrollAnchorRef = useRef<ScrollAnchor | null>(null);
-
-  useEffect(() => {
-    oldestMessageRef.current = messages[0] ?? null;
-  }, [messages]);
-
-  useEffect(() => {
-    hasMoreRef.current = hasMore;
-  }, [hasMore]);
-
-  const loadInitial = useCallback(() => {
-    setLoading(true);
-    setLoadError(null);
-    setHasMore(true);
-    fetchTokenRef.current += 1;
-    const myToken = fetchTokenRef.current;
-    return loadMessagesFromDB(workspaceId, INITIAL_HISTORY_LIMIT).then(
-      ({ messages: msgs, error: fetchErr, reachedEnd }) => {
-        if (fetchTokenRef.current !== myToken) return;
-        setMessages(msgs);
-        setLoadError(fetchErr);
-        setHasMore(!reachedEnd);
-        setLoading(false);
-      },
-    );
-  }, [workspaceId]);
-
-  useEffect(() => {
-    loadInitial();
-  }, [loadInitial]);
-
-  const loadOlder = useCallback(async () => {
-    if (inflightRef.current || !hasMoreRef.current) return;
-    const oldest = oldestMessageRef.current;
-    if (!oldest) return;
-    const container = containerRef?.current;
-    if (!container) return;
-    inflightRef.current = true;
-    scrollAnchorRef.current = {
-      savedDistanceFromBottom: container.scrollHeight - container.scrollTop,
-      expectFirstIdNotEqual: oldest.id,
-    };
-    fetchTokenRef.current += 1;
-    const myToken = fetchTokenRef.current;
-    setLoadingOlder(true);
-    try {
-      const { messages: older, reachedEnd } = await loadMessagesFromDB(
-        workspaceId,
-        OLDER_HISTORY_BATCH,
-        oldest.timestamp,
-      );
-      if (fetchTokenRef.current !== myToken) {
-        scrollAnchorRef.current = null;
-        return;
-      }
-      if (older.length > 0) {
-        setMessages((prev) => [...older, ...prev]);
-      } else {
-        scrollAnchorRef.current = null;
-      }
-      setHasMore(!reachedEnd);
-    } finally {
-      setLoadingOlder(false);
-      inflightRef.current = false;
-    }
-  }, [workspaceId, containerRef]);
-
-  return {
-    messages,
-    loading,
-    loadError,
-    loadingOlder,
-    hasMore,
-    loadInitial,
-    loadOlder,
-    appendMessageDeduped: (msg: ChatMessage) =>
-      setMessages((prev) => appendMessageDedupedFn(prev, msg)),
-    setMessages,
-    scrollAnchorRef,
-  };
-}

canvas/src/components/tabs/chat/hooks/useChatSend.ts

@@ -1,182 +0,0 @@
-"use client";
-
-import { useCallback, useRef, useState } from "react";
-import { api } from "@/lib/api";
-import { uploadChatFiles } from "../uploads";
-import { createMessage, type ChatMessage, type ChatAttachment } from "../types";
-import { extractFilesFromTask } from "../message-parser";
-
-interface A2APart {
-  kind: string;
-  text?: string;
-  file?: {
-    name?: string;
-    mimeType?: string;
-    uri?: string;
-    size?: number;
-  };
-}
-
-interface A2AResponse {
-  result?: {
-    parts?: A2APart[];
-    artifacts?: Array<{ parts: A2APart[] }>;
-  };
-}
-
-export function extractReplyText(resp: A2AResponse): string {
-  const collect = (parts: A2APart[] | undefined): string => {
-    if (!parts) return "";
-    return parts
-      .filter((p) => p.kind === "text")
-      .map((p) => p.text ?? "")
-      .filter(Boolean)
-      .join("\n");
-  };
-  const result = resp?.result;
-  const collected: string[] = [];
-  const fromParts = collect(result?.parts);
-  if (fromParts) collected.push(fromParts);
-  if (result?.artifacts) {
-    for (const a of result.artifacts) {
-      const t = collect(a.parts);
-      if (t) collected.push(t);
-    }
-  }
-  return collected.join("\n");
-}
-
-export interface UseChatSendOptions {
-  getHistoryMessages: () => ChatMessage[];
-  onUserMessage?: (msg: ChatMessage) => void;
-  onAgentMessage?: (msg: ChatMessage) => void;
-}
-
-export function useChatSend(workspaceId: string, options: UseChatSendOptions) {
-  const [sending, setSending] = useState(false);
-  const [uploading, setUploading] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-  const sendInFlightRef = useRef(false);
-  const sendingFromAPIRef = useRef(false);
-  const sendTokenRef = useRef(0);
-  const optionsRef = useRef(options);
-  optionsRef.current = options;
-
-  const releaseSendGuards = useCallback(() => {
-    setSending(false);
-    sendingFromAPIRef.current = false;
-    sendInFlightRef.current = false;
-  }, []);
-
-  const clearError = useCallback(() => setError(null), []);
-
-  const sendMessage = useCallback(
-    async (text: string, files: File[] = []) => {
-      const trimmed = text.trim();
-      if ((!trimmed && files.length === 0) || sending || uploading) return;
-      if (sendInFlightRef.current) return;
-      sendInFlightRef.current = true;
-
-      let uploaded: ChatAttachment[] = [];
-      if (files.length > 0) {
-        setUploading(true);
-        try {
-          uploaded = await uploadChatFiles(workspaceId, files);
-        } catch (e) {
-          setUploading(false);
-          sendInFlightRef.current = false;
-          setError(
-            e instanceof Error ? `Upload failed: ${e.message}` : "Upload failed",
-          );
-          return;
-        }
-        setUploading(false);
-      }
-
-      const userMsg = createMessage("user", trimmed, uploaded);
-      optionsRef.current.onUserMessage?.(userMsg);
-
-      setSending(true);
-      sendingFromAPIRef.current = true;
-      setError(null);
-      const myToken = ++sendTokenRef.current;
-
-      const history = optionsRef.current
-        .getHistoryMessages()
-        .filter((m) => m.role === "user" || m.role === "agent")
-        .slice(-20)
-        .map((m) => ({
-          role: m.role === "user" ? "user" : "agent",
-          parts: [{ kind: "text", text: m.content }],
-        }));
-
-      const parts: A2APart[] = [];
-      if (trimmed) parts.push({ kind: "text", text: trimmed });
-      for (const att of uploaded) {
-        parts.push({
-          kind: "file",
-          file: {
-            name: att.name,
-            mimeType: att.mimeType,
-            uri: att.uri,
-            size: att.size,
-          },
-        });
-      }
-
-      api
-        .post<A2AResponse>(
-          `/workspaces/${workspaceId}/a2a`,
-          {
-            method: "message/send",
-            params: {
-              message: {
-                role: "user",
-                messageId: crypto.randomUUID(),
-                parts,
-              },
-              metadata: { history },
-            },
-          },
-          { timeoutMs: 120_000 },
-        )
-        .then((resp) => {
-          if (sendTokenRef.current !== myToken) return;
-          if (!sendingFromAPIRef.current) {
-            sendInFlightRef.current = false;
-            return;
-          }
-          const replyText = extractReplyText(resp);
-          const replyFiles = extractFilesFromTask(
-            (resp?.result ?? {}) as Record<string, unknown>,
-          );
-          if (replyText || replyFiles.length > 0) {
-            optionsRef.current.onAgentMessage?.(
-              createMessage("agent", replyText, replyFiles),
-            );
-          }
-          releaseSendGuards();
-        })
-        .catch(() => {
-          if (sendTokenRef.current !== myToken) return;
-          if (!sendingFromAPIRef.current) {
-            sendInFlightRef.current = false;
-            return;
-          }
-          releaseSendGuards();
-          setError("Failed to send message — agent may be unreachable");
-        });
-    },
-    [workspaceId, sending, uploading],
-  );
-
-  return {
-    sending,
-    uploading,
-    sendMessage,
-    error,
-    clearError,
-    releaseSendGuards,
-    sendingFromAPIRef,
-  };
-}

canvas/src/components/tabs/chat/hooks/useChatSocket.ts

@@ -1,100 +0,0 @@
-"use client";
-
-import { useCallback, useEffect, useRef } from "react";
-import { useCanvasStore, type WorkspaceNodeData } from "@/store/canvas";
-import { useSocketEvent } from "@/hooks/useSocketEvent";
-import { createMessage, type ChatMessage } from "../types";
-
-export interface UseChatSocketCallbacks {
-  onAgentMessage?: (msg: ChatMessage) => void;
-  onActivityLog?: (entry: string) => void;
-  onSendComplete?: () => void;
-  onSendError?: (error: string) => void;
-}
-
-export function useChatSocket(
-  workspaceId: string,
-  callbacks: UseChatSocketCallbacks,
-): void {
-  const callbacksRef = useRef(callbacks);
-  callbacksRef.current = callbacks;
-
-  // Agent push messages from global store
-  const pendingAgentMsgs = useCanvasStore((s) => s.agentMessages[workspaceId]);
-  useEffect(() => {
-    if (!pendingAgentMsgs || pendingAgentMsgs.length === 0) return;
-    const consume = useCanvasStore.getState().consumeAgentMessages;
-    const msgs = consume(workspaceId);
-    for (const m of msgs) {
-      callbacksRef.current.onAgentMessage?.(
-        createMessage("agent", m.content, m.attachments),
-      );
-    }
-    if (msgs.length > 0) {
-      callbacksRef.current.onSendComplete?.();
-    }
-  }, [pendingAgentMsgs, workspaceId]);
-
-  const resolveWorkspaceName = useCallback((id: string) => {
-    const nodes = useCanvasStore.getState().nodes;
-    const node = nodes.find((n) => n.id === id);
-    return (node?.data as WorkspaceNodeData)?.name || id.slice(0, 8);
-  }, []);
-
-  useSocketEvent((msg) => {
-    try {
-      if (msg.event === "ACTIVITY_LOGGED") {
-        if (msg.workspace_id !== workspaceId) return;
-
-        const p = msg.payload || {};
-        const type = p.activity_type as string;
-        const method = (p.method as string) || "";
-        const status = (p.status as string) || "";
-        const targetId = (p.target_id as string) || "";
-        const durationMs = p.duration_ms as number | undefined;
-        const summary = (p.summary as string) || "";
-
-        let line = "";
-        if (type === "a2a_receive" && method === "message/send") {
-          const targetName = resolveWorkspaceName(targetId || msg.workspace_id);
-          if (status === "ok" && durationMs) {
-            const sec = Math.round(durationMs / 1000);
-            line = `← ${targetName} responded (${sec}s)`;
-            const own = (targetId || msg.workspace_id) === workspaceId;
-            if (own) callbacksRef.current.onSendComplete?.();
-          } else if (status === "error") {
-            line = `⚠ ${targetName} error`;
-            const own = (targetId || msg.workspace_id) === workspaceId;
-            if (own) {
-              callbacksRef.current.onSendComplete?.();
-              callbacksRef.current.onSendError?.(
-                "Agent error (Exception) — see workspace logs for details.",
-              );
-            }
-          }
-        } else if (type === "a2a_send") {
-          const targetName = resolveWorkspaceName(targetId);
-          line = `→ Delegating to ${targetName}...`;
-        } else if (type === "task_update") {
-          if (summary) line = `⟳ ${summary}`;
-        } else if (type === "agent_log") {
-          if (summary) line = summary;
-        }
-
-        if (line) {
-          callbacksRef.current.onActivityLog?.(line);
-        }
-      } else if (
-        msg.event === "TASK_UPDATED" &&
-        msg.workspace_id === workspaceId
-      ) {
-        const task = (msg.payload?.current_task as string) || "";
-        if (task) {
-          callbacksRef.current.onActivityLog?.(`⟳ ${task}`);
-        }
-      }
-    } catch {
-      /* ignore */
-    }
-  });
-}

canvas/src/components/tabs/chat/index.ts

@@ -1,5 +1,2 @@
 export { type ChatMessage, createMessage, appendMessageDeduped } from "./types";
 export { extractAgentText, extractTextsFromParts, extractResponseText } from "./message-parser";
-export { useChatHistory } from "./hooks/useChatHistory";
-export { useChatSend } from "./hooks/useChatSend";
-export { useChatSocket } from "./hooks/useChatSocket";

canvas/src/hooks/useTemplateDeploy.tsx

@@ -8,7 +8,6 @@ import {
   type PreflightResult,
   type Template,
 } from "@/lib/deploy-preflight";
-import { isSaaSTenant } from "@/lib/tenant";
 import { MissingKeysModal } from "@/components/MissingKeysModal";
 
 /**
@@ -106,7 +105,7 @@ export function useTemplateDeploy(
         const ws = await api.post<{ id: string }>("/workspaces", {
           name: template.name,
           template: template.id,
-          tier: isSaaSTenant() ? 4 : template.tier,
+          tier: template.tier,
           canvas: coords,
           ...(model ? { model } : {}),
         });

canvas/src/lib/api.ts

@@ -8,18 +8,14 @@ import { getTenantSlug } from "./tenant";
 export const PLATFORM_URL =
   process.env.NEXT_PUBLIC_PLATFORM_URL ?? "http://localhost:8080";
 
-// 35s is long enough for the slowest server-side path (EIC SSH
-// tunnel for tenant EC2 file operations, bounded server-side by
-// `eicFileOpTimeout = 30 * time.Second` in
-// workspace-server/internal/handlers/template_files_eic.go) so the
-// canvas surfaces the server's real error instead of aborting first
-// with a generic timeout. Shorter values caused "Save & Restart" to
-// time out at the client before the backend returned its 5xx. The
-// abort still propagates through AbortController so React components
-// can render a retry affordance. Callers that know an endpoint is
-// intentionally slow (org import walks a tree of workspaces with
-// server-side pacing) can pass `timeoutMs` to override.
-const DEFAULT_TIMEOUT_MS = 35_000;
+// 15s is long enough for slow CP queries but short enough that a
+// hung backend doesn't leave the UI spinning forever. The abort
+// propagates through AbortController so React components can observe
+// the error and render a retry affordance. Callers that know the
+// endpoint is intentionally slow (org import walks a tree of
+// workspaces with server-side pacing) can pass `timeoutMs` to
+// override.
+const DEFAULT_TIMEOUT_MS = 15_000;
 
 export interface RequestOptions {
   timeoutMs?: number;

canvas/src/store/canvas-topology.ts

@@ -519,10 +519,6 @@ export function buildNodesAndEdges(
         // #2054 — server-declared per-workspace provisioning timeout.
         // Falls through to the runtime profile when null/absent.
         provisionTimeoutMs: ws.provision_timeout_ms ?? null,
-        // Workspace abilities — defaults preserved for old platform versions
-        // that don't yet include these columns in the GET response.
-        broadcastEnabled: ws.broadcast_enabled ?? false,
-        talkToUserEnabled: ws.talk_to_user_enabled ?? true,
       },
     };
     if (hasParent) {

canvas/src/store/canvas.ts

@@ -99,13 +99,6 @@ export interface WorkspaceNodeData extends Record<string, unknown> {
    *  @/lib/runtimeProfiles. Lets a slow runtime declare its cold-boot
    *  expectation without a canvas release. */
   provisionTimeoutMs?: number | null;
-  /** When true the workspace may POST /broadcast to send org-wide messages.
-   *  Default false. Toggled by user/admin via PATCH /workspaces/:id/abilities. */
-  broadcastEnabled?: boolean;
-  /** When false the workspace cannot deliver canvas chat messages.
-   *  send_message_to_user / POST /notify return 403 and the canvas
-   *  shows a "not enabled" state with a button to re-enable. Default true. */
-  talkToUserEnabled?: boolean;
 }
 
 export type PanelTab = "details" | "skills" | "chat" | "terminal" | "config" | "schedule" | "channels" | "files" | "memory" | "traces" | "events" | "activity" | "audit";

canvas/src/store/socket.ts

@@ -299,9 +299,6 @@ export interface WorkspaceData {
    *  `@/lib/runtimeProfiles` when absent (the default behavior for any
    *  template that hasn't yet declared the field). */
   provision_timeout_ms?: number | null;
-  /** Workspace ability flags (migration 20260514). */
-  broadcast_enabled?: boolean;
-  talk_to_user_enabled?: boolean;
 }
 
 let socket: ReconnectingSocket | null = null;

manifest.json

@@ -30,7 +30,10 @@
     {"name": "openclaw", "repo": "molecule-ai/molecule-ai-workspace-template-openclaw", "ref": "main"},
     {"name": "codex", "repo": "molecule-ai/molecule-ai-workspace-template-codex", "ref": "main"},
     {"name": "langgraph", "repo": "molecule-ai/molecule-ai-workspace-template-langgraph", "ref": "main"},
-    {"name": "autogen", "repo": "molecule-ai/molecule-ai-workspace-template-autogen", "ref": "main"}
+    {"name": "crewai", "repo": "molecule-ai/molecule-ai-workspace-template-crewai", "ref": "main"},
+    {"name": "autogen", "repo": "molecule-ai/molecule-ai-workspace-template-autogen", "ref": "main"},
+    {"name": "deepagents", "repo": "molecule-ai/molecule-ai-workspace-template-deepagents", "ref": "main"},
+    {"name": "gemini-cli", "repo": "molecule-ai/molecule-ai-workspace-template-gemini-cli", "ref": "main"}
   ],
   "org_templates": [
     {"name": "molecule-dev", "repo": "molecule-ai/molecule-ai-org-template-molecule-dev", "ref": "main"},

tests/e2e/test_peer_visibility_mcp_staging.sh

@@ -1,376 +0,0 @@
-#!/usr/bin/env bash
-# Staging E2E — fresh-provision peer-visibility gate via the LITERAL MCP path.
-#
-# WHY THIS EXISTS
-# ---------------
-# Hermes and OpenClaw were repeatedly reported "fleet-verified / cascade-
-# complete" because the *proxy* signals were green:
-#   - registry-registration + heartbeat (Hermes), and
-#   - model round-trip 200 (OpenClaw).
-# But a freshly-provisioned workspace, asked on canvas "can you see your
-# peers", actually FAILS:
-#   - Hermes: 401 on the molecule MCP `list_peers` call,
-#   - OpenClaw: falls back to native `sessions_list`, sees no platform peers.
-# Tasks #142/#159 were even marked "completed" under this same proxy flaw.
-#
-# This script codifies the LITERAL user-facing path so it can never silently
-# regress: it provisions a brand-new throwaway org + sibling workspaces via
-# the real control-plane provisioning path, then for each runtime that should
-# have platform peer-visibility it drives the EXACT MCP call the canvas agent
-# makes — `POST /workspaces/:id/mcp` JSON-RPC tools/call name=list_peers,
-# authenticated by that workspace's own bearer token through the real
-# WorkspaceAuth + MCPRateLimiter middleware chain. It then asserts:
-#   (1) HTTP 200,
-#   (2) JSON-RPC `result` present (NOT an `error` object — a -32000
-#       "tool call failed" or a 401 from WorkspaceAuth fails here),
-#   (3) the returned peer set CONTAINS the other provisioned sibling
-#       workspace IDs — not an empty list, not a native-sessions fallback.
-#
-# This is NOT a proxy. It does not look at a registry row, /health, the
-# heartbeat table, or `GET /registry/:id/peers`. It drives the byte-for-byte
-# JSON-RPC envelope that mcp_molecule_list_peers issues from a real agent.
-#
-# It is written to FAIL on today's broken Hermes/OpenClaw behavior and go
-# green only when the in-flight root-cause fixes (Hermes-401, OpenClaw MCP
-# wiring) actually land. That is the point: it is the objective proof gate.
-#
-# AUTH MODEL (mirrors tests/e2e/test_staging_full_saas.sh)
-# --------------------------------------------------------
-#   Single MOLECULE_ADMIN_TOKEN (= CP_ADMIN_API_TOKEN on Railway staging)
-#   drives: POST /cp/admin/orgs (provision), GET
-#   /cp/admin/orgs/:slug/admin-token (per-tenant token), DELETE
-#   /cp/admin/tenants/:slug (teardown). The per-tenant admin token drives
-#   tenant workspace creation; each workspace's OWN auth_token (returned by
-#   POST /workspaces) drives its MCP call.
-#
-# Required env:
-#   MOLECULE_ADMIN_TOKEN   CP admin bearer — Railway staging CP_ADMIN_API_TOKEN
-# Optional env:
-#   MOLECULE_CP_URL        default https://staging-api.moleculesai.app
-#   E2E_RUN_ID             slug suffix; CI passes ${GITHUB_RUN_ID}
-#   PV_RUNTIMES            space list; default "hermes openclaw claude-code"
-#   E2E_PROVISION_TIMEOUT_SECS  default 1800 (hermes/openclaw cold EC2 budget)
-#   E2E_MINIMAX_API_KEY / E2E_ANTHROPIC_API_KEY / E2E_OPENAI_API_KEY
-#                          LLM provider key injected so the runtime can boot
-#   E2E_KEEP_ORG           1 → skip teardown (local debugging only)
-#
-# Exit codes:
-#   0  every runtime saw its peers via the literal MCP call
-#   1  generic failure
-#   2  missing required env
-#   3  provisioning timed out
-#   4  teardown left orphan resources
-#   10 peer-visibility regression reproduced (the gate firing as designed)
-
-set -uo pipefail
-
-CP_URL="${MOLECULE_CP_URL:-https://staging-api.moleculesai.app}"
-ADMIN_TOKEN="${MOLECULE_ADMIN_TOKEN:?MOLECULE_ADMIN_TOKEN required — Railway staging CP_ADMIN_API_TOKEN}"
-RUN_ID_SUFFIX="${E2E_RUN_ID:-$(date +%H%M%S)-$$}"
-PV_RUNTIMES="${PV_RUNTIMES:-hermes openclaw claude-code}"
-PROVISION_TIMEOUT_SECS="${E2E_PROVISION_TIMEOUT_SECS:-1800}"
-
-# Slug MUST start with 'e2e-' so the sweep-stale-e2e-orgs safety net
-# (EPHEMERAL_PREFIXES) catches any leak this run fails to tear down.
-SLUG="e2e-pv-$(date +%Y%m%d)-${RUN_ID_SUFFIX}"
-SLUG=$(echo "$SLUG" | tr '[:upper:]' '[:lower:]' | tr -cd 'a-z0-9-' | head -c 32)
-
-ORG_ID=""
-TENANT_URL=""
-TENANT_TOKEN=""
-
-log()  { echo "[$(date +%H:%M:%S)] $*"; }
-fail() { echo "[$(date +%H:%M:%S)] ❌ $*" >&2; exit 1; }
-ok()   { echo "[$(date +%H:%M:%S)] ✅ $*"; }
-
-admin_call() {
-  local method="$1" path="$2"; shift 2
-  curl -sS -X "$method" "$CP_URL$path" \
-    -H "Authorization: Bearer $ADMIN_TOKEN" \
-    -H "Content-Type: application/json" "$@"
-}
-tenant_call() {
-  local method="$1" path="$2"; shift 2
-  curl -sS -X "$method" "$TENANT_URL$path" \
-    -H "Authorization: Bearer $TENANT_TOKEN" \
-    -H "X-Molecule-Org-Id: $ORG_ID" \
-    -H "Content-Type: application/json" "$@"
-}
-
-# ─── Scoped teardown ───────────────────────────────────────────────────
-# Deletes ONLY the org this run created (DELETE /cp/admin/tenants/$SLUG
-# with the {"confirm":$SLUG} fat-finger guard). Never a cluster-wide
-# sweep — honors feedback_cleanup_after_each_test and
-# feedback_never_run_cluster_cleanup_tests_on_live_platform. The
-# workflow's always() step + sweep-stale-e2e-orgs are the outer nets.
-teardown() {
-  local rc=$?
-  set +e
-  if [ "${E2E_KEEP_ORG:-0}" = "1" ]; then
-    echo ""
-    log "[teardown] E2E_KEEP_ORG=1 — leaving $SLUG for debugging (REMEMBER TO DELETE)"
-    exit $rc
-  fi
-  echo ""
-  log "[teardown] DELETE /cp/admin/tenants/$SLUG (scoped to this run only)"
-  admin_call DELETE "/cp/admin/tenants/$SLUG" --max-time 120 \
-    -d "{\"confirm\":\"$SLUG\"}" >/dev/null 2>&1
-  for j in $(seq 1 24); do
-    LIST=$(admin_call GET "/cp/admin/orgs?limit=500" 2>/dev/null)
-    LEAK=$(echo "$LIST" | python3 -c "
-import sys, json
-try: d = json.load(sys.stdin)
-except Exception: print(1); sys.exit(0)
-orgs = d if isinstance(d, list) else d.get('orgs', [])
-print(sum(1 for o in orgs if o.get('slug') == '$SLUG' and o.get('instance_status') not in ('purged',) and o.get('status') != 'purged'))
-" 2>/dev/null || echo 1)
-    if [ "$LEAK" = "0" ]; then
-      log "[teardown] ✓ $SLUG purged (after ${j}x5s)"
-      exit $rc
-    fi
-    sleep 5
-  done
-  echo "::warning::[teardown] $SLUG still present after 120s — sweep-stale-e2e-orgs will catch it within MAX_AGE_MINUTES" >&2
-  [ $rc -eq 0 ] && rc=4
-  exit $rc
-}
-trap teardown EXIT INT TERM
-
-# ─── 1. Provision the throwaway org ────────────────────────────────────
-log "1/6 POST /cp/admin/orgs — slug=$SLUG"
-CREATE=$(admin_call POST /cp/admin/orgs \
-  -d "{\"slug\":\"$SLUG\",\"name\":\"E2E peer-visibility $SLUG\",\"owner_user_id\":\"e2e-runner:$SLUG\"}")
-ORG_ID=$(echo "$CREATE" | python3 -c "import sys,json; print(json.load(sys.stdin).get('id',''))" 2>/dev/null)
-[ -n "$ORG_ID" ] || fail "org creation failed: $(echo "$CREATE" | head -c 300)"
-log "    ORG_ID=$ORG_ID"
-
-# ─── 2. Wait for tenant EC2 + DNS ──────────────────────────────────────
-log "2/6 waiting for tenant instance_status=running (cold EC2 + cloudflared)..."
-DEADLINE=$(( $(date +%s) + PROVISION_TIMEOUT_SECS ))
-while true; do
-  [ "$(date +%s)" -gt "$DEADLINE" ] && fail "tenant never came up within ${PROVISION_TIMEOUT_SECS}s"
-  STATUS=$(admin_call GET "/cp/admin/orgs?limit=500" 2>/dev/null | python3 -c "
-import sys, json
-try: d = json.load(sys.stdin)
-except Exception: sys.exit(0)
-orgs = d if isinstance(d, list) else d.get('orgs', [])
-for o in orgs:
-    if o.get('slug') == '$SLUG':
-        print(o.get('instance_status') or o.get('status') or 'unknown'); break
-" 2>/dev/null)
-  case "$STATUS" in running|online|ready) break ;; esac
-  sleep 10
-done
-log "    tenant status=$STATUS"
-
-# ─── 3. Per-tenant admin token + tenant URL ────────────────────────────
-log "3/6 fetching per-tenant admin token..."
-TT_RESP=$(admin_call GET "/cp/admin/orgs/$SLUG/admin-token")
-TENANT_TOKEN=$(echo "$TT_RESP" | python3 -c "import sys,json; print(json.load(sys.stdin).get('admin_token',''))" 2>/dev/null)
-[ -n "$TENANT_TOKEN" ] || fail "tenant token fetch failed: $(echo "$TT_RESP" | head -c 200)"
-
-CP_HOST=$(echo "$CP_URL" | sed -E 's#^https?://##; s#/.*$##')
-case "$CP_HOST" in
-  api.*)         DERIVED_DOMAIN="${CP_HOST#api.}" ;;
-  staging-api.*) DERIVED_DOMAIN="staging.${CP_HOST#staging-api.}" ;;
-  *)             DERIVED_DOMAIN="$CP_HOST" ;;
-esac
-TENANT_URL="https://${SLUG}.${DERIVED_DOMAIN}"
-log "    tenant url: $TENANT_URL"
-
-log "3b. waiting for tenant /health (TLS/DNS, up to 10min)..."
-for i in $(seq 1 120); do
-  curl -fsS "$TENANT_URL/health" -m 5 -k >/dev/null 2>&1 && { log "    /health ok (attempt $i)"; break; }
-  sleep 5
-done
-
-# ─── 4. Provision the parent + one sibling per runtime under test ──────
-# Inject the LLM provider key so each runtime can authenticate at boot.
-# Priority: MiniMax → direct-Anthropic → OpenAI (mirrors
-# test_staging_full_saas.sh's secrets-injection chain).
-SECRETS_JSON='{}'
-if [ -n "${E2E_MINIMAX_API_KEY:-}" ]; then
-  SECRETS_JSON=$(python3 -c "import json,os;k=os.environ['E2E_MINIMAX_API_KEY'];print(json.dumps({'ANTHROPIC_BASE_URL':'https://api.minimax.io/anthropic','ANTHROPIC_AUTH_TOKEN':k,'MINIMAX_API_KEY':k}))")
-elif [ -n "${E2E_ANTHROPIC_API_KEY:-}" ]; then
-  SECRETS_JSON=$(python3 -c "import json,os;k=os.environ['E2E_ANTHROPIC_API_KEY'];print(json.dumps({'ANTHROPIC_API_KEY':k}))")
-elif [ -n "${E2E_OPENAI_API_KEY:-}" ]; then
-  SECRETS_JSON=$(python3 -c "import json,os;k=os.environ['E2E_OPENAI_API_KEY'];print(json.dumps({'OPENAI_API_KEY':k,'OPENAI_BASE_URL':'https://api.openai.com/v1','MODEL_PROVIDER':'openai:gpt-4o','HERMES_INFERENCE_PROVIDER':'custom','HERMES_CUSTOM_BASE_URL':'https://api.openai.com/v1','HERMES_CUSTOM_API_KEY':k,'HERMES_CUSTOM_API_MODE':'chat_completions'}))")
-fi
-
-log "4/6 provisioning parent (claude-code) + one sibling per runtime under test..."
-P_RESP=$(tenant_call POST /workspaces \
-  -d "{\"name\":\"pv-parent\",\"runtime\":\"claude-code\",\"tier\":3,\"secrets\":$SECRETS_JSON}")
-PARENT_ID=$(echo "$P_RESP" | python3 -c "import sys,json; print(json.load(sys.stdin).get('id',''))" 2>/dev/null)
-[ -n "$PARENT_ID" ] || fail "parent create failed: $(echo "$P_RESP" | head -c 300)"
-log "    PARENT_ID=$PARENT_ID"
-
-# WS_IDS[runtime]=id ; WS_TOKENS[runtime]=auth_token (the MCP bearer)
-declare -A WS_IDS WS_TOKENS
-ALL_WS_IDS="$PARENT_ID"
-for rt in $PV_RUNTIMES; do
-  R=$(tenant_call POST /workspaces \
-    -d "{\"name\":\"pv-$rt\",\"runtime\":\"$rt\",\"tier\":2,\"parent_id\":\"$PARENT_ID\",\"secrets\":$SECRETS_JSON}")
-  WID=$(echo "$R" | python3 -c "import sys,json; print(json.load(sys.stdin).get('id',''))" 2>/dev/null)
-  # auth_token is top-level for container runtimes; external-like nest it
-  # under connection.auth_token (verified vs staging response shape).
-  WTOK=$(echo "$R" | python3 -c "
-import sys, json
-try: d = json.load(sys.stdin)
-except Exception: print(''); sys.exit(0)
-print(d.get('auth_token') or d.get('connection', {}).get('auth_token') or '')
-" 2>/dev/null)
-  [ -n "$WID" ] || fail "$rt workspace create failed: $(echo "$R" | head -c 300)"
-  [ -n "$WTOK" ] || fail "$rt workspace did not return an auth_token — cannot drive its MCP call (resp: $(echo "$R" | head -c 300))"
-  WS_IDS[$rt]="$WID"
-  WS_TOKENS[$rt]="$WTOK"
-  ALL_WS_IDS="$ALL_WS_IDS $WID"
-  log "    $rt → $WID"
-done
-
-# ─── 5. Wait for every sibling online ──────────────────────────────────
-log "5/6 waiting for all workspaces status=online (up to ${PROVISION_TIMEOUT_SECS}s — cold boot)..."
-WS_DEADLINE=$(( $(date +%s) + PROVISION_TIMEOUT_SECS ))
-for rt in $PV_RUNTIMES; do
-  wid="${WS_IDS[$rt]}"
-  LAST=""
-  while true; do
-    [ "$(date +%s)" -gt "$WS_DEADLINE" ] && fail "$rt ($wid) never reached online (last=$LAST)"
-    S=$(tenant_call GET "/workspaces/$wid" 2>/dev/null | python3 -c "
-import sys, json
-try: d = json.load(sys.stdin)
-except Exception: sys.exit(0)
-w = d.get('workspace') if isinstance(d.get('workspace'), dict) else d
-print(w.get('status') or '')
-" 2>/dev/null)
-    [ "$S" != "$LAST" ] && { log "    $rt → $S"; LAST="$S"; }
-    case "$S" in
-      online) break ;;
-      failed) sleep 10 ;;   # transient: bootstrap-watcher 5-min deadline, heartbeat recovers
-      *)      sleep 10 ;;
-    esac
-  done
-  ok "    $rt online"
-done
-
-# ─── 6. THE GATE — literal mcp_molecule_list_peers via POST /:id/mcp ────
-# This is the byte-for-byte user-facing call. NOT GET /registry/:id/peers,
-# NOT /health, NOT the heartbeat table. JSON-RPC 2.0 tools/call,
-# name=list_peers, authenticated by the workspace's OWN bearer token
-# through WorkspaceAuth + MCPRateLimiter.
-log "6/6 driving the LITERAL list_peers MCP call per runtime..."
-echo ""
-RPC_BODY='{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"list_peers","arguments":{}}}'
-REGRESSED=0
-declare -A VERDICT
-
-for rt in $PV_RUNTIMES; do
-  wid="${WS_IDS[$rt]}"
-  wtok="${WS_TOKENS[$rt]}"
-  # The expected peer set = every OTHER provisioned workspace (parent +
-  # the sibling runtimes), excluding the caller itself.
-  EXPECT_IDS=$(echo "$ALL_WS_IDS" | tr ' ' '\n' | grep -v "^${wid}$" | grep -v '^$')
-
-  set +e
-  RESP=$(curl -sS -X POST "$TENANT_URL/workspaces/$wid/mcp" \
-    -H "Authorization: Bearer $wtok" \
-    -H "X-Molecule-Org-Id: $ORG_ID" \
-    -H "Content-Type: application/json" \
-    -d "$RPC_BODY" \
-    -o /tmp/pv_mcp_body.json -w "%{http_code}" 2>/dev/null)
-  set -e
-  HTTP_CODE="$RESP"
-  BODY=$(cat /tmp/pv_mcp_body.json 2>/dev/null || echo '')
-
-  echo "--- $rt (ws=$wid) ---"
-  echo "    HTTP $HTTP_CODE"
-  echo "    body: $(echo "$BODY" | head -c 600)"
-
-  # (1) HTTP 200 — a 401 (WorkspaceAuth reject, the Hermes symptom) fails here.
-  if [ "$HTTP_CODE" != "200" ]; then
-    echo "  ✗ $rt: list_peers MCP call returned HTTP $HTTP_CODE (expected 200)"
-    VERDICT[$rt]="FAIL(http=$HTTP_CODE)"
-    REGRESSED=1
-    continue
-  fi
-
-  # (2) JSON-RPC result present, not an error object.
-  PARSE=$(echo "$BODY" | python3 -c "
-import sys, json
-expect = set(filter(None, '''$EXPECT_IDS'''.split()))
-try:
-    d = json.load(sys.stdin)
-except Exception as e:
-    print('PARSE_ERROR:' + str(e)); sys.exit(0)
-if isinstance(d, dict) and d.get('error') is not None:
-    print('RPC_ERROR:' + json.dumps(d['error'])[:200]); sys.exit(0)
-res = d.get('result') if isinstance(d, dict) else None
-if res is None:
-    print('NO_RESULT'); sys.exit(0)
-# MCP tools/call result shape: {content:[{type:text,text:'<json or prose>'}]}
-text = ''
-if isinstance(res, dict):
-    for c in res.get('content', []):
-        if c.get('type') == 'text':
-            text += c.get('text', '')
-text_l = text.lower()
-# Native-sessions fallback signature (the OpenClaw symptom): the agent
-# answered from its own runtime session list, not the platform peer set.
-if 'sessions_list' in text_l or 'no platform peers' in text_l or 'native session' in text_l:
-    print('NATIVE_FALLBACK:' + text[:200]); sys.exit(0)
-# The expected sibling IDs must literally appear in the returned peer text.
-found = sorted(i for i in expect if i in text)
-missing = sorted(expect - set(found))
-if not expect:
-    print('NO_EXPECTED_PEERS_CONFIGURED'); sys.exit(0)
-if missing:
-    print('MISSING_PEERS:found=%d/%d missing=%s' % (len(found), len(expect), ','.join(m[:8] for m in missing)))
-    sys.exit(0)
-print('OK:found=%d/%d' % (len(found), len(expect)))
-" 2>/dev/null)
-
-  case "$PARSE" in
-    OK:*)
-      echo "  ✓ $rt: list_peers returned 200 and contains all expected peers ($PARSE)"
-      VERDICT[$rt]="OK"
-      ;;
-    NATIVE_FALLBACK:*)
-      echo "  ✗ $rt: list_peers fell back to NATIVE sessions — sees no platform peers ($PARSE)"
-      VERDICT[$rt]="FAIL(native-fallback)"
-      REGRESSED=1
-      ;;
-    RPC_ERROR:*|NO_RESULT|PARSE_ERROR:*)
-      echo "  ✗ $rt: list_peers MCP call did not return a usable result ($PARSE)"
-      VERDICT[$rt]="FAIL(rpc=$PARSE)"
-      REGRESSED=1
-      ;;
-    MISSING_PEERS:*)
-      echo "  ✗ $rt: list_peers returned 200 but peer set is wrong/empty ($PARSE)"
-      VERDICT[$rt]="FAIL(peers=$PARSE)"
-      REGRESSED=1
-      ;;
-    *)
-      echo "  ✗ $rt: unexpected verdict '$PARSE'"
-      VERDICT[$rt]="FAIL(unknown)"
-      REGRESSED=1
-      ;;
-  esac
-  echo ""
-done
-
-echo "=== SUMMARY — fresh-provision peer-visibility (literal MCP list_peers) ==="
-for rt in $PV_RUNTIMES; do
-  printf '  %-14s %s\n' "$rt" "${VERDICT[$rt]:-NO_RUN}"
-done
-echo ""
-
-if [ "$REGRESSED" -ne 0 ]; then
-  echo "✗ GATE FAILED — at least one runtime cannot see its peers via the"
-  echo "  literal mcp_molecule_list_peers call. This is the real user-facing"
-  echo "  failure the proxy signals (registry row / heartbeat / model 200)"
-  echo "  were hiding. Expected RED until the Hermes-401 + OpenClaw-MCP-wiring"
-  echo "  root-cause fixes land; goes green only when they actually do."
-  exit 10
-fi
-
-ok "GATE PASSED — every runtime under test sees its platform peers via the literal MCP call."
-exit 0

tests/e2e/test_workspace_abilities_e2e.sh

@@ -1,296 +0,0 @@
-#!/usr/bin/env bash
-# E2E test: workspace broadcast and talk-to-user platform abilities.
-#
-# What this proves:
-#   1. talk_to_user_enabled (default true) — POST /notify works out-of-the-box.
-#   2. PATCH /workspaces/:id/abilities { talk_to_user_enabled: false } disables
-#      delivery: /notify → 403 with error="talk_to_user_disabled" + delegate hint.
-#   3. Re-enabling talk_to_user_enabled restores delivery.
-#   4. broadcast_enabled (default false) — POST /broadcast → 403 when disabled.
-#   5. PATCH { broadcast_enabled: true } enables fan-out.
-#   6. POST /broadcast delivers to all non-sender, non-removed workspaces:
-#      - Returns {"status":"sent","delivered":N}
-#      - Receiver's activity log has a broadcast_receive entry with the message.
-#      - Sender's activity log has a broadcast_sent entry.
-#   7. The sender itself does NOT receive a broadcast_receive entry.
-#
-# Usage:  tests/e2e/test_workspace_abilities_e2e.sh
-# Prereqs: workspace-server on http://localhost:8080, MOLECULE_ENV != production
-
-set -euo pipefail
-
-source "$(dirname "$0")/_lib.sh"
-
-PASS=0
-FAIL=0
-SENDER_ID=""
-RECEIVER_ID=""
-
-cleanup() {
-  for wid in "$SENDER_ID" "$RECEIVER_ID"; do
-    if [ -n "$wid" ]; then
-      curl -s -X DELETE "$BASE/workspaces/$wid?confirm=true" > /dev/null || true
-    fi
-  done
-}
-trap cleanup EXIT INT TERM
-
-assert() {
-  local label="$1" actual="$2" expected="$3"
-  if [ "$actual" = "$expected" ]; then
-    echo "  PASS — $label"
-    PASS=$((PASS+1))
-  else
-    echo "  FAIL — $label"
-    echo "         expected: $expected"
-    echo "         actual:   $actual"
-    FAIL=$((FAIL+1))
-  fi
-}
-
-assert_contains() {
-  local label="$1" haystack="$2" needle="$3"
-  if echo "$haystack" | grep -qF "$needle"; then
-    echo "  PASS — $label"
-    PASS=$((PASS+1))
-  else
-    echo "  FAIL — $label"
-    echo "         needle:   $needle"
-    echo "         haystack: $haystack"
-    FAIL=$((FAIL+1))
-  fi
-}
-
-assert_not_contains() {
-  local label="$1" haystack="$2" needle="$3"
-  if ! echo "$haystack" | grep -qF "$needle"; then
-    echo "  PASS — $label"
-    PASS=$((PASS+1))
-  else
-    echo "  FAIL — $label (unexpected match)"
-    echo "         needle:   $needle"
-    echo "         haystack: $haystack"
-    FAIL=$((FAIL+1))
-  fi
-}
-
-# ── Pre-sweep: remove any stale leftover workspaces from a prior aborted run ──
-echo "=== Setup ==="
-for NAME in "Abilities Sender" "Abilities Receiver"; do
-  PRIOR=$(curl -s "$BASE/workspaces" | python3 -c "
-import json, sys
-try:
-    print(' '.join(w['id'] for w in json.load(sys.stdin) if w.get('name') == '$NAME'))
-except Exception:
-    pass
-")
-  for _wid in $PRIOR; do
-    echo "Sweeping leftover '$NAME' workspace: $_wid"
-    curl -s -X DELETE "$BASE/workspaces/$_wid?confirm=true" > /dev/null || true
-  done
-done
-
-R=$(curl -s -X POST "$BASE/workspaces" -H "Content-Type: application/json" \
-  -d '{"name":"Abilities Sender","tier":1}')
-SENDER_ID=$(echo "$R" | python3 -c 'import json,sys;print(json.load(sys.stdin)["id"])' 2>/dev/null || true)
-[ -n "$SENDER_ID" ] || { echo "Failed to create sender workspace: $R"; exit 1; }
-echo "Created sender   workspace: $SENDER_ID"
-
-R=$(curl -s -X POST "$BASE/workspaces" -H "Content-Type: application/json" \
-  -d '{"name":"Abilities Receiver","tier":1}')
-RECEIVER_ID=$(echo "$R" | python3 -c 'import json,sys;print(json.load(sys.stdin)["id"])' 2>/dev/null || true)
-[ -n "$RECEIVER_ID" ] || { echo "Failed to create receiver workspace: $R"; exit 1; }
-echo "Created receiver workspace: $RECEIVER_ID"
-
-# Mint workspace-scoped bearer tokens (test-only endpoint, disabled in prod).
-SENDER_TOKEN=$(e2e_mint_test_token "$SENDER_ID")
-[ -n "$SENDER_TOKEN" ] || { echo "Failed to mint sender token"; exit 1; }
-SENDER_AUTH="Authorization: Bearer $SENDER_TOKEN"
-
-# Admin token — any live workspace bearer satisfies AdminAuth in local dev.
-# In production-like envs, set MOLECULE_ADMIN_TOKEN.
-ADMIN_TOKEN="${MOLECULE_ADMIN_TOKEN:-$SENDER_TOKEN}"
-ADMIN_AUTH="Authorization: Bearer $ADMIN_TOKEN"
-
-# ─────────────────────────────────────────────────────────────────────────────
-echo ""
-echo "=== Part 1: talk_to_user ability ==="
-
-echo ""
-echo "--- 1a: /notify works with default talk_to_user_enabled=true ---"
-CODE=$(curl -s -o /dev/null -w "%{http_code}" -X POST "$BASE/workspaces/$SENDER_ID/notify" \
-  -H "Content-Type: application/json" -H "$SENDER_AUTH" \
-  -d '{"message":"Hello from sender"}')
-assert "POST /notify returns 200 when talk_to_user_enabled=true (default)" "$CODE" "200"
-
-echo ""
-echo "--- 1b: Disable talk_to_user ---"
-CODE=$(curl -s -o /dev/null -w "%{http_code}" -X PATCH "$BASE/workspaces/$SENDER_ID/abilities" \
-  -H "Content-Type: application/json" -H "$ADMIN_AUTH" \
-  -d '{"talk_to_user_enabled": false}')
-assert "PATCH /abilities talk_to_user_enabled=false returns 200" "$CODE" "200"
-
-# Verify the flag is reflected in the workspace GET response.
-WS=$(curl -s "$BASE/workspaces/$SENDER_ID" -H "$SENDER_AUTH")
-FLAG=$(echo "$WS" | python3 -c 'import json,sys;print(json.load(sys.stdin).get("talk_to_user_enabled","MISSING"))')
-assert "GET /workspaces/:id reflects talk_to_user_enabled=false" "$FLAG" "False"
-
-echo ""
-echo "--- 1c: /notify blocked when talk_to_user disabled ---"
-BODY=$(curl -s -w "" -X POST "$BASE/workspaces/$SENDER_ID/notify" \
-  -H "Content-Type: application/json" -H "$SENDER_AUTH" \
-  -d '{"message":"Should be blocked"}')
-CODE=$(curl -s -o /dev/null -w "%{http_code}" -X POST "$BASE/workspaces/$SENDER_ID/notify" \
-  -H "Content-Type: application/json" -H "$SENDER_AUTH" \
-  -d '{"message":"Should be blocked"}')
-assert "POST /notify returns 403 when talk_to_user_enabled=false" "$CODE" "403"
-
-ERR=$(echo "$BODY" | python3 -c 'import json,sys;print(json.load(sys.stdin).get("error",""))' 2>/dev/null || echo "")
-assert_contains "403 body contains talk_to_user_disabled error code" "$ERR" "talk_to_user_disabled"
-
-HINT=$(echo "$BODY" | python3 -c 'import json,sys;print(json.load(sys.stdin).get("hint",""))' 2>/dev/null || echo "")
-assert_contains "403 body contains delegate_task hint" "$HINT" "delegate_task"
-
-echo ""
-echo "--- 1d: Re-enable talk_to_user and verify /notify works again ---"
-CODE=$(curl -s -o /dev/null -w "%{http_code}" -X PATCH "$BASE/workspaces/$SENDER_ID/abilities" \
-  -H "Content-Type: application/json" -H "$ADMIN_AUTH" \
-  -d '{"talk_to_user_enabled": true}')
-assert "PATCH /abilities talk_to_user_enabled=true returns 200" "$CODE" "200"
-
-CODE=$(curl -s -o /dev/null -w "%{http_code}" -X POST "$BASE/workspaces/$SENDER_ID/notify" \
-  -H "Content-Type: application/json" -H "$SENDER_AUTH" \
-  -d '{"message":"Re-enabled, should work"}')
-assert "POST /notify returns 200 after re-enabling talk_to_user" "$CODE" "200"
-
-# ─────────────────────────────────────────────────────────────────────────────
-echo ""
-echo "=== Part 2: broadcast ability ==="
-
-echo ""
-echo "--- 2a: Broadcast blocked by default (broadcast_enabled=false) ---"
-CODE=$(curl -s -o /dev/null -w "%{http_code}" -X POST "$BASE/workspaces/$SENDER_ID/broadcast" \
-  -H "Content-Type: application/json" -H "$SENDER_AUTH" \
-  -d '{"message":"Should be blocked"}')
-assert "POST /broadcast returns 403 when broadcast_enabled=false (default)" "$CODE" "403"
-
-echo ""
-echo "--- 2b: Enable broadcast ---"
-CODE=$(curl -s -o /dev/null -w "%{http_code}" -X PATCH "$BASE/workspaces/$SENDER_ID/abilities" \
-  -H "Content-Type: application/json" -H "$ADMIN_AUTH" \
-  -d '{"broadcast_enabled": true}')
-assert "PATCH /abilities broadcast_enabled=true returns 200" "$CODE" "200"
-
-WS=$(curl -s "$BASE/workspaces/$SENDER_ID" -H "$SENDER_AUTH")
-FLAG=$(echo "$WS" | python3 -c 'import json,sys;print(json.load(sys.stdin).get("broadcast_enabled","MISSING"))')
-assert "GET /workspaces/:id reflects broadcast_enabled=true" "$FLAG" "True"
-
-echo ""
-echo "--- 2c: Successful broadcast fan-out ---"
-BCAST=$(curl -s -X POST "$BASE/workspaces/$SENDER_ID/broadcast" \
-  -H "Content-Type: application/json" -H "$SENDER_AUTH" \
-  -d '{"message":"Org-wide notice: scheduled maintenance in 5 minutes."}')
-BSTATUS=$(echo "$BCAST" | python3 -c 'import json,sys;print(json.load(sys.stdin).get("status",""))' 2>/dev/null || echo "")
-BDELIVERED=$(echo "$BCAST" | python3 -c 'import json,sys;print(json.load(sys.stdin).get("delivered","-1"))' 2>/dev/null || echo "-1")
-assert "POST /broadcast returns status=sent" "$BSTATUS" "sent"
-
-# delivered count must be >= 1 (the receiver workspace).
-echo "  INFO — broadcast delivered=$BDELIVERED"
-if python3 -c "import sys; sys.exit(0 if int('$BDELIVERED') >= 1 else 1)" 2>/dev/null; then
-  echo "  PASS — delivered count >= 1"
-  PASS=$((PASS+1))
-else
-  echo "  FAIL — expected delivered >= 1, got $BDELIVERED"
-  FAIL=$((FAIL+1))
-fi
-
-echo ""
-echo "--- 2d: Receiver activity log has broadcast_receive entry ---"
-RECEIVER_TOKEN=$(e2e_mint_test_token "$RECEIVER_ID")
-[ -n "$RECEIVER_TOKEN" ] || { echo "Failed to mint receiver token"; exit 1; }
-RECEIVER_AUTH="Authorization: Bearer $RECEIVER_TOKEN"
-
-ACT=$(curl -s -H "$RECEIVER_AUTH" "$BASE/workspaces/$RECEIVER_ID/activity?source=agent&limit=20")
-ROW=$(echo "$ACT" | python3 -c '
-import json, sys
-rows = json.load(sys.stdin) or []
-for r in rows:
-    if r.get("activity_type") == "broadcast_receive":
-        print(json.dumps(r))
-        break
-')
-[ -n "$ROW" ] || {
-  echo "  FAIL — could not find broadcast_receive row in receiver activity"
-  FAIL=$((FAIL+1))
-}
-
-if [ -n "$ROW" ]; then
-  # Message is stored in summary field.
-  MSG=$(echo "$ROW" | python3 -c 'import json,sys;r=json.load(sys.stdin);print(r.get("summary",""))')
-  assert_contains "broadcast_receive row summary has original message" "$MSG" "scheduled maintenance"
-  # Sender ID is stored in source_id field.
-  SRC=$(echo "$ROW" | python3 -c 'import json,sys;r=json.load(sys.stdin);print(r.get("source_id",""))')
-  assert "broadcast_receive row source_id is sender workspace" "$SRC" "$SENDER_ID"
-fi
-
-echo ""
-echo "--- 2e: Sender activity log has broadcast_sent entry ---"
-ACT_SENDER=$(curl -s -H "$SENDER_AUTH" "$BASE/workspaces/$SENDER_ID/activity?limit=20")
-SENT_ROW=$(echo "$ACT_SENDER" | python3 -c '
-import json, sys
-rows = json.load(sys.stdin) or []
-for r in rows:
-    if r.get("activity_type") == "broadcast_sent":
-        print(json.dumps(r))
-        break
-')
-[ -n "$SENT_ROW" ] || {
-  echo "  FAIL — could not find broadcast_sent row in sender activity"
-  FAIL=$((FAIL+1))
-}
-
-if [ -n "$SENT_ROW" ]; then
-  # Delivered count is baked into the summary field (no response_body for sender row).
-  SUMMARY=$(echo "$SENT_ROW" | python3 -c 'import json,sys;print(json.load(sys.stdin).get("summary",""))')
-  assert_contains "broadcast_sent summary mentions workspace count" "$SUMMARY" "workspace"
-fi
-
-echo ""
-echo "--- 2f: Sender does NOT receive a broadcast_receive entry ---"
-SELF_RECV=$(echo "$ACT_SENDER" | python3 -c '
-import json, sys
-rows = json.load(sys.stdin) or []
-for r in rows:
-    if r.get("activity_type") == "broadcast_receive":
-        print("found")
-        break
-')
-assert_not_contains "sender has no broadcast_receive in own activity log" "${SELF_RECV:-}" "found"
-
-# ─────────────────────────────────────────────────────────────────────────────
-echo ""
-echo "--- 2g: Empty message is rejected ---"
-CODE=$(curl -s -o /dev/null -w "%{http_code}" -X POST "$BASE/workspaces/$SENDER_ID/broadcast" \
-  -H "Content-Type: application/json" -H "$SENDER_AUTH" \
-  -d '{"message":""}')
-assert "POST /broadcast with empty message returns 400" "$CODE" "400"
-
-echo ""
-echo "--- 2h: Partial PATCH does not clobber other flags ---"
-# Set talk_to_user=false, then patch only broadcast — talk_to_user must stay false.
-curl -s -o /dev/null -X PATCH "$BASE/workspaces/$SENDER_ID/abilities" \
-  -H "Content-Type: application/json" -H "$ADMIN_AUTH" \
-  -d '{"talk_to_user_enabled": false}'
-curl -s -o /dev/null -X PATCH "$BASE/workspaces/$SENDER_ID/abilities" \
-  -H "Content-Type: application/json" -H "$ADMIN_AUTH" \
-  -d '{"broadcast_enabled": false}'
-WS=$(curl -s "$BASE/workspaces/$SENDER_ID" -H "$SENDER_AUTH")
-TUF=$(echo "$WS" | python3 -c 'import json,sys;print(json.load(sys.stdin).get("talk_to_user_enabled","MISSING"))')
-BEF=$(echo "$WS" | python3 -c 'import json,sys;print(json.load(sys.stdin).get("broadcast_enabled","MISSING"))')
-assert "partial PATCH preserves talk_to_user_enabled=false" "$TUF" "False"
-assert "partial PATCH sets broadcast_enabled=false" "$BEF" "False"
-
-# ─────────────────────────────────────────────────────────────────────────────
-echo ""
-echo "=== Results: $PASS passed, $FAIL failed ==="
-[ "$FAIL" -eq 0 ]

workspace-server/internal/handlers/a2a_poll_ingest_persist_test.go

@@ -1,160 +0,0 @@
-package handlers
-
-// Regression coverage for the POLL-mode arm of the canvas user-message
-// data-loss bug (internal#470 sibling — tracked on internal#471).
-//
-// Bug (reported 2026-05-16 by CTO Hongming): "in canvas i sometimes lose
-// my own message when i exit chat". The push-mode arm was fixed by
-// #1347 (persistUserMessageAtIngest — a SYNCHRONOUS, before-dispatch,
-// context.WithoutCancel INSERT). #1347's framing asserted "poll-mode
-// workspaces were never affected — logA2AReceiveQueued already persists
-// at ingest". That assertion is OVERSTATED.
-//
-// Hongming's tenant (slug `hongming`, org 2c940477-...) has 4 workspaces,
-// ALL runtime=external with empty URL → ALL delivery_mode=poll (proven
-// empirically: a benign A2A probe returns the synthetic
-// {"delivery_mode":"poll","status":"queued"} envelope for every one).
-// So his reported loss is the POLL path, NOT the push path #1347 fixes.
-//
-// Root cause (poll arm): the poll-mode short-circuit (a2a_proxy.go ~402)
-// calls logA2AReceiveQueued and then IMMEDIATELY returns the synthetic
-// 200 {status:"queued"} to the canvas. But logA2AReceiveQueued's durable
-// INSERT runs inside h.goAsync(...) — a DETACHED goroutine with NO
-// happens-before barrier against the HTTP response. The canvas sees 200
-// ("message accepted") while the activity_logs row may not yet be — and,
-// on a workspace-server restart / deploy / OOM / EC2 hibernation between
-// the 200 and the goroutine's commit, NEVER will be — durable. There is
-// also no fallback (unlike push-mode's legacy-INSERT fallback): a
-// swallowed LogActivity error loses the message with only a log line.
-// Chat-history reads activity_logs (postgres_store.go:165-187); a missing
-// row = message gone on reopen. That is exactly Hongming's symptom.
-//
-// Fix (parity with push-mode): the poll-mode ingest persist of the
-// canvas user message must be SYNCHRONOUS — committed before the queued
-// 200 is returned — on a context.WithoutCancel derived context, so a
-// client disconnect on chat-exit and a post-response restart cannot lose
-// it. Behavior is never worse than today (best-effort; a persist error
-// still returns queued).
-//
-// TEST DESIGN NOTE: sqlmock.ExpectationsWereMet() hangs indefinitely if
-// the expected query never fires. We use a select+default+time.After
-// pattern so the test FAILS fast (not hangs) when the production code
-// regresses to async (the INSERT never fires before handler returns),
-// while still returning promptly when all expectations are met. The
-// insertDelay is kept small (50ms) to minimise suite-level timing
-// impact under -race detection, where mock delays are amplified by
-// the instrumenter's goroutine overhead.
-
-import (
-	"bytes"
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"github.com/DATA-DOG/go-sqlmock"
-	"github.com/gin-gonic/gin"
-)
-
-// TestProxyA2A_PollMode_PersistsUserMessageSynchronouslyBeforeQueuedResponse
-// is the defining contract: for a poll-mode workspace, the canvas user
-// message MUST be durably INSERTed into activity_logs BEFORE the synthetic
-// queued 200 is returned to the client — with NO reliance on a detached
-// async goroutine completing later.
-//
-// The test proves the ordering by making the INSERT block briefly and
-// asserting the handler does NOT return until the INSERT has completed.
-// Pre-fix (INSERT in h.goAsync, response returned immediately) the
-// handler returns ~instantly while the INSERT is still pending in the
-// goroutine → the elapsed time is far below the injected INSERT delay and
-// ExpectationsWereMet() is racy/unmet at return. Post-fix (synchronous
-// persist before the queued response) the handler return is gated on the
-// INSERT, so elapsed >= the injected delay and the expectation is met
-// deterministically at return WITHOUT any waitAsyncForTest()/sleep.
-func TestProxyA2A_PollMode_PersistsUserMessageSynchronouslyBeforeQueuedResponse(t *testing.T) {
-	mock := setupTestDB(t)
-	setupTestRedis(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewWorkspaceHandler(broadcaster, nil, "http://localhost:8080", t.TempDir())
-
-	const wsID = "ws-poll-sync-persist"
-	// Keep delay small: -race detection amplifies mock delays significantly.
-	// A 50ms delay is sufficient to prove synchronous blocking (~50× the
-	// normal INSERT latency) without bloating the full ./... suite runtime.
-	const insertDelay = 50 * time.Millisecond
-
-	expectBudgetCheck(mock, wsID)
-
-	// lookupDeliveryMode → poll, triggering the short-circuit.
-	mock.ExpectQuery("SELECT delivery_mode FROM workspaces WHERE id").
-		WithArgs(wsID).
-		WillReturnRows(sqlmock.NewRows([]string{"delivery_mode"}).AddRow("poll"))
-
-	// workspace-name lookup inside logA2AReceiveQueued.
-	mock.ExpectQuery(`SELECT name FROM workspaces WHERE id`).
-		WithArgs(wsID).
-		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("Poll WS"))
-
-	// The durable user-message write. We delay it so a synchronous
-	// persist visibly gates the handler return; a detached-goroutine
-	// persist (pre-fix) does not. The fix must keep using
-	// context.WithoutCancel so this write survives a chat-exit cancel.
-	mock.ExpectExec("INSERT INTO activity_logs").
-		WillDelayFor(insertDelay).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: wsID}}
-
-	// callerID == "" (no X-Workspace-ID) → this is a canvas_user message,
-	// exactly Hongming's case.
-	body := `{"jsonrpc":"2.0","id":"poll-canvas-1","method":"message/send","params":{"message":{"role":"user","parts":[{"text":"my own message"}]}}}`
-	c.Request = httptest.NewRequest("POST", "/workspaces/"+wsID+"/a2a", bytes.NewBufferString(body))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	start := time.Now()
-	handler.ProxyA2A(c)
-	elapsed := time.Since(start)
-
-	// Defining assertion #1: the handler must not have returned the
-	// queued response before the durable INSERT committed. Pre-fix this
-	// fails (elapsed ≈ 0, INSERT still racing in goAsync).
-	if elapsed < insertDelay {
-		t.Fatalf("poll-mode queued response returned in %v, before the %v user-message INSERT — "+
-			"the message is not durable when the client/process goes away (DATA LOSS). "+
-			"Persist must be synchronous before the queued 200.", elapsed, insertDelay)
-	}
-
-	// Defining assertion #2: the durable write actually happened by the
-	// time the handler returned. ExpectionsWereMet() hangs indefinitely if
-	// the mock never fires (e.g. production code regressed to async),
-	// so we check it in a goroutine with a hard 2s timeout — fails fast
-	// (no CI hang) on regression while returning promptly on success.
-	expectDone := make(chan error, 1)
-	go func() { expectDone <- mock.ExpectationsWereMet() }()
-	select {
-	case err := <-expectDone:
-		if err != nil {
-			t.Fatalf("user-message INSERT was not durable at handler return (unmet sqlmock expectations): %v", err)
-		}
-	case <-time.After(2 * time.Second):
-		t.Fatalf("ExpectationsWereMet() hung for >2s — INSERT mock never fired. " +
-			"Likely cause: production code regressed logA2AReceiveQueued to goAsync " +
-			"(INSERT fires after handler returns, not before).")
-	}
-
-	// Sanity: still the correct poll-mode envelope + status.
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected 200 (queued), got %d: %s", w.Code, w.Body.String())
-	}
-	var resp map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("response is not valid JSON: %v", err)
-	}
-	if resp["status"] != "queued" || resp["delivery_mode"] != "poll" {
-		t.Errorf("poll envelope changed: got status=%v delivery_mode=%v, want queued/poll",
-			resp["status"], resp["delivery_mode"])
-	}
-}

workspace-server/internal/handlers/a2a_proxy_helpers.go

@@ -504,49 +504,25 @@ func lookupDeliveryMode(ctx context.Context, workspaceID string) string {
 // reads in PR 3 — that's how a poll-mode workspace receives inbound A2A
 // without a public URL.
 func (h *WorkspaceHandler) logA2AReceiveQueued(ctx context.Context, workspaceID, callerID string, body []byte, a2aMethod string) {
-	// DATA-LOSS FIX (internal#471 — poll-mode sibling of #1347/internal#470):
-	// this is the ONLY durable write of a poll-mode inbound message,
-	// including a canvas_user message (callerID == "") typed in the canvas
-	// chat. It MUST be SYNCHRONOUS and complete BEFORE the caller returns
-	// the synthetic {status:"queued"} 200 — otherwise the canvas sees the
-	// send acknowledged while the activity_logs row is still racing in a
-	// detached goroutine, and a workspace-server restart / deploy / OOM /
-	// EC2 hibernation between the 200 and the goroutine's commit loses the
-	// user's message permanently (chat-history reads activity_logs, so a
-	// missing row = message gone on reopen). Hongming's tenant is entirely
-	// poll-mode (4 external workspaces, no URL — verified empirically), so
-	// his reported loss is THIS path; #1347 (push-mode, persists AFTER the
-	// poll short-circuit) structurally cannot cover it.
-	//
-	// Mirrors persistUserMessageAtIngest's discipline:
-	//   - context.WithoutCancel: a client disconnect on chat-exit (which
-	//     cancels the inbound request ctx) MUST NOT abort this write.
-	//   - SYNCHRONOUS (no goAsync): the row must be durable before the
-	//     queued 200 is returned to the caller.
-	//   - Best-effort: LogActivity already logs+swallows INSERT errors, so
-	//     a hiccup never blocks or fails the user's send (behavior for
-	//     that one request is never worse than the pre-fix async path).
-	// The post-commit broadcast still fires inside LogActivity; a missed
-	// WebSocket event is not data loss (the durable row is the truth the
-	// canvas re-reads on reopen).
-	insCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second)
-	defer cancel()
-
 	var wsName string
-	db.DB.QueryRowContext(insCtx, `SELECT name FROM workspaces WHERE id = $1`, workspaceID).Scan(&wsName)
+	db.DB.QueryRowContext(ctx, `SELECT name FROM workspaces WHERE id = $1`, workspaceID).Scan(&wsName)
 	if wsName == "" {
 		wsName = workspaceID
 	}
 	summary := a2aMethod + " → " + wsName + " (queued for poll)"
-	LogActivity(insCtx, h.broadcaster, ActivityParams{
-		WorkspaceID:  workspaceID,
-		ActivityType: "a2a_receive",
-		SourceID:     nilIfEmpty(callerID),
-		TargetID:     &workspaceID,
-		Method:       &a2aMethod,
-		Summary:      &summary,
-		RequestBody:  json.RawMessage(body),
-		Status:       "ok",
+	h.goAsync(func() {
+		logCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second)
+		defer cancel()
+		LogActivity(logCtx, h.broadcaster, ActivityParams{
+			WorkspaceID:  workspaceID,
+			ActivityType: "a2a_receive",
+			SourceID:     nilIfEmpty(callerID),
+			TargetID:     &workspaceID,
+			Method:       &a2aMethod,
+			Summary:      &summary,
+			RequestBody:  json.RawMessage(body),
+			Status:       "ok",
+		})
 	})
 }
 

workspace-server/internal/handlers/activity.go

@@ -482,13 +482,6 @@ func (h *ActivityHandler) Notify(c *gin.Context) {
 			c.JSON(http.StatusNotFound, gin.H{"error": "workspace not found"})
 			return
 		}
-		if errors.Is(err, ErrTalkToUserDisabled) {
-			c.JSON(http.StatusForbidden, gin.H{
-				"error": "talk_to_user_disabled",
-				"hint":  "This workspace is not allowed to send messages directly to the user. Forward your update to a parent workspace using delegate_task — they may be able to reach the user.",
-			})
-			return
-		}
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "internal error"})
 		return
 	}

workspace-server/internal/handlers/activity_test.go

@@ -464,9 +464,9 @@ func TestNotify_PersistsToActivityLogsForReloadRecovery(t *testing.T) {
 	t.Cleanup(func() { db.DB = prevDB; mockDB.Close() })
 
 	// Workspace existence check
-	mock.ExpectQuery(`SELECT name, talk_to_user_enabled FROM workspaces`).
+	mock.ExpectQuery(`SELECT name FROM workspaces`).
 		WithArgs("ws-notify").
-		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("DD", true))
+		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("DD"))
 
 	// Persistence INSERT — verify shape
 	mock.ExpectExec(`INSERT INTO activity_logs`).
@@ -511,9 +511,9 @@ func TestNotify_WithAttachments_PersistsFilePartsForReload(t *testing.T) {
 	db.DB = mockDB
 	t.Cleanup(func() { db.DB = prevDB; mockDB.Close() })
 
-	mock.ExpectQuery(`SELECT name, talk_to_user_enabled FROM workspaces`).
+	mock.ExpectQuery(`SELECT name FROM workspaces`).
 		WithArgs("ws-attach").
-		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("DD", true))
+		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("DD"))
 
 	// Capture the JSONB arg so we can assert on the persisted shape
 	// AFTER the call (must include parts[].kind=file so reload
@@ -640,9 +640,9 @@ func TestNotify_DBFailure_StillBroadcastsAnd200(t *testing.T) {
 	db.DB = mockDB
 	t.Cleanup(func() { db.DB = prevDB; mockDB.Close() })
 
-	mock.ExpectQuery(`SELECT name, talk_to_user_enabled FROM workspaces`).
+	mock.ExpectQuery(`SELECT name FROM workspaces`).
 		WithArgs("ws-x").
-		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("DD", true))
+		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("DD"))
 	mock.ExpectExec(`INSERT INTO activity_logs`).
 		WillReturnError(fmt.Errorf("simulated db hiccup"))
 

workspace-server/internal/handlers/admin_workspace_images.go

@@ -44,8 +44,8 @@ func NewWorkspaceImageService(docker *dockerclient.Client) *WorkspaceImageServic
 // AllRuntimes is the canonical list mirroring docs/workspace-runtime-package.md.
 // Update both when a new template is added.
 var AllRuntimes = []string{
-	"claude-code", "langgraph", "autogen",
-	"hermes", "openclaw",
+	"claude-code", "langgraph", "crewai", "autogen",
+	"deepagents", "hermes", "gemini-cli", "openclaw",
 }
 
 // RefreshResult is the per-call outcome surfaced to HTTP callers AND logged

workspace-server/internal/handlers/agent_message_writer.go

@@ -54,11 +54,6 @@ import (
 // timeout) surface as wrapped errors and should be treated as 503.
 var ErrWorkspaceNotFound = errors.New("agent_message: workspace not found")
 
-// ErrTalkToUserDisabled is returned when the workspace has
-// talk_to_user_enabled=false. Callers surface HTTP 403 so the Python tool
-// can detect it and suggest forwarding to a parent workspace.
-var ErrTalkToUserDisabled = errors.New("agent_message: talk_to_user disabled")
-
 // AgentMessageAttachment is one file attached to an agent → user
 // message. Identical to handlers.NotifyAttachment in field set; kept
 // distinct so the writer's API doesn't import a handler type with HTTP
@@ -112,20 +107,16 @@ func (w *AgentMessageWriter) Send(
 	// notify call surfaced as "workspace not found" and masked real
 	// incidents in the alert path.
 	var wsName string
-	var talkToUserEnabled bool
 	err := w.db.QueryRowContext(ctx,
-		`SELECT name, talk_to_user_enabled FROM workspaces WHERE id = $1 AND status != 'removed'`,
+		`SELECT name FROM workspaces WHERE id = $1 AND status != 'removed'`,
 		workspaceID,
-	).Scan(&wsName, &talkToUserEnabled)
+	).Scan(&wsName)
 	if errors.Is(err, sql.ErrNoRows) {
 		return ErrWorkspaceNotFound
 	}
 	if err != nil {
 		return fmt.Errorf("agent_message: workspace lookup: %w", err)
 	}
-	if !talkToUserEnabled {
-		return ErrTalkToUserDisabled
-	}
 
 	// 2. Build broadcast payload + WS-emit. Same shape that ChatTab's
 	//    AGENT_MESSAGE handler in canvas/src/store/canvas-events.ts has

workspace-server/internal/handlers/agent_message_writer_test.go

@@ -88,9 +88,9 @@ func TestAgentMessageWriter_Send_Success_NoAttachments(t *testing.T) {
 	mock := setupTestDB(t)
 	w := NewAgentMessageWriter(db.DB, newTestBroadcaster())
 
-	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
+	mock.ExpectQuery("SELECT name FROM workspaces").
 		WithArgs("ws-1").
-		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("CEO Ryan PC", true))
+		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("CEO Ryan PC"))
 
 	mock.ExpectExec(`INSERT INTO activity_logs.*'a2a_receive'.*'notify'`).
 		WithArgs(
@@ -116,9 +116,9 @@ func TestAgentMessageWriter_Send_Success_WithAttachments(t *testing.T) {
 	mock := setupTestDB(t)
 	w := NewAgentMessageWriter(db.DB, newTestBroadcaster())
 
-	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
+	mock.ExpectQuery("SELECT name FROM workspaces").
 		WithArgs("ws-att").
-		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("Ryan", true))
+		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("Ryan"))
 
 	mock.ExpectExec(`INSERT INTO activity_logs.*'a2a_receive'.*'notify'`).
 		WithArgs(
@@ -173,9 +173,9 @@ func TestAgentMessageWriter_Send_WorkspaceNotFound(t *testing.T) {
 	emitter := &capturingEmitter{}
 	w := NewAgentMessageWriter(db.DB, emitter)
 
-	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
+	mock.ExpectQuery("SELECT name FROM workspaces").
 		WithArgs("ws-missing").
-		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}))
+		WillReturnRows(sqlmock.NewRows([]string{"name"}))
 
 	err := w.Send(context.Background(), "ws-missing", "lost in the void", nil)
 	if !errors.Is(err, ErrWorkspaceNotFound) {
@@ -202,9 +202,9 @@ func TestAgentMessageWriter_Send_DBInsertFailureStillReturnsNil(t *testing.T) {
 	mock := setupTestDB(t)
 	w := NewAgentMessageWriter(db.DB, newTestBroadcaster())
 
-	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
+	mock.ExpectQuery("SELECT name FROM workspaces").
 		WithArgs("ws-dbfail").
-		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("CEO Ryan PC", true))
+		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("CEO Ryan PC"))
 
 	mock.ExpectExec(`INSERT INTO activity_logs`).
 		WillReturnError(errors.New("transient db error"))
@@ -223,9 +223,9 @@ func TestAgentMessageWriter_Send_PreviewTruncation(t *testing.T) {
 	mock := setupTestDB(t)
 	w := NewAgentMessageWriter(db.DB, newTestBroadcaster())
 
-	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
+	mock.ExpectQuery("SELECT name FROM workspaces").
 		WithArgs("ws-trunc").
-		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("Ryan", true))
+		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("Ryan"))
 
 	longMsg := strings.Repeat("x", 200)
 	mock.ExpectExec(`INSERT INTO activity_logs`).
@@ -263,9 +263,9 @@ func TestAgentMessageWriter_Send_BroadcastsAgentMessageEvent(t *testing.T) {
 	emitter := &capturingEmitter{}
 	w := NewAgentMessageWriter(db.DB, emitter)
 
-	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
+	mock.ExpectQuery("SELECT name FROM workspaces").
 		WithArgs("ws-bc").
-		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("Workspace Name", true))
+		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("Workspace Name"))
 	mock.ExpectExec(`INSERT INTO activity_logs`).
 		WillReturnResult(sqlmock.NewResult(1, 1))
 
@@ -315,7 +315,7 @@ func TestAgentMessageWriter_Send_DBErrorOnLookupReturnsWrapped(t *testing.T) {
 	w := NewAgentMessageWriter(db.DB, newTestBroadcaster())
 
 	transientErr := errors.New("connection refused")
-	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
+	mock.ExpectQuery("SELECT name FROM workspaces").
 		WithArgs("ws-dbdown").
 		WillReturnError(transientErr)
 
@@ -350,9 +350,9 @@ func TestAgentMessageWriter_Send_NonASCIIMessagePersists(t *testing.T) {
 	// the byte-slice bug.
 	msg := strings.Repeat("你", 200)
 
-	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
+	mock.ExpectQuery("SELECT name FROM workspaces").
 		WithArgs("ws-cjk").
-		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("CEO Ryan PC", true))
+		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("CEO Ryan PC"))
 
 	mock.ExpectExec(`INSERT INTO activity_logs`).
 		WithArgs(
@@ -395,9 +395,9 @@ func TestAgentMessageWriter_Send_OmitsAttachmentsKeyWhenEmpty(t *testing.T) {
 	emitter := &capturingEmitter{}
 	w := NewAgentMessageWriter(db.DB, emitter)
 
-	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
+	mock.ExpectQuery("SELECT name FROM workspaces").
 		WithArgs("ws-noatt").
-		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("X", true))
+		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("X"))
 	mock.ExpectExec(`INSERT INTO activity_logs`).
 		WillReturnResult(sqlmock.NewResult(1, 1))
 

workspace-server/internal/handlers/approvals.go

@@ -116,9 +116,6 @@ func (h *ApprovalsHandler) ListAll(c *gin.Context) {
 			"created_at":     createdAt,
 		})
 	}
-	if err := rows.Err(); err != nil {
-		log.Printf("ListPendingApprovals rows.Err: %v", err)
-	}
 
 	c.JSON(http.StatusOK, approvals)
 }
@@ -158,9 +155,6 @@ func (h *ApprovalsHandler) List(c *gin.Context) {
 			"created_at": createdAt,
 		})
 	}
-	if err := rows.Err(); err != nil {
-		log.Printf("ListApprovals rows.Err workspace=%s: %v", workspaceID, err)
-	}
 
 	c.JSON(http.StatusOK, approvals)
 }

workspace-server/internal/handlers/delegation_list_test.go

@@ -486,10 +486,3 @@ func TestListDelegationsFromActivityLogs_RowsErr(t *testing.T) {
 		t.Errorf("sqlmock expectations: %v", err)
 	}
 }
-
-// TestListDelegationsFromActivityLogs_ScanErrorSkipped is removed.
-//
-// Same reason as TestListDelegationsFromLedger_ScanError: Go 1.25 causes
-// sqlmock.NewRows([]string{}).AddRow(...) to panic in test SETUP. The handler
-// has no recover(), so a scan panic would crash the process — the correct
-// behaviour. Real-DB integration tests cover this path.

workspace-server/internal/handlers/external_connection.go

@@ -646,12 +646,8 @@ const externalOpenClawTemplate = `# OpenClaw MCP config — outbound tool path.
 # external machine today, pair with the Python SDK tab.
 
 # 1. Install openclaw CLI + the workspace runtime wheel:
-#    The version pin (>=0.1.999) ensures the "molecule-mcp" console
-#    script is present — it is what keeps the workspace ALIVE on canvas
-#    (register-on-startup + 20s heartbeat). Older versions only ship
-#    a2a_mcp_server which does not heartbeat.
 npm install -g openclaw@latest
-pip install "molecule-ai-workspace-runtime>=0.1.999"
+pip install molecule-ai-workspace-runtime
 
 # 2. Onboard openclaw against your model provider (one-time setup).
 #    --non-interactive needs an explicit --provider + --model so it

workspace-server/internal/handlers/handlers_additional_test.go

@@ -230,21 +230,20 @@ func TestWorkspaceList_WithData(t *testing.T) {
 	broadcaster := newTestBroadcaster()
 	handler := NewWorkspaceHandler(broadcaster, nil, "http://localhost:8080", t.TempDir())
 
-	// 23 cols — broadcast_enabled + talk_to_user_enabled added after monthly_spend
-	// (migration 20260514). Column order must match scanWorkspaceRow exactly.
+	// 21 cols — see scanWorkspaceRow for order (max_concurrent_tasks
+	// lands between active_tasks and last_error_rate).
 	columns := []string{
 		"id", "name", "role", "tier", "status", "agent_card", "url",
 		"parent_id", "active_tasks", "max_concurrent_tasks",
 		"last_error_rate", "last_sample_error",
 		"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 		"budget_limit", "monthly_spend",
-		"broadcast_enabled", "talk_to_user_enabled",
 	}
 	rows := sqlmock.NewRows(columns).
 		AddRow("ws-1", "Agent One", "worker", 1, "online", []byte(`{"name":"agent1"}`), "http://localhost:8001",
-			nil, 3, 1, 0.02, "", 7200, "processing", "langgraph", "", 10.0, 20.0, false, nil, int64(0), false, true).
+			nil, 3, 1, 0.02, "", 7200, "processing", "langgraph", "", 10.0, 20.0, false, nil, int64(0)).
 		AddRow("ws-2", "Agent Two", "", 2, "degraded", []byte("null"), "",
-			nil, 0, 1, 0.6, "timeout", 100, "", "claude-code", "", 50.0, 60.0, true, nil, int64(0), false, true)
+			nil, 0, 1, 0.6, "timeout", 100, "", "claude-code", "", 50.0, 60.0, true, nil, int64(0))
 
 	mock.ExpectQuery("SELECT w.id, w.name").
 		WillReturnRows(rows)

workspace-server/internal/handlers/handlers_test.go

@@ -407,21 +407,21 @@ func TestWorkspaceList(t *testing.T) {
 	broadcaster := newTestBroadcaster()
 	handler := NewWorkspaceHandler(broadcaster, nil, "http://localhost:8080", "/tmp/configs")
 
-	// 23 cols: broadcast_enabled + talk_to_user_enabled added after monthly_spend
-	// (migration 20260514). Column order must match scanWorkspaceRow exactly.
+	// 21 cols: `max_concurrent_tasks` added between active_tasks and
+	// last_error_rate (see scanWorkspaceRow + COALESCE(w.max_concurrent_tasks, 1)
+	// in workspace.go). Column order must match that scan exactly.
 	columns := []string{
 		"id", "name", "role", "tier", "status", "agent_card", "url",
 		"parent_id", "active_tasks", "max_concurrent_tasks",
 		"last_error_rate", "last_sample_error",
 		"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 		"budget_limit", "monthly_spend",
-		"broadcast_enabled", "talk_to_user_enabled",
 	}
 	rows := sqlmock.NewRows(columns).
 		AddRow("ws-1", "Agent One", "worker", 1, "online", []byte("null"), "http://localhost:8001",
-			nil, 0, 1, 0.0, "", 100, "", "claude-code", "", 10.0, 20.0, false, nil, int64(0), false, true).
+			nil, 0, 1, 0.0, "", 100, "", "claude-code", "", 10.0, 20.0, false, nil, int64(0)).
 		AddRow("ws-2", "Agent Two", "manager", 2, "provisioning", []byte("null"), "",
-			nil, 0, 1, 0.0, "", 0, "", "langgraph", "", 50.0, 60.0, false, nil, int64(0), false, true)
+			nil, 0, 1, 0.0, "", 0, "", "langgraph", "", 50.0, 60.0, false, nil, int64(0))
 
 	mock.ExpectQuery("SELECT w.id, w.name").
 		WillReturnRows(rows)
@@ -1135,14 +1135,13 @@ func TestWorkspaceGet_CurrentTask(t *testing.T) {
 		"parent_id", "active_tasks", "max_concurrent_tasks", "last_error_rate", "last_sample_error",
 		"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 		"budget_limit", "monthly_spend",
-		"broadcast_enabled", "talk_to_user_enabled",
 	}
 	mock.ExpectQuery("SELECT w.id, w.name").
 		WithArgs("dddddddd-0004-0000-0000-000000000000").
 		WillReturnRows(sqlmock.NewRows(columns).AddRow(
 			"dddddddd-0004-0000-0000-000000000000", "Task Worker", "worker", 1, "online", []byte("null"), "http://localhost:9000",
 			nil, 2, 1, 0.0, "", 300, "Analyzing document", "langgraph", "", 10.0, 20.0, false,
-			nil, int64(0), false, true,
+			nil, int64(0),
 		))
 
 	w := httptest.NewRecorder()

workspace-server/internal/handlers/instructions.go

@@ -248,9 +248,6 @@ func (h *InstructionsHandler) Resolve(c *gin.Context) {
 		b.WriteString(content)
 		b.WriteString("\n\n")
 	}
-	if err := rows.Err(); err != nil {
-		log.Printf("ResolveInstructions rows.Err workspace=%s: %v", workspaceID, err)
-	}
 
 	c.JSON(http.StatusOK, gin.H{
 		"workspace_id": workspaceID,
@@ -261,7 +258,6 @@ func (h *InstructionsHandler) Resolve(c *gin.Context) {
 func scanInstructions(rows interface {
 	Next() bool
 	Scan(dest ...interface{}) error
-	Err() error
 }) []Instruction {
 	var instructions []Instruction
 	for rows.Next() {
@@ -273,9 +269,6 @@ func scanInstructions(rows interface {
 		}
 		instructions = append(instructions, inst)
 	}
-	if err := rows.Err(); err != nil {
-		log.Printf("scanInstructions rows.Err: %v", err)
-	}
 	if instructions == nil {
 		instructions = []Instruction{}
 	}

workspace-server/internal/handlers/instructions_test.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"errors"
 	"net/http"
 	"net/http/httptest"
 	"regexp"
@@ -15,69 +14,22 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-// ─── request helpers ───────────────────────────────────────────────────────────
+// ── List ─────────────────────────────────────────────────────────────────────────
 
-func newPostRequest(path string, body interface{}) (*httptest.ResponseRecorder, *gin.Context) {
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	raw, _ := json.Marshal(body)
-	c.Request = httptest.NewRequest(http.MethodPost, path, bytes.NewReader(raw))
-	c.Request.Header.Set("Content-Type", "application/json")
-	return w, c
-}
-
-func newPutRequest(path string, body interface{}) (*httptest.ResponseRecorder, *gin.Context) {
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	raw, _ := json.Marshal(body)
-	c.Request = httptest.NewRequest(http.MethodPut, path, bytes.NewReader(raw))
-	c.Request.Header.Set("Content-Type", "application/json")
-	return w, c
-}
-
-func newDeleteRequest(path string) (*httptest.ResponseRecorder, *gin.Context) {
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Request = httptest.NewRequest(http.MethodDelete, path, nil)
-	return w, c
-}
-
-func newGetRequest(path string) (*httptest.ResponseRecorder, *gin.Context) {
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Request = httptest.NewRequest(http.MethodGet, path, nil)
-	return w, c
-}
-
-// ─── mock row helpers ─────────────────────────────────────────────────────────
-
-// instructionCols matches the SELECT in List/Resolve.
-var instructionCols = []string{
-	"id", "scope", "scope_target", "title", "content",
-	"priority", "enabled", "created_at", "updated_at",
-}
-
-// resolveCols matches the SELECT in Resolve (scope, title, content).
-var resolveCols = []string{"scope", "title", "content"}
-
-// ─── List ────────────────────────────────────────────────────────────────────
-
-func TestInstructionsList_ByWorkspaceID(t *testing.T) {
+func TestInstructionsHandler_List_EmptyResult(t *testing.T) {
 	mock := setupTestDB(t)
-	h := NewInstructionsHandler()
+	handler := NewInstructionsHandler()
 
-	wsID := "ws-123-abc"
-	w, c := newGetRequest("/instructions?workspace_id=" + wsID)
-	c.Request = httptest.NewRequest(http.MethodGet, "/instructions?workspace_id="+wsID, nil)
+	mock.ExpectQuery("SELECT id, scope, scope_target, title, content, priority, enabled, created_at, updated_at FROM platform_instructions WHERE 1=1 ORDER BY scope, priority DESC, created_at").
+		WillReturnRows(sqlmock.NewRows([]string{
+			"id", "scope", "scope_target", "title", "content", "priority", "enabled", "created_at", "updated_at",
+		}))
 
-	rows := sqlmock.NewRows(instructionCols).
-		AddRow("inst-1", "global", nil, "Be helpful", "Always be helpful.", 10, true, time.Now(), time.Now()).
-		AddRow("inst-2", "workspace", &wsID, "Use Claude", "Use Claude Code.", 5, true, time.Now(), time.Now())
-	mock.ExpectQuery("SELECT id, scope, scope_target, title, content, priority, enabled, created_at, updated_at").
-		WithArgs(wsID).
-		WillReturnRows(rows)
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Request = httptest.NewRequest("GET", "/instructions", nil)
 
-	h.List(c)
+	handler.List(c)
 
 	if w.Code != http.StatusOK {
 		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
@@ -86,11 +38,8 @@ func TestInstructionsList_ByWorkspaceID(t *testing.T) {
 	if err := json.Unmarshal(w.Body.Bytes(), &result); err != nil {
 		t.Fatalf("invalid JSON: %v", err)
 	}
-	if len(result) != 2 {
-		t.Fatalf("expected 2 instructions, got %d", len(result))
-	}
-	if result[0].Scope != "global" || result[1].Scope != "workspace" {
-		t.Fatalf("expected global then workspace instructions, got %#v", result)
+	if len(result) != 0 {
+		t.Fatalf("expected 0 instructions, got %d", len(result))
 	}
 	if err := mock.ExpectationsWereMet(); err != nil {
 		t.Fatalf("unmet expectations: %v", err)
@@ -215,104 +164,33 @@ func TestInstructionsHandler_Create_Success(t *testing.T) {
 	if w.Code != http.StatusCreated {
 		t.Fatalf("expected 201, got %d: %s", w.Code, w.Body.String())
 	}
-	var out map[string]string
-	if err := json.Unmarshal(w.Body.Bytes(), &out); err != nil {
-		t.Fatalf("response not valid JSON: %v", err)
+	var resp map[string]string
+	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
+		t.Fatalf("invalid JSON: %v", err)
 	}
-	if out["id"] != "new-inst-id" {
-		t.Errorf("expected id new-inst-id, got %s", out["id"])
+	if resp["id"] != "new-inst-id" {
+		t.Errorf("expected id 'new-inst-id', got %q", resp["id"])
 	}
 	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
+		t.Fatalf("unmet expectations: %v", err)
 	}
 }
 
-func TestInstructionsCreate_ValidWorkspace(t *testing.T) {
-	mock := setupTestDB(t)
-	h := NewInstructionsHandler()
-	wsTarget := "ws-xyz-789"
-
-	w, c := newPostRequest("/instructions", map[string]interface{}{
-		"scope":        "workspace",
-		"scope_target": wsTarget,
-		"title":        "Use Claude Code",
-		"content":      "Prefer Claude Code for all tasks.",
-		"priority":     5,
-	})
-
-	mock.ExpectQuery("INSERT INTO platform_instructions").
-		WithArgs("workspace", &wsTarget, "Use Claude Code", "Prefer Claude Code for all tasks.", 5).
-		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow("ws-inst-2"))
-
-	h.Create(c)
-
-	if w.Code != http.StatusCreated {
-		t.Fatalf("expected 201, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-func TestInstructionsCreate_MissingScope(t *testing.T) {
+func TestInstructionsHandler_Create_InvalidScope(t *testing.T) {
 	setupTestDB(t)
-	h := NewInstructionsHandler()
+	handler := NewInstructionsHandler()
 
-	w, c := newPostRequest("/instructions", map[string]interface{}{
-		"title":   "Missing Scope",
-		"content": "This has no scope.",
-	})
-
-	h.Create(c)
-
-	if w.Code != http.StatusBadRequest {
-		t.Fatalf("expected 400, got %d: %s", w.Code, w.Body.String())
-	}
-}
-
-func TestInstructionsCreate_MissingTitle(t *testing.T) {
-	setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	w, c := newPostRequest("/instructions", map[string]interface{}{
-		"scope":   "global",
-		"content": "Has no title.",
-	})
-
-	h.Create(c)
-
-	if w.Code != http.StatusBadRequest {
-		t.Fatalf("expected 400, got %d: %s", w.Code, w.Body.String())
-	}
-}
-
-func TestInstructionsCreate_MissingContent(t *testing.T) {
-	setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	w, c := newPostRequest("/instructions", map[string]interface{}{
-		"scope": "global",
-		"title": "Has no content",
-	})
-
-	h.Create(c)
-
-	if w.Code != http.StatusBadRequest {
-		t.Fatalf("expected 400, got %d: %s", w.Code, w.Body.String())
-	}
-}
-
-func TestInstructionsCreate_InvalidScope(t *testing.T) {
-	setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	w, c := newPostRequest("/instructions", map[string]interface{}{
+	body, _ := json.Marshal(map[string]interface{}{
 		"scope":   "team",
-		"title":   "Bad Scope",
-		"content": "Team scope is not supported yet.",
+		"title":   "Test",
+		"content": "Test content",
 	})
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Request = httptest.NewRequest("POST", "/instructions", bytes.NewReader(body))
+	c.Request.Header.Set("Content-Type", "application/json")
 
-	h.Create(c)
+	handler.Create(c)
 
 	if w.Code != http.StatusBadRequest {
 		t.Fatalf("expected 400, got %d: %s", w.Code, w.Body.String())
@@ -384,489 +262,55 @@ func TestInstructionsHandler_Create_TitleTooLong(t *testing.T) {
 	}
 }
 
-func TestInstructionsCreate_DBError(t *testing.T) {
+func TestInstructionsHandler_Create_WorkspaceScopeWithScopeTarget(t *testing.T) {
 	mock := setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	w, c := newPostRequest("/instructions", map[string]interface{}{
-		"scope":   "global",
-		"title":   "DB Error",
-		"content": "This will fail.",
-	})
+	handler := NewInstructionsHandler()
+	wsID := "ws-abc-123"
 
 	mock.ExpectQuery("INSERT INTO platform_instructions").
-		WillReturnError(errors.New("connection refused"))
+		WithArgs("workspace", &wsID, "WS rule", "Use HTTPS", 10).
+		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow("ws-inst-1"))
 
-	h.Create(c)
-
-	if w.Code != http.StatusInternalServerError {
-		t.Fatalf("expected 500, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-// ─── Update ──────────────────────────────────────────────────────────────────
-
-func TestInstructionsUpdate_ValidPartial(t *testing.T) {
-	mock := setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	instID := "inst-update-1"
-	newTitle := "Updated Title"
-	w, c := newPutRequest("/instructions/"+instID, map[string]interface{}{
-		"title": newTitle,
-	})
-	c.Params = []gin.Param{{Key: "id", Value: instID}}
-
-	mock.ExpectExec("UPDATE platform_instructions SET").
-		WithArgs(instID, &newTitle, sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg()).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-
-	h.Update(c)
-
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-func TestInstructionsUpdate_AllFields(t *testing.T) {
-	mock := setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	instID := "inst-update-2"
-	title := "Full Update"
-	content := "New content body."
-	priority := 20
-	enabled := false
-	w, c := newPutRequest("/instructions/"+instID, map[string]interface{}{
-		"title":    title,
-		"content":  content,
-		"priority": priority,
-		"enabled":  enabled,
-	})
-	c.Params = []gin.Param{{Key: "id", Value: instID}}
-
-	mock.ExpectExec("UPDATE platform_instructions SET").
-		WithArgs(instID, &title, &content, &priority, &enabled).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-
-	h.Update(c)
-
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-func TestInstructionsUpdate_ContentTooLong(t *testing.T) {
-	setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	instID := "inst-too-long"
-	longContent := string(make([]byte, maxInstructionContentLen+1))
-	w, c := newPutRequest("/instructions/"+instID, map[string]interface{}{
-		"content": longContent,
-	})
-	c.Params = []gin.Param{{Key: "id", Value: instID}}
-
-	h.Update(c)
-
-	if w.Code != http.StatusBadRequest {
-		t.Fatalf("expected 400, got %d: %s", w.Code, w.Body.String())
-	}
-}
-
-func TestInstructionsUpdate_TitleTooLong(t *testing.T) {
-	setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	instID := "inst-title-long"
-	longTitle := string(make([]byte, 201))
-	w, c := newPutRequest("/instructions/"+instID, map[string]interface{}{
-		"title": longTitle,
-	})
-	c.Params = []gin.Param{{Key: "id", Value: instID}}
-
-	h.Update(c)
-
-	if w.Code != http.StatusBadRequest {
-		t.Fatalf("expected 400, got %d: %s", w.Code, w.Body.String())
-	}
-}
-
-func TestInstructionsUpdate_NotFound(t *testing.T) {
-	mock := setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	instID := "inst-missing"
-	w, c := newPutRequest("/instructions/"+instID, map[string]interface{}{
-		"title": "New Title",
-	})
-	c.Params = []gin.Param{{Key: "id", Value: instID}}
-
-	mock.ExpectExec("UPDATE platform_instructions SET").
-		WillReturnResult(sqlmock.NewResult(0, 0))
-
-	h.Update(c)
-
-	if w.Code != http.StatusNotFound {
-		t.Fatalf("expected 404, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-func TestInstructionsUpdate_DBError(t *testing.T) {
-	mock := setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	instID := "inst-db-err"
-	w, c := newPutRequest("/instructions/"+instID, map[string]interface{}{
-		"title": "Error Update",
-	})
-	c.Params = []gin.Param{{Key: "id", Value: instID}}
-
-	mock.ExpectExec("UPDATE platform_instructions SET").
-		WillReturnError(errors.New("connection refused"))
-
-	h.Update(c)
-
-	if w.Code != http.StatusInternalServerError {
-		t.Fatalf("expected 500, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-// ─── Delete ───────────────────────────────────────────────────────────────────
-
-func TestInstructionsDelete_Valid(t *testing.T) {
-	mock := setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	instID := "inst-delete-1"
-	w, c := newDeleteRequest("/instructions/" + instID)
-	c.Params = []gin.Param{{Key: "id", Value: instID}}
-
-	mock.ExpectExec(`DELETE FROM platform_instructions WHERE id = \$1`).
-		WithArgs(instID).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-
-	h.Delete(c)
-
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-func TestInstructionsDelete_NotFound(t *testing.T) {
-	mock := setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	instID := "inst-not-there"
-	w, c := newDeleteRequest("/instructions/" + instID)
-	c.Params = []gin.Param{{Key: "id", Value: instID}}
-
-	mock.ExpectExec(`DELETE FROM platform_instructions WHERE id = \$1`).
-		WithArgs(instID).
-		WillReturnResult(sqlmock.NewResult(0, 0))
-
-	h.Delete(c)
-
-	if w.Code != http.StatusNotFound {
-		t.Fatalf("expected 404, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-func TestInstructionsDelete_DBError(t *testing.T) {
-	mock := setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	instID := "inst-del-err"
-	w, c := newDeleteRequest("/instructions/" + instID)
-	c.Params = []gin.Param{{Key: "id", Value: instID}}
-
-	mock.ExpectExec(`DELETE FROM platform_instructions WHERE id = \$1`).
-		WithArgs(instID).
-		WillReturnError(errors.New("connection refused"))
-
-	h.Delete(c)
-
-	if w.Code != http.StatusInternalServerError {
-		t.Fatalf("expected 500, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-// ─── Resolve ──────────────────────────────────────────────────────────────────
-
-func TestInstructionsResolve_GlobalThenWorkspace(t *testing.T) {
-	mock := setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	wsID := "ws-resolve-1"
-	w, c := newGetRequest("/workspaces/" + wsID + "/instructions/resolve")
-	c.Params = []gin.Param{{Key: "id", Value: wsID}}
-	c.Request = httptest.NewRequest(http.MethodGet, "/workspaces/"+wsID+"/instructions/resolve", nil)
-
-	rows := sqlmock.NewRows(resolveCols).
-		AddRow("global", "Be Helpful", "Always help the user.").
-		AddRow("global", "Stay on Topic", "Don't diverge.").
-		AddRow("workspace", "Use Claude Code", "Claude Code is the default runtime.")
-	mock.ExpectQuery("SELECT scope, title, content FROM platform_instructions").
-		WithArgs(wsID).
-		WillReturnRows(rows)
-
-	h.Resolve(c)
-
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	var out struct {
-		WorkspaceID   string `json:"workspace_id"`
-		Instructions string `json:"instructions"`
-	}
-	if err := json.Unmarshal(w.Body.Bytes(), &out); err != nil {
-		t.Fatalf("response not valid JSON: %v", err)
-	}
-	if out.WorkspaceID != wsID {
-		t.Errorf("expected workspace_id %s, got %s", wsID, out.WorkspaceID)
-	}
-	// Global section must come before workspace section.
-	if !bytes.Contains([]byte(out.Instructions), []byte("Platform-Wide Rules")) {
-		t.Error("instructions should contain 'Platform-Wide Rules' section")
-	}
-	if !bytes.Contains([]byte(out.Instructions), []byte("Role-Specific Rules")) {
-		t.Error("instructions should contain 'Role-Specific Rules' section")
-	}
-	// Global instructions must appear before workspace instructions.
-	idxGlobal := bytes.Index([]byte(out.Instructions), []byte("Platform-Wide Rules"))
-	idxWorkspace := bytes.Index([]byte(out.Instructions), []byte("Role-Specific Rules"))
-	if idxGlobal >= idxWorkspace {
-		t.Error("global section should appear before workspace section")
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-func TestInstructionsResolve_EmptyWorkspace(t *testing.T) {
-	mock := setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	wsID := "ws-empty"
-	w, c := newGetRequest("/workspaces/" + wsID + "/instructions/resolve")
-	c.Params = []gin.Param{{Key: "id", Value: wsID}}
-	c.Request = httptest.NewRequest(http.MethodGet, "/workspaces/"+wsID+"/instructions/resolve", nil)
-
-	rows := sqlmock.NewRows(resolveCols)
-	mock.ExpectQuery("SELECT scope, title, content FROM platform_instructions").
-		WithArgs(wsID).
-		WillReturnRows(rows)
-
-	h.Resolve(c)
-
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	var out struct {
-		Instructions string `json:"instructions"`
-	}
-	if err := json.Unmarshal(w.Body.Bytes(), &out); err != nil {
-		t.Fatalf("response not valid JSON: %v", err)
-	}
-	// No rows → builder writes nothing; empty string returned.
-	if out.Instructions != "" {
-		t.Errorf("expected empty instructions for empty workspace, got: %q", out.Instructions)
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-func TestInstructionsResolve_DBError(t *testing.T) {
-	mock := setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	wsID := "ws-err"
-	w, c := newGetRequest("/workspaces/" + wsID + "/instructions/resolve")
-	c.Params = []gin.Param{{Key: "id", Value: wsID}}
-	c.Request = httptest.NewRequest(http.MethodGet, "/workspaces/"+wsID+"/instructions/resolve", nil)
-
-	mock.ExpectQuery("SELECT scope, title, content FROM platform_instructions").
-		WithArgs(wsID).
-		WillReturnError(errors.New("connection refused"))
-
-	h.Resolve(c)
-
-	if w.Code != http.StatusInternalServerError {
-		t.Fatalf("expected 500, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-func TestInstructionsResolve_MissingWorkspaceID(t *testing.T) {
-	setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	w, c := newGetRequest("/workspaces//instructions/resolve")
-	c.Params = []gin.Param{{Key: "id", Value: ""}}
-
-	h.Resolve(c)
-
-	if w.Code != http.StatusBadRequest {
-		t.Fatalf("expected 400, got %d: %s", w.Code, w.Body.String())
-	}
-}
-
-// ─── scanInstructions edge cases ───────────────────────────────────────────────
-
-// NOTE: TestScanInstructions_ScanError was removed — go-sqlmock v1.5.2 does not
-// implement Go 1.25's sql.Rows.Next([]byte) bool method, so *sqlmock.Rows cannot
-// satisfy scanInstructions' interface. The test needs a sqlmock upgrade or a
-// different mocking strategy (tracked: internal issue).
-
-// ─── maxInstructionContentLen boundary ────────────────────────────────────────
-
-func TestInstructionsCreate_ContentExactlyAtLimit(t *testing.T) {
-	mock := setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	exactContent := string(make([]byte, maxInstructionContentLen))
-	w, c := newPostRequest("/instructions", map[string]interface{}{
-		"scope":   "global",
-		"title":   "At Limit",
-		"content": exactContent,
-	})
-
-	mock.ExpectQuery("INSERT INTO platform_instructions").
-		WithArgs("global", nil, "At Limit", exactContent, 0).
-		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow("at-limit-1"))
-
-	h.Create(c)
-
-	// Exactly at limit must succeed (8192 chars is acceptable).
-	if w.Code != http.StatusCreated {
-		t.Fatalf("expected 201 for content at limit, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-// ─── priority defaults ────────────────────────────────────────────────────────
-
-func TestInstructionsCreate_PriorityDefaultsToZero(t *testing.T) {
-	mock := setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	// Body omits priority — expect it defaults to 0.
-	w, c := newPostRequest("/instructions", map[string]interface{}{
-		"scope":   "global",
-		"title":   "No Priority",
-		"content": "Default priority body.",
-	})
-
-	mock.ExpectQuery("INSERT INTO platform_instructions").
-		WithArgs("global", nil, "No Priority", "Default priority body.", 0).
-		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow("no-prio-1"))
-
-	h.Create(c)
-
-	if w.Code != http.StatusCreated {
-		t.Fatalf("expected 201, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-// ─── nil scope_target for global instructions ─────────────────────────────────
-
-func TestInstructionsCreate_GlobalScopeNilTarget(t *testing.T) {
-	mock := setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	w, c := newPostRequest("/instructions", map[string]interface{}{
-		"scope":   "global",
-		"title":   "Global Nil Target",
-		"content": "Global instruction.",
-	})
-
-	// For global scope, scope_target must be SQL NULL.
-	mock.ExpectQuery("INSERT INTO platform_instructions").
-		WithArgs("global", nil, "Global Nil Target", "Global instruction.", 0).
-		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow("global-nil-1"))
-
-	h.Create(c)
-
-	if w.Code != http.StatusCreated {
-		t.Fatalf("expected 201, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-// ─── workspace scope with empty string target (rejected) ─────────────────────
-
-func TestInstructionsCreate_WorkspaceScopeEmptyStringTarget(t *testing.T) {
-	setupTestDB(t)
-	h := NewInstructionsHandler()
-
-	empty := ""
-	w, c := newPostRequest("/instructions", map[string]interface{}{
+	body, _ := json.Marshal(map[string]interface{}{
 		"scope":        "workspace",
-		"scope_target": empty,
-		"title":        "Empty Target",
-		"content":      "Empty workspace target.",
+		"scope_target": wsID,
+		"title":        "WS rule",
+		"content":      "Use HTTPS",
+		"priority":     10,
 	})
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Request = httptest.NewRequest("POST", "/instructions", bytes.NewReader(body))
+	c.Request.Header.Set("Content-Type", "application/json")
 
-	h.Create(c)
+	handler.Create(c)
 
-	if w.Code != http.StatusBadRequest {
-		t.Fatalf("expected 400 for empty string scope_target, got %d: %s", w.Code, w.Body.String())
+	if w.Code != http.StatusCreated {
+		t.Fatalf("expected 201, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Fatalf("unmet expectations: %v", err)
 	}
 }
 
-// ─── Resolve: scope label transitions ────────────────────────────────────────
+// ── Update ────────────────────────────────────────────────────────────────────
 
-func TestInstructionsResolve_ScopeTransitionOnlyGlobal(t *testing.T) {
+func TestInstructionsHandler_Update_Success(t *testing.T) {
 	mock := setupTestDB(t)
-	h := NewInstructionsHandler()
+	handler := NewInstructionsHandler()
 
-	wsID := "ws-only-global"
-	w, c := newGetRequest("/workspaces/" + wsID + "/instructions/resolve")
-	c.Params = []gin.Param{{Key: "id", Value: wsID}}
-	c.Request = httptest.NewRequest(http.MethodGet, "/workspaces/"+wsID+"/instructions/resolve", nil)
+	mock.ExpectExec(regexp.QuoteMeta("UPDATE platform_instructions SET\n\t\t\t\ttitle = COALESCE($2, title),\n\t\t\t\tcontent = COALESCE($3, content),\n\t\t\t\tpriority = COALESCE($4, priority),\n\t\t\t\tenabled = COALESCE($5, enabled),\n\t\t\t\tupdated_at = NOW()\n\t\t\t\tWHERE id = $1")).
+		WithArgs("inst-1", sqlmock.AnyArg(), nil, nil, nil).
+		WillReturnResult(sqlmock.NewResult(0, 1))
 
-	rows := sqlmock.NewRows(resolveCols).
-		AddRow("global", "Rule One", "First rule.").
-		AddRow("global", "Rule Two", "Second rule.")
-	mock.ExpectQuery("SELECT scope, title, content FROM platform_instructions").
-		WithArgs(wsID).
-		WillReturnRows(rows)
+	body, _ := json.Marshal(map[string]interface{}{"title": "Updated title"})
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Params = gin.Params{{Key: "id", Value: "inst-1"}}
+	c.Request = httptest.NewRequest("PUT", "/instructions/inst-1", bytes.NewReader(body))
+	c.Request.Header.Set("Content-Type", "application/json")
 
-	h.Resolve(c)
+	handler.Update(c)
 
 	if w.Code != http.StatusOK {
 		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())

workspace-server/internal/handlers/mcp_test.go

@@ -751,9 +751,9 @@ func TestMCPHandler_SendMessageToUser_DBErrorLogsAndStill200s(t *testing.T) {
 	t.Setenv("MOLECULE_MCP_ALLOW_SEND_MESSAGE", "true")
 	h, mock := newMCPHandler(t)
 
-	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
+	mock.ExpectQuery("SELECT name FROM workspaces").
 		WithArgs("ws-err").
-		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("CEO Ryan PC", true))
+		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("CEO Ryan PC"))
 
 	// INSERT fails — must NOT abort the tool response.
 	mock.ExpectExec(`INSERT INTO activity_logs.*'a2a_receive'.*'notify'`).
@@ -802,9 +802,9 @@ func TestMCPHandler_SendMessageToUser_ResponseBodyShape(t *testing.T) {
 
 	const userMessage = "Hi there from the agent"
 
-	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
+	mock.ExpectQuery("SELECT name FROM workspaces").
 		WithArgs("ws-shape").
-		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("CEO Ryan PC", true))
+		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("CEO Ryan PC"))
 
 	// Capture the response_body argument and assert its exact shape.
 	mock.ExpectExec(`INSERT INTO activity_logs.*'a2a_receive'.*'notify'`).
@@ -861,9 +861,9 @@ func TestMCPHandler_SendMessageToUser_PersistsToActivityLog(t *testing.T) {
 	// before it does anything else. Returning a name lets the
 	// broadcast payload populate; the test doesn't assert on the
 	// broadcast (no observable WS in this fake), only on the DB.
-	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
+	mock.ExpectQuery("SELECT name FROM workspaces").
 		WithArgs("ws-msg").
-		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("CEO Ryan PC", true))
+		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("CEO Ryan PC"))
 
 	// The persistence INSERT — pin the exact shape so a future
 	// refactor that switches columns or drops `method='notify'`

workspace-server/internal/handlers/org_helpers.go

@@ -15,7 +15,6 @@ import (
 
 	"gopkg.in/yaml.v3"
 )
-
 // resolvePromptRef reads a prompt body from either an inline string or a
 // file ref relative to the workspace's files_dir. Inline always wins when
 // both are non-empty (caller-provided inline is more authoritative than a
@@ -81,100 +80,23 @@ func hasUnresolvedVarRef(original, expanded string) bool {
 }
 
 // expandWithEnv expands ${VAR} and $VAR references in s using the env map.
-// Falls back to the platform process env only when the whole value is a
-// single variable reference; embedded process-env expansion is too broad for
-// imported org YAML because host variables such as HOME are not template data.
+// Falls back to the platform process env if a var isn't in the map.
+// Shell variables must start with a letter or '_' per POSIX; invalid identifiers
+// are returned literally so that "$100" and "$5" stay as-is.
 func expandWithEnv(s string, env map[string]string) string {
-	if s == "" {
-		return ""
-	}
-	var b strings.Builder
-	for i := 0; i < len(s); {
-		if s[i] != '$' {
-			b.WriteByte(s[i])
-			i++
-			continue
+	return os.Expand(s, func(key string) string {
+		if len(key) == 0 {
+			return "$"
 		}
-
-		if i+1 >= len(s) {
-			b.WriteByte('$')
-			i++
-			continue
+		c := key[0]
+		if !((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_') {
+			return "$" + key // not a valid shell identifier — return literal
 		}
-
-		if s[i+1] == '{' {
-			end := strings.IndexByte(s[i+2:], '}')
-			if end < 0 {
-				b.WriteByte('$')
-				i++
-				continue
-			}
-			end += i + 2
-			key := s[i+2 : end]
-			ref := s[i : end+1]
-			b.WriteString(expandEnvRef(key, ref, s, env))
-			i = end + 1
-			continue
+		if v, ok := env[key]; ok {
+			return v
 		}
-
-		if !isEnvIdentStart(s[i+1]) {
-			b.WriteByte('$')
-			i++
-			continue
-		}
-		j := i + 2
-		for j < len(s) && isEnvIdentPart(s[j]) {
-			j++
-		}
-		key := s[i+1 : j]
-		ref := s[i:j]
-		b.WriteString(expandEnvRef(key, ref, s, env))
-		i = j
-	}
-	return b.String()
-}
-
-// expandEnvRef resolves a single variable reference extracted from s.
-//
-// Guards:
-//   - Empty key → "$$" escape, return "$"
-//   - key[0] not POSIX ident start → "$" + partial chars, return "$<chars>"
-//   - Key in env map → return the mapped value (template override wins)
-//   - Otherwise → only fall back to os.Getenv if the whole input string IS the
-//     variable reference (ref == whole).
-//
-// Bare $VAR format:
-//   $HOME (alone) → ref==whole → os.Getenv ✓  (host HOME is org-template HOME)
-//   $HOME/path (partial) → ref!=whole → literal "$HOME" ✓  (CWE-78: prevents host leak)
-//
-// Braced ${VAR} format:
-//   ${HOME} (alone) → ref==whole → os.Getenv ✓
-//   ${ROLE}/admin (partial) → ref!=whole → literal ✓
-//   "yes and ${NOT_SET}" (embedded) → ref!=whole → literal ✓
-//
-// This is the CWE-78 fix from commit a3a358f9.
-func expandEnvRef(key, ref, whole string, env map[string]string) string {
-	if key == "" {
-		return "$"
-	}
-	if !isEnvIdentStart(key[0]) {
-		return "$" + key
-	}
-	if v, ok := env[key]; ok {
-		return v
-	}
-	if ref == whole {
 		return os.Getenv(key)
-	}
-	return ref
-}
-
-func isEnvIdentStart(c byte) bool {
-	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_'
-}
-
-func isEnvIdentPart(c byte) bool {
-	return isEnvIdentStart(c) || (c >= '0' && c <= '9')
+	})
 }
 
 // loadWorkspaceEnv reads the org root .env and the workspace-specific .env

workspace-server/internal/handlers/org_helpers_pure_test.go

@@ -462,8 +462,6 @@ func TestExpandWithEnv_LiteralDollar(t *testing.T) {
 func TestExpandWithEnv_PartiallyPresent(t *testing.T) {
 	env := map[string]string{"SET": "yes"}
 	result := expandWithEnv("${SET} and ${NOT_SET}", env)
-	// ${SET} resolved from env; ${NOT_SET} stays literal (not whole-string ref,
-	// so os.Getenv fallback is NOT used — CWE-78 regression guard).
 	assert.Equal(t, "yes and ${NOT_SET}", result)
 }
 
@@ -628,7 +626,7 @@ func TestRenderCategoryRoutingYAML_SpecialCharactersEscaped(t *testing.T) {
 // ── Additional coverage: appendYAMLBlock ───────────────────────────
 func TestAppendYAMLBlock_BothEmpty(t *testing.T) {
 	result := appendYAMLBlock(nil, "")
-	assert.Nil(t, result) // append(nil, []byte("")...) returns nil in Go
+	assert.Nil(t, result)
 }
 
 func TestAppendYAMLBlock_ExistingHasNewline(t *testing.T) {

workspace-server/internal/handlers/org_helpers_security_test.go

@@ -276,121 +276,3 @@ func TestMergeCategoryRouting_OriginalMapsUnmodified(t *testing.T) {
 		t.Error("ws routing should be unmodified after merge")
 	}
 }
-
-// ── expandWithEnv ─────────────────────────────────────────────────────────────
-//
-// CWE-78 regression tests. The original fix (a3a358f9) ensures that partial
-// variable references like $HOME/path are NOT resolved via os.Getenv — the
-// host HOME env var must not leak into org template values. Only whole-string
-// references ($VAR or ${VAR}) may fall back to the host process environment.
-
-func TestExpandWithEnv_PartialRefDollarHomePath(t *testing.T) {
-	// $HOME/path must NOT resolve to the host's HOME env var.
-	// The literal $HOME must be returned as-is.
-	got := expandWithEnv("$HOME/path", nil)
-	if got != "$HOME/path" {
-		t.Errorf("$HOME/path: got %q, want literal $HOME/path", got)
-	}
-}
-
-func TestExpandWithEnv_PartialRefBracedRoleAdmin(t *testing.T) {
-	// ${ROLE}/admin — ROLE is not in env, so expand to the literal ${ROLE}/admin.
-	got := expandWithEnv("${ROLE}/admin", nil)
-	if got != "${ROLE}/admin" {
-		t.Errorf("${ROLE}/admin: got %q, want literal ${ROLE}/admin", got)
-	}
-}
-
-func TestExpandWithEnv_PartialRefMiddleOfString(t *testing.T) {
-	// $ROLE in the middle of a string — literal, not os.Getenv.
-	got := expandWithEnv("prefix/$ROLE/suffix", nil)
-	if got != "prefix/$ROLE/suffix" {
-		t.Errorf("prefix/$ROLE/suffix: got %q, want literal", got)
-	}
-}
-
-func TestExpandWithEnv_WholeVarInEnv(t *testing.T) {
-	// Whole-string $VAR that IS in env — env value wins.
-	env := map[string]string{"FOO": "barvalue"}
-	got := expandWithEnv("$FOO", env)
-	if got != "barvalue" {
-		t.Errorf("$FOO with FOO=barvalue: got %q, want barvalue", got)
-	}
-}
-
-func TestExpandWithEnv_WholeVarBracedInEnv(t *testing.T) {
-	// Whole-string ${VAR} that IS in env — env value wins.
-	env := map[string]string{"FOO": "barvalue"}
-	got := expandWithEnv("${FOO}", env)
-	if got != "barvalue" {
-		t.Errorf("${FOO} with FOO=barvalue: got %q, want barvalue", got)
-	}
-}
-
-func TestExpandWithEnv_WholeVarNotInEnvBare(t *testing.T) {
-	// Whole-string $VAR not in env — falls back to os.Getenv.
-	// If the host has the var, we get the host value. If not, empty.
-	// At minimum, the result must NOT be the literal "$UNDEFINED_VAR_9Z".
-	got := expandWithEnv("$UNDEFINED_VAR_9Z", nil)
-	if got == "$UNDEFINED_VAR_9Z" {
-		t.Errorf("$UNDEFINED_VAR_9Z: should expand (whole-string fallback to os.Getenv), got literal")
-	}
-}
-
-func TestExpandWithEnv_WholeVarNotInEnvBraced(t *testing.T) {
-	// Whole-string ${VAR} not in env — falls back to os.Getenv.
-	got := expandWithEnv("${UNDEFINED_VAR_9Z}", nil)
-	if got == "${UNDEFINED_VAR_9Z}" {
-		t.Errorf("${UNDEFINED_VAR_9Z}: should expand (whole-string fallback to os.Getenv), got literal")
-	}
-}
-
-func TestExpandWithEnv_EmptyString(t *testing.T) {
-	got := expandWithEnv("", map[string]string{"FOO": "bar"})
-	if got != "" {
-		t.Errorf("empty string: got %q, want empty", got)
-	}
-}
-
-func TestExpandWithEnv_NoVarRefs(t *testing.T) {
-	got := expandWithEnv("plain string with no vars", map[string]string{"FOO": "bar"})
-	if got != "plain string with no vars" {
-		t.Errorf("plain string: got %q, want unchanged", got)
-	}
-}
-
-func TestExpandWithEnv_MultipleVarRefs(t *testing.T) {
-	// Two vars, both whole — both expand from env.
-	env := map[string]string{"A": "alpha", "B": "beta"}
-	got := expandWithEnv("$A and $B and more", env)
-	if got != "alpha and beta and more" {
-		t.Errorf("multiple vars: got %q, want alpha and beta and more", got)
-	}
-}
-
-func TestExpandWithEnv_NumericVarRef(t *testing.T) {
-	// $5 — starts with digit, not a valid identifier start.
-	// Must return the literal "$5", not expand via os.Getenv.
-	got := expandWithEnv("$5", map[string]string{"5": "five"})
-	if got != "$5" {
-		t.Errorf("$5: got %q, want literal $5", got)
-	}
-}
-
-func TestExpandWithEnv_DollarEscape(t *testing.T) {
-	// $$ → both $ written literally (each $ is not followed by an identifier char,
-	// so it is written as-is). No special escape sequence for $$.
-	got := expandWithEnv("$$", nil)
-	if got != "$$" {
-		t.Errorf("$$: got %q, want literal $$", got)
-	}
-}
-
-func TestExpandWithEnv_MixedPartialAndWhole(t *testing.T) {
-	// $A is in env (whole), $HOME is partial — only $A expands.
-	env := map[string]string{"A": "alpha"}
-	got := expandWithEnv("$A at $HOME", env)
-	if got != "alpha at $HOME" {
-		t.Errorf("$A at $HOME: got %q, want alpha at $HOME", got)
-	}
-}

workspace-server/internal/handlers/secrets.go

@@ -64,7 +64,7 @@ func (h *SecretsHandler) List(c *gin.Context) {
 		})
 	}
 	if err := rows.Err(); err != nil {
-		log.Printf("List workspace secrets iteration error: %v", err)
+		log.Printf("List secrets rows.Err: %v", err)
 	}
 
 	// 2. Global secrets not overridden at workspace level
@@ -95,7 +95,7 @@ func (h *SecretsHandler) List(c *gin.Context) {
 		})
 	}
 	if err := globalRows.Err(); err != nil {
-		log.Printf("List global secrets iteration error: %v", err)
+		log.Printf("List secrets (global) rows.Err: %v", err)
 	}
 
 	c.JSON(http.StatusOK, secrets)
@@ -181,7 +181,7 @@ func (h *SecretsHandler) Values(c *gin.Context) {
 			}
 		}
 		if err := globalRows.Err(); err != nil {
-			log.Printf("secrets.Values: global rows iteration error: %v", err)
+			log.Printf("secrets.Values globalRows.Err: %v", err)
 		}
 	}
 
@@ -205,7 +205,7 @@ func (h *SecretsHandler) Values(c *gin.Context) {
 			}
 		}
 		if err := wsRows.Err(); err != nil {
-			log.Printf("secrets.Values: workspace rows iteration error: %v", err)
+			log.Printf("secrets.Values wsRows.Err: %v", err)
 		}
 	}
 
@@ -337,7 +337,7 @@ func (h *SecretsHandler) ListGlobal(c *gin.Context) {
 		})
 	}
 	if err := rows.Err(); err != nil {
-		log.Printf("ListGlobal iteration error: %v", err)
+		log.Printf("ListGlobal rows.Err: %v", err)
 	}
 	c.JSON(http.StatusOK, secrets)
 }
@@ -416,7 +416,7 @@ func (h *SecretsHandler) restartAllAffectedByGlobalKey(key string) {
 		}
 	}
 	if err := rows.Err(); err != nil {
-		log.Printf("restartAllAffectedByGlobalKey: iteration error: %v", err)
+		log.Printf("restartAllAffectedByGlobalKey rows.Err: %v", err)
 	}
 	if len(ids) == 0 {
 		return

workspace-server/internal/handlers/templates.go

@@ -186,16 +186,11 @@ func (h *TemplatesHandler) List(c *gin.Context) {
 			model = raw.RuntimeConfig.Model
 		}
 
-		tier := raw.Tier
-		if h.wh != nil && h.wh.IsSaaS() {
-			tier = h.wh.DefaultTier()
-		}
-
 		templates = append(templates, templateSummary{
 			ID:                      id,
 			Name:                    raw.Name,
 			Description:             raw.Description,
-			Tier:                    tier,
+			Tier:                    raw.Tier,
 			Runtime:                 raw.Runtime,
 			Model:                   model,
 			Models:                  raw.RuntimeConfig.Models,
@@ -345,11 +340,6 @@ func (h *TemplatesHandler) ListFiles(c *gin.Context) {
 		if err != nil || path == walkRoot {
 			return nil
 		}
-		// Skip symlinks to prevent path traversal via malicious symlinks
-		// inside the workspace config directory (OFFSEC-010).
-		if info.Mode()&os.ModeSymlink != 0 {
-			return nil
-		}
 		rel, _ := filepath.Rel(walkRoot, path)
 		// Enforce depth limit
 		if strings.Count(rel, string(filepath.Separator))+1 > depth {

workspace-server/internal/handlers/templates_test.go

@@ -847,58 +847,6 @@ func TestListFiles_FallbackToHost_WithTemplate(t *testing.T) {
 	}
 }
 
-func TestListFiles_FallbackToHost_SkipsSymlinks(t *testing.T) {
-	mock := setupTestDB(t)
-	setupTestRedis(t)
-
-	tmpDir := t.TempDir()
-	tmplDir := filepath.Join(tmpDir, "test-agent")
-	if err := os.MkdirAll(tmplDir, 0755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(tmplDir, "config.yaml"), []byte("name: Test Agent\n"), 0644); err != nil {
-		t.Fatal(err)
-	}
-	secret := filepath.Join(t.TempDir(), "secret.txt")
-	if err := os.WriteFile(secret, []byte("do-not-list"), 0600); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Symlink(secret, filepath.Join(tmplDir, "leaked-secret")); err != nil {
-		t.Fatal(err)
-	}
-
-	handler := NewTemplatesHandler(tmpDir, nil, nil)
-
-	mock.ExpectQuery(`SELECT name, COALESCE\(instance_id, ''\), COALESCE\(runtime, ''\) FROM workspaces WHERE id =`).
-		WithArgs("ws-tmpl").
-		WillReturnRows(sqlmock.NewRows([]string{"name", "instance_id", "runtime"}).AddRow("Test Agent", "", ""))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: "ws-tmpl"}}
-	c.Request = httptest.NewRequest("GET", "/workspaces/ws-tmpl/files", nil)
-
-	handler.ListFiles(c)
-
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-
-	var resp []map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatal(err)
-	}
-	for _, file := range resp {
-		if file["path"] == "leaked-secret" {
-			t.Fatalf("symlink should not be listed: %#v", resp)
-		}
-	}
-
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet sqlmock expectations: %v", err)
-	}
-}
-
 // ==================== GET /workspaces/:id/files/*path ====================
 
 func TestReadFile_PathTraversal(t *testing.T) {
@@ -1252,3 +1200,4 @@ func TestCWE78_DeleteFile_TraversalVariants(t *testing.T) {
 		})
 	}
 }
+

workspace-server/internal/handlers/tokens.go

@@ -67,9 +67,6 @@ func (h *TokenHandler) List(c *gin.Context) {
 		}
 		tokens = append(tokens, t)
 	}
-	if err := rows.Err(); err != nil {
-		log.Printf("ListTokens rows.Err workspace=%s: %v", workspaceID, err)
-	}
 
 	c.JSON(http.StatusOK, gin.H{
 		"tokens": tokens,

workspace-server/internal/handlers/workspace.go

@@ -74,10 +74,7 @@ type WorkspaceHandler struct {
 	// memory plugin). main.go sets this to plugin.DeleteNamespace
 	// when MEMORY_PLUGIN_URL is configured.
 	namespaceCleanupFn func(ctx context.Context, workspaceID string)
-	// asyncWG tracks goroutines launched by goAsync so tests can wait
-	// for async DB users (restart, provision) before asserting results.
-	// Matches the pattern from main commit 1c3b4ff3.
-	asyncWG sync.WaitGroup
+	asyncWG            sync.WaitGroup
 }
 
 func (h *WorkspaceHandler) goAsync(fn func()) {
@@ -164,14 +161,15 @@ func (h *WorkspaceHandler) Create(c *gin.Context) {
 
 	id := uuid.New().String()
 	awarenessNamespace := workspaceAwarenessNamespace(id)
-	if h.IsSaaS() {
-		// SaaS hard gate: every hosted workspace gets its own sibling
-		// EC2 instance, so T4 is the only meaningful runtime boundary.
-		// Do not trust stale clients/templates that still send T1/T2/T3.
-		payload.Tier = 4
-	} else if payload.Tier == 0 {
-		// Self-hosted default remains T3. Lower tiers (T1 sandboxed,
-		// T2 standard) stay explicit opt-ins for low-trust local agents.
+	if payload.Tier == 0 {
+		// SaaS-aware default. SaaS → T4 (full host access; each
+		// workspace runs on its own sibling EC2 so the tier boundary
+		// is a Docker resource limit on the only container present —
+		// no neighbour to protect from). Self-hosted → T3 (read-write
+		// workspace mount + Docker daemon access, most templates'
+		// baseline). Lower tiers (T1 sandboxed, T2 standard) remain
+		// explicit opt-ins for low-trust agents. Matches the canvas
+		// CreateWorkspaceDialog defaults so the API and the UI agree.
 		payload.Tier = h.DefaultTier()
 	}
 
@@ -594,7 +592,7 @@ func scanWorkspaceRow(rows interface {
 	var id, name, role, status, url, sampleError, currentTask, runtime, workspaceDir string
 	var tier, activeTasks, maxConcurrentTasks, uptimeSeconds int
 	var errorRate, x, y float64
-	var collapsed, broadcastEnabled, talkToUserEnabled bool
+	var collapsed bool
 	var parentID *string
 	var agentCard []byte
 	var budgetLimit sql.NullInt64
@@ -603,7 +601,7 @@ func scanWorkspaceRow(rows interface {
 	err := rows.Scan(&id, &name, &role, &tier, &status, &agentCard, &url,
 		&parentID, &activeTasks, &maxConcurrentTasks, &errorRate, &sampleError, &uptimeSeconds,
 		&currentTask, &runtime, &workspaceDir, &x, &y, &collapsed,
-		&budgetLimit, &monthlySpend, &broadcastEnabled, &talkToUserEnabled)
+		&budgetLimit, &monthlySpend)
 	if err != nil {
 		return nil, err
 	}
@@ -627,8 +625,6 @@ func scanWorkspaceRow(rows interface {
 		"x":                    x,
 		"y":                    y,
 		"collapsed":            collapsed,
-		"broadcast_enabled":    broadcastEnabled,
-		"talk_to_user_enabled": talkToUserEnabled,
 	}
 
 	// budget_limit: nil when no limit set, int64 otherwise
@@ -664,8 +660,7 @@ const workspaceListQuery = `
 		   COALESCE(w.current_task, ''), COALESCE(w.runtime, 'langgraph'),
 		   COALESCE(w.workspace_dir, ''),
 		   COALESCE(cl.x, 0), COALESCE(cl.y, 0), COALESCE(cl.collapsed, false),
-		   w.budget_limit, COALESCE(w.monthly_spend, 0),
-		   w.broadcast_enabled, w.talk_to_user_enabled
+		   w.budget_limit, COALESCE(w.monthly_spend, 0)
 	FROM workspaces w
 	LEFT JOIN canvas_layouts cl ON cl.workspace_id = w.id
 	WHERE w.status != 'removed'
@@ -725,8 +720,7 @@ func (h *WorkspaceHandler) Get(c *gin.Context) {
 			   COALESCE(w.current_task, ''), COALESCE(w.runtime, 'langgraph'),
 			   COALESCE(w.workspace_dir, ''),
 			   COALESCE(cl.x, 0), COALESCE(cl.y, 0), COALESCE(cl.collapsed, false),
-			   w.budget_limit, COALESCE(w.monthly_spend, 0),
-			   w.broadcast_enabled, w.talk_to_user_enabled
+			   w.budget_limit, COALESCE(w.monthly_spend, 0)
 		FROM workspaces w
 		LEFT JOIN canvas_layouts cl ON cl.workspace_id = w.id
 		WHERE w.id = $1

workspace-server/internal/handlers/workspace_abilities.go

@@ -1,82 +0,0 @@
-package handlers
-
-// workspace_abilities.go — PATCH /workspaces/:id/abilities
-//
-// Allows users and admin agents to toggle two workspace-level ability flags:
-//
-//   broadcast_enabled   — workspace may POST /broadcast to send org-wide messages
-//   talk_to_user_enabled — workspace may deliver canvas chat messages via
-//                          send_message_to_user / POST /notify
-//
-// Gated behind AdminAuth so workspace agents cannot self-modify their own
-// ability flags (that would let any agent grant itself broadcast rights or
-// suppress its own chat-silence constraint).
-
-import (
-	"log"
-	"net/http"
-
-	"github.com/Molecule-AI/molecule-monorepo/platform/internal/db"
-	"github.com/gin-gonic/gin"
-)
-
-// AbilitiesPayload carries the subset of ability flags the caller wants to
-// update. Fields are pointers so that the handler can distinguish "caller
-// supplied false" from "caller omitted the field" (omitempty semantics).
-type AbilitiesPayload struct {
-	BroadcastEnabled   *bool `json:"broadcast_enabled"`
-	TalkToUserEnabled  *bool `json:"talk_to_user_enabled"`
-}
-
-// PatchAbilities handles PATCH /workspaces/:id/abilities (AdminAuth).
-func PatchAbilities(c *gin.Context) {
-	id := c.Param("id")
-	if err := validateWorkspaceID(id); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid workspace ID"})
-		return
-	}
-
-	var body AbilitiesPayload
-	if err := c.ShouldBindJSON(&body); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request body"})
-		return
-	}
-	if body.BroadcastEnabled == nil && body.TalkToUserEnabled == nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "at least one ability field required"})
-		return
-	}
-
-	ctx := c.Request.Context()
-
-	var exists bool
-	if err := db.DB.QueryRowContext(ctx,
-		`SELECT EXISTS(SELECT 1 FROM workspaces WHERE id = $1 AND status != 'removed')`, id,
-	).Scan(&exists); err != nil || !exists {
-		c.JSON(http.StatusNotFound, gin.H{"error": "workspace not found"})
-		return
-	}
-
-	if body.BroadcastEnabled != nil {
-		if _, err := db.DB.ExecContext(ctx,
-			`UPDATE workspaces SET broadcast_enabled = $2, updated_at = now() WHERE id = $1`,
-			id, *body.BroadcastEnabled,
-		); err != nil {
-			log.Printf("PatchAbilities broadcast_enabled for %s: %v", id, err)
-			c.JSON(http.StatusInternalServerError, gin.H{"error": "update failed"})
-			return
-		}
-	}
-
-	if body.TalkToUserEnabled != nil {
-		if _, err := db.DB.ExecContext(ctx,
-			`UPDATE workspaces SET talk_to_user_enabled = $2, updated_at = now() WHERE id = $1`,
-			id, *body.TalkToUserEnabled,
-		); err != nil {
-			log.Printf("PatchAbilities talk_to_user_enabled for %s: %v", id, err)
-			c.JSON(http.StatusInternalServerError, gin.H{"error": "update failed"})
-			return
-		}
-	}
-
-	c.JSON(http.StatusOK, gin.H{"status": "updated"})
-}

workspace-server/internal/handlers/workspace_broadcast.go

@@ -1,185 +0,0 @@
-package handlers
-
-// workspace_broadcast.go — POST /workspaces/:id/broadcast
-//
-// Allows a workspace with broadcast_enabled=true to send a message to every
-// non-removed agent workspace in the SAME ORG.  The message is:
-//
-//   • Persisted in each recipient's activity_logs (type='broadcast_receive')
-//     so poll-mode agents pick it up via GET /activity.
-//   • Broadcast via WebSocket BROADCAST_MESSAGE event so canvas panels can
-//     show a real-time banner for each recipient workspace.
-//
-// The sender's own workspace logs a 'broadcast_sent' activity row for
-// traceability.
-//
-// Auth: WorkspaceAuth (the agent triggers this with its own bearer token).
-// The handler re-validates broadcast_enabled inside the DB lookup to prevent
-// TOCTOU — the middleware only proved the token is valid, not the ability.
-//
-// Org isolation (OFFSEC-015): recipients are scoped to the sender's org using
-// a recursive CTE that walks the parent_id chain to find the org root. This
-// prevents a compromised or misconfigured workspace from broadcasting to
-// workspaces in other tenants' orgs.
-
-import (
-	"log"
-	"net/http"
-	"strconv"
-
-	"github.com/Molecule-AI/molecule-monorepo/platform/internal/db"
-	"github.com/Molecule-AI/molecule-monorepo/platform/internal/events"
-	"github.com/gin-gonic/gin"
-)
-
-// BroadcastHandler is constructed once and shared across requests.
-type BroadcastHandler struct {
-	broadcaster *events.Broadcaster
-}
-
-// NewBroadcastHandler creates a BroadcastHandler.
-func NewBroadcastHandler(b *events.Broadcaster) *BroadcastHandler {
-	return &BroadcastHandler{broadcaster: b}
-}
-
-// Broadcast handles POST /workspaces/:id/broadcast.
-func (h *BroadcastHandler) Broadcast(c *gin.Context) {
-	senderID := c.Param("id")
-	if err := validateWorkspaceID(senderID); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid workspace ID"})
-		return
-	}
-
-	var body struct {
-		Message string `json:"message" binding:"required"`
-	}
-	if err := c.ShouldBindJSON(&body); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "message is required"})
-		return
-	}
-
-	ctx := c.Request.Context()
-
-	// Verify sender exists and has broadcast_enabled=true.
-	var senderName string
-	var broadcastEnabled bool
-	err := db.DB.QueryRowContext(ctx,
-		`SELECT name, broadcast_enabled FROM workspaces WHERE id = $1 AND status != 'removed'`,
-		senderID,
-	).Scan(&senderName, &broadcastEnabled)
-	if err != nil {
-		c.JSON(http.StatusNotFound, gin.H{"error": "workspace not found"})
-		return
-	}
-	if !broadcastEnabled {
-		c.JSON(http.StatusForbidden, gin.H{
-			"error": "broadcast_disabled",
-			"hint":  "This workspace does not have the broadcast ability. Ask a user or admin to enable it via PATCH /workspaces/:id/abilities.",
-		})
-		return
-	}
-
-	// Find the sender's org root by walking the parent_id chain.
-	// Workspaces with parent_id = NULL are org roots; every other workspace
-	// belongs to the org identified by its topmost ancestor.
-	var orgRootID string
-	err = db.DB.QueryRowContext(ctx, `
-		WITH RECURSIVE org_chain AS (
-			SELECT id, parent_id, id AS root_id
-			FROM workspaces
-			WHERE id = $1
-			UNION ALL
-			SELECT w.id, w.parent_id, c.root_id
-			FROM workspaces w
-			JOIN org_chain c ON w.id = c.parent_id
-		)
-		SELECT root_id FROM org_chain WHERE parent_id IS NULL LIMIT 1
-	`, senderID).Scan(&orgRootID)
-	if err != nil {
-		log.Printf("Broadcast: org root lookup for %s: %v", senderID, err)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "internal error"})
-		return
-	}
-
-	// Collect all non-removed agent workspaces in the SAME ORG (same root_id),
-	// excluding the sender itself.
-	rows, err := db.DB.QueryContext(ctx, `
-		WITH RECURSIVE org_chain AS (
-			SELECT id, parent_id, id AS root_id
-			FROM workspaces
-			WHERE parent_id IS NULL
-			UNION ALL
-			SELECT w.id, w.parent_id, c.root_id
-			FROM workspaces w
-			JOIN org_chain c ON w.parent_id = c.id
-		)
-		SELECT c.id
-		FROM org_chain c
-		WHERE c.root_id = $1
-		  AND c.id != $2
-		  AND EXISTS (
-			  SELECT 1 FROM workspaces w
-			  WHERE w.id = c.id AND w.status != 'removed'
-		  )
-	`, orgRootID, senderID)
-	if err != nil {
-		log.Printf("Broadcast: recipient query failed for %s: %v", senderID, err)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "internal error"})
-		return
-	}
-	defer rows.Close()
-
-	var recipientIDs []string
-	for rows.Next() {
-		var rid string
-		if rows.Scan(&rid) == nil {
-			recipientIDs = append(recipientIDs, rid)
-		}
-	}
-	if err := rows.Err(); err != nil {
-		log.Printf("Broadcast: recipient rows error for %s: %v", senderID, err)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "internal error"})
-		return
-	}
-
-	broadcastPayload := map[string]interface{}{
-		"message":   body.Message,
-		"sender_id": senderID,
-		"sender":    senderName,
-	}
-
-	// Persist broadcast_receive in each recipient's activity log + emit WS event.
-	delivered := 0
-	for _, rid := range recipientIDs {
-		if _, err := db.DB.ExecContext(ctx, `
-			INSERT INTO activity_logs (workspace_id, activity_type, method, source_id, summary, status)
-			VALUES ($1, 'broadcast_receive', 'broadcast', $2, $3, 'ok')
-		`, rid, senderID, "Broadcast from "+senderName+": "+broadcastTruncate(body.Message, 120)); err != nil {
-			log.Printf("Broadcast: activity_logs insert for recipient %s: %v", rid, err)
-			continue
-		}
-		h.broadcaster.BroadcastOnly(rid, "BROADCAST_MESSAGE", broadcastPayload)
-		delivered++
-	}
-
-	// Record the send on the sender's own log.
-	if _, err := db.DB.ExecContext(ctx, `
-		INSERT INTO activity_logs (workspace_id, activity_type, method, summary, status)
-		VALUES ($1, 'broadcast_sent', 'broadcast', $2, 'ok')
-	`, senderID, "Broadcast sent to "+strconv.Itoa(delivered)+" workspace(s)"); err != nil {
-		log.Printf("Broadcast: sender activity_log for %s: %v", senderID, err)
-	}
-
-	c.JSON(http.StatusOK, gin.H{
-		"status":    "sent",
-		"delivered": delivered,
-	})
-}
-
-func broadcastTruncate(s string, max int) string {
-	runes := []rune(s)
-	if len(runes) <= max {
-		return s
-	}
-	return string(runes[:max]) + "…"
-}

workspace-server/internal/handlers/workspace_broadcast_test.go

@@ -1,428 +0,0 @@
-package handlers
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/DATA-DOG/go-sqlmock"
-	"github.com/gin-gonic/gin"
-)
-
-// -------- Org-scoped recipient query tests (OFFSEC-015) --------
-
-// TestBroadcast_OrgScopedRecipients verifies that a broadcast from Org-A does
-// NOT reach workspaces belonging to Org-B. This is the core regression test
-// for OFFSEC-015: the original query had no org filter, so a workspace in
-// Org-A could broadcast to every non-removed workspace in the entire DB,
-// including workspaces owned by other tenants.
-func TestBroadcast_OrgScopedRecipients(t *testing.T) {
-	mock := setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	// Org-A structure:
-	//   org-a-root  (parent_id = NULL)  ← sender
-	//   ├── ws-a-child
-	// Org-B structure:
-	//   org-b-root  (parent_id = NULL)
-	//   └── ws-b-child
-	senderID := "00000000-0000-0000-0000-000000000001" // org-a-root
-	wsAChild := "00000000-0000-0000-0000-000000000002"
-	// ws-b-child is in Org-B (different root); the org-scoped query MUST NOT include it.
-
-	// 1. Sender lookup
-	mock.ExpectQuery(`SELECT name, broadcast_enabled FROM workspaces WHERE id = \$1 AND status != 'removed'`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).AddRow("Org-A Root", true))
-
-	// 2. Org root lookup — sender is its own root (parent_id = NULL)
-	mock.ExpectQuery(`WITH RECURSIVE org_chain AS`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"root_id"}).AddRow(senderID))
-
-	// 3. Org-scoped recipient query — MUST include org filter so ws-b-child is NOT included.
-	// The query joins on org_chain.root_id = orgRootID, which scopes to Org-A only.
-	mock.ExpectQuery(`WITH RECURSIVE org_chain AS`).
-		WithArgs(senderID, senderID). // orgRootID, senderID (EXCLUDED)
-		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(wsAChild)) // only Org-A child
-
-	// Activity log inserts
-	mock.ExpectExec(`INSERT INTO activity_logs`).WithArgs(wsAChild, senderID, sqlmock.AnyArg()).WillReturnResult(sqlmock.NewResult(0, 1))
-	mock.ExpectExec(`INSERT INTO activity_logs`).WithArgs(senderID, sqlmock.AnyArg()).WillReturnResult(sqlmock.NewResult(0, 1))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: senderID}}
-	body := `{"message":"hello from org-a"}`
-	c.Request = httptest.NewRequest("POST", "/workspaces/"+senderID+"/broadcast", bytes.NewBufferString(body))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Broadcast(c)
-
-	if w.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-
-	var resp map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to unmarshal response: %v", err)
-	}
-	if resp["status"] != "sent" {
-		t.Errorf("expected status 'sent', got %v", resp["status"])
-	}
-	// ws-b-child is in a DIFFERENT org — the org-scoped query MUST NOT include it.
-	// If it were included, the mock would have an unmet expectation.
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet mock expectations — cross-org workspace was included in broadcast: %v", err)
-	}
-}
-
-// TestBroadcast_OrgScoped_OrgRootSender verifies that when the sender IS the
-// org root (parent_id = NULL), broadcasts still reach sibling workspaces.
-func TestBroadcast_OrgScoped_OrgRootSender(t *testing.T) {
-	mock := setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	senderID := "00000000-0000-0000-0000-000000000001" // org-a-root
-	siblingID := "00000000-0000-0000-0000-000000000002"
-
-	mock.ExpectQuery(`SELECT name, broadcast_enabled FROM workspaces WHERE id = \$1 AND status != 'removed'`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).AddRow("Root Agent", true))
-
-	// Sender is the org root — CTE returns sender's own ID as root
-	mock.ExpectQuery(`WITH RECURSIVE org_chain AS`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"root_id"}).AddRow(senderID))
-
-	// Recipients in same org, excluding sender
-	mock.ExpectQuery(`WITH RECURSIVE org_chain AS`).
-		WithArgs(senderID, senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(siblingID))
-
-	mock.ExpectExec(`INSERT INTO activity_logs`).WithArgs(siblingID, senderID, sqlmock.AnyArg()).WillReturnResult(sqlmock.NewResult(0, 1))
-	mock.ExpectExec(`INSERT INTO activity_logs`).WithArgs(senderID, sqlmock.AnyArg()).WillReturnResult(sqlmock.NewResult(0, 1))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: senderID}}
-	body := `{"message":"hello siblings"}`
-	c.Request = httptest.NewRequest("POST", "/workspaces/"+senderID+"/broadcast", bytes.NewBufferString(body))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Broadcast(c)
-
-	if w.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-// TestBroadcast_OrgScoped_ChildWorkspaceSender verifies that a non-root child
-// workspace can broadcast to siblings in the same org.
-func TestBroadcast_OrgScoped_ChildWorkspaceSender(t *testing.T) {
-	mock := setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	orgRootID := "00000000-0000-0000-0000-000000000001"
-	senderID := "00000000-0000-0000-0000-000000000002" // child workspace
-	siblingID := "00000000-0000-0000-0000-000000000003"
-
-	mock.ExpectQuery(`SELECT name, broadcast_enabled FROM workspaces WHERE id = \$1 AND status != 'removed'`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).AddRow("Child Agent", true))
-
-	// Org root lookup — walk up to find org-a-root
-	mock.ExpectQuery(`WITH RECURSIVE org_chain AS`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"root_id"}).AddRow(orgRootID))
-
-	// Recipients: same org, excluding sender
-	mock.ExpectQuery(`WITH RECURSIVE org_chain AS`).
-		WithArgs(orgRootID, senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(siblingID))
-
-	mock.ExpectExec(`INSERT INTO activity_logs`).WithArgs(siblingID, senderID, sqlmock.AnyArg()).WillReturnResult(sqlmock.NewResult(0, 1))
-	mock.ExpectExec(`INSERT INTO activity_logs`).WithArgs(senderID, sqlmock.AnyArg()).WillReturnResult(sqlmock.NewResult(0, 1))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: senderID}}
-	body := `{"message":"child broadcasting"}`
-	c.Request = httptest.NewRequest("POST", "/workspaces/"+senderID+"/broadcast", bytes.NewBufferString(body))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Broadcast(c)
-
-	if w.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-// -------- Non-regression cases --------
-
-func TestBroadcast_NotFound(t *testing.T) {
-	mock := setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	senderID := "00000000-0000-0000-0000-000000000099"
-	// UUID is valid, but no workspace row matches
-	mock.ExpectQuery(`SELECT name, broadcast_enabled FROM workspaces WHERE id = \$1 AND status != 'removed'`).
-		WithArgs(senderID).
-		WillReturnError(errors.New("workspace not found"))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: senderID}}
-	body := `{"message":"test"}`
-	c.Request = httptest.NewRequest("POST", "/workspaces/"+senderID+"/broadcast", bytes.NewBufferString(body))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Broadcast(c)
-
-	if w.Code != http.StatusNotFound {
-		t.Errorf("expected 404, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-func TestBroadcast_Disabled(t *testing.T) {
-	mock := setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	senderID := "00000000-0000-0000-0000-000000000001"
-	mock.ExpectQuery(`SELECT name, broadcast_enabled FROM workspaces WHERE id = \$1 AND status != 'removed'`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).AddRow("Disabled Agent", false))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: senderID}}
-	body := `{"message":"should not send"}`
-	c.Request = httptest.NewRequest("POST", "/workspaces/"+senderID+"/broadcast", bytes.NewBufferString(body))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Broadcast(c)
-
-	if w.Code != http.StatusForbidden {
-		t.Errorf("expected 403, got %d: %s", w.Code, w.Body.String())
-	}
-	var resp map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to unmarshal: %v", err)
-	}
-	if resp["error"] != "broadcast_disabled" {
-		t.Errorf("expected error 'broadcast_disabled', got %v", resp["error"])
-	}
-}
-
-func TestBroadcast_EmptyOrg_NoRecipients(t *testing.T) {
-	mock := setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	senderID := "00000000-0000-0000-0000-000000000001" // org root, only workspace in org
-
-	mock.ExpectQuery(`SELECT name, broadcast_enabled FROM workspaces WHERE id = \$1 AND status != 'removed'`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).AddRow("Lone Root", true))
-
-	mock.ExpectQuery(`WITH RECURSIVE org_chain AS`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"root_id"}).AddRow(senderID))
-
-	// No other workspaces in this org
-	mock.ExpectQuery(`WITH RECURSIVE org_chain AS`).
-		WithArgs(senderID, senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"id"}))
-
-	mock.ExpectExec(`INSERT INTO activity_logs`).WithArgs(senderID, sqlmock.AnyArg()).WillReturnResult(sqlmock.NewResult(0, 1))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: senderID}}
-	body := `{"message":"hello org"}`
-	c.Request = httptest.NewRequest("POST", "/workspaces/"+senderID+"/broadcast", bytes.NewBufferString(body))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Broadcast(c)
-
-	if w.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	var resp map[string]interface{}
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("failed to unmarshal: %v", err)
-	}
-	if resp["delivered"] != float64(0) {
-		t.Errorf("expected delivered=0, got %v", resp["delivered"])
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-func TestBroadcast_InvalidWorkspaceID(t *testing.T) {
-	setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: "not-a-uuid"}}
-	body := `{"message":"test"}`
-	c.Request = httptest.NewRequest("POST", "/workspaces/not-a-uuid/broadcast", bytes.NewBufferString(body))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Broadcast(c)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400, got %d: %s", w.Code, w.Body.String())
-	}
-}
-
-func TestBroadcast_MissingMessage(t *testing.T) {
-	setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: "00000000-0000-0000-0000-000000000001"}}
-	c.Request = httptest.NewRequest("POST", "/workspaces/00000000-0000-0000-0000-000000000001/broadcast", bytes.NewBufferString("{}"))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Broadcast(c)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400, got %d: %s", w.Code, w.Body.String())
-	}
-}
-
-// TestBroadcast_OrgRootLookupFails verifies that if the recursive CTE for
-// finding the org root errors, the handler returns 500 instead of proceeding
-// with an un-scoped query that would broadcast to all orgs.
-func TestBroadcast_OrgRootLookupFails(t *testing.T) {
-	mock := setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	senderID := "00000000-0000-0000-0000-000000000001"
-
-	mock.ExpectQuery(`SELECT name, broadcast_enabled FROM workspaces WHERE id = \$1 AND status != 'removed'`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).AddRow("Root Agent", true))
-
-	// Org root CTE fails
-	mock.ExpectQuery(`WITH RECURSIVE org_chain AS`).
-		WithArgs(senderID).
-		WillReturnError(context.DeadlineExceeded)
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: senderID}}
-	body := `{"message":"should not broadcast"}`
-	c.Request = httptest.NewRequest("POST", "/workspaces/"+senderID+"/broadcast", bytes.NewBufferString(body))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Broadcast(c)
-
-	if w.Code != http.StatusInternalServerError {
-		t.Errorf("expected 500, got %d: %s", w.Code, w.Body.String())
-	}
-	// The recipient query MUST NOT be called — it would broadcast cross-org
-	// if the org root lookup failed silently.
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-// TestBroadcast_OrgScoped_SelfBroadcastExcluded verifies that broadcasting
-// from a workspace does not send a broadcast_receive to the sender itself
-// (the sender logs broadcast_sent, not broadcast_receive).
-func TestBroadcast_OrgScoped_SelfBroadcastExcluded(t *testing.T) {
-	mock := setupTestDB(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewBroadcastHandler(broadcaster)
-
-	senderID := "00000000-0000-0000-0000-000000000001"
-	peerID := "00000000-0000-0000-0000-000000000002"
-
-	mock.ExpectQuery(`SELECT name, broadcast_enabled FROM workspaces WHERE id = \$1 AND status != 'removed'`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"name", "broadcast_enabled"}).AddRow("Root Agent", true))
-
-	mock.ExpectQuery(`WITH RECURSIVE org_chain AS`).
-		WithArgs(senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"root_id"}).AddRow(senderID))
-
-	// Recipient query MUST exclude sender via id != senderID
-	mock.ExpectQuery(`WITH RECURSIVE org_chain AS`).
-		WithArgs(senderID, senderID).
-		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(peerID))
-
-	// Peer receives broadcast_receive
-	mock.ExpectExec(`INSERT INTO activity_logs`).WithArgs(peerID, senderID, sqlmock.AnyArg()).WillReturnResult(sqlmock.NewResult(0, 1))
-	// Sender logs broadcast_sent (NOT broadcast_receive)
-	mock.ExpectExec(`INSERT INTO activity_logs`).WithArgs(senderID, sqlmock.AnyArg()).WillReturnResult(sqlmock.NewResult(0, 1))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: senderID}}
-	body := `{"message":"no echo to self"}`
-	c.Request = httptest.NewRequest("POST", "/workspaces/"+senderID+"/broadcast", bytes.NewBufferString(body))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Broadcast(c)
-
-	if w.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet expectations: %v", err)
-	}
-}
-
-// TestBroadcast_Truncate tests that messages are truncated with the Unicode ellipsis
-// TestBroadcast_Truncate tests that messages are truncated with the Unicode ellipsis
-// character (U+2026) when len(msg) > max. The truncated output is max runes + "…",
-// so truncating a 48-char string at max=20 produces 21 characters (20 runes + "…").
-func TestBroadcast_Truncate(t *testing.T) {
-	cases := []struct {
-		msg    string
-		max    int
-		expect string
-	}{
-		{"short", 120, "short"}, // under max — no truncation
-		// exactly120chars (15) + 105 ones = 120 chars; at max=120 → unchanged
-		{"exactly120chars1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 120, "exactly120chars111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111…"},
-		// "this is a longer mes" = 20 runes; + "…" = 21 chars
-		{"this is a longer message that needs truncating", 20, "this is a longer mes…"},
-		// at-max boundary: 20 chars at max=20 → no truncation
-		{"exactly twenty chars", 20, "exactly twenty chars"},
-		// over max: 11 chars at max=10 → 10 + "…" = 11
-		{"hello world!", 10, "hello worl…"},
-	}
-	for _, tc := range cases {
-		result := broadcastTruncate(tc.msg, tc.max)
-		if result != tc.expect {
-			t.Errorf("broadcastTruncate(%q, %d) = %q; want %q", tc.msg, tc.max, result, tc.expect)
-		}
-	}
-}

workspace-server/internal/handlers/workspace_budget_test.go

@@ -33,7 +33,6 @@ var wsColumns = []string{
 	"parent_id", "active_tasks", "max_concurrent_tasks", "last_error_rate", "last_sample_error",
 	"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 	"budget_limit", "monthly_spend",
-	"broadcast_enabled", "talk_to_user_enabled",
 }
 
 // ==================== GET — financial fields stripped from open endpoint ====================
@@ -53,10 +52,8 @@ func TestWorkspaceBudget_Get_NilLimit(t *testing.T) {
 				[]byte(`{}`), "http://localhost:9001",
 				nil, 0, 1, 0.0, "", 0, "", "langgraph", "",
 				0.0, 0.0, false,
-				nil,   // budget_limit NULL
-				0,     // monthly_spend 0
-				false, // broadcast_enabled
-				true)) // talk_to_user_enabled
+				nil, // budget_limit NULL
+				0))  // monthly_spend 0
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -99,8 +96,7 @@ func TestWorkspaceBudget_Get_WithLimit(t *testing.T) {
 				nil, 0, 1, 0.0, "", 0, "", "langgraph", "",
 				0.0, 0.0, false,
 				int64(500),  // budget_limit = $5.00 in DB
-				int64(123),  // monthly_spend = $1.23 in DB
-				false, true)) // broadcast_enabled, talk_to_user_enabled
+				int64(123))) // monthly_spend = $1.23 in DB
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)

workspace-server/internal/handlers/workspace_provision.go

@@ -15,7 +15,6 @@ import (
 	"github.com/Molecule-AI/molecule-monorepo/platform/internal/models"
 	"github.com/Molecule-AI/molecule-monorepo/platform/internal/provisioner"
 	"github.com/Molecule-AI/molecule-monorepo/platform/internal/wsauth"
-	"gopkg.in/yaml.v3"
 )
 
 // logProvisionPanic is the deferred recover at the top of every provision
@@ -473,10 +472,9 @@ func configDirName(workspaceID string) string {
 // runtime means bumping both this list and the Docker image tags.
 // knownRuntimes is populated from manifest.json at service init (see
 // runtime_registry.go). The package init order is:
-//  1. var knownRuntimes = fallbackRuntimes
-//  2. init() calls initKnownRuntimes() which replaces it if
-//     manifest.json is readable.
-//
+//   1. var knownRuntimes = fallbackRuntimes
+//   2. init() calls initKnownRuntimes() which replaces it if
+//      manifest.json is readable.
 // The fallback matters for unit tests that don't mount the manifest.
 //
 // "external" is a first-class runtime that intentionally does NOT
@@ -541,9 +539,6 @@ func (h *WorkspaceHandler) ensureDefaultConfig(workspaceID string, payload model
 		// org_import.go; consolidating prevents silent drift.
 		model = models.DefaultModel(runtime)
 	}
-	if runtime == "claude-code" {
-		model = normalizeClaudeCodeModel(model)
-	}
 
 	// Sanitize name/role/model for YAML safety — always double-quote so
 	// a crafted value with a newline or colon can't terminate the scalar
@@ -559,11 +554,6 @@ func (h *WorkspaceHandler) ensureDefaultConfig(workspaceID string, payload model
 	quoteModel := yamlQuote(model)
 	configYAML := fmt.Sprintf("name: %s\ndescription: %s\nversion: 1.0.0\ntier: %d\nruntime: %s\n",
 		quoteName, quoteRole, payload.Tier, runtime)
-	if runtime == "claude-code" {
-		if providersYAML := h.defaultTemplateProvidersYAML(runtime); providersYAML != "" {
-			configYAML += providersYAML + "\n"
-		}
-	}
 
 	// Model always at top level — config.py reads raw["model"] for all runtimes.
 	configYAML += fmt.Sprintf("model: %s\n", quoteModel)
@@ -573,11 +563,7 @@ func (h *WorkspaceHandler) ensureDefaultConfig(workspaceID string, payload model
 	// and preflight already validates that the env vars are present before
 	// the agent loop starts.  Hardcoding token names here caused #1028
 	// (expired CLAUDE_CODE_OAUTH_TOKEN baked into config.yaml).
-	configYAML += "runtime_config:\n"
-	if runtime == "claude-code" {
-		configYAML += fmt.Sprintf("  model: %s\n", quoteModel)
-	}
-	configYAML += "  timeout: 0\n"
+	configYAML += "runtime_config:\n  timeout: 0\n"
 
 	files["config.yaml"] = []byte(configYAML)
 
@@ -585,60 +571,6 @@ func (h *WorkspaceHandler) ensureDefaultConfig(workspaceID string, payload model
 	return files
 }
 
-func normalizeClaudeCodeModel(model string) string {
-	model = strings.TrimSpace(model)
-	if before, after, ok := strings.Cut(model, "/"); ok && before != "" && after != "" {
-		return after
-	}
-	return model
-}
-
-func (h *WorkspaceHandler) defaultTemplateProvidersYAML(runtime string) string {
-	if h.configsDir == "" {
-		return ""
-	}
-	templateName := runtime + "-default"
-	templatePath, err := resolveInsideRoot(h.configsDir, templateName)
-	if err != nil {
-		log.Printf("Provisioner: default template providers skipped for runtime %s: %v", runtime, err)
-		return ""
-	}
-	data, err := os.ReadFile(filepath.Join(templatePath, "config.yaml"))
-	if err != nil {
-		return ""
-	}
-
-	var root yaml.Node
-	if err := yaml.Unmarshal(data, &root); err != nil {
-		log.Printf("Provisioner: default template providers skipped for runtime %s: invalid YAML: %v", runtime, err)
-		return ""
-	}
-	if len(root.Content) == 0 || root.Content[0].Kind != yaml.MappingNode {
-		return ""
-	}
-
-	mapping := root.Content[0]
-	for i := 0; i+1 < len(mapping.Content); i += 2 {
-		if mapping.Content[i].Value != "providers" {
-			continue
-		}
-		out := yaml.Node{
-			Kind: yaml.MappingNode,
-			Content: []*yaml.Node{
-				{Kind: yaml.ScalarNode, Value: "providers"},
-				mapping.Content[i+1],
-			},
-		}
-		encoded, err := yaml.Marshal(&out)
-		if err != nil {
-			log.Printf("Provisioner: default template providers skipped for runtime %s: marshal failed: %v", runtime, err)
-			return ""
-		}
-		return strings.TrimRight(string(encoded), "\n")
-	}
-	return ""
-}
-
 // deriveProviderFromModelSlug maps a hermes-agent model slug prefix to
 // its provider name — a Go translation of the case statement in
 // workspace-configs-templates/hermes/scripts/derive-provider.sh that we
@@ -873,9 +805,6 @@ func loadWorkspaceSecrets(ctx context.Context, workspaceID string) (map[string]s
 				envVars[k] = string(decrypted)
 			}
 		}
-		if err := globalRows.Err(); err != nil {
-			log.Printf("Provisioner: global_secrets rows.Err workspace=%s: %v", workspaceID, err)
-		}
 	}
 	wsRows, err := db.DB.QueryContext(ctx,
 		`SELECT key, encrypted_value, encryption_version FROM workspace_secrets WHERE workspace_id = $1`, workspaceID)
@@ -894,9 +823,6 @@ func loadWorkspaceSecrets(ctx context.Context, workspaceID string) (map[string]s
 				envVars[k] = string(decrypted)
 			}
 		}
-		if err := wsRows.Err(); err != nil {
-			log.Printf("Provisioner: workspace_secrets rows.Err workspace=%s: %v", workspaceID, err)
-		}
 	}
 	return envVars, ""
 }

workspace-server/internal/handlers/workspace_provision_test.go

@@ -261,67 +261,6 @@ func TestEnsureDefaultConfig_ClaudeCode(t *testing.T) {
 	}
 }
 
-func TestEnsureDefaultConfig_ClaudeCodeCopiesProviderRegistry(t *testing.T) {
-	broadcaster := newTestBroadcaster()
-	configsDir := t.TempDir()
-	templateDir := filepath.Join(configsDir, "claude-code-default")
-	if err := os.MkdirAll(templateDir, 0o755); err != nil {
-		t.Fatalf("mkdir template: %v", err)
-	}
-	if err := os.WriteFile(filepath.Join(templateDir, "config.yaml"), []byte(`
-name: Claude Code Agent
-runtime: claude-code
-providers:
-  - name: anthropic-oauth
-    auth_mode: oauth
-    model_aliases: [sonnet]
-    auth_env: [CLAUDE_CODE_OAUTH_TOKEN]
-  - name: minimax
-    auth_mode: third_party_anthropic_compat
-    model_prefixes: [minimax-]
-    base_url: https://api.minimax.io/anthropic
-    auth_env: [MINIMAX_API_KEY, ANTHROPIC_AUTH_TOKEN]
-runtime_config:
-  model: sonnet
-`), 0o644); err != nil {
-		t.Fatalf("write template: %v", err)
-	}
-	handler := NewWorkspaceHandler(broadcaster, nil, "http://localhost:8080", configsDir)
-
-	files := handler.ensureDefaultConfig("ws-code-123", models.CreateWorkspacePayload{
-		Name:    "Code Agent",
-		Tier:    4,
-		Runtime: "claude-code",
-		Model:   "minimax/MiniMax-M2.7",
-	})
-
-	var parsed struct {
-		Model     string `yaml:"model"`
-		Providers []struct {
-			Name          string   `yaml:"name"`
-			ModelPrefixes []string `yaml:"model_prefixes"`
-		} `yaml:"providers"`
-		RuntimeConfig struct {
-			Model string `yaml:"model"`
-		} `yaml:"runtime_config"`
-	}
-	if err := yaml.Unmarshal(files["config.yaml"], &parsed); err != nil {
-		t.Fatalf("generated YAML invalid: %v\n%s", err, files["config.yaml"])
-	}
-	if parsed.Model != "MiniMax-M2.7" {
-		t.Fatalf("top-level model = %q, want MiniMax-M2.7\n%s", parsed.Model, files["config.yaml"])
-	}
-	if parsed.RuntimeConfig.Model != "MiniMax-M2.7" {
-		t.Fatalf("runtime_config.model = %q, want MiniMax-M2.7\n%s", parsed.RuntimeConfig.Model, files["config.yaml"])
-	}
-	if len(parsed.Providers) != 2 {
-		t.Fatalf("providers len = %d, want 2\n%s", len(parsed.Providers), files["config.yaml"])
-	}
-	if parsed.Providers[1].Name != "minimax" || len(parsed.Providers[1].ModelPrefixes) != 1 || parsed.Providers[1].ModelPrefixes[0] != "minimax-" {
-		t.Fatalf("minimax provider registry not preserved: %+v\n%s", parsed.Providers, files["config.yaml"])
-	}
-}
-
 func TestEnsureDefaultConfig_CustomModel(t *testing.T) {
 	broadcaster := newTestBroadcaster()
 	handler := NewWorkspaceHandler(broadcaster, nil, "http://localhost:8080", t.TempDir())

workspace-server/internal/handlers/workspace_test.go

@@ -29,7 +29,6 @@ func TestWorkspaceGet_Success(t *testing.T) {
 		"parent_id", "active_tasks", "max_concurrent_tasks", "last_error_rate", "last_sample_error",
 		"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 		"budget_limit", "monthly_spend",
-		"broadcast_enabled", "talk_to_user_enabled",
 	}
 	mock.ExpectQuery("SELECT w.id, w.name").
 		WithArgs("cccccccc-0001-0000-0000-000000000000").
@@ -37,7 +36,7 @@ func TestWorkspaceGet_Success(t *testing.T) {
 			AddRow("cccccccc-0001-0000-0000-000000000000", "My Agent", "worker", 1, "online", []byte(`{"name":"test"}`),
 				"http://localhost:8001", nil, 2, 1, 0.05, "", 3600, "working", "langgraph",
 				"", 10.0, 20.0, false,
-				nil, 0, false, true))
+				nil, 0))
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -119,7 +118,6 @@ func TestWorkspaceGet_RemovedReturns410(t *testing.T) {
 		"parent_id", "active_tasks", "max_concurrent_tasks", "last_error_rate", "last_sample_error",
 		"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 		"budget_limit", "monthly_spend",
-		"broadcast_enabled", "talk_to_user_enabled",
 	}
 	mock.ExpectQuery("SELECT w.id, w.name").
 		WithArgs(id).
@@ -127,7 +125,7 @@ func TestWorkspaceGet_RemovedReturns410(t *testing.T) {
 			AddRow(id, "Old Agent", "worker", 1, string(models.StatusRemoved), []byte(`null`),
 				"", nil, 0, 1, 0.0, "", 0, "", "langgraph",
 				"", 0.0, 0.0, false,
-				nil, 0, false, true))
+				nil, 0))
 	mock.ExpectQuery(`SELECT updated_at FROM workspaces`).
 		WithArgs(id).
 		WillReturnRows(sqlmock.NewRows([]string{"updated_at"}).AddRow(removedAt))
@@ -183,7 +181,6 @@ func TestWorkspaceGet_RemovedReturns410WithNullRemovedAtOnTimestampFetchFailure(
 		"parent_id", "active_tasks", "max_concurrent_tasks", "last_error_rate", "last_sample_error",
 		"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 		"budget_limit", "monthly_spend",
-		"broadcast_enabled", "talk_to_user_enabled",
 	}
 	mock.ExpectQuery("SELECT w.id, w.name").
 		WithArgs(id).
@@ -191,7 +188,7 @@ func TestWorkspaceGet_RemovedReturns410WithNullRemovedAtOnTimestampFetchFailure(
 			AddRow(id, "Vanished", "worker", 1, string(models.StatusRemoved), []byte(`null`),
 				"", nil, 0, 1, 0.0, "", 0, "", "langgraph",
 				"", 0.0, 0.0, false,
-				nil, 0, false, true))
+				nil, 0))
 	// Simulate the row vanishing between the two queries.
 	mock.ExpectQuery(`SELECT updated_at FROM workspaces`).
 		WithArgs(id).
@@ -246,7 +243,6 @@ func TestWorkspaceGet_RemovedWithIncludeQueryReturns200(t *testing.T) {
 		"parent_id", "active_tasks", "max_concurrent_tasks", "last_error_rate", "last_sample_error",
 		"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 		"budget_limit", "monthly_spend",
-		"broadcast_enabled", "talk_to_user_enabled",
 	}
 	mock.ExpectQuery("SELECT w.id, w.name").
 		WithArgs(id).
@@ -254,7 +250,7 @@ func TestWorkspaceGet_RemovedWithIncludeQueryReturns200(t *testing.T) {
 			AddRow(id, "Audit Agent", "worker", 1, string(models.StatusRemoved), []byte(`null`),
 				"", nil, 0, 1, 0.0, "", 0, "", "langgraph",
 				"", 0.0, 0.0, false,
-				nil, 0, false, true))
+				nil, 0))
 	// last_outbound_at follow-up query (existing path)
 	mock.ExpectQuery(`SELECT last_outbound_at FROM workspaces`).
 		WithArgs(id).
@@ -414,44 +410,6 @@ func TestWorkspaceCreate_DefaultsApplied(t *testing.T) {
 	}
 }
 
-func TestWorkspaceCreate_SaaSHardForcesTier4(t *testing.T) {
-	mock := setupTestDB(t)
-	setupTestRedis(t)
-	broadcaster := newTestBroadcaster()
-	handler := NewWorkspaceHandler(broadcaster, nil, "http://localhost:8080", t.TempDir())
-	handler.SetCPProvisioner(&trackingCPProv{})
-
-	mock.ExpectBegin()
-	mock.ExpectExec("INSERT INTO workspaces").
-		WithArgs(sqlmock.AnyArg(), "SaaS External Agent", nil, 4, "external", sqlmock.AnyArg(), (*string)(nil), nil, "none", (*int64)(nil), models.DefaultMaxConcurrentTasks, "push").
-		WillReturnResult(sqlmock.NewResult(0, 1))
-	mock.ExpectCommit()
-	mock.ExpectExec("INSERT INTO canvas_layouts").
-		WithArgs(sqlmock.AnyArg(), float64(0), float64(0)).
-		WillReturnResult(sqlmock.NewResult(0, 1))
-	mock.ExpectExec("INSERT INTO structure_events").
-		WillReturnResult(sqlmock.NewResult(0, 1))
-	mock.ExpectExec("UPDATE workspaces SET url").
-		WillReturnResult(sqlmock.NewResult(0, 1))
-	mock.ExpectExec("INSERT INTO structure_events").
-		WillReturnResult(sqlmock.NewResult(0, 1))
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	body := `{"name":"SaaS External Agent","runtime":"external","external":true,"url":"https://example.com/agent","tier":2}`
-	c.Request = httptest.NewRequest("POST", "/workspaces", bytes.NewBufferString(body))
-	c.Request.Header.Set("Content-Type", "application/json")
-
-	handler.Create(c)
-
-	if w.Code != http.StatusCreated {
-		t.Errorf("expected status 201, got %d: %s", w.Code, w.Body.String())
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet sqlmock expectations: %v", err)
-	}
-}
-
 // TestWorkspaceCreate_WithSecrets_Persists asserts that secrets in the create
 // payload are written to workspace_secrets inside the same transaction as the
 // workspace row, and that the handler returns 201.
@@ -718,7 +676,6 @@ func TestWorkspaceList_Empty(t *testing.T) {
 			"parent_id", "active_tasks", "last_error_rate", "last_sample_error",
 			"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 			"budget_limit", "monthly_spend",
-		"broadcast_enabled", "talk_to_user_enabled",
 		}))
 
 	w := httptest.NewRecorder()
@@ -1422,7 +1379,6 @@ func TestWorkspaceGet_FinancialFieldsStripped(t *testing.T) {
 		"parent_id", "active_tasks", "max_concurrent_tasks", "last_error_rate", "last_sample_error",
 		"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 		"budget_limit", "monthly_spend",
-		"broadcast_enabled", "talk_to_user_enabled",
 	}
 	// Populate with non-zero financial values to confirm they are stripped.
 	mock.ExpectQuery("SELECT w.id, w.name").
@@ -1431,7 +1387,7 @@ func TestWorkspaceGet_FinancialFieldsStripped(t *testing.T) {
 			AddRow("cccccccc-0010-0000-0000-000000000000", "Finance Test", "worker", 1, "online", []byte(`{}`),
 				"http://localhost:9001", nil, 0, 1, 0.0, "", 0, "", "langgraph",
 				"", 0.0, 0.0, false,
-				int64(50000), int64(12500), false, true)) // budget_limit=500 USD, spend=125 USD
+				int64(50000), int64(12500))) // budget_limit=500 USD, spend=125 USD
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -1479,7 +1435,6 @@ func TestWorkspaceGet_SensitiveFieldsStripped(t *testing.T) {
 		"parent_id", "active_tasks", "max_concurrent_tasks", "last_error_rate", "last_sample_error",
 		"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 		"budget_limit", "monthly_spend",
-		"broadcast_enabled", "talk_to_user_enabled",
 	}
 	mock.ExpectQuery("SELECT w.id, w.name").
 		WithArgs("cccccccc-0955-0000-0000-000000000000").
@@ -1492,7 +1447,7 @@ func TestWorkspaceGet_SensitiveFieldsStripped(t *testing.T) {
 				"langgraph",
 				"/home/user/secret-projects/client-work",
 				0.0, 0.0, false,
-				nil, 0, false, true))
+				nil, 0))
 
 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)

workspace-server/internal/models/runtime_defaults.go

@@ -23,8 +23,8 @@ package models
 //   - claude-code: "sonnet" — Anthropic's CLI accepts the short
 //     name and resolves it via the operator's anthropic-oauth or
 //     ANTHROPIC_API_KEY chain.
-//   - everything else (hermes, langgraph, autogen, codex, openclaw,
-//     external, ""): a fully-qualified
+//   - everything else (hermes, langgraph, crewai, autogen, deepagents,
+//     codex, openclaw, gemini-cli, external, ""): a fully-qualified
 //     vendor:model slug that the universal MODEL_PROVIDER chain in
 //     molecule-core PR #247 can route via per-vendor required_env.
 //

workspace-server/internal/models/runtime_defaults_test.go

@@ -21,9 +21,12 @@ func TestDefaultModel(t *testing.T) {
 		// as a generic "unknown" failure.
 		{"hermes", "anthropic:claude-opus-4-7"},
 		{"langgraph", "anthropic:claude-opus-4-7"},
+		{"crewai", "anthropic:claude-opus-4-7"},
 		{"autogen", "anthropic:claude-opus-4-7"},
+		{"deepagents", "anthropic:claude-opus-4-7"},
 		{"codex", "anthropic:claude-opus-4-7"},
 		{"openclaw", "anthropic:claude-opus-4-7"},
+		{"gemini-cli", "anthropic:claude-opus-4-7"},
 		{"external", "anthropic:claude-opus-4-7"},
 
 		// Unknown / empty — fall through to universal default rather

workspace-server/internal/models/workspace.go

@@ -36,15 +36,6 @@ type Workspace struct {
 	// to activity_logs, agent reads via GET /activity?since_id=). See
 	// migration 045 + RFC #2339.
 	DeliveryMode       string          `json:"delivery_mode" db:"delivery_mode"`
-	// BroadcastEnabled: when true the workspace may call POST /broadcast to
-	// deliver a message to all non-removed agent workspaces in the org.
-	// Default false — only privileged orchestrators should hold this ability.
-	BroadcastEnabled   bool            `json:"broadcast_enabled" db:"broadcast_enabled"`
-	// TalkToUserEnabled: when false the workspace's send_message_to_user calls
-	// and POST /notify requests are rejected with HTTP 403 so the agent is
-	// forced to route updates through a parent workspace. Default true
-	// (preserves existing behaviour for all workspaces).
-	TalkToUserEnabled  bool            `json:"talk_to_user_enabled" db:"talk_to_user_enabled"`
 	// Canvas layout fields (from JOIN)
 	X         float64 `json:"x"`
 	Y         float64 `json:"y"`

workspace-server/internal/provisioner/cp_provisioner.go

@@ -4,14 +4,12 @@ import (
 	"bytes"
 	"context"
 	"database/sql"
-	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"io"
 	"log"
 	"net/http"
 	"os"
-	"path/filepath"
 	"strings"
 	"time"
 
@@ -158,11 +156,6 @@ type cpProvisionRequest struct {
 	Tier        int               `json:"tier"`
 	PlatformURL string            `json:"platform_url"`
 	Env         map[string]string `json:"env"`
-	// ConfigFiles are template + generated config files to write into the
-	// EC2 instance's /configs directory. OFFSEC-010: collected by
-	// collectCPConfigFiles which rejects symlinks and non-regular files
-	// before including them. Serialised as base64 to avoid JSON escaping.
-	ConfigFiles map[string]string `json:"config_files,omitempty"`
 }
 
 type cpProvisionResponse struct {
@@ -186,16 +179,6 @@ func (p *CPProvisioner) Start(ctx context.Context, cfg WorkspaceConfig) (string,
 		}
 		env["ADMIN_TOKEN"] = p.adminToken
 	}
-	// Collect template files and generated configs, with OFFSEC-010 guards:
-	// - Rejects symlinks at the template root (prevents bypass via symlink traversal)
-	// - Skips symlinks during WalkDir (prevents /etc/passwd etc. inclusion)
-	// - Validates all paths are relative and non-escaping
-	// - Caps total size at 12 KiB to prevent payload bloat
-	configFiles, err := collectCPConfigFiles(cfg)
-	if err != nil {
-		return "", fmt.Errorf("cp provisioner: collect config files: %w", err)
-	}
-
 	req := cpProvisionRequest{
 		OrgID:       p.orgID,
 		WorkspaceID: cfg.WorkspaceID,
@@ -203,7 +186,6 @@ func (p *CPProvisioner) Start(ctx context.Context, cfg WorkspaceConfig) (string,
 		Tier:        cfg.Tier,
 		PlatformURL: cfg.PlatformURL,
 		Env:         env,
-		ConfigFiles: configFiles,
 	}
 
 	body, err := json.Marshal(req)
@@ -255,95 +237,6 @@ func (p *CPProvisioner) Start(ctx context.Context, cfg WorkspaceConfig) (string,
 	return result.InstanceID, nil
 }
 
-const cpConfigFilesMaxBytes = 12 << 10
-
-// isCPTemplateConfigFile restricts which files from a template directory are
-// eligible for transport to the control plane. Only config.yaml (the runtime
-// entrypoint config) and files under prompts/ (system prompts) are needed;
-// shipping arbitrary files (e.g. adapter.py, Dockerfile) is both unnecessary
-// and a potential data-exfiltration surface.
-func isCPTemplateConfigFile(name string) bool {
-	name = filepath.ToSlash(filepath.Clean(name))
-	return name == "config.yaml" || strings.HasPrefix(name, "prompts/")
-}
-
-func collectCPConfigFiles(cfg WorkspaceConfig) (map[string]string, error) {
-	files := make(map[string]string)
-	total := 0
-	addFile := func(name string, data []byte) error {
-		name = filepath.ToSlash(filepath.Clean(name))
-		if name == "." || strings.HasPrefix(name, "../") || strings.HasPrefix(name, "/") || strings.Contains(name, "/../") {
-			return fmt.Errorf("invalid config file path %q", name)
-		}
-		total += len(data)
-		if total > cpConfigFilesMaxBytes {
-			return fmt.Errorf("config files exceed %d bytes", cpConfigFilesMaxBytes)
-		}
-		files[name] = base64.StdEncoding.EncodeToString(data)
-		return nil
-	}
-
-	if cfg.TemplatePath != "" {
-		// Reject symlinks on the root itself — WalkDir follows symlinks,
-		// so a symlink TemplatePath that escapes the intended root directory
-		// would bypass the subsequent path-relativization checks below.
-		rootInfo, err := os.Lstat(cfg.TemplatePath)
-		if err != nil {
-			return nil, fmt.Errorf("collectCPConfigFiles: lstat template path: %w", err)
-		}
-		if rootInfo.Mode()&os.ModeSymlink != 0 {
-			return nil, fmt.Errorf("collectCPConfigFiles: template path must not be a symlink")
-		}
-		err = filepath.WalkDir(cfg.TemplatePath, func(path string, d os.DirEntry, walkErr error) error {
-			if walkErr != nil {
-				return walkErr
-			}
-			// Skip symlinks — WalkDir follows them by default, which means
-			// a symlink inside the template dir pointing to /etc/passwd
-			// would be traversed even though the resulting relative-path
-			// check would correctly reject it. Defense-in-depth: don't
-			// follow symlinks at all. (OFFSEC-010)
-			if d.Type()&os.ModeSymlink != 0 {
-				return nil
-			}
-			if d.IsDir() {
-				return nil
-			}
-			info, err := d.Info()
-			if err != nil {
-				return err
-			}
-			if !info.Mode().IsRegular() {
-				return nil
-			}
-			rel, err := filepath.Rel(cfg.TemplatePath, path)
-			if err != nil {
-				return err
-			}
-			if !isCPTemplateConfigFile(rel) {
-				return nil
-			}
-			data, err := os.ReadFile(path)
-			if err != nil {
-				return err
-			}
-			return addFile(rel, data)
-		})
-		if err != nil {
-			return nil, err
-		}
-	}
-	for name, data := range cfg.ConfigFiles {
-		if err := addFile(name, data); err != nil {
-			return nil, err
-		}
-	}
-	if len(files) == 0 {
-		return nil, nil
-	}
-	return files, nil
-}
-
 // Stop terminates the workspace's EC2 instance via the control plane.
 //
 // Looks up the actual EC2 instance_id from the workspaces table before
@@ -498,9 +391,7 @@ func (p *CPProvisioner) IsRunning(ctx context.Context, workspaceID string) (bool
 		// Don't leak the body — upstream errors may echo headers.
 		return true, fmt.Errorf("cp provisioner: status: unexpected %d", resp.StatusCode)
 	}
-	var result struct {
-		State string `json:"state"`
-	}
+	var result struct{ State string `json:"state"` }
 	// Cap body read at 64 KiB for parity with Start — a misconfigured
 	// or compromised CP streaming a huge body could otherwise exhaust
 	// memory in this hot path (called reactively per-request from

workspace-server/internal/provisioner/cp_provisioner_test.go

@@ -1,15 +1,11 @@
 package provisioner
 
 import (
-	"bytes"
 	"context"
-	"encoding/base64"
 	"encoding/json"
 	"io"
 	"net/http"
 	"net/http/httptest"
-	"os"
-	"path/filepath"
 	"strings"
 	"testing"
 	"time"
@@ -217,59 +213,6 @@ func TestStart_HappyPath(t *testing.T) {
 	}
 }
 
-func TestStart_SendsTemplateAndGeneratedConfigFiles(t *testing.T) {
-	tmpl := t.TempDir()
-	if err := os.WriteFile(filepath.Join(tmpl, "config.yaml"), []byte("name: template\n"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(tmpl, "adapter.py"), bytes.Repeat([]byte("x"), cpConfigFilesMaxBytes), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Mkdir(filepath.Join(tmpl, "prompts"), 0o700); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(tmpl, "prompts", "system.md"), []byte("hello"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-
-	var body cpProvisionRequest
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-			t.Errorf("decode request: %v", err)
-		}
-		w.WriteHeader(http.StatusCreated)
-		_, _ = io.WriteString(w, `{"instance_id":"i-abc123","state":"pending"}`)
-	}))
-	defer srv.Close()
-
-	p := &CPProvisioner{baseURL: srv.URL, orgID: "org-1", httpClient: srv.Client()}
-	_, err := p.Start(context.Background(), WorkspaceConfig{
-		WorkspaceID:  "ws-1",
-		Runtime:      "claude-code",
-		Tier:         4,
-		PlatformURL:  "http://tenant",
-		TemplatePath: tmpl,
-		ConfigFiles: map[string][]byte{
-			"config.yaml": []byte("name: generated\n"),
-		},
-	})
-	if err != nil {
-		t.Fatalf("Start: %v", err)
-	}
-
-	wantConfig := base64.StdEncoding.EncodeToString([]byte("name: generated\n"))
-	if got := body.ConfigFiles["config.yaml"]; got != wantConfig {
-		t.Errorf("config.yaml payload = %q, want generated override %q", got, wantConfig)
-	}
-	wantPrompt := base64.StdEncoding.EncodeToString([]byte("hello"))
-	if got := body.ConfigFiles["prompts/system.md"]; got != wantPrompt {
-		t.Errorf("prompt payload = %q, want %q", got, wantPrompt)
-	}
-	if _, ok := body.ConfigFiles["adapter.py"]; ok {
-		t.Error("non-config template file adapter.py must not be sent to CP")
-	}
-}
-
 // TestStart_Non201ReturnsStructuredError — when CP returns 401 with a
 // structured {"error":"..."} body, Start surfaces that error message.
 // Verifies the defense against log-leaking raw upstream bodies.
@@ -336,105 +279,6 @@ func TestStart_TransportFailureSurfaces(t *testing.T) {
 	}
 }
 
-// TestStart_CollectsConfigFiles — verify that collectCPConfigFiles is called and
-// its result is included in the cpProvisionRequest sent to the control plane.
-// Tests the OFFSEC-010 wiring: the function's symlink guards are only effective
-// if the call site actually invokes it.
-func TestStart_CollectsConfigFiles(t *testing.T) {
-	tmpl := t.TempDir()
-	if err := os.WriteFile(filepath.Join(tmpl, "config.yaml"), []byte("name: test\n"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	// adapter.py is within the size limit but is NOT config.yaml or prompts/,
-	// so isCPTemplateConfigFile must exclude it from the transport.
-	if err := os.WriteFile(filepath.Join(tmpl, "adapter.py"), bytes.Repeat([]byte("x"), cpConfigFilesMaxBytes), 0o600); err != nil {
-		t.Fatal(err)
-	}
-
-	var gotBody cpProvisionRequest
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_ = json.NewDecoder(r.Body).Decode(&gotBody)
-		w.WriteHeader(http.StatusCreated)
-		_, _ = io.WriteString(w, `{"instance_id":"i-abc123","state":"pending"}`)
-	}))
-	defer srv.Close()
-
-	p := &CPProvisioner{baseURL: srv.URL, orgID: "org-1", httpClient: srv.Client()}
-	_, err := p.Start(context.Background(), WorkspaceConfig{
-		WorkspaceID:  "ws-1",
-		Runtime:     "python",
-		Tier:         1,
-		PlatformURL:  "http://tenant",
-		TemplatePath: tmpl,
-		ConfigFiles:  map[string][]byte{"generated.json": []byte(`{"key":"value"}`)},
-	})
-	if err != nil {
-		t.Fatalf("Start: %v", err)
-	}
-
-	// config.yaml from TemplatePath must be base64-encoded in ConfigFiles
-	if len(gotBody.ConfigFiles) == 0 {
-		t.Fatal("ConfigFiles is empty: collectCPConfigFiles was not called")
-	}
-
-	// Find config.yaml entry and verify it's valid base64 + correct content
-	var foundTemplate, foundGenerated bool
-	for name, encoded := range gotBody.ConfigFiles {
-		decoded, err := base64.StdEncoding.DecodeString(encoded)
-		if err != nil {
-			t.Errorf("ConfigFiles[%q] is not valid base64: %v", name, err)
-			continue
-		}
-		if name == "config.yaml" && string(decoded) == "name: test\n" {
-			foundTemplate = true
-		}
-		if name == "generated.json" && string(decoded) == `{"key":"value"}` {
-			foundGenerated = true
-		}
-	}
-	if !foundTemplate {
-		t.Errorf("ConfigFiles missing config.yaml from TemplatePath")
-	}
-	if !foundGenerated {
-		t.Errorf("ConfigFiles missing generated.json from ConfigFiles")
-	}
-	// adapter.py must NOT be in ConfigFiles — isCPTemplateConfigFile filters it out
-	for name := range gotBody.ConfigFiles {
-		if name == "adapter.py" {
-			t.Errorf("adapter.py should not be in ConfigFiles — isCPTemplateConfigFile must filter it out")
-		}
-	}
-}
-
-// TestStart_SymlinkTemplatePathError — a symlink TemplatePath should cause
-// collectCPConfigFiles to return an error, which Start must propagate.
-// Without this wiring, OFFSEC-010's root-symlink guard is dead code.
-func TestStart_SymlinkTemplatePathError(t *testing.T) {
-	// Create a temp file and a symlink pointing to it
-	tmp := t.TempDir()
-	realFile := filepath.Join(tmp, "real")
-	if err := os.WriteFile(realFile, []byte("data"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	symlink := filepath.Join(tmp, "template_link")
-	if err := os.Symlink(realFile, symlink); err != nil {
-		t.Fatal(err)
-	}
-
-	p := &CPProvisioner{baseURL: "http://unused", orgID: "org-1", httpClient: &http.Client{Timeout: time.Second}}
-	_, err := p.Start(context.Background(), WorkspaceConfig{
-		WorkspaceID:  "ws-1",
-		Runtime:     "python",
-		TemplatePath: symlink, // symlink root → OFFSEC-010 guard should fire
-	})
-	if err == nil {
-		t.Fatal("expected error for symlink TemplatePath, got nil")
-	}
-	if !strings.Contains(err.Error(), "symlink") {
-		t.Errorf("error should mention symlink, got %q", err.Error())
-	}
-}
-
 // TestStop_SendsBothAuthHeaders — verify #118/#130 compliance on the
 // teardown path. Any call to /cp/workspaces/:id must carry both the
 // platform-wide shared secret AND the per-tenant admin token, or the
@@ -572,9 +416,9 @@ func TestStop_4xxResponseSurfacesError(t *testing.T) {
 func TestStop_2xxVariantsAllSucceed(t *testing.T) {
 	primeInstanceIDLookup(t, map[string]string{"ws-1": "i-ok"})
 	for _, code := range []int{
-		http.StatusOK,        // 200
-		http.StatusAccepted,  // 202
-		http.StatusNoContent, // 204
+		http.StatusOK,           // 200
+		http.StatusAccepted,     // 202
+		http.StatusNoContent,    // 204
 	} {
 		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
 			w.WriteHeader(code)
@@ -642,11 +486,11 @@ func TestIsRunning_ParsesStateField(t *testing.T) {
 			_, _ = io.WriteString(w, `{"state":"`+state+`"}`)
 		}))
 		p := &CPProvisioner{
-			baseURL:      srv.URL,
-			orgID:        "org-1",
+			baseURL:    srv.URL,
+			orgID:      "org-1",
 			sharedSecret: "s3cret",
 			adminToken:   "tok-xyz",
-			httpClient:   srv.Client(),
+			httpClient: srv.Client(),
 		}
 		got, err := p.IsRunning(context.Background(), "ws-1")
 		srv.Close()
@@ -998,67 +842,3 @@ func TestIsRunning_EmptyInstanceIDReturnsFalse(t *testing.T) {
 		t.Errorf("IsRunning with empty instance_id should return running=false, got true")
 	}
 }
-
-// TestCollectCPConfigFiles_SkipsSymlinks — WalkDir follows symlinks by default,
-// but collectCPConfigFiles must skip them so a symlink inside a template dir
-// pointing outside (e.g. ln -s /etc snapshot) cannot be traversed.
-// Verifies OFFSEC-010 defense-in-depth fix. (OFFSEC-010)
-func TestCollectCPConfigFiles_SkipsSymlinks(t *testing.T) {
-	tmpl := t.TempDir()
-	// Write a real file that should be included.
-	if err := os.WriteFile(filepath.Join(tmpl, "config.yaml"), []byte("name: real\n"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	// Create a subdir with a file that will be symlinked-outside.
-	sensitiveDir := t.TempDir()
-	if err := os.WriteFile(filepath.Join(sensitiveDir, "secret.txt"), []byte("SENSITIVE\n"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	// Symlink inside template dir pointing to outside path.
-	symlinkPath := filepath.Join(tmpl, "snapshot")
-	if err := os.Symlink(sensitiveDir, symlinkPath); err != nil {
-		t.Fatal(err)
-	}
-
-	files, err := collectCPConfigFiles(WorkspaceConfig{TemplatePath: tmpl})
-	if err != nil {
-		t.Fatalf("collectCPConfigFiles: %v", err)
-	}
-	if files == nil {
-		t.Fatal("files should not be nil")
-	}
-	// config.yaml must be present.
-	if _, ok := files["config.yaml"]; !ok {
-		t.Errorf("config.yaml missing from files")
-	}
-	// The symlinked path must NOT be included (even though WalkDir would
-	// traverse it, the d.Type()&os.ModeSymlink guard skips the entry).
-	for k := range files {
-		if strings.Contains(k, "snapshot") || strings.Contains(k, "secret") {
-			t.Errorf("symlink path %q should not be in files — OFFSEC-010 regression", k)
-		}
-	}
-}
-
-// TestCollectCPConfigFiles_RejectsRootSymlink — if cfg.TemplatePath itself is
-// a symlink, WalkDir would follow it to an arbitrary directory, bypassing the
-// cfg.TemplatePath boundary. The function must reject this case explicitly.
-// (OFFSEC-010)
-func TestCollectCPConfigFiles_RejectsRootSymlink(t *testing.T) {
-	real := t.TempDir()
-	if err := os.WriteFile(filepath.Join(real, "config.yaml"), []byte("name: real\n"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	link := filepath.Join(t.TempDir(), "template-link")
-	if err := os.Symlink(real, link); err != nil {
-		t.Fatal(err)
-	}
-
-	_, err := collectCPConfigFiles(WorkspaceConfig{TemplatePath: link})
-	if err == nil {
-		t.Error("collectCPConfigFiles with symlink TemplatePath should return error")
-	}
-	if err != nil && !strings.Contains(err.Error(), "symlink") {
-		t.Errorf("expected symlink-related error, got: %v", err)
-	}
-}

workspace-server/internal/provisioner/localbuild_test.go

@@ -190,7 +190,7 @@ func TestEnsureLocalImage_RepoNotFound(t *testing.T) {
 	opts.HTTPClient = srv.Client()
 	opts.remoteHeadSha = nil // exercise real HTTP path
 
-	_, err := ensureLocalImageWithOpts(context.Background(), "hermes", opts)
+	_, err := ensureLocalImageWithOpts(context.Background(), "crewai", opts)
 	if err == nil {
 		t.Fatalf("expected error, got nil")
 	}

workspace-server/internal/provisioner/provisioner.go

@@ -35,19 +35,6 @@ import (
 // drift-risk #6.
 var ErrNoBackend = errors.New("provisioner: no backend configured (zero-valued receiver)")
 
-// ErrUnresolvableRuntime is returned by selectImage when a workspace
-// names a runtime that has no resolvable image (not in RuntimeImages and
-// no operator-pinned cfg.Image). RFC internal#483 + security review 4269:
-// previously such a request silently fell through to DefaultImage
-// (langgraph) — a user asking for crewai would get a langgraph container
-// with no signal. The CTO standing directive
-// (feedback_platform_must_hardgate_base_contract) is fail-closed: a
-// named-but-unresolvable runtime must reject with a structured,
-// runtime-naming error so the existing provision-failed notify/log path
-// surfaces it, NOT silently degrade. The genuinely-unspecified (empty)
-// runtime is still a distinct, legitimate path that keeps DefaultImage.
-var ErrUnresolvableRuntime = errors.New("provisioner: requested runtime has no resolvable image")
-
 // RuntimeImages maps runtime names to their Docker image refs.
 // Each standalone template repo publishes its image via the reusable
 // publish-template-image workflow in molecule-ci on every main merge.
@@ -117,33 +104,20 @@ type WorkspaceConfig struct {
 // selectImage resolves the final Docker image ref for a workspace. The handler
 // layer is the source of truth — if it set cfg.Image (the digest-pinned form
 // from runtime_image_pins, #2272), honor that. Otherwise fall back to the
-// runtime→tag lookup in RuntimeImages (legacy `:latest` behavior).
-//
-// Fail-closed contract (RFC internal#483 / security review 4269 /
-// feedback_platform_must_hardgate_base_contract): if the workspace NAMES a
-// runtime that resolves to no image (not in RuntimeImages, no pinned
-// cfg.Image), reject with ErrUnresolvableRuntime instead of silently
-// substituting DefaultImage. Pre-fix, removing crewai/deepagents/gemini-cli
-// from the catalog left those create requests silently provisioning a
-// langgraph container — the user asked for crewai and got langgraph with no
-// signal. The error propagates through Start → markProvisionFailed, which
-// already broadcasts WorkspaceProvisionFailed and records the message.
-//
-// The genuinely-unspecified runtime (empty cfg.Runtime, e.g. an org template
-// that doesn't pin one) is an intended distinct path and still resolves to
-// DefaultImage — only a NAMED-but-unresolvable runtime is rejected.
-func selectImage(cfg WorkspaceConfig) (string, error) {
+// runtime→tag lookup in RuntimeImages (legacy `:latest` behavior). When the
+// runtime isn't recognized either, fall back to DefaultImage so Start() still
+// has something to hand Docker — surfacing a "No such image" later is more
+// actionable than a silent "" panic in ContainerCreate.
+func selectImage(cfg WorkspaceConfig) string {
 	if cfg.Image != "" {
-		return cfg.Image, nil
+		return cfg.Image
 	}
 	if cfg.Runtime != "" {
 		if img, ok := RuntimeImages[cfg.Runtime]; ok {
-			return img, nil
+			return img
 		}
-		return "", fmt.Errorf("%w: runtime %q (known runtimes: %v)",
-			ErrUnresolvableRuntime, cfg.Runtime, knownRuntimes)
 	}
-	return DefaultImage, nil
+	return DefaultImage
 }
 
 // Workspace-access constants for #65. Matches the CHECK constraint on
@@ -215,24 +189,6 @@ const containerNamePrefix = "ws-"
 // (the wiped-DB case after `docker compose down -v`).
 const LabelManaged = "molecule.platform.managed"
 
-// AgentUID / AgentGID are the uid/gid of the unprivileged `agent` user that
-// every workspace template creates and drops to via `gosu agent` before
-// exec'ing the runtime (the a2a_mcp_server runs under this uid). The value is
-// fixed at 1000:1000 across all templates — see:
-//   - workspace-configs-templates/claude-code-default/Dockerfile (`useradd -u 1000 ... agent`)
-//   - workspace-configs-templates/hermes/Dockerfile               (`useradd -u 1000 ... agent`)
-//   - workspace/entrypoint.sh                                     (`exec gosu agent` — "uid 1000")
-//
-// Files the platform injects into /configs AFTER the entrypoint's
-// `chown -R agent:agent /configs` (the post-start #418 re-injection and the
-// pre-start #1877 volume write) must be owned by this uid/gid, otherwise the
-// agent-uid MCP server hits EACCES reading /configs/.auth_token, sends an
-// empty bearer, and the platform 401s on /registry/{id}/peers (list_peers).
-const (
-	AgentUID = 1000
-	AgentGID = 1000
-)
-
 // managedLabels is the canonical label map applied to every workspace
 // container + volume. Pulled out so a future addition (e.g. instance
 // UUID for multi-platform-shared-daemon disambiguation) is one edit.
@@ -362,15 +318,7 @@ func (p *Provisioner) Start(ctx context.Context, cfg WorkspaceConfig) (string, e
 
 	env := buildContainerEnv(cfg)
 
-	image, imgErr := selectImage(cfg)
-	if imgErr != nil {
-		// Fail-closed: a named-but-unresolvable runtime must not silently
-		// become DefaultImage (RFC internal#483 / review 4269). The caller's
-		// error path (markProvisionFailed) broadcasts the failure + records
-		// the message so the canvas surfaces it.
-		log.Printf("Provisioner: refusing to start %s: %v", cfg.WorkspaceID, imgErr)
-		return "", imgErr
-	}
+	image := selectImage(cfg)
 
 	// Local-build mode (issue #63 / Task #194): when MOLECULE_IMAGE_REGISTRY
 	// is unset, the OSS contributor path skips the registry pull entirely
@@ -825,15 +773,6 @@ func ApplyTierConfig(hostCfg *container.HostConfig, cfg WorkspaceConfig, configM
 
 // CopyTemplateToContainer copies files from a host directory into /configs in the container.
 func (p *Provisioner) CopyTemplateToContainer(ctx context.Context, containerID, templatePath string) error {
-	buf, err := buildTemplateTar(templatePath)
-	if err != nil {
-		return err
-	}
-
-	return p.cli.CopyToContainer(ctx, containerID, "/configs", buf, container.CopyToContainerOptions{})
-}
-
-func buildTemplateTar(templatePath string) (*bytes.Buffer, error) {
 	// Resolve symlinks at the root before walking. filepath.Walk does
 	// NOT follow a symlink that IS the root — it Lstats the path, sees
 	// a symlink (non-directory), and emits exactly one entry without
@@ -856,15 +795,6 @@ func buildTemplateTar(templatePath string) (*bytes.Buffer, error) {
 		if err != nil {
 			return err
 		}
-		// OFFSEC-010: skip symlinks to prevent path traversal via malicious
-		// template symlinks (e.g. template/.ssh → /root/.ssh). filepath.Walk
-		// follows symlinks by default, so without this guard a crafted symlink
-		// inside the template directory could escape to include arbitrary host
-		// files in the tar archive. We intentionally skip rather than error so
-		// a broken symlink in an org template is a silent no-op.
-		if info.Mode()&os.ModeSymlink != 0 {
-			return nil
-		}
 		rel, err := filepath.Rel(templatePath, path)
 		if err != nil {
 			return err
@@ -905,27 +835,17 @@ func buildTemplateTar(templatePath string) (*bytes.Buffer, error) {
 		return nil
 	})
 	if err != nil {
-		return nil, fmt.Errorf("failed to create tar from %s: %w", templatePath, err)
+		return fmt.Errorf("failed to create tar from %s: %w", templatePath, err)
 	}
 	if err := tw.Close(); err != nil {
-		return nil, fmt.Errorf("failed to close tar writer: %w", err)
+		return fmt.Errorf("failed to close tar writer: %w", err)
 	}
 
-	return &buf, nil
+	return p.cli.CopyToContainer(ctx, containerID, "/configs", &buf, container.CopyToContainerOptions{})
 }
 
-// buildConfigFilesTar builds the tar stream that WriteFilesToContainer streams
-// into /configs via CopyToContainer. Every entry is stamped Uid/Gid = agent
-// (AgentUID/AgentGID) so the files land agent-owned after extraction. This is
-// the issue #418 post-start re-injection path: it runs AFTER the template
-// entrypoint's `chown -R agent:agent /configs`, so without explicit ownership
-// in the tar header the files extract as root:root (tar Uid/Gid default 0) and
-// the agent-uid MCP server can no longer read /configs/.auth_token (and
-// /configs/.platform_inbound_secret) → empty bearer → list_peers 401.
-//
-// Pulled out as a pure function so the ownership contract is unit-testable
-// without a live Docker daemon (mirrors buildTemplateTar).
-func buildConfigFilesTar(files map[string][]byte) (*bytes.Buffer, error) {
+// WriteFilesToContainer writes in-memory files into /configs in the container.
+func (p *Provisioner) WriteFilesToContainer(ctx context.Context, containerID string, files map[string][]byte) error {
 	var buf bytes.Buffer
 	tw := tar.NewWriter(&buf)
 
@@ -938,10 +858,8 @@ func buildConfigFilesTar(files map[string][]byte) (*bytes.Buffer, error) {
 				Typeflag: tar.TypeDir,
 				Name:     dir + "/",
 				Mode:     0755,
-				Uid:      AgentUID,
-				Gid:      AgentGID,
 			}); err != nil {
-				return nil, fmt.Errorf("failed to write tar dir header for %s: %w", dir, err)
+				return fmt.Errorf("failed to write tar dir header for %s: %w", dir, err)
 			}
 			createdDirs[dir] = true
 		}
@@ -950,30 +868,19 @@ func buildConfigFilesTar(files map[string][]byte) (*bytes.Buffer, error) {
 			Name: name,
 			Mode: 0644,
 			Size: int64(len(data)),
-			Uid:  AgentUID,
-			Gid:  AgentGID,
 		}
 		if err := tw.WriteHeader(header); err != nil {
-			return nil, fmt.Errorf("failed to write tar header for %s: %w", name, err)
+			return fmt.Errorf("failed to write tar header for %s: %w", name, err)
 		}
 		if _, err := tw.Write(data); err != nil {
-			return nil, fmt.Errorf("failed to write tar data for %s: %w", name, err)
+			return fmt.Errorf("failed to write tar data for %s: %w", name, err)
 		}
 	}
 	if err := tw.Close(); err != nil {
-		return nil, fmt.Errorf("failed to close tar writer: %w", err)
+		return fmt.Errorf("failed to close tar writer: %w", err)
 	}
-	return &buf, nil
-}
 
-// WriteFilesToContainer writes in-memory files into /configs in the container,
-// agent-owned (see buildConfigFilesTar).
-func (p *Provisioner) WriteFilesToContainer(ctx context.Context, containerID string, files map[string][]byte) error {
-	buf, err := buildConfigFilesTar(files)
-	if err != nil {
-		return err
-	}
-	return p.cli.CopyToContainer(ctx, containerID, "/configs", buf, container.CopyToContainerOptions{})
+	return p.cli.CopyToContainer(ctx, containerID, "/configs", &buf, container.CopyToContainerOptions{})
 }
 
 // CopyToContainer exposes CopyToContainer from the Docker client for use by other packages.
@@ -1063,28 +970,13 @@ func (p *Provisioner) ReadFromVolume(ctx context.Context, volumeName, filePath s
 	return clean, nil
 }
 
-// writeAuthTokenVolumeCmd is the shell command the throwaway alpine container
-// runs to seed /vol/.auth_token. alpine runs it as root, so without the
-// explicit `chown 1000:1000` the file stays root:root after the template
-// entrypoint's `chown -R agent:agent /configs` has already run — the agent-uid
-// (AgentUID) MCP server then gets EACCES reading it → empty bearer →
-// list_peers 401. Pulled out as a pure function so the ownership contract is
-// unit-testable without a live Docker daemon. Issue #1877.
-func writeAuthTokenVolumeCmd() string {
-	return fmt.Sprintf(
-		"mkdir -p /vol && printf '%%s' $TOKEN > /vol/.auth_token && chmod 0600 /vol/.auth_token && chown %d:%d /vol/.auth_token",
-		AgentUID, AgentGID,
-	)
-}
-
 // WriteAuthTokenToVolume writes the workspace auth token into the config volume
 // BEFORE the container starts, eliminating the token-injection race window where
 // a restarted container could read a stale token from /configs/.auth_token before
 // WriteFilesToContainer writes the new one. Issue #1877.
 //
 // Uses a throwaway alpine container to write directly to the named volume,
-// bypassing the container lifecycle entirely. The written file is chowned to
-// the agent uid/gid (see writeAuthTokenVolumeCmd).
+// bypassing the container lifecycle entirely.
 func (p *Provisioner) WriteAuthTokenToVolume(ctx context.Context, workspaceID, token string) error {
 	if p == nil || p.cli == nil {
 		return ErrNoBackend
@@ -1092,7 +984,7 @@ func (p *Provisioner) WriteAuthTokenToVolume(ctx context.Context, workspaceID, t
 	volName := ConfigVolumeName(workspaceID)
 	resp, err := p.cli.ContainerCreate(ctx, &container.Config{
 		Image: "alpine",
-		Cmd:   []string{"sh", "-c", writeAuthTokenVolumeCmd()},
+		Cmd:   []string{"sh", "-c", "mkdir -p /vol && printf '%s' $TOKEN > /vol/.auth_token && chmod 0600 /vol/.auth_token"},
 		Env:   []string{"TOKEN=" + token},
 	}, &container.HostConfig{
 		Binds: []string{volName + ":/vol"},

workspace-server/internal/provisioner/provisioner_test.go

@@ -1,9 +1,7 @@
 package provisioner
 
 import (
-	"archive/tar"
 	"errors"
-	"io"
 	"os"
 	"path/filepath"
 	"strings"
@@ -82,54 +80,6 @@ func TestStartSeedsConfigsBeforeContainerStart(t *testing.T) {
 	}
 }
 
-func TestBuildTemplateTar_SkipsSymlinks(t *testing.T) {
-	dir := t.TempDir()
-	if err := os.WriteFile(filepath.Join(dir, "config.yaml"), []byte("name: safe\n"), 0644); err != nil {
-		t.Fatalf("write config: %v", err)
-	}
-	outside := filepath.Join(t.TempDir(), "secret.txt")
-	if err := os.WriteFile(outside, []byte("do-not-copy\n"), 0644); err != nil {
-		t.Fatalf("write outside target: %v", err)
-	}
-	if err := os.Symlink(outside, filepath.Join(dir, "linked-secret.txt")); err != nil {
-		t.Fatalf("create symlink: %v", err)
-	}
-
-	buf, err := buildTemplateTar(dir)
-	if err != nil {
-		t.Fatalf("buildTemplateTar: %v", err)
-	}
-
-	names := map[string]string{}
-	tr := tar.NewReader(buf)
-	for {
-		hdr, err := tr.Next()
-		if errors.Is(err, io.EOF) {
-			break
-		}
-		if err != nil {
-			t.Fatalf("read tar: %v", err)
-		}
-		body, err := io.ReadAll(tr)
-		if err != nil {
-			t.Fatalf("read body for %s: %v", hdr.Name, err)
-		}
-		names[hdr.Name] = string(body)
-	}
-
-	if got := names["config.yaml"]; got != "name: safe\n" {
-		t.Fatalf("config.yaml body = %q, want safe config", got)
-	}
-	if _, ok := names["linked-secret.txt"]; ok {
-		t.Fatalf("symlink entry was copied into template tar: %#v", names)
-	}
-	for name, body := range names {
-		if strings.Contains(body, "do-not-copy") {
-			t.Fatalf("symlink target leaked through %s: %q", name, body)
-		}
-	}
-}
-
 // baseHostConfig returns a fresh HostConfig with typical pre-tier binds,
 // mimicking what Start() builds before calling ApplyTierConfig.
 func baseHostConfig(pluginsPath string) *container.HostConfig {
@@ -513,10 +463,7 @@ func TestWorkspaceConfig_ResetClaudeSessionFieldPresent(t *testing.T) {
 // we lose the "one bad publish doesn't break every workspace" guarantee.
 func TestSelectImage_PrefersExplicitImage(t *testing.T) {
 	pinned := "ghcr.io/molecule-ai/workspace-template-claude-code@sha256:3d6761a97ed07d7d33cfc19a8fbab81175d9d9179618d493dbc00c5f7ef076a3"
-	got, err := selectImage(WorkspaceConfig{Runtime: "claude-code", Image: pinned})
-	if err != nil {
-		t.Fatalf("selectImage with cfg.Image=pinned: unexpected error %v", err)
-	}
+	got := selectImage(WorkspaceConfig{Runtime: "claude-code", Image: pinned})
 	if got != pinned {
 		t.Errorf("selectImage with cfg.Image=pinned: got %q, want %q", got, pinned)
 	}
@@ -526,46 +473,28 @@ func TestSelectImage_PrefersExplicitImage(t *testing.T) {
 // pin lookup deliberately bypassed via WORKSPACE_IMAGE_LOCAL_OVERRIDE).
 // selectImage must use the legacy runtime→:latest map.
 func TestSelectImage_FallsBackToRuntimeMap(t *testing.T) {
-	got, err := selectImage(WorkspaceConfig{Runtime: "claude-code", Image: ""})
-	if err != nil {
-		t.Fatalf("selectImage with empty Image: unexpected error %v", err)
-	}
+	got := selectImage(WorkspaceConfig{Runtime: "claude-code", Image: ""})
 	want := RuntimeImages["claude-code"]
 	if got != want {
 		t.Errorf("selectImage with empty Image: got %q, want %q", got, want)
 	}
 }
 
-// TestSelectImage_NamedUnresolvableRuntimeRejects pins the fail-closed
-// contract (RFC internal#483 / security review 4269 /
-// feedback_platform_must_hardgate_base_contract): a NAMED runtime with no
-// resolvable image must reject with ErrUnresolvableRuntime, NOT silently
-// substitute DefaultImage. Pre-fix this returned langgraph — a user asking
-// for a removed runtime (crewai/deepagents/gemini-cli) silently got a
-// langgraph container. "crewai" is the concrete regression from the
-// security finding.
-func TestSelectImage_NamedUnresolvableRuntimeRejects(t *testing.T) {
-	for _, rt := range []string{"no-such-runtime", "crewai", "deepagents", "gemini-cli"} {
-		got, err := selectImage(WorkspaceConfig{Runtime: rt})
-		if !errors.Is(err, ErrUnresolvableRuntime) {
-			t.Errorf("selectImage(%q): got err %v, want ErrUnresolvableRuntime", rt, err)
-		}
-		if got != "" {
-			t.Errorf("selectImage(%q): got image %q, want \"\" on reject", rt, got)
-		}
-		if err != nil && !strings.Contains(err.Error(), rt) {
-			t.Errorf("selectImage(%q): error must name the offending runtime, got %v", rt, err)
-		}
+// TestSelectImage_UnknownRuntimeFallsBackToDefault preserves today's
+// behavior — an unrecognized runtime resolves to DefaultImage rather than
+// "" so ContainerCreate gets a usable arg and surfaces a meaningful
+// "No such image" error if the default itself is missing.
+func TestSelectImage_UnknownRuntimeFallsBackToDefault(t *testing.T) {
+	got := selectImage(WorkspaceConfig{Runtime: "no-such-runtime"})
+	if got != DefaultImage {
+		t.Errorf("selectImage with unknown runtime: got %q, want DefaultImage %q", got, DefaultImage)
 	}
 }
 
 // TestSelectImage_EmptyRuntimeFallsBackToDefault: same invariant for the
 // no-runtime-supplied path (legacy callers / older handler code).
 func TestSelectImage_EmptyRuntimeFallsBackToDefault(t *testing.T) {
-	got, err := selectImage(WorkspaceConfig{})
-	if err != nil {
-		t.Fatalf("selectImage with zero cfg: unexpected error %v (empty runtime is a legitimate DefaultImage path)", err)
-	}
+	got := selectImage(WorkspaceConfig{})
 	if got != DefaultImage {
 		t.Errorf("selectImage with zero cfg: got %q, want DefaultImage %q", got, DefaultImage)
 	}
@@ -829,7 +758,7 @@ func TestIsImageNotFoundErr(t *testing.T) {
 		{"nil", nil, false},
 		{"moby no such image", fmtErr(`Error response from daemon: No such image: workspace-template:openclaw`), true},
 		{"no such image lowercase", fmtErr(`error: no such image: foo:bar`), true},
-		{"image not found", fmtErr(`Error: image "workspace-template:hermes" not found`), true},
+		{"image not found", fmtErr(`Error: image "workspace-template:crewai" not found`), true},
 		{"generic not found without image", fmtErr(`container not found`), false},
 		{"unrelated error", fmtErr(`connection refused`), false},
 		{"permission denied", fmtErr(`permission denied`), false},

workspace-server/internal/provisioner/registry.go

@@ -21,6 +21,9 @@ var knownRuntimes = []string{
 	"autogen",
 	"claude-code",
 	"codex",
+	"crewai",
+	"deepagents",
+	"gemini-cli",
 	"hermes",
 	"langgraph",
 	"openclaw",

workspace-server/internal/provisioner/registry_test.go

@@ -53,8 +53,8 @@ func TestRuntimeImage_AllKnownRuntimes(t *testing.T) {
 		}
 	}
 	// Pin the count so adding a runtime requires explicit test acknowledgement.
-	if len(knownRuntimes) != 6 {
-		t.Errorf("knownRuntimes length = %d, want 6 (autogen, claude-code, codex, hermes, langgraph, openclaw)", len(knownRuntimes))
+	if len(knownRuntimes) != 9 {
+		t.Errorf("knownRuntimes length = %d, want 9 (autogen, claude-code, codex, crewai, deepagents, gemini-cli, hermes, langgraph, openclaw)", len(knownRuntimes))
 	}
 }
 

workspace-server/internal/provisioner/token_ownership_test.go

@@ -1,95 +0,0 @@
-package provisioner
-
-import (
-	"archive/tar"
-	"errors"
-	"io"
-	"strings"
-	"testing"
-)
-
-// These tests pin the P0 fix for the fleet-wide list_peers 401 (Hermes and
-// every other template): the workspace-server token-injection paths wrote
-// /configs/.auth_token (and /configs/.platform_inbound_secret) as root:root
-// AFTER the template entrypoint's `chown -R agent:agent /configs` ran, so the
-// agent-uid (1000) MCP server (a2a_mcp_server, running via `gosu agent`) hit
-// `[Errno 13] Permission denied` reading the bearer → empty bearer → platform
-// 401 on /registry/{id}/peers (the literal tool_list_peers path).
-//
-// The agent uid is 1000:1000, verified from the templates:
-//   - workspace-configs-templates/claude-code-default/Dockerfile: `useradd -u 1000 ... agent`
-//   - workspace-configs-templates/hermes/Dockerfile:               `useradd -u 1000 ... agent`
-//   - workspace/entrypoint.sh / claude-code-default/entrypoint.sh:  `exec gosu agent` ("uid 1000")
-//
-// Both tests assert the real artifact (the tar headers Docker's CopyToContainer
-// honours for ownership, and the literal shell command the throwaway alpine
-// container runs), not a mock that bypasses ownership. They FAIL on pre-fix
-// code (no Uid/Gid in tar headers; no chown in the alpine command → root:root)
-// and PASS post-fix (agent-owned).
-
-// TestWriteFilesToContainerTar_FilesAreAgentOwned covers the issue #418
-// post-start re-injection path (WriteFilesToContainer): the tar it streams
-// into /configs via CopyToContainer must carry Uid/Gid = agent (1000) so the
-// extracted files land agent-readable, not root:root. This is the path that
-// (re)writes BOTH .auth_token and .platform_inbound_secret on a cadence.
-func TestWriteFilesToContainerTar_FilesAreAgentOwned(t *testing.T) {
-	files := map[string][]byte{
-		".auth_token":              []byte("tok-abc123"),
-		".platform_inbound_secret": []byte("inbound-secret-xyz"),
-		"nested/dir/file.txt":      []byte("data"),
-	}
-
-	buf, err := buildConfigFilesTar(files)
-	if err != nil {
-		t.Fatalf("buildConfigFilesTar: %v", err)
-	}
-
-	tr := tar.NewReader(buf)
-	seen := map[string]bool{}
-	for {
-		hdr, err := tr.Next()
-		if errors.Is(err, io.EOF) {
-			break
-		}
-		if err != nil {
-			t.Fatalf("read tar: %v", err)
-		}
-		if _, err := io.Copy(io.Discard, tr); err != nil {
-			t.Fatalf("drain %s: %v", hdr.Name, err)
-		}
-		seen[hdr.Name] = true
-		if hdr.Uid != AgentUID {
-			t.Fatalf("tar entry %q Uid = %d, want %d (agent) — root-owned injection causes the list_peers 401",
-				hdr.Name, hdr.Uid, AgentUID)
-		}
-		if hdr.Gid != AgentGID {
-			t.Fatalf("tar entry %q Gid = %d, want %d (agent)", hdr.Name, hdr.Gid, AgentGID)
-		}
-	}
-
-	for _, want := range []string{".auth_token", ".platform_inbound_secret"} {
-		if !seen[want] {
-			t.Fatalf("tar missing %q (seen: %v)", want, seen)
-		}
-	}
-}
-
-// TestWriteAuthTokenVolumeCmd_ChownsToAgent covers the issue #1877 pre-start
-// volume-write path (WriteAuthTokenToVolume): the throwaway alpine container
-// writes /vol/.auth_token then chmod 0600 but, pre-fix, never chowns it, so it
-// stays root:root (alpine runs the command as root). The literal command must
-// chown the file to the agent uid:gid so the agent-uid MCP server can read it.
-func TestWriteAuthTokenVolumeCmd_ChownsToAgent(t *testing.T) {
-	cmd := writeAuthTokenVolumeCmd()
-
-	if !strings.Contains(cmd, "chmod 0600 /vol/.auth_token") {
-		t.Fatalf("alpine cmd lost the 0600 chmod (regression): %q", cmd)
-	}
-
-	wantChown := "chown 1000:1000 /vol/.auth_token"
-	if !strings.Contains(cmd, wantChown) {
-		t.Fatalf("alpine cmd = %q, missing %q — without it .auth_token stays root:root "+
-			"and the agent-uid MCP server gets EACCES → empty bearer → list_peers 401",
-			cmd, wantChown)
-	}
-}

workspace-server/internal/router/router.go

@@ -146,9 +146,6 @@ func Setup(hub *ws.Hub, broadcaster *events.Broadcaster, prov *provisioner.Provi
 		wsAdmin.GET("/workspaces", wh.List)
 		wsAdmin.POST("/workspaces", wh.Create)
 		wsAdmin.DELETE("/workspaces/:id", wh.Delete)
-		// Ability toggles — admin-only so workspace agents cannot self-modify
-		// broadcast_enabled or talk_to_user_enabled.
-		wsAdmin.PATCH("/workspaces/:id/abilities", handlers.PatchAbilities)
 		// Out-of-band bootstrap signal: CP's watcher POSTs here when it
 		// detects "RUNTIME CRASHED" in a workspace EC2 console output,
 		// so the canvas flips to failed in seconds instead of waiting
@@ -204,12 +201,6 @@ func Setup(hub *ws.Hub, broadcaster *events.Broadcaster, prov *provisioner.Provi
 		// to 'hibernated'. The workspace auto-wakes on the next A2A message.
 		wsAuth.POST("/hibernate", wh.Hibernate)
 
-		// Broadcast — send a message to all non-removed workspaces in the org.
-		// Requires broadcast_enabled=true on the source workspace (checked
-		// inside the handler). WorkspaceAuth on wsAuth proves token ownership.
-		broadcastH := handlers.NewBroadcastHandler(broadcaster)
-		wsAuth.POST("/broadcast", broadcastH.Broadcast)
-
 		// External-workspace credential lifecycle (issue #319 follow-up to
 		// the Create flow). Both endpoints reject runtime ≠ external with
 		// 400 — see external_rotate.go for the rationale.

workspace-server/migrations/20260514120000_workspace_abilities.down.sql

@@ -1,3 +0,0 @@
-ALTER TABLE workspaces
-    DROP COLUMN IF EXISTS broadcast_enabled,
-    DROP COLUMN IF EXISTS talk_to_user_enabled;

workspace-server/migrations/20260514120000_workspace_abilities.up.sql

@@ -1,16 +0,0 @@
--- Workspace abilities: opt-in flags that gate platform-level behaviours.
---
--- broadcast_enabled (default FALSE): when TRUE the workspace may call
---   POST /workspaces/:id/broadcast to send a message to every non-removed
---   agent workspace in the org. Off by default — only privileged
---   orchestrator workspaces should hold this ability.
---
--- talk_to_user_enabled (default TRUE): when FALSE the workspace is not
---   allowed to deliver messages to the canvas user via send_message_to_user /
---   POST /notify. The platform returns HTTP 403 so the agent can forward its
---   update to a parent workspace instead. Default TRUE preserves existing
---   behaviour for all current workspaces.
-
-ALTER TABLE workspaces
-    ADD COLUMN IF NOT EXISTS broadcast_enabled    BOOLEAN NOT NULL DEFAULT FALSE,
-    ADD COLUMN IF NOT EXISTS talk_to_user_enabled BOOLEAN NOT NULL DEFAULT TRUE;

workspace/_sanitize_a2a.py

@@ -40,8 +40,6 @@ _A2A_BOUNDARY_END = "[/A2A_RESULT_FROM_PEER]"
 # inside the trusted zone. Escape BOTH boundary markers in the raw text
 # before wrapping so they can never close the boundary early.
 # We use "[/ " as the escape prefix — visually distinct from the real marker.
-_A2A_BOUNDARY_START_ESCAPED = "[/ A2A_RESULT_FROM_PEER]"
-_A2A_BOUNDARY_END_ESCAPED = "[/ /A2A_RESULT_FROM_PEER]"
 
 
 def _escape_boundary_markers(text: str) -> str:
@@ -52,8 +50,8 @@ def _escape_boundary_markers(text: str) -> str:
     the boundary early or inject a fake opener.
     """
     return (
-        text.replace(_A2A_BOUNDARY_START, _A2A_BOUNDARY_START_ESCAPED)
-        .replace(_A2A_BOUNDARY_END, _A2A_BOUNDARY_END_ESCAPED)
+        text.replace(_A2A_BOUNDARY_START, "[/ A2A_RESULT_FROM_PEER]")
+        .replace(_A2A_BOUNDARY_END, "[/ /A2A_RESULT_FROM_PEER]")
     )
 
 

workspace/a2a_mcp_server.py

@@ -29,7 +29,6 @@ from typing import Callable
 import inbox
 
 from a2a_tools import (
-    tool_broadcast_message,
     tool_chat_history,
     tool_check_task_status,
     tool_commit_memory,
@@ -161,11 +160,6 @@ async def handle_tool_call(name: str, arguments: dict) -> str:
             arguments.get("before_ts", ""),
             source_workspace_id=arguments.get("source_workspace_id") or None,
         )
-    elif name == "broadcast_message":
-        return await tool_broadcast_message(
-            arguments.get("message", ""),
-            workspace_id=arguments.get("workspace_id") or None,
-        )
     return f"Unknown tool: {name}"
 
 

workspace/a2a_tools.py

@@ -137,7 +137,6 @@ from a2a_tools_delegation import (  # noqa: E402  (import after the from-a2a_cli
 # identically.
 from a2a_tools_messaging import (  # noqa: E402  (import after the top-of-module imports)
     _upload_chat_files,
-    tool_broadcast_message,
     tool_chat_history,
     tool_get_workspace_info,
     tool_list_peers,

workspace/a2a_tools_delegation.py

@@ -49,9 +49,7 @@ from a2a_client import (
 from a2a_tools_rbac import auth_headers_for_heartbeat as _auth_headers_for_heartbeat
 from _sanitize_a2a import (
     _A2A_BOUNDARY_END,
-    _A2A_BOUNDARY_END_ESCAPED,
     _A2A_BOUNDARY_START,
-    _A2A_BOUNDARY_START_ESCAPED,
     sanitize_a2a_result,
 )  # noqa: E402
 
@@ -332,18 +330,8 @@ async def tool_delegate_task(
     # markers so the agent can distinguish trusted (own output) from untrusted
     # (peer-supplied) content.  Explicit wrapping here rather than inside
     # sanitize_a2a_result preserves a clean separation of concerns.
-    #
-    # Truncate at the closer BEFORE sanitizing so the raw closer (which gets
-    # lost during escaping) is removed from the content.  After truncation,
-    # sanitize the remaining text and wrap with escaped boundary markers.
-    if _A2A_BOUNDARY_END in result:
-        result = result[:result.index(_A2A_BOUNDARY_END)]
     escaped = sanitize_a2a_result(result)
-    return (
-        f"{_A2A_BOUNDARY_START_ESCAPED}\n"
-        f"{escaped}\n"
-        f"{_A2A_BOUNDARY_END_ESCAPED}"
-    )
+    return f"{_A2A_BOUNDARY_START}\n{escaped}\n{_A2A_BOUNDARY_END}"
 
 
 async def tool_delegate_task_async(

workspace/a2a_tools_messaging.py

@@ -101,50 +101,6 @@ async def _upload_chat_files(
     return uploaded, None
 
 
-async def tool_broadcast_message(
-    message: str,
-    workspace_id: str | None = None,
-) -> str:
-    """Send a broadcast message to ALL agent workspaces in the org.
-
-    Requires the workspace to have broadcast_enabled=true (set by a user or
-    admin via PATCH /workspaces/:id/abilities). Use for urgent org-wide
-    signals — status changes, critical alerts, coordination instructions.
-    Every non-removed workspace receives the message in its activity log so
-    poll-mode agents pick it up, and push-mode canvases get a real-time
-    BROADCAST_MESSAGE WebSocket event.
-
-    Args:
-        message: The broadcast text. Keep it concise — all agents receive
-            this, so avoid lengthy prose that floods every context.
-        workspace_id: Optional. Which registered workspace to send the
-            broadcast from. Single-workspace agents omit this.
-    """
-    if not message:
-        return "Error: message is required"
-    target_workspace_id = (workspace_id or "").strip() or WORKSPACE_ID
-    try:
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            resp = await client.post(
-                f"{PLATFORM_URL}/workspaces/{target_workspace_id}/broadcast",
-                json={"message": message},
-                headers=_auth_headers_for_heartbeat(target_workspace_id),
-            )
-            if resp.status_code == 200:
-                data = resp.json()
-                delivered = data.get("delivered", "?")
-                return f"Broadcast sent to {delivered} workspace(s)"
-            if resp.status_code == 403:
-                try:
-                    hint = resp.json().get("hint", "")
-                except Exception:
-                    hint = ""
-                return f"Error: broadcast ability not enabled.{(' ' + hint) if hint else ''}"
-            return f"Error: platform returned {resp.status_code}"
-    except Exception as e:
-        return f"Error sending broadcast: {e}"
-
-
 async def tool_send_message_to_user(
     message: str,
     attachments: list[str] | None = None,
@@ -195,20 +151,6 @@ async def tool_send_message_to_user(
                 if uploaded:
                     return f"Message sent to user with {len(uploaded)} attachment(s)"
                 return "Message sent to user"
-            if resp.status_code == 403:
-                try:
-                    body = resp.json()
-                    if body.get("error") == "talk_to_user_disabled":
-                        hint = body.get("hint", "")
-                        return (
-                            "Error: this workspace is not allowed to send messages "
-                            "directly to the user (talk_to_user is disabled). "
-                            + (hint + " " if hint else "")
-                            + "Use delegate_task to forward your update to a parent "
-                            "or supervisor workspace that can reach the user."
-                        )
-                except Exception:
-                    pass
             return f"Error: platform returned {resp.status_code}"
     except Exception as e:
         return f"Error sending message: {e}"

workspace/adapter_base.py

@@ -3,57 +3,9 @@
 import logging
 import os
 from abc import ABC, abstractmethod
-from collections.abc import Mapping
 from dataclasses import dataclass, field
 from typing import Any
 
-# ---------------------------------------------------------------------------
-# Provider routing — type alias + resolver used by individual adapters.
-# Each adapter defines its own ProviderRegistry with the providers it accepts.
-# ---------------------------------------------------------------------------
-
-# Maps prefix → (ordered_auth_env_vars, default_base_url).
-ProviderRegistry = dict[str, tuple[tuple[str, ...], str]]
-
-
-def resolve_provider_routing(
-    model_str: str,
-    env: Mapping[str, str],
-    *,
-    registry: ProviderRegistry,
-    runtime_config: dict[str, Any] | None = None,
-) -> tuple[str, str, str]:
-    """Resolve a ``provider:model`` string to ``(api_key, base_url, bare_model_id)``.
-
-    URL precedence (highest to lowest):
-      1. ``<PREFIX>_BASE_URL`` env var
-      2. ``runtime_config["provider_url"]``
-      3. registry default for the prefix
-
-    Unknown prefixes fall back to OPENAI_API_KEY + api.openai.com.
-    Raises RuntimeError when no API key env var is set for the prefix.
-    """
-    if ":" in model_str:
-        prefix, model_id = model_str.split(":", 1)
-    else:
-        prefix, model_id = "openai", model_str
-
-    env_vars, default_url = registry.get(
-        prefix, (("OPENAI_API_KEY",), "https://api.openai.com/v1")
-    )
-    api_key = next((env[v] for v in env_vars if env.get(v)), "")
-    if not api_key:
-        raise RuntimeError(
-            f"No API key found for provider {prefix!r} "
-            f"(checked: {', '.join(env_vars)}). Set one in workspace secrets."
-        )
-
-    env_url = env.get(f"{prefix.upper()}_BASE_URL", "")
-    config_url = (runtime_config or {}).get("provider_url", "")
-    base_url = env_url or config_url or default_url
-
-    return api_key, base_url, model_id
-
 from a2a.server.agent_execution import AgentExecutor
 
 from event_log import DisabledEventLog, EventLogBackend

workspace/executor_helpers.py

@@ -340,10 +340,6 @@ _CLI_A2A_COMMAND_KEYWORDS: dict[str, str | None] = {
     "delegate_task_async": "delegate --async",
     "check_task_status": "status",
     "get_workspace_info": "info",
-    # `broadcast_message` is not exposed via the CLI subprocess interface
-    # today — it's an MCP-first capability. If a2a_cli grows a `broadcast`
-    # subcommand, map it here and the alignment test will gate the change.
-    "broadcast_message": None,
     # `send_message_to_user` is not exposed via the CLI subprocess
     # interface today — it requires a structured `attachments` field
     # that wouldn't survive a positional-arg shell invocation cleanly.

workspace/inbox.py

@@ -431,43 +431,6 @@ def _is_self_notify_row(row: dict[str, Any]) -> bool:
     return source_id is None or source_id == ""
 
 
-def _is_self_echo_row(row: dict[str, Any], workspace_id: str) -> bool:
-    """Return True if ``row`` is a self-originated a2a_receive row.
-
-    Internal #469: when a workspace delegates to a target that never picks
-    up the task, ``tool_delegate_task`` calls ``report_activity`` which
-    POSTs to the platform with source_id set to the *sender's* workspace
-    UUID (mandated by spoof-defense in workspace-server's a2a_proxy). The
-    activity API exposes that row under type=a2a_receive, so the inbox
-    poller re-fetches it. Without this guard the row is surfaced as
-    kind='peer_agent' with the workspace's own identity as peer_id —
-    the workspace sees its own delegation-failure echoed back as if a
-    peer had delegated to it.
-
-    The guard mirrors the existing _is_self_notify_row pattern: both
-    skip rows that would otherwise create spurious inbound signal. The
-    long-term fix (making the platform write a distinct activity_type
-    for agent-outbound rows) is tracked separately; this guard stays
-    because it only excludes rows the agent never wants.
-
-    ``workspace_id`` must be non-empty — an empty-string workspace_id
-    (single-workspace legacy path) can never match a UUID source_id, so
-    the predicate is always False there, which is safe.
-
-    RFC #2829 PR-2 note: rows with method="delegate_result" are excluded
-    from the self-echo guard even when source_id matches our workspace_id.
-    The platform may write a delegation-result row with source_id set to
-    our workspace_id (e.g. a self-delegation or edge case in the platform's
-    result-writing path). Such rows must reach the inbox so that
-    message_from_activity can surface them as peer_agent inbound and the
-    runtime receives the delegation result. Silently filtering them as
-    self-echo would break delegation result delivery.
-    """
-    if not workspace_id:
-        return False
-    return row.get("source_id") == workspace_id and row.get("method") != "delegate_result"
-
-
 def message_from_activity(row: dict[str, Any]) -> InboxMessage:
     """Convert one /activity row into an InboxMessage.
 
@@ -660,16 +623,6 @@ def _poll_once(
             # the same self-notify on every iteration.
             last_id = str(row.get("id", "")) or last_id
             continue
-        if _is_self_echo_row(row, workspace_id):
-            # Internal #469: tool_delegate_task writes its own a2a_receive
-            # row with source_id = this workspace's UUID (spoof-defense).
-            # The poll fetches it back as kind='peer_agent', making the
-            # workspace echo its own delegation-failure as an inbound from
-            # a phantom peer. Skip it — the real delegation-result path
-            # (delegate_result push) is separate and unaffected. Cursor
-            # still advances so the next poll doesn't re-seen this row.
-            last_id = str(row.get("id", "")) or last_id
-            continue
         message = message_from_activity(row)
         if not message.activity_id:
             continue

workspace/platform_tools/registry.py

@@ -51,7 +51,6 @@ from dataclasses import dataclass
 from typing import Any, Literal
 
 from a2a_tools import (
-    tool_broadcast_message,
     tool_chat_history,
     tool_check_task_status,
     tool_commit_memory,
@@ -289,44 +288,6 @@ _GET_WORKSPACE_INFO = ToolSpec(
     section=A2A_SECTION,
 )
 
-_BROADCAST_MESSAGE = ToolSpec(
-    name="broadcast_message",
-    short=(
-        "Send a message to ALL agent workspaces in the org simultaneously. "
-        "Requires broadcast_enabled=true on this workspace (set by user/admin)."
-    ),
-    when_to_use=(
-        "Use for urgent, org-wide signals: critical status changes, emergency "
-        "stop instructions, coordinated task announcements. Every non-removed "
-        "workspace receives the message in its activity log (poll-mode agents "
-        "see it on their next poll; push-mode canvases get a real-time banner). "
-        "This tool returns an error if broadcast_enabled is false — a user or "
-        "admin must enable it via the workspace abilities settings first."
-    ),
-    input_schema={
-        "type": "object",
-        "properties": {
-            "message": {
-                "type": "string",
-                "description": (
-                    "The broadcast text. Keep it concise — every agent in the "
-                    "org receives this in their activity feed."
-                ),
-            },
-            "workspace_id": {
-                "type": "string",
-                "description": (
-                    "Optional. Multi-workspace mode: the registered workspace "
-                    "to broadcast from. Single-workspace agents omit this."
-                ),
-            },
-        },
-        "required": ["message"],
-    },
-    impl=tool_broadcast_message,
-    section=A2A_SECTION,
-)
-
 _SEND_MESSAGE_TO_USER = ToolSpec(
     name="send_message_to_user",
     short=(
@@ -642,7 +603,6 @@ TOOLS: list[ToolSpec] = [
     _CHECK_TASK_STATUS,
     _LIST_PEERS,
     _GET_WORKSPACE_INFO,
-    _BROADCAST_MESSAGE,
     _SEND_MESSAGE_TO_USER,
     # Inbox (standalone-only; in-container returns informational error)
     _WAIT_FOR_MESSAGE,

workspace/tests/snapshots/a2a_instructions_mcp.txt

@@ -5,7 +5,6 @@
 - **check_task_status**: Poll the status of a task started with delegate_task_async; returns result when done.
 - **list_peers**: List the workspaces this agent can communicate with — name, ID, status, role for each.
 - **get_workspace_info**: Get this workspace's own info — ID, name, role, tier, parent, status.
-- **broadcast_message**: Send a message to ALL agent workspaces in the org simultaneously. Requires broadcast_enabled=true on this workspace (set by user/admin).
 - **send_message_to_user**: Send a message directly to the user's canvas chat — pushed instantly via WebSocket. Use this to: (1) acknowledge a task immediately ('Got it, I'll start working on this'), (2) send interim progress updates while doing long work, (3) deliver follow-up results after delegation completes, (4) attach files (zip, pdf, csv, image) for the user to download via the `attachments` field (NEVER paste file URLs in `message`). The message appears in the user's chat as if you're proactively reaching out.
 - **wait_for_message**: Block until the next inbound message (canvas user OR peer agent) arrives, or until ``timeout_secs`` elapses.
 - **inbox_peek**: List pending inbound messages without removing them.
@@ -27,9 +26,6 @@ Call this first when you need to delegate but don't know the target's ID. Access
 ### get_workspace_info
 Use to introspect your own identity (e.g. before reporting back to the user, or to determine whether you're a tier-0 root that can write GLOBAL memory).
 
-### broadcast_message
-Use for urgent, org-wide signals: critical status changes, emergency stop instructions, coordinated task announcements. Every non-removed workspace receives the message in its activity log (poll-mode agents see it on their next poll; push-mode canvases get a real-time banner). This tool returns an error if broadcast_enabled is false — a user or admin must enable it via the workspace abilities settings first.
-
 ### send_message_to_user
 Use proactively across the lifecycle of a task — early to acknowledge, mid-flight to update, late to deliver. Never paste file URLs in the message body — always pass absolute paths in `attachments` so the platform serves them as download chips (works on SaaS where external file hosts are unreachable).