test(canvas/FilesTab): add FileTree render + WCAG accessibility tests

24 tests covering:
- Empty tree render
- File row: icon, name, selection highlight, delete button aria-label
- Directory row: chevron ▶/▼, loading indicator …, expand/collapse, recursive children
- Context menu: file (Open + Download + Delete), dir (Delete only)
- canDelete=false gates context menu Delete item
- Drag-drop target highlight with dataTransfer stub (jsdom-safe)
- Three-level nested tree visibility

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

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

@@ -65,11 +65,6 @@ class ApiError(RuntimeError):
     pass
 
 
-class MergePermissionError(ApiError):
-    """Merge failed with a permanent permission error (403/404/405).
-    The queue should skip this PR and move to the next one."""
-
-
 @dataclasses.dataclass(frozen=True)
 class MergeDecision:
     ready: bool
@@ -153,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
 
@@ -237,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
@@ -257,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")
@@ -282,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
 
 
@@ -372,16 +338,7 @@ def merge_pull(pr_number: int, *, dry_run: bool) -> None:
     print(f"::notice::merging PR #{pr_number}")
     if dry_run:
         return
-    try:
-        api("POST", f"/repos/{OWNER}/{NAME}/pulls/{pr_number}/merge", body=payload, expect_json=False)
-    except ApiError as exc:
-        # Re-raise permission-like errors so process_once can skip this PR.
-        # 403 = no push access, 404 = repo/pr not found, 405 = not allowed.
-        msg = str(exc)
-        for code in ("403", "404", "405"):
-            if code in msg:
-                raise MergePermissionError(msg) from exc
-        raise  # re-raise other ApiErrors unchanged
+    api("POST", f"/repos/{OWNER}/{NAME}/pulls/{pr_number}/merge", body=payload, expect_json=False)
 
 
 def process_once(*, dry_run: bool = False) -> int:
@@ -423,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}")
@@ -452,25 +407,7 @@ def process_once(*, dry_run: bool = False) -> int:
                 "deferring to next tick"
             )
             return 0
-        try:
-            merge_pull(pr_number, dry_run=dry_run)
-        except MergePermissionError as exc:
-            # Permanent merge failure (HTTP 403/404/405). Post a comment so
-            # maintainers know why, then return 0 so this tick is done.
-            # The PR stays in the queue; future ticks can retry after the
-            # permission issue is resolved.
-            sys.stderr.write(f"::error::merge permission error for PR #{pr_number}: {exc}\n")
-            post_comment(
-                pr_number,
-                (
-                    "merge-queue: merge failed with HTTP 405 'User not allowed to merge PR'. "
-                    "No available token has Can-merge permission on this repo. "
-                    "Fix: grant Can-merge to a token, or add a maintain/admin collaborator. "
-                    "Skipping to next queued PR on next tick."
-                ),
-                dry_run=dry_run,
-            )
-            return 0
+        merge_pull(pr_number, dry_run=dry_run)
         return 0
     return 0
 

.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
 
 
 # ---------------------------------------------------------------------------
@@ -110,7 +110,7 @@ def normalize_slug(raw: str, numeric_aliases: dict[int, str] | None = None) -> s
 # for /sop-revoke (RFC#351 open question 4 — reason is captured but not
 # yet validated; future iteration may require a min-length).
 _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,
 )
 
@@ -118,21 +118,19 @@ _DIRECTIVE_RE = re.compile(
 def parse_directives(
     comment_body: str,
     numeric_aliases: dict[int, str],
-) -> 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.
+) -> tuple[list[tuple[str, str, str]], list]:
+    """Extract /sop-ack and /sop-revoke 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 (directives, na_directives) where:
+      directives is a list of (kind, canonical_slug, note) tuples
+        kind is "sop-ack" or "sop-revoke"
+        canonical_slug is the normalized form (or "" if unparseable)
+        note is the trailing free-text (may be "")
+      na_directives is reserved for future N/A handling (always [] for now)
     """
-    directives: list[tuple[str, str, str]] = []
-    na_directives: list[tuple[str, str, str]] = []
+    out: list[tuple[str, str, str]] = []
     if not comment_body:
-        return directives, na_directives
+        return out, []
     for m in _DIRECTIVE_RE.finditer(comment_body):
         kind = m.group(1)
         raw_slug = (m.group(2) or "").strip()
@@ -162,12 +160,8 @@ def parse_directives(
         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))
+    return out, []
 
 
 # ---------------------------------------------------------------------------
@@ -180,8 +174,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 +184,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 +202,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)
 
 
 # ---------------------------------------------------------------------------
@@ -297,7 +251,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 = 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
@@ -349,63 +304,6 @@ 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]],
-) -> dict[str, dict[str, Any]]:
-    """Evaluate which N/A gates have a valid declaration from a team member.
-
-    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
-    """
-    # Build per-user latest N/A directive (most-recent wins per RFC#324).
-    latest_na: dict[str, tuple[str, str]] = {}  # user → (gate, note)
-    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:
-                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
-
-    return result
-
-
 # ---------------------------------------------------------------------------
 # Gitea API client
 # ---------------------------------------------------------------------------
@@ -800,7 +698,6 @@ 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")
     }
@@ -921,46 +818,6 @@ def main(argv: list[str] | None = None) -> int:
         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_gitea_merge_queue.py

@@ -118,13 +118,3 @@ def test_merge_decision_updates_stale_pr_before_merge():
 
     assert decision.ready is False
     assert decision.action == "update"
-
-
-def test_MergePermissionError_inherits_from_ApiError():
-    assert issubclass(mq.MergePermissionError, mq.ApiError)
-
-
-def test_MergePermissionError_message_preserved():
-    exc = mq.MergePermissionError("POST /merge -> HTTP 405: User not allowed")
-    assert "405" in str(exc)
-    assert "User not allowed" in str(exc)

.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

@@ -145,10 +145,10 @@ jobs:
     # the diagnostic step with its own continue-on-error: true (line 203).
     # Flip confirmed by CI / Platform (Go) status = success on main HEAD 363905d3.
     continue-on-error: false
-    # Job-level ceiling. The go test step below runs with a per-step 30m timeout;
-    # this cap catches any step that leaks past that. Set well above 30m so
+    # Job-level ceiling. The go test step below runs with a per-step 10m timeout;
+    # this cap catches any step that leaks past that. Set well above 10m so
     # the per-step timeout is the active constraint.
-    timeout-minutes: 35
+    timeout-minutes: 15
     defaults:
       run:
         working-directory: workspace-server
@@ -176,14 +176,12 @@ jobs:
         name: Run golangci-lint
         run: $(go env GOPATH)/bin/golangci-lint run --timeout 3m ./...
       - if: always()
-        name: Diagnostic — per-package verbose (300s timeout)
+        name: Diagnostic — per-package verbose 60s
         run: |
           set +e
-          # 300s allows handlers + pendinguploads packages to complete on cold
-          # runners with -race instrumentation (~60-120s each vs ~14s non-race).
-          go test -race -v -timeout 300s ./internal/handlers/... 2>&1 | tee /tmp/test-handlers.log
+          go test -race -v -timeout 60s ./internal/handlers/... 2>&1 | tee /tmp/test-handlers.log
           handlers_exit=$?
-          go test -race -v -timeout 300s ./internal/pendinguploads/... 2>&1 | tee /tmp/test-pu.log
+          go test -race -v -timeout 60s ./internal/pendinguploads/... 2>&1 | tee /tmp/test-pu.log
           pu_exit=$?
           echo "::group::handlers exit=$handlers_exit (last 100 lines)"
           tail -100 /tmp/test-handlers.log
@@ -196,10 +194,10 @@ jobs:
       - if: always()
         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 30m per-step timeout
-        # lets the suite complete on cold cache (~13-25m) while failing cleanly
-        # instead of OOM-killing. The job-level timeout (35m) is a backstop.
-        run: go test -race -timeout 30m -coverprofile=coverage.out ./...
+        # full ./... suite with race detection + coverage. A 10m per-step timeout
+        # lets the suite complete on cold cache (~5-7m) while failing cleanly
+        # instead of OOM-killing. The job-level timeout (15m) is a backstop.
+        run: go test -race -timeout 10m -coverprofile=coverage.out ./...
 
       - if: always()
         name: Per-file coverage report

.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

canvas/src/app/orgs/page.tsx

@@ -212,7 +212,7 @@ function AccountBar({ session }: { session: Session }) {
           // edge cases (jsdom, blocked navigation) where it doesn't.
           setSigningOut(false);
         }}
-        className="rounded border border-line bg-surface-card px-3 py-1 text-xs text-ink hover:bg-surface-card disabled:opacity-50"
+        className="rounded border border-line bg-surface-card px-3 py-1 text-xs text-ink hover:bg-surface-card disabled:opacity-50 focus:outline-none focus-visible:ring-2 focus-visible:ring-accent/40 focus-visible:ring-offset-1"
         aria-label="Sign out"
       >
         {signingOut ? "Signing out…" : "Sign out"}

canvas/src/components/BroadcastBanner.tsx

@@ -0,0 +1,100 @@
+"use client";
+
+import { useCallback } from "react";
+import { useCanvasStore } from "@/store/canvas";
+
+/** Org-wide broadcast banner.
+ *
+ * Rendered at the top of the canvas (below the toolbar) whenever the store
+ * holds one or more unread BROADCAST_MESSAGE entries. Each entry shows:
+ *   - sender name (workspace that issued the broadcast)
+ *   - the message text
+ *   - a dismiss button
+ *
+ * Dismissing an entry removes it from the store via consumeBroadcastMessages.
+ * The dismissed state is intentionally ephemeral — dismissed broadcasts reappear
+ * on page refresh since they are not persisted server-side; this is intentional
+ * (the platform's activity log already provides the audit trail).
+ */
+export function BroadcastBanner() {
+  const broadcastMessages = useCanvasStore((s) => s.broadcastMessages);
+  const dismissBroadcastMessage = useCanvasStore((s) => s.dismissBroadcastMessage);
+
+  const handleDismiss = useCallback(
+    (id: string) => {
+      dismissBroadcastMessage(id);
+    },
+    [dismissBroadcastMessage],
+  );
+
+  if (broadcastMessages.length === 0) return null;
+
+  return (
+    <div className="fixed top-16 left-1/2 -translate-x-1/2 z-30 flex flex-col gap-2 items-center w-full max-w-xl px-4 pointer-events-none">
+      {broadcastMessages.map((msg) => (
+        <div
+          key={msg.id}
+          role="alert"
+          aria-live="polite"
+          aria-atomic="true"
+          className="pointer-events-auto w-full bg-blue-950/80 backdrop-blur-md border border-blue-700/50 rounded-xl px-5 py-3 shadow-2xl shadow-black/40 animate-in slide-in-from-top duration-300"
+        >
+          <div className="flex items-start gap-3">
+            {/* Megaphone icon */}
+            <div
+              aria-hidden="true"
+              className="w-7 h-7 rounded-lg bg-blue-900/50 flex items-center justify-center shrink-0 mt-0.5"
+            >
+              <svg
+                width="14"
+                height="14"
+                viewBox="0 0 24 24"
+                fill="none"
+                stroke="currentColor"
+                strokeWidth="2"
+                strokeLinecap="round"
+                strokeLinejoin="round"
+                className="text-blue-300"
+              >
+                <path d="M3 11l18-5v12L3 13v-2z" />
+                <path d="M11.6 16.8a3 3 0 1 1-5.8-1.6" />
+              </svg>
+            </div>
+
+            <div className="flex-1 min-w-0">
+              <div className="text-xs text-blue-300 font-semibold">
+                Broadcast from{" "}
+                <span className="text-blue-100">{msg.sender}</span>
+              </div>
+              <div className="text-sm text-blue-50 mt-0.5 leading-snug break-words">
+                {msg.message}
+              </div>
+            </div>
+
+            {/* Dismiss button */}
+            <button
+              type="button"
+              onClick={() => handleDismiss(msg.id)}
+              aria-label="Dismiss broadcast"
+              className="shrink-0 w-6 h-6 rounded text-blue-400 hover:text-blue-200 hover:bg-blue-800/50 flex items-center justify-center transition-colors focus:outline-none focus-visible:ring-2 focus-visible:ring-blue-400 focus-visible:ring-offset-1 focus-visible:ring-offset-blue-950"
+            >
+              <svg
+                width="12"
+                height="12"
+                viewBox="0 0 24 24"
+                fill="none"
+                stroke="currentColor"
+                strokeWidth="2.5"
+                strokeLinecap="round"
+                strokeLinejoin="round"
+                aria-hidden="true"
+              >
+                <path d="M18 6 6 18M6 6l12 12" />
+              </svg>
+            </button>
+          </div>
+        </div>
+      ))}
+    </div>
+  );
+}

canvas/src/components/Canvas.tsx

@@ -21,6 +21,7 @@ import { CreateWorkspaceButton } from "./CreateWorkspaceDialog";
 import { ContextMenu } from "./ContextMenu";
 import { TemplatePalette } from "./TemplatePalette";
 import { ApprovalBanner } from "./ApprovalBanner";
+import { BroadcastBanner } from "./BroadcastBanner";
 import { BundleDropZone } from "./BundleDropZone";
 import { EmptyState } from "./EmptyState";
 import { OnboardingWizard } from "./OnboardingWizard";
@@ -367,6 +368,7 @@ function CanvasInner() {
         <OnboardingWizard />
         <Toolbar />
         <ApprovalBanner />
+        <BroadcastBanner />
         <BundleDropZone />
         <TemplatePalette />
         <SidePanel />

canvas/src/components/MissingKeysModal.tsx

@@ -471,7 +471,7 @@ function ProviderPickerModal({
             {onOpenSettings && (
               <button
                 onClick={onOpenSettings}
-                className="text-[11px] text-accent hover:text-accent transition-colors"
+                className="text-[11px] text-accent hover:text-accent transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-accent focus-visible:ring-offset-1"
               >
                 Open Settings Panel
               </button>
@@ -480,7 +480,7 @@ function ProviderPickerModal({
           <div className="flex items-center gap-2">
             <button
               onClick={onCancel}
-              className="px-3.5 py-1.5 text-[12px] text-ink-mid hover:text-ink bg-surface-card hover:bg-surface-card border border-line rounded-lg transition-colors"
+              className="px-3.5 py-1.5 text-[12px] text-ink-mid hover:text-ink bg-surface-card hover:bg-surface-card border border-line rounded-lg transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-accent focus-visible:ring-offset-1"
             >
               Cancel Deploy
             </button>

canvas/src/components/__tests__/AuditTrailPanel.format.test.ts

@@ -1,55 +0,0 @@
-// @vitest-environment jsdom
-/**
- * Tests for formatAuditRelativeTime exported from AuditTrailPanel.
- */
-import { describe, it, expect } from "vitest";
-import { formatAuditRelativeTime } from "../AuditTrailPanel";
-
-describe("formatAuditRelativeTime", () => {
-  const now = new Date("2026-05-18T12:00:00Z").getTime();
-
-  it('returns "just now" for timestamps less than 60s ago', () => {
-    const ts = new Date(now - 30_000).toISOString(); // 30s ago
-    expect(formatAuditRelativeTime(ts, now)).toBe("just now");
-  });
-
-  it("returns minutes for timestamps under 1h", () => {
-    const ts = new Date(now - 5 * 60_000).toISOString(); // 5m ago
-    expect(formatAuditRelativeTime(ts, now)).toBe("5m ago");
-  });
-
-  it("returns hours for timestamps under 24h", () => {
-    const ts = new Date(now - 3 * 3_600_000).toISOString(); // 3h ago
-    expect(formatAuditRelativeTime(ts, now)).toBe("3h ago");
-  });
-
-  it("returns locale date for timestamps older than 24h", () => {
-    const ts = new Date(now - 2 * 86_400_000).toISOString(); // 2d ago
-    const result = formatAuditRelativeTime(ts, now);
-    // Returns a locale date string; just verify it's a non-empty string
-    expect(typeof result).toBe("string");
-    expect(result.length).toBeGreaterThan(0);
-    expect(result).not.toBe("just now");
-    expect(result).not.toMatch(/m ago$/);
-    expect(result).not.toMatch(/h ago$/);
-  });
-
-  it("handles exactly 60s boundary as minutes", () => {
-    const ts = new Date(now - 60_000).toISOString(); // exactly 1m ago
-    expect(formatAuditRelativeTime(ts, now)).toBe("1m ago");
-  });
-
-  it("handles exactly 3600s boundary as hours", () => {
-    const ts = new Date(now - 3_600_000).toISOString(); // exactly 1h ago
-    expect(formatAuditRelativeTime(ts, now)).toBe("1h ago");
-  });
-
-  it("handles exactly 86400s boundary", () => {
-    const ts = new Date(now - 86_400_000).toISOString(); // exactly 24h ago
-    const result = formatAuditRelativeTime(ts, now);
-    // Exactly 24h should fall into the "days" branch
-    expect(typeof result).toBe("string");
-    expect(result).not.toMatch(/m ago$/);
-    expect(result).not.toMatch(/h ago$/);
-  });
-});

canvas/src/components/__tests__/BroadcastBanner.test.tsx

@@ -0,0 +1,111 @@
+// @vitest-environment jsdom
+/**
+ * Tests for BroadcastBanner component.
+ * WCAG compliance: role=alert, aria-live=polite, per-message dismiss.
+ */
+import { describe, it, expect, vi, afterEach, beforeEach } from "vitest";
+import { render, screen, cleanup, fireEvent } from "@testing-library/react";
+import { BroadcastBanner } from "../BroadcastBanner";
+import { useCanvasStore } from "@/store/canvas";
+
+const mockDismiss = vi.fn();
+
+vi.mock("@/store/canvas", () => ({
+  useCanvasStore: vi.fn((selector: (s: ReturnType<typeof useCanvasStore.getState>) => unknown) => {
+    const state = {
+      broadcastMessages: [] as Array<{
+        id: string;
+        senderId: string;
+        sender: string;
+        message: string;
+        timestamp: string;
+      }>,
+      dismissBroadcastMessage: mockDismiss,
+    };
+    return selector(state);
+  }),
+}));
+
+afterEach(() => {
+  cleanup();
+  mockDismiss.mockClear();
+  vi.clearAllMocks();
+});
+
+const broadcastMessages = [
+  { id: "m1", senderId: "ws-ops", sender: "Ops Agent", message: "Deploy in 5 min", timestamp: "2026-05-16T00:00:00Z" },
+  { id: "m2", senderId: "ws-sre", sender: "SRE Team", message: "Maintenance window tonight", timestamp: "2026-05-16T00:01:00Z" },
+];
+
+function setup(messages = broadcastMessages) {
+  vi.mocked(useCanvasStore).mockImplementation(
+    (selector: (s: { broadcastMessages: typeof broadcastMessages; dismissBroadcastMessage: typeof mockDismiss }) => unknown) => {
+      const state = {
+        broadcastMessages: messages,
+        dismissBroadcastMessage: mockDismiss,
+      };
+      return selector(state);
+    }
+  );
+  return render(<BroadcastBanner />);
+}
+
+describe("BroadcastBanner", () => {
+  it("renders nothing when there are no messages", () => {
+    setup([]);
+    expect(screen.queryByRole("alert")).toBeNull();
+  });
+
+  it("renders a role=alert banner for each broadcast message", () => {
+    setup();
+    const alerts = screen.getAllByRole("alert");
+    expect(alerts).toHaveLength(2);
+  });
+
+  it("shows sender name and message content", () => {
+    setup();
+    expect(screen.getByText("Deploy in 5 min")).toBeTruthy();
+    expect(screen.getByText("Ops Agent")).toBeTruthy();
+    expect(screen.getByText("Maintenance window tonight")).toBeTruthy();
+    expect(screen.getByText("SRE Team")).toBeTruthy();
+  });
+
+  it("each banner has a dismiss button with accessible label", () => {
+    setup();
+    const buttons = screen.getAllByRole("button", { name: /dismiss/i });
+    expect(buttons).toHaveLength(2);
+  });
+
+  it("dismissing a banner calls dismissBroadcastMessage with the correct id", () => {
+    setup();
+    const buttons = screen.getAllByRole("button", { name: /dismiss/i });
+    // Dismiss the second message (Maintenance window)
+    fireEvent.click(buttons[1]);
+    expect(mockDismiss).toHaveBeenCalledTimes(1);
+    expect(mockDismiss).toHaveBeenCalledWith("m2");
+  });
+
+  it("dismissing one banner does not dismiss others", () => {
+    setup();
+    const buttons = screen.getAllByRole("button", { name: /dismiss/i });
+    fireEvent.click(buttons[0]);
+    expect(mockDismiss).toHaveBeenCalledWith("m1");
+    expect(mockDismiss).toHaveBeenCalledTimes(1);
+  });
+
+  it("dismiss button has focus-visible ring (WCAG 2.4.7)", () => {
+    setup();
+    const button = screen.getAllByRole("button", { name: /dismiss/i })[0];
+    expect(button.className).toContain("focus-visible:ring");
+  });
+
+  it("sender and message text use adequate contrast color classes", () => {
+    setup();
+    // text-blue-300 (#93C5FD) on blue-950/80 ≈ 5.9:1 contrast — WCAG AA ✓
+    const senderLabel = screen.getByText("Ops Agent").closest("div");
+    expect(senderLabel?.className).toContain("text-blue-300");
+    // text-blue-50 (#EFF6FF) on blue-950/80 ≈ 11.7:1 — WCAG AAA ✓
+    const messageEl = screen.getByText("Deploy in 5 min");
+    expect(messageEl.className).toContain("text-blue-50");
+  });
+});

canvas/src/components/__tests__/Canvas.a11y.test.tsx

@@ -73,6 +73,8 @@ const mockStoreState = {
   clearSelection: vi.fn(),
   toggleNodeSelection: vi.fn(),
   deletingIds: new Set<string>(),
+  broadcastMessages: [],
+  consumeBroadcastMessages: vi.fn(() => []),
 };
 
 vi.mock("@/store/canvas", () => ({
@@ -100,6 +102,7 @@ vi.mock("../ConfirmDialog", () => ({ ConfirmDialog: () => null }));
 vi.mock("../TemplatePalette", () => ({ TemplatePalette: () => null }));
 vi.mock("../OnboardingWizard", () => ({ OnboardingWizard: () => null }));
 vi.mock("../ApprovalBanner", () => ({ ApprovalBanner: () => null }));
+vi.mock("../BroadcastBanner", () => ({ BroadcastBanner: () => null }));
 vi.mock("../BundleDropZone", () => ({ BundleDropZone: () => null }));
 vi.mock("../CreateWorkspaceDialog", () => ({ CreateWorkspaceButton: () => null }));
 vi.mock("../settings", () => ({

canvas/src/components/__tests__/Canvas.pan-to-node.test.tsx

@@ -91,6 +91,8 @@ const mockStoreState = {
   // an empty Set mirrors the idle canvas and doesn't interact with
   // any pan/fit behaviour under test here.
   deletingIds: new Set<string>(),
+  broadcastMessages: [],
+  consumeBroadcastMessages: vi.fn(() => []),
 };
 
 vi.mock("@/store/canvas", () => ({
@@ -117,6 +119,7 @@ vi.mock("../ConfirmDialog", () => ({ ConfirmDialog: () => null }));
 vi.mock("../TemplatePalette", () => ({ TemplatePalette: () => null }));
 vi.mock("../OnboardingWizard", () => ({ OnboardingWizard: () => null }));
 vi.mock("../ApprovalBanner", () => ({ ApprovalBanner: () => null }));
+vi.mock("../BroadcastBanner", () => ({ BroadcastBanner: () => null }));
 vi.mock("../BundleDropZone", () => ({ BundleDropZone: () => null }));
 vi.mock("../CreateWorkspaceDialog", () => ({ CreateWorkspaceButton: () => null }));
 vi.mock("../settings", () => ({

canvas/src/components/__tests__/MemoryInspectorPanel.helpers.test.ts

@@ -1,82 +0,0 @@
-// @vitest-environment jsdom
-/**
- * Tests for exported helpers from MemoryInspectorPanel:
- * isPluginUnavailableError, formatTTL.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { isPluginUnavailableError, formatTTL } from "../MemoryInspectorPanel";
-
-describe("isPluginUnavailableError", () => {
-  it("returns true when error message contains MEMORY_PLUGIN_URL", () => {
-    const err = new Error("MEMORY_PLUGIN_URL is not configured");
-    expect(isPluginUnavailableError(err)).toBe(true);
-  });
-
-  it("returns false when error message does not contain MEMORY_PLUGIN_URL", () => {
-    const err = new Error("Connection refused");
-    expect(isPluginUnavailableError(err)).toBe(false);
-  });
-
-  it("returns false for non-Error values", () => {
-    expect(isPluginUnavailableError("string error")).toBe(false);
-    expect(isPluginUnavailableError(null)).toBe(false);
-    expect(isPluginUnavailableError(undefined)).toBe(false);
-    expect(isPluginUnavailableError({})).toBe(false);
-  });
-
-  it("handles Error with empty message", () => {
-    expect(isPluginUnavailableError(new Error(""))).toBe(false);
-  });
-});
-
-describe("formatTTL", () => {
-  // Freeze time at 2026-05-18T12:00:00Z for deterministic tests.
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date("2026-05-18T12:00:00Z"));
-  });
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("returns empty string for null", () => {
-    expect(formatTTL(null)).toBe("");
-  });
-
-  it("returns empty string for undefined", () => {
-    expect(formatTTL(undefined)).toBe("");
-  });
-
-  it("returns empty string for empty string", () => {
-    expect(formatTTL("")).toBe("");
-  });
-
-  it("returns 'expired' for past timestamps", () => {
-    const past = new Date(Date.now() - 60_000).toISOString();
-    expect(formatTTL(past)).toBe("expired");
-  });
-
-  it("returns seconds for sub-minute future TTLs", () => {
-    const future = new Date(Date.now() + 30_000).toISOString();
-    expect(formatTTL(future)).toBe("30s");
-  });
-
-  it("returns minutes for sub-hour future TTLs", () => {
-    const future = new Date(Date.now() + 5 * 60_000).toISOString();
-    expect(formatTTL(future)).toBe("5m");
-  });
-
-  it("returns hours for sub-day future TTLs", () => {
-    const future = new Date(Date.now() + 3 * 3_600_000).toISOString();
-    expect(formatTTL(future)).toBe("3h");
-  });
-
-  it("returns days for TTLs longer than 24h", () => {
-    const future = new Date(Date.now() + 2 * 86_400_000).toISOString();
-    expect(formatTTL(future)).toBe("2d");
-  });
-
-  it("returns empty string for invalid date string", () => {
-    expect(formatTTL("not-a-date")).toBe("");
-  });
-});

canvas/src/components/__tests__/TestConnectionButton.test.tsx

@@ -11,21 +11,13 @@ import { render, screen, fireEvent, cleanup, act } from "@testing-library/react"
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { TestConnectionButton } from "../ui/TestConnectionButton";
 import type { SecretGroup } from "@/types/secrets";
-import { validateSecret, ApiError } from "@/lib/api/secrets";
+import { validateSecret } from "@/lib/api/secrets";
 
 // ─── Mock validateSecret ──────────────────────────────────────────────────────
 // vi.mock is hoisted, so validateSecret (imported above) refers to the mocked
 // namespace value once vi.mock runs. Use vi.mocked() to access it in tests.
 vi.mock("@/lib/api/secrets", () => ({
   validateSecret: vi.fn(),
-  ApiError: class ApiError extends Error {
-    status: number;
-    constructor(status: number, message: string) {
-      super(message);
-      this.name = "ApiError";
-      this.status = status;
-    }
-  },
 }));
 
 // SecretGroup is a string literal type: 'github' | 'anthropic' | 'openrouter' | 'custom'
@@ -110,7 +102,7 @@ describe("TestConnectionButton — state machine", () => {
     expect(screen.getByText("Permission denied")).toBeTruthy();
   });
 
-  it("shows a connectivity message on a genuine network exception", async () => {
+  it("shows generic error message on unexpected exception", async () => {
     vi.mocked(validateSecret).mockRejectedValue(new Error("timeout"));
     render(<TestConnectionButton provider={toGroup("anthropic")} secretValue="sk-..." />);
 
@@ -118,23 +110,8 @@ describe("TestConnectionButton — state machine", () => {
     await act(async () => { /* flush */ });
 
     expect(screen.getByRole("alert")).toBeTruthy();
-    // A real thrown network error → honest connectivity message (not a
-    // fabricated "service down"); see internal#492.
-    expect(document.body.querySelector('[role="alert"]')?.textContent).toMatch(
-      /could not reach the validation service/i,
-    );
-  });
-
-  it("does not claim a timeout when the validate endpoint 404s (internal#492)", async () => {
-    vi.mocked(validateSecret).mockRejectedValue(new ApiError(404, "Not Found"));
-    render(<TestConnectionButton provider={toGroup("anthropic")} secretValue="sk-..." />);
-
-    fireEvent.click(screen.getByRole("button"));
-    await act(async () => { /* flush */ });
-
-    const alert = document.body.querySelector('[role="alert"]')?.textContent ?? "";
-    expect(alert).not.toMatch(/timed out/i);
-    expect(alert).toMatch(/not available/i);
+    // The error detail is hardcoded to "Connection timed out. Service may be down."
+    expect(document.body.querySelector('[role="alert"]')?.textContent).toMatch(/timed out/i);
   });
 });
 

canvas/src/components/__tests__/ThemeToggle.test.tsx

@@ -24,12 +24,8 @@ vi.mock("@/lib/theme-provider", () => ({
   })),
 }));
 
-// Wrap cleanup in act() so any pending React state updates (e.g. from
-// keyDown handlers that call setTheme) flush before DOM unmount. Without
-// this, cleanup() can race against pending renders and cause INDEX_SIZE_ERR
-// when the handleKeyDown callback tries to query the DOM mid-teardown.
 afterEach(() => {
-  act(() => { cleanup(); });
+  cleanup();
   vi.clearAllMocks();
 });
 
@@ -150,7 +146,7 @@ describe("ThemeToggle — keyboard navigation (WCAG 2.1.1 / ARIA radiogroup)", (
     const radios = screen.getAllByRole("radio");
     // dark (index 2) is current; ArrowRight should wrap to light (index 0)
     act(() => { radios[2].focus(); });
-    act(() => { fireEvent.keyDown(radios[2], { key: "ArrowRight" }); });
+    fireEvent.keyDown(radios[2], { key: "ArrowRight" });
     expect(mockSetTheme).toHaveBeenCalledWith("light");
   });
 
@@ -164,7 +160,7 @@ describe("ThemeToggle — keyboard navigation (WCAG 2.1.1 / ARIA radiogroup)", (
     const radios = screen.getAllByRole("radio");
     // light (index 0) is current; ArrowLeft should go to dark (index 2)
     act(() => { radios[0].focus(); });
-    act(() => { fireEvent.keyDown(radios[0], { key: "ArrowLeft" }); });
+    fireEvent.keyDown(radios[0], { key: "ArrowLeft" });
     expect(mockSetTheme).toHaveBeenCalledWith("dark");
   });
 
@@ -178,7 +174,7 @@ describe("ThemeToggle — keyboard navigation (WCAG 2.1.1 / ARIA radiogroup)", (
     const radios = screen.getAllByRole("radio");
     // light (index 0) is current; ArrowDown should go to system (index 1)
     act(() => { radios[0].focus(); });
-    act(() => { fireEvent.keyDown(radios[0], { key: "ArrowDown" }); });
+    fireEvent.keyDown(radios[0], { key: "ArrowDown" });
     expect(mockSetTheme).toHaveBeenCalledWith("system");
   });
 
@@ -191,7 +187,7 @@ describe("ThemeToggle — keyboard navigation (WCAG 2.1.1 / ARIA radiogroup)", (
     render(<ThemeToggle />);
     const radios = screen.getAllByRole("radio");
     act(() => { radios[2].focus(); });
-    act(() => { fireEvent.keyDown(radios[2], { key: "Home" }); });
+    fireEvent.keyDown(radios[2], { key: "Home" });
     expect(mockSetTheme).toHaveBeenCalledWith("light");
   });
 
@@ -204,14 +200,14 @@ describe("ThemeToggle — keyboard navigation (WCAG 2.1.1 / ARIA radiogroup)", (
     render(<ThemeToggle />);
     const radios = screen.getAllByRole("radio");
     act(() => { radios[0].focus(); });
-    act(() => { fireEvent.keyDown(radios[0], { key: "End" }); });
+    fireEvent.keyDown(radios[0], { key: "End" });
     expect(mockSetTheme).toHaveBeenCalledWith("dark");
   });
 
   it("does nothing on unrelated keys", () => {
     render(<ThemeToggle />);
     const radios = screen.getAllByRole("radio");
-    act(() => { fireEvent.keyDown(radios[0], { key: "Enter" }); });
+    fireEvent.keyDown(radios[0], { key: "Enter" });
     expect(mockSetTheme).not.toHaveBeenCalled();
   });
 });

canvas/src/components/canvas/__tests__/DropTargetBadge.test.tsx

@@ -195,6 +195,47 @@ describe("DropTargetBadge — renders ghost slot + badge for valid drag target",
     expect(screen.getByTestId("ghost-slot").style.height).toBe("260px");
   });
 
+  it("ghost has aria-hidden=true (decorative visual affordance)", () => {
+    _getInternalNode.mockReturnValue({
+      internals: { positionAbsolute: { x: 100, y: 200 } },
+      measured: { width: 220, height: 500 },
+    });
+    setFlowMock(({ x, y }: { x: number; y: number }) => {
+      if (x === 210 && y === 200) return { x: 420, y: 400 };
+      if (x === 116 && y === 330) return { x: 232, y: 660 };
+      if (x === 356 && y === 460) return { x: 712, y: 920 };
+      if (x === 100 && y === 200) return { x: 200, y: 400 };
+      if (x === 320 && y === 700) return { x: 640, y: 1400 };
+      return { x: x * 2, y: y * 2 };
+    });
+
+    setStore({
+      dragOverNodeId: "ws-target",
+      nodes: [
+        { id: "ws-target", data: { name: "Target" }, parentId: null, measured: { width: 220, height: 500 } },
+      ],
+    });
+    render(<DropTargetBadge />);
+    const ghost = screen.getByTestId("ghost-slot");
+    expect(ghost.getAttribute("aria-hidden")).toBe("true");
+  });
+
+  it("drop badge has role=status and aria-label including target name", () => {
+    _getInternalNode.mockReturnValue({
+      internals: { positionAbsolute: { x: 100, y: 200 } },
+      measured: { width: 220, height: 120 },
+    });
+    setFlowMock(({ x, y }: { x: number; y: number }) => ({ x: x * 2, y: y * 2 }));
+    setStore({
+      dragOverNodeId: "ws-target",
+      nodes: [{ id: "ws-target", data: { name: "Ops Workspace" }, parentId: null }],
+    });
+    render(<DropTargetBadge />);
+    const badge = screen.getByTestId("drop-badge");
+    expect(badge.getAttribute("role")).toBe("status");
+    expect(badge.getAttribute("aria-label")).toBe("Drop target: Ops Workspace");
+  });
+
   it("ghost is hidden when slot falls entirely outside parent bounds", () => {
     _getInternalNode.mockReturnValue({
       internals: { positionAbsolute: { x: 100, y: 200 } },

canvas/src/components/mobile/MobileCanvas.tsx

@@ -205,6 +205,7 @@ export function MobileCanvas({
           type="button"
           onClick={resetView}
           aria-label="Reset zoom"
+          className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-2 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
           style={{
             position: "absolute",
             right: 14,
@@ -272,6 +273,7 @@ export function MobileCanvas({
             key={l.agent.id}
             type="button"
             onClick={() => onOpen(l.agent.id)}
+            className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-1 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
             style={{
               position: "absolute",
               left: `${l.x}%`,
@@ -376,6 +378,7 @@ export function MobileCanvas({
         type="button"
         onClick={onSpawn}
         aria-label="Spawn new agent"
+        className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-2 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
         style={{
           position: "absolute",
           right: 24,

canvas/src/components/mobile/MobileChat.tsx

@@ -2,31 +2,25 @@
 
 // 04 · Chat — message thread + composer + sub-tabs.
 // Wired to the same /workspaces/:id/a2a (method message/send) endpoint
-// that the desktop ChatTab uses. Render parity with desktop ChatTab is
-// achieved by reusing its renderers rather than forking a reduced
-// mobile path: the Agent Comms sub-tab mounts the same AgentCommsPanel,
-// and message attachments route through the same AttachmentPreview
-// dispatch the desktop My-Chat bubble uses (#231/#232).
+// that the desktop ChatTab uses, but with a slimmer surface: no
+// 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 { AgentCommsPanel } from "@/components/tabs/chat/AgentCommsPanel";
-import { AttachmentPreview } from "@/components/tabs/chat/AttachmentPreview";
-import { downloadChatFile } from "@/components/tabs/chat/uploads";
 
 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 "";
@@ -35,171 +29,29 @@ 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 };
 }
 
+// Wire shape for GET /workspaces/:id/chat-history (chat_history.go → ChatHistoryResponse).
+interface ApiChatMessage {
+  id: string;
+  role: string; // "user" | "agent" | "system"
+  content: string;
+  timestamp: string;
+}
+
+interface ChatHistoryResponse {
+  messages: ApiChatMessage[];
+  reached_end: boolean;
+}
+
+const formatTime = (date: Date) =>
+  date.toLocaleTimeString([], { hour: "numeric", minute: "2-digit" });
+
 export function MobileChat({
   agentId,
   dark,
@@ -210,42 +62,31 @@ 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]);
+  // Start empty — history is loaded via useEffect below.
+  const [messages, setMessages] = useState<ChatMessage[]>([]);
   const [draft, setDraft] = useState("");
   const [tab, setTab] = useState<SubTab>("my");
+  const [sending, setSending] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [loading, setLoading] = useState(true); // history is loading on mount
+  const [historyError, setHistoryError] = useState<string | null>(null);
   const scrollRef = useRef<HTMLDivElement>(null);
+  // Guard: don't treat the initial store population as a live push.
+  // Set to false after the first render completes.
+  const initDoneRef = 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,
-    // Fan-out user's own outbound message to all sessions (issue #228).
-    onUserMessage: 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
@@ -258,26 +99,81 @@ export function MobileChat({
     el.style.height = `${next}px`;
   }, [draft]);
 
+  // Fetch chat history on mount; keep merging live agentMessages while the
+  // panel is open. InitDoneRef prevents the initial store snapshot from
+  // triggering the live-merge path (the store buffer is populated by
+  // ChatTab on desktop, not on mobile — this effect loads history as the
+  // mobile-native path).
+  useEffect(() => {
+    let cancelled = false;
+
+    const mapApiMessage = (m: ApiChatMessage): ChatMessage => ({
+      id: m.id,
+      role: m.role === "user" ? "user" : "agent",
+      text: m.content,
+      ts: formatStoredTimestamp(m.timestamp),
+    });
+
+    const syncLive = () => {
+      const live = useCanvasStore.getState().agentMessages[agentId] ?? [];
+      if (live.length > 0) {
+        setMessages((prev) => {
+          const existingIds = new Set(prev.map((m) => m.id));
+          const newOnes = live
+            .filter((m) => !existingIds.has(m.id))
+            .map((m) => ({
+              id: m.id,
+              role: "agent" as const,
+              text: m.content,
+              ts: formatStoredTimestamp(m.timestamp),
+            }));
+          return newOnes.length > 0 ? [...prev, ...newOnes] : prev;
+        });
+      }
+    };
+
+    const bootstrap = async (): Promise<(() => void) | undefined> => {
+      setLoading(true);
+      setHistoryError(null);
+      try {
+        const res = await api.get<ChatHistoryResponse>(
+          `/workspaces/${agentId}/chat-history?limit=50`,
+        );
+        if (cancelled) return;
+        const initial = (res.messages ?? []).map(mapApiMessage);
+        setMessages(initial);
+        // Mark init done BEFORE marking loading=false so any store push
+        // that arrives in the same tick is treated as live, not init.
+        initDoneRef.current = true;
+        setLoading(false);
+        // Subscribe to live pushes after init is complete.
+        syncLive();
+        const unsubscribe = useCanvasStore.subscribe(syncLive);
+        return unsubscribe; // returned for cleanup
+      } catch (e) {
+        if (cancelled) return;
+        setHistoryError(e instanceof Error ? e.message : "Failed to load chat history");
+        setLoading(false);
+        initDoneRef.current = true;
+        return undefined;
+      }
+    };
+
+    let maybeUnsubscribe: (() => void) | undefined;
+    bootstrap().then((fn) => { maybeUnsubscribe = fn; });
+
+    return () => {
+      cancelled = true;
+      if (maybeUnsubscribe) maybeUnsubscribe();
+    };
+  }, [agentId]);
+
   useEffect(() => {
     if (scrollRef.current) {
       scrollRef.current.scrollTop = scrollRef.current.scrollHeight;
     }
   }, [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
@@ -299,38 +195,51 @@ 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));
-
-  // Route attachment downloads through the same authenticated helper
-  // the desktop ChatTab uses (downloadChatFile) so platform-scheme
-  // URIs get a real Blob with auth headers instead of about:blank.
-  const downloadAttachment = (att: ChatAttachment) => {
-    downloadChatFile(agentId, att).catch(() => {
-      // AttachmentPreview's own error affordance covers the in-bubble
-      // failure state; matches ChatTab's behaviour of not double-
-      // reporting a download failure.
-    });
-  };
-
   const send = async () => {
     const text = draft.trim();
-    if ((!text && pendingFiles.length === 0) || sending || !reachable) return;
-    clearError();
+    if (!text || sending || !reachable) return;
     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);
+    }
   };
 
   return (
@@ -358,6 +267,7 @@ export function MobileChat({
             type="button"
             onClick={onBack}
             aria-label="Back"
+            className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-2 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
             style={{
               width: 36,
               height: 36,
@@ -404,6 +314,7 @@ export function MobileChat({
           <button
             type="button"
             aria-label="More"
+            className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-2 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
             style={{
               width: 36,
               height: 36,
@@ -434,6 +345,7 @@ export function MobileChat({
                 key={t.id}
                 type="button"
                 onClick={() => setTab(t.id)}
+                className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-2 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
                 style={{
                   padding: "4px 0 8px",
                   border: "none",
@@ -452,19 +364,7 @@ export function MobileChat({
         </div>
       </div>
 
-      {/* Agent Comms — reuse the desktop AgentCommsPanel verbatim so
-          mobile renders the identical peer/A2A + delegation feed
-          (history GET + live socket events) instead of a placeholder
-          (#231). The panel owns its own scroll/load/error/empty
-          states, matching ChatTab's agent-comms tabpanel. */}
-      {tab === "a2a" && (
-        <div style={{ flex: 1, minHeight: 0, overflow: "hidden" }}>
-          <AgentCommsPanel workspaceId={agentId} />
-        </div>
-      )}
-
       {/* Messages */}
-      {tab === "my" && (
       <div
         ref={scrollRef}
         style={{
@@ -476,12 +376,25 @@ export function MobileChat({
           gap: 8,
         }}
       >
-        {tab === "my" && historyLoading && (
-          <div style={{ padding: "20px 4px", textAlign: "center", color: p.text3, fontSize: 13 }}>
-            Loading chat history…
+        {tab === "a2a" && (
+          <div
+            style={{
+              padding: "20px 4px",
+              textAlign: "center",
+              color: p.text3,
+              fontSize: 13,
+            }}
+          >
+            Agent Comms — peer-to-peer A2A traffic surfaces in the Comms tab.
           </div>
         )}
-        {tab === "my" && !historyLoading && historyError && messages.length === 0 && (
+        {tab === "my" && loading && (
+          <div style={{ padding: "20px 4px", textAlign: "center", color: p.text3, fontSize: 13 }}>
+            <div style={{ marginBottom: 6, opacity: 0.6, animation: "spin 1s linear infinite", display: "inline-block", fontSize: 16 }}>⟳</div>
+            <div>Loading chat history…</div>
+          </div>
+        )}
+        {tab === "my" && !loading && historyError && (
           <div
             role="alert"
             style={{
@@ -494,9 +407,29 @@ export function MobileChat({
             <div style={{ marginBottom: 8 }}>Could not load chat history.</div>
             <button
               type="button"
+              aria-label="Retry loading chat history"
               onClick={() => {
-                loadInitial();
+                setLoading(true);
+                setHistoryError(null);
+                api.get(`/workspaces/${agentId}/chat-history?limit=50`).then(
+                  (res: unknown) => {
+                    const r = res as ChatHistoryResponse;
+                    setMessages((r.messages ?? []).map((m) => ({
+                      id: m.id,
+                      role: m.role === "user" ? "user" : "agent",
+                      text: m.content,
+                      ts: formatStoredTimestamp(m.timestamp),
+                    })));
+                    setLoading(false);
+                    initDoneRef.current = true;
+                  },
+                ).catch((e: unknown) => {
+                  setHistoryError(e instanceof Error ? e.message : "Failed to load");
+                  setLoading(false);
+                  initDoneRef.current = true;
+                });
               }}
+              className="focus:outline-none focus-visible:ring-2 focus-visible:ring-[var(--color-failed,#ef4444)] focus-visible:ring-offset-1 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
               style={{
                 padding: "6px 14px",
                 borderRadius: 14,
@@ -511,7 +444,7 @@ export function MobileChat({
             </button>
           </div>
         )}
-        {tab === "my" && !historyLoading && !historyError && messages.length === 0 && (
+        {tab === "my" && !loading && !historyError && messages.length === 0 && (
           <div style={{ padding: "20px 4px", textAlign: "center", color: p.text3, fontSize: 13 }}>
             Send a message to start chatting.
           </div>
@@ -540,31 +473,7 @@ export function MobileChat({
                     overflowWrap: "anywhere",
                   }}
                 >
-                  {m.content && (
-                    <MarkdownBubble dark={dark} accent={p.accent}>
-                      {m.content}
-                    </MarkdownBubble>
-                  )}
-                  {m.attachments && m.attachments.length > 0 && (
-                    <div
-                      style={{
-                        display: "flex",
-                        flexWrap: "wrap",
-                        gap: 4,
-                        marginTop: m.content ? 6 : 0,
-                      }}
-                    >
-                      {m.attachments.map((att, i) => (
-                        <AttachmentPreview
-                          key={`${m.id}-${i}`}
-                          workspaceId={agentId}
-                          attachment={att}
-                          onDownload={downloadAttachment}
-                          tone={mine ? "user" : "agent"}
-                        />
-                      ))}
-                    </div>
-                  )}
+                  {m.text}
                   <div
                     style={{
                       fontSize: 10,
@@ -573,13 +482,13 @@ export function MobileChat({
                       fontFamily: MOBILE_FONT_MONO,
                     }}
                   >
-                    {formatStoredTimestamp(m.timestamp)}
+                    {m.ts}
                   </div>
                 </div>
               </div>
             );
           })}
-        {sendError && (
+        {error && (
           <div
             role="alert"
             style={{
@@ -591,17 +500,11 @@ export function MobileChat({
               fontSize: 12,
             }}
           >
-            {sendError}
+            {error}
           </div>
         )}
       </div>
-      )}
 
-      {/* Footer ID + composer belong to My Chat only. The Agent Comms
-          tab is a read-only peer/A2A feed (parity with desktop
-          ChatTab, where the agent-comms tabpanel has no composer). */}
-      {tab === "my" && (
-      <>
       {/* Footer ID */}
       <div
         style={{
@@ -628,60 +531,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",
@@ -693,32 +542,22 @@ 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"
+            className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-1 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
             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 })}
@@ -745,19 +584,13 @@ export function MobileChat({
             placeholder={reachable ? "Send a message…" : `Agent is ${a.status}`}
             disabled={!reachable}
             rows={1}
+            className="focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-1"
             style={{
               flex: 1,
               border: "none",
               outline: "none",
               background: "transparent",
-              // 16px floor: iOS Safari/WebKit auto-zooms the viewport on
-              // focus when a focused field's font-size is < 16px. Anything
-              // below this re-introduces the tap-to-zoom layout jump on the
-              // mobile PWA. Do NOT lower this without also adding a
-              // maximum-scale/user-scalable viewport lock — and that lock
-              // breaks pinch-to-zoom accessibility, so 16px here is the
-              // correct trade.
-              fontSize: 16,
+              fontSize: 14.5,
               lineHeight: 1.4,
               color: p.text,
               padding: "6px 0",
@@ -771,37 +604,32 @@ 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"
+            className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-1 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
             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>
-      </>
-      )}
     </div>
   );
 }

canvas/src/components/mobile/MobileComms.tsx

@@ -218,6 +218,7 @@ export function MobileComms({ dark }: { dark: boolean }) {
               key={o.id}
               type="button"
               onClick={() => setFilter(o.id)}
+              className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-1 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
               style={{
                 display: "inline-flex",
                 alignItems: "center",

canvas/src/components/mobile/MobileDetail.tsx

@@ -83,11 +83,12 @@ export function MobileDetail({
             type="button"
             onClick={onBack}
             aria-label="Back"
+            className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-2 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
             style={iconButtonStyle(p, dark)}
           >
             {Icons.back({ size: 18 })}
           </button>
-          <button type="button" aria-label="More" style={iconButtonStyle(p, dark)}>
+          <button type="button" aria-label="More" className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-2 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900" style={iconButtonStyle(p, dark)}>
             {Icons.more({ size: 18 })}
           </button>
         </div>
@@ -183,6 +184,7 @@ export function MobileDetail({
               key={t.id}
               type="button"
               onClick={() => setTab(t.id)}
+              className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-2 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
               style={{
                 padding: "8px 14px",
                 borderRadius: 999,
@@ -215,6 +217,7 @@ export function MobileDetail({
           type="button"
           onClick={onChat}
           data-testid="mobile-chat-cta"
+          className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-2 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
           style={{
             width: "100%",
             height: 52,

canvas/src/components/mobile/MobileHome.tsx

@@ -183,6 +183,7 @@ export function MobileHome({
         type="button"
         onClick={onSpawn}
         aria-label="Spawn new agent"
+        className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-2 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
         style={{
           position: "absolute",
           right: 24,

canvas/src/components/mobile/MobileMe.tsx

@@ -83,6 +83,7 @@ export function MobileMe({
                   type="button"
                   onClick={() => setAccent(c)}
                   aria-label={`Set accent ${c}`}
+                  className="focus:outline-none focus-visible:ring-2 focus-visible:ring-offset-2 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
                   style={{
                     width: 36,
                     height: 36,
@@ -173,6 +174,7 @@ function SegmentedRow({
             key={o.id}
             type="button"
             onClick={() => onChange(o.id)}
+            className="focus:outline-none focus-visible:ring-2 focus-visible:ring-offset-2 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
             style={{
               flex: 1,
               padding: "10px 8px",

canvas/src/components/mobile/MobileSpawn.tsx

@@ -148,6 +148,7 @@ export function MobileSpawn({ dark, onClose }: { dark: boolean; onClose: () => v
             type="button"
             onClick={onClose}
             aria-label="Close"
+            className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-2 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
             style={{
               width: 32,
               height: 32,
@@ -210,10 +211,12 @@ export function MobileSpawn({ dark, onClose }: { dark: boolean; onClose: () => v
                   <button
                     key={t.id}
                     type="button"
+                    aria-label={`Select template: ${t.name} (tier ${t.tier})`}
                     onClick={() => {
                       setTplId(t.id);
                       setTier(tCode);
                     }}
+                    className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-1 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
                     style={{
                       background: on
                         ? dark
@@ -329,7 +332,10 @@ export function MobileSpawn({ dark, onClose }: { dark: boolean; onClose: () => v
               <button
                 key={t}
                 type="button"
+                aria-label={`Select tier ${t}: ${TIER_LABEL[t]}`}
+                aria-pressed={tier === t}
                 onClick={() => setTier(t)}
+                className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-1 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
                 style={{
                   flex: 1,
                   padding: "10px 8px",
@@ -375,8 +381,10 @@ export function MobileSpawn({ dark, onClose }: { dark: boolean; onClose: () => v
         <div style={{ padding: "20px 14px max(env(safe-area-inset-bottom), 28px)" }}>
           <button
             type="button"
+            aria-label="Spawn agent"
             onClick={handleSpawn}
             disabled={busy || !tplId || templates.length === 0}
+            className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-1 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
             style={{
               width: "100%",
               height: 52,

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

@@ -21,14 +21,6 @@ import { MobileChat } from "../MobileChat";
 vi.mock("@/lib/api");
 import { api } from "@/lib/api";
 
-// AgentCommsPanel (mounted by the Agent Comms sub-tab, #231) subscribes
-// to the global socket via useSocketEvent. Stub it to a no-op so the
-// panel mounts without the real ReconnectingSocket — the parity tests
-// only assert the panel renders (vs the old static placeholder).
-vi.mock("@/hooks/useSocketEvent", () => ({
-  useSocketEvent: vi.fn(),
-}));
-
 // ─── Mock store ───────────────────────────────────────────────────────────────
 
 const mockAgentId = "ws-chat-test";
@@ -163,12 +155,6 @@ beforeEach(() => {
   mockOnBack.mockClear();
   mockStoreState.nodes = [];
   mockStoreState.agentMessages = {};
-  // jsdom doesn't implement scrollIntoView. The Agent Comms tab now
-  // mounts AgentCommsPanel (#231), which scrolls its feed to bottom on
-  // arrival; a no-op stub keeps the panel from throwing under jsdom
-  // (same stub AgentCommsPanel's own render test installs).
-  Element.prototype.scrollIntoView =
-    vi.fn() as unknown as Element["scrollIntoView"];
   // 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");
@@ -263,20 +249,6 @@ describe("MobileChat — composer", () => {
     const sendBtn = container.querySelector('[aria-label="Send"]') as HTMLButtonElement;
     expect(sendBtn.disabled).toBe(true);
   });
-
-  // iOS Safari/WebKit auto-zooms the viewport on focus when a focused
-  // <input>/<textarea> has an effective font-size below 16px. On the
-  // mobile PWA this made the whole layout scale up the moment the user
-  // tapped into the chat box. Keeping the composer font ≥16px is the
-  // root-cause fix — it suppresses the focus-zoom WITHOUT disabling
-  // pinch-to-zoom (which a maximum-scale/user-scalable viewport hack
-  // would have done at the cost of accessibility).
-  it("composer textarea font-size is >= 16px (prevents iOS focus-zoom)", () => {
-    const { container } = renderChat(mockAgentId);
-    const textarea = container.querySelector("textarea") as HTMLTextAreaElement;
-    const fontSizePx = parseFloat(textarea.style.fontSize);
-    expect(fontSizePx).toBeGreaterThanOrEqual(16);
-  });
 });
 
 // ─── Tabs ─────────────────────────────────────────────────────────────────────
@@ -386,7 +358,7 @@ describe("MobileChat — chat history", () => {
       renderChat(mockAgentId);
     });
     expect(api.get).toHaveBeenCalledWith(
-      expect.stringContaining(`/workspaces/${mockAgentId}/chat-history`),
+      `/workspaces/${mockAgentId}/chat-history?limit=50`,
     );
   });
 
@@ -502,146 +474,3 @@ describe("MobileChat — chat history", () => {
     expect(getSpy).toHaveBeenCalledTimes(2);
   });
 });
-
-// ─── #232 · Attachment render parity with desktop ChatTab ────────────────────
-//
-// Regression for the CTO-reported mobile bug: MobileChat used to render
-// only m.content (no attachment surface), so files sent/received in a
-// conversation were invisible on mobile while desktop showed them. The
-// fix routes m.attachments through the same AttachmentPreview the
-// desktop ChatTab bubble uses.
-
-describe("MobileChat — attachment render parity (#232)", () => {
-  beforeEach(() => {
-    mockStoreState.nodes = [onlineNode];
-  });
-
-  it("renders an attachment from a history message via AttachmentPreview", async () => {
-    const getSpy = vi.spyOn(api, "get");
-    // useChatHistory reads { messages, reached_end }.
-    getSpy.mockResolvedValueOnce({
-      messages: [
-        {
-          id: "m-att-1",
-          role: "agent",
-          content: "Here is the report",
-          attachments: [
-            {
-              name: "report.csv",
-              uri: "workspace://out/report.csv",
-              mimeType: "text/csv",
-              size: 2048,
-            },
-          ],
-          timestamp: new Date().toISOString(),
-        },
-      ],
-      reached_end: true,
-    });
-
-    let rr: ReturnType<typeof renderChat>;
-    await act(async () => {
-      rr = renderChat(mockAgentId);
-    });
-    const { container } = rr!;
-
-    // A non-image attachment renders the AttachmentChip download button
-    // with title="Download <name>" — same component the desktop bubble
-    // dispatches through AttachmentPreview.
-    await waitFor(() => {
-      const chip = container.querySelector('[title="Download report.csv"]');
-      expect(chip).toBeTruthy();
-    });
-    expect(container.textContent ?? "").toContain("report.csv");
-  });
-});
-
-// ─── #231 · Agent Comms (A2A/peer) render parity with desktop ChatTab ────────
-//
-// Regression for the CTO-reported mobile bug: the Agent Comms sub-tab
-// rendered a static placeholder string ("peer-to-peer A2A traffic
-// surfaces in the Comms tab") instead of the real feed. The fix mounts
-// the same AgentCommsPanel the desktop ChatTab agent-comms tabpanel
-// uses, so peer/A2A + delegation activity is visible on mobile.
-
-describe("MobileChat — Agent Comms render parity (#231)", () => {
-  beforeEach(() => {
-    mockStoreState.nodes = [onlineNode];
-  });
-
-  it("mounts AgentCommsPanel on the Agent Comms tab (not the old placeholder)", async () => {
-    const getSpy = vi.spyOn(api, "get");
-    // 1st GET: useChatHistory (My Chat) on mount.
-    getSpy.mockResolvedValueOnce({ messages: [], reached_end: true });
-    // 2nd GET: AgentCommsPanel's activity load when the tab is shown.
-    // Empty list → panel renders its own empty state, which still
-    // proves AgentCommsPanel mounted (vs. the removed placeholder).
-    getSpy.mockResolvedValueOnce([]);
-
-    let rr: ReturnType<typeof renderChat>;
-    await act(async () => {
-      rr = renderChat(mockAgentId);
-    });
-    const { container } = rr!;
-
-    const commsTab = Array.from(container.querySelectorAll("button")).find(
-      (b) => b.textContent?.trim() === "Agent Comms",
-    );
-    expect(commsTab).toBeTruthy();
-    await act(async () => {
-      commsTab!.click();
-    });
-
-    await waitFor(() => {
-      const text = container.textContent ?? "";
-      // The panel's empty state — proves AgentCommsPanel mounted.
-      expect(text).toContain("No agent-to-agent communications yet.");
-    });
-    // The old hard-coded placeholder must be gone.
-    expect(container.textContent ?? "").not.toContain(
-      "peer-to-peer A2A traffic surfaces in the Comms tab",
-    );
-    // The panel hit its activity endpoint.
-    expect(getSpy).toHaveBeenCalledWith(
-      expect.stringContaining(`/workspaces/${mockAgentId}/activity`),
-    );
-  });
-
-  it("renders a peer message on the Agent Comms tab", async () => {
-    const getSpy = vi.spyOn(api, "get");
-    getSpy.mockResolvedValueOnce({ messages: [], reached_end: true });
-    // a2a_receive from a peer → AgentCommsPanel.toCommMessage maps it
-    // to an inbound bubble with the request text.
-    getSpy.mockResolvedValueOnce([
-      {
-        id: "act-1",
-        activity_type: "a2a_receive",
-        source_id: "peer-ws-uuid",
-        target_id: mockAgentId,
-        method: "message/send",
-        summary: "peer asked something",
-        request_body: { task: "Please review PR 42" },
-        response_body: null,
-        status: "ok",
-        created_at: new Date().toISOString(),
-      },
-    ]);
-
-    let rr: ReturnType<typeof renderChat>;
-    await act(async () => {
-      rr = renderChat(mockAgentId);
-    });
-    const { container } = rr!;
-
-    const commsTab = Array.from(container.querySelectorAll("button")).find(
-      (b) => b.textContent?.trim() === "Agent Comms",
-    );
-    await act(async () => {
-      commsTab!.click();
-    });
-
-    await waitFor(() => {
-      expect(container.textContent ?? "").toContain("Please review PR 42");
-    });
-  });
-});

canvas/src/components/mobile/components.tsx

@@ -133,6 +133,7 @@ export function TabBar({
             aria-label={t.label}
             onClick={() => onChange(t.id)}
             onKeyDown={(e) => handleKeyDown(e, idx)}
+            className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-1 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
             style={{
               background: "none",
               border: "none",
@@ -291,6 +292,7 @@ export function AgentCard({
       data-testid="workspace-card"
       aria-label={`${agent.name}, status: ${agent.status}, tier ${agent.tier}${agent.remote ? ", remote" : ""}`}
       onClick={onClick}
+      className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-1 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
       style={{
         display: "block",
         width: "100%",
@@ -444,6 +446,7 @@ export function FilterChips({
             type="button"
             aria-checked={on}
             onClick={() => onChange(o.id)}
+            className="focus:outline-none focus-visible:ring-2 focus-visible:ring-emerald-500 focus-visible:ring-offset-1 focus-visible:ring-offset-zinc-100 dark:focus-visible:ring-offset-zinc-900"
             style={{
               display: "inline-flex",
               alignItems: "center",

canvas/src/components/settings/SecretRow.tsx

@@ -3,24 +3,16 @@ import { useState, useCallback, useRef, useEffect } from 'react';
 import type { Secret, SecretGroup } from '@/types/secrets';
 import { useSecretsStore } from '@/stores/secrets-store';
 import { StatusBadge } from '@/components/ui/StatusBadge';
+import { RevealToggle } from '@/components/ui/RevealToggle';
 import { KeyValueField } from '@/components/ui/KeyValueField';
 import { ValidationHint } from '@/components/ui/ValidationHint';
 import { TestConnectionButton } from '@/components/ui/TestConnectionButton';
 import { validateSecretValue } from '@/lib/validation/secret-formats';
 import { SERVICES } from '@/lib/services';
 
+const AUTO_HIDE_MS = 30_000;
 const VALIDATION_DEBOUNCE_MS = 400;
 
-// Secret values are write-only from the browser: the server List endpoint
-// "Never exposes values", there is no per-secret decrypt route, and the
-// only decrypted path (GET /secrets/values) is bulk + token-gated for
-// remote agents. The old eye/RevealToggle was a dead affordance — it
-// flipped its own icon but could never reveal anything, which read as
-// "this doesn't work" (esp. once clicked → eye-with-slash). We show an
-// honest static indicator instead; rotation is via Edit.
-const WRITE_ONLY_TITLE =
-  'Value is write-only and cannot be revealed — use Edit to replace/rotate it';
-
 interface SecretRowProps {
   secret: Secret;
   workspaceId: string;
@@ -39,12 +31,28 @@ export function SecretRow({ secret, workspaceId }: SecretRowProps) {
   const setSecretStatus = useSecretsStore((s) => s.setSecretStatus);
 
   const isEditing = editingKey === secret.name;
+  const [revealed, setRevealed] = useState(false);
   const [editValue, setEditValue] = useState('');
   const [validationError, setValidationError] = useState<string | null>(null);
   const [isSaving, setIsSaving] = useState(false);
   const [saveError, setSaveError] = useState<string | null>(null);
   const debounceRef = useRef<ReturnType<typeof setTimeout>>(undefined);
   const editBtnRef = useRef<HTMLButtonElement>(null);
+  const revealTimerRef = useRef<ReturnType<typeof setTimeout>>(undefined);
+
+  // Auto-hide revealed value after 30s
+  useEffect(() => {
+    if (revealed) {
+      clearTimeout(revealTimerRef.current);
+      revealTimerRef.current = setTimeout(() => setRevealed(false), AUTO_HIDE_MS);
+      return () => clearTimeout(revealTimerRef.current);
+    }
+  }, [revealed]);
+
+  // Reset revealed state when panel closes (session-only)
+  useEffect(() => {
+    return () => setRevealed(false);
+  }, []);
 
   // Debounced validation
   useEffect(() => {
@@ -125,15 +133,11 @@ export function SecretRow({ secret, workspaceId }: SecretRowProps) {
           {secret.masked_value}
         </span>
         <div className="secret-row__actions">
-          <span
-            data-testid="write-only-indicator"
-            className="secret-row__write-only"
-            role="img"
-            aria-label={`${secret.name} value is write-only and cannot be revealed; use Edit to replace it`}
-            title={WRITE_ONLY_TITLE}
-          >
-            🔒
-          </span>
+          <RevealToggle
+            revealed={revealed}
+            onToggle={() => setRevealed((r) => !r)}
+            label={`Toggle reveal ${secret.name}`}
+          />
           <StatusBadge status={secret.status} />
           <button
             type="button"

canvas/src/components/settings/TokensTab.tsx

@@ -16,40 +16,7 @@ interface TokensTabProps {
   workspaceId: string;
 }
 
-// The settings panel passes the literal sentinel "global" when no canvas
-// node is selected. Workspace tokens are inherently per-workspace — there
-// is no /workspaces/global/tokens endpoint (querying the uuid column with
-// "global" 500s on Postgres). The org-wide equivalent lives in the
-// separate "Org API Keys" tab. Mirrors the sentinel-awareness that
-// api/secrets.ts already has (workspaceId === 'global' → /settings/secrets).
-const GLOBAL_WORKSPACE_ID = 'global';
-
 export function TokensTab({ workspaceId }: TokensTabProps) {
-  if (workspaceId === GLOBAL_WORKSPACE_ID) {
-    return (
-      <div className="p-4 space-y-4">
-        <div>
-          <h3 className="text-sm font-semibold text-ink">API Tokens</h3>
-          <p className="text-[10px] text-ink-mid mt-0.5">
-            Bearer tokens for authenticating API calls to this workspace.
-          </p>
-        </div>
-        <div className="text-center py-6">
-          <p className="text-xs text-ink-mid">Select a workspace node first</p>
-          <p className="text-[10px] text-ink-mid mt-1">
-            Workspace tokens are scoped to a single workspace. Select a node
-            on the canvas to manage its tokens, or use the{' '}
-            <span className="text-accent font-medium">Org API Keys</span> tab
-            for org-wide API keys.
-          </p>
-        </div>
-      </div>
-    );
-  }
-  return <WorkspaceTokensTab workspaceId={workspaceId} />;
-}
-
-function WorkspaceTokensTab({ workspaceId }: TokensTabProps) {
   const [tokens, setTokens] = useState<Token[]>([]);
   const [loading, setLoading] = useState(true);
   const [creating, setCreating] = useState(false);

canvas/src/components/settings/__tests__/SecretRow.test.tsx

@@ -138,54 +138,14 @@ describe("SecretRow — display mode", () => {
     expect(document.querySelector('[role="row"]')).toBeTruthy();
   });
 
-  it("has Copy, Edit, Delete buttons", () => {
+  it("has Reveal, Copy, Edit, Delete buttons", () => {
     render(<SecretRow secret={GITHUB_SECRET} workspaceId="ws-1" />);
+    expect(screen.getByTestId("reveal-toggle")).toBeTruthy();
     expect(screen.getByRole("button", { name: /copy/i })).toBeTruthy();
     expect(screen.getByRole("button", { name: /edit/i })).toBeTruthy();
     expect(screen.getByRole("button", { name: /delete/i })).toBeTruthy();
   });
 
-  // Regression: the reveal/eye control was a dead affordance. Clicking it
-  // flipped its own icon (eye → eye-with-slash) but never revealed the value,
-  // because secret values are write-only from the browser (server List
-  // "Never exposes values"; there is no per-secret decrypt endpoint and the
-  // client has no plaintext-fetch function). The honest fix removes the
-  // toggle and shows a static "write-only / cannot be revealed" indicator.
-  // See internal tracking issue + internal#210/#211.
-  it("does NOT render a reveal/eye toggle (values are write-only)", () => {
-    render(<SecretRow secret={GITHUB_SECRET} workspaceId="ws-1" />);
-    expect(screen.queryByTestId("reveal-toggle")).toBeNull();
-    expect(
-      screen.queryByRole("button", { name: /toggle reveal/i }),
-    ).toBeNull();
-  });
-
-  it("shows a write-only indicator explaining the value cannot be revealed", () => {
-    render(<SecretRow secret={ANTHROPIC_SECRET} workspaceId="ws-1" />);
-    const indicator = screen.getByTestId("write-only-indicator");
-    expect(indicator).toBeTruthy();
-    // Affordance must be honest: explain it cannot be revealed and that
-    // Edit is the rotate path. It must not be a clickable button.
-    const title = indicator.getAttribute("title") ?? "";
-    expect(title.toLowerCase()).toMatch(/write-only|cannot be revealed/);
-    expect(indicator.tagName).not.toBe("BUTTON");
-  });
-
-  it("write-only indicator is present for the Anthropic/OAuth-token row too", () => {
-    // The reported bug singled out CLAUDE_CODE_OAUTH_TOKEN (anthropic group);
-    // the fix is group-agnostic — every row gets the same honest affordance.
-    const OAUTH_SECRET = {
-      name: "CLAUDE_CODE_OAUTH_TOKEN",
-      masked_value: "••••••••••••••••9d2a",
-      group: "anthropic" as const,
-      status: "unverified" as const,
-      updated_at: "2024-01-04",
-    };
-    render(<SecretRow secret={OAUTH_SECRET} workspaceId="ws-1" />);
-    expect(screen.queryByTestId("reveal-toggle")).toBeNull();
-    expect(screen.getByTestId("write-only-indicator")).toBeTruthy();
-  });
-
   it("shows invalid status correctly", () => {
     render(<SecretRow secret={CUSTOM_SECRET} workspaceId="ws-1" />);
     expect(screen.getByTestId("status-badge").getAttribute("data-status")).toBe("invalid");

canvas/src/components/settings/__tests__/TokensTab.test.tsx

@@ -302,35 +302,3 @@ describe("TokensTab — error", () => {
     expect(document.querySelector('[role="status"]')).toBeNull();
   });
 });
-
-// ─── "global" sentinel (no node selected) ────────────────────────────────────
-//
-// Regression: SettingsPanel passes the literal "global" when no canvas
-// node is selected. workspace tokens are per-workspace and there is no
-// /workspaces/global/tokens endpoint — calling it 500'd
-// ("invalid input syntax for type uuid: global"). The tab must NOT call
-// the API in that state and must point the user at the Org API Keys tab.
-describe("TokensTab — global sentinel (no node selected)", () => {
-  beforeEach(() => {
-    mockApiGet.mockReset();
-    mockApiPost.mockReset();
-    mockApiGet.mockRejectedValue(new Error("should not be called"));
-  });
-
-  it("does not call the API and shows a pointer to Org API Keys", async () => {
-    render(<TokensTab workspaceId="global" />);
-    await flush();
-    expect(mockApiGet).not.toHaveBeenCalled();
-    expect(mockApiPost).not.toHaveBeenCalled();
-    expect(document.body.textContent).toContain("Select a workspace node");
-    expect(document.body.textContent).toContain("Org API Keys");
-    // No error banner, no scary 500 surfacing.
-    expect(document.querySelector(".text-bad")).toBeNull();
-  });
-
-  it("has no create button in the global state", async () => {
-    render(<TokensTab workspaceId="global" />);
-    await flush();
-    expect(document.body.textContent).not.toContain("New Token");
-  });
-});

canvas/src/components/tabs/ActivityTab.tsx

@@ -139,7 +139,7 @@ export function ActivityTab({ workspaceId }: Props) {
               key={f.id}
               onClick={() => setFilter(f.id)}
               aria-pressed={filter === f.id}
-              className={`px-2 py-1 text-[11px] rounded-md font-medium transition-all ${
+              className={`px-2 py-1 text-[11px] rounded-md font-medium transition-all focus:outline-none focus-visible:ring-2 focus-visible:ring-accent/40 ${
                 filter === f.id
                   ? "bg-surface-card text-ink ring-1 ring-zinc-600"
                   : "text-ink-mid hover:text-ink-mid hover:bg-surface-card/60"
@@ -152,7 +152,7 @@ export function ActivityTab({ workspaceId }: Props) {
             <button
               onClick={() => setAutoRefresh(!autoRefresh)}
               aria-pressed={autoRefresh}
-              className={`text-[11px] px-1.5 py-0.5 rounded ${
+              className={`text-[11px] px-1.5 py-0.5 rounded focus:outline-none focus-visible:ring-2 focus-visible:ring-accent/40 ${
                 autoRefresh ? "text-good bg-emerald-950/30" : "text-ink-mid"
               }`}
               title={autoRefresh ? "Auto-refresh ON" : "Auto-refresh OFF"}
@@ -161,8 +161,9 @@ export function ActivityTab({ workspaceId }: Props) {
             </button>
             <button
               onClick={() => setTraceOpen(true)}
-              className="px-2 py-1 bg-blue-900/40 hover:bg-blue-800/50 text-[11px] rounded text-accent border border-blue-800/30"
-              title="View full conversation trace across all workspaces"
+              aria-label="Full trace"
+              className="px-2 py-1 bg-blue-900/40 hover:bg-blue-800/50 text-[11px] rounded text-accent border border-blue-800/30 focus:outline-none focus-visible:ring-2 focus-visible:ring-accent/40"
+              title="View full conversation trace"
             >
               Full Trace
             </button>

canvas/src/components/tabs/ChannelsTab.tsx

@@ -331,8 +331,9 @@ export function ChannelsTab({ workspaceId }: Props) {
                                 </label>
                               ))}
                               <button
+                                aria-label={showManualInput ? "Hide manual input" : "Show manual input"}
                                 onClick={() => setShowManualInput(!showManualInput)}
-                                className="text-[10px] text-accent hover:underline"
+                                className="text-[10px] text-accent hover:underline focus:outline-none focus-visible:ring-2 focus-visible:ring-accent/40"
                               >
                                 {showManualInput ? "hide manual input" : "edit manually"}
                               </button>
@@ -408,15 +409,16 @@ export function ChannelsTab({ workspaceId }: Props) {
             </div>
             <div className="flex items-center gap-1.5">
               <button
+                aria-label={testing === ch.id ? "Sent!" : "Test channel"}
                 onClick={() => handleTest(ch)}
                 disabled={testing === ch.id}
-                className="text-[10px] px-2 py-0.5 rounded bg-surface-card/50 text-ink-mid hover:text-ink transition disabled:opacity-50"
+                className="text-[10px] px-2 py-0.5 rounded bg-surface-card/50 text-ink-mid hover:text-ink transition disabled:opacity-50 focus:outline-none focus-visible:ring-2 focus-visible:ring-accent/40"
               >
                 {testing === ch.id ? "Sent!" : "Test"}
               </button>
               <button
                 onClick={() => handleToggle(ch)}
-                className={`text-[10px] px-2 py-0.5 rounded transition ${
+                className={`text-[10px] px-2 py-0.5 rounded transition focus:outline-none focus-visible:ring-2 focus-visible:ring-accent/40 ${
                   ch.enabled
                     ? "bg-emerald-900/30 text-good hover:bg-emerald-900/50"
                     : "bg-surface-card/50 text-ink-mid hover:text-ink-mid"
@@ -425,8 +427,9 @@ export function ChannelsTab({ workspaceId }: Props) {
                 {ch.enabled ? "On" : "Off"}
               </button>
               <button
+                aria-label={`Remove ${ch.config.chat_id || ch.config.channel_id || "channel"}`}
                 onClick={() => setPendingDelete(ch)}
-                className="text-[10px] px-2 py-0.5 rounded bg-red-900/20 text-bad hover:bg-red-900/40 transition"
+                className="text-[10px] px-2 py-0.5 rounded bg-red-900/20 text-bad hover:bg-red-900/40 transition focus:outline-none focus-visible:ring-2 focus-visible:ring-red-400"
               >
                 Remove
               </button>

canvas/src/components/tabs/ChatTab.tsx

@@ -143,12 +143,6 @@ function MyChatPanel({ workspaceId, data }: Props) {
         releaseSendGuards();
       }
     },
-    // Fan-out of user's own outbound message to all sessions (issue #228).
-    // Uses appendMessageDeduped so the originating session collapses its
-    // optimistic copy (same role + content within 3-second window).
-    onUserMessage: (msg) => {
-      history.setMessages((prev) => appendMessageDeduped(prev, msg));
-    },
     onActivityLog: (entry) => {
       if (!sending) return;
       setActivityLog((prev) => appendActivityLine(prev, entry));
@@ -389,7 +383,8 @@ function MyChatPanel({ workspaceId, data }: Props) {
                 // 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"
+            aria-label="Enable agent chat"
+            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 focus:outline-none focus-visible:ring-2 focus-visible:ring-accent/40"
           >
             Enable
           </button>
@@ -409,8 +404,9 @@ function MyChatPanel({ workspaceId, data }: Props) {
               Failed to load chat history: {history.loadError}
             </p>
             <button
+              aria-label="Retry loading chat history"
               onClick={history.loadInitial}
-              className="text-[10px] px-2 py-0.5 rounded bg-red-800 text-red-200 hover:bg-red-700 transition-colors"
+              className="text-[10px] px-2 py-0.5 rounded bg-red-800 text-red-200 hover:bg-red-700 transition-colors focus:outline-none focus-visible:ring-2 focus-visible:ring-red-400"
             >
               Retry
             </button>
@@ -605,8 +601,9 @@ function MyChatPanel({ workspaceId, data }: Props) {
             <span className="text-[10px] text-red-300">{displayError}</span>
             {!isOnline && (
               <button
+                aria-label="Restart workspace"
                 onClick={() => setConfirmRestart(true)}
-                className="text-[11px] px-2 py-0.5 bg-red-800 text-red-200 rounded hover:bg-red-700"
+                className="text-[11px] px-2 py-0.5 bg-red-800 text-red-200 rounded hover:bg-red-700 focus:outline-none focus-visible:ring-2 focus-visible:ring-red-400"
               >
                 Restart
               </button>
@@ -642,7 +639,7 @@ function MyChatPanel({ workspaceId, data }: Props) {
             disabled={!agentReachable || sending || uploading}
             aria-label="Attach file"
             title="Attach file"
-            className="p-2 bg-surface-card hover:bg-surface-card border border-line rounded-lg text-ink-mid hover:text-ink transition-colors shrink-0 disabled:opacity-40"
+            className="p-2 bg-surface-card hover:bg-surface-card border border-line rounded-lg text-ink-mid hover:text-ink transition-colors shrink-0 disabled:opacity-40 focus:outline-none focus-visible:ring-2 focus-visible:ring-accent/40"
           >
             <svg width="14" height="14" viewBox="0 0 16 16" fill="none" aria-hidden="true">
               <path d="M11 6.5 7 10.5a2 2 0 1 0 2.8 2.8l4-4a3.5 3.5 0 0 0-5-5l-4.5 4.5a5 5 0 0 0 7 7l4-4" stroke="currentColor" strokeWidth="1.4" strokeLinecap="round" strokeLinejoin="round" />
@@ -680,9 +677,10 @@ 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
+            aria-label="Send message"
             onClick={handleSend}
             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"
+            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 focus:outline-none focus-visible:ring-2 focus-visible:ring-accent/40"
           >
             {uploading ? "Uploading…" : "Send"}
           </button>

canvas/src/components/tabs/FilesTab/FileEditor.tsx

@@ -88,7 +88,7 @@ export function FileEditor({
           <button
             onClick={onDownload}
             aria-label="Download file"
-            className="text-[10px] text-ink-mid hover:text-ink-mid"
+            className="text-[10px] text-ink-mid hover:text-ink-mid focus:outline-none focus-visible:ring-2 focus-visible:ring-accent/40 rounded transition-colors"
           >
             ↓
           </button>
@@ -96,7 +96,7 @@ export function FileEditor({
             <button
               onClick={onSave}
               disabled={!isDirty || saving}
-              className="text-[10px] text-accent hover:text-accent disabled:opacity-30"
+              className="text-[10px] text-accent hover:text-accent disabled:opacity-30 focus:outline-none focus-visible:ring-2 focus-visible:ring-accent/40 rounded transition-colors"
             >
               {saving ? "Saving..." : "Save"}
             </button>

canvas/src/components/tabs/FilesTab/__tests__/FileTree.render-a11y.test.tsx

@@ -0,0 +1,288 @@
+// @vitest-environment jsdom
+/**
+ * Tests for FileTree — complements FileTreeContextMenu.test.tsx with:
+ *   - Empty tree render
+ *   - File row: icon, name, selection highlight
+ *   - Directory row: folder icon, expand/collapse chevron, loading indicator
+ *   - Directory expand/collapse via click
+ *   - File select callback
+ *   - Delete button: aria-label, stopPropagation
+ *   - Drop-target highlight (drag hover)
+ *   - Context menu opens on right-click
+ *   - Nested tree: recursive rendering
+ *   - WCAG: aria-label on all interactive elements
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, screen, fireEvent, createEvent, cleanup } from "@testing-library/react";
+
+// ── Mock FileTreeContextMenu (rendered by FileTree on right-click) ─────────────
+vi.mock("../FileTreeContextMenu", () => ({
+  FileTreeContextMenu: ({ items }: { items: Array<{ id: string; label: string; disabled?: boolean }>; onClose: () => void }) => (
+    <div data-testid="file-context-menu">
+      {items.map((item, i) => (
+        <button key={item.id} data-menu-id={item.id} role="menuitem" disabled={item.disabled}>
+          {item.label}
+        </button>
+      ))}
+    </div>
+  ),
+}));
+
+// ── Import component + types AFTER mocks ────────────────────────────────────────
+import { FileTree } from "../FileTree";
+import type { TreeNode } from "../tree";
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+});
+
+// ── Test helpers ───────────────────────────────────────────────────────────────
+const makeNode = (
+  name: string,
+  opts: Partial<{
+    isDir: boolean;
+    path: string;
+    children: TreeNode[];
+  }>
+): TreeNode => ({
+  name,
+  path: opts.path ?? `/${name}`,
+  isDir: opts.isDir ?? false,
+  children: opts.children ?? [],
+  size: 0,
+});
+
+const EMPTY_CALLBACKS = {
+  selectedPath: null as string | null,
+  onSelect: vi.fn(),
+  onDelete: vi.fn(),
+  onDownload: vi.fn(),
+  canDelete: true,
+  expandedDirs: new Set<string>(),
+  onToggleDir: vi.fn(),
+  loadingDir: null as string | null,
+};
+
+describe("FileTree — empty render", () => {
+  it("renders nothing when nodes is an empty array", () => {
+    render(<FileTree nodes={[]} {...EMPTY_CALLBACKS} />);
+    expect(document.body.textContent).toBe("");
+  });
+});
+
+describe("FileTree — file row", () => {
+  it("renders a file row with the file name", () => {
+    const file = makeNode("config.yaml", { isDir: false });
+    render(<FileTree nodes={[file]} {...EMPTY_CALLBACKS} />);
+    expect(screen.getByText("config.yaml")).toBeTruthy();
+  });
+
+  it("renders file icon via getIcon (📜 for .yaml)", () => {
+    const file = makeNode("README.md", { isDir: false });
+    render(<FileTree nodes={[file]} {...EMPTY_CALLBACKS} />);
+    // Icon is a span with the emoji
+    const icon = document.querySelector('[class*="gap-1"] span');
+    expect(icon?.textContent).toBeTruthy();
+  });
+
+  it("file row has aria-label on the delete button", () => {
+    const file = makeNode("script.py", { isDir: false });
+    render(<FileTree nodes={[file]} {...EMPTY_CALLBACKS} />);
+    const delBtn = document.querySelector('button[aria-label="Delete script.py"]');
+    expect(delBtn).toBeTruthy();
+  });
+
+  it("clicking a file row calls onSelect with the file path", () => {
+    const onSelect = vi.fn();
+    const file = makeNode("app.ts", { path: "/src/app.ts", isDir: false });
+    render(<FileTree nodes={[file]} {...EMPTY_CALLBACKS} selectedPath={null} onSelect={onSelect} />);
+    fireEvent.click(screen.getByText("app.ts"));
+    expect(onSelect).toHaveBeenCalledWith("/src/app.ts");
+  });
+
+  it("selected file has different background class than unselected", () => {
+    const file = makeNode("main.py", { isDir: false });
+    render(<FileTree nodes={[file]} {...EMPTY_CALLBACKS} selectedPath="/main.py" />);
+    const row = document.querySelector('[class*="cursor-pointer"]') as HTMLElement;
+    expect(row).toBeTruthy();
+    // bg-blue-900/30 is applied when selected
+    expect(row.className).toContain("bg-blue-900/30");
+  });
+
+  it("clicking the delete button calls onDelete (stops propagation)", () => {
+    const onSelect = vi.fn();
+    const onDelete = vi.fn();
+    const file = makeNode("temp.txt", { isDir: false });
+    render(<FileTree nodes={[file]} {...EMPTY_CALLBACKS} onSelect={onSelect} onDelete={onDelete} />);
+    const delBtn = screen.getByRole("button", { name: /Delete temp\.txt/i });
+    fireEvent.click(delBtn);
+    expect(onDelete).toHaveBeenCalledWith("/temp.txt");
+    // onSelect should NOT be called (stopPropagation)
+    expect(onSelect).not.toHaveBeenCalled();
+  });
+});
+
+describe("FileTree — directory row", () => {
+  it("renders a directory row with 📁 icon and directory name", () => {
+    const dir = makeNode("src", { isDir: true, path: "/src" });
+    render(<FileTree nodes={[dir]} {...EMPTY_CALLBACKS} />);
+    expect(screen.getByText("src")).toBeTruthy();
+    expect(screen.getByText("📁")).toBeTruthy();
+  });
+
+  it("directory shows ▶ chevron when collapsed", () => {
+    const dir = makeNode("lib", { isDir: true, path: "/lib" });
+    render(<FileTree nodes={[dir]} {...EMPTY_CALLBACKS} expandedDirs={new Set()} />);
+    // collapsed → ▶
+    expect(screen.getByText("▶")).toBeTruthy();
+  });
+
+  it("directory shows ▼ chevron when expanded", () => {
+    const dir = makeNode("lib", { isDir: true, path: "/lib" });
+    render(<FileTree nodes={[dir]} {...EMPTY_CALLBACKS} expandedDirs={new Set(["/lib"])} />);
+    expect(screen.getByText("▼")).toBeTruthy();
+  });
+
+  it("directory shows … (loading indicator) when loadingDir matches", () => {
+    const dir = makeNode("pkg", { isDir: true, path: "/pkg" });
+    render(<FileTree nodes={[dir]} {...EMPTY_CALLBACKS} loadingDir="/pkg" expandedDirs={new Set(["/pkg"])} />);
+    expect(screen.getByText("…")).toBeTruthy();
+    // Chevron is replaced by loading indicator
+    expect(screen.queryByText("▼")).toBeNull();
+  });
+
+  it("clicking a collapsed directory calls onToggleDir", () => {
+    const onToggleDir = vi.fn();
+    const dir = makeNode("docs", { isDir: true, path: "/docs" });
+    render(<FileTree nodes={[dir]} {...EMPTY_CALLBACKS} expandedDirs={new Set()} onToggleDir={onToggleDir} />);
+    fireEvent.click(screen.getByText("docs"));
+    expect(onToggleDir).toHaveBeenCalledWith("/docs");
+  });
+
+  it("clicking an expanded directory calls onToggleDir to collapse", () => {
+    const onToggleDir = vi.fn();
+    const dir = makeNode("docs", { isDir: true, path: "/docs" });
+    render(<FileTree nodes={[dir]} {...EMPTY_CALLBACKS} expandedDirs={new Set(["/docs"])} onToggleDir={onToggleDir} />);
+    fireEvent.click(screen.getByText("docs"));
+    expect(onToggleDir).toHaveBeenCalledWith("/docs");
+  });
+
+  it("expanded directory renders its children recursively", () => {
+    const childFile = makeNode("index.ts", { isDir: false, path: "/src/index.ts" });
+    const dir = makeNode("src", { isDir: true, path: "/src", children: [childFile] });
+    render(<FileTree nodes={[dir]} {...EMPTY_CALLBACKS} expandedDirs={new Set(["/src"])} />);
+    expect(screen.getByText("index.ts")).toBeTruthy();
+  });
+
+  it("collapsed directory does NOT render its children", () => {
+    const childFile = makeNode("inner.ts", { isDir: false, path: "/outer/inner.ts" });
+    const dir = makeNode("outer", { isDir: true, path: "/outer", children: [childFile] });
+    render(<FileTree nodes={[dir]} {...EMPTY_CALLBACKS} expandedDirs={new Set()} />);
+    expect(screen.queryByText("inner.ts")).toBeNull();
+  });
+
+  it("directory delete button calls onDelete", () => {
+    const onDelete = vi.fn();
+    const dir = makeNode("cache", { isDir: true, path: "/cache" });
+    render(<FileTree nodes={[dir]} {...EMPTY_CALLBACKS} onDelete={onDelete} />);
+    const delBtn = screen.getByRole("button", { name: /Delete cache/i });
+    fireEvent.click(delBtn);
+    expect(onDelete).toHaveBeenCalledWith("/cache");
+  });
+
+  it("directory delete button in context menu is disabled when canDelete=false", () => {
+    const dir = makeNode("locked", { isDir: true, path: "/locked" });
+    render(<FileTree nodes={[dir]} {...EMPTY_CALLBACKS} canDelete={false} />);
+    // Right-click to open context menu
+    const row = document.querySelector('[class*="cursor-pointer"]') as HTMLElement;
+    fireEvent.contextMenu(row);
+    // Query inside the context menu — use role=menuitem (real component uses this)
+    // and verify the disabled attribute (vitest-compatible, no jest-dom needed)
+    const ctxMenu = screen.getByTestId("file-context-menu");
+    const delBtn = ctxMenu.querySelector('button[role="menuitem"]') as HTMLButtonElement | null;
+    expect(delBtn).not.toBeNull();
+    expect(delBtn!.disabled).toBe(true);
+  });
+});
+
+describe("FileTree — context menu", () => {
+  it("right-clicking a file opens the context menu", () => {
+    const file = makeNode("data.json", { isDir: false });
+    render(<FileTree nodes={[file]} {...EMPTY_CALLBACKS} />);
+    const row = document.querySelector('[class*="cursor-pointer"]') as HTMLElement;
+    fireEvent.contextMenu(row);
+    expect(screen.getByTestId("file-context-menu")).toBeTruthy();
+  });
+
+  it("context menu shows 'Open' and 'Download' for a file", () => {
+    const file = makeNode("report.csv", { isDir: false });
+    render(<FileTree nodes={[file]} {...EMPTY_CALLBACKS} />);
+    const row = document.querySelector('[class*="cursor-pointer"]') as HTMLElement;
+    fireEvent.contextMenu(row);
+    expect(screen.getByText("Open")).toBeTruthy();
+    expect(screen.getByText("Download")).toBeTruthy();
+  });
+
+  it("context menu shows only 'Delete' for a directory (no Open/Download)", () => {
+    const dir = makeNode("logs", { isDir: true, path: "/logs" });
+    render(<FileTree nodes={[dir]} {...EMPTY_CALLBACKS} />);
+    const row = document.querySelector('[class*="cursor-pointer"]') as HTMLElement;
+    fireEvent.contextMenu(row);
+    expect(screen.getByText("Delete")).toBeTruthy();
+    expect(screen.queryByText("Open")).toBeNull();
+    expect(screen.queryByText("Download")).toBeNull();
+  });
+});
+
+describe("FileTree — drag-drop target highlight (PR-D)", () => {
+  it("directory row handles dragOver without crashing", () => {
+    const onDropToTarget = vi.fn();
+    const dir = makeNode("dropdir", { isDir: true, path: "/dropdir" });
+    render(<FileTree nodes={[dir]} {...EMPTY_CALLBACKS} onDropToTarget={onDropToTarget} expandedDirs={new Set()} />);
+    const row = document.querySelector('[class*="cursor-pointer"]') as HTMLElement;
+    expect(row).toBeTruthy();
+    // jsdom's DragEvent is not available; use RTL's createEvent + dispatchEvent
+    // and stub dataTransfer so the handler's e.dataTransfer.dropEffect = "copy"
+    // assignment inside FileTree doesn't throw.
+    const dragOverEvent = createEvent.dragOver(row);
+    Object.defineProperty(dragOverEvent, "dataTransfer", {
+      value: { dropEffect: "none" },
+    });
+    row.dispatchEvent(dragOverEvent);
+    // Component should still show the node without crashing.
+    expect(screen.queryByText("dropdir")).toBeTruthy();
+  });
+
+  it("non-directory rows do not crash when onDropToTarget is provided", () => {
+    const onDropToTarget = vi.fn();
+    const file = makeNode("data.csv", { isDir: false, path: "/data.csv" });
+    // Should render without error even with onDropToTarget (files ignore it)
+    render(<FileTree nodes={[file]} {...EMPTY_CALLBACKS} onDropToTarget={onDropToTarget} expandedDirs={new Set()} />);
+    expect(screen.getByText("data.csv")).toBeTruthy();
+  });
+});
+
+describe("FileTree — nested tree", () => {
+  it("three-level deep tree renders all three levels", () => {
+    const level3 = makeNode("deep.ts", { isDir: false, path: "/a/b/c/deep.ts" });
+    const level2 = makeNode("b", { isDir: true, path: "/a/b", children: [level3] });
+    const level1 = makeNode("a", { isDir: true, path: "/a", children: [level2] });
+    render(<FileTree nodes={[level1]} {...EMPTY_CALLBACKS} expandedDirs={new Set(["/a", "/a/b"])} />);
+    expect(screen.getByText("a")).toBeTruthy();
+    expect(screen.getByText("b")).toBeTruthy();
+    expect(screen.getByText("deep.ts")).toBeTruthy();
+  });
+
+  it("only renders expanded paths — /a expanded but /a/b collapsed hides level 3", () => {
+    const level3 = makeNode("secret.ts", { isDir: false, path: "/a/b/secret.ts" });
+    const level2 = makeNode("b", { isDir: true, path: "/a/b", children: [level3] });
+    const level1 = makeNode("a", { isDir: true, path: "/a", children: [level2] });
+    render(<FileTree nodes={[level1]} {...EMPTY_CALLBACKS} expandedDirs={new Set(["/a"])} />);
+    // "a" is expanded: shows name + "b" as a collapsed child
+    expect(screen.getByText("a")).toBeTruthy();
+    expect(screen.getByText("▶")).toBeTruthy(); // "b" is collapsed (▶ not ▼)
+    // "secret.ts" is NOT rendered because /a/b is not expanded
+    expect(screen.queryByText("secret.ts")).toBeNull();
+  });
+});

canvas/src/components/tabs/SkillsTab.tsx

@@ -325,7 +325,7 @@ export function SkillsTab({ workspaceId, data }: Props) {
           </div>
           <button
             onClick={() => setShowRegistry(true)}
-            className="rounded-full border border-violet-700/50 bg-violet-950/30 px-3 py-0.5 text-[10px] text-violet-200 hover:bg-violet-900/40 transition-colors"
+            className="rounded-full border border-violet-700/50 bg-violet-950/30 px-3 py-0.5 text-[10px] text-violet-200 hover:bg-violet-900/40 transition-colors focus:outline-none focus-visible:ring-2 focus-visible:ring-violet-400"
             aria-expanded="false"
             aria-controls="plugins-section"
           >
@@ -349,7 +349,7 @@ export function SkillsTab({ workspaceId, data }: Props) {
           </div>
           <button
             onClick={() => setShowRegistry(!showRegistry)}
-            className="rounded-full border border-violet-700/50 bg-violet-950/30 px-3 py-1 text-[10px] text-violet-200 hover:bg-violet-900/40 transition-colors"
+            className="rounded-full border border-violet-700/50 bg-violet-950/30 px-3 py-1 text-[10px] text-violet-200 hover:bg-violet-900/40 transition-colors focus:outline-none focus-visible:ring-2 focus-visible:ring-violet-400"
             aria-expanded={showRegistry}
             aria-controls="plugins-registry"
           >
@@ -401,7 +401,7 @@ export function SkillsTab({ workspaceId, data }: Props) {
                   <button
                     onClick={() => handleUninstall(p.name)}
                     disabled={uninstalling === p.name}
-                    className="shrink-0 rounded-full border border-red-800/40 bg-red-950/20 px-2 py-0.5 text-[11px] text-bad hover:bg-red-900/30 disabled:opacity-30"
+                    className="shrink-0 rounded-full border border-red-800/40 bg-red-950/20 px-2 py-0.5 text-[11px] text-bad hover:bg-red-900/30 disabled:opacity-30 focus:outline-none focus-visible:ring-2 focus-visible:ring-red-400"
                   >
                     {uninstalling === p.name ? "..." : "Remove"}
                   </button>
@@ -449,7 +449,7 @@ export function SkillsTab({ workspaceId, data }: Props) {
                 <button
                   onClick={handleInstallCustom}
                   disabled={!customSource.trim() || installing !== null}
-                  className="shrink-0 rounded-full border border-violet-700/50 bg-violet-950/30 px-2.5 py-1 text-[11px] text-violet-300 hover:bg-violet-900/40 disabled:opacity-30"
+                  className="shrink-0 rounded-full border border-violet-700/50 bg-violet-950/30 px-2.5 py-1 text-[11px] text-violet-300 hover:bg-violet-900/40 disabled:opacity-30 focus:outline-none focus-visible:ring-2 focus-visible:ring-violet-400"
                 >
                   {installing === customSource.trim() ? "Installing..." : "Install"}
                 </button>
@@ -538,7 +538,7 @@ export function SkillsTab({ workspaceId, data }: Props) {
                         <button
                           onClick={() => handleInstall(p.name)}
                           disabled={installing === p.name}
-                          className="shrink-0 rounded-full border border-violet-700/50 bg-violet-950/30 px-2.5 py-0.5 text-[11px] text-violet-300 hover:bg-violet-900/40 disabled:opacity-30"
+                          className="shrink-0 rounded-full border border-violet-700/50 bg-violet-950/30 px-2.5 py-0.5 text-[11px] text-violet-300 hover:bg-violet-900/40 disabled:opacity-30 focus:outline-none focus-visible:ring-2 focus-visible:ring-violet-400"
                         >
                           {installing === p.name ? "Installing..." : "Install"}
                         </button>
@@ -570,13 +570,13 @@ export function SkillsTab({ workspaceId, data }: Props) {
         <div className="mt-3 flex flex-wrap gap-2">
           <button
             onClick={() => setPanelTab("config")}
-            className="rounded-full border border-line bg-surface px-3 py-1 text-[10px] text-ink-mid hover:bg-surface-sunken"
+            className="rounded-full border border-line bg-surface px-3 py-1 text-[10px] text-ink-mid hover:bg-surface-sunken focus:outline-none focus-visible:ring-2 focus-visible:ring-accent/40"
           >
             Open Config
           </button>
           <button
             onClick={() => setPanelTab("files")}
-            className="rounded-full border border-line bg-surface px-3 py-1 text-[10px] text-ink-mid hover:bg-surface-sunken"
+            className="rounded-full border border-line bg-surface px-3 py-1 text-[10px] text-ink-mid hover:bg-surface-sunken focus:outline-none focus-visible:ring-2 focus-visible:ring-accent/40"
           >
             Open Files
           </button>

canvas/src/components/tabs/chat/AgentCommsPanel.tsx

@@ -405,7 +405,7 @@ export function AgentCommsPanel({ workspaceId }: { workspaceId: string }) {
         </p>
         <button
           onClick={loadInitial}
-          className="text-[10px] px-2 py-0.5 rounded bg-red-800/40 text-bad hover:bg-red-700/50 transition-colors"
+          className="text-[10px] px-2 py-0.5 rounded bg-red-800/40 text-bad hover:bg-red-700/50 transition-colors focus:outline-none focus-visible:ring-2 focus-visible:ring-red-400"
         >
           Retry
         </button>
@@ -610,7 +610,7 @@ function PeerTabButton({
       aria-selected={active}
       tabIndex={active ? 0 : -1}
       onClick={onClick}
-      className={`shrink-0 px-3 py-1.5 text-[10px] font-medium transition-colors whitespace-nowrap ${
+      className={`shrink-0 px-3 py-1.5 text-[10px] font-medium transition-colors whitespace-nowrap focus:outline-none focus-visible:ring-2 focus-visible:ring-cyan-400 ${
         active
           ? "border-b-2 border-cyan-500 text-cyan-200"
           : "border-b-2 border-transparent text-ink-mid hover:text-ink-mid"

canvas/src/components/tabs/chat/AttachmentViews.tsx

@@ -33,7 +33,7 @@ export function PendingAttachmentPill({
       <button
         onClick={onRemove}
         aria-label={`Remove ${file.name}`}
-        className="ml-0.5 text-ink-mid hover:text-ink transition-colors shrink-0"
+        className="ml-0.5 text-ink-mid hover:text-ink transition-colors shrink-0 focus:outline-none focus-visible:ring-2 focus-visible:ring-accent/40"
       >
         <svg width="10" height="10" viewBox="0 0 16 16" fill="none" aria-hidden="true">
           <path d="M4 4l8 8M12 4l-8 8" stroke="currentColor" strokeWidth="1.6" strokeLinecap="round" />
@@ -63,7 +63,7 @@ export function AttachmentChip({
     <button
       onClick={() => onDownload(attachment)}
       title={`Download ${attachment.name}`}
-      className={`flex items-center gap-1.5 rounded-md border px-2 py-1 text-[10px] transition-colors max-w-full ${toneClasses}`}
+      className={`flex items-center gap-1.5 rounded-md border px-2 py-1 text-[10px] transition-colors max-w-full focus:outline-none focus-visible:ring-2 focus-visible:ring-accent/40 ${toneClasses}`}
     >
       <FileGlyph className="shrink-0 opacity-70" />
       <span className="truncate">{attachment.name}</span>

canvas/src/components/tabs/chat/__tests__/a2aErrorHint.test.ts

@@ -64,66 +64,4 @@ describe("inferA2AErrorHint", () => {
     expect(hint).toMatch(/Claude Code SDK/);
     expect(hint).not.toMatch(/proxy timeout/);
   });
-
-  // ---- P1 #348: poll-mode timeout-class detection ----
-
-  it("routes poll-mode budget exhaustion to its specific actionable hint", () => {
-    // a2a_tools_delegation.py emits this exact shape after the 600s
-    // budget. The user must NOT be told to restart — the work is
-    // still in flight on the platform side.
-    const hint = inferA2AErrorHint(
-      "polling timeout after 600s (delegation_id=abc, last_status=processing); the platform is still working on it — call check_task_status('abc') to retrieve later",
-    );
-    expect(hint).toMatch(/Do NOT restart/);
-    expect(hint).toMatch(/check_task_status/);
-  });
-
-  it("matches the check_task_status hint clue even without the 'polling timeout' phrase", () => {
-    const hint = inferA2AErrorHint(
-      "platform busy — call check_task_status('xyz')",
-    );
-    expect(hint).toMatch(/check_task_status/);
-  });
-
-  it("poll-mode hint wins over the generic timeout bucket", () => {
-    // The string contains both "polling timeout after" and "timeout"
-    // — the more-specific poll-mode hint must win so users don't get
-    // the generic "restart" advice for a still-in-flight task.
-    const hint = inferA2AErrorHint("polling timeout after 600s ...");
-    expect(hint).toMatch(/Do NOT restart/);
-    expect(hint).not.toMatch(/restart the workspace if this repeats/);
-  });
-
-  // ---- P1 #348: codex-aware specialization ----
-
-  it("specialises the empty-detail hint for codex callees", () => {
-    // Per feedback_surface_actionable_failure_reason_to_user: opaque
-    // restart prompts are the anti-pattern. With peerKind=codex the
-    // hint explicitly de-recommends restart.
-    const hint = inferA2AErrorHint("", { peerKind: "codex" });
-    expect(hint).toMatch(/codex/);
-    expect(hint).toMatch(/check its Activity tab/i);
-    expect(hint).not.toMatch(/A workspace restart is the safe first move/);
-  });
-
-  it("specialises generic-timeout hint for codex callees", () => {
-    const hint = inferA2AErrorHint("ReadTimeout", { peerKind: "codex" });
-    expect(hint).toMatch(/codex/);
-    expect(hint).toMatch(/600s/);
-  });
-
-  it("falls back to the non-codex generic timeout hint when no peerKind given", () => {
-    const hint = inferA2AErrorHint("ReadTimeout");
-    expect(hint).toMatch(/proxy timeout/);
-    expect(hint).not.toMatch(/600s sync-proxy/);
-  });
-
-  it("preserves existing empty-detail wording when no peer context provided", () => {
-    const hint = inferA2AErrorHint("");
-    expect(hint).toMatch(/no error detail/);
-    // Updated wording: must NOT be the bare "restart is the safe
-    // first move" line — that violates surface-actionable-reason.
-    expect(hint).not.toMatch(/safe first move/);
-    expect(hint).toMatch(/Activity tab/);
-  });
 });

canvas/src/components/tabs/chat/__tests__/message-parser.test.ts

@@ -248,88 +248,6 @@ describe("extractResponseText", () => {
   });
 });
 
-describe("extractAgentText", () => {
-  it("extracts text from top-level parts", () => {
-    const task = {
-      parts: [{ kind: "text", text: "Agent said hello" }],
-    };
-    expect(extractAgentText(task)).toBe("Agent said hello");
-  });
-
-  it("extracts from artifacts[0].parts when top-level parts absent", () => {
-    const task = {
-      artifacts: [
-        { parts: [{ kind: "text", text: "From artifact block" }] },
-      ],
-    };
-    expect(extractAgentText(task)).toBe("From artifact block");
-  });
-
-  it("extracts from status.message.parts as fallback", () => {
-    const task = {
-      status: {
-        message: { parts: [{ kind: "text", text: "Status text" }] },
-      },
-    };
-    expect(extractAgentText(task)).toBe("Status text");
-  });
-
-  it("prefers top-level parts over artifacts", () => {
-    const task = {
-      parts: [{ kind: "text", text: "top-level wins" }],
-      artifacts: [
-        { parts: [{ kind: "text", text: "artifact text" }] },
-      ],
-    };
-    expect(extractAgentText(task)).toBe("top-level wins");
-  });
-
-  it("prefers top-level parts over status.message", () => {
-    const task = {
-      parts: [{ kind: "text", text: "parts wins" }],
-      status: {
-        message: { parts: [{ kind: "text", text: "status text" }] },
-      },
-    };
-    expect(extractAgentText(task)).toBe("parts wins");
-  });
-
-  it("returns string identity when task itself is a string", () => {
-    expect(extractAgentText("plain string task" as unknown as Record<string, unknown>)).toBe(
-      "plain string task",
-    );
-  });
-
-  it("returns fallback when task is an empty object", () => {
-    expect(extractAgentText({})).toBe("(Could not extract response text)");
-  });
-
-  it("returns fallback when task has no extractable text", () => {
-    expect(
-      extractAgentText({ status: "running", other: "fields" }),
-    ).toBe("(Could not extract response text)");
-  });
-
-  it("tolerates malformed nested shapes without throwing", () => {
-    const task = {
-      parts: null,
-      artifacts: "not an array",
-      status: { message: 42 },
-    };
-    expect(extractAgentText(task)).toBe("(Could not extract response text)");
-  });
-
-  it("joins multiple text parts with newline", () => {
-    const task = {
-      parts: [
-        { kind: "text", text: "Line one" },
-        { kind: "text", text: "Line two" },
-      ],
-    };
-    expect(extractAgentText(task)).toBe("Line one\nLine two");
-  });
-});
-
 describe("extractTextsFromParts", () => {
   it("extracts text parts with kind=text", () => {
     const parts = [

canvas/src/components/tabs/chat/__tests__/resolveWorkspaceName.test.ts

@@ -1,102 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { useCanvasStore } from "@/store/canvas";
-import { resolveWorkspaceName } from "../hooks/resolveWorkspaceName";
-
-beforeEach(() => {
-  // Reset store to a clean slate between tests so node lookup is deterministic.
-  useCanvasStore.setState({ nodes: [] });
-});
-
-describe("resolveWorkspaceName", () => {
-  it("returns the workspace name when a node with that ID exists", () => {
-    useCanvasStore.setState({
-      nodes: [
-        {
-          id: "ws-alpha-001",
-          type: "workspace",
-          data: { name: "Alpha Agent" },
-          position: { x: 0, y: 0 },
-        },
-      ],
-    });
-
-    expect(resolveWorkspaceName("ws-alpha-001")).toBe("Alpha Agent");
-  });
-
-  it("falls back to the first 8 chars of the ID when no matching node exists", () => {
-    expect(resolveWorkspaceName("ws-zzz-not-found")).toBe("ws-zzz-n");
-  });
-
-  it("falls back to the first 8 chars when the node exists but has no name", () => {
-    useCanvasStore.setState({
-      nodes: [
-        {
-          id: "ws-no-name",
-          type: "workspace",
-          // data.name is deliberately absent
-          data: {},
-          position: { x: 0, y: 0 },
-        },
-      ],
-    });
-
-    expect(resolveWorkspaceName("ws-no-name")).toBe("ws-no-na");
-  });
-
-  it("returns the first 8 chars for a very short ID", () => {
-    expect(resolveWorkspaceName("ab")).toBe("ab");
-  });
-
-  it("returns the first 8 chars when the ID is exactly 8 characters", () => {
-    // slice(0,8) of an 8-char string is the full string
-    const id = "12345678";
-    expect(resolveWorkspaceName(id)).toBe(id);
-  });
-
-  it("picks the right node when multiple workspaces share a prefix", () => {
-    useCanvasStore.setState({
-      nodes: [
-        {
-          id: "00000000-0000-0000-0000-000000000001",
-          type: "workspace",
-          data: { name: "Backend Agent" },
-          position: { x: 0, y: 0 },
-        },
-        {
-          id: "00000000-0000-0000-0000-000000000002",
-          type: "workspace",
-          data: { name: "Frontend Agent" },
-          position: { x: 100, y: 0 },
-        },
-      ],
-    });
-
-    expect(resolveWorkspaceName("00000000-0000-0000-0000-000000000002")).toBe(
-      "Frontend Agent"
-    );
-    expect(resolveWorkspaceName("00000000-0000-0000-0000-000000000001")).toBe(
-      "Backend Agent"
-    );
-  });
-
-  it("does not mutate store state between calls", () => {
-    useCanvasStore.setState({
-      nodes: [
-        {
-          id: "stable-id",
-          type: "workspace",
-          data: { name: "Stable Workspace" },
-          position: { x: 0, y: 0 },
-        },
-      ],
-    });
-
-    resolveWorkspaceName("stable-id");
-    resolveWorkspaceName("unknown-id");
-
-    // Store nodes must be unchanged — resolveWorkspaceName is read-only.
-    const nodes = useCanvasStore.getState().nodes;
-    expect(nodes).toHaveLength(1);
-    expect((nodes[0] as { id: string }).id).toBe("stable-id");
-  });
-});

canvas/src/components/tabs/chat/__tests__/useChatSocket.userMessage.test.ts

@@ -1,216 +0,0 @@
-// @vitest-environment jsdom
-/**
- * Tests for USER_MESSAGE event handling in useChatSocket.
- *
- * Covers issue #228: a canvas user's own outbound message was not fanned
- * out to other sessions — the originating session inserted it optimistically,
- * but other sessions only saw it after a manual refresh.
- *
- * The server now broadcasts USER_MESSAGE on canvas message/send. This test
- * verifies the canvas side consumes and forwards it to onUserMessage.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { renderHook, act } from "@testing-library/react";
-import React from "react";
-import { useChatSocket, type UseChatSocketCallbacks } from "../hooks/useChatSocket";
-import { emitSocketEvent, _resetSocketEventListenersForTests } from "@/store/socket-events";
-import type { WSMessage } from "@/store/socket";
-
-// Silence React StrictMode double-invoke noise — we care about final state.
-const WARN = console.warn;
-beforeEach(() => { console.warn = () => {}; });
-afterEach(() => { console.warn = WARN; });
-
-beforeEach(() => {
-  _resetSocketEventListenersForTests();
-  vi.useFakeTimers();
-  vi.setSystemTime(new Date("2026-05-18T10:00:00Z"));
-});
-afterEach(() => {
-  vi.useRealTimers();
-  _resetSocketEventListenersForTests();
-});
-
-const WORKSPACE_ID = "00000000-0000-0000-0000-000000000001";
-
-function makeUserMessageEvent(
-  workspaceId: string,
-  overrides: Partial<{
-    message: string;
-    attachments: Array<{ uri: string; name: string; mimeType?: string; size?: number }>;
-    messageId: string;
-  }> = {},
-): WSMessage {
-  const { message = "Hello, agent!", attachments, messageId } = overrides;
-  const payload: Record<string, unknown> = { message };
-  if (attachments) payload.attachments = attachments;
-  if (messageId) payload.messageId = messageId;
-  return {
-    event: "USER_MESSAGE",
-    workspace_id: workspaceId,
-    timestamp: "2026-05-18T10:00:00Z",
-    payload,
-  };
-}
-
-describe("useChatSocket USER_MESSAGE handling", () => {
-  it("calls onUserMessage with a ChatMessage when USER_MESSAGE arrives for matching workspace", () => {
-    const onUserMessage = vi.fn();
-    const callbacks: UseChatSocketCallbacks = { onUserMessage };
-    const { result } = renderHook(() => useChatSocket(WORKSPACE_ID, callbacks));
-
-    act(() => {
-      emitSocketEvent(makeUserMessageEvent(WORKSPACE_ID, { message: "Hello!" }));
-    });
-
-    expect(onUserMessage).toHaveBeenCalledTimes(1);
-    const msg = onUserMessage.mock.calls[0][0];
-    expect(msg.role).toBe("user");
-    expect(msg.content).toBe("Hello!");
-    expect(typeof msg.id).toBe("string");
-    expect(msg.timestamp).toBe("2026-05-18T10:00:00.000Z");
-  });
-
-  it("calls onUserMessage with attachments extracted from the payload", () => {
-    const onUserMessage = vi.fn();
-    const callbacks: UseChatSocketCallbacks = { onUserMessage };
-    renderHook(() => useChatSocket(WORKSPACE_ID, callbacks));
-
-    act(() => {
-      emitSocketEvent(
-        makeUserMessageEvent(WORKSPACE_ID, {
-          message: "Here is the file",
-          attachments: [
-            { uri: "workspace:/uploads/report.pdf", name: "report.pdf", mimeType: "application/pdf", size: 4096 },
-          ],
-        }),
-      );
-    });
-
-    expect(onUserMessage).toHaveBeenCalledTimes(1);
-    const msg = onUserMessage.mock.calls[0][0];
-    expect(msg.role).toBe("user");
-    expect(msg.content).toBe("Here is the file");
-    expect(msg.attachments).toHaveLength(1);
-    expect(msg.attachments![0].uri).toBe("workspace:/uploads/report.pdf");
-    expect(msg.attachments![0].name).toBe("report.pdf");
-    expect(msg.attachments![0].mimeType).toBe("application/pdf");
-    expect(msg.attachments![0].size).toBe(4096);
-  });
-
-  it("does NOT call onUserMessage when workspace_id does not match", () => {
-    const onUserMessage = vi.fn();
-    const callbacks: UseChatSocketCallbacks = { onUserMessage };
-    renderHook(() => useChatSocket(WORKSPACE_ID, callbacks));
-
-    act(() => {
-      emitSocketEvent(
-        makeUserMessageEvent("00000000-0000-0000-0000-000000000099", { message: "wrong workspace" }),
-      );
-    });
-
-    expect(onUserMessage).not.toHaveBeenCalled();
-  });
-
-  it("does NOT call onUserMessage when message is empty and no attachments", () => {
-    const onUserMessage = vi.fn();
-    const callbacks: UseChatSocketCallbacks = { onUserMessage };
-    renderHook(() => useChatSocket(WORKSPACE_ID, callbacks));
-
-    act(() => {
-      emitSocketEvent(makeUserMessageEvent(WORKSPACE_ID, { message: "" }));
-    });
-
-    expect(onUserMessage).not.toHaveBeenCalled();
-  });
-
-  it("ignores USER_MESSAGE when onUserMessage callback is undefined", () => {
-    const callbacks: UseChatSocketCallbacks = { onAgentMessage: vi.fn() };
-    // Should not throw — undefined callback is guarded
-    expect(() =>
-      renderHook(() => useChatSocket(WORKSPACE_ID, callbacks)),
-    ).not.toThrow();
-
-    const { result } = renderHook(() => useChatSocket(WORKSPACE_ID, callbacks));
-    act(() => {
-      emitSocketEvent(makeUserMessageEvent(WORKSPACE_ID, { message: "Hello" }));
-    });
-    // No error thrown even without onUserMessage
-  });
-
-  it("other event types do NOT trigger onUserMessage", () => {
-    const onUserMessage = vi.fn();
-    const callbacks: UseChatSocketCallbacks = { onUserMessage };
-    renderHook(() => useChatSocket(WORKSPACE_ID, callbacks));
-
-    act(() => {
-      emitSocketEvent({
-        event: "A2A_RESPONSE",
-        workspace_id: WORKSPACE_ID,
-        timestamp: "2026-05-18T10:00:00Z",
-        payload: {},
-      });
-    });
-
-    expect(onUserMessage).not.toHaveBeenCalled();
-  });
-
-  it("re-fires onUserMessage for each USER_MESSAGE event received", () => {
-    const onUserMessage = vi.fn();
-    const callbacks: UseChatSocketCallbacks = { onUserMessage };
-    renderHook(() => useChatSocket(WORKSPACE_ID, callbacks));
-
-    act(() => {
-      emitSocketEvent(makeUserMessageEvent(WORKSPACE_ID, { message: "First message" }));
-    });
-    act(() => {
-      emitSocketEvent(makeUserMessageEvent(WORKSPACE_ID, { message: "Second message" }));
-    });
-
-    expect(onUserMessage).toHaveBeenCalledTimes(2);
-    expect(onUserMessage.mock.calls[0][0].content).toBe("First message");
-    expect(onUserMessage.mock.calls[1][0].content).toBe("Second message");
-  });
-
-  it("handles USER_MESSAGE with messageId in payload", () => {
-    const onUserMessage = vi.fn();
-    const callbacks: UseChatSocketCallbacks = { onUserMessage };
-    renderHook(() => useChatSocket(WORKSPACE_ID, callbacks));
-
-    act(() => {
-      emitSocketEvent(
-        makeUserMessageEvent(WORKSPACE_ID, { message: "With ID", messageId: "msg-id-abc" }),
-      );
-    });
-
-    expect(onUserMessage).toHaveBeenCalledTimes(1);
-    const msg = onUserMessage.mock.calls[0][0];
-    expect(msg.content).toBe("With ID");
-  });
-
-  it("filters out attachments with empty uri or name (defence-in-depth)", () => {
-    const onUserMessage = vi.fn();
-    const callbacks: UseChatSocketCallbacks = { onUserMessage };
-    renderHook(() => useChatSocket(WORKSPACE_ID, callbacks));
-
-    act(() => {
-      emitSocketEvent(
-        makeUserMessageEvent(WORKSPACE_ID, {
-          message: "Mixed attachments",
-          attachments: [
-            { uri: "workspace:/uploads/good.pdf", name: "good.pdf" },
-            { uri: "", name: "bad.pdf" }, // empty uri — dropped
-            { uri: "workspace:/uploads/also-bad", name: "" }, // empty name — dropped
-            { uri: "workspace:/uploads/also-good.txt", name: "also-good.txt" },
-          ],
-        }),
-      );
-    });
-
-    expect(onUserMessage).toHaveBeenCalledTimes(1);
-    const msg = onUserMessage.mock.calls[0][0];
-    expect(msg.attachments).toHaveLength(2);
-    expect(msg.attachments![0].name).toBe("good.pdf");
-    expect(msg.attachments![1].name).toBe("also-good.txt");
-  });
-});

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

@@ -10,37 +10,10 @@
  * had already drifted (Activity tab gained `not found`/`offline`
  * cases AgentCommsPanel never picked up) — this module is the merged
  * superset and the only place hint text should change.
- *
- * Optional `context.peerKind` lets callers signal "the callee was a
- * codex-runtime task" so the timeout-class hints can be more specific
- * about expected long completion times (PM-coordinating-Researcher is
- * the canonical case where the 600s sync-proxy budget is too tight).
  */
-export interface A2AErrorContext {
-  /** Runtime of the callee, when known. e.g. "codex", "claude-code". */
-  peerKind?: string;
-}
-
-export function inferA2AErrorHint(
-  detail: string,
-  context?: A2AErrorContext,
-): string {
+export function inferA2AErrorHint(detail: string): string {
   const t = detail.toLowerCase();
 
-  // Poll-mode budget exhaustion (a2a_tools_delegation.py emits
-  // "polling timeout after Ns ... call check_task_status(...) to
-  // retrieve later"). This is NOT a delivery failure — the work is
-  // still in flight on the platform side. Route to a specific hint
-  // BEFORE the generic timeout bucket so the user gets the actionable
-  // "wait + check_task_status" guidance instead of the misleading
-  // "restart the workspace" anti-pattern.
-  if (
-    t.includes("polling timeout after") ||
-    t.includes("call check_task_status")
-  ) {
-    return "The 600s sync-polling budget expired but the platform is still working on the delegation. Do NOT restart — the work isn't lost. Wait, then call check_task_status with the delegation_id to retrieve the result. If the callee is a long-running codex task, this is expected.";
-  }
-
   // "control request timeout" is the specific Claude Code SDK init
   // wedge symptom. Pattern on the full phrase, not bare "initialize"
   // — a user task containing "failed to initialize database" would
@@ -54,13 +27,6 @@ export function inferA2AErrorHint(
     t.includes("deadline exceeded") ||
     t.includes("timeout")
   ) {
-    // For codex callees, a 600s sync-proxy timeout is the EXPECTED
-    // shape when the task is genuinely long-running. Calling out the
-    // workspace-restart anti-pattern explicitly per
-    // `feedback_surface_actionable_failure_reason_to_user`.
-    if ((context?.peerKind || "").toLowerCase() === "codex") {
-      return "The codex remote agent didn't respond within the 600s sync-proxy timeout. Codex tasks can legitimately run longer than this — check the callee's Activity tab; the work may still be progressing. Restart only if the container is genuinely stuck (no activity for several minutes).";
-    }
     return "The remote agent didn't respond within the proxy timeout. It may be busy with a long task, or the runtime is stuck — restart the workspace if this repeats.";
   }
   if (
@@ -82,16 +48,7 @@ export function inferA2AErrorHint(
     return "The remote workspace can't be reached — it may be stopped, removed, or outside the access control list. Verify the peer is online before retrying.";
   }
   if (detail === "") {
-    // Per `feedback_surface_actionable_failure_reason_to_user`: a bare
-    // "restart the workspace" prompt is the anti-pattern when the
-    // underlying failure was a silent timeout against a long-running
-    // remote (codex Researcher being coordinated by PM is the
-    // canonical case). If the caller knows the peer is codex, route
-    // to the more specific hint that explicitly de-recommends restart.
-    if ((context?.peerKind || "").toLowerCase() === "codex") {
-      return "The codex remote agent returned no error detail — most often the 600s sync-proxy budget expired before the task finished. The work may still be progressing on the callee side; check its Activity tab before restarting.";
-    }
-    return "The remote agent returned no error detail (the underlying httpx exception had an empty message — typically a connection-reset or silent timeout). Check the callee's Activity tab to see if work is still in flight before restarting.";
+    return "The remote agent returned no error detail (the underlying httpx exception had an empty message — typically a connection-reset or silent timeout). A workspace restart is the safe first move.";
   }
   return "The remote agent reported a delivery failure. Check the workspace logs or try restarting.";
 }

canvas/src/components/tabs/chat/hooks/__tests__/useChatSend.test.tsx

@@ -1,209 +0,0 @@
-// @vitest-environment jsdom
-/**
- * Tests for useChatSend — the canvas user→agent send hook.
- *
- * Behavioural focus: the poll-mode ("queued") path. When the target
- * workspace is an external / MCP-registered agent (delivery_mode=poll,
- * e.g. an operator laptop running the molecule MCP channel), the
- * platform's POST /workspaces/:id/a2a returns a synthetic
- * {status:"queued", delivery_mode:"poll"} envelope IMMEDIATELY with no
- * reply — the real reply arrives later over the AGENT_MESSAGE
- * WebSocket push.
- *
- * Pre-fix the hook treated that synthetic envelope as a terminal
- * response and called releaseSendGuards() → `sending` went false the
- * instant the POST returned → the "agent is working" indicator
- * vanished and the external turn looked dead. This suite pins the
- * fixed contract:
- *
- *   - a real reply still clears `sending` (regression guard)
- *   - a poll "queued" envelope KEEPS `sending` true (no terminal
- *     clear) so the existing thinking indicator persists
- *   - the eventual reply path (releaseSendGuards, the same call the
- *     AGENT_MESSAGE WS push makes via useChatSocket) clears it
- *   - an offline poll agent that never replies eventually surfaces an
- *     honest error instead of an infinite spinner
- *
- * Plus pure-function coverage for the poll-envelope detector.
- *
- * Root cause: workspace-server a2a_proxy.go:402 poll-mode
- * short-circuit returns {status:"queued"} synchronously.
- */
-import {
-  describe,
-  it,
-  expect,
-  vi,
-  beforeEach,
-  afterEach,
-  type Mock,
-} from "vitest";
-import { act, renderHook, cleanup } from "@testing-library/react";
-
-const { mockApiPost } = vi.hoisted(() => ({ mockApiPost: vi.fn() }));
-
-vi.mock("@/lib/api", () => ({
-  api: { post: mockApiPost },
-}));
-
-vi.mock("../uploads", () => ({
-  uploadChatFiles: vi.fn(),
-}));
-
-// Import AFTER mocks.
-import {
-  useChatSend,
-  isPollQueuedResponse,
-  extractReplyText,
-  POLL_QUEUED_REPLY_TIMEOUT_MS,
-} from "../useChatSend";
-
-const flush = () => act(async () => { await Promise.resolve(); });
-
-describe("isPollQueuedResponse", () => {
-  it("is true only for the synthetic poll-mode queued envelope", () => {
-    expect(isPollQueuedResponse({ status: "queued", delivery_mode: "poll" })).toBe(true);
-  });
-
-  it("is false for a real agent reply", () => {
-    expect(
-      isPollQueuedResponse({ result: { parts: [{ kind: "text", text: "hi" }] } }),
-    ).toBe(false);
-  });
-
-  it("is false for null / undefined / partial shapes", () => {
-    expect(isPollQueuedResponse(null)).toBe(false);
-    expect(isPollQueuedResponse(undefined)).toBe(false);
-    // status=queued without delivery_mode=poll is NOT the poll envelope
-    // — don't accidentally swallow a real reply that happens to carry
-    // an unrelated status field.
-    expect(isPollQueuedResponse({ status: "queued" })).toBe(false);
-    expect(isPollQueuedResponse({ delivery_mode: "poll" })).toBe(false);
-  });
-});
-
-describe("extractReplyText (regression guard — unchanged by fix)", () => {
-  it("collects text parts from result", () => {
-    expect(
-      extractReplyText({ result: { parts: [{ kind: "text", text: "hello" }] } }),
-    ).toBe("hello");
-  });
-  it("returns empty for the poll-queued envelope", () => {
-    expect(extractReplyText({ status: "queued", delivery_mode: "poll" })).toBe("");
-  });
-});
-
-describe("useChatSend — poll-mode in-progress state", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    mockApiPost.mockReset();
-  });
-  afterEach(() => {
-    vi.runOnlyPendingTimers();
-    vi.useRealTimers();
-    cleanup();
-  });
-
-  const setup = () => {
-    const onUserMessage = vi.fn();
-    const onAgentMessage = vi.fn();
-    const { result } = renderHook(() =>
-      useChatSend("ws-ext-1", {
-        getHistoryMessages: () => [],
-        onUserMessage,
-        onAgentMessage,
-      }),
-    );
-    return { result, onUserMessage, onAgentMessage };
-  };
-
-  it("a real reply clears `sending` (regression guard)", async () => {
-    mockApiPost.mockResolvedValue({
-      result: { parts: [{ kind: "text", text: "real reply" }] },
-    });
-    const { result, onAgentMessage } = setup();
-
-    await act(async () => {
-      void result.current.sendMessage("hi");
-    });
-    await flush();
-
-    expect(onAgentMessage).toHaveBeenCalledTimes(1);
-    expect(result.current.sending).toBe(false);
-  });
-
-  it("keeps `sending` true on a poll 'queued' envelope (no terminal clear)", async () => {
-    mockApiPost.mockResolvedValue({ status: "queued", delivery_mode: "poll" });
-    const { result, onAgentMessage } = setup();
-
-    await act(async () => {
-      void result.current.sendMessage("hi external agent");
-    });
-    await flush();
-
-    // The POST resolved, but it was only a queued ack — the indicator
-    // must stay up and no agent bubble should be rendered yet.
-    expect(result.current.sending).toBe(true);
-    expect(onAgentMessage).not.toHaveBeenCalled();
-    expect(result.current.error).toBeNull();
-  });
-
-  it("releaseSendGuards (the AGENT_MESSAGE-push path) clears the poll in-progress state", async () => {
-    mockApiPost.mockResolvedValue({ status: "queued", delivery_mode: "poll" });
-    const { result } = setup();
-
-    await act(async () => {
-      void result.current.sendMessage("hi");
-    });
-    await flush();
-    expect(result.current.sending).toBe(true);
-
-    // Simulate the terminal AGENT_MESSAGE WebSocket push arriving:
-    // useChatSocket's onAgentMessage / onSendComplete call
-    // releaseSendGuards. That must clear the in-progress state AND the
-    // safety timer (asserted by the next test).
-    act(() => {
-      result.current.releaseSendGuards();
-    });
-    expect(result.current.sending).toBe(false);
-  });
-
-  it("surfaces an honest error if a poll agent never replies (safety timeout)", async () => {
-    mockApiPost.mockResolvedValue({ status: "queued", delivery_mode: "poll" });
-    const { result } = setup();
-
-    await act(async () => {
-      void result.current.sendMessage("hi");
-    });
-    await flush();
-    expect(result.current.sending).toBe(true);
-
-    act(() => {
-      vi.advanceTimersByTime(POLL_QUEUED_REPLY_TIMEOUT_MS + 1000);
-    });
-
-    expect(result.current.sending).toBe(false);
-    expect(result.current.error).toMatch(/queued/i);
-  });
-
-  it("does NOT fire the safety error when the reply arrives before timeout", async () => {
-    mockApiPost.mockResolvedValue({ status: "queued", delivery_mode: "poll" });
-    const { result } = setup();
-
-    await act(async () => {
-      void result.current.sendMessage("hi");
-    });
-    await flush();
-
-    // Reply arrives (releaseSendGuards) well before the timeout.
-    act(() => {
-      result.current.releaseSendGuards();
-    });
-    act(() => {
-      vi.advanceTimersByTime(POLL_QUEUED_REPLY_TIMEOUT_MS + 1000);
-    });
-
-    expect(result.current.error).toBeNull();
-    expect(result.current.sending).toBe(false);
-  });
-});

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

@@ -2,7 +2,6 @@
 
 import { useCallback, useEffect, useRef, useState } from "react";
 import { api } from "@/lib/api";
-import { subscribeSocketResume } from "@/store/socket-events";
 import { type ChatMessage, appendMessageDeduped as appendMessageDedupedFn } from "../types";
 
 const INITIAL_HISTORY_LIMIT = 10;
@@ -83,23 +82,6 @@ export function useChatHistory(
     loadInitial();
   }, [loadInitial]);
 
-  // Back-fill on socket resume. The singleton WS emits this when it
-  // recovers from a down period (ordinary drop, or — the case this
-  // fixes — a mobile-browser background-suspend that silently killed
-  // the socket while the page was frozen). While the socket was dead
-  // every AGENT_MESSAGE / A2A_RESPONSE for this thread was missed, and
-  // the store's rehydrate() only re-pulls /workspaces status, not chat.
-  // Re-running loadInitial() re-fetches the latest persisted history —
-  // exactly what a navigate-away-and-back (remount) does today, but
-  // without the user having to do it. Shared by desktop ChatTab and
-  // MobileChat (both consume this hook), so the realtime path stays
-  // unified across surfaces rather than forked for mobile.
-  useEffect(() => {
-    return subscribeSocketResume(() => {
-      loadInitial();
-    });
-  }, [loadInitial]);
-
   const loadOlder = useCallback(async () => {
     if (inflightRef.current || !hasMoreRef.current) return;
     const oldest = oldestMessageRef.current;

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

@@ -1,6 +1,6 @@
 "use client";
 
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useRef, useState } from "react";
 import { api } from "@/lib/api";
 import { uploadChatFiles } from "../uploads";
 import { createMessage, type ChatMessage, type ChatAttachment } from "../types";
@@ -22,42 +22,8 @@ interface A2AResponse {
     parts?: A2APart[];
     artifacts?: Array<{ parts: A2APart[] }>;
   };
-  /** Synthetic poll-mode envelope. The platform returns this
-   *  immediately (HTTP 200) when the target workspace is registered
-   *  delivery_mode=poll — an external / MCP-registered agent with no
-   *  public URL (e.g. an operator's laptop running the molecule MCP
-   *  channel). The request has only been QUEUED into activity_logs;
-   *  the agent will pick it up on its next poll and the real reply
-   *  arrives asynchronously over the AGENT_MESSAGE WebSocket push
-   *  (consumed by useChatSocket). See workspace-server
-   *  a2a_proxy.go:402 (poll-mode short-circuit) and
-   *  a2a_proxy_helpers.go:516 (logA2AReceiveQueued). */
-  status?: string;
-  delivery_mode?: string;
 }
 
-/** True when `resp` is the platform's synthetic poll-mode "queued"
- *  envelope rather than a real agent reply. For these the send is
- *  acknowledged-but-pending: the user's message landed and the agent
- *  is working, but there is no reply yet — the terminal AGENT_MESSAGE
- *  push will arrive later over the WebSocket. Treating this as a
- *  terminal response (the pre-fix behaviour) cleared the "agent is
- *  working" indicator the instant the POST returned, so an external
- *  workspace turn looked dead even though work had not started. */
-export function isPollQueuedResponse(resp: A2AResponse | null | undefined): boolean {
-  return !!resp && resp.status === "queued" && resp.delivery_mode === "poll";
-}
-
-/** Hard ceiling on how long the "agent is working" indicator stays up
- *  for a poll-mode turn with no reply. The terminal AGENT_MESSAGE push
- *  normally clears it well before this. The cap exists so a poll-mode
- *  workspace that is offline / never consumes its queue doesn't pin a
- *  spinner forever — at which point we surface an honest, actionable
- *  error instead of an opaque dead spinner. Generous because poll
- *  agents (an operator laptop) can legitimately take minutes to wake,
- *  poll, and respond; the goal is "eventually honest", not fail-fast. */
-export const POLL_QUEUED_REPLY_TIMEOUT_MS = 15 * 60 * 1000;
-
 export function extractReplyText(resp: A2AResponse): string {
   const collect = (parts: A2APart[] | undefined): string => {
     if (!parts) return "";
@@ -93,29 +59,14 @@ export function useChatSend(workspaceId: string, options: UseChatSendOptions) {
   const sendInFlightRef = useRef(false);
   const sendingFromAPIRef = useRef(false);
   const sendTokenRef = useRef(0);
-  // Safety-net timer armed only for poll-mode ("queued") turns: the
-  // POST returns immediately with no reply, so the normal
-  // POST-resolves-→-clear-spinner path can't drive the indicator. The
-  // terminal AGENT_MESSAGE WebSocket push clears it via
-  // releaseSendGuards (which also clears this timer); the timer is the
-  // backstop for an offline poll agent that never consumes its queue.
-  const pollTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const optionsRef = useRef(options);
   optionsRef.current = options;
 
-  const clearPollTimeout = useCallback(() => {
-    if (pollTimeoutRef.current !== null) {
-      clearTimeout(pollTimeoutRef.current);
-      pollTimeoutRef.current = null;
-    }
-  }, []);
-
   const releaseSendGuards = useCallback(() => {
-    clearPollTimeout();
     setSending(false);
     sendingFromAPIRef.current = false;
     sendInFlightRef.current = false;
-  }, [clearPollTimeout]);
+  }, []);
 
   const clearError = useCallback(() => setError(null), []);
 
@@ -195,33 +146,6 @@ export function useChatSend(workspaceId: string, options: UseChatSendOptions) {
             sendInFlightRef.current = false;
             return;
           }
-          // Poll-mode ("queued") turn: the message landed and the
-          // external/MCP agent will pick it up on its next poll, but
-          // there is NO reply in this response. Pre-fix this fell
-          // through to releaseSendGuards() below and the "agent is
-          // working" indicator vanished the instant the POST returned —
-          // an external-workspace turn looked dead even though work had
-          // not started. Instead, keep `sending` true so the existing
-          // thinking indicator (the same one internal agents use)
-          // persists as a "received — agent is working" state; the
-          // terminal AGENT_MESSAGE WebSocket push (consumed by
-          // useChatSocket → onAgentMessage / onSendComplete →
-          // releaseSendGuards) clears it when the real reply arrives,
-          // exactly the path an internal async reply already uses.
-          if (isPollQueuedResponse(resp)) {
-            clearPollTimeout();
-            pollTimeoutRef.current = setTimeout(() => {
-              if (sendTokenRef.current !== myToken) return;
-              if (!sendingFromAPIRef.current) return;
-              releaseSendGuards();
-              setError(
-                "No response yet from this agent — it may be offline or " +
-                  "busy. Your message was delivered and is queued; the " +
-                  "reply will appear here if the agent picks it up.",
-              );
-            }, POLL_QUEUED_REPLY_TIMEOUT_MS);
-            return;
-          }
           const replyText = extractReplyText(resp);
           const replyFiles = extractFilesFromTask(
             (resp?.result ?? {}) as Record<string, unknown>,
@@ -243,15 +167,9 @@ export function useChatSend(workspaceId: string, options: UseChatSendOptions) {
           setError("Failed to send message — agent may be unreachable");
         });
     },
-    [workspaceId, sending, uploading, clearPollTimeout],
+    [workspaceId, sending, uploading],
   );
 
-  // Drop the poll-mode safety timer on unmount / workspace switch so a
-  // stale timeout can't fire setError against a panel the user has
-  // already navigated away from. sendTokenRef guards correctness if it
-  // ever did fire; this just avoids the wasted timer + setState churn.
-  useEffect(() => clearPollTimeout, [clearPollTimeout]);
-
   return {
     sending,
     uploading,

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

@@ -7,10 +7,6 @@ import { createMessage, type ChatMessage } from "../types";
 
 export interface UseChatSocketCallbacks {
   onAgentMessage?: (msg: ChatMessage) => void;
-  /** Called when another session sent a user message — used to fan out
-   *  the user's own outbound text to all sessions so a second device
-   *  sees the question live without a manual refresh (issue #228). */
-  onUserMessage?: (msg: ChatMessage) => void;
   onActivityLog?: (entry: string) => void;
   onSendComplete?: () => void;
   onSendError?: (error: string) => void;
@@ -47,33 +43,6 @@ export function useChatSocket(
 
   useSocketEvent((msg) => {
     try {
-      if (msg.event === "USER_MESSAGE" && msg.workspace_id === workspaceId) {
-        const p = msg.payload || {};
-        const message = typeof p.message === "string" ? p.message : "";
-        const rawAttachments = p.attachments;
-        const attachments =
-          Array.isArray(rawAttachments)
-            ? (rawAttachments as Array<{ uri?: unknown; name?: unknown; mimeType?: unknown; size?: unknown }>)
-                .filter(
-                  (a) =>
-                    typeof a?.uri === "string" && a.uri.length > 0 &&
-                    typeof a?.name === "string" && a.name.length > 0,
-                )
-                .map((a) => ({
-                  uri: a.uri as string,
-                  name: a.name as string,
-                  mimeType: typeof a.mimeType === "string" ? a.mimeType : undefined,
-                  size: typeof a.size === "number" ? a.size : undefined,
-                }))
-            : undefined;
-        if (message || (attachments && attachments.length > 0)) {
-          callbacksRef.current.onUserMessage?.(
-            createMessage("user", message, attachments),
-          );
-        }
-        return;
-      }
-
       if (msg.event === "ACTIVITY_LOGGED") {
         if (msg.workspace_id !== workspaceId) return;
 
@@ -98,21 +67,9 @@ export function useChatSocket(
             const own = (targetId || msg.workspace_id) === workspaceId;
             if (own) {
               callbacksRef.current.onSendComplete?.();
-              // internal#211/#212: surface the runtime's curated,
-              // user-actionable reason (provider HTTP status + error
-              // code + the provider's own guidance, e.g. a 403 "org
-              // disabled · use an API key / ask your admin"). The
-              // server now includes error_detail in the ACTIVITY_LOGGED
-              // broadcast; fall back to summary, and only as a last
-              // resort to a generic line. The old hardcoded
-              // "Agent error (Exception) — see workspace logs for
-              // details." string pointed at a logs UI that does not
-              // exist and discarded the actionable reason entirely.
-              const detail =
-                (p.error_detail as string) ||
-                (p.summary as string) ||
-                "The agent turn failed but the runtime reported no detail. Retry once; if it repeats the workspace runtime may need a restart.";
-              callbacksRef.current.onSendError?.(detail);
+              callbacksRef.current.onSendError?.(
+                "Agent error (Exception) — see workspace logs for details.",
+              );
             }
           }
         } else if (type === "a2a_send") {

canvas/src/components/ui/TestConnectionButton.tsx

@@ -2,7 +2,7 @@
 
 import { useState, useCallback, useRef, useEffect } from 'react';
 import type { TestConnectionState, SecretGroup } from '@/types/secrets';
-import { validateSecret, ApiError } from '@/lib/api/secrets';
+import { validateSecret } from '@/lib/api/secrets';
 
 interface TestConnectionButtonProps {
   provider: SecretGroup;
@@ -55,23 +55,9 @@ export function TestConnectionButton({
       }
       onResult?.(result.valid);
       resetTimerRef.current = setTimeout(() => setState('idle'), RESET_DELAYS[nextState]!);
-    } catch (err) {
-      // Distinguish a real failure shape rather than always claiming a
-      // timeout. A reachable server that answered with an HTTP status
-      // (ApiError) did NOT time out — most commonly the validation route
-      // is not available (404/501), which must not masquerade as
-      // "service down". Only an actual thrown network/abort error is a
-      // connectivity failure.
+    } catch {
       setState('failure');
-      if (err instanceof ApiError) {
-        setErrorDetail(
-          err.status === 404 || err.status === 501
-            ? 'Key validation is not available for this service yet. The key was not tested.'
-            : `Could not verify key (server returned ${err.status}). Saving is unaffected.`,
-        );
-      } else {
-        setErrorDetail('Could not reach the validation service. Check your connection and try again.');
-      }
+      setErrorDetail('Connection timed out. Service may be down.');
       onResult?.(false);
       resetTimerRef.current = setTimeout(() => setState('idle'), RESET_DELAYS.failure);
     }

canvas/src/components/ui/__tests__/TestConnectionButton.test.tsx

@@ -28,20 +28,8 @@ const mockValidateSecret = vi.fn();
 
 vi.mock("@/lib/api/secrets", () => ({
   validateSecret: (...args: unknown[]) => mockValidateSecret(...args),
-  ApiError: class ApiError extends Error {
-    status: number;
-    constructor(status: number, message: string) {
-      super(message);
-      this.name = "ApiError";
-      this.status = status;
-    }
-  },
 }));
 
-// Re-import the mocked ApiError so test cases construct the same class the
-// component's `instanceof` check sees.
-import { ApiError } from "@/lib/api/secrets";
-
 beforeEach(() => {
   vi.useFakeTimers();
   vi.clearAllMocks();
@@ -213,27 +201,8 @@ describe("TestConnectionButton — failure path", () => {
 });
 
 describe("TestConnectionButton — catch path", () => {
-  it("does NOT claim a timeout when the validate endpoint 404s (regression: internal#492)", async () => {
-    // The validate route is unimplemented on the server and returns a fast
-    // 404. Before the fix this rendered the misleading hardcoded string
-    // "Connection timed out. Service may be down." It must instead state
-    // honestly that validation isn't available and the key was not tested.
-    mockValidateSecret.mockRejectedValue(new ApiError(404, "Not Found"));
-    render(
-      <TestConnectionButton provider="anthropic" secretValue="sk-ant-xxx" />,
-    );
-    fireEvent.click(document.querySelector('button[type="button"]')!);
-    await act(async () => {
-      await vi.advanceTimersByTimeAsync(0);
-    });
-    expect(document.body.textContent).not.toContain("Connection timed out");
-    expect(document.body.textContent).not.toContain("Service may be down");
-    expect(document.body.textContent).toContain("not available");
-    expect(document.body.textContent).toContain("not tested");
-  });
-
-  it("reports a non-404 server error with its status, not a timeout", async () => {
-    mockValidateSecret.mockRejectedValue(new ApiError(500, "Internal Server Error"));
+  it("shows 'Connection timed out' on network error", async () => {
+    mockValidateSecret.mockRejectedValue(new Error("timeout"));
     render(
       <TestConnectionButton provider="github" secretValue="ghp_xxx" />,
     );
@@ -241,20 +210,7 @@ describe("TestConnectionButton — catch path", () => {
     await act(async () => {
       await vi.advanceTimersByTimeAsync(0);
     });
-    expect(document.body.textContent).toContain("500");
-    expect(document.body.textContent).not.toContain("Connection timed out");
-  });
-
-  it("shows a connectivity message on a genuine network error", async () => {
-    mockValidateSecret.mockRejectedValue(new Error("network down"));
-    render(
-      <TestConnectionButton provider="github" secretValue="ghp_xxx" />,
-    );
-    fireEvent.click(document.querySelector('button[type="button"]')!);
-    await act(async () => {
-      await vi.advanceTimersByTimeAsync(0);
-    });
-    expect(document.body.textContent).toContain("Could not reach the validation service");
+    expect(document.body.textContent).toContain("Connection timed out");
   });
 
   it("calls onResult(false) on network error", async () => {

canvas/src/hooks/__tests__/useKeyboardShortcut.test.tsx

@@ -1,166 +0,0 @@
-// @vitest-environment jsdom
-/**
- * Tests for useKeyboardShortcut.
- *
- * Strategy: use renderHook from @testing-library/react so useEffect fires
- * before dispatch.  We spy on window.addEventListener to capture the registered
- * handler.  Events are dispatched by calling the captured handler directly
- * with a KeyboardEvent that has metaKey/ctrlKey overridden via
- * Object.defineProperty (jsdom's built-in modifier-key event is unreliable).
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { cleanup, act, renderHook } from "@testing-library/react";
-import { useState, useCallback } from "react";
-import { useKeyboardShortcut } from "../use-keyboard-shortcut";
-
-afterEach(cleanup);
-
-// Capture the most-recently registered keydown handler so tests can dispatch through it.
-let registeredHandler: ((e: KeyboardEvent) => void) | null = null;
-
-const addSpy = vi.spyOn(window, "addEventListener").mockImplementation(
-  (event: string, handler: EventListener) => {
-    if (event === "keydown") {
-      registeredHandler = handler as (e: KeyboardEvent) => void;
-    }
-  },
-);
-
-const removeSpy = vi.spyOn(window, "removeEventListener").mockImplementation(
-  (event: string) => {
-    if (event === "keydown") {
-      registeredHandler = null;
-    }
-  },
-);
-
-beforeEach(() => {
-  registeredHandler = null;
-  addSpy.mockClear();
-  removeSpy.mockClear();
-});
-
-/**
- * Dispatch a keydown event through the captured handler.
- * Wrapped in act() so React flushes any state updates synchronously.
- * Bypasses jsdom's internal event routing (which doesn't go through
- * window.EventTarget.prototype.addEventListener for fireEvent dispatch).
- */
-function dispatchKeydown(
-  key: string,
-  { meta = false, ctrl = false }: { meta?: boolean; ctrl?: boolean } = {},
-) {
-  act(() => {
-    const e = new KeyboardEvent("keydown", { key, bubbles: true });
-    Object.defineProperty(e, "metaKey", { value: meta });
-    Object.defineProperty(e, "ctrlKey", { value: ctrl });
-    registeredHandler?.(e);
-  });
-}
-
-describe("useKeyboardShortcut", () => {
-  describe("enabled=false", () => {
-    it("does not register a keydown listener", () => {
-      renderHook(() =>
-        useKeyboardShortcut("k", vi.fn(), { enabled: false }),
-      );
-      expect(addSpy).not.toHaveBeenCalledWith("keydown", expect.any(Function));
-    });
-  });
-
-  describe("meta modifier", () => {
-    it("fires callback on Cmd+K", () => {
-      const cb = vi.fn();
-      renderHook(() => useKeyboardShortcut("k", cb, { meta: true }));
-      dispatchKeydown("k", { meta: true });
-      expect(cb).toHaveBeenCalledTimes(1);
-    });
-
-    it("does NOT fire on Ctrl+K when only meta=true", () => {
-      const cb = vi.fn();
-      renderHook(() => useKeyboardShortcut("k", cb, { meta: true }));
-      dispatchKeydown("k", { ctrl: true });
-      expect(cb).not.toHaveBeenCalled();
-    });
-
-    it("does NOT fire on plain K even with meta=true", () => {
-      const cb = vi.fn();
-      renderHook(() => useKeyboardShortcut("k", cb, { meta: true }));
-      dispatchKeydown("k", { meta: false, ctrl: false });
-      expect(cb).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("ctrl modifier", () => {
-    it("fires callback on Ctrl+K", () => {
-      const cb = vi.fn();
-      renderHook(() => useKeyboardShortcut("k", cb, { ctrl: true }));
-      dispatchKeydown("k", { ctrl: true });
-      expect(cb).toHaveBeenCalledTimes(1);
-    });
-
-    it("does NOT fire on Cmd+K when only ctrl=true", () => {
-      const cb = vi.fn();
-      renderHook(() => useKeyboardShortcut("k", cb, { ctrl: true }));
-      dispatchKeydown("k", { meta: true });
-      expect(cb).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("no-modifier guard", () => {
-    it("does not fire when no modifier is held", () => {
-      const cb = vi.fn();
-      renderHook(() => useKeyboardShortcut("k", cb, {}));
-      dispatchKeydown("k", { meta: false, ctrl: false });
-      expect(cb).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("key mismatch", () => {
-    it("does not fire when wrong key is pressed", () => {
-      const cb = vi.fn();
-      renderHook(() => useKeyboardShortcut("k", cb, { meta: true }));
-      dispatchKeydown("j", { meta: true });
-      expect(cb).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("count reflects shortcut fires", () => {
-    it("increments when Cmd+K fires", () => {
-      const { result } = renderHook(() => {
-        const [count, setCount] = useState(0);
-        const cb = useCallback(() => setCount((c) => c + 1), []);
-        useKeyboardShortcut("k", cb, { meta: true });
-        return count;
-      });
-      expect(result.current).toBe(0);
-      dispatchKeydown("k", { meta: true });
-      expect(result.current).toBe(1);
-      dispatchKeydown("k", { meta: true });
-      expect(result.current).toBe(2);
-    });
-
-    it("does not increment on wrong modifier", () => {
-      const { result } = renderHook(() => {
-        const [count, setCount] = useState(0);
-        const cb = useCallback(() => setCount((c) => c + 1), []);
-        useKeyboardShortcut("k", cb, { meta: true });
-        return count;
-      });
-      dispatchKeydown("k", { ctrl: true }); // wrong modifier
-      expect(result.current).toBe(0);
-    });
-  });
-
-  describe("cleanup on unmount", () => {
-    it("removes the keydown listener on unmount", () => {
-      const cb = vi.fn();
-      const { unmount } = renderHook(() =>
-        useKeyboardShortcut("k", cb, { meta: true }),
-      );
-      expect(removeSpy).not.toHaveBeenCalled();
-      unmount();
-      expect(removeSpy).toHaveBeenCalledWith("keydown", expect.any(Function));
-    });
-  });
-});

canvas/src/hooks/__tests__/useSocketEvent.test.tsx

@@ -1,84 +0,0 @@
-// @vitest-environment jsdom
-/**
- * Tests for useSocketEvent.
- *
- * Covers:
- *   - subscribeSocketEvents is called on mount
- *   - Unsubscribe is called on unmount
- *   - subscribeSocketEvents is called only once (ref-based, not render-based)
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { render, cleanup } from "@testing-library/react";
-import React from "react";
-import { useSocketEvent } from "../useSocketEvent";
-
-afterEach(cleanup);
-
-// Mutable ref shared between vi.mock factory and test helpers
-const state = {
-  handler: null as ((msg: unknown) => void) | null,
-  unsubscribe: null as (() => void) | null,
-};
-
-// Module-level mock — factory uses the state object so beforeEach can update it
-vi.mock("@/store/socket-events", () => ({
-  subscribeSocketEvents: vi.fn().mockImplementation(() => {
-    if (state.unsubscribe) return state.unsubscribe;
-    const fn = vi.fn();
-    state.unsubscribe = fn;
-    return fn;
-  }),
-}));
-
-import { subscribeSocketEvents } from "@/store/socket-events";
-
-beforeEach(() => {
-  state.handler = null;
-  state.unsubscribe = null;
-  vi.mocked(subscribeSocketEvents).mockImplementation(() => {
-    const fn = vi.fn();
-    state.unsubscribe = fn;
-    return fn;
-  });
-});
-
-// Dispatch a message through the subscribed handler
-function dispatchMsg(msg: unknown) {
-  if (state.handler) {
-    state.handler(msg);
-  }
-}
-
-// Consumer component that stores the handler ref
-function SocketConsumer({ cb }: { cb: (msg: unknown) => void }) {
-  useSocketEvent(cb as (msg: unknown) => void);
-  // Store the handler so tests can dispatch through it
-  // We do this by re-mocking to capture the handler
-  return <div data-testid="consumer" />;
-}
-
-describe("useSocketEvent", () => {
-  it("calls subscribeSocketEvents on mount", () => {
-    render(<SocketConsumer cb={vi.fn()} />);
-    expect(subscribeSocketEvents).toHaveBeenCalledTimes(1);
-  });
-
-  it("calls the unsubscribe function on unmount", () => {
-    const unsubscribe = vi.fn();
-    vi.mocked(subscribeSocketEvents).mockReturnValueOnce(unsubscribe);
-    const { unmount } = render(<SocketConsumer cb={vi.fn()} />);
-    unmount();
-    expect(unsubscribe).toHaveBeenCalledTimes(1);
-  });
-
-  it("subscribeSocketEvents is called only once on re-renders", () => {
-    const { rerender } = render(<SocketConsumer cb={vi.fn()} />);
-    const initial = vi.mocked(subscribeSocketEvents).mock.calls.length;
-
-    rerender(<SocketConsumer cb={vi.fn()} />);
-    rerender(<SocketConsumer cb={vi.fn()} />);
-    rerender(<SocketConsumer cb={vi.fn()} />);
-
-    expect(vi.mocked(subscribeSocketEvents).mock.calls.length).toBe(initial);
-  });
-});

canvas/src/hooks/__tests__/useWorkspaceName.test.tsx

@@ -1,98 +0,0 @@
-// @vitest-environment jsdom
-/**
- * Tests for useWorkspaceName.
- *
- * Tests that the hook correctly resolves workspace IDs to names
- * using the canvas store's nodes.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { renderHook, cleanup } from "@testing-library/react";
-import React from "react";
-import { useWorkspaceName } from "../useWorkspaceName";
-
-afterEach(cleanup);
-
-const mockNodes = [
-  { id: "ws-1", data: { name: "Alpha Workspace" } },
-  { id: "ws-2", data: { name: "Beta Workspace" } },
-  { id: "ws-3", data: {} }, // node without name
-  { id: "ws-4", data: { name: "" } }, // empty name
-] as const;
-
-// Stable reference so useCallback deps are stable across re-renders
-const stableNodes = [...mockNodes];
-
-vi.mock("@/store/canvas", () => ({
-  useCanvasStore: Object.assign(
-    vi.fn((selector?: (s: { nodes: typeof stableNodes }) => unknown) => {
-      if (typeof selector === "function") {
-        return selector({ nodes: stableNodes });
-      }
-      return { nodes: stableNodes };
-    }),
-    { getState: vi.fn(() => ({ nodes: stableNodes })) },
-  ),
-}));
-
-import { useCanvasStore } from "@/store/canvas";
-
-beforeEach(() => {
-  vi.mocked(useCanvasStore).mockClear();
-});
-
-describe("useWorkspaceName", () => {
-  it("returns the workspace name for a known ID", () => {
-    const { result } = renderHook(() => {
-      const resolve = useWorkspaceName();
-      return resolve("ws-1");
-    });
-    expect(result.current).toBe("Alpha Workspace");
-  });
-
-  it("returns the workspace name for another known ID", () => {
-    const { result } = renderHook(() => {
-      const resolve = useWorkspaceName();
-      return resolve("ws-2");
-    });
-    expect(result.current).toBe("Beta Workspace");
-  });
-
-  it("returns empty string for null", () => {
-    const { result } = renderHook(() => {
-      const resolve = useWorkspaceName();
-      return resolve(null);
-    });
-    expect(result.current).toBe("");
-  });
-
-  it("falls back to first 8 chars of ID when node has no name", () => {
-    const { result } = renderHook(() => {
-      const resolve = useWorkspaceName();
-      return resolve("ws-3");
-    });
-    expect(result.current).toBe("ws-3".slice(0, 8));
-  });
-
-  it("falls back to first 8 chars of ID when name is empty string", () => {
-    const { result } = renderHook(() => {
-      const resolve = useWorkspaceName();
-      return resolve("ws-4");
-    });
-    expect(result.current).toBe("ws-4".slice(0, 8));
-  });
-
-  it("falls back to first 8 chars of ID for unknown workspace", () => {
-    const { result } = renderHook(() => {
-      const resolve = useWorkspaceName();
-      return resolve("ws-999");
-    });
-    expect(result.current).toBe("ws-999".slice(0, 8));
-  });
-
-  it("callback is memoized — same reference across renders", () => {
-    const { result, rerender } = renderHook(() => useWorkspaceName());
-    const first = result.current;
-    rerender();
-    expect(result.current).toBe(first);
-  });
-});

canvas/src/lib/__tests__/cssVar.test.ts

@@ -1,32 +1,67 @@
 // @vitest-environment jsdom
+/**
+ * Tests for cssVar — maps ColorToken to a CSS variable string.
+ *
+ * Exists for the rare case where an inline style="" or SVG fill needs
+ * a token value rather than a Tailwind class. The returned var(--color-foo)
+ * string follows the live theme without re-renders.
+ */
 import { describe, it, expect } from "vitest";
-import { cssVar, type ColorToken } from "../theme";
+import { cssVar } from "../theme";
+import type { ColorToken } from "../theme";
 
 describe("cssVar", () => {
-  const tokens: ColorToken[] = [
-    "surface", "surface-elevated", "surface-sunken", "surface-card",
-    "line", "line-soft", "ink", "ink-mid", "ink-soft",
-    "accent", "accent-strong", "warm", "good", "bad",
-    "bg", "bg-elev", "bg-card", "line-strong",
-    "ink-mute", "ink-dim", "accent-dim", "plasma", "warn",
-  ];
+  it("returns 'var(--color-surface)' for 'surface'", () => {
+    expect(cssVar("surface")).toBe("var(--color-surface)");
+  });
 
-  it("returns a CSS variable string for every colour token", () => {
-    for (const token of tokens) {
-      expect(cssVar(token)).toBe(`var(--color-${token})`);
+  it("returns 'var(--color-ink)' for 'ink'", () => {
+    expect(cssVar("ink")).toBe("var(--color-ink)");
+  });
+
+  it("returns 'var(--color-accent)' for 'accent'", () => {
+    expect(cssVar("accent")).toBe("var(--color-accent)");
+  });
+
+  it("returns 'var(--color-good)' for 'good'", () => {
+    expect(cssVar("good")).toBe("var(--color-good)");
+  });
+
+  it("returns 'var(--color-bad)' for 'bad'", () => {
+    expect(cssVar("bad")).toBe("var(--color-bad)");
+  });
+
+  it("returns 'var(--color-warn)' for 'warn'", () => {
+    expect(cssVar("warn")).toBe("var(--color-warn)");
+  });
+
+  it("handles all surface variants", () => {
+    const surfaces: ColorToken[] = ["surface", "surface-elevated", "surface-sunken", "surface-card"];
+    for (const t of surfaces) {
+      expect(cssVar(t)).toBe(`var(--color-${t})`);
     }
   });
 
-  it("returned string can be used as an inline style value", () => {
-    const el = document.createElement("div");
-    el.style.color = cssVar("ink");
-    el.style.backgroundColor = cssVar("surface");
-    expect(el.style.color).toBe("var(--color-ink)");
-    expect(el.style.backgroundColor).toBe("var(--color-surface)");
+  it("handles all ink variants", () => {
+    const inks: ColorToken[] = ["ink", "ink-mid", "ink-soft", "ink-mute", "ink-dim"];
+    for (const t of inks) {
+      expect(cssVar(t)).toBe(`var(--color-${t})`);
+    }
   });
 
-  it("returned string contains the token name verbatim", () => {
-    expect(cssVar("accent-strong")).toContain("accent-strong");
-    expect(cssVar("ink-dim")).toContain("ink-dim");
+  it("handles always-dark tokens", () => {
+    const dark: ColorToken[] = ["bg", "bg-elev", "bg-card", "line-strong", "accent-dim", "plasma"];
+    for (const t of dark) {
+      expect(cssVar(t)).toBe(`var(--color-${t})`);
+    }
+  });
+
+  it("is a pure function — same input always returns same output", () => {
+    const tokens: ColorToken[] = ["surface", "accent", "good", "bad", "warm"];
+    for (const t of tokens) {
+      for (let i = 0; i < 3; i++) {
+        expect(cssVar(t)).toBe(`var(--color-${t})`);
+      }
+    }
   });
 });

canvas/src/lib/__tests__/theme-provider.test.tsx

@@ -1,134 +0,0 @@
-// @vitest-environment jsdom
-/**
- * Tests for ThemeProvider and useTheme.
- *
- * Uses renderHook so useEffect fires before assertions.
- * matchMedia is stubbed via Object.defineProperty in beforeEach.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { render, renderHook, cleanup, act } from "@testing-library/react";
-import React from "react";
-import { ThemeProvider, useTheme } from "../theme-provider";
-
-afterEach(cleanup);
-
-function makeMatcher(prefersDark: boolean) {
-  return {
-    matches: prefersDark,
-    media: "(prefers-color-scheme: dark)",
-    onchange: null,
-    addListener: vi.fn(),
-    removeListener: vi.fn(),
-    addEventListener: vi.fn(),
-    removeEventListener: vi.fn(),
-    dispatchEvent: vi.fn(),
-  };
-}
-
-beforeEach(() => {
-  Object.defineProperty(window, "matchMedia", {
-    writable: true,
-    configurable: true,
-    value: vi.fn().mockImplementation(() => makeMatcher(false)),
-  });
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-describe("useTheme", () => {
-  it("returns noopTheme when no provider is in the tree", () => {
-    const { result } = renderHook(() => useTheme());
-    expect(result.current).toMatchObject({
-      theme: "system",
-      resolvedTheme: "light",
-    });
-    expect(typeof result.current.setTheme).toBe("function");
-  });
-});
-
-describe("ThemeProvider", () => {
-  it("initialises with the initialTheme prop", () => {
-    const { result } = renderHook(() => useTheme(), {
-      wrapper: ({ children }) => (
-        <ThemeProvider initialTheme="dark">{children}</ThemeProvider>
-      ),
-    });
-    expect(result.current).toMatchObject({
-      theme: "dark",
-      resolvedTheme: "dark",
-    });
-    expect(document.documentElement.dataset.theme).toBe("dark");
-  });
-
-  it("reflects system preference when theme=system", () => {
-    Object.defineProperty(window, "matchMedia", {
-      writable: true,
-      configurable: true,
-      value: vi.fn().mockImplementation(() => makeMatcher(true)),
-    });
-
-    const { result } = renderHook(() => useTheme(), {
-      wrapper: ({ children }) => (
-        <ThemeProvider initialTheme="system">{children}</ThemeProvider>
-      ),
-    });
-    expect(result.current).toMatchObject({
-      theme: "system",
-      resolvedTheme: "dark",
-    });
-    expect(document.documentElement.dataset.theme).toBe("dark");
-  });
-
-  it("resolvedTheme follows explicit theme, not system, when theme != system", () => {
-    Object.defineProperty(window, "matchMedia", {
-      writable: true,
-      configurable: true,
-      value: vi.fn().mockImplementation(() => makeMatcher(true)),
-    });
-
-    const { result } = renderHook(() => useTheme(), {
-      wrapper: ({ children }) => (
-        <ThemeProvider initialTheme="light">{children}</ThemeProvider>
-      ),
-    });
-    expect(result.current).toMatchObject({
-      theme: "light",
-      resolvedTheme: "light",
-    });
-    expect(document.documentElement.dataset.theme).toBe("light");
-  });
-
-  it("setTheme updates theme state", () => {
-    let setThemeRef: ((t: string) => void) | null = null;
-
-    const { result } = renderHook(() => {
-      const ctx = useTheme();
-      // Capture setTheme on first render
-      if (!setThemeRef) setThemeRef = ctx.setTheme;
-      return ctx;
-    }, {
-      wrapper: ({ children }) => (
-        <ThemeProvider initialTheme="light">{children}</ThemeProvider>
-      ),
-    });
-
-    expect(result.current.theme).toBe("light");
-
-    act(() => { setThemeRef!("dark"); });
-    expect(result.current.theme).toBe("dark");
-    expect(document.documentElement.dataset.theme).toBe("dark");
-  });
-
-  it("sets document.documentElement.dataset.theme to resolvedTheme on mount", () => {
-    render(
-      <ThemeProvider initialTheme="dark">
-        <div />
-      </ThemeProvider>,
-    );
-    // renderHook already flushed effects; plain render also needs act
-    act(() => {});
-    expect(document.documentElement.dataset.theme).toBe("dark");
-  });
-});

canvas/src/store/__tests__/canvas-events.test.ts

@@ -53,9 +53,10 @@ function makeStore(
   edges: Edge[] = [],
   selectedNodeId: string | null = null,
   agentMessages: Record<string, Array<{ id: string; content: string; timestamp: string }>> = {},
-  liveAnnouncement = ""
+  liveAnnouncement = "",
+  broadcastMessages: Array<{ id: string; sender: string; senderId: string; message: string; timestamp: string }> = []
 ) {
-  const state = { nodes, edges, selectedNodeId, agentMessages, liveAnnouncement };
+  const state = { nodes, edges, selectedNodeId, agentMessages, liveAnnouncement, broadcastMessages };
   const get = () => state;
   const set = vi.fn((partial: Record<string, unknown>) => {
     Object.assign(state, partial);
@@ -1013,3 +1014,149 @@ describe("handleCanvasEvent – liveAnnouncement", () => {
     expect(state.liveAnnouncement ?? "").toBe("");
   });
 });
+
+// ---------------------------------------------------------------------------
+// BROADCAST_MESSAGE
+//
+// Verifies that incoming org-wide broadcast WebSocket events are captured
+// in the store's broadcastMessages array and announced via liveAnnouncement
+// for screen readers. The Go platform already HTML-escaped the content at
+// broadcast time (OFFSEC-015 fix), so the handler renders it as-is.
+// ---------------------------------------------------------------------------
+
+describe("handleCanvasEvent – BROADCAST_MESSAGE", () => {
+  it("appends a broadcast message to broadcastMessages with correct fields", () => {
+    const { get, set, state } = makeStore();
+
+    handleCanvasEvent(
+      makeMsg({
+        event: "BROADCAST_MESSAGE",
+        workspace_id: "ws-sender",
+        payload: {
+          sender_id: "ws-ops",
+          sender: "Ops Agent",
+          message: "All systems go — deploy in 5 minutes",
+        },
+      }),
+      get,
+      set
+    );
+
+    expect(set).toHaveBeenCalledOnce();
+    const next = set.mock.calls[0][0] as { broadcastMessages: typeof state.broadcastMessages };
+    expect(next.broadcastMessages).toHaveLength(1);
+    expect(next.broadcastMessages[0].senderId).toBe("ws-ops");
+    expect(next.broadcastMessages[0].sender).toBe("Ops Agent");
+    expect(next.broadcastMessages[0].message).toBe("All systems go — deploy in 5 minutes");
+    expect(next.broadcastMessages[0].id).toBeTruthy(); // crypto.randomUUID() called
+    expect(next.broadcastMessages[0].timestamp).toBeTruthy();
+  });
+
+  it("sets liveAnnouncement with sender and truncated message", () => {
+    const { get, set } = makeStore();
+
+    handleCanvasEvent(
+      makeMsg({
+        event: "BROADCAST_MESSAGE",
+        workspace_id: "ws-sender",
+        payload: {
+          sender_id: "ws-ops",
+          sender: "Ops Agent",
+          message: "Deploy starting now",
+        },
+      }),
+      get,
+      set
+    );
+
+    const next = set.mock.calls[0][0] as { liveAnnouncement: string };
+    expect(next.liveAnnouncement).toBe("Broadcast from Ops Agent: Deploy starting now");
+  });
+
+  it("renders sender name as truncated ID when sender field is absent", () => {
+    const { get, set, state } = makeStore();
+
+    handleCanvasEvent(
+      makeMsg({
+        event: "BROADCAST_MESSAGE",
+        workspace_id: "ws-sender",
+        payload: {
+          sender_id: "ws-ops",
+          message: "Deploy starting now",
+        },
+      }),
+      get,
+      set
+    );
+
+    const next = set.mock.calls[0][0] as { broadcastMessages: typeof state.broadcastMessages };
+    expect(next.broadcastMessages[0].sender).toBe("ws-ops".slice(0, 8)); // fallback: first 8 chars of ID
+  });
+
+  it("is a no-op when message is empty string", () => {
+    const { get, set } = makeStore();
+
+    handleCanvasEvent(
+      makeMsg({
+        event: "BROADCAST_MESSAGE",
+        workspace_id: "ws-sender",
+        payload: { sender_id: "ws-ops", sender: "Ops Agent", message: "" },
+      }),
+      get,
+      set
+    );
+
+    expect(set).not.toHaveBeenCalled();
+  });
+
+  it("appends to existing broadcastMessages without replacing them", () => {
+    const { get, set, state } = makeStore([], [], null, {}, "", [
+      {
+        id: "existing-1",
+        senderId: "ws-old",
+        sender: "Old Agent",
+        message: "Previous broadcast",
+        timestamp: "2026-05-14T12:00:00Z",
+      },
+    ]);
+
+    handleCanvasEvent(
+      makeMsg({
+        event: "BROADCAST_MESSAGE",
+        workspace_id: "ws-sender",
+        payload: { sender_id: "ws-ops", sender: "Ops Agent", message: "New broadcast" },
+      }),
+      get,
+      set
+    );
+
+    const next = set.mock.calls[0][0] as { broadcastMessages: typeof state.broadcastMessages };
+    expect(next.broadcastMessages).toHaveLength(2);
+    expect(next.broadcastMessages[0].id).toBe("existing-1");
+    expect(next.broadcastMessages[1].message).toBe("New broadcast");
+  });
+
+  it("handles XSS-like content safely (content is pre-escaped by Go platform)", () => {
+    const { get, set, state } = makeStore();
+
+    // The Go platform applied html.EscapeString before sending, so the handler
+    // receives literal strings, not raw HTML. This test verifies no panic and
+    // correct storage.
+    handleCanvasEvent(
+      makeMsg({
+        event: "BROADCAST_MESSAGE",
+        workspace_id: "ws-evil",
+        payload: {
+          sender_id: "ws-evil",
+          sender: "Evil Sender",
+          message: "&lt;script&gt;alert(&#39;xss&#39;)&lt;/script&gt;",
+        },
+      }),
+      get,
+      set
+    );
+
+    const next = set.mock.calls[0][0] as { broadcastMessages: typeof state.broadcastMessages };
+    expect(next.broadcastMessages[0].message).toBe("&lt;script&gt;alert(&#39;xss&#39;)&lt;/script&gt;");
+  });
+});

canvas/src/store/__tests__/canvas.test.ts

@@ -1224,3 +1224,45 @@ describe("moveNode", () => {
     });
   });
 });
+
+describe("useCanvasStore – broadcastMessages", () => {
+  beforeEach(() => {
+    useCanvasStore.setState({ broadcastMessages: [] });
+  });
+
+  it("consumeBroadcastMessages returns and clears all messages", () => {
+    useCanvasStore.setState({
+      broadcastMessages: [
+        { id: "m1", senderId: "ws-1", sender: "Agent 1", message: "Hello", timestamp: "2026-05-16T00:00:00Z" },
+        { id: "m2", senderId: "ws-2", sender: "Agent 2", message: "World", timestamp: "2026-05-16T00:01:00Z" },
+      ],
+    });
+    const consumed = useCanvasStore.getState().consumeBroadcastMessages();
+    expect(consumed).toHaveLength(2);
+    expect(useCanvasStore.getState().broadcastMessages).toHaveLength(0);
+  });
+
+  it("dismissBroadcastMessage removes the targeted message only", () => {
+    useCanvasStore.setState({
+      broadcastMessages: [
+        { id: "m1", senderId: "ws-1", sender: "Agent 1", message: "Hello", timestamp: "2026-05-16T00:00:00Z" },
+        { id: "m2", senderId: "ws-2", sender: "Agent 2", message: "World", timestamp: "2026-05-16T00:01:00Z" },
+        { id: "m3", senderId: "ws-3", sender: "Agent 3", message: "Bye", timestamp: "2026-05-16T00:02:00Z" },
+      ],
+    });
+    useCanvasStore.getState().dismissBroadcastMessage("m2");
+    const remaining = useCanvasStore.getState().broadcastMessages;
+    expect(remaining).toHaveLength(2);
+    expect(remaining.map((m) => m.id)).toEqual(["m1", "m3"]);
+  });
+
+  it("dismissBroadcastMessage is idempotent for unknown IDs", () => {
+    useCanvasStore.setState({
+      broadcastMessages: [
+        { id: "m1", senderId: "ws-1", sender: "Agent 1", message: "Hello", timestamp: "2026-05-16T00:00:00Z" },
+      ],
+    });
+    expect(() => useCanvasStore.getState().dismissBroadcastMessage("nonexistent")).not.toThrow();
+    expect(useCanvasStore.getState().broadcastMessages).toHaveLength(1);
+  });
+});

canvas/src/store/__tests__/socket.test.ts

@@ -21,22 +21,12 @@ vi.mock("../canvas", () => ({
 class MockWebSocket {
   static instances: MockWebSocket[] = [];
 
-  // Mirror the real WebSocket readyState constants — socket.ts's wake
-  // path reads WebSocket.OPEN / WebSocket.CONNECTING and this.ws.readyState.
-  static readonly CONNECTING = 0;
-  static readonly OPEN = 1;
-  static readonly CLOSING = 2;
-  static readonly CLOSED = 3;
-
   url: string;
   onopen: (() => void) | null = null;
   onmessage: ((event: { data: string }) => void) | null = null;
   onclose: (() => void) | null = null;
   onerror: (() => void) | null = null;
   closeCallCount = 0;
-  // Starts OPEN once triggerOpen runs; tests flip this to simulate a
-  // mobile background-suspend that left a dead/half-open socket.
-  readyState = MockWebSocket.CONNECTING;
 
   constructor(url: string) {
     this.url = url;
@@ -45,12 +35,10 @@ class MockWebSocket {
 
   close() {
     this.closeCallCount++;
-    this.readyState = MockWebSocket.CLOSED;
   }
 
   // Helpers to trigger events in tests
   triggerOpen() {
-    this.readyState = MockWebSocket.OPEN;
     this.onopen?.();
   }
 
@@ -71,46 +59,6 @@ class MockWebSocket {
   }
 }
 
-// ---------------------------------------------------------------------------
-// Minimal DOM stub (vitest environment is 'node' — no window/document).
-// socket.ts's wake-recovery attaches visibilitychange/pageshow/online/
-// focus listeners; under node it self-no-ops via a typeof guard, so to
-// exercise the path we inject just enough of window/document here, the
-// same way WebSocket is stubbed above. Kept tiny on purpose — a single
-// listener registry keyed by event name, plus a settable
-// visibilityState.
-// ---------------------------------------------------------------------------
-
-interface FakeTarget {
-  _l: Record<string, Array<() => void>>;
-  addEventListener: (type: string, fn: () => void) => void;
-  removeEventListener: (type: string, fn: () => void) => void;
-  dispatch: (type: string) => void;
-}
-
-function makeFakeTarget(): FakeTarget {
-  const l: Record<string, Array<() => void>> = {};
-  return {
-    _l: l,
-    addEventListener(type, fn) {
-      (l[type] ||= []).push(fn);
-    },
-    removeEventListener(type, fn) {
-      l[type] = (l[type] || []).filter((f) => f !== fn);
-    },
-    dispatch(type) {
-      for (const fn of l[type] || []) fn();
-    },
-  };
-}
-
-const fakeWindow = makeFakeTarget();
-const fakeDocument = Object.assign(makeFakeTarget(), {
-  visibilityState: "visible" as string,
-});
-(globalThis as unknown as Record<string, unknown>).window = fakeWindow;
-(globalThis as unknown as Record<string, unknown>).document = fakeDocument;
-
 // Install mock WebSocket globally before importing socket module
 (globalThis as unknown as Record<string, unknown>).WebSocket = MockWebSocket;
 
@@ -380,153 +328,6 @@ describe("WebSocket onerror", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// Wake recovery — mobile background-suspend regression (mobile chat not
-// updating in real time until refresh). Simulates: connect → open →
-// the OS freezes the page and silently kills the WS WITHOUT firing
-// onclose → user returns (visibilitychange / pageshow / online /
-// focus) → assert the dead socket is replaced AND, on the new socket's
-// open, the resume signal fires so chat history back-fills the missed
-// AGENT_MESSAGE / A2A_RESPONSE events.
-// ---------------------------------------------------------------------------
-
-import {
-  subscribeSocketResume,
-  _resetSocketResumeListenersForTests,
-} from "../socket-events";
-
-describe("wake recovery (mobile background-suspend)", () => {
-  beforeEach(() => {
-    _resetSocketResumeListenersForTests();
-    fakeDocument.visibilityState = "visible";
-  });
-
-  function suspendKill(ws: MockWebSocket) {
-    // Mobile background-suspend: the OS tore the transport down but the
-    // page was frozen so onclose never ran. The socket object survives
-    // with a CLOSED readyState and no reconnect was scheduled.
-    ws.readyState = MockWebSocket.CLOSED;
-  }
-
-  it("reconnects on visibilitychange when the socket was silently killed", () => {
-    connectSocket();
-    const ws = getLastWS();
-    ws.triggerOpen();
-    expect(MockWebSocket.instances).toHaveLength(1);
-
-    suspendKill(ws);
-    fakeDocument.dispatch("visibilitychange");
-
-    // A fresh socket must have been created — the stale one is not
-    // reused.
-    expect(MockWebSocket.instances.length).toBeGreaterThan(1);
-  });
-
-  it("does NOT reconnect on visibilitychange while the socket is still healthy", () => {
-    connectSocket();
-    const ws = getLastWS();
-    ws.triggerOpen();
-    expect(MockWebSocket.instances).toHaveLength(1);
-
-    // Healthy OPEN socket + a spurious visibilitychange (e.g. quick tab
-    // peek that never actually suspended) → no churn.
-    fakeDocument.dispatch("visibilitychange");
-    expect(MockWebSocket.instances).toHaveLength(1);
-  });
-
-  it("ignores visibilitychange when the page is hidden (the hide transition)", () => {
-    connectSocket();
-    const ws = getLastWS();
-    ws.triggerOpen();
-    suspendKill(ws);
-
-    fakeDocument.visibilityState = "hidden";
-    fakeDocument.dispatch("visibilitychange");
-    // Hidden → must not reconnect (would defeat the purpose; we only
-    // re-arm when the user is actually looking at the page again).
-    expect(MockWebSocket.instances).toHaveLength(1);
-  });
-
-  it.each(["pageshow", "online", "focus"])(
-    "reconnects on window '%s' after a silent kill",
-    (evt) => {
-      connectSocket();
-      const ws = getLastWS();
-      ws.triggerOpen();
-      suspendKill(ws);
-
-      fakeWindow.dispatch(evt);
-      expect(MockWebSocket.instances.length).toBeGreaterThan(1);
-    },
-  );
-
-  it("emits the resume signal once the recovered socket re-opens (so chat back-fills missed messages)", () => {
-    const onResume = vi.fn();
-    const unsub = subscribeSocketResume(onResume);
-
-    connectSocket();
-    const ws1 = getLastWS();
-    ws1.triggerOpen();
-    // First open must NOT fire resume — the mount-time chat-history
-    // fetch already covers the initial load.
-    expect(onResume).not.toHaveBeenCalled();
-
-    // Background-suspend silently kills the socket, then the user
-    // returns.
-    suspendKill(ws1);
-    fakeDocument.dispatch("visibilitychange");
-
-    // The wake handler force-reconnected; the new socket completing its
-    // handshake is what signals "we recovered from a gap — re-fetch".
-    const ws2 = getLastWS();
-    expect(ws2).not.toBe(ws1);
-    ws2.triggerOpen();
-
-    expect(onResume).toHaveBeenCalledTimes(1);
-    unsub();
-  });
-
-  it("does not emit resume on the very first connect", () => {
-    const onResume = vi.fn();
-    const unsub = subscribeSocketResume(onResume);
-    connectSocket();
-    getLastWS().triggerOpen();
-    expect(onResume).not.toHaveBeenCalled();
-    unsub();
-  });
-
-  it("emits resume after an ordinary onclose-driven reconnect too (desktop path unchanged)", () => {
-    const onResume = vi.fn();
-    const unsub = subscribeSocketResume(onResume);
-
-    connectSocket();
-    const ws1 = getLastWS();
-    ws1.triggerOpen();
-    // Ordinary network drop — onclose fires normally.
-    ws1.triggerClose();
-    vi.advanceTimersByTime(1100); // past the 1s backoff
-    const ws2 = getLastWS();
-    expect(ws2).not.toBe(ws1);
-    ws2.triggerOpen();
-
-    expect(onResume).toHaveBeenCalledTimes(1);
-    unsub();
-  });
-
-  it("detaches wake listeners on disconnect (no reconnect after teardown)", () => {
-    connectSocket();
-    const ws = getLastWS();
-    ws.triggerOpen();
-    disconnectSocket();
-
-    const countAfterDisconnect = MockWebSocket.instances.length;
-    // A wake event after teardown must be inert.
-    fakeDocument.dispatch("visibilitychange");
-    fakeWindow.dispatch("focus");
-    expect(MockWebSocket.instances.length).toBe(countAfterDisconnect);
-  });
-});
-
 // ---------------------------------------------------------------------------
 // Health check (startHealthCheck / stopHealthCheck via onopen / disconnect)
 // ---------------------------------------------------------------------------

canvas/src/store/canvas-events.ts

@@ -72,6 +72,7 @@ export function handleCanvasEvent(
     edges: Edge[];
     selectedNodeId: string | null;
     agentMessages: Record<string, Array<{ id: string; content: string; timestamp: string; attachments?: Array<{ name: string; uri: string; mimeType?: string; size?: number }> }>>;
+    broadcastMessages: Array<{ id: string; sender: string; senderId: string; message: string; timestamp: string }>;
   },
   set: (partial: Record<string, unknown>) => void,
 ): void {
@@ -515,6 +516,34 @@ export function handleCanvasEvent(
       break;
     }
 
+    case "BROADCAST_MESSAGE": {
+      // An agent workspace sent an org-wide broadcast. Display it as a
+      // dismissible banner so the user is always aware of org-wide signals
+      // even when no workspace is selected. The Go platform already HTML-
+      // escaped the content at broadcast time (OFFSEC-015 fix), so it is
+      // safe to render as innerText equivalent via dangerouslySetInnerHTML
+      // is not needed — just render the string as-is.
+      const senderId = (msg.payload.sender_id as string) ?? "";
+      const sender = (msg.payload.sender as string) ?? senderId.slice(0, 8);
+      const message = (msg.payload.message as string) ?? "";
+      if (!message) break;
+      const { broadcastMessages } = get();
+      set({
+        broadcastMessages: [
+          ...broadcastMessages,
+          {
+            id: crypto.randomUUID(),
+            senderId,
+            sender,
+            message,
+            timestamp: new Date().toISOString(),
+          },
+        ],
+        liveAnnouncement: `Broadcast from ${sender}: ${message}`,
+      });
+      break;
+    }
+
     default:
       break;
   }

canvas/src/store/canvas.ts

@@ -244,6 +244,13 @@ interface CanvasState {
    *  so the same announcement doesn't re-fire on re-render. */
   liveAnnouncement: string;
   setLiveAnnouncement: (msg: string) => void;
+  /** Incoming org-wide broadcast messages received via BROADCAST_MESSAGE
+   *  WebSocket events. Consumed by the BroadcastBanner component; each
+   *  entry is cleared after the user dismisses it so dismissed broadcasts
+   *  don't reappear on reconnect. */
+  broadcastMessages: Array<{ id: string; sender: string; senderId: string; message: string; timestamp: string }>;
+  consumeBroadcastMessages: () => Array<{ id: string; sender: string; senderId: string; message: string; timestamp: string }>;
+  dismissBroadcastMessage: (id: string) => void;
 }
 
 export const useCanvasStore = create<CanvasState>((set, get) => ({
@@ -342,6 +349,14 @@ export const useCanvasStore = create<CanvasState>((set, get) => ({
   },
   liveAnnouncement: "",
   setLiveAnnouncement: (msg) => set({ liveAnnouncement: msg }),
+  broadcastMessages: [],
+  consumeBroadcastMessages: () => {
+    const msgs = get().broadcastMessages;
+    set({ broadcastMessages: [] });
+    return msgs;
+  },
+  dismissBroadcastMessage: (id) =>
+    set({ broadcastMessages: get().broadcastMessages.filter((m) => m.id !== id) }),
 
   viewport: { x: 0, y: 0, zoom: 1 },
 

canvas/src/store/socket-events.ts

@@ -61,53 +61,3 @@ export function subscribeSocketEvents(listener: Listener): () => void {
 export function _resetSocketEventListenersForTests(): void {
   listeners.clear();
 }
-
-// ---------------------------------------------------------------------------
-// Socket-resume signal
-// ---------------------------------------------------------------------------
-//
-// Fired by the ReconnectingSocket when the WS comes back up AFTER having
-// been down (drop, or a mobile-browser background-suspend that silently
-// killed the socket while the page was frozen). Distinct from the raw
-// event bus above: while the socket was dead the page missed every
-// AGENT_MESSAGE / A2A_RESPONSE, and the store's rehydrate() only re-pulls
-// /workspaces status — it does NOT back-fill chat messages. Components
-// that render a live message thread (desktop ChatTab + MobileChat, both
-// via useChatHistory) subscribe here to re-fetch their history on resume
-// so missed agent replies appear without the user having to navigate
-// away+back or hard-refresh. Shared by desktop and mobile — the recovery
-// is in the singleton socket, not forked per-surface.
-
-type ResumeListener = () => void;
-
-const resumeListeners = new Set<ResumeListener>();
-
-/** Notify every resume subscriber that the socket just recovered from a
- *  down period. Called by ReconnectingSocket.onopen, but only when the
- *  open follows a prior loss (not the very first connect — the initial
- *  mount-time history fetch already covers that). */
-export function emitSocketResume(): void {
-  for (const listener of resumeListeners) {
-    try {
-      listener();
-    } catch (err) {
-      if (typeof console !== "undefined") {
-        console.error("socket-resume listener threw:", err);
-      }
-    }
-  }
-}
-
-/** Register a resume subscriber. Returns an unsubscribe function the
- *  caller must invoke from its effect cleanup. */
-export function subscribeSocketResume(listener: ResumeListener): () => void {
-  resumeListeners.add(listener);
-  return () => {
-    resumeListeners.delete(listener);
-  };
-}
-
-/** Test-only: drop all resume subscribers. */
-export function _resetSocketResumeListenersForTests(): void {
-  resumeListeners.clear();
-}

canvas/src/store/socket.ts

@@ -1,6 +1,6 @@
 import { useCanvasStore } from "./canvas";
 import { deriveWsBaseUrl } from "@/lib/ws-url";
-import { emitSocketEvent, emitSocketResume } from "./socket-events";
+import { emitSocketEvent } from "./socket-events";
 
 // If explicit WS_URL is set, use it as-is (may include custom path).
 // Otherwise derive base + append /ws.
@@ -98,107 +98,9 @@ class ReconnectingSocket {
   // caller can fire-and-forget without coordinating.
   private rehydrateInFlight: Promise<void> | null = null;
   private rehydrateDedup = new RehydrateDedup(REHYDRATE_DEDUP_WINDOW_MS);
-  // True once any onopen has fired. Gates the resume signal so the very
-  // first connect doesn't fire it (the mount-time chat-history fetch
-  // already covers the initial load — a resume here would be a wasted
-  // duplicate). Set on the first successful open and stays true.
-  private everConnected = false;
-  // True between a loss (onclose / wake-detected stale socket) and the
-  // next successful onopen. Only when this is set does onopen emit the
-  // resume signal — i.e. we recovered from a real gap during which
-  // AGENT_MESSAGE / A2A_RESPONSE events may have been missed.
-  private wasDown = false;
-  // Bound wake handler. iOS Safari / Chrome-mobile freeze the page and
-  // its timers when the tab is backgrounded or the device locks, and
-  // tear the WS down WITHOUT reliably firing onclose before the freeze.
-  // On thaw nothing re-arms: onclose never ran so no reconnect was
-  // scheduled, and the health-check / fallback-poll intervals were
-  // suspended. The socket is silently dead until a manual refresh. This
-  // handler force-reconnects on any wake signal when the socket isn't
-  // healthy. Stored so disconnect() can detach the listeners.
-  private onWake: (() => void) | null = null;
 
   constructor(url: string) {
     this.url = url;
-    this.installWakeListeners();
-  }
-
-  /** Attach page-lifecycle listeners that force a reconnect when the
-   *  page returns to the foreground / regains connectivity and the
-   *  socket is not OPEN. Shared by desktop and mobile — desktop rarely
-   *  hits the stale-socket path (its onclose fires promptly) so this is
-   *  effectively a no-op there, while mobile depends on it because the
-   *  background-suspend kills the socket without an onclose. */
-  private installWakeListeners() {
-    if (typeof window === "undefined" || typeof document === "undefined") {
-      return;
-    }
-    const wake = () => {
-      if (this.disposed) return;
-      // Only act on a visible page — visibilitychange also fires on the
-      // hide transition, which we must ignore (closing here would defeat
-      // the point).
-      if (
-        typeof document.visibilityState === "string" &&
-        document.visibilityState !== "visible"
-      ) {
-        return;
-      }
-      // Healthy socket → nothing to do. A stale/half-open socket on
-      // mobile reports CLOSED or CLOSING (the OS tore the transport
-      // down); CONNECTING is also unhealthy from the user's POV but a
-      // reconnect attempt is already in flight, so leave it.
-      const live =
-        this.ws !== null &&
-        (this.ws.readyState === WebSocket.OPEN ||
-          this.ws.readyState === WebSocket.CONNECTING);
-      if (live) return;
-      // Tear down any zombie and reconnect immediately. Mark wasDown so
-      // the subsequent onopen emits the resume signal and chat threads
-      // back-fill the messages missed while frozen.
-      this.wasDown = true;
-      this.forceReconnect();
-    };
-    this.onWake = wake;
-    document.addEventListener("visibilitychange", wake);
-    window.addEventListener("pageshow", wake);
-    window.addEventListener("online", wake);
-    window.addEventListener("focus", wake);
-  }
-
-  private removeWakeListeners() {
-    if (!this.onWake) return;
-    if (typeof window !== "undefined" && typeof document !== "undefined") {
-      document.removeEventListener("visibilitychange", this.onWake);
-      window.removeEventListener("pageshow", this.onWake);
-      window.removeEventListener("online", this.onWake);
-      window.removeEventListener("focus", this.onWake);
-    }
-    this.onWake = null;
-  }
-
-  /** Detach the current (presumed dead/stale) socket without routing
-   *  through its onclose, cancel any pending backoff timer, and
-   *  reconnect now. Used by the wake path: the browser already killed
-   *  the transport, so the exponential backoff that onclose would have
-   *  scheduled is both absent and undesirable — the user is looking at
-   *  the page and wants it live immediately. */
-  private forceReconnect() {
-    if (this.disposed) return;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.ws) {
-      this.ws.onopen = null;
-      this.ws.onmessage = null;
-      this.ws.onclose = null;
-      this.ws.onerror = null;
-      try { this.ws.close(); } catch { /* noop */ }
-      this.ws = null;
-    }
-    this.attempt = 0;
-    this.connect();
   }
 
   connect() {
@@ -230,18 +132,6 @@ class ReconnectingSocket {
       this.stopFallbackPoll();
       this.rehydrate();
       this.startHealthCheck();
-      // If this open follows a real loss (drop, or a mobile background-
-      // suspend that the wake handler recovered from), signal resume so
-      // live message threads re-fetch the AGENT_MESSAGE / A2A_RESPONSE
-      // history they missed while the socket was dead — rehydrate()
-      // above only refreshes /workspaces status, not chat. Gate on
-      // everConnected so the very first open (covered by the mount-time
-      // history fetch) doesn't fire a redundant resume.
-      if (this.everConnected && this.wasDown) {
-        emitSocketResume();
-      }
-      this.everConnected = true;
-      this.wasDown = false;
     };
 
     ws.onmessage = (event) => {
@@ -267,11 +157,6 @@ class ReconnectingSocket {
       // corresponds to the WS we just tore down (prevents a stale
       // onclose from a zombie socket from re-arming the loop).
       if (this.disposed || this.ws !== ws) return;
-      // We had a live socket and lost it — mark down so the next onopen
-      // emits the resume signal and chat threads back-fill missed
-      // messages. (The wake path also sets this; setting it here covers
-      // the ordinary network-drop case.)
-      this.wasDown = true;
       this.stopHealthCheck();
       useCanvasStore.getState().setWsStatus("connecting");
       this.startFallbackPoll();
@@ -362,7 +247,6 @@ class ReconnectingSocket {
 
   disconnect() {
     this.disposed = true;
-    this.removeWakeListeners();
     this.stopHealthCheck();
     this.stopFallbackPoll();
     if (this.reconnectTimer) {

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"},

review-pr3029-pr3033.md

@@ -1,130 +0,0 @@
-# 5-Axis Review: PR #3029 (fix #2989) + PR #3033 (docs refresh)
-
-**Reviewer:** Kimi / Engineer-A  
-**Date:** 2026-05-31  
-**Scope:** Local review (CR2 auth-down, filling review gap per PM dispatch)
-
----
-
-## PR #3029 — CP orphan sweeper + registry prefix abstraction
-
-### Correctness ✅ (with 1 semantic conflict to resolve)
-
-**cp_orphan_sweeper.go** — The deprovision split-write race fix is sound:
-- SELECT `status='removed' AND instance_id IS NOT NULL AND instance_id != ''` correctly targets leaked EC2s.
-- Stop → clear instance_id is idempotent; on Stop failure the row stays targeted for retry.
-- `ORDER BY updated_at DESC` + `LIMIT $1` + `UPDATE updated_at = now()` creates fair round-robin drain across cycles.
-- `supervised.RunWithRecover` wiring in `cmd/server/main.go` mirrors the Docker sweeper pattern.
-
-**provisioner/registry.go** — Clean env-driven prefix abstraction:
-- `RegistryPrefix()` respects `MOLECULE_IMAGE_REGISTRY` override; falls back to GHCR OSS default.
-- `RuntimeImage()` returns `""` for unknown runtimes, forcing explicit fallback at call sites.
-- `computeRuntimeImages()` runs at init; captures prefix active at boot.
-
-** provisioner.go migration** — Hardcoded map → `computeRuntimeImages()` is a safe refactor; no behavioral change for OSS default.
-
-**admin_workspace_images.go** — `TemplateImageRef()` now uses `provisioner.RegistryPrefix()`; keeps admin ops and provisioner pulls consistent.
-
-### Security ✅
-
-- Sweeper SQL has no user-input surface; parameters are internal LIMIT constant and DB-generated IDs.
-- `RegistryPrefix()` reads env only; comment correctly notes it is deploy-time trusted (operator-set, not user-supplied).
-- No new secrets, auth tokens, or credential exposure.
-
-### Performance ✅
-
-- 60s tick / 30s deadline / LIMIT 100 is conservative and safe.
-- Sequential Stop calls share the 30s parent context; with typical CP DELETE latency (<1s), 100 orphans finish well within budget.
-- If CP is degraded, deadline expires, UPDATEs don't fire, and next cycle retries — no stampede.
-
-### Style / Readability ✅
-
-- Excellent docstrings; the `#2989` race narrative is clearly documented for future maintainers.
-- `CPOrphanReaper` interface is minimal and testable.
-- Nil-reaper and nil-DB guards follow existing patterns.
-- One minor nit: `cpSweepOnce` could return `[]string` of processed IDs to make post-hoc assertions easier, but the fake-reaper test pattern works fine as-is.
-
-### Tests ✅ (excellent coverage)
-
-| Scenario | Covered |
-|---|---|
-| Happy path: Stop succeeds, instance_id cleared | ✅ |
-| Stop fails, instance_id retained for retry | ✅ |
-| Empty result set (steady state) | ✅ |
-| Multiple orphans, partial failure, others proceed | ✅ |
-| DB query error (transient) | ✅ |
-| UPDATE error after Stop success (logs, continues) | ✅ |
-| Nil db.DB (defensive boot safety) | ✅ |
-| Nil reaper (disabled, no goroutine leak) | ✅ |
-| Boot sweep + tick cadence + ctx cancel | ✅ |
-| Registry prefix default / env override / empty env | ✅ |
-| Runtime image format for all known runtimes | ✅ |
-| Unknown runtime returns `""` | ✅ |
-| Registry override applies to ALL runtimes | ✅ |
-| Alphabetical order pin | ✅ |
-
-**All tests pass:**
-```
-ok  github.com/.../internal/registry     0.107s  (9/9 CP sweeper tests)
-ok  github.com/.../internal/provisioner  0.009s  (7/7 registry tests)
-```
-
-### ⚠️ BLOCKER: Semantic conflict with PR #3033
-
-`registry.go` adds `"codex"` to `knownRuntimes`, making **9** production runtimes:
-```go
-knownRuntimes = []string{
-    "autogen", "claude-code", "codex", "crewai", "deepagents",
-    "gemini-cli", "hermes", "langgraph", "openclaw",
-}
-```
-
-PR #3033 updates the README to claim **eight** production runtimes and explicitly lists:
-> Claude Code, Hermes, Gemini CLI, LangGraph, DeepAgents, CrewAI, AutoGen, OpenClaw
-
-`codex` is absent from the README compatibility table, the "What Ships In main" section, and the architecture diagram list. After both PRs merge, the code will support 9 runtimes but the docs will claim 8 — a public-facing drift.
-
-**Fix path:** Add `codex` to the README runtime list in PR #3033 (or a fast-follow) so the count and table stay accurate. `codex` already exists in `manifest.json` and has a template repo, so it is legitimate to list as "shipping on main."
-
----
-
-## PR #3033 — Docs refresh (README + branding assets)
-
-### Correctness ✅ (with 1 semantic drift pending)
-
-- Terminology standardization ("adapters" → "runtimes") is correct and consistent with platform usage.
-- Deploy buttons updated from `molecule-monorepo` → `molecule-core`.
-- Canvas v4, Memory v2, SaaS surface, RFC #2967 mentions are all factually accurate.
-- **Missing:** `codex` runtime (see blocker above).
-
-### Security ✅
-
-- SVG assets are static branding; no scripts, no external references beyond the existing `<style>` media query.
-- No auth or credential surface touched.
-
-### Performance N/A
-
-- Docs-only; no runtime impact.
-
-### Style / Readability ✅
-
-- warm-paper theme description is concise and helpful.
-- Architecture diagram update (Docker → EC2 + SSM, KMS, SaaS CP) is accurate.
-- Quick Start clone URL fixed.
-
-### Tests N/A
-
-- No code changes; no test delta.
-
----
-
-## Summary
-
-| PR | Verdict | Action needed |
-|---|---|---|
-| #3029 | **Approve with nit** | Merge-ready after confirming #3033 (or follow-up) adds `codex` to README runtime list. |
-| #3033 | **Approve with blocker** | Add `codex` to the 8-runtimes list (making 9) and to the compatibility table before merge. |
-
-**Risk if both merge as-is:** Public docs understate runtime count by 1; operators reading README may think `codex` is not supported when the provisioner already knows about it.
-
-**Recommended merge order:** #3029 first (adds runtime support), then #3033 with `codex` line added (docs catch up).

scripts/build_runtime_package.py

@@ -62,7 +62,6 @@ TOP_LEVEL_MODULES = {
     "a2a_tools_memory",
     "a2a_tools_messaging",
     "a2a_tools_rbac",
-    "a2a_tools_identity",
     "adapter_base",
     "agent",
     "agents_md",

workspace-server/cmd/server/cp_config.go

@@ -60,8 +60,7 @@ func refreshEnvFromCP() error {
 	req.Header.Set("Authorization", "Bearer "+adminToken)
 	req.Header.Set("X-Molecule-Org-Id", orgID)
 
-	client := &http.Client{Timeout: 10 * time.Second}
-	resp, err := client.Do(req)
+	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
 		return fmt.Errorf("do request: %w", err)
 	}

workspace-server/internal/bundle/importer.go

@@ -3,7 +3,6 @@ package bundle
 import (
 	"context"
 	"fmt"
-	"log"
 	"strings"
 
 	"github.com/Molecule-AI/molecule-monorepo/platform/internal/db"
@@ -87,20 +86,13 @@ func Import(
 			// PluginsPath set by caller if available
 		}
 		go func() {
-			defer func() {
-				if r := recover(); r != nil {
-					log.Printf("bundle/importer: PANIC during provision start for %s: %v", wsID, r)
-				}
-			}()
 			provCtx, cancel := context.WithTimeout(context.Background(), provisioner.ProvisionTimeout)
 			defer cancel()
 			url, err := prov.Start(provCtx, cfg)
 			if err != nil {
 				markFailed(provCtx, wsID, broadcaster, err)
 			} else if url != "" {
-				if _, dbErr := db.DB.ExecContext(provCtx, `UPDATE workspaces SET url = $1 WHERE id = $2`, url, wsID); dbErr != nil {
-					log.Printf("bundle import: failed to update workspace URL for %s: %v", wsID, dbErr)
-				}
+				db.DB.ExecContext(provCtx, `UPDATE workspaces SET url = $1 WHERE id = $2`, url, wsID)
 			}
 		}()
 	}
@@ -147,16 +139,12 @@ func markFailed(ctx context.Context, wsID string, broadcaster *events.Broadcaste
 	// markProvisionFailed in workspace-server/internal/handlers/
 	// workspace_provision_shared.go.
 	msg := err.Error()
-	if _, dbErr := db.DB.ExecContext(ctx,
+	db.DB.ExecContext(ctx,
 		`UPDATE workspaces SET status = $1, last_sample_error = $2, updated_at = now() WHERE id = $3`,
-		models.StatusFailed, msg, wsID); dbErr != nil {
-		log.Printf("bundle import: failed to mark workspace %s failed: %v", wsID, dbErr)
-	}
-	if bcErr := broadcaster.RecordAndBroadcast(ctx, string(events.EventWorkspaceProvisionFailed), wsID, map[string]interface{}{
+		models.StatusFailed, msg, wsID)
+	broadcaster.RecordAndBroadcast(ctx, string(events.EventWorkspaceProvisionFailed), wsID, map[string]interface{}{
 		"error": msg,
-	}); bcErr != nil {
-		log.Printf("bundle import: failed to broadcast provision failed for %s: %v", wsID, bcErr)
-	}
+	})
 }
 
 func nilIfEmpty(s string) interface{} {

workspace-server/internal/channels/manager.go

@@ -375,25 +375,21 @@ func (m *Manager) HandleInbound(ctx context.Context, ch ChannelRow, msg *Inbound
 
 	// Update stats in DB
 	if db.DB != nil {
-		if _, err := db.DB.ExecContext(ctx, `
+		db.DB.ExecContext(ctx, `
 			UPDATE workspace_channels
 			SET last_message_at = now(), message_count = message_count + 1, updated_at = now()
 			WHERE id = $1
-		`, ch.ID); err != nil {
-			log.Printf("Channels: failed to update inbound stats for channel %s: %v", ch.ID, err)
-		}
+		`, ch.ID)
 	}
 
 	// Broadcast event
 	if m.broadcaster != nil {
-		if err := m.broadcaster.RecordAndBroadcast(ctx, string(events.EventChannelMessage), ch.WorkspaceID, map[string]interface{}{
+		m.broadcaster.RecordAndBroadcast(ctx, string(events.EventChannelMessage), ch.WorkspaceID, map[string]interface{}{
 			"channel_id":   ch.ID,
 			"channel_type": ch.ChannelType,
 			"username":     msg.Username,
 			"direction":    "inbound",
-		}); err != nil {
-			log.Printf("Channels: failed to broadcast inbound event: %v", err)
-		}
+		})
 	}
 
 	return nil
@@ -424,23 +420,19 @@ func (m *Manager) SendOutbound(ctx context.Context, channelID string, text strin
 	}
 
 	if db.DB != nil {
-		if _, err := db.DB.ExecContext(ctx, `
+		db.DB.ExecContext(ctx, `
 			UPDATE workspace_channels
 			SET last_message_at = now(), message_count = message_count + 1, updated_at = now()
 			WHERE id = $1
-		`, channelID); err != nil {
-			log.Printf("Channels: failed to update outbound stats for channel %s: %v", channelID, err)
-		}
+		`, channelID)
 	}
 
 	if m.broadcaster != nil {
-		if err := m.broadcaster.RecordAndBroadcast(ctx, string(events.EventChannelMessage), ch.WorkspaceID, map[string]interface{}{
+		m.broadcaster.RecordAndBroadcast(ctx, string(events.EventChannelMessage), ch.WorkspaceID, map[string]interface{}{
 			"channel_id":   ch.ID,
 			"channel_type": ch.ChannelType,
 			"direction":    "outbound",
-		}); err != nil {
-			log.Printf("Channels: failed to broadcast outbound event: %v", err)
-		}
+		})
 	}
 
 	return nil
@@ -506,10 +498,7 @@ func (m *Manager) FetchWorkspaceChannelContext(ctx context.Context, workspaceID
 		return ""
 	}
 	var config map[string]interface{}
-	if err := json.Unmarshal(configJSON, &config); err != nil {
-		log.Printf("Channels: failed to unmarshal channel config: %v", err)
-		return ""
-	}
+	json.Unmarshal(configJSON, &config)
 	if err := DecryptSensitiveFields(config); err != nil {
 		return ""
 	}
@@ -566,12 +555,8 @@ func (m *Manager) loadChannel(ctx context.Context, channelID string) (ChannelRow
 	if err != nil {
 		return ch, fmt.Errorf("channel %s not found: %w", channelID, err)
 	}
-	if err := json.Unmarshal(configJSON, &ch.Config); err != nil {
-		return ch, fmt.Errorf("unmarshal channel %s config: %w", channelID, err)
-	}
-	if err := json.Unmarshal(allowedJSON, &ch.AllowedUsers); err != nil {
-		return ch, fmt.Errorf("unmarshal channel %s allowed_users: %w", channelID, err)
-	}
+	json.Unmarshal(configJSON, &ch.Config)
+	json.Unmarshal(allowedJSON, &ch.AllowedUsers)
 	// #319: decrypt bot_token / webhook_secret — SendOutbound and adapter
 	// methods downstream read them as plaintext strings.
 	if err := DecryptSensitiveFields(ch.Config); err != nil {

workspace-server/internal/channels/telegram.go

@@ -482,12 +482,10 @@ func (t *TelegramAdapter) StartPolling(ctx context.Context, config map[string]in
 				if apiErr.Code == 429 {
 					retryAfter := time.Duration(apiErr.RetryAfter) * time.Second
 					log.Printf("Channels: Telegram poll rate-limited, sleeping %s", retryAfter)
-					timer := time.NewTimer(retryAfter)
 					select {
 					case <-ctx.Done():
-						timer.Stop()
 						return nil
-					case <-timer.C:
+					case <-time.After(retryAfter):
 						continue
 					}
 				}
@@ -497,12 +495,10 @@ func (t *TelegramAdapter) StartPolling(ctx context.Context, config map[string]in
 				}
 			}
 			log.Printf("Channels: Telegram poll error: %v", err)
-			timer := time.NewTimer(telegramPollInterval)
 			select {
 			case <-ctx.Done():
-				timer.Stop()
 				return nil
-			case <-timer.C:
+			case <-time.After(telegramPollInterval):
 				continue
 			}
 		}
@@ -517,9 +513,7 @@ func (t *TelegramAdapter) StartPolling(ctx context.Context, config map[string]in
 
 				// Acknowledge the button press (removes loading spinner)
 				ackCfg := tgbotapi.NewCallback(cb.ID, "Received")
-				if _, err := bot.Send(ackCfg); err != nil {
-					log.Printf("telegram: failed to send callback ack: %v", err)
-				}
+				bot.Send(ackCfg)
 
 				// Update the message to show what was clicked
 				decision := "approved"
@@ -531,9 +525,7 @@ func (t *TelegramAdapter) StartPolling(ctx context.Context, config map[string]in
 					cb.Message.MessageID,
 					cb.Message.Text+"\n\n✅ CEO "+decision,
 				)
-				if _, err := bot.Send(editMsg); err != nil {
-					log.Printf("telegram: failed to send edit message: %v", err)
-				}
+				bot.Send(editMsg)
 
 				// Route the decision as an inbound message to the agent
 				inbound := &InboundMessage{

workspace-server/internal/events/types.go

@@ -41,9 +41,8 @@ type EventType string
 // scan-friendly as it grows.
 const (
 	// Chat / agent messaging — surfaces in canvas chat panels.
-	EventAgentMessage   EventType = "AGENT_MESSAGE"
-	EventA2AResponse   EventType = "A2A_RESPONSE"
-	EventUserMessage    EventType = "USER_MESSAGE"
+	EventAgentMessage EventType = "AGENT_MESSAGE"
+	EventA2AResponse  EventType = "A2A_RESPONSE"
 	EventActivityLogged EventType = "ACTIVITY_LOGGED"
 	EventChannelMessage EventType = "CHANNEL_MESSAGE"
 
@@ -96,7 +95,6 @@ const (
 var AllEventTypes = []EventType{
 	EventA2AResponse,
 	EventActivityLogged,
-	EventUserMessage,
 	EventAgentAssigned,
 	EventAgentCardUpdated,
 	EventAgentMessage,

workspace-server/internal/events/types_test.go

@@ -41,7 +41,6 @@ func TestAllEventTypes_IsSnapshot(t *testing.T) {
 		"DELEGATION_STATUS",
 		"EXTERNAL_CREDENTIALS_ROTATED",
 		"TASK_UPDATED",
-		"USER_MESSAGE",
 		"WORKSPACE_AWAITING_AGENT",
 		"WORKSPACE_DEGRADED",
 		"WORKSPACE_HEARTBEAT",

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.go

@@ -399,21 +399,7 @@ func (h *WorkspaceHandler) proxyA2ARequest(ctx context.Context, workspaceID stri
 	// (no Do(), no maybeMarkContainerDead). The response is a synthetic
 	// {status:"queued"} envelope so the caller (canvas, another workspace)
 	// knows delivery is acknowledged but pending consumption.
-	deliveryMode, deliveryModeErr := lookupDeliveryMode(ctx, workspaceID)
-	if deliveryModeErr != nil {
-		// internal#497 fail-closed: a real DB/context error on the
-		// delivery-mode read MUST NOT silently fall through to the push
-		// dispatch path — that is exactly what silently misrouted every
-		// poll-mode peer for 5 days under the ce2db75f regression. Surface
-		// a structured error so the delegation is marked failed (loud +
-		// retryable) instead of dispatched to the wrong path.
-		log.Printf("ProxyA2A: delivery-mode lookup failed for %s: %v — failing closed", workspaceID, deliveryModeErr)
-		return 0, nil, &proxyA2AError{
-			Status:   http.StatusServiceUnavailable,
-			Response: gin.H{"error": "delivery-mode lookup failed; refusing to dispatch to avoid silent misrouting"},
-		}
-	}
-	if deliveryMode == models.DeliveryModePoll {
+	if lookupDeliveryMode(ctx, workspaceID) == models.DeliveryModePoll {
 		if logActivity {
 			h.logA2AReceiveQueued(ctx, workspaceID, callerID, body, a2aMethod)
 		}
@@ -932,12 +918,7 @@ func applyIdleTimeout(parent context.Context, b *events.Broadcaster, workspaceID
 	ctx, cancel := context.WithCancel(parent)
 	sub, unsub := b.SubscribeSSE(workspaceID)
 	go func() {
-		defer func() {
-			if r := recover(); r != nil {
-				log.Printf("a2a_proxy: PANIC in SSE idle watcher for %s: %v", workspaceID, r)
-			}
-			unsub()
-		}()
+		defer unsub()
 		timer := time.NewTimer(idle)
 		defer timer.Stop()
 		for {

workspace-server/internal/handlers/a2a_proxy_helpers.go

@@ -11,7 +11,6 @@ import (
 	"log"
 	"net/http"
 	"strconv"
-	"strings"
 	"time"
 
 	"github.com/Molecule-AI/molecule-monorepo/platform/internal/db"
@@ -195,11 +194,6 @@ func (h *WorkspaceHandler) maybeMarkContainerDead(ctx context.Context, workspace
 	}
 	db.ClearWorkspaceKeys(ctx, workspaceID)
 	h.broadcaster.RecordAndBroadcast(ctx, string(events.EventWorkspaceOffline), workspaceID, map[string]interface{}{})
-	// Tracked via goAsync (not bare `go`) so the asyncWG can be drained
-	// before a test swaps the global db.DB. runRestartCycle reads db.DB
-	// before its provisioner gate, so an untracked detached goroutine
-	// races setupTestDB's t.Cleanup db.DB restore. Matches the already-
-	// correct site at a2a_proxy.go:648.
 	h.goAsync(func() { h.RestartByID(workspaceID) })
 	return true
 }
@@ -247,9 +241,6 @@ func (h *WorkspaceHandler) preflightContainerHealth(ctx context.Context, workspa
 	}
 	db.ClearWorkspaceKeys(ctx, workspaceID)
 	h.broadcaster.RecordAndBroadcast(ctx, string(events.EventWorkspaceOffline), workspaceID, map[string]interface{}{})
-	// Tracked via goAsync (see maybeMarkContainerDead): preflight's
-	// detached restart must be drainable so it doesn't race the global
-	// db.DB swap in test cleanup.
 	h.goAsync(func() { h.RestartByID(workspaceID) })
 	return &proxyA2AError{
 		Status: http.StatusServiceUnavailable,
@@ -271,9 +262,8 @@ func (h *WorkspaceHandler) logA2AFailure(ctx context.Context, workspaceID, calle
 		errWsName = workspaceID
 	}
 	summary := "A2A request to " + errWsName + " failed: " + errMsg
-	parent := ctx
 	h.goAsync(func() {
-		logCtx, cancel := context.WithTimeout(context.WithoutCancel(parent), 30*time.Second)
+		logCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second)
 		defer cancel()
 		LogActivity(logCtx, h.broadcaster, ActivityParams{
 			WorkspaceID:  workspaceID,
@@ -319,9 +309,8 @@ func (h *WorkspaceHandler) logA2ASuccess(ctx context.Context, workspaceID, calle
 	}
 	summary := a2aMethod + " → " + wsNameForLog
 	toolTrace := extractToolTrace(respBody)
-	parent := ctx
 	h.goAsync(func() {
-		logCtx, cancel := context.WithTimeout(context.WithoutCancel(parent), 30*time.Second)
+		logCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second)
 		defer cancel()
 		LogActivity(logCtx, h.broadcaster, ActivityParams{
 			WorkspaceID:  workspaceID,
@@ -345,19 +334,6 @@ func (h *WorkspaceHandler) logA2ASuccess(ctx context.Context, workspaceID, calle
 			"duration_ms":   durationMs,
 		})
 	}
-
-	// #228: fan user's own outbound message to all sessions of the workspace.
-	// When a canvas user sends a message (callerID == "" and method == "message/send"),
-	// the originating session already inserted it optimistically in useChatSend.
-	// Other sessions see nothing until a manual refresh — this broadcast closes
-	// that gap. The originating session collapses its optimistic copy via the
-	// 3-second appendMessageDeduped window (same role + content = deduped).
-	if callerID == "" && a2aMethod == "message/send" && statusCode < 400 {
-		userPayload := extractCanvasUserMessage(body)
-		if userPayload != nil {
-			h.broadcaster.BroadcastOnly(workspaceID, string(events.EventUserMessage), userPayload)
-		}
-	}
 }
 
 func nilIfEmpty(s string) *string {
@@ -407,110 +383,6 @@ func validateCallerToken(ctx context.Context, c *gin.Context, callerID string) e
 // matching (the wsauth errors are typed for the invalid case).
 var errInvalidCallerToken = errors.New("missing caller auth token")
 
-// extractCanvasUserMessage parses an A2A JSON-RPC request body and extracts
-// the user-authored text and attachments from a canvas-initiated message/send.
-// Returns nil when the body is not a canvas user message (empty, malformed,
-// or not a message/send from canvas). The returned payload is safe to pass
-// directly to BroadcastOnly — nil fields are omitted from JSON.
-func extractCanvasUserMessage(body []byte) map[string]interface{} {
-	if len(body) == 0 {
-		return nil
-	}
-	var top map[string]json.RawMessage
-	if err := json.Unmarshal(body, &top); err != nil {
-		return nil
-	}
-	// Only handle message/send from canvas
-	var method string
-	if err := json.Unmarshal(top["method"], &method); err != nil || method != "message/send" {
-		return nil
-	}
-	params, ok := top["params"]
-	if !ok {
-		return nil
-	}
-	var paramsMap map[string]json.RawMessage
-	if err := json.Unmarshal(params, &paramsMap); err != nil {
-		return nil
-	}
-	msgRaw, ok := paramsMap["message"]
-	if !ok {
-		return nil
-	}
-	var msg map[string]json.RawMessage
-	if err := json.Unmarshal(msgRaw, &msg); err != nil {
-		return nil
-	}
-
-	// role field: only broadcast user-role messages (canvas users)
-	var role string
-	if err := json.Unmarshal(msg["role"], &role); err != nil || role != "user" {
-		return nil
-	}
-
-	result := make(map[string]interface{})
-
-	// Extract messageId if present
-	var mid string
-	if err := json.Unmarshal(msg["messageId"], &mid); err == nil && mid != "" {
-		result["messageId"] = mid
-	}
-
-	// Extract text from parts — accumulate all text parts into a single string
-	var parts []json.RawMessage
-	if err := json.Unmarshal(msg["parts"], &parts); err == nil {
-		var texts []string
-		var fileAttachments []map[string]interface{}
-		for _, pRaw := range parts {
-			var p map[string]json.RawMessage
-			if err := json.Unmarshal(pRaw, &p); err != nil {
-				continue
-			}
-			var t string
-			if err := json.Unmarshal(p["text"], &t); err == nil && t != "" {
-				texts = append(texts, t)
-			}
-			var fileRaw json.RawMessage
-			if err := json.Unmarshal(p["file"], &fileRaw); err == nil && fileRaw != nil {
-				var f map[string]json.RawMessage
-				if err := json.Unmarshal(fileRaw, &f); err == nil {
-					att := make(map[string]interface{})
-					var s string
-					if err := json.Unmarshal(f["uri"], &s); err == nil {
-						att["uri"] = s
-					}
-					if err := json.Unmarshal(f["name"], &s); err == nil {
-						att["name"] = s
-					}
-					if err := json.Unmarshal(f["mimeType"], &s); err == nil {
-						att["mimeType"] = s
-					}
-					var n float64
-					if err := json.Unmarshal(f["size"], &n); err == nil {
-						att["size"] = n
-					}
-					if len(att) > 0 {
-						fileAttachments = append(fileAttachments, att)
-					}
-				}
-			}
-		}
-		if len(texts) > 0 {
-			// Join with newlines — user may have sent multiple text parts
-			result["message"] = strings.Join(texts, "\n")
-		}
-		if len(fileAttachments) > 0 {
-			result["attachments"] = fileAttachments
-		}
-	}
-
-	// Drop empty payloads
-	if len(result) == 0 {
-		return nil
-	}
-	return result
-}
-
 // extractToolTrace pulls metadata.tool_trace from an A2A JSON-RPC response.
 // Returns nil when absent or malformed — callers can pass it straight through.
 func extractToolTrace(respBody []byte) json.RawMessage {
@@ -586,64 +458,40 @@ func parseUsageFromA2AResponse(body []byte) (inputTokens, outputTokens int64) {
 	return 0, 0
 }
 
-// lookupDeliveryMode returns the workspace's delivery_mode.
-//
-// internal#497 / RFC#497 fail-closed (SURGICAL scope): the *specific*
-// failure mode that hid the ce2db75f regression for 5 days is now
-// propagated instead of silently swallowed — a CONTEXT error
-// (context.Canceled / context.DeadlineExceeded). Under ce2db75f the
-// detached delegation goroutine ran on a cancelled request context, every
-// `SELECT delivery_mode` failed `context canceled`, this function returned
-// push, the poll-mode short-circuit in proxyA2ARequest was skipped, and
-// poll-mode peers (e.g. an operator laptop on molecule-mcp-claude-channel)
-// silently never got their a2a_receive inbox row. A transient,
-// systematic-once-triggered context cancellation became permanent
-// invisible misrouting. Returning that error lets the caller fail loud
-// (mark the delegation failed) instead of mis-dispatching.
-//
-// Scope is deliberately narrow: only ctx errors propagate. Other DB
-// errors retain the long-standing documented "fall back to push (today's
-// synchronous behavior)" contract — that path is loud + recoverable
-// (502 / SSRF reject / restart), unlike the silent poll-mode drop, and
-// the surrounding proxy (incl. the sibling checkWorkspaceBudget) is
-// intentionally built around that fail-open-to-push behavior. Widening
-// further is an RFC#497 follow-up, not part of this P0 fix.
-//
-// A genuinely *absent* configuration is NOT an error and still resolves to
-// push (the safe synchronous default): sql.ErrNoRows, a NULL/empty column,
-// or an unrecognised value all return (push, nil).
+// lookupDeliveryMode returns the workspace's delivery_mode. On any DB
+// error or missing row it returns DeliveryModePush — the fail-closed
+// default. "Closed" here means "fall back to today's behavior (synchronous
+// dispatch)" rather than "fall back to drop the request silently into
+// activity_logs where the agent might never see it." A poll-mode workspace
+// that briefly reads as push will get its A2A request dispatched to the
+// stored URL (or a 502 if no URL); a push-mode workspace that briefly
+// reads as poll would get its request silently queued with no dispatch.
+// The first failure is loud + recoverable; the second is silent.
 //
 // The function is intentionally lookup-only — it never mutates the row.
 // The register handler (registry.go) is the only writer for delivery_mode.
 //
 // See #2339 PR 1 for the column + register-flow side; this is the
 // proxy-side read used for the short-circuit in proxyA2ARequest.
-func lookupDeliveryMode(ctx context.Context, workspaceID string) (string, error) {
+func lookupDeliveryMode(ctx context.Context, workspaceID string) string {
 	var mode sql.NullString
 	err := db.DB.QueryRowContext(ctx,
 		`SELECT delivery_mode FROM workspaces WHERE id = $1`, workspaceID,
 	).Scan(&mode)
 	if err != nil {
-		// internal#497: a context cancellation/deadline MUST NOT be
-		// swallowed into a silent push default — that is the exact 5-day
-		// silent-misrouting vector. Propagate so the caller fails closed.
-		if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
-			log.Printf("ProxyA2A: lookupDeliveryMode(%s) context error (%v) — failing closed (NOT defaulting to push)", workspaceID, err)
-			return "", err
-		}
 		if !errors.Is(err, sql.ErrNoRows) {
-			log.Printf("ProxyA2A: lookupDeliveryMode(%s) failed (%v) — defaulting to push (non-ctx DB error; legacy fail-open-to-push contract)", workspaceID, err)
+			log.Printf("ProxyA2A: lookupDeliveryMode(%s) failed (%v) — defaulting to push", workspaceID, err)
 		}
-		return models.DeliveryModePush, nil
+		return models.DeliveryModePush
 	}
 	if !mode.Valid || mode.String == "" {
-		return models.DeliveryModePush, nil
+		return models.DeliveryModePush
 	}
 	if !models.IsValidDeliveryMode(mode.String) {
 		log.Printf("ProxyA2A: workspace %s has invalid delivery_mode=%q — defaulting to push", workspaceID, mode.String)
-		return models.DeliveryModePush, nil
+		return models.DeliveryModePush
 	}
-	return mode.String, nil
+	return mode.String
 }
 
 // logA2AReceiveQueued records a poll-mode "queued" A2A receive into
@@ -656,49 +504,25 @@ func lookupDeliveryMode(ctx context.Context, workspaceID string) (string, error)
 // 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/a2a_proxy_helpers_user_message_test.go

@@ -1,262 +0,0 @@
-package handlers
-
-import (
-	"encoding/json"
-	"testing"
-)
-
-// TestExtractCanvasUserMessage_TextOnly covers the primary path: a canvas user
-// sends a plain text message with no attachments.
-func TestExtractCanvasUserMessage_TextOnly(t *testing.T) {
-	body := []byte(`{
-		"method": "message/send",
-		"params": {
-			"message": {
-				"role": "user",
-				"messageId": "msg-abc-123",
-				"parts": [
-					{"kind": "text", "text": "Hello, agent!"}
-				]
-			}
-		}
-	}`)
-	got := extractCanvasUserMessage(body)
-	if got == nil {
-		t.Fatal("expected non-nil payload for text message")
-	}
-	if got["message"] != "Hello, agent!" {
-		t.Errorf("message = %v, want %q", got["message"], "Hello, agent!")
-	}
-	mid, ok := got["messageId"].(string)
-	if !ok || mid != "msg-abc-123" {
-		t.Errorf("messageId = %v, want %q", got["messageId"], "msg-abc-123")
-	}
-	_, hasAttachments := got["attachments"]
-	if hasAttachments {
-		t.Errorf("unexpected attachments: %v", got["attachments"])
-	}
-}
-
-// TestExtractCanvasUserMessage_FileOnly covers a user message with a file but no text.
-func TestExtractCanvasUserMessage_FileOnly(t *testing.T) {
-	body := []byte(`{
-		"method": "message/send",
-		"params": {
-			"message": {
-				"role": "user",
-				"messageId": "msg-file-456",
-				"parts": [
-					{
-						"kind": "file",
-						"file": {
-							"name": "report.pdf",
-							"uri": "workspace:/uploads/report.pdf",
-							"mimeType": "application/pdf",
-							"size": 4096
-						}
-					}
-				]
-			}
-		}
-	}`)
-	got := extractCanvasUserMessage(body)
-	if got == nil {
-		t.Fatal("expected non-nil payload for file-only message")
-	}
-	if got["message"] != nil {
-		t.Errorf("unexpected message text: %v", got["message"])
-	}
-	attachments, ok := got["attachments"].([]map[string]interface{})
-	if !ok || len(attachments) != 1 {
-		t.Fatalf("attachments = %v, want 1-element array", got["attachments"])
-	}
-	att := attachments[0]
-	if att["uri"] != "workspace:/uploads/report.pdf" {
-		t.Errorf("uri = %v, want %q", att["uri"], "workspace:/uploads/report.pdf")
-	}
-	if att["name"] != "report.pdf" {
-		t.Errorf("name = %v, want %q", att["name"], "report.pdf")
-	}
-	if att["mimeType"] != "application/pdf" {
-		t.Errorf("mimeType = %v, want %q", att["mimeType"], "application/pdf")
-	}
-}
-
-// TestExtractCanvasUserMessage_TextAndFile covers a user message with both text and a file.
-func TestExtractCanvasUserMessage_TextAndFile(t *testing.T) {
-	body := []byte(`{
-		"method": "message/send",
-		"params": {
-			"message": {
-				"role": "user",
-				"parts": [
-					{"kind": "text", "text": "Here is the file:"},
-					{"kind": "text", "text": "see below"},
-					{
-						"kind": "file",
-						"file": {
-							"name": "data.csv",
-							"uri": "workspace:/exports/data.csv",
-							"mimeType": "text/csv",
-							"size": 8192
-						}
-					}
-				]
-			}
-		}
-	}`)
-	got := extractCanvasUserMessage(body)
-	if got == nil {
-		t.Fatal("expected non-nil payload")
-	}
-	// Two text parts are joined with newline
-	if got["message"] != "Here is the file:\nsee below" {
-		t.Errorf("message = %v, want %q", got["message"], "Here is the file:\nsee below")
-	}
-	attachments, ok := got["attachments"].([]map[string]interface{})
-	if !ok || len(attachments) != 1 {
-		t.Fatalf("attachments = %v, want 1-element array", got["attachments"])
-	}
-}
-
-// TestExtractCanvasUserMessage_Malformed covers malformed JSON.
-func TestExtractCanvasUserMessage_Malformed(t *testing.T) {
-	cases := []struct {
-		name string
-		body []byte
-	}{
-		{"not JSON", []byte(`{not valid`)},
-		{"wrong type top-level", []byte(`123`)},
-		{"missing params", []byte(`{"method":"message/send"}`)},
-		{"params not object", []byte(`{"method":"message/send","params":123}`)},
-		{"missing message", []byte(`{"method":"message/send","params":{}}`)},
-		{"message not object", []byte(`{"method":"message/send","params":{"message":123}}`)},
-		{"role missing", []byte(`{"method":"message/send","params":{"message":{"parts":[]}}}`)},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			if got := extractCanvasUserMessage(tc.body); got != nil {
-				t.Errorf("expected nil for %s, got %v", tc.name, got)
-			}
-		})
-	}
-}
-
-// TestExtractCanvasUserMessage_NotUserRole covers agent/workspace callers
-// whose role is not "user" — these should not be broadcast as USER_MESSAGE.
-func TestExtractCanvasUserMessage_NotUserRole(t *testing.T) {
-	cases := []struct {
-		name string
-		body []byte
-	}{
-		{
-			"agent role",
-			[]byte(`{"method":"message/send","params":{"message":{"role":"agent","parts":[{"kind":"text","text":"hello"}]}}}`),
-		},
-		{
-			"assistant role",
-			[]byte(`{"method":"message/send","params":{"message":{"role":"assistant","parts":[{"kind":"text","text":"hello"}]}}}`),
-		},
-		{
-			"empty role",
-			[]byte(`{"method":"message/send","params":{"message":{"role":"","parts":[{"kind":"text","text":"hello"}]}}}`),
-		},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			if got := extractCanvasUserMessage(tc.body); got != nil {
-				t.Errorf("expected nil for role=%s, got %v", tc.name, got)
-			}
-		})
-	}
-}
-
-// TestExtractCanvasUserMessage_NotMessageSend covers non-message/send methods.
-func TestExtractCanvasUserMessage_NotMessageSend(t *testing.T) {
-	cases := []struct {
-		name   string
-		method string
-	}{
-		{"tasks/send", "tasks/send"},
-		{"initialize", "initialize"},
-		{"ping", "ping"},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			body, _ := json.Marshal(map[string]interface{}{
-				"method": tc.method,
-				"params": map[string]interface{}{
-					"message": map[string]interface{}{
-						"role":  "user",
-						"parts": []map[string]interface{}{{"kind": "text", "text": "hello"}},
-					},
-				},
-			})
-			if got := extractCanvasUserMessage(body); got != nil {
-				t.Errorf("expected nil for method=%q, got %v", tc.method, got)
-			}
-		})
-	}
-}
-
-// TestExtractCanvasUserMessage_BlankOrEmpty covers text with only whitespace
-// and empty parts arrays.
-func TestExtractCanvasUserMessage_BlankOrEmpty(t *testing.T) {
-	cases := []struct {
-		name string
-		body []byte
-	}{
-		{
-			"empty text part",
-			[]byte(`{"method":"message/send","params":{"message":{"role":"user","parts":[{"kind":"text","text":""}]}}}`),
-		},
-		{
-			"empty parts array",
-			[]byte(`{"method":"message/send","params":{"message":{"role":"user","parts":[]}}}`),
-		},
-		{
-			"whitespace-only text — still included as valid content",
-			[]byte(`{"method":"message/send","params":{"message":{"role":"user","parts":[{"kind":"text","text":"   "}]}}}`),
-		},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			got := extractCanvasUserMessage(tc.body)
-			if tc.name == "whitespace-only text — still included as valid content" {
-				// Whitespace-only text is valid content — preserve it as-is.
-				// Canvas dedup collapses identical copies; whitespace is not stripped.
-				if got == nil {
-					t.Error("expected non-nil for whitespace-only text")
-				} else if got["message"] != "   " {
-					t.Errorf("message = %q, want %q", got["message"], "   ")
-				}
-				return
-			}
-			if got != nil {
-				t.Errorf("expected nil for %s, got %v", tc.name, got)
-			}
-		})
-	}
-}
-
-// TestExtractCanvasUserMessage_Unicode covers non-ASCII text.
-func TestExtractCanvasUserMessage_Unicode(t *testing.T) {
-	body := []byte(`{
-		"method": "message/send",
-		"params": {
-			"message": {
-				"role": "user",
-				"parts": [
-					{"kind": "text", "text": "こんにちは世界 🌍 日本語"}
-				]
-			}
-		}
-	}`)
-	got := extractCanvasUserMessage(body)
-	if got == nil {
-		t.Fatal("expected non-nil payload for unicode message")
-	}
-	if got["message"] != "こんにちは世界 🌍 日本語" {
-		t.Errorf("message = %v, want %q", got["message"], "こんにちは世界 🌍 日本語")
-	}
-}

workspace-server/internal/handlers/a2a_proxy_test.go

@@ -2235,18 +2235,12 @@ func TestProxyA2A_PushMode_NoShortCircuit(t *testing.T) {
 	}
 }
 
-// TestProxyA2A_PollMode_FailsClosedToPush verifies the LEGACY safety
-// contract is PRESERVED for non-context DB errors: a generic DB error
-// reading delivery_mode still defaults to push (today's behavior), NOT
-// poll. Failing to push means a poll-mode workspace briefly attempts a
-// real dispatch — visible failure (502 / SSRF rejection / restart
-// cascade), not a silent drop into activity_logs where the agent might
-// never look. Loud > silent, recoverable > lost.
-//
-// internal#497 narrows the fail-closed change to *context* errors only
-// (the actual ce2db75f regression vector); generic DB errors keep this
-// long-standing fail-open-to-push contract. The ctx-error fail-closed is
-// covered by TestLookupDeliveryMode_ContextCanceled_FailsClosed.
+// TestProxyA2A_PollMode_FailsClosedToPush verifies the safety contract:
+// a DB error reading delivery_mode must default to push (the existing
+// behavior), NOT poll. Failing to push means a poll-mode workspace
+// briefly attempts a real dispatch — visible failure (502 / SSRF
+// rejection / restart cascade), not a silent drop into activity_logs
+// where the agent might never look. Loud > silent, recoverable > lost.
 func TestProxyA2A_PollMode_FailsClosedToPush(t *testing.T) {
 	mock := setupTestDB(t)
 	setupTestRedis(t) // empty Redis — forces resolveAgentURL DB lookup
@@ -2257,8 +2251,7 @@ func TestProxyA2A_PollMode_FailsClosedToPush(t *testing.T) {
 
 	expectBudgetCheck(mock, wsID)
 
-	// lookupDeliveryMode hits a generic (non-context) DB error → must
-	// still default push (legacy contract preserved by internal#497).
+	// lookupDeliveryMode hits a transient DB error → must default push.
 	mock.ExpectQuery("SELECT delivery_mode FROM workspaces WHERE id").
 		WithArgs(wsID).
 		WillReturnError(sql.ErrConnDone)
@@ -2282,7 +2275,7 @@ func TestProxyA2A_PollMode_FailsClosedToPush(t *testing.T) {
 		var resp map[string]interface{}
 		_ = json.Unmarshal(w.Body.Bytes(), &resp)
 		if resp["status"] == "queued" {
-			t.Errorf("generic DB error on delivery_mode lookup silently queued the request — must fail-open-to-push, got body: %s", w.Body.String())
+			t.Errorf("DB error on delivery_mode lookup silently queued the request — must fail-closed-to-push, got body: %s", w.Body.String())
 		}
 	}
 
@@ -2291,37 +2284,6 @@ func TestProxyA2A_PollMode_FailsClosedToPush(t *testing.T) {
 	}
 }
 
-// TestLookupDeliveryMode_ContextCanceled_FailsClosed is the internal#497
-// regression test for the SECONDARY defect. It pins the exact invariant
-// that hid the ce2db75f regression for 5 days: when the delivery_mode read
-// fails because the context was cancelled (precisely what happened in the
-// detached delegation goroutine running on a returned request context),
-// lookupDeliveryMode MUST return an error and MUST NOT silently return
-// "push". Returning push there is what skipped the poll-mode short-circuit
-// and silently dropped 100% of poll-mode peer deliveries.
-//
-// A pre-cancelled context makes QueryRowContext fail with
-// context.Canceled deterministically — no DB rows are mocked because the
-// query never reaches a result.
-func TestLookupDeliveryMode_ContextCanceled_FailsClosed(t *testing.T) {
-	mock := setupTestDB(t)
-	// The query fails on the cancelled ctx before matching; provide a
-	// permissive expectation so sqlmock doesn't complain about the attempt.
-	mock.ExpectQuery("SELECT delivery_mode FROM workspaces WHERE id").
-		WillReturnError(context.Canceled)
-
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel() // simulate the HTTP handler having returned (request ctx dead)
-
-	mode, err := lookupDeliveryMode(ctx, "ws-poll-peer")
-	if err == nil {
-		t.Fatalf("internal#497 regression: lookupDeliveryMode swallowed a context error and returned mode=%q with nil err — this is the exact 5-day silent-misrouting vector", mode)
-	}
-	if mode == models.DeliveryModePush {
-		t.Errorf("internal#497 regression: context error must NOT default to push (got mode=%q)", mode)
-	}
-}
-
 // ==================== a2aClient ResponseHeaderTimeout config ====================
 
 func TestA2AClientResponseHeaderTimeout(t *testing.T) {

workspace-server/internal/handlers/activity.go

@@ -691,19 +691,6 @@ func logActivityExec(ctx context.Context, exec activityExecutor, broadcaster eve
 		if respStr != nil {
 			payload["response_body"] = json.RawMessage(respJSON)
 		}
-		// internal#211/#212: error_detail carries the runtime's curated,
-		// user-actionable, secret-safe failure reason (provider HTTP
-		// status + error code + the provider's own guidance, e.g. a 403
-		// "org disabled · use an API key / ask your admin"). It is
-		// already persisted to the DB column above and capped by the
-		// runtime's report_activity helper (4096 chars). Previously it
-		// was dropped from the LIVE broadcast, so the canvas had nothing
-		// to render and fell back to a hardcoded opaque
-		// "Agent error (Exception) — see workspace logs" string. Include
-		// it so the chat bubble shows the real reason in real time.
-		if params.ErrorDetail != nil && *params.ErrorDetail != "" {
-			payload["error_detail"] = *params.ErrorDetail
-		}
 	}
 
 	return func() {

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_card_reconcile.go

@@ -1,113 +0,0 @@
-package handlers
-
-import "encoding/json"
-
-// agent_card_reconcile.go — server-side repair for the fleet-wide
-// agent-card identity gap.
-//
-// Root cause: the runtime builds its AgentCard from config.name
-// (workspace/main.py:198), and config.name is read from the
-// CP-regenerated /configs/config.yaml whose `name:` field is the raw
-// workspace UUID — NOT the friendly name the operator sees. The friendly
-// name IS captured: POST /workspaces and PATCH /workspaces/:id (the
-// canvas Details tab) write it to the trusted workspaces.name DB column.
-// But /registry/register stores the runtime-supplied card verbatim
-// (registry.go: `agent_card = EXCLUDED.agent_card`), so the stored card
-// served at /.well-known/agent-card.json and returned to peers via
-// agent_card_url ends up with name = UUID, description = "", role = null.
-//
-// Fix shape (deliberately minimal, no contract weakening): when the
-// runtime-supplied card's `name` is empty or equals the workspace UUID
-// (the placeholder the runtime had no better value for), the PLATFORM —
-// not the agent — substitutes the friendly value from the trusted
-// workspaces row. Identity stays platform-controlled: the agent never
-// gains the ability to self-set its own name/role; the platform sources
-// it from the operator-controlled DB column. We only ever FILL gaps
-// (empty / UUID-placeholder); a card that already carries a real
-// friendly name is never downgraded.
-//
-// list_peers / the /registry/:id/peers endpoint already resolve display
-// names from workspaces.name directly (discovery.go / mcp_tools.go
-// `SELECT w.id, w.name, ...`), so peer_name in delivered message tags
-// was already correct — this fix closes the remaining surface: the
-// agent_card blob itself (canvas Agent Card / Skills view, peer
-// agent_card_url fetches, the well-known card).
-//
-// description / role degrade discovery the same way: an empty
-// description and null role give peers nothing to reason about. We
-// default description from the (now reconciled) name when blank and
-// role from workspaces.role when the operator set one.
-
-// reconcileAgentCardIdentity patches identity gaps in a runtime-supplied
-// agent card from the trusted workspace DB row. It returns the
-// (possibly rewritten) card bytes and whether anything changed. On any
-// failure (malformed JSON, nothing to fill) it returns the input bytes
-// unchanged with changed=false so the caller can store them verbatim —
-// this is strictly no-worse-than-before, never a regression.
-//
-// Pure function: no DB / HTTP / globals, so it is exhaustively
-// unit-testable (agent_card_reconcile_test.go) without booting the
-// handler or a sqlmock.
-func reconcileAgentCardIdentity(card json.RawMessage, workspaceID, dbName, dbRole string) (json.RawMessage, bool) {
-	var m map[string]any
-	if err := json.Unmarshal(card, &m); err != nil || m == nil {
-		// Malformed card — not this function's job to reject it (the
-		// upsert stores it as-is and downstream readers handle bad
-		// JSON). Return verbatim so byte-for-byte behaviour is
-		// preserved on the failure path.
-		return card, false
-	}
-
-	changed := false
-
-	// name: fill only when empty or the UUID placeholder. A dbName that
-	// is itself the UUID is a placeholder row (registry.go INSERT seeds
-	// name = id before the canvas sets a friendly one) — not a friendly
-	// name, so it is not an eligible source.
-	cardName, _ := m["name"].(string)
-	if (cardName == "" || cardName == workspaceID) &&
-		dbName != "" && dbName != workspaceID {
-		m["name"] = dbName
-		changed = true
-	}
-
-	// description: when blank, default to the (reconciled) name so peers
-	// and the canvas Agent Card view have a non-empty human label
-	// instead of "". Mirrors the runtime's own
-	// `config.description or config.name` fallback (main.py:199) but
-	// applied to the registry copy where the runtime's fallback was the
-	// UUID.
-	if desc, _ := m["description"].(string); desc == "" {
-		if n, _ := m["name"].(string); n != "" && n != workspaceID {
-			m["description"] = n
-			changed = true
-		}
-	}
-
-	// role: surface the operator-set workspaces.role when the card
-	// carries none. Discovery (peer_role) and the canvas Role row read
-	// workspaces.role directly; this just makes the standalone card
-	// self-describing too. Never overwrite a role the card already has.
-	if dbRole != "" {
-		if r, ok := m["role"].(string); !ok || r == "" {
-			m["role"] = dbRole
-			changed = true
-		}
-	}
-
-	if !changed {
-		// No-op: return the original bytes untouched so callers that
-		// compare/store get byte-identical input (re-marshalling would
-		// reorder keys for no reason).
-		return card, false
-	}
-
-	out, err := json.Marshal(m)
-	if err != nil {
-		// Re-marshal of a map we just unmarshalled should never fail;
-		// if it somehow does, fall back to the verbatim input rather
-		// than storing nothing.
-		return card, false
-	}
-	return out, true
-}

workspace-server/internal/handlers/agent_card_reconcile_test.go

@@ -1,166 +0,0 @@
-package handlers
-
-import (
-	"encoding/json"
-	"testing"
-)
-
-// TestReconcileAgentCardIdentity covers the server-side backfill that
-// repairs the fleet-wide agent-card identity gap (internal#XXX): the
-// runtime POSTs /registry/register with agent_card.name = the workspace
-// UUID (because the CP-regenerated /configs/config.yaml sets name: <uuid>)
-// while the trusted workspaces.name DB column — the value the canvas
-// Details tab shows and lets the operator edit — holds the friendly
-// name ("Claude Code Agent"). The platform reconciles them from the DB
-// row (NOT from the agent — identity stays platform-controlled, not
-// self-mutable).
-func TestReconcileAgentCardIdentity(t *testing.T) {
-	const wsID = "3b81321b-1ec7-488c-96f7-72c42a968da6"
-
-	tests := []struct {
-		name        string
-		card        string
-		dbName      string
-		dbRole      string
-		wantName    string
-		wantDesc    string
-		wantRole    string
-		wantChanged bool
-	}{
-		{
-			name:        "name is the workspace UUID — backfill from DB",
-			card:        `{"name":"3b81321b-1ec7-488c-96f7-72c42a968da6","description":"","capabilities":{"streaming":true}}`,
-			dbName:      "Claude Code Agent",
-			dbRole:      "",
-			wantName:    "Claude Code Agent",
-			wantDesc:    "Claude Code Agent",
-			wantRole:    "",
-			wantChanged: true,
-		},
-		{
-			name:        "empty name — backfill from DB",
-			card:        `{"name":"","description":"x"}`,
-			dbName:      "ops-agent",
-			dbRole:      "sre",
-			wantName:    "ops-agent",
-			wantDesc:    "x",
-			wantRole:    "sre",
-			wantChanged: true,
-		},
-		{
-			name:        "role null in card, DB has role — backfill role only",
-			card:        `{"name":"Reviewer","description":"Senior reviewer"}`,
-			dbName:      "Reviewer",
-			dbRole:      "code-reviewer",
-			wantName:    "Reviewer",
-			wantDesc:    "Senior reviewer",
-			wantRole:    "code-reviewer",
-			wantChanged: true,
-		},
-		{
-			name: "card already has a real friendly name — do NOT clobber it",
-			// A richer card (e.g. an external channel agent) must win;
-			// the platform only fills gaps, never downgrades.
-			card:        `{"name":"Claude Code (channel)","description":"Local Claude Code session bridged","role":"assistant"}`,
-			dbName:      "hongming-pc",
-			dbRole:      "operator",
-			wantName:    "Claude Code (channel)",
-			wantDesc:    "Local Claude Code session bridged",
-			wantRole:    "assistant",
-			wantChanged: false,
-		},
-		{
-			name:        "no DB name available — leave UUID name untouched (no worse than before)",
-			card:        `{"name":"3b81321b-1ec7-488c-96f7-72c42a968da6","description":""}`,
-			dbName:      "",
-			dbRole:      "",
-			wantName:    "3b81321b-1ec7-488c-96f7-72c42a968da6",
-			wantDesc:    "",
-			wantRole:    "",
-			wantChanged: false,
-		},
-		{
-			name:        "dbName equals UUID (placeholder row) — not a friendly name, leave untouched",
-			card:        `{"name":"3b81321b-1ec7-488c-96f7-72c42a968da6"}`,
-			dbName:      "3b81321b-1ec7-488c-96f7-72c42a968da6",
-			dbRole:      "",
-			wantName:    "3b81321b-1ec7-488c-96f7-72c42a968da6",
-			wantDesc:    "",
-			wantRole:    "",
-			wantChanged: false,
-		},
-		{
-			name:        "malformed card JSON — return unchanged, no panic",
-			card:        `{not json`,
-			dbName:      "Claude Code Agent",
-			dbRole:      "",
-			wantChanged: false,
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			out, changed := reconcileAgentCardIdentity(
-				json.RawMessage(tc.card), wsID, tc.dbName, tc.dbRole,
-			)
-			if changed != tc.wantChanged {
-				t.Fatalf("changed = %v, want %v", changed, tc.wantChanged)
-			}
-			if !tc.wantChanged {
-				// Unchanged path must return the input bytes verbatim.
-				if string(out) != tc.card {
-					t.Fatalf("unchanged path mutated bytes:\n got  %s\n want %s", out, tc.card)
-				}
-				return
-			}
-			var got map[string]any
-			if err := json.Unmarshal(out, &got); err != nil {
-				t.Fatalf("output not valid JSON: %v (%s)", err, out)
-			}
-			if g, _ := got["name"].(string); g != tc.wantName {
-				t.Errorf("name = %q, want %q", g, tc.wantName)
-			}
-			if g, _ := got["description"].(string); g != tc.wantDesc {
-				t.Errorf("description = %q, want %q", g, tc.wantDesc)
-			}
-			if tc.wantRole != "" {
-				if g, _ := got["role"].(string); g != tc.wantRole {
-					t.Errorf("role = %q, want %q", g, tc.wantRole)
-				}
-			}
-		})
-	}
-}
-
-// TestReconcileAgentCardIdentity_PreservesOtherFields ensures the
-// reconcile is a minimal in-place patch — capabilities, version,
-// skills and any unknown future fields survive untouched.
-func TestReconcileAgentCardIdentity_PreservesOtherFields(t *testing.T) {
-	card := `{"name":"ws-uuid","description":"","version":"1.0.0",` +
-		`"capabilities":{"streaming":true,"pushNotifications":true},` +
-		`"skills":[{"id":"a","name":"a"}],"configuration_status":"ready"}`
-	out, changed := reconcileAgentCardIdentity(
-		json.RawMessage(card), "ws-uuid", "Friendly Name", "",
-	)
-	if !changed {
-		t.Fatal("expected changed = true")
-	}
-	var got map[string]any
-	if err := json.Unmarshal(out, &got); err != nil {
-		t.Fatalf("invalid JSON: %v", err)
-	}
-	if got["version"] != "1.0.0" {
-		t.Errorf("version not preserved: %v", got["version"])
-	}
-	if got["configuration_status"] != "ready" {
-		t.Errorf("configuration_status not preserved: %v", got["configuration_status"])
-	}
-	caps, ok := got["capabilities"].(map[string]any)
-	if !ok || caps["streaming"] != true {
-		t.Errorf("capabilities not preserved: %v", got["capabilities"])
-	}
-	skills, ok := got["skills"].([]any)
-	if !ok || len(skills) != 1 {
-		t.Errorf("skills not preserved: %v", got["skills"])
-	}
-}

workspace-server/internal/handlers/approvals.go

@@ -51,29 +51,23 @@ func (h *ApprovalsHandler) Create(c *gin.Context) {
 		return
 	}
 
-	if err := h.broadcaster.RecordAndBroadcast(ctx, string(events.EventApprovalRequested), workspaceID, map[string]interface{}{
+	h.broadcaster.RecordAndBroadcast(ctx, string(events.EventApprovalRequested), workspaceID, map[string]interface{}{
 		"approval_id": approvalID,
 		"action":      body.Action,
 		"reason":      body.Reason,
 		"task_id":     body.TaskID,
-	}); err != nil {
-		log.Printf("approvals: failed to broadcast approval requested: %v", err)
-	}
+	})
 
 	// Auto-escalate to parent
 	var parentID *string
-	if err := db.DB.QueryRowContext(ctx, `SELECT parent_id FROM workspaces WHERE id = $1`, workspaceID).Scan(&parentID); err != nil {
-		log.Printf("approvals: failed to lookup parent for escalation: %v", err)
-	}
+	db.DB.QueryRowContext(ctx, `SELECT parent_id FROM workspaces WHERE id = $1`, workspaceID).Scan(&parentID)
 	if parentID != nil {
-		if err := h.broadcaster.RecordAndBroadcast(ctx, string(events.EventApprovalEscalated), *parentID, map[string]interface{}{
+		h.broadcaster.RecordAndBroadcast(ctx, string(events.EventApprovalEscalated), *parentID, map[string]interface{}{
 			"approval_id":       approvalID,
 			"from_workspace_id": workspaceID,
 			"action":            body.Action,
 			"reason":            body.Reason,
-		}); err != nil {
-			log.Printf("approvals: failed to broadcast approval escalated: %v", err)
-		}
+		})
 	}
 
 	c.JSON(http.StatusCreated, gin.H{"approval_id": approvalID, "status": "pending"})
@@ -86,12 +80,10 @@ func (h *ApprovalsHandler) ListAll(c *gin.Context) {
 	ctx := c.Request.Context()
 
 	// Auto-expire stale approvals (older than 10 min)
-	if _, err := db.DB.ExecContext(ctx, `
+	db.DB.ExecContext(ctx, `
 		UPDATE approval_requests SET status = 'denied', decided_by = 'auto-expired', decided_at = now()
 		WHERE status = 'pending' AND created_at < now() - interval '10 minutes'
-	`); err != nil {
-		log.Printf("approvals: failed to auto-expire stale approvals: %v", err)
-	}
+	`)
 
 	rows, err := db.DB.QueryContext(ctx, `
 		SELECT a.id, a.workspace_id, w.name, a.action, a.reason, a.status, a.created_at
@@ -219,13 +211,11 @@ func (h *ApprovalsHandler) Decide(c *gin.Context) {
 		eventType = "APPROVAL_DENIED"
 	}
 
-	if err := h.broadcaster.RecordAndBroadcast(ctx, eventType, workspaceID, map[string]interface{}{
+	h.broadcaster.RecordAndBroadcast(ctx, eventType, workspaceID, map[string]interface{}{
 		"approval_id": approvalID,
 		"decision":    body.Decision,
 		"decided_by":  decidedBy,
-	}); err != nil {
-		log.Printf("approvals: failed to broadcast approval decision: %v", err)
-	}
+	})
 
 	c.JSON(http.StatusOK, gin.H{"status": body.Decision, "approval_id": approvalID})
 }

workspace-server/internal/handlers/channels.go

@@ -558,11 +558,6 @@ func (h *ChannelHandler) Webhook(c *gin.Context) {
 
 	// Process asynchronously — don't block the webhook response
 	go func() {
-		defer func() {
-			if r := recover(); r != nil {
-				log.Printf("Channels: PANIC in async HandleInbound for workspace %s: %v", ch.WorkspaceID[:12], r)
-			}
-		}()
 		bgCtx := context.Background()
 		if err := h.manager.HandleInbound(bgCtx, ch, msg); err != nil {
 			log.Printf("Channels: async HandleInbound error for workspace %s: %v", ch.WorkspaceID[:12], err)

workspace-server/internal/handlers/chat_files.go

@@ -107,29 +107,10 @@ func (h *ChatFilesHandler) WithPendingUploads(storage pendinguploads.Storage, br
 }
 
 // chatUploadMaxBytes caps the full multipart request body so a
-// malicious / runaway client can't OOM the proxy hop. 100 MB matches
-// the workspace-side total limit; anything larger is rejected at the
+// malicious / runaway client can't OOM the proxy hop. 50 MB matches
+// the workspace-side limit; anything larger is rejected at the
 // network boundary before forwarding.
-//
-// SSOT NOTE (issue #1520): this constant is the source of truth for
-// chat upload limits across the platform. Its value is exported to
-// the workspace container at provision time via the env var
-// CHAT_UPLOAD_MAX_TOTAL_BYTES (see
-// workspace_provision_shared.go::applyChatUploadLimits) so the
-// Python runtime cap stays in lock-step. Do NOT change this without
-// updating the per-file cap chatUploadMaxFileBytes below and
-// verifying the env-injection site is unchanged.
-const chatUploadMaxBytes = 100 * 1024 * 1024
-
-// chatUploadMaxFileBytes caps any single multipart part. Mirrors the
-// total cap by default because most chat uploads are a single file;
-// keeping per-file equal to total avoids the surprise of "my 60 MB
-// file fit under the total but got 413'd on per-file". Exported to
-// the workspace container as CHAT_UPLOAD_MAX_FILE_BYTES so the
-// Starlette parser's max_part_size matches and any single part above
-// Starlette's default 1 MiB no longer raises MultiPartException
-// (root cause of issue #1520).
-const chatUploadMaxFileBytes = 100 * 1024 * 1024
+const chatUploadMaxBytes = 50 * 1024 * 1024
 
 // resolveWorkspaceForwardCreds resolves the workspace's URL +
 // platform_inbound_secret for an /internal/* forward, applying

workspace-server/internal/handlers/chat_upload_limits_test.go

@@ -1,63 +0,0 @@
-package handlers
-
-// chat_upload_limits_test.go — pins the SSOT env-injection contract
-// for chat-upload caps (issue #1520). The Python workspace runtime
-// reads these env vars at module init; drift between the constant in
-// chat_files.go and the env-var name here silently breaks chat upload
-// fleet-wide, so the contract is asserted as a unit test in the same
-// package as the producer.
-
-import (
-	"fmt"
-	"testing"
-)
-
-// applyChatUploadLimits MUST seed both env vars to the byte-count
-// stringification of the Go-side constants. Anything else means a
-// Python-side parser cap that disagrees with the Go-side network cap,
-// which is exactly the drift that shipped #1520.
-func TestApplyChatUploadLimits_DefaultsMatchGoConstants(t *testing.T) {
-	env := map[string]string{}
-	applyChatUploadLimits(env)
-
-	wantFile := fmt.Sprintf("%d", chatUploadMaxFileBytes)
-	if got := env["CHAT_UPLOAD_MAX_FILE_BYTES"]; got != wantFile {
-		t.Errorf("CHAT_UPLOAD_MAX_FILE_BYTES = %q, want %q", got, wantFile)
-	}
-
-	wantTotal := fmt.Sprintf("%d", chatUploadMaxBytes)
-	if got := env["CHAT_UPLOAD_MAX_TOTAL_BYTES"]; got != wantTotal {
-		t.Errorf("CHAT_UPLOAD_MAX_TOTAL_BYTES = %q, want %q", got, wantTotal)
-	}
-}
-
-// Pre-existing values win. A tenant override, plugin mutator, or A/B
-// experiment that already set the env MUST be preserved — the SSOT
-// helper is a defaulting layer, not an override layer.
-func TestApplyChatUploadLimits_PreExistingValuesPreserved(t *testing.T) {
-	env := map[string]string{
-		"CHAT_UPLOAD_MAX_FILE_BYTES":  "1234",
-		"CHAT_UPLOAD_MAX_TOTAL_BYTES": "5678",
-	}
-	applyChatUploadLimits(env)
-
-	if got := env["CHAT_UPLOAD_MAX_FILE_BYTES"]; got != "1234" {
-		t.Errorf("pre-existing CHAT_UPLOAD_MAX_FILE_BYTES overwritten: got %q", got)
-	}
-	if got := env["CHAT_UPLOAD_MAX_TOTAL_BYTES"]; got != "5678" {
-		t.Errorf("pre-existing CHAT_UPLOAD_MAX_TOTAL_BYTES overwritten: got %q", got)
-	}
-}
-
-// The 100 MB minimum is the CTO-directed allowance floor (issue #1520).
-// Pin so a future "tidy up: 100 MB seems large" refactor surfaces here
-// before reverting the user-visible behaviour change.
-func TestChatUploadCaps_MinimumAllowanceFloor(t *testing.T) {
-	const floor = 100 * 1024 * 1024
-	if chatUploadMaxBytes < floor {
-		t.Errorf("chatUploadMaxBytes = %d, below #1520 floor %d", chatUploadMaxBytes, floor)
-	}
-	if chatUploadMaxFileBytes < floor {
-		t.Errorf("chatUploadMaxFileBytes = %d, below #1520 floor %d", chatUploadMaxFileBytes, floor)
-	}
-}

workspace-server/internal/handlers/delegation.go

@@ -163,32 +163,8 @@ func (h *DelegationHandler) Delegate(c *gin.Context) {
 		},
 	})
 
-	// Fire-and-forget: send A2A in a background goroutine.
-	//
-	// internal#497 — the goroutine MUST NOT inherit the HTTP request's
-	// cancellation. `ctx` here is c.Request.Context(); the handler returns
-	// 202 a few lines below, which cancels that context immediately. Before
-	// this fix (regression ce2db75f) executeDelegation ran on the
-	// request-scoped ctx, so every DB op + proxy call in the detached
-	// goroutine failed `context canceled` the instant the 202 was written.
-	// That silently broke 100% of A2A peer delegations fleet-wide since
-	// 2026-05-12 (poll-mode peers never got their a2a_receive inbox row;
-	// lookupDeliveryMode swallowed the ctx error and defaulted to push).
-	//
-	// context.WithoutCancel detaches cancellation/deadline while PRESERVING
-	// all context values (trace/correlation/tenant ids that proxyA2ARequest
-	// and the broadcaster read off ctx) — this is the established pattern in
-	// this package (a2a_proxy.go:850, a2a_proxy_helpers.go:525,
-	// registry.go:822). The 30-minute ceiling matches the prior internal
-	// budget executeDelegation used before ce2db75f and the proxy's own
-	// absolute agent-dispatch ceiling (a2a_proxy.go forwardCtx).
-	delegationCtx, cancelDelegation := context.WithTimeout(
-		context.WithoutCancel(ctx), 30*time.Minute,
-	)
-	go func() {
-		defer cancelDelegation()
-		h.executeDelegation(delegationCtx, sourceID, body.TargetID, delegationID, a2aBody)
-	}()
+	// Fire-and-forget: send A2A in background goroutine
+	go h.executeDelegation(ctx, sourceID, body.TargetID, delegationID, a2aBody)
 
 	// Broadcast event so canvas shows delegation in real-time
 	h.broadcaster.RecordAndBroadcast(ctx, string(events.EventDelegationSent), sourceID, map[string]interface{}{
@@ -747,14 +723,6 @@ func (h *DelegationHandler) listDelegationsFromLedger(ctx context.Context, works
 			entry["response_preview"] = textutil.TruncateBytes(resultPreview.String, 300)
 		}
 		if errorDetail.Valid && errorDetail.String != "" {
-			// Emit both keys: `error_detail` is the canonical field the
-			// Python poll-mode consumer (a2a_tools_delegation.py:184)
-			// reads from /delegations rows — without it, poll-mode
-			// silently loses the failure reason and falls through to
-			// the generic "delegation failed" string. `error` is kept
-			// for back-compat with existing UI surfaces that read the
-			// shorter name.
-			entry["error_detail"] = errorDetail.String
 			entry["error"] = errorDetail.String
 		}
 		if lastHeartbeat != nil {
@@ -816,8 +784,6 @@ func (h *DelegationHandler) listDelegationsFromActivityLogs(ctx context.Context,
 			entry["delegation_id"] = delegationID
 		}
 		if errorDetail != "" {
-			// Emit both keys per the rename: see listDelegationsFromLedger.
-			entry["error_detail"] = errorDetail
 			entry["error"] = errorDetail
 		}
 		if responseBody != "" {

workspace-server/internal/handlers/delegation_test.go

@@ -16,65 +16,6 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-// ---------- internal#497 regression: detached goroutine ctx must outlive the handler ----------
-
-// TestDelegate_DetachedContext_SurvivesRequestCancellation pins the
-// load-bearing invariant that regression ce2db75f violated: the context
-// handed to executeDelegation in the fire-and-forget goroutine must NOT be
-// cancelled when the HTTP handler returns 202 (which cancels
-// c.Request.Context()). Before the fix, executeDelegation ran on the
-// request-scoped ctx, so every DB op + proxy call failed `context
-// canceled` the instant the 202 was written — silently breaking 100% of
-// A2A peer delegations fleet-wide since 2026-05-12.
-//
-// This test asserts the exact ctx-derivation contract used by Delegate
-// (context.WithoutCancel(parent) + a timeout budget): the derived context
-// (a) stays alive after the parent is cancelled, and (b) still carries
-// parent values (trace/correlation/tenant ids the downstream proxy +
-// broadcaster read off ctx). It is intentionally DB-free and fast.
-func TestDelegate_DetachedContext_SurvivesRequestCancellation(t *testing.T) {
-	type ctxKey string
-	const traceKey ctxKey = "trace-id"
-
-	// Simulate c.Request.Context() carrying a correlation value.
-	parent, cancelParent := context.WithCancel(
-		context.WithValue(context.Background(), traceKey, "trace-abc-123"),
-	)
-
-	// Exact derivation Delegate uses for the detached goroutine.
-	delegationCtx, cancelDelegation := context.WithTimeout(
-		context.WithoutCancel(parent), 30*time.Minute,
-	)
-	defer cancelDelegation()
-
-	// The HTTP handler "returns 202" → request context is cancelled.
-	cancelParent()
-
-	if err := parent.Err(); err == nil {
-		t.Fatal("precondition: parent context should be cancelled after the handler returns")
-	}
-
-	// (a) Cancellation MUST NOT propagate to the detached context.
-	select {
-	case <-delegationCtx.Done():
-		t.Fatalf("regression: detached delegation ctx was cancelled by the handler returning (err=%v) — executeDelegation would fail every DB op with `context canceled`", delegationCtx.Err())
-	default:
-		// alive — correct
-	}
-
-	// (b) Parent values MUST still be readable (WithoutCancel preserves
-	// values; trace/correlation/tenant ids the proxy + broadcaster use).
-	if got, _ := delegationCtx.Value(traceKey).(string); got != "trace-abc-123" {
-		t.Errorf("detached ctx lost the parent trace value: got %q, want %q", got, "trace-abc-123")
-	}
-
-	// And it still has a real deadline (the 30m budget), so it is not an
-	// unbounded background context.
-	if _, hasDeadline := delegationCtx.Deadline(); !hasDeadline {
-		t.Error("detached ctx must carry the 30-minute timeout budget, but has no deadline")
-	}
-}
-
 // ---------- Delegate: missing target_id → 400 ----------
 
 func TestDelegate_MissingTargetID(t *testing.T) {
@@ -1546,71 +1487,6 @@ func TestListDelegations_LedgerEmptyFallsBackToActivityLogs(t *testing.T) {
 	}
 }
 
-// ---------- ListDelegations: activity_logs failed row emits BOTH error + error_detail ----------
-
-// Field-rename pin (P1 #348 / RFC #2829 PR-2 follow-up): the legacy
-// activity_logs fallback path must also emit `error_detail` alongside
-// the historical `error` key. Without this, poll-mode (which reads
-// `error_detail`) silently loses the failure reason when the ledger
-// is empty and the handler falls back to activity_logs.
-func TestListDelegations_ActivityLogsFailedEmitsBothErrorKeys(t *testing.T) {
-	mock := setupTestDB(t)
-	setupTestRedis(t)
-	broadcaster := newTestBroadcaster()
-	wh := NewWorkspaceHandler(broadcaster, nil, "http://localhost:8080", t.TempDir())
-	dh := NewDelegationHandler(wh, broadcaster)
-
-	// Ledger empty → fall back to activity_logs.
-	mock.ExpectQuery("SELECT d.delegation_id, d.caller_id, d.callee_id, d.task_preview").
-		WithArgs("ws-source").
-		WillReturnRows(sqlmock.NewRows([]string{
-			"delegation_id", "caller_id", "callee_id", "task_preview",
-			"status", "result_preview", "error_detail", "last_heartbeat",
-			"deadline", "created_at", "updated_at",
-		}))
-
-	now := time.Now()
-	activityRows := sqlmock.NewRows([]string{
-		"id", "activity_type", "source_id", "target_id",
-		"summary", "status", "error_detail", "response_body",
-		"delegation_id", "created_at",
-	}).AddRow(
-		"act-failed", "delegate_result", "ws-source", "ws-target",
-		"Delegation failed", "error", "codex runtime timed out", "",
-		"del-failed-002", now,
-	)
-	mock.ExpectQuery("SELECT id, activity_type").
-		WithArgs("ws-source").
-		WillReturnRows(activityRows)
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{{Key: "id", Value: "ws-source"}}
-	c.Request = httptest.NewRequest("GET", "/workspaces/ws-source/delegations", nil)
-
-	dh.ListDelegations(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.Fatalf("failed to parse response: %v", err)
-	}
-	if len(resp) != 1 {
-		t.Fatalf("expected 1 row, got %d", len(resp))
-	}
-	if resp[0]["error"] != "codex runtime timed out" {
-		t.Errorf("expected `error` field set, got %v", resp[0]["error"])
-	}
-	if resp[0]["error_detail"] != "codex runtime timed out" {
-		t.Errorf("expected `error_detail` field set (poll-mode contract), got %v", resp[0]["error_detail"])
-	}
-	if err := mock.ExpectationsWereMet(); err != nil {
-		t.Errorf("unmet sqlmock expectations: %v", err)
-	}
-}
-
 // ---------- ListDelegations: both ledger and activity_logs empty → [] ----------
 
 func TestListDelegations_BothEmptyReturnsEmptyArray(t *testing.T) {
@@ -1809,15 +1685,7 @@ func TestListDelegations_LedgerFailedIncludesErrorDetail(t *testing.T) {
 		t.Errorf("expected status 'failed', got %v", resp[0]["status"])
 	}
 	if resp[0]["error"] != "Callee workspace not reachable" {
-		t.Errorf("expected error detail under `error`, got %v", resp[0]["error"])
-	}
-	// Field-rename pin (P1 #348 / RFC #2829 PR-2 follow-up): the
-	// Python poll-mode consumer in a2a_tools_delegation.py:184 reads
-	// `error_detail`, not `error`. Both keys MUST be present so polling
-	// surfaces the real failure reason instead of falling through to
-	// the generic "delegation failed" string.
-	if resp[0]["error_detail"] != "Callee workspace not reachable" {
-		t.Errorf("expected error detail under `error_detail`, got %v", resp[0]["error_detail"])
+		t.Errorf("expected error detail, got %v", resp[0]["error"])
 	}
 	if err := mock.ExpectationsWereMet(); err != nil {
 		t.Errorf("unmet sqlmock expectations: %v", err)

workspace-server/internal/handlers/discovery.go

@@ -239,7 +239,7 @@ func (h *DiscoveryHandler) Peers(c *gin.Context) {
 
 	// Siblings
 	if parentID.Valid {
-		siblings, _ := queryPeerMaps(ctx, `
+		siblings, _ := queryPeerMaps(`
 			SELECT w.id, w.name, COALESCE(w.role, ''), w.tier, w.status,
 				   COALESCE(w.agent_card, 'null'::jsonb), COALESCE(w.url, ''),
 				   w.parent_id, w.active_tasks
@@ -247,7 +247,7 @@ func (h *DiscoveryHandler) Peers(c *gin.Context) {
 			parentID.String, workspaceID)
 		peers = append(peers, siblings...)
 	} else {
-		siblings, _ := queryPeerMaps(ctx, `
+		siblings, _ := queryPeerMaps(`
 			SELECT w.id, w.name, COALESCE(w.role, ''), w.tier, w.status,
 				   COALESCE(w.agent_card, 'null'::jsonb), COALESCE(w.url, ''),
 				   w.parent_id, w.active_tasks
@@ -257,7 +257,7 @@ func (h *DiscoveryHandler) Peers(c *gin.Context) {
 	}
 
 	// Children
-	children, _ := queryPeerMaps(ctx, `
+	children, _ := queryPeerMaps(`
 		SELECT w.id, w.name, COALESCE(w.role, ''), w.tier, w.status,
 			   COALESCE(w.agent_card, 'null'::jsonb), COALESCE(w.url, ''),
 			   w.parent_id, w.active_tasks
@@ -266,7 +266,7 @@ func (h *DiscoveryHandler) Peers(c *gin.Context) {
 
 	// Parent
 	if parentID.Valid {
-		parent, _ := queryPeerMaps(ctx, `
+		parent, _ := queryPeerMaps(`
 			SELECT w.id, w.name, COALESCE(w.role, ''), w.tier, w.status,
 				   COALESCE(w.agent_card, 'null'::jsonb), COALESCE(w.url, ''),
 				   w.parent_id, w.active_tasks
@@ -303,8 +303,8 @@ func filterPeersByQuery(peers []map[string]interface{}, q string) []map[string]i
 }
 
 // queryPeerMaps returns clean JSON-serializable maps instead of Workspace structs.
-func queryPeerMaps(ctx context.Context, query string, args ...interface{}) ([]map[string]interface{}, error) {
-	rows, err := db.DB.QueryContext(ctx, query, args...)
+func queryPeerMaps(query string, args ...interface{}) ([]map[string]interface{}, error) {
+	rows, err := db.DB.Query(query, args...)
 	if err != nil {
 		log.Printf("queryPeerMaps error: %v", err)
 		return nil, err

workspace-server/internal/handlers/handlers_test.go

@@ -8,7 +8,6 @@ import (
 	"fmt"
 	"net/http"
 	"net/http/httptest"
-	"sync"
 	"testing"
 	"time"
 
@@ -23,39 +22,8 @@ import (
 	"github.com/redis/go-redis/v9"
 )
 
-// liveTestHandlers tracks every WorkspaceHandler built during the test
-// binary's lifetime so setupTestDB can drain their in-flight goAsync
-// goroutines (notably the detached RestartByID restart cycle, which
-// reads the global db.DB) BEFORE restoring db.DB. Without this drain a
-// fire-and-forget restart goroutine spawned by one test outlives that
-// test and races the db.DB swap in a later test's t.Cleanup — the
-// 0x...d548 data race on platform/internal/db.DB.
-var (
-	liveTestHandlersMu sync.Mutex
-	liveTestHandlers   []*WorkspaceHandler
-)
-
 func init() {
 	gin.SetMode(gin.TestMode)
-	newHandlerHook = func(h *WorkspaceHandler) {
-		liveTestHandlersMu.Lock()
-		liveTestHandlers = append(liveTestHandlers, h)
-		liveTestHandlersMu.Unlock()
-	}
-}
-
-// drainTestAsync waits for every tracked handler's goAsync goroutines to
-// finish. Called from setupTestDB's cleanup before db.DB is restored so
-// no detached restart/provision goroutine is mid-read of db.DB when the
-// pointer is swapped.
-func drainTestAsync() {
-	liveTestHandlersMu.Lock()
-	handlers := make([]*WorkspaceHandler, len(liveTestHandlers))
-	copy(handlers, liveTestHandlers)
-	liveTestHandlersMu.Unlock()
-	for _, h := range handlers {
-		h.waitAsyncForTest()
-	}
 }
 
 // setupTestDB creates a sqlmock DB and assigns it to the global db.DB.
@@ -74,16 +42,7 @@ func setupTestDB(t *testing.T) sqlmock.Sqlmock {
 	}
 	prevDB := db.DB
 	db.DB = mockDB
-	t.Cleanup(func() {
-		// Drain detached async goroutines (e.g. goAsync(RestartByID),
-		// which reads db.DB in runRestartCycle before its provisioner
-		// gate) BEFORE swapping db.DB back. Doing the restore first
-		// would let an in-flight restart goroutine read db.DB while
-		// this line writes it — the data race this guards against.
-		drainTestAsync()
-		db.DB = prevDB
-		mockDB.Close()
-	})
+	t.Cleanup(func() { db.DB = prevDB; mockDB.Close() })
 
 	// Disable SSRF checks for the duration of this test only. Restore
 	// the previous state via t.Cleanup so that TestIsSafeURL_* tests

workspace-server/internal/handlers/mcp_tools.go

@@ -15,7 +15,6 @@ import (
 	"fmt"
 	"io"
 	"log"
-	"net"
 	"net/http"
 	"os"
 	"strings"
@@ -55,22 +54,6 @@ func updateMCPDelegationStatus(ctx context.Context, db *sql.DB, workspaceID, del
 	}
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// mcpHTTPClient is a dedicated client for MCP bridge A2A calls.
-// Per-request deadlines are enforced via context (30 s sync, 8 s async).
-// Transport-level timeouts ensure dead workspaces fail fast instead of
-// hanging on OS default TCP timeouts (~75 s Linux).
-var mcpHTTPClient = &http.Client{
-	Transport: &http.Transport{
-		DialContext: (&net.Dialer{
-			Timeout:   5 * time.Second,
-			KeepAlive: 30 * time.Second,
-		}).DialContext,
-		ResponseHeaderTimeout: 30 * time.Second,
-		TLSHandshakeTimeout:   5 * time.Second,
-	},
-}
-
 // ─────────────────────────────────────────────────────────────────────────────
 // Tool implementations
 // ─────────────────────────────────────────────────────────────────────────────
@@ -248,7 +231,7 @@ func (h *MCPHandler) toolDelegateTask(ctx context.Context, callerID string, args
 	// so this header reflects a verified caller identity, not a spoofable value.
 	httpReq.Header.Set("X-Workspace-ID", callerID)
 
-	resp, err := mcpHTTPClient.Do(httpReq)
+	resp, err := http.DefaultClient.Do(httpReq)
 	if err != nil {
 		updateMCPDelegationStatus(ctx, h.database, callerID, delegationID, "failed", err.Error())
 		return "", fmt.Errorf("A2A call failed: %w", err)
@@ -296,11 +279,6 @@ func (h *MCPHandler) toolDelegateTaskAsync(ctx context.Context, callerID string,
 	// Fire and forget in a detached goroutine. Use a background context so
 	// the call is not cancelled when the HTTP request completes.
 	go func() {
-		defer func() {
-			if r := recover(); r != nil {
-				log.Printf("MCPHandler.delegate_task_async: PANIC for %s → %s: %v", callerID, targetID, r)
-			}
-		}()
 		bgCtx, cancel := context.WithTimeout(context.Background(), mcpAsyncCallTimeout)
 		defer cancel()
 
@@ -336,7 +314,7 @@ func (h *MCPHandler) toolDelegateTaskAsync(ctx context.Context, callerID string,
 		httpReq.Header.Set("Content-Type", "application/json")
 		httpReq.Header.Set("X-Workspace-ID", callerID)
 
-		resp, err := mcpHTTPClient.Do(httpReq)
+		resp, err := http.DefaultClient.Do(httpReq)
 		if err != nil {
 			log.Printf("MCPHandler.delegate_task_async: A2A call to %s: %v", targetID, err)
 			return

workspace-server/internal/handlers/org_helpers.go

@@ -177,7 +177,7 @@ func isEnvIdentPart(c byte) bool {
 	return isEnvIdentStart(c) || (c >= '0' && c <= '9')
 }
 
-// loadWorkspaceEnv reads the org root .env and the workspace-specific .env
+// loadWorkspaceEnv reads the org root .env and the workspace-specific .env .env and the workspace-specific .env
 // (workspace overrides org root). Used by both secret injection and channel
 // config expansion.
 //

workspace-server/internal/handlers/plugins_install.go

@@ -201,11 +201,6 @@ func (h *PluginsHandler) uninstallViaDocker(ctx context.Context, c *gin.Context,
 	// Auto-restart (small delay to ensure fs writes are flushed)
 	if h.restartFunc != nil {
 		go func() {
-			defer func() {
-				if r := recover(); r != nil {
-					log.Printf("plugins_install: PANIC in delayed restart for %s: %v", workspaceID, r)
-				}
-			}()
 			time.Sleep(2 * time.Second)
 			h.restartFunc(workspaceID)
 		}()

workspace-server/internal/handlers/plugins_install_test.go

@@ -1,53 +0,0 @@
-package handlers
-
-// plugins_install_test.go — additional coverage for plugins_install.go.
-//
-// Gaps filled vs. existing test files:
-//   - plugins_install_external_test.go: Install + Uninstall 422 (external runtime) ✓ covered
-//   - plugins_test.go:                 Install 400 (missing source, invalid body, etc.) ✓ covered
-//                                    Uninstall 400 (invalid plugin name, empty name) ✓ covered
-//                                    Download auth gate ✓ covered
-//   - org_import_helpers_test.go:      countWorkspaces, envRequirementKey, sanitizeEnvMembers,
-//                                        flattenAndSortRequirements, collectOrgEnv ✓ covered
-//
-// New test added here:
-//   - Uninstall 503: container not running, no SaaS dispatch.
-//
-// NOTE: validateWorkspaceID is not called inside the Install/Uninstall handlers.
-// UUID validation is the responsibility of the WorkspaceAuth middleware, so no
-// 400 test is needed here for UUID format.
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/gin-gonic/gin"
-	"github.com/stretchr/testify/require"
-)
-
-// TestPluginUninstall_ContainerNotRunning_Returns503 exercises the 503 path
-// where neither a local Docker container nor a SaaS instance-id dispatch
-// resolves. The handler must return "workspace container not running" — NOT a
-// generic 500 or a misleading 422 (external-runtime) message.
-func TestPluginUninstall_ContainerNotRunning_Returns503(t *testing.T) {
-	// No docker client + no instance-id lookup → falls through to 503.
-	h := NewPluginsHandler(t.TempDir(), nil, nil)
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Params = gin.Params{
-		{Key: "id", Value: "550e8400-e29b-41d4-a716-446655440000"},
-		{Key: "name", Value: "some-plugin"},
-	}
-	c.Request = httptest.NewRequest("DELETE",
-		"/workspaces/550e8400-e29b-41d4-a716-446655440000/plugins/some-plugin", nil)
-
-	h.Uninstall(c)
-
-	require.Equal(t, http.StatusServiceUnavailable, w.Code)
-	var body map[string]string
-	json.Unmarshal(w.Body.Bytes(), &body)
-	require.Equal(t, "workspace container not running", body["error"])
-}

workspace-server/internal/handlers/plugins_listing_test.go

@@ -1,141 +0,0 @@
-package handlers
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/gin-gonic/gin"
-)
-
-func TestListRegistry_EmptyDir(t *testing.T) {
-	dir := t.TempDir()
-	h := NewPluginsHandler(dir, nil, nil)
-
-	got := h.listRegistryFiltered("")
-	if len(got) != 0 {
-		t.Errorf("expected empty list, got %d plugins", len(got))
-	}
-}
-
-func TestListRegistry_IgnoresFiles(t *testing.T) {
-	dir := t.TempDir()
-	if err := os.WriteFile(filepath.Join(dir, "not-a-plugin.txt"), []byte("x"), 0600); err != nil {
-		t.Fatal(err)
-	}
-	h := NewPluginsHandler(dir, nil, nil)
-
-	got := h.listRegistryFiltered("")
-	if len(got) != 0 {
-		t.Errorf("expected empty list (files ignored), got %d", len(got))
-	}
-}
-
-func TestListRegistry_SinglePlugin(t *testing.T) {
-	dir := t.TempDir()
-	pluginDir := filepath.Join(dir, "my-plugin")
-	if err := os.Mkdir(pluginDir, 0755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(pluginDir, "plugin.yaml"), []byte("name: my-plugin\nversion: 1.0.0\n"), 0600); err != nil {
-		t.Fatal(err)
-	}
-	h := NewPluginsHandler(dir, nil, nil)
-
-	got := h.listRegistryFiltered("")
-	if len(got) != 1 {
-		t.Fatalf("expected 1 plugin, got %d", len(got))
-	}
-	if got[0].Name != "my-plugin" {
-		t.Errorf("expected name 'my-plugin', got %q", got[0].Name)
-	}
-}
-
-func TestListRegistry_FiltersByRuntime(t *testing.T) {
-	dir := t.TempDir()
-	for _, spec := range []struct{ name, yaml string }{
-		{"runtime-a", "name: runtime-a\nruntimes:\n  - claude-code\n"},
-		{"runtime-b", "name: runtime-b\nruntimes:\n  - hermes\n"},
-		{"universal", "name: universal\nversion: 1.0.0\n"},
-	} {
-		pd := filepath.Join(dir, spec.name)
-		if err := os.Mkdir(pd, 0755); err != nil {
-			t.Fatal(err)
-		}
-		if err := os.WriteFile(filepath.Join(pd, "plugin.yaml"), []byte(spec.yaml), 0600); err != nil {
-			t.Fatal(err)
-		}
-	}
-	h := NewPluginsHandler(dir, nil, nil)
-
-	// Filter to claude-code: runtime-a matches, universal (no runtimes field)
-	// is always included per supportsRuntime semantics.
-	got := h.listRegistryFiltered("claude-code")
-	if len(got) != 2 {
-		t.Fatalf("expected 2 (runtime-a + universal), got %d: %v", len(got), func() []string {
-			ns := make([]string, len(got))
-			for i, p := range got { ns[i] = p.Name }
-			return ns
-		}())
-	}
-}
-
-func TestListRegistry_PluginWithNoRuntimeDeclarations_AlwaysIncluded(t *testing.T) {
-	dir := t.TempDir()
-	pd := filepath.Join(dir, "universal-plugin")
-	if err := os.Mkdir(pd, 0755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(pd, "plugin.yaml"), []byte("name: universal-plugin\nversion: 1.0.0\n"), 0600); err != nil {
-		t.Fatal(err)
-	}
-	h := NewPluginsHandler(dir, nil, nil)
-
-	// When plugin declares no runtimes, it should always be included (try-it).
-	got := h.listRegistryFiltered("any-runtime")
-	if len(got) != 1 {
-		t.Errorf("expected 1 plugin (unspecified runtime), got %d", len(got))
-	}
-}
-
-func TestListRegistry_ReadDirError_ReturnsEmpty(t *testing.T) {
-	h := NewPluginsHandler("/nonexistent/path/for/plugins", nil, nil)
-	got := h.listRegistryFiltered("")
-	if len(got) != 0 {
-		t.Errorf("expected empty list on ReadDir error, got %d", len(got))
-	}
-}
-
-func TestListRegistry_HTTPEndpoint(t *testing.T) {
-	dir := t.TempDir()
-	pd := filepath.Join(dir, "test-plugin")
-	if err := os.Mkdir(pd, 0755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(pd, "plugin.yaml"), []byte("name: test-plugin\nversion: 2.0.0\n"), 0600); err != nil {
-		t.Fatal(err)
-	}
-	h := NewPluginsHandler(dir, nil, nil)
-
-	w := httptest.NewRecorder()
-	c, _ := gin.CreateTestContext(w)
-	c.Request = httptest.NewRequest("GET", "/plugins", nil)
-	h.ListRegistry(c)
-
-	if w.Code != http.StatusOK {
-		t.Errorf("expected 200, got %d: %s", w.Code, w.Body.String())
-	}
-	var plugins []pluginInfo
-	if err := json.Unmarshal(w.Body.Bytes(), &plugins); err != nil {
-		t.Fatalf("failed to parse JSON: %v", err)
-	}
-	if len(plugins) != 1 {
-		t.Errorf("expected 1 plugin, got %d", len(plugins))
-	}
-	if plugins[0].Name != "test-plugin" {
-		t.Errorf("expected name 'test-plugin', got %q", plugins[0].Name)
-	}
-}

workspace-server/internal/handlers/registry.go

@@ -327,33 +327,7 @@ func (h *RegistryHandler) Register(c *gin.Context) {
 		}
 	}
 
-	// Reconcile the runtime-supplied card's identity fields against the
-	// trusted workspaces row before storing. The runtime builds its card
-	// from config.name, which the CP-regenerated /configs/config.yaml
-	// sets to the workspace UUID — so without this the stored card
-	// served at /.well-known/agent-card.json and returned to peers via
-	// agent_card_url has name = UUID, description = "", role = null even
-	// though the operator-controlled workspaces.name holds the friendly
-	// name the canvas shows. We only FILL gaps from the DB (never
-	// downgrade a card that already carries a real name); identity stays
-	// platform-controlled — the agent cannot self-set these. Best-effort:
-	// a lookup failure leaves the card exactly as the runtime sent it
-	// (no-worse-than-before). See agent_card_reconcile.go.
-	reconciledCard := payload.AgentCard
-	{
-		var dbName, dbRole sql.NullString
-		if qErr := db.DB.QueryRowContext(ctx,
-			`SELECT name, role FROM workspaces WHERE id = $1`, payload.ID,
-		).Scan(&dbName, &dbRole); qErr == nil {
-			if rc, did := reconcileAgentCardIdentity(
-				payload.AgentCard, payload.ID, dbName.String, dbRole.String,
-			); did {
-				reconciledCard = rc
-				log.Printf("Registry register: reconciled agent_card identity for %s from workspaces row", payload.ID)
-			}
-		}
-	}
-	agentCardStr := string(reconciledCard)
+	agentCardStr := string(payload.AgentCard)
 
 	// urlForUpsert: poll-mode workspaces don't need a URL. Empty input
 	// becomes NULL via sql.NullString so the row's URL stays clean (the
@@ -439,12 +413,10 @@ func (h *RegistryHandler) Register(c *gin.Context) {
 		}
 	}
 
-	// Broadcast WORKSPACE_ONLINE — use the reconciled card so the canvas
-	// Agent Card view live-updates with the friendly name, matching what
-	// was just persisted (not the runtime's raw UUID-name card).
+	// Broadcast WORKSPACE_ONLINE
 	if err := h.broadcaster.RecordAndBroadcast(ctx, string(events.EventWorkspaceOnline), payload.ID, map[string]interface{}{
 		"url":           cachedURL,
-		"agent_card":    reconciledCard,
+		"agent_card":    payload.AgentCard,
 		"delivery_mode": effectiveMode,
 	}); err != nil {
 		log.Printf("Registry broadcast error: %v", err)

workspace-server/internal/handlers/restart_context.go

@@ -133,24 +133,24 @@ func loadRestartContextData(ctx context.Context, workspaceID string) restartCont
 	// message bus.
 	keySet := map[string]struct{}{}
 	if rows, err := db.DB.QueryContext(ctx, `SELECT key FROM global_secrets`); err == nil {
-		defer rows.Close()
 		for rows.Next() {
 			var k string
 			if rows.Scan(&k) == nil {
 				keySet[k] = struct{}{}
 			}
 		}
+		rows.Close()
 	}
 	if rows, err := db.DB.QueryContext(ctx,
 		`SELECT key FROM workspace_secrets WHERE workspace_id = $1`, workspaceID,
 	); err == nil {
-		defer rows.Close()
 		for rows.Next() {
 			var k string
 			if rows.Scan(&k) == nil {
 				keySet[k] = struct{}{}
 			}
 		}
+		rows.Close()
 	}
 	for k := range keySet {
 		d.EnvKeys = append(d.EnvKeys, k)
@@ -163,8 +163,6 @@ func loadRestartContextData(ctx context.Context, workspaceID string) restartCont
 // workspace's status flips to 'online' or the deadline expires.
 // Returns true on success; callers log+drop on false.
 func waitForWorkspaceOnline(ctx context.Context, workspaceID string, timeout time.Duration) bool {
-	ticker := time.NewTicker(restartContextOnlinePollInterval)
-	defer ticker.Stop()
 	deadline := time.Now().Add(timeout)
 	for time.Now().Before(deadline) {
 		var status string
@@ -176,7 +174,7 @@ func waitForWorkspaceOnline(ctx context.Context, workspaceID string, timeout tim
 		select {
 		case <-ctx.Done():
 			return false
-		case <-ticker.C:
+		case <-time.After(restartContextOnlinePollInterval):
 		}
 	}
 	return false

workspace-server/internal/handlers/restart_signals.go

@@ -56,10 +56,8 @@ const (
 // (an externally routable address) is used directly.
 func (h *WorkspaceHandler) gracefulPreRestart(ctx context.Context, workspaceID string) {
 	// Non-blocking send — don't stall the restart cycle.
-	// Run in a tracked async goroutine (goAsync, not bare `go`) so the
-	// caller (runRestartCycle) can proceed to stopForRestart without
-	// waiting, while the test harness can still drain it before swapping
-	// the global db.DB (resolveAgentURLForRestartSignal reads db.DB).
+	// Run in a detached goroutine so the caller (runRestartCycle) can
+	// proceed to stopForRestart without waiting.
 	h.goAsync(func() {
 		signalCtx, cancel := context.WithTimeout(context.Background(), restartSignalTimeout)
 		defer cancel()