test(secrets): 100% coverage — compileAll + ScanBytes error-path tests

Adds two tests to close the coverage gaps flagged post-merge of PR #1255 (issue #1269): - TestCompileError: injects an invalid regex ("(unbalanced") into Patterns via package-level shadow, calls compileAll() directly, and asserts compileErr is set and compiledPatterns is nil. - TestScanBytes_CompileErr: forces a compile failure first (invalid regex "[unclosed"), then calls ScanBytes and asserts it returns (nil, compileErr) — verifying the "compile failed" error-return branch that the happy-path tests never exercise. Both tests reset compiledOnce between attempts so each is self-contained and deterministic regardless of test execution order. Coverage: 100.0% of statements. Refs: #1269 Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
feat(files): Phase 1 /agent-home stub for Files API (RFC internal#425)
2026-05-16 01:12:11 +00:00 · 2026-05-16 00:13:20 +00:00 · 2026-05-15 22:19:23 +00:00 · 2026-05-15 21:25:19 +00:00 · 2026-05-15 07:42:19 +00:00 · 2026-05-15 00:19:44 -07:00
43 changed files with 2269 additions and 219 deletions
@@ -118,17 +118,19 @@ _DIRECTIVE_RE = re.compile(
 def parse_directives(
    comment_body: str,
    numeric_aliases: dict[int, str],
-) -> list[tuple[str, str, str]]:
+) -> tuple[list[tuple[str, str, str]], list]:
    """Extract /sop-ack and /sop-revoke directives from a comment body.

-    Returns a list of (kind, canonical_slug, note) tuples where:
-      kind is "sop-ack" or "sop-revoke"
-      canonical_slug is the normalized form (or "" if unparseable)
-      note is the trailing free-text (may be "")
+    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)
    """
    out: list[tuple[str, str, str]] = []
    if not comment_body:
-        return out
+        return out, []
    for m in _DIRECTIVE_RE.finditer(comment_body):
        kind = m.group(1)
        raw_slug = (m.group(2) or "").strip()
@@ -159,7 +161,7 @@ def parse_directives(
        # If we collapsed multi-word slug into kebab and there's a
        # trailing-text group too, append it.
        out.append((kind, canonical, note_from_group))
-    return out
+    return out, []


 # ---------------------------------------------------------------------------
@@ -249,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):
+        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
@@ -133,7 +133,6 @@ jobs:
  # the name match works on PRs that don't touch workspace-server/).
  platform-build:
    name: Platform (Go)
-    needs: changes
    runs-on: ubuntu-latest
    # mc#774 (closed 2026-05-14): Phase 4 flip of the platform-build job.
    # Phase 4 (#656) originally flipped this to continue-on-error: false based on
@@ -154,29 +153,29 @@ jobs:
      run:
        working-directory: workspace-server
    steps:
-      - if: needs.changes.outputs.platform != 'true'
+      - if: false
        working-directory: .
        run: echo "No platform/** changes — skipping real build steps; this job always runs to satisfy the required-check name on branch protection."
-      - if: needs.changes.outputs.platform == 'true'
+      - if: always()
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-      - if: needs.changes.outputs.platform == 'true'
+      - if: always()
        uses: actions/setup-go@40f1582b2485089dde7abd97c1529aa768e1baff # v5
        with:
          go-version: 'stable'
-      - if: needs.changes.outputs.platform == 'true'
+      - if: always()
        run: go mod download
-      - if: needs.changes.outputs.platform == 'true'
+      - if: always()
        run: go build ./cmd/server
      # CLI (molecli) moved to standalone repo: git.moleculesai.app/molecule-ai/molecule-cli
-      - if: needs.changes.outputs.platform == 'true'
+      - if: always()
        run: go vet ./...
-      - if: needs.changes.outputs.platform == 'true'
+      - if: always()
        name: Install golangci-lint
        run: go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.12.2
-      - if: needs.changes.outputs.platform == 'true'
+      - if: always()
        name: Run golangci-lint
        run: $(go env GOPATH)/bin/golangci-lint run --timeout 3m ./...
-      - if: needs.changes.outputs.platform == 'true'
+      - if: always()
        name: Diagnostic — per-package verbose 60s
        run: |
          set +e
@@ -192,7 +191,7 @@ jobs:
          echo "::endgroup::"
        # mc#774: pre-existing continue-on-error mask; root-fix and remove, do not renew silently.
        continue-on-error: true
-      - if: needs.changes.outputs.platform == 'true'
+      - 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 10m per-step timeout
@@ -200,7 +199,7 @@ jobs:
        # instead of OOM-killing. The job-level timeout (15m) is a backstop.
        run: go test -race -timeout 10m -coverprofile=coverage.out ./...

-      - if: needs.changes.outputs.platform == 'true'
+      - if: always()
        name: Per-file coverage report
        # Advisory — lists every source file with its coverage so reviewers
        # can see at-a-glance where gaps are. Sorted ascending so the worst
@@ -214,7 +213,7 @@ jobs:
                   END {for (f in s) printf "%6.1f%%  %s\n", s[f]/c[f], f}' \
            | sort -n

-      - if: needs.changes.outputs.platform == 'true'
+      - if: always()
        name: Check coverage thresholds
        # Enforces two gates from #1823 Layer 1:
        #   1. Total floor (25% — ratchet plan in COVERAGE_FLOOR.md).
@@ -302,28 +301,28 @@ jobs:
  # siblings — verified empirically on PR #2314).
  canvas-build:
    name: Canvas (Next.js)
-    needs: changes
    runs-on: ubuntu-latest
+    timeout-minutes: 20
    # Phase 4 (RFC #219 §1): confirmed green on main 2026-05-12.
    continue-on-error: false
    defaults:
      run:
        working-directory: canvas
    steps:
-      - if: needs.changes.outputs.canvas != 'true'
+      - if: false
        working-directory: .
        run: echo "No canvas/** changes — skipping real build steps; this job always runs to satisfy the required-check name on branch protection."
-      - if: needs.changes.outputs.canvas == 'true'
+      - if: always()
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-      - if: needs.changes.outputs.canvas == 'true'
+      - if: always()
        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
        with:
          node-version: '22'
-      - if: needs.changes.outputs.canvas == 'true'
+      - if: always()
        run: rm -f package-lock.json && npm install
-      - if: needs.changes.outputs.canvas == 'true'
+      - if: always()
        run: npm run build
-      - if: needs.changes.outputs.canvas == 'true'
+      - if: always()
        name: Run tests with coverage
        # Coverage instrumentation is configured in canvas/vitest.config.ts
        # (provider: v8, reporters: text + html + json-summary). Step 2 of
@@ -332,7 +331,7 @@ jobs:
        # tracked in #1815) after the team sees what current coverage is.
        run: npx vitest run --coverage
      - name: Upload coverage summary as artifact
-        if: needs.changes.outputs.canvas == 'true' && always()
+        if: always()
        # Pinned to v3 for Gitea act_runner v0.6 compatibility — v4+ uses
        # the GHES 3.10+ artifact protocol that Gitea 1.22.x does NOT
        # implement, surfacing as `GHESNotSupportedError: @actions/artifact
@@ -962,6 +962,32 @@ function MyChatPanel({ workspaceId, data }: Props) {
          </div>
        </div>
      )}
+      {/* talk_to_user disabled banner — shown when the workspace has
+           talk_to_user_enabled=false. The agent cannot send canvas messages;
+           the user can re-enable the ability from here without opening settings. */}
+      {data.talkToUserEnabled === false && (
+        <div className="flex items-center gap-2 px-3 py-2 bg-surface-sunken border-b border-line/40 shrink-0">
+          <svg width="14" height="14" viewBox="0 0 16 16" fill="none" aria-hidden="true" className="shrink-0 text-ink-mid">
+            <path d="M8 1a7 7 0 1 0 0 14A7 7 0 0 0 8 1Zm0 10.5a.75.75 0 1 1 0-1.5.75.75 0 0 1 0 1.5ZM8 4a.75.75 0 0 1 .75.75v4a.75.75 0 0 1-1.5 0v-4A.75.75 0 0 1 8 4Z" fill="currentColor"/>
+          </svg>
+          <span className="text-[10px] text-ink-mid flex-1">
+            Agent is not enabled to chat with you.
+          </span>
+          <button
+            onClick={async () => {
+              try {
+                await api.patch(`/workspaces/${workspaceId}/abilities`, { talk_to_user_enabled: true });
+                useCanvasStore.getState().updateNodeData(workspaceId, { talkToUserEnabled: true });
+              } catch {
+                // ignore — user will see no change and can retry
+              }
+            }}
+            className="px-2 py-0.5 text-[10px] font-medium bg-accent/10 hover:bg-accent/20 text-accent rounded border border-accent/30 transition-colors shrink-0"
+          >
+            Enable
+          </button>
+        </div>
+      )}
      {/* Messages */}
      <div ref={containerRef} className="flex-1 overflow-y-auto p-3 space-y-3">
        {loading && (
@@ -332,6 +332,105 @@ describe("handleCanvasEvent – WORKSPACE_PROVISIONING", () => {
    const bPos = lastNodes.find((n) => n.id === "ws-b")!.position;
    expect(bPos).toEqual({ x: 420, y: 100 }); // idx 1 = (100 + 320, 100)
  });
+
+  it("uses finalX/finalY from payload when parentId is set and parent exists in store", () => {
+    // Org-import child lands with explicit coords — these are server-computed
+    // parent-relative positions. The handler must trust them verbatim.
+    const parent = makeNode("parent-root", { name: "Root" });
+    const { get, set } = makeStore([parent]);
+
+    handleCanvasEvent(
+      makeMsg({
+        event: "WORKSPACE_PROVISIONING",
+        workspace_id: "child-org",
+        payload: {
+          name: "Org Child",
+          tier: 2,
+          parent_id: "parent-root",
+          x: 500,
+          y: 300,
+        },
+      }),
+      get,
+      set
+    );
+
+    const newNodes = (set.mock.calls[0][0] as { nodes: Node<WorkspaceNodeData>[] }).nodes;
+    expect(newNodes).toHaveLength(2);
+    const child = newNodes.find((n) => n.id === "child-org")!;
+
+    // Must use the server-provided coords, not grid
+    expect(child.position).toEqual({ x: 500, y: 300 });
+    // Must bind parentId so RF renders it nested inside the parent card
+    expect(child.parentId).toBe("parent-root");
+    expect(child.data.parentId).toBe("parent-root");
+    expect(child.data.name).toBe("Org Child");
+    expect(child.data.status).toBe("provisioning");
+  });
+
+  it("uses grid position when parentId is set but parent is NOT in store yet", () => {
+    // Rare WS-reorder: child event arrives before parent's PROVISIONING event.
+    // Must not crash — uses grid slot as fallback. Parent will reparent
+    // the child when it lands.
+    const { get, set } = makeStore([]);
+
+    handleCanvasEvent(
+      makeMsg({
+        event: "WORKSPACE_PROVISIONING",
+        workspace_id: "orphan-child",
+        payload: {
+          name: "Orphan",
+          parent_id: "unknown-parent",
+          x: 999,
+          y: 888,
+        },
+      }),
+      get,
+      set
+    );
+
+    const newNodes = (set.mock.calls[0][0] as { nodes: Node<WorkspaceNodeData>[] }).nodes;
+    const child = newNodes.find((n) => n.id === "orphan-child")!;
+
+    // Must NOT use finalX/finalY — parent isn't in store so grid slot is used
+    expect(child.position).not.toEqual({ x: 999, y: 888 });
+    // Grid slot for idx 0: (100, 100)
+    expect(child.position).toEqual({ x: 100, y: 100 });
+    // parentId is NOT set on the node when parent is unknown:
+    // the node will be reparented when the parent eventually lands
+    expect(child.data.parentId).not.toBe("unknown-parent");
+  });
+
+  it("no-op cascade: parent in store but no finalX/Y → grid position, no parentId", () => {
+    // Parent exists but payload has no x/y → must not crash, uses grid slot.
+    // parentId is NOT set because we don't have parent-relative coords.
+    const parent = makeNode("parent-exists");
+    const { get, set } = makeStore([parent]);
+
+    handleCanvasEvent(
+      makeMsg({
+        event: "WORKSPACE_PROVISIONING",
+        workspace_id: "child-no-coords",
+        payload: {
+          name: "No Coords",
+          parent_id: "parent-exists",
+          // no x or y
+        },
+      }),
+      get,
+      set
+    );
+
+    const newNodes = (set.mock.calls[0][0] as { nodes: Node<WorkspaceNodeData>[] }).nodes;
+    const child = newNodes.find((n) => n.id === "child-no-coords")!;
+
+    // Grid slot for idx 0: (100, 100)
+    expect(child.position).toEqual({ x: 100, y: 100 });
+    // parentId stays null (not undefined) when no finalX/Y — server has no
+    // position for this node, and the handler initialises parentId=null
+    expect(child.parentId).toBeUndefined();
+    expect(child.data.parentId).toBeNull();
+  });
 });

 // ---------------------------------------------------------------------------
@@ -848,6 +848,374 @@ describe("hydrationError", () => {
  });
 });

+// ---------- growParentsToFitChildren ----------
+//
+// growParentsToFitChildren walks every parent node and expands its width/height
+// so all children fit inside with padding. Collapsed parents are skipped (grow-
+// only, never shrink). Returns the same array reference when no changes are
+// needed, a new array when at least one parent grew.
+//
+// Constants (from canvas-topology.ts):
+//   CHILD_DEFAULT_WIDTH  = 240
+//   CHILD_DEFAULT_HEIGHT = 130
+//   PARENT_SIDE_PADDING   = 16
+//   PARENT_BOTTOM_PADDING  = 16
+//
+// For a child at (childX, childY) with size (childW, childH):
+//   requiredParentW = childX + childW + PARENT_SIDE_PADDING
+//   requiredParentH = childY + childH + PARENT_BOTTOM_PADDING
+//
+// Coverage targets:
+//   - Node with no parentId → skipped entirely (returns same node)
+//   - Parent with no children → skipped (kids.length === 0 → returns n)
+//   - Collapsed parent → skipped even when children overflow
+//   - Child fits within existing parent → no-op (requiredW <= currentW && requiredH <= currentH)
+//   - Child overflows parent width → grows width only
+//   - Child overflows parent height → grows height only
+//   - Child overflows both → grows both
+//   - Missing measured.width (falls back to width, then CHILD_DEFAULT_WIDTH)
+//   - Missing measured.height (falls back to height, then CHILD_DEFAULT_HEIGHT)
+//   - Missing parent measured.width (falls back to width, then 0)
+//   - Missing parent measured.height (falls back to height, then 0)
+//   - No change at all → returns same array reference (changed=false path)
+
+describe("growParentsToFitChildren", () => {
+  it("skips nodes with no parentId (standalone roots)", () => {
+    useCanvasStore.setState({
+      nodes: [
+        {
+          id: "root",
+          type: "workspaceNode",
+          position: { x: 0, y: 0 },
+          data: { name: "Root", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: null, currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+          measured: { width: 200, height: 150 },
+        },
+      ],
+    });
+
+    const before = useCanvasStore.getState().nodes;
+    useCanvasStore.getState().growParentsToFitChildren();
+    const after = useCanvasStore.getState().nodes;
+
+    // Same array reference (no change needed)
+    expect(after).toBe(before);
+  });
+
+  it("skips parent with no children (orphan parentId)", () => {
+    useCanvasStore.setState({
+      nodes: [
+        {
+          id: "orphan",
+          type: "workspaceNode",
+          position: { x: 0, y: 0 },
+          parentId: "nonexistent",
+          data: { name: "Orphan", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: null, currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+          measured: { width: 100, height: 100 },
+        },
+      ],
+    });
+
+    const before = useCanvasStore.getState().nodes;
+    useCanvasStore.getState().growParentsToFitChildren();
+    const after = useCanvasStore.getState().nodes;
+
+    // Same array reference (parentId exists but no children reference it)
+    expect(after).toBe(before);
+    expect(after[0].measured).toEqual({ width: 100, height: 100 });
+  });
+
+  it("skips collapsed parents even when children overflow", () => {
+    // Child at (500, 400) → requires parent 500+240+16=756w, 400+130+16=546h
+    // Parent is collapsed AND tiny — must NOT grow
+    useCanvasStore.setState({
+      nodes: [
+        {
+          id: "parent",
+          type: "workspaceNode",
+          position: { x: 0, y: 0 },
+          data: { name: "Parent", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: true, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: null, currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+          measured: { width: 200, height: 150 },
+        },
+        {
+          id: "child",
+          type: "workspaceNode",
+          position: { x: 500, y: 400 },
+          parentId: "parent",
+          data: { name: "Child", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: "parent", currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+          measured: { width: 240, height: 130 },
+        },
+      ],
+    });
+
+    const before = useCanvasStore.getState().nodes;
+    useCanvasStore.getState().growParentsToFitChildren();
+    const after = useCanvasStore.getState().nodes;
+
+    // Same reference (collapsed → skipped entirely)
+    expect(after).toBe(before);
+    const parent = after.find((n) => n.id === "parent")!;
+    expect(parent.measured).toEqual({ width: 200, height: 150 });
+  });
+
+  it("no-op when child fits within existing parent size", () => {
+    // Child at (0,0) 240x130 → requires 0+240+16=256w, 0+130+16=146h
+    // Parent is exactly 256×146 → fits perfectly
+    useCanvasStore.setState({
+      nodes: [
+        {
+          id: "parent",
+          type: "workspaceNode",
+          position: { x: 0, y: 0 },
+          data: { name: "Parent", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: null, currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+          measured: { width: 256, height: 146 },
+        },
+        {
+          id: "child",
+          type: "workspaceNode",
+          position: { x: 0, y: 0 },
+          parentId: "parent",
+          data: { name: "Child", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: "parent", currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+          measured: { width: 240, height: 130 },
+        },
+      ],
+    });
+
+    const before = useCanvasStore.getState().nodes;
+    useCanvasStore.getState().growParentsToFitChildren();
+    const after = useCanvasStore.getState().nodes;
+
+    // Same array reference (no change needed)
+    expect(after).toBe(before);
+    const parent = after.find((n) => n.id === "parent")!;
+    expect(parent.measured).toEqual({ width: 256, height: 146 });
+  });
+
+  it("grows parent width only when child overflows width but not height", () => {
+    // Child at (100, 0) 240x130 → requires 100+240+16=356w, 0+130+16=146h
+    // Parent is 256×146 → fits height, overflows width → grows to 356×146
+    useCanvasStore.setState({
+      nodes: [
+        {
+          id: "parent",
+          type: "workspaceNode",
+          position: { x: 0, y: 0 },
+          data: { name: "Parent", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: null, currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+          measured: { width: 256, height: 146 },
+        },
+        {
+          id: "child",
+          type: "workspaceNode",
+          position: { x: 100, y: 0 },
+          parentId: "parent",
+          data: { name: "Child", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: "parent", currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+          measured: { width: 240, height: 130 },
+        },
+      ],
+    });
+
+    useCanvasStore.getState().growParentsToFitChildren();
+    const parent = useCanvasStore.getState().nodes.find((n) => n.id === "parent")!;
+
+    expect(parent.width).toBe(356); // 100+240+16
+    expect(parent.height).toBe(146); // unchanged
+  });
+
+  it("grows parent height only when child overflows height but not width", () => {
+    // Child at (0, 50) 240x130 → requires 0+240+16=256w, 50+130+16=196h
+    // Parent is 256×146 → fits width, overflows height → grows to 256×196
+    useCanvasStore.setState({
+      nodes: [
+        {
+          id: "parent",
+          type: "workspaceNode",
+          position: { x: 0, y: 0 },
+          data: { name: "Parent", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: null, currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+          measured: { width: 256, height: 146 },
+        },
+        {
+          id: "child",
+          type: "workspaceNode",
+          position: { x: 0, y: 50 },
+          parentId: "parent",
+          data: { name: "Child", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: "parent", currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+          measured: { width: 240, height: 130 },
+        },
+      ],
+    });
+
+    useCanvasStore.getState().growParentsToFitChildren();
+    const parent = useCanvasStore.getState().nodes.find((n) => n.id === "parent")!;
+
+    expect(parent.width).toBe(256); // unchanged
+    expect(parent.height).toBe(196); // 50+130+16
+  });
+
+  it("grows parent in both dimensions when child overflows both", () => {
+    // Child at (200, 100) 240x130 → requires 200+240+16=456w, 100+130+16=246h
+    // Parent is 256×146 → grows to 456×246
+    useCanvasStore.setState({
+      nodes: [
+        {
+          id: "parent",
+          type: "workspaceNode",
+          position: { x: 0, y: 0 },
+          data: { name: "Parent", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: null, currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+          measured: { width: 256, height: 146 },
+        },
+        {
+          id: "child",
+          type: "workspaceNode",
+          position: { x: 200, y: 100 },
+          parentId: "parent",
+          data: { name: "Child", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: "parent", currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+          measured: { width: 240, height: 130 },
+        },
+      ],
+    });
+
+    useCanvasStore.getState().growParentsToFitChildren();
+    const parent = useCanvasStore.getState().nodes.find((n) => n.id === "parent")!;
+
+    expect(parent.width).toBe(456);  // 200+240+16
+    expect(parent.height).toBe(246); // 100+130+16
+  });
+
+  it("uses CHILD_DEFAULT_WIDTH/HEIGHT when child has no measured or explicit dimensions", () => {
+    // Child with NO measured, NO width/height → falls back to 240×130 defaults
+    // Child at (500, 200) → requires 500+240+16=756w, 200+130+16=346h
+    useCanvasStore.setState({
+      nodes: [
+        {
+          id: "parent",
+          type: "workspaceNode",
+          position: { x: 0, y: 0 },
+          data: { name: "Parent", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: null, currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+          measured: { width: 100, height: 100 },
+        },
+        {
+          id: "child",
+          type: "workspaceNode",
+          position: { x: 500, y: 200 },
+          parentId: "parent",
+          // No measured, no width/height → uses CHILD_DEFAULT_WIDTH=240, CHILD_DEFAULT_HEIGHT=130
+          data: { name: "Child", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: "parent", currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+        },
+      ],
+    });
+
+    useCanvasStore.getState().growParentsToFitChildren();
+    const parent = useCanvasStore.getState().nodes.find((n) => n.id === "parent")!;
+
+    expect(parent.width).toBe(756);  // 500+240+16
+    expect(parent.height).toBe(346); // 200+130+16
+  });
+
+  it("uses explicit width/height when measured is absent on child", () => {
+    // Child has width/height but NOT measured
+    // Child at (300, 50) with explicit 200×100 → requires 300+200+16=516w, 50+100+16=166h
+    useCanvasStore.setState({
+      nodes: [
+        {
+          id: "parent",
+          type: "workspaceNode",
+          position: { x: 0, y: 0 },
+          data: { name: "Parent", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: null, currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+          measured: { width: 200, height: 100 },
+        },
+        {
+          id: "child",
+          type: "workspaceNode",
+          position: { x: 300, y: 50 },
+          parentId: "parent",
+          width: 200,
+          height: 100,
+          // No measured → falls back to width=200, height=100
+          data: { name: "Child", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: "parent", currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+        },
+      ],
+    });
+
+    useCanvasStore.getState().growParentsToFitChildren();
+    const parent = useCanvasStore.getState().nodes.find((n) => n.id === "parent")!;
+
+    expect(parent.width).toBe(516);  // 300+200+16
+    expect(parent.height).toBe(166); // 50+100+16
+  });
+
+  it("uses measured when present (takes precedence over explicit width/height)", () => {
+    // Child has both measured AND explicit width/height — measured should win
+    // Child at (0,0) measured=240×130 explicit=100×50 → uses measured
+    // Required: 0+240+16=256w, 0+130+16=146h
+    useCanvasStore.setState({
+      nodes: [
+        {
+          id: "parent",
+          type: "workspaceNode",
+          position: { x: 0, y: 0 },
+          data: { name: "Parent", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: null, currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+          measured: { width: 256, height: 146 }, // fits exactly
+        },
+        {
+          id: "child",
+          type: "workspaceNode",
+          position: { x: 0, y: 0 },
+          parentId: "parent",
+          width: 100,   // ignored (measured present)
+          height: 50,   // ignored
+          measured: { width: 240, height: 130 },
+          data: { name: "Child", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: "parent", currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+        },
+      ],
+    });
+
+    const before = useCanvasStore.getState().nodes;
+    useCanvasStore.getState().growParentsToFitChildren();
+    const after = useCanvasStore.getState().nodes;
+
+    // Same reference (measured fits exactly)
+    expect(after).toBe(before);
+  });
+
+  it("multiple children: grows to fit the furthest child in each dimension", () => {
+    // Child 1 at (0, 0) 240×130 → maxRight=240, maxBottom=130
+    // Child 2 at (300, 200) 240×130 → maxRight=540, maxBottom=330
+    // Required: 540+16=556w, 330+16=346h
+    useCanvasStore.setState({
+      nodes: [
+        {
+          id: "parent",
+          type: "workspaceNode",
+          position: { x: 0, y: 0 },
+          data: { name: "Parent", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: null, currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+          measured: { width: 100, height: 100 },
+        },
+        {
+          id: "child1",
+          type: "workspaceNode",
+          position: { x: 0, y: 0 },
+          parentId: "parent",
+          data: { name: "Child1", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: "parent", currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+          measured: { width: 240, height: 130 },
+        },
+        {
+          id: "child2",
+          type: "workspaceNode",
+          position: { x: 300, y: 200 },
+          parentId: "parent",
+          data: { name: "Child2", status: "online", tier: 1, agentCard: null, activeTasks: 0, collapsed: false, role: "agent", lastErrorRate: 0, lastSampleError: "", url: "", parentId: "parent", currentTask: "", needsRestart: false, runtime: "", budgetLimit: null },
+          measured: { width: 240, height: 130 },
+        },
+      ],
+    });
+
+    useCanvasStore.getState().growParentsToFitChildren();
+    const parent = useCanvasStore.getState().nodes.find((n) => n.id === "parent")!;
+
+    expect(parent.width).toBe(556);  // max(0+240, 300+240)+16
+    expect(parent.height).toBe(346); // max(0+130, 200+130)+16
+  });
+});
+
 // ---------- ACTIVITY_LOGGED event ----------

 describe("ACTIVITY_LOGGED event", () => {
@@ -519,6 +519,10 @@ export function buildNodesAndEdges(
        // #2054 — server-declared per-workspace provisioning timeout.
        // Falls through to the runtime profile when null/absent.
        provisionTimeoutMs: ws.provision_timeout_ms ?? null,
+        // Workspace abilities — defaults preserved for old platform versions
+        // that don't yet include these columns in the GET response.
+        broadcastEnabled: ws.broadcast_enabled ?? false,
+        talkToUserEnabled: ws.talk_to_user_enabled ?? true,
      },
    };
    if (hasParent) {
@@ -99,6 +99,13 @@ export interface WorkspaceNodeData extends Record<string, unknown> {
   *  @/lib/runtimeProfiles. Lets a slow runtime declare its cold-boot
   *  expectation without a canvas release. */
  provisionTimeoutMs?: number | null;
+  /** When true the workspace may POST /broadcast to send org-wide messages.
+   *  Default false. Toggled by user/admin via PATCH /workspaces/:id/abilities. */
+  broadcastEnabled?: boolean;
+  /** When false the workspace cannot deliver canvas chat messages.
+   *  send_message_to_user / POST /notify return 403 and the canvas
+   *  shows a "not enabled" state with a button to re-enable. Default true. */
+  talkToUserEnabled?: boolean;
 }

 export type PanelTab = "details" | "skills" | "chat" | "terminal" | "config" | "schedule" | "channels" | "files" | "memory" | "traces" | "events" | "activity" | "audit";
@@ -299,6 +299,9 @@ export interface WorkspaceData {
   *  `@/lib/runtimeProfiles` when absent (the default behavior for any
   *  template that hasn't yet declared the field). */
  provision_timeout_ms?: number | null;
+  /** Workspace ability flags (migration 20260514). */
+  broadcast_enabled?: boolean;
+  talk_to_user_enabled?: boolean;
 }

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

 	// Workspace existence check
-	mock.ExpectQuery(`SELECT name FROM workspaces`).
+	mock.ExpectQuery(`SELECT name, talk_to_user_enabled FROM workspaces`).
 		WithArgs("ws-notify").
-		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("DD"))
+		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("DD", true))

 	// Persistence INSERT — verify shape
 	mock.ExpectExec(`INSERT INTO activity_logs`).
@@ -511,9 +511,9 @@ func TestNotify_WithAttachments_PersistsFilePartsForReload(t *testing.T) {
 	db.DB = mockDB
 	t.Cleanup(func() { db.DB = prevDB; mockDB.Close() })

-	mock.ExpectQuery(`SELECT name FROM workspaces`).
+	mock.ExpectQuery(`SELECT name, talk_to_user_enabled FROM workspaces`).
 		WithArgs("ws-attach").
-		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("DD"))
+		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("DD", true))

 	// Capture the JSONB arg so we can assert on the persisted shape
 	// AFTER the call (must include parts[].kind=file so reload
@@ -640,9 +640,9 @@ func TestNotify_DBFailure_StillBroadcastsAnd200(t *testing.T) {
 	db.DB = mockDB
 	t.Cleanup(func() { db.DB = prevDB; mockDB.Close() })

-	mock.ExpectQuery(`SELECT name FROM workspaces`).
+	mock.ExpectQuery(`SELECT name, talk_to_user_enabled FROM workspaces`).
 		WithArgs("ws-x").
-		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("DD"))
+		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("DD", true))
 	mock.ExpectExec(`INSERT INTO activity_logs`).
 		WillReturnError(fmt.Errorf("simulated db hiccup"))

@@ -54,6 +54,11 @@ import (
 // timeout) surface as wrapped errors and should be treated as 503.
 var ErrWorkspaceNotFound = errors.New("agent_message: workspace not found")

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

 	// 2. Build broadcast payload + WS-emit. Same shape that ChatTab's
 	//    AGENT_MESSAGE handler in canvas/src/store/canvas-events.ts has
@@ -88,9 +88,9 @@ func TestAgentMessageWriter_Send_Success_NoAttachments(t *testing.T) {
 	mock := setupTestDB(t)
 	w := NewAgentMessageWriter(db.DB, newTestBroadcaster())

-	mock.ExpectQuery("SELECT name FROM workspaces").
+	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
 		WithArgs("ws-1").
-		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("CEO Ryan PC"))
+		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("CEO Ryan PC", true))

 	mock.ExpectExec(`INSERT INTO activity_logs.*'a2a_receive'.*'notify'`).
 		WithArgs(
@@ -116,9 +116,9 @@ func TestAgentMessageWriter_Send_Success_WithAttachments(t *testing.T) {
 	mock := setupTestDB(t)
 	w := NewAgentMessageWriter(db.DB, newTestBroadcaster())

-	mock.ExpectQuery("SELECT name FROM workspaces").
+	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
 		WithArgs("ws-att").
-		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("Ryan"))
+		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("Ryan", true))

 	mock.ExpectExec(`INSERT INTO activity_logs.*'a2a_receive'.*'notify'`).
 		WithArgs(
@@ -173,9 +173,9 @@ func TestAgentMessageWriter_Send_WorkspaceNotFound(t *testing.T) {
 	emitter := &capturingEmitter{}
 	w := NewAgentMessageWriter(db.DB, emitter)

-	mock.ExpectQuery("SELECT name FROM workspaces").
+	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
 		WithArgs("ws-missing").
-		WillReturnRows(sqlmock.NewRows([]string{"name"}))
+		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}))

 	err := w.Send(context.Background(), "ws-missing", "lost in the void", nil)
 	if !errors.Is(err, ErrWorkspaceNotFound) {
@@ -202,9 +202,9 @@ func TestAgentMessageWriter_Send_DBInsertFailureStillReturnsNil(t *testing.T) {
 	mock := setupTestDB(t)
 	w := NewAgentMessageWriter(db.DB, newTestBroadcaster())

-	mock.ExpectQuery("SELECT name FROM workspaces").
+	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
 		WithArgs("ws-dbfail").
-		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("CEO Ryan PC"))
+		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("CEO Ryan PC", true))

 	mock.ExpectExec(`INSERT INTO activity_logs`).
 		WillReturnError(errors.New("transient db error"))
@@ -223,9 +223,9 @@ func TestAgentMessageWriter_Send_PreviewTruncation(t *testing.T) {
 	mock := setupTestDB(t)
 	w := NewAgentMessageWriter(db.DB, newTestBroadcaster())

-	mock.ExpectQuery("SELECT name FROM workspaces").
+	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
 		WithArgs("ws-trunc").
-		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("Ryan"))
+		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("Ryan", true))

 	longMsg := strings.Repeat("x", 200)
 	mock.ExpectExec(`INSERT INTO activity_logs`).
@@ -263,9 +263,9 @@ func TestAgentMessageWriter_Send_BroadcastsAgentMessageEvent(t *testing.T) {
 	emitter := &capturingEmitter{}
 	w := NewAgentMessageWriter(db.DB, emitter)

-	mock.ExpectQuery("SELECT name FROM workspaces").
+	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
 		WithArgs("ws-bc").
-		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("Workspace Name"))
+		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("Workspace Name", true))
 	mock.ExpectExec(`INSERT INTO activity_logs`).
 		WillReturnResult(sqlmock.NewResult(1, 1))

@@ -315,7 +315,7 @@ func TestAgentMessageWriter_Send_DBErrorOnLookupReturnsWrapped(t *testing.T) {
 	w := NewAgentMessageWriter(db.DB, newTestBroadcaster())

 	transientErr := errors.New("connection refused")
-	mock.ExpectQuery("SELECT name FROM workspaces").
+	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
 		WithArgs("ws-dbdown").
 		WillReturnError(transientErr)

@@ -350,9 +350,9 @@ func TestAgentMessageWriter_Send_NonASCIIMessagePersists(t *testing.T) {
 	// the byte-slice bug.
 	msg := strings.Repeat("你", 200)

-	mock.ExpectQuery("SELECT name FROM workspaces").
+	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
 		WithArgs("ws-cjk").
-		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("CEO Ryan PC"))
+		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("CEO Ryan PC", true))

 	mock.ExpectExec(`INSERT INTO activity_logs`).
 		WithArgs(
@@ -395,9 +395,9 @@ func TestAgentMessageWriter_Send_OmitsAttachmentsKeyWhenEmpty(t *testing.T) {
 	emitter := &capturingEmitter{}
 	w := NewAgentMessageWriter(db.DB, emitter)

-	mock.ExpectQuery("SELECT name FROM workspaces").
+	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
 		WithArgs("ws-noatt").
-		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("X"))
+		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("X", true))
 	mock.ExpectExec(`INSERT INTO activity_logs`).
 		WillReturnResult(sqlmock.NewResult(1, 1))

@@ -116,6 +116,9 @@ func (h *ApprovalsHandler) ListAll(c *gin.Context) {
 			"created_at":     createdAt,
 		})
 	}
+	if err := rows.Err(); err != nil {
+		log.Printf("ListPendingApprovals rows.Err: %v", err)
+	}

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

 	c.JSON(http.StatusOK, approvals)
 }
@@ -230,20 +230,21 @@ func TestWorkspaceList_WithData(t *testing.T) {
 	broadcaster := newTestBroadcaster()
 	handler := NewWorkspaceHandler(broadcaster, nil, "http://localhost:8080", t.TempDir())

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

 	mock.ExpectQuery("SELECT w.id, w.name").
 		WillReturnRows(rows)
@@ -392,21 +392,21 @@ func TestWorkspaceList(t *testing.T) {
 	broadcaster := newTestBroadcaster()
 	handler := NewWorkspaceHandler(broadcaster, nil, "http://localhost:8080", "/tmp/configs")

-	// 21 cols: `max_concurrent_tasks` added between active_tasks and
-	// last_error_rate (see scanWorkspaceRow + COALESCE(w.max_concurrent_tasks, 1)
-	// in workspace.go). Column order must match that scan exactly.
+	// 23 cols: broadcast_enabled + talk_to_user_enabled added after monthly_spend
+	// (migration 20260514). Column order must match scanWorkspaceRow exactly.
 	columns := []string{
 		"id", "name", "role", "tier", "status", "agent_card", "url",
 		"parent_id", "active_tasks", "max_concurrent_tasks",
 		"last_error_rate", "last_sample_error",
 		"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 		"budget_limit", "monthly_spend",
+		"broadcast_enabled", "talk_to_user_enabled",
 	}
 	rows := sqlmock.NewRows(columns).
 		AddRow("ws-1", "Agent One", "worker", 1, "online", []byte("null"), "http://localhost:8001",
-			nil, 0, 1, 0.0, "", 100, "", "claude-code", "", 10.0, 20.0, false, nil, int64(0)).
+			nil, 0, 1, 0.0, "", 100, "", "claude-code", "", 10.0, 20.0, false, nil, int64(0), false, true).
 		AddRow("ws-2", "Agent Two", "manager", 2, "provisioning", []byte("null"), "",
-			nil, 0, 1, 0.0, "", 0, "", "langgraph", "", 50.0, 60.0, false, nil, int64(0))
+			nil, 0, 1, 0.0, "", 0, "", "langgraph", "", 50.0, 60.0, false, nil, int64(0), false, true)

 	mock.ExpectQuery("SELECT w.id, w.name").
 		WillReturnRows(rows)
@@ -1120,13 +1120,14 @@ func TestWorkspaceGet_CurrentTask(t *testing.T) {
 		"parent_id", "active_tasks", "max_concurrent_tasks", "last_error_rate", "last_sample_error",
 		"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 		"budget_limit", "monthly_spend",
+		"broadcast_enabled", "talk_to_user_enabled",
 	}
 	mock.ExpectQuery("SELECT w.id, w.name").
 		WithArgs("dddddddd-0004-0000-0000-000000000000").
 		WillReturnRows(sqlmock.NewRows(columns).AddRow(
 			"dddddddd-0004-0000-0000-000000000000", "Task Worker", "worker", 1, "online", []byte("null"), "http://localhost:9000",
 			nil, 2, 1, 0.0, "", 300, "Analyzing document", "langgraph", "", 10.0, 20.0, false,
-			nil, int64(0),
+			nil, int64(0), false, true,
 		))

 	w := httptest.NewRecorder()
@@ -248,6 +248,9 @@ func (h *InstructionsHandler) Resolve(c *gin.Context) {
 		b.WriteString(content)
 		b.WriteString("\n\n")
 	}
+	if err := rows.Err(); err != nil {
+		log.Printf("ResolveInstructions rows.Err workspace=%s: %v", workspaceID, err)
+	}

 	c.JSON(http.StatusOK, gin.H{
 		"workspace_id": workspaceID,
@@ -258,6 +261,7 @@ func (h *InstructionsHandler) Resolve(c *gin.Context) {
 func scanInstructions(rows interface {
 	Next() bool
 	Scan(dest ...interface{}) error
+	Err() error
 }) []Instruction {
 	var instructions []Instruction
 	for rows.Next() {
@@ -269,6 +273,9 @@ func scanInstructions(rows interface {
 		}
 		instructions = append(instructions, inst)
 	}
+	if err := rows.Err(); err != nil {
+		log.Printf("scanInstructions rows.Err: %v", err)
+	}
 	if instructions == nil {
 		instructions = []Instruction{}
 	}
@@ -751,9 +751,9 @@ func TestMCPHandler_SendMessageToUser_DBErrorLogsAndStill200s(t *testing.T) {
 	t.Setenv("MOLECULE_MCP_ALLOW_SEND_MESSAGE", "true")
 	h, mock := newMCPHandler(t)

-	mock.ExpectQuery("SELECT name FROM workspaces").
+	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
 		WithArgs("ws-err").
-		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("CEO Ryan PC"))
+		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("CEO Ryan PC", true))

 	// INSERT fails — must NOT abort the tool response.
 	mock.ExpectExec(`INSERT INTO activity_logs.*'a2a_receive'.*'notify'`).
@@ -802,9 +802,9 @@ func TestMCPHandler_SendMessageToUser_ResponseBodyShape(t *testing.T) {

 	const userMessage = "Hi there from the agent"

-	mock.ExpectQuery("SELECT name FROM workspaces").
+	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
 		WithArgs("ws-shape").
-		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("CEO Ryan PC"))
+		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("CEO Ryan PC", true))

 	// Capture the response_body argument and assert its exact shape.
 	mock.ExpectExec(`INSERT INTO activity_logs.*'a2a_receive'.*'notify'`).
@@ -861,9 +861,9 @@ func TestMCPHandler_SendMessageToUser_PersistsToActivityLog(t *testing.T) {
 	// before it does anything else. Returning a name lets the
 	// broadcast payload populate; the test doesn't assert on the
 	// broadcast (no observable WS in this fake), only on the DB.
-	mock.ExpectQuery("SELECT name FROM workspaces").
+	mock.ExpectQuery("SELECT name, talk_to_user_enabled FROM workspaces").
 		WithArgs("ws-msg").
-		WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("CEO Ryan PC"))
+		WillReturnRows(sqlmock.NewRows([]string{"name", "talk_to_user_enabled"}).AddRow("CEO Ryan PC", true))

 	// The persistence INSERT — pin the exact shape so a future
 	// refactor that switches columns or drops `method='notify'`
@@ -287,7 +287,7 @@ func TestRenderCategoryRoutingYAML_StableOrdering(t *testing.T) {
 	if ai <= 0 || zi <= 0 || mi <= 0 {
 		t.Fatalf("could not locate all keys in output: %s", out)
 	}
-	if !(ai < mi && mi < zi) {
+	if ai >= mi || mi >= zi {
 		t.Errorf("keys not sorted: alpha=%d middle=%d zebra=%d, output:\n%s", ai, mi, zi, out)
 	}
 }
@@ -19,15 +19,23 @@ import (

 // allowedRoots are the container paths that the Files API can browse.
 var allowedRoots = map[string]bool{
-	"/configs":   true,
-	"/workspace": true,
-	"/home":      true,
-	"/plugins":   true,
+	"/configs":     true,
+	"/workspace":   true,
+	"/home":        true,
+	"/plugins":     true,
+	"/agent-home":  true, // Phase 1 stub (RFC internal#425); full implementation to follow
 }

 // maxUploadFiles limits the number of files in a single import/replace.
 const maxUploadFiles = 200

+// isAgentHomeStubRequest returns true when the rootPath is /agent-home,
+// which is a Phase 1 stub (RFC internal#425). Canvas designs against the
+// shape; the full implementation will follow in a later phase.
+func isAgentHomeStubRequest(rootPath string) bool {
+	return rootPath == "/agent-home"
+}
+
 type TemplatesHandler struct {
 	configsDir string
 	docker     *client.Client
@@ -218,6 +226,11 @@ func (h *TemplatesHandler) ListFiles(c *gin.Context) {
 	//   ?path=  — subdirectory to list (relative to root, default: "")
 	//   ?depth= — max depth to recurse (default: 1, max: 5)
 	rootPath := c.DefaultQuery("root", "/configs")
+	// Phase 1 stub — RFC internal#425
+	if isAgentHomeStubRequest(rootPath) {
+		c.JSON(http.StatusNotImplemented, gin.H{"error": "/agent-home is not yet implemented"})
+		return
+	}
 	if !allowedRoots[rootPath] {
 		c.JSON(http.StatusBadRequest, gin.H{"error": "root must be one of: /configs, /workspace, /home, /plugins"})
 		return
@@ -382,6 +395,11 @@ func (h *TemplatesHandler) ReadFile(c *gin.Context) {

 	ctx := c.Request.Context()
 	rootPath := c.DefaultQuery("root", "/configs")
+	// Phase 1 stub — RFC internal#425
+	if isAgentHomeStubRequest(rootPath) {
+		c.JSON(http.StatusNotImplemented, gin.H{"error": "/agent-home is not yet implemented"})
+		return
+	}
 	if !allowedRoots[rootPath] {
 		c.JSON(http.StatusBadRequest, gin.H{"error": "root must be one of: /configs, /workspace, /home, /plugins"})
 		return
@@ -495,6 +513,11 @@ func (h *TemplatesHandler) WriteFile(c *gin.Context) {

 	ctx := c.Request.Context()
 	rootPath := c.DefaultQuery("root", "/configs")
+	// Phase 1 stub — RFC internal#425
+	if isAgentHomeStubRequest(rootPath) {
+		c.JSON(http.StatusNotImplemented, gin.H{"error": "/agent-home is not yet implemented"})
+		return
+	}
 	if !allowedRoots[rootPath] {
 		c.JSON(http.StatusBadRequest, gin.H{"error": "root must be one of: /configs, /workspace, /home, /plugins"})
 		return
@@ -572,6 +595,11 @@ func (h *TemplatesHandler) DeleteFile(c *gin.Context) {

 	ctx := c.Request.Context()
 	rootPath := c.DefaultQuery("root", "/configs")
+	// Phase 1 stub — RFC internal#425
+	if isAgentHomeStubRequest(rootPath) {
+		c.JSON(http.StatusNotImplemented, gin.H{"error": "/agent-home is not yet implemented"})
+		return
+	}
 	if !allowedRoots[rootPath] {
 		c.JSON(http.StatusBadRequest, gin.H{"error": "root must be one of: /configs, /workspace, /home, /plugins"})
 		return
@@ -67,6 +67,9 @@ func (h *TokenHandler) List(c *gin.Context) {
 		}
 		tokens = append(tokens, t)
 	}
+	if err := rows.Err(); err != nil {
+		log.Printf("ListTokens rows.Err workspace=%s: %v", workspaceID, err)
+	}

 	c.JSON(http.StatusOK, gin.H{
 		"tokens": tokens,
@@ -595,7 +595,7 @@ func scanWorkspaceRow(rows interface {
 	var id, name, role, status, url, sampleError, currentTask, runtime, workspaceDir string
 	var tier, activeTasks, maxConcurrentTasks, uptimeSeconds int
 	var errorRate, x, y float64
-	var collapsed bool
+	var collapsed, broadcastEnabled, talkToUserEnabled bool
 	var parentID *string
 	var agentCard []byte
 	var budgetLimit sql.NullInt64
@@ -604,7 +604,7 @@ func scanWorkspaceRow(rows interface {
 	err := rows.Scan(&id, &name, &role, &tier, &status, &agentCard, &url,
 		&parentID, &activeTasks, &maxConcurrentTasks, &errorRate, &sampleError, &uptimeSeconds,
 		&currentTask, &runtime, &workspaceDir, &x, &y, &collapsed,
-		&budgetLimit, &monthlySpend)
+		&budgetLimit, &monthlySpend, &broadcastEnabled, &talkToUserEnabled)
 	if err != nil {
 		return nil, err
 	}
@@ -628,6 +628,8 @@ func scanWorkspaceRow(rows interface {
 		"x":                    x,
 		"y":                    y,
 		"collapsed":            collapsed,
+		"broadcast_enabled":    broadcastEnabled,
+		"talk_to_user_enabled": talkToUserEnabled,
 	}

 	// budget_limit: nil when no limit set, int64 otherwise
@@ -663,7 +665,8 @@ const workspaceListQuery = `
 		   COALESCE(w.current_task, ''), COALESCE(w.runtime, 'langgraph'),
 		   COALESCE(w.workspace_dir, ''),
 		   COALESCE(cl.x, 0), COALESCE(cl.y, 0), COALESCE(cl.collapsed, false),
-		   w.budget_limit, COALESCE(w.monthly_spend, 0)
+		   w.budget_limit, COALESCE(w.monthly_spend, 0),
+		   w.broadcast_enabled, w.talk_to_user_enabled
 	FROM workspaces w
 	LEFT JOIN canvas_layouts cl ON cl.workspace_id = w.id
 	WHERE w.status != 'removed'
@@ -723,7 +726,8 @@ func (h *WorkspaceHandler) Get(c *gin.Context) {
 			   COALESCE(w.current_task, ''), COALESCE(w.runtime, 'langgraph'),
 			   COALESCE(w.workspace_dir, ''),
 			   COALESCE(cl.x, 0), COALESCE(cl.y, 0), COALESCE(cl.collapsed, false),
-			   w.budget_limit, COALESCE(w.monthly_spend, 0)
+			   w.budget_limit, COALESCE(w.monthly_spend, 0),
+			   w.broadcast_enabled, w.talk_to_user_enabled
 		FROM workspaces w
 		LEFT JOIN canvas_layouts cl ON cl.workspace_id = w.id
 		WHERE w.id = $1
@@ -0,0 +1,82 @@
+package handlers
+
+// workspace_abilities.go — PATCH /workspaces/:id/abilities
+//
+// Allows users and admin agents to toggle two workspace-level ability flags:
+//
+//   broadcast_enabled   — workspace may POST /broadcast to send org-wide messages
+//   talk_to_user_enabled — workspace may deliver canvas chat messages via
+//                          send_message_to_user / POST /notify
+//
+// Gated behind AdminAuth so workspace agents cannot self-modify their own
+// ability flags (that would let any agent grant itself broadcast rights or
+// suppress its own chat-silence constraint).
+
+import (
+	"log"
+	"net/http"
+
+	"github.com/Molecule-AI/molecule-monorepo/platform/internal/db"
+	"github.com/gin-gonic/gin"
+)
+
+// AbilitiesPayload carries the subset of ability flags the caller wants to
+// update. Fields are pointers so that the handler can distinguish "caller
+// supplied false" from "caller omitted the field" (omitempty semantics).
+type AbilitiesPayload struct {
+	BroadcastEnabled   *bool `json:"broadcast_enabled"`
+	TalkToUserEnabled  *bool `json:"talk_to_user_enabled"`
+}
+
+// PatchAbilities handles PATCH /workspaces/:id/abilities (AdminAuth).
+func PatchAbilities(c *gin.Context) {
+	id := c.Param("id")
+	if err := validateWorkspaceID(id); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid workspace ID"})
+		return
+	}
+
+	var body AbilitiesPayload
+	if err := c.ShouldBindJSON(&body); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request body"})
+		return
+	}
+	if body.BroadcastEnabled == nil && body.TalkToUserEnabled == nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "at least one ability field required"})
+		return
+	}
+
+	ctx := c.Request.Context()
+
+	var exists bool
+	if err := db.DB.QueryRowContext(ctx,
+		`SELECT EXISTS(SELECT 1 FROM workspaces WHERE id = $1 AND status != 'removed')`, id,
+	).Scan(&exists); err != nil || !exists {
+		c.JSON(http.StatusNotFound, gin.H{"error": "workspace not found"})
+		return
+	}
+
+	if body.BroadcastEnabled != nil {
+		if _, err := db.DB.ExecContext(ctx,
+			`UPDATE workspaces SET broadcast_enabled = $2, updated_at = now() WHERE id = $1`,
+			id, *body.BroadcastEnabled,
+		); err != nil {
+			log.Printf("PatchAbilities broadcast_enabled for %s: %v", id, err)
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "update failed"})
+			return
+		}
+	}
+
+	if body.TalkToUserEnabled != nil {
+		if _, err := db.DB.ExecContext(ctx,
+			`UPDATE workspaces SET talk_to_user_enabled = $2, updated_at = now() WHERE id = $1`,
+			id, *body.TalkToUserEnabled,
+		); err != nil {
+			log.Printf("PatchAbilities talk_to_user_enabled for %s: %v", id, err)
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "update failed"})
+			return
+		}
+	}
+
+	c.JSON(http.StatusOK, gin.H{"status": "updated"})
+}
@@ -0,0 +1,142 @@
+package handlers
+
+// workspace_broadcast.go — POST /workspaces/:id/broadcast
+//
+// Allows a workspace with broadcast_enabled=true to send a message to every
+// non-removed agent workspace in the org.  The message is:
+//
+//   • Persisted in each recipient's activity_logs (type='broadcast_receive')
+//     so poll-mode agents pick it up via GET /activity.
+//   • Broadcast via WebSocket BROADCAST_MESSAGE event so canvas panels can
+//     show a real-time banner for each recipient workspace.
+//
+// The sender's own workspace logs a 'broadcast_sent' activity row for
+// traceability.
+//
+// Auth: WorkspaceAuth (the agent triggers this with its own bearer token).
+// The handler re-validates broadcast_enabled inside the DB lookup to prevent
+// TOCTOU — the middleware only proved the token is valid, not the ability.
+
+import (
+	"log"
+	"net/http"
+	"strconv"
+
+	"github.com/Molecule-AI/molecule-monorepo/platform/internal/db"
+	"github.com/Molecule-AI/molecule-monorepo/platform/internal/events"
+	"github.com/gin-gonic/gin"
+)
+
+// BroadcastHandler is constructed once and shared across requests.
+type BroadcastHandler struct {
+	broadcaster *events.Broadcaster
+}
+
+// NewBroadcastHandler creates a BroadcastHandler.
+func NewBroadcastHandler(b *events.Broadcaster) *BroadcastHandler {
+	return &BroadcastHandler{broadcaster: b}
+}
+
+// Broadcast handles POST /workspaces/:id/broadcast.
+func (h *BroadcastHandler) Broadcast(c *gin.Context) {
+	senderID := c.Param("id")
+	if err := validateWorkspaceID(senderID); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid workspace ID"})
+		return
+	}
+
+	var body struct {
+		Message string `json:"message" binding:"required"`
+	}
+	if err := c.ShouldBindJSON(&body); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "message is required"})
+		return
+	}
+
+	ctx := c.Request.Context()
+
+	// Verify sender exists and has broadcast_enabled=true.
+	var senderName string
+	var broadcastEnabled bool
+	err := db.DB.QueryRowContext(ctx,
+		`SELECT name, broadcast_enabled FROM workspaces WHERE id = $1 AND status != 'removed'`,
+		senderID,
+	).Scan(&senderName, &broadcastEnabled)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "workspace not found"})
+		return
+	}
+	if !broadcastEnabled {
+		c.JSON(http.StatusForbidden, gin.H{
+			"error": "broadcast_disabled",
+			"hint":  "This workspace does not have the broadcast ability. Ask a user or admin to enable it via PATCH /workspaces/:id/abilities.",
+		})
+		return
+	}
+
+	// Collect all non-removed agent workspaces (excludes the sender itself).
+	rows, err := db.DB.QueryContext(ctx,
+		`SELECT id FROM workspaces WHERE status != 'removed' AND id != $1`,
+		senderID,
+	)
+	if err != nil {
+		log.Printf("Broadcast: recipient query failed for %s: %v", senderID, err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "internal error"})
+		return
+	}
+	defer rows.Close()
+
+	var recipientIDs []string
+	for rows.Next() {
+		var rid string
+		if rows.Scan(&rid) == nil {
+			recipientIDs = append(recipientIDs, rid)
+		}
+	}
+	if err := rows.Err(); err != nil {
+		log.Printf("Broadcast: recipient rows error for %s: %v", senderID, err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "internal error"})
+		return
+	}
+
+	broadcastPayload := map[string]interface{}{
+		"message":   body.Message,
+		"sender_id": senderID,
+		"sender":    senderName,
+	}
+
+	// Persist broadcast_receive in each recipient's activity log + emit WS event.
+	delivered := 0
+	for _, rid := range recipientIDs {
+		if _, err := db.DB.ExecContext(ctx, `
+			INSERT INTO activity_logs (workspace_id, activity_type, method, source_id, summary, status)
+			VALUES ($1, 'broadcast_receive', 'broadcast', $2, $3, 'ok')
+		`, rid, senderID, "Broadcast from "+senderName+": "+broadcastTruncate(body.Message, 120)); err != nil {
+			log.Printf("Broadcast: activity_logs insert for recipient %s: %v", rid, err)
+			continue
+		}
+		h.broadcaster.BroadcastOnly(rid, "BROADCAST_MESSAGE", broadcastPayload)
+		delivered++
+	}
+
+	// Record the send on the sender's own log.
+	if _, err := db.DB.ExecContext(ctx, `
+		INSERT INTO activity_logs (workspace_id, activity_type, method, summary, status)
+		VALUES ($1, 'broadcast_sent', 'broadcast', $2, 'ok')
+	`, senderID, "Broadcast sent to "+strconv.Itoa(delivered)+" workspace(s)"); err != nil {
+		log.Printf("Broadcast: sender activity_log for %s: %v", senderID, err)
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"status":    "sent",
+		"delivered": delivered,
+	})
+}
+
+func broadcastTruncate(s string, max int) string {
+	runes := []rune(s)
+	if len(runes) <= max {
+		return s
+	}
+	return string(runes[:max]) + "…"
+}
@@ -33,6 +33,7 @@ var wsColumns = []string{
 	"parent_id", "active_tasks", "max_concurrent_tasks", "last_error_rate", "last_sample_error",
 	"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 	"budget_limit", "monthly_spend",
+	"broadcast_enabled", "talk_to_user_enabled",
 }

 // ==================== GET — financial fields stripped from open endpoint ====================
@@ -52,8 +53,10 @@ func TestWorkspaceBudget_Get_NilLimit(t *testing.T) {
 				[]byte(`{}`), "http://localhost:9001",
 				nil, 0, 1, 0.0, "", 0, "", "langgraph", "",
 				0.0, 0.0, false,
-				nil, // budget_limit NULL
-				0))  // monthly_spend 0
+				nil,   // budget_limit NULL
+				0,     // monthly_spend 0
+				false, // broadcast_enabled
+				true)) // talk_to_user_enabled

 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -96,7 +99,8 @@ func TestWorkspaceBudget_Get_WithLimit(t *testing.T) {
 				nil, 0, 1, 0.0, "", 0, "", "langgraph", "",
 				0.0, 0.0, false,
 				int64(500),  // budget_limit = $5.00 in DB
-				int64(123))) // monthly_spend = $1.23 in DB
+				int64(123),  // monthly_spend = $1.23 in DB
+				false, true)) // broadcast_enabled, talk_to_user_enabled

 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -805,6 +805,9 @@ func loadWorkspaceSecrets(ctx context.Context, workspaceID string) (map[string]s
 				envVars[k] = string(decrypted)
 			}
 		}
+		if err := globalRows.Err(); err != nil {
+			log.Printf("Provisioner: global_secrets rows.Err workspace=%s: %v", workspaceID, err)
+		}
 	}
 	wsRows, err := db.DB.QueryContext(ctx,
 		`SELECT key, encrypted_value, encryption_version FROM workspace_secrets WHERE workspace_id = $1`, workspaceID)
@@ -823,6 +826,9 @@ func loadWorkspaceSecrets(ctx context.Context, workspaceID string) (map[string]s
 				envVars[k] = string(decrypted)
 			}
 		}
+		if err := wsRows.Err(); err != nil {
+			log.Printf("Provisioner: workspace_secrets rows.Err workspace=%s: %v", workspaceID, err)
+		}
 	}
 	return envVars, ""
 }
@@ -29,6 +29,7 @@ func TestWorkspaceGet_Success(t *testing.T) {
 		"parent_id", "active_tasks", "max_concurrent_tasks", "last_error_rate", "last_sample_error",
 		"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 		"budget_limit", "monthly_spend",
+		"broadcast_enabled", "talk_to_user_enabled",
 	}
 	mock.ExpectQuery("SELECT w.id, w.name").
 		WithArgs("cccccccc-0001-0000-0000-000000000000").
@@ -36,7 +37,7 @@ func TestWorkspaceGet_Success(t *testing.T) {
 			AddRow("cccccccc-0001-0000-0000-000000000000", "My Agent", "worker", 1, "online", []byte(`{"name":"test"}`),
 				"http://localhost:8001", nil, 2, 1, 0.05, "", 3600, "working", "langgraph",
 				"", 10.0, 20.0, false,
-				nil, 0))
+				nil, 0, false, true))

 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -118,6 +119,7 @@ func TestWorkspaceGet_RemovedReturns410(t *testing.T) {
 		"parent_id", "active_tasks", "max_concurrent_tasks", "last_error_rate", "last_sample_error",
 		"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 		"budget_limit", "monthly_spend",
+		"broadcast_enabled", "talk_to_user_enabled",
 	}
 	mock.ExpectQuery("SELECT w.id, w.name").
 		WithArgs(id).
@@ -125,7 +127,7 @@ func TestWorkspaceGet_RemovedReturns410(t *testing.T) {
 			AddRow(id, "Old Agent", "worker", 1, string(models.StatusRemoved), []byte(`null`),
 				"", nil, 0, 1, 0.0, "", 0, "", "langgraph",
 				"", 0.0, 0.0, false,
-				nil, 0))
+				nil, 0, false, true))
 	mock.ExpectQuery(`SELECT updated_at FROM workspaces`).
 		WithArgs(id).
 		WillReturnRows(sqlmock.NewRows([]string{"updated_at"}).AddRow(removedAt))
@@ -181,6 +183,7 @@ func TestWorkspaceGet_RemovedReturns410WithNullRemovedAtOnTimestampFetchFailure(
 		"parent_id", "active_tasks", "max_concurrent_tasks", "last_error_rate", "last_sample_error",
 		"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 		"budget_limit", "monthly_spend",
+		"broadcast_enabled", "talk_to_user_enabled",
 	}
 	mock.ExpectQuery("SELECT w.id, w.name").
 		WithArgs(id).
@@ -188,7 +191,7 @@ func TestWorkspaceGet_RemovedReturns410WithNullRemovedAtOnTimestampFetchFailure(
 			AddRow(id, "Vanished", "worker", 1, string(models.StatusRemoved), []byte(`null`),
 				"", nil, 0, 1, 0.0, "", 0, "", "langgraph",
 				"", 0.0, 0.0, false,
-				nil, 0))
+				nil, 0, false, true))
 	// Simulate the row vanishing between the two queries.
 	mock.ExpectQuery(`SELECT updated_at FROM workspaces`).
 		WithArgs(id).
@@ -243,6 +246,7 @@ func TestWorkspaceGet_RemovedWithIncludeQueryReturns200(t *testing.T) {
 		"parent_id", "active_tasks", "max_concurrent_tasks", "last_error_rate", "last_sample_error",
 		"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 		"budget_limit", "monthly_spend",
+		"broadcast_enabled", "talk_to_user_enabled",
 	}
 	mock.ExpectQuery("SELECT w.id, w.name").
 		WithArgs(id).
@@ -250,7 +254,7 @@ func TestWorkspaceGet_RemovedWithIncludeQueryReturns200(t *testing.T) {
 			AddRow(id, "Audit Agent", "worker", 1, string(models.StatusRemoved), []byte(`null`),
 				"", nil, 0, 1, 0.0, "", 0, "", "langgraph",
 				"", 0.0, 0.0, false,
-				nil, 0))
+				nil, 0, false, true))
 	// last_outbound_at follow-up query (existing path)
 	mock.ExpectQuery(`SELECT last_outbound_at FROM workspaces`).
 		WithArgs(id).
@@ -676,6 +680,7 @@ func TestWorkspaceList_Empty(t *testing.T) {
 			"parent_id", "active_tasks", "last_error_rate", "last_sample_error",
 			"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 			"budget_limit", "monthly_spend",
+		"broadcast_enabled", "talk_to_user_enabled",
 		}))

 	w := httptest.NewRecorder()
@@ -1379,6 +1384,7 @@ func TestWorkspaceGet_FinancialFieldsStripped(t *testing.T) {
 		"parent_id", "active_tasks", "max_concurrent_tasks", "last_error_rate", "last_sample_error",
 		"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 		"budget_limit", "monthly_spend",
+		"broadcast_enabled", "talk_to_user_enabled",
 	}
 	// Populate with non-zero financial values to confirm they are stripped.
 	mock.ExpectQuery("SELECT w.id, w.name").
@@ -1387,7 +1393,7 @@ func TestWorkspaceGet_FinancialFieldsStripped(t *testing.T) {
 			AddRow("cccccccc-0010-0000-0000-000000000000", "Finance Test", "worker", 1, "online", []byte(`{}`),
 				"http://localhost:9001", nil, 0, 1, 0.0, "", 0, "", "langgraph",
 				"", 0.0, 0.0, false,
-				int64(50000), int64(12500))) // budget_limit=500 USD, spend=125 USD
+				int64(50000), int64(12500), false, true)) // budget_limit=500 USD, spend=125 USD

 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -1435,6 +1441,7 @@ func TestWorkspaceGet_SensitiveFieldsStripped(t *testing.T) {
 		"parent_id", "active_tasks", "max_concurrent_tasks", "last_error_rate", "last_sample_error",
 		"uptime_seconds", "current_task", "runtime", "workspace_dir", "x", "y", "collapsed",
 		"budget_limit", "monthly_spend",
+		"broadcast_enabled", "talk_to_user_enabled",
 	}
 	mock.ExpectQuery("SELECT w.id, w.name").
 		WithArgs("cccccccc-0955-0000-0000-000000000000").
@@ -1447,7 +1454,7 @@ func TestWorkspaceGet_SensitiveFieldsStripped(t *testing.T) {
 				"langgraph",
 				"/home/user/secret-projects/client-work",
 				0.0, 0.0, false,
-				nil, 0))
+				nil, 0, false, true))

 	w := httptest.NewRecorder()
 	c, _ := gin.CreateTestContext(w)
@@ -36,6 +36,15 @@ type Workspace struct {
 	// to activity_logs, agent reads via GET /activity?since_id=). See
 	// migration 045 + RFC #2339.
 	DeliveryMode       string          `json:"delivery_mode" db:"delivery_mode"`
+	// BroadcastEnabled: when true the workspace may call POST /broadcast to
+	// deliver a message to all non-removed agent workspaces in the org.
+	// Default false — only privileged orchestrators should hold this ability.
+	BroadcastEnabled   bool            `json:"broadcast_enabled" db:"broadcast_enabled"`
+	// TalkToUserEnabled: when false the workspace's send_message_to_user calls
+	// and POST /notify requests are rejected with HTTP 403 so the agent is
+	// forced to route updates through a parent workspace. Default true
+	// (preserves existing behaviour for all workspaces).
+	TalkToUserEnabled  bool            `json:"talk_to_user_enabled" db:"talk_to_user_enabled"`
 	// Canvas layout fields (from JOIN)
 	X         float64 `json:"x"`
 	Y         float64 `json:"y"`
@@ -4,12 +4,14 @@ import (
 	"bytes"
 	"context"
 	"database/sql"
+	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"io"
 	"log"
 	"net/http"
 	"os"
+	"path/filepath"
 	"strings"
 	"time"

@@ -156,6 +158,11 @@ type cpProvisionRequest struct {
 	Tier        int               `json:"tier"`
 	PlatformURL string            `json:"platform_url"`
 	Env         map[string]string `json:"env"`
+	// ConfigFiles are template + generated config files to write into the
+	// EC2 instance's /configs directory. OFFSEC-010: collected by
+	// collectCPConfigFiles which rejects symlinks and non-regular files
+	// before including them. Serialised as base64 to avoid JSON escaping.
+	ConfigFiles map[string]string `json:"config_files,omitempty"`
 }

 type cpProvisionResponse struct {
@@ -179,6 +186,16 @@ func (p *CPProvisioner) Start(ctx context.Context, cfg WorkspaceConfig) (string,
 		}
 		env["ADMIN_TOKEN"] = p.adminToken
 	}
+	// Collect template files and generated configs, with OFFSEC-010 guards:
+	// - Rejects symlinks at the template root (prevents bypass via symlink traversal)
+	// - Skips symlinks during WalkDir (prevents /etc/passwd etc. inclusion)
+	// - Validates all paths are relative and non-escaping
+	// - Caps total size at 12 KiB to prevent payload bloat
+	configFiles, err := collectCPConfigFiles(cfg)
+	if err != nil {
+		return "", fmt.Errorf("cp provisioner: collect config files: %w", err)
+	}
+
 	req := cpProvisionRequest{
 		OrgID:       p.orgID,
 		WorkspaceID: cfg.WorkspaceID,
@@ -186,6 +203,7 @@ func (p *CPProvisioner) Start(ctx context.Context, cfg WorkspaceConfig) (string,
 		Tier:        cfg.Tier,
 		PlatformURL: cfg.PlatformURL,
 		Env:         env,
+		ConfigFiles: configFiles,
 	}

 	body, err := json.Marshal(req)
@@ -237,6 +255,94 @@ func (p *CPProvisioner) Start(ctx context.Context, cfg WorkspaceConfig) (string,
 	return result.InstanceID, nil
 }

+const cpConfigFilesMaxBytes = 12 << 10
+
+// isCPTemplateConfigFile restricts which files from a template directory are
+// eligible for transport to the control plane. Only config.yaml (the runtime
+// entrypoint config) and files under prompts/ (system prompts) are needed;
+// shipping arbitrary files (e.g. adapter.py, Dockerfile) is both unnecessary
+// and a potential data-exfiltration surface.
+func isCPTemplateConfigFile(name string) bool {
+	name = filepath.ToSlash(filepath.Clean(name))
+	return name == "config.yaml" || strings.HasPrefix(name, "prompts/")
+}
+
+func collectCPConfigFiles(cfg WorkspaceConfig) (map[string]string, error) {
+	files := make(map[string]string)
+	total := 0
+	addFile := func(name string, data []byte) error {
+		name = filepath.ToSlash(filepath.Clean(name))
+		if name == "." || strings.HasPrefix(name, "../") || strings.HasPrefix(name, "/") || strings.Contains(name, "/../") {
+			return fmt.Errorf("invalid config file path %q", name)
+		}
+		total += len(data)
+		if total > cpConfigFilesMaxBytes {
+			return fmt.Errorf("config files exceed %d bytes", cpConfigFilesMaxBytes)
+		}
+		files[name] = base64.StdEncoding.EncodeToString(data)
+		return nil
+	}
+
+	if cfg.TemplatePath != "" {
+		// Reject symlinks on the root itself — WalkDir follows symlinks,
+		// so a symlink TemplatePath that escapes the intended root directory
+		// would bypass the subsequent path-relativization checks below.
+		rootInfo, err := os.Lstat(cfg.TemplatePath)
+		if err != nil {
+			return nil, fmt.Errorf("collectCPConfigFiles: lstat template path: %w", err)
+		}
+		if rootInfo.Mode()&os.ModeSymlink != 0 {
+			return nil, fmt.Errorf("collectCPConfigFiles: template path must not be a symlink")
+		}
+		err = filepath.WalkDir(cfg.TemplatePath, func(path string, d os.DirEntry, walkErr error) error {
+			if walkErr != nil {
+				return walkErr
+			}
+			// Skip symlinks — WalkDir follows them by default, which means
+			// a symlink inside the template dir pointing to /etc/passwd
+			// would be traversed even though the resulting relative-path
+			// check would correctly reject it. Defense-in-depth: don't
+			// follow symlinks at all. (OFFSEC-010)
+			if d.Type()&os.ModeSymlink != 0 {
+				return nil
+			}
+			if d.IsDir() {
+				return nil
+			}
+			info, err := d.Info()
+			if err != nil {
+				return err
+			}
+			if !info.Mode().IsRegular() {
+				return nil
+			}
+			rel, err := filepath.Rel(cfg.TemplatePath, path)
+			if err != nil {
+				return err
+			}
+			if !isCPTemplateConfigFile(rel) {
+				return nil
+			}
+			data, err := os.ReadFile(path)
+			if err != nil {
+				return err
+			}
+			return addFile(rel, data)
+		})
+		if err != nil {
+			return nil, err
+		}
+	}
+	for name, data := range cfg.ConfigFiles {
+		if err := addFile(name, data); err != nil {
+			return nil, err
+		}
+	}
+	if len(files) == 0 {
+		return nil, nil
+	}
+	return files, nil
+}
 // Stop terminates the workspace's EC2 instance via the control plane.
 //
 // Looks up the actual EC2 instance_id from the workspaces table before
@@ -1,11 +1,15 @@
 package provisioner

 import (
+	"bytes"
 	"context"
+	"encoding/base64"
 	"encoding/json"
 	"io"
 	"net/http"
 	"net/http/httptest"
+	"os"
+	"path/filepath"
 	"strings"
 	"testing"
 	"time"
@@ -279,6 +283,105 @@ func TestStart_TransportFailureSurfaces(t *testing.T) {
 	}
 }

+// TestStart_CollectsConfigFiles — verify that collectCPConfigFiles is called and
+// its result is included in the cpProvisionRequest sent to the control plane.
+// Tests the OFFSEC-010 wiring: the function's symlink guards are only effective
+// if the call site actually invokes it.
+func TestStart_CollectsConfigFiles(t *testing.T) {
+	tmpl := t.TempDir()
+	if err := os.WriteFile(filepath.Join(tmpl, "config.yaml"), []byte("name: test\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	// adapter.py is within the size limit but is NOT config.yaml or prompts/,
+	// so isCPTemplateConfigFile must exclude it from the transport.
+	if err := os.WriteFile(filepath.Join(tmpl, "adapter.py"), bytes.Repeat([]byte("x"), cpConfigFilesMaxBytes), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	var gotBody cpProvisionRequest
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_ = json.NewDecoder(r.Body).Decode(&gotBody)
+		w.WriteHeader(http.StatusCreated)
+		_, _ = io.WriteString(w, `{"instance_id":"i-abc123","state":"pending"}`)
+	}))
+	defer srv.Close()
+
+	p := &CPProvisioner{baseURL: srv.URL, orgID: "org-1", httpClient: srv.Client()}
+	_, err := p.Start(context.Background(), WorkspaceConfig{
+		WorkspaceID:  "ws-1",
+		Runtime:     "python",
+		Tier:         1,
+		PlatformURL:  "http://tenant",
+		TemplatePath: tmpl,
+		ConfigFiles:  map[string][]byte{"generated.json": []byte(`{"key":"value"}`)},
+	})
+	if err != nil {
+		t.Fatalf("Start: %v", err)
+	}
+
+	// config.yaml from TemplatePath must be base64-encoded in ConfigFiles
+	if len(gotBody.ConfigFiles) == 0 {
+		t.Fatal("ConfigFiles is empty: collectCPConfigFiles was not called")
+	}
+
+	// Find config.yaml entry and verify it's valid base64 + correct content
+	var foundTemplate, foundGenerated bool
+	for name, encoded := range gotBody.ConfigFiles {
+		decoded, err := base64.StdEncoding.DecodeString(encoded)
+		if err != nil {
+			t.Errorf("ConfigFiles[%q] is not valid base64: %v", name, err)
+			continue
+		}
+		if name == "config.yaml" && string(decoded) == "name: test\n" {
+			foundTemplate = true
+		}
+		if name == "generated.json" && string(decoded) == `{"key":"value"}` {
+			foundGenerated = true
+		}
+	}
+	if !foundTemplate {
+		t.Errorf("ConfigFiles missing config.yaml from TemplatePath")
+	}
+	if !foundGenerated {
+		t.Errorf("ConfigFiles missing generated.json from ConfigFiles")
+	}
+	// adapter.py must NOT be in ConfigFiles — isCPTemplateConfigFile filters it out
+	for name := range gotBody.ConfigFiles {
+		if name == "adapter.py" {
+			t.Errorf("adapter.py should not be in ConfigFiles — isCPTemplateConfigFile must filter it out")
+		}
+	}
+}
+
+// TestStart_SymlinkTemplatePathError — a symlink TemplatePath should cause
+// collectCPConfigFiles to return an error, which Start must propagate.
+// Without this wiring, OFFSEC-010's root-symlink guard is dead code.
+func TestStart_SymlinkTemplatePathError(t *testing.T) {
+	// Create a temp file and a symlink pointing to it
+	tmp := t.TempDir()
+	realFile := filepath.Join(tmp, "real")
+	if err := os.WriteFile(realFile, []byte("data"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	symlink := filepath.Join(tmp, "template_link")
+	if err := os.Symlink(realFile, symlink); err != nil {
+		t.Fatal(err)
+	}
+
+	p := &CPProvisioner{baseURL: "http://unused", orgID: "org-1", httpClient: &http.Client{Timeout: time.Second}}
+	_, err := p.Start(context.Background(), WorkspaceConfig{
+		WorkspaceID:  "ws-1",
+		Runtime:     "python",
+		TemplatePath: symlink, // symlink root → OFFSEC-010 guard should fire
+	})
+	if err == nil {
+		t.Fatal("expected error for symlink TemplatePath, got nil")
+	}
+	if !strings.Contains(err.Error(), "symlink") {
+		t.Errorf("error should mention symlink, got %q", err.Error())
+	}
+}
+
 // TestStop_SendsBothAuthHeaders — verify #118/#130 compliance on the
 // teardown path. Any call to /cp/workspaces/:id must carry both the
 // platform-wide shared secret AND the per-tenant admin token, or the
@@ -842,3 +945,67 @@ func TestIsRunning_EmptyInstanceIDReturnsFalse(t *testing.T) {
 		t.Errorf("IsRunning with empty instance_id should return running=false, got true")
 	}
 }
+
+// TestCollectCPConfigFiles_SkipsSymlinks — WalkDir follows symlinks by default,
+// but collectCPConfigFiles must skip them so a symlink inside a template dir
+// pointing outside (e.g. ln -s /etc snapshot) cannot be traversed.
+// Verifies OFFSEC-010 defense-in-depth fix. (OFFSEC-010)
+func TestCollectCPConfigFiles_SkipsSymlinks(t *testing.T) {
+	tmpl := t.TempDir()
+	// Write a real file that should be included.
+	if err := os.WriteFile(filepath.Join(tmpl, "config.yaml"), []byte("name: real\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	// Create a subdir with a file that will be symlinked-outside.
+	sensitiveDir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(sensitiveDir, "secret.txt"), []byte("SENSITIVE\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	// Symlink inside template dir pointing to outside path.
+	symlinkPath := filepath.Join(tmpl, "snapshot")
+	if err := os.Symlink(sensitiveDir, symlinkPath); err != nil {
+		t.Fatal(err)
+	}
+
+	files, err := collectCPConfigFiles(WorkspaceConfig{TemplatePath: tmpl})
+	if err != nil {
+		t.Fatalf("collectCPConfigFiles: %v", err)
+	}
+	if files == nil {
+		t.Fatal("files should not be nil")
+	}
+	// config.yaml must be present.
+	if _, ok := files["config.yaml"]; !ok {
+		t.Errorf("config.yaml missing from files")
+	}
+	// The symlinked path must NOT be included (even though WalkDir would
+	// traverse it, the d.Type()&os.ModeSymlink guard skips the entry).
+	for k := range files {
+		if strings.Contains(k, "snapshot") || strings.Contains(k, "secret") {
+			t.Errorf("symlink path %q should not be in files — OFFSEC-010 regression", k)
+		}
+	}
+}
+
+// TestCollectCPConfigFiles_RejectsRootSymlink — if cfg.TemplatePath itself is
+// a symlink, WalkDir would follow it to an arbitrary directory, bypassing the
+// cfg.TemplatePath boundary. The function must reject this case explicitly.
+// (OFFSEC-010)
+func TestCollectCPConfigFiles_RejectsRootSymlink(t *testing.T) {
+	real := t.TempDir()
+	if err := os.WriteFile(filepath.Join(real, "config.yaml"), []byte("name: real\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	link := filepath.Join(t.TempDir(), "template-link")
+	if err := os.Symlink(real, link); err != nil {
+		t.Fatal(err)
+	}
+
+	_, err := collectCPConfigFiles(WorkspaceConfig{TemplatePath: link})
+	if err == nil {
+		t.Error("collectCPConfigFiles with symlink TemplatePath should return error")
+	}
+	if err != nil && !strings.Contains(err.Error(), "symlink") {
+		t.Errorf("expected symlink-related error, got: %v", err)
+	}
+}
@@ -146,6 +146,9 @@ func Setup(hub *ws.Hub, broadcaster *events.Broadcaster, prov *provisioner.Provi
 		wsAdmin.GET("/workspaces", wh.List)
 		wsAdmin.POST("/workspaces", wh.Create)
 		wsAdmin.DELETE("/workspaces/:id", wh.Delete)
+		// Ability toggles — admin-only so workspace agents cannot self-modify
+		// broadcast_enabled or talk_to_user_enabled.
+		wsAdmin.PATCH("/workspaces/:id/abilities", handlers.PatchAbilities)
 		// Out-of-band bootstrap signal: CP's watcher POSTs here when it
 		// detects "RUNTIME CRASHED" in a workspace EC2 console output,
 		// so the canvas flips to failed in seconds instead of waiting
@@ -201,6 +204,12 @@ func Setup(hub *ws.Hub, broadcaster *events.Broadcaster, prov *provisioner.Provi
 		// to 'hibernated'. The workspace auto-wakes on the next A2A message.
 		wsAuth.POST("/hibernate", wh.Hibernate)

+		// Broadcast — send a message to all non-removed workspaces in the org.
+		// Requires broadcast_enabled=true on the source workspace (checked
+		// inside the handler). WorkspaceAuth on wsAuth proves token ownership.
+		broadcastH := handlers.NewBroadcastHandler(broadcaster)
+		wsAuth.POST("/broadcast", broadcastH.Broadcast)
+
 		// External-workspace credential lifecycle (issue #319 follow-up to
 		// the Create flow). Both endpoints reject runtime ≠ external with
 		// 400 — see external_rotate.go for the rationale.
@@ -0,0 +1,226 @@
+// Package secrets provides the canonical SSOT for credential-shaped
+// regex patterns used by:
+//
+//   - the CI `Secret scan` workflow (.gitea/workflows/secret-scan.yml)
+//   - the runtime's bundled pre-commit hook
+//     (molecule-ai-workspace-runtime/molecule_runtime/scripts/pre-commit-checks.sh)
+//   - the upcoming Phase 2b docker-exec Files API backend, which has
+//     to refuse to surface files whose path OR content matches a
+//     credential shape (RFC internal#425, Hongming 2026-05-15)
+//
+// Before this package, the same regex set lived as duplicate bash
+// arrays in two unrelated repos; adding a pattern required editing
+// both, and pattern drift was caught only via secret-scan workflow
+// failures on PRs that had unrelated changes (#2090-class incident
+// vector). Centralising in Go makes the Files API the SSOT, with the
+// YAML + bash arrays generated/asserted from this package so drift
+// is detected at CI time, not at exfiltration time.
+//
+// This file is Phase 2a of the internal#425 RFC. Phase 2b will import
+// `Patterns` from `template_files_docker_exec.go` to gate
+// `listFilesViaDockerExec` / `readFileViaDockerExec` against
+// secret-shaped paths AND content. Until 2b lands, the package has
+// one consumer: this package's own unit tests, which pin the regex
+// strings so a refactor that drops or weakens one is caught here.
+package secrets
+
+import (
+	"fmt"
+	"regexp"
+	"sync"
+)
+
+// Pattern is one named credential shape — a human label plus the
+// compiled regex. The label appears in CI error output ("matched:
+// github-pat") so an operator can identify the family without seeing
+// the actual matched bytes (echoing the bytes widens the blast radius
+// per the secret-scan workflow's recovery prose).
+type Pattern struct {
+	// Name is a short kebab-case identifier (e.g. "github-pat",
+	// "anthropic-api-key"). Stable across versions — consumers may
+	// switch on it.
+	Name string
+	// Description is a one-line human-readable explanation of what
+	// the pattern matches. Used in CI error messages and the Files
+	// API "<denied: secret-shape>" placeholder rationale.
+	Description string
+	// regexSource is the regex literal in Go-RE2 syntax. Stored as a
+	// string so the slice declaration below stays readable; compiled
+	// once via sync.Once into a *regexp.Regexp.
+	regexSource string
+}
+
+// Patterns is the canonical credential-shape regex set.
+//
+// Adding a pattern here:
+//
+//  1. Add a new Pattern{} entry below with a kebab-case Name, a
+//     one-line Description, and the regex literal. Anchor on a
+//     low-false-positive prefix.
+//  2. Add a positive + negative test case in patterns_test.go.
+//  3. Mirror the regex string into:
+//     a. .gitea/workflows/secret-scan.yml SECRET_PATTERNS array
+//     b. molecule-ai-workspace-runtime/molecule_runtime/scripts/pre-commit-checks.sh
+//     (or wait for the codegen target that consumes this slice — TBD
+//     follow-up; tracked in the Phase 2a PR description.)
+//
+// The order is: alphabetical within each provider family, families
+// grouped by ecosystem (GitHub family, AI-provider family, chat
+// family, cloud family). Keep this stable so diffs are reviewable.
+var Patterns = []Pattern{
+	// --- GitHub token family ---
+	{
+		Name:        "github-pat-classic",
+		Description: "GitHub personal access token (classic)",
+		regexSource: `ghp_[A-Za-z0-9]{36,}`,
+	},
+	{
+		Name:        "github-app-installation-token",
+		Description: "GitHub App installation token (#2090 vector)",
+		regexSource: `ghs_[A-Za-z0-9]{36,}`,
+	},
+	{
+		Name:        "github-oauth-user-to-server",
+		Description: "GitHub OAuth user-to-server token",
+		regexSource: `gho_[A-Za-z0-9]{36,}`,
+	},
+	{
+		Name:        "github-oauth-user",
+		Description: "GitHub OAuth user token",
+		regexSource: `ghu_[A-Za-z0-9]{36,}`,
+	},
+	{
+		Name:        "github-oauth-refresh",
+		Description: "GitHub OAuth refresh token",
+		regexSource: `ghr_[A-Za-z0-9]{36,}`,
+	},
+	{
+		Name:        "github-pat-fine-grained",
+		Description: "GitHub fine-grained personal access token",
+		regexSource: `github_pat_[A-Za-z0-9_]{82,}`,
+	},
+
+	// --- AI-provider API key family ---
+	{
+		Name:        "anthropic-api-key",
+		Description: "Anthropic API key",
+		regexSource: `sk-ant-[A-Za-z0-9_-]{40,}`,
+	},
+	{
+		Name:        "openai-project-key",
+		Description: "OpenAI project API key",
+		regexSource: `sk-proj-[A-Za-z0-9_-]{40,}`,
+	},
+	{
+		Name:        "openai-service-account-key",
+		Description: "OpenAI service-account API key",
+		regexSource: `sk-svcacct-[A-Za-z0-9_-]{40,}`,
+	},
+	{
+		Name:        "minimax-api-key",
+		Description: "MiniMax API key (F1088 vector)",
+		regexSource: `sk-cp-[A-Za-z0-9_-]{60,}`,
+	},
+
+	// --- Chat-platform token family ---
+	{
+		Name:        "slack-token",
+		Description: "Slack token (xoxb/xoxa/xoxp/xoxr/xoxs)",
+		regexSource: `xox[baprs]-[A-Za-z0-9-]{20,}`,
+	},
+
+	// --- Cloud-provider credential family ---
+	{
+		Name:        "aws-access-key-id",
+		Description: "AWS access key ID",
+		regexSource: `AKIA[0-9A-Z]{16}`,
+	},
+	{
+		Name:        "aws-sts-temp-access-key-id",
+		Description: "AWS STS temporary access key ID",
+		regexSource: `ASIA[0-9A-Z]{16}`,
+	},
+}
+
+// compiledOnce protects the lazy build of compiledPatterns. We compile
+// lazily so package init is cheap; callers pay only on first match
+// (typically once per workspace-server boot).
+var (
+	compiledOnce     sync.Once
+	compiledPatterns []*compiledPattern
+	compileErr       error
+)
+
+type compiledPattern struct {
+	Name        string
+	Description string
+	Re          *regexp.Regexp
+}
+
+// compileAll compiles every Pattern.regexSource into a *regexp.Regexp.
+// Called once via compiledOnce. Any compile failure here is a build
+// bug (the unit tests assert each regex compiles) — surfacing via
+// returned error so callers don't panic in request handling.
+func compileAll() {
+	out := make([]*compiledPattern, 0, len(Patterns))
+	for _, p := range Patterns {
+		re, err := regexp.Compile(p.regexSource)
+		if err != nil {
+			compileErr = fmt.Errorf("secrets: pattern %q failed to compile: %w", p.Name, err)
+			return
+		}
+		out = append(out, &compiledPattern{Name: p.Name, Description: p.Description, Re: re})
+	}
+	compiledPatterns = out
+}
+
+// ScanBytes returns a non-nil Match if any pattern matches anywhere
+// inside b. Returns (nil, nil) on no match. Returns (nil, err) only
+// if a regex in the package fails to compile — that's a build bug,
+// not a runtime data issue.
+//
+// Match contains the pattern Name + Description so the caller can
+// emit a path-or-content-denial rationale WITHOUT round-tripping the
+// matched bytes (which would defeat the purpose). The matched bytes
+// stay inside this function.
+//
+// The Files API Phase 2b backend will call ScanBytes on:
+//
+//   - the absolute path string (catches a file literally named
+//     `ghs_abc.txt`)
+//   - the file content (catches a credential pasted into a workspace
+//     file by an agent or user — the Files API refuses to surface it
+//     and the canvas renders "<denied: secret-shape>")
+//
+// Ordering: patterns are tried in declaration order. First match
+// wins. This means narrower patterns (e.g. `sk-svcacct-…`) should
+// appear in `Patterns` before broader ones (`sk-…`) — today there's
+// no overlap, so order is descriptive only.
+func ScanBytes(b []byte) (*Match, error) {
+	compiledOnce.Do(compileAll)
+	if compileErr != nil {
+		return nil, compileErr
+	}
+	for _, cp := range compiledPatterns {
+		if cp.Re.Match(b) {
+			return &Match{Name: cp.Name, Description: cp.Description}, nil
+		}
+	}
+	return nil, nil
+}
+
+// ScanString is the string-input convenience wrapper around ScanBytes.
+// Identical semantics — the body never copies, []byte(s) is a
+// zero-copy reinterpret for the regex matcher.
+func ScanString(s string) (*Match, error) {
+	return ScanBytes([]byte(s))
+}
+
+// Match describes which pattern caught a value. Deliberately does
+// NOT include the matched substring — callers must not echo it.
+type Match struct {
+	// Name is the pattern's kebab-case identifier (e.g. "github-pat-classic").
+	Name string
+	// Description is the human-readable line for UI / log surfaces.
+	Description string
+}
@@ -0,0 +1,253 @@
+package secrets
+
+import (
+	"strings"
+	"sync"
+	"testing"
+)
+
+// TestEveryPatternCompiles pins that every Pattern.regexSource is a
+// valid Go-RE2 expression. Without this, a bad regex would silently
+// disable ScanBytes for everything after it (the lazy compile would
+// set compileErr and ScanBytes would return that error every call).
+func TestEveryPatternCompiles(t *testing.T) {
+	for _, p := range Patterns {
+		if p.Name == "" {
+			t.Errorf("pattern with empty Name: regex=%q", p.regexSource)
+		}
+		if p.Description == "" {
+			t.Errorf("pattern %q has empty Description", p.Name)
+		}
+	}
+	// Force compile + check error.
+	if _, err := ScanBytes([]byte("placeholder")); err != nil {
+		t.Fatalf("ScanBytes init failed: %v", err)
+	}
+}
+
+// TestNoDuplicateNames — a duplicate pattern Name would make the
+// "first match wins" semantics surprising to readers and any caller
+// switching on Match.Name (none today but adding the guard is cheap).
+func TestNoDuplicateNames(t *testing.T) {
+	seen := map[string]bool{}
+	for _, p := range Patterns {
+		if seen[p.Name] {
+			t.Errorf("duplicate pattern Name: %q", p.Name)
+		}
+		seen[p.Name] = true
+	}
+}
+
+// TestKnownPatternsAllPresent — pins which specific Name values are
+// expected. A future refactor that renames or removes one without
+// updating consumers (CI workflow, runtime pre-commit hook, Files
+// API Phase 2b backend) would silently widen the leak surface.
+// Failing here forces the rename to be intentional.
+func TestKnownPatternsAllPresent(t *testing.T) {
+	expected := []string{
+		"github-pat-classic",
+		"github-app-installation-token",
+		"github-oauth-user-to-server",
+		"github-oauth-user",
+		"github-oauth-refresh",
+		"github-pat-fine-grained",
+		"anthropic-api-key",
+		"openai-project-key",
+		"openai-service-account-key",
+		"minimax-api-key",
+		"slack-token",
+		"aws-access-key-id",
+		"aws-sts-temp-access-key-id",
+	}
+	got := map[string]bool{}
+	for _, p := range Patterns {
+		got[p.Name] = true
+	}
+	for _, want := range expected {
+		if !got[want] {
+			t.Errorf("expected pattern %q missing from Patterns slice", want)
+		}
+	}
+}
+
+// TestPositiveMatches — for each pattern, supply a representative
+// shape and assert ScanBytes returns a Match with the right Name.
+// These are TEST FIXTURES, not real credentials — each is the
+// pattern's prefix + a long-enough trailing run of placeholder chars.
+// `EXAMPLE` is sprinkled in to make grep-finds in CI logs obviously
+// fake to a human reader (matches saved memory
+// feedback_assert_exact_not_substring: tighten by Name not body).
+func TestPositiveMatches(t *testing.T) {
+	cases := []struct {
+		fixture      string
+		expectedName string
+	}{
+		{"ghp_EXAMPLE111122223333444455556666777788889999", "github-pat-classic"},
+		{"ghs_EXAMPLE111122223333444455556666777788889999", "github-app-installation-token"},
+		{"gho_EXAMPLE111122223333444455556666777788889999", "github-oauth-user-to-server"},
+		{"ghu_EXAMPLE111122223333444455556666777788889999", "github-oauth-user"},
+		{"ghr_EXAMPLE111122223333444455556666777788889999", "github-oauth-refresh"},
+		{"github_pat_EXAMPLE" + strings.Repeat("1", 80), "github-pat-fine-grained"},
+		{"sk-ant-EXAMPLE" + strings.Repeat("1", 40), "anthropic-api-key"},
+		{"sk-proj-EXAMPLE" + strings.Repeat("1", 40), "openai-project-key"},
+		{"sk-svcacct-EXAMPLE" + strings.Repeat("1", 40), "openai-service-account-key"},
+		{"sk-cp-EXAMPLE" + strings.Repeat("1", 60), "minimax-api-key"},
+		{"xoxb-" + strings.Repeat("a", 25), "slack-token"},
+		{"xoxa-" + strings.Repeat("a", 25), "slack-token"},
+		// AWS regex requires [0-9A-Z]{16} — uppercase + digits only.
+		{"AKIA1234567890ABCDEF", "aws-access-key-id"},
+		{"ASIA1234567890ABCDEF", "aws-sts-temp-access-key-id"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.expectedName, func(t *testing.T) {
+			m, err := ScanBytes([]byte(tc.fixture))
+			if err != nil {
+				t.Fatalf("ScanBytes(%q) errored: %v", tc.fixture, err)
+			}
+			if m == nil {
+				t.Fatalf("ScanBytes(%q) returned no match — expected %q", tc.fixture, tc.expectedName)
+			}
+			if m.Name != tc.expectedName {
+				t.Errorf("ScanBytes(%q) matched %q; expected %q", tc.fixture, m.Name, tc.expectedName)
+			}
+		})
+	}
+}
+
+// TestNegativeShapes — strings that look credential-adjacent but
+// shouldn't match (too short, wrong prefix, missing trailing bytes).
+// Failing here means a pattern is too loose, which would generate
+// false-positive denial in Files API and false-positive workflow
+// failures in CI.
+func TestNegativeShapes(t *testing.T) {
+	cases := []string{
+		// Too-short variants — anchored on the length suffix.
+		"ghp_tooshort",
+		"ghs_alsoshort1234",
+		"github_pat_short",
+		"sk-ant-short",
+		"sk-cp-not-enough-bytes-here",
+		// Looks like one of the prefixes but isn't (different letter).
+		"gha_EXAMPLE_thirty_six_or_more_chars_here_xxx",
+		// Slack family — wrong letter after xox.
+		"xoxz-aaaaaaaaaaaaaaaaaaaaaaaaa",
+		// AWS-shaped but wrong length suffix.
+		"AKIATOOSHORT",
+		// Empty / whitespace.
+		"",
+		"   ",
+		// Plain prose mentioning the prefix as part of a longer word.
+		"see also `ghp_HOWTO.md` in the repo",
+	}
+	for _, c := range cases {
+		t.Run(c, func(t *testing.T) {
+			m, err := ScanBytes([]byte(c))
+			if err != nil {
+				t.Fatalf("ScanBytes(%q) errored: %v", c, err)
+			}
+			if m != nil {
+				t.Errorf("ScanBytes(%q) unexpectedly matched %q", c, m.Name)
+			}
+		})
+	}
+}
+
+// TestScanString_NoOp — sanity-check ScanString is the zero-copy
+// wrapper around ScanBytes. Without this, a future refactor that
+// makes ScanString do its own thing (e.g. accidentally normalises
+// case) would diverge silently.
+func TestScanString_NoOp(t *testing.T) {
+	in := "ghp_EXAMPLE111122223333444455556666777788889999"
+	m1, err1 := ScanBytes([]byte(in))
+	if err1 != nil {
+		t.Fatalf("ScanBytes errored: %v", err1)
+	}
+	m2, err2 := ScanString(in)
+	if err2 != nil {
+		t.Fatalf("ScanString errored: %v", err2)
+	}
+	if m1 == nil || m2 == nil {
+		t.Fatalf("expected matches; got bytes=%+v string=%+v", m1, m2)
+	}
+	if m1.Name != m2.Name {
+		t.Errorf("ScanString and ScanBytes returned different Names: %q vs %q", m1.Name, m2.Name)
+	}
+}
+
+// TestMatch_NoRoundtrip — assert the Match struct does NOT include
+// the matched substring as a field. Adding such a field would
+// regress the "matched bytes never leave ScanBytes" invariant that
+// makes this package safe to call from log/UI surfaces. This is a
+// reflection-light contract test — checks the field names statically.
+func TestMatch_NoRoundtrip(t *testing.T) {
+	var m Match
+	// If someone adds a `Matched string` (or similar) field, this
+	// test reads as the canonical place to update + reconsider.
+	_ = m.Name
+	_ = m.Description
+	// The two-field shape is part of the public contract; new fields
+	// require deliberation about whether they leak the secret value.
+}
+
+// TestCompileError verifies that compileAll() sets compileErr and
+// leaves compiledPatterns nil when a Pattern.regexSource is an invalid
+// Go-RE2 expression. The unbalanced-paren pattern is a real compile
+// error that regexp.Compile() rejects.
+//
+// We reset compiledOnce between attempts by re-assigning the package
+// variable directly so each test run starts from a clean slate.
+func TestCompileError(t *testing.T) {
+	// Reset the sync.Once and error state so this test is fully
+	// deterministic regardless of test execution order.
+	compiledOnce = sync.Once{}
+	compiledPatterns = nil
+	compileErr = nil
+
+	// Swap in an invalid pattern for the duration of this test.
+	// The shadow prevents modifying the global Patterns slice.
+	orig := Patterns
+	Patterns = []Pattern{{Name: "bad", Description: "invalid", regexSource: "(unbalanced"}}
+	compileAll()
+	Patterns = orig
+
+	if compileErr == nil {
+		t.Fatal("compileAll() with invalid regex did not set compileErr")
+	}
+	if compiledPatterns != nil {
+		t.Errorf("compiledPatterns should be nil on compile error; got %d entries", len(compiledPatterns))
+	}
+}
+
+// TestScanBytes_CompileErr verifies that ScanBytes returns the
+// compileErr error (not nil, not a Match) when the lazy compilation
+// previously failed. This is the "compile failed" branch of the
+// ScanBytes function, distinct from the "compiled ok, no match" branch
+// (nil, nil) and the "compiled ok, match" branch (Match, nil).
+//
+// compiledOnce and compileErr must already be set from a prior failed
+// compile attempt. We reset compiledOnce and deliberately trigger a
+// compile failure first so this test is self-contained.
+func TestScanBytes_CompileErr(t *testing.T) {
+	// Force a compile failure so compileErr is populated.
+	compiledOnce = sync.Once{}
+	compiledPatterns = nil
+	compileErr = nil
+
+	orig := Patterns
+	Patterns = []Pattern{{Name: "bad2", Description: "bad2", regexSource: "[unclosed"}}
+	compileAll()
+	Patterns = orig
+
+	if compileErr == nil {
+		t.Fatal("precondition failed: compileErr must be set before TestScanBytes_CompileErr")
+	}
+
+	// ScanBytes should propagate compileErr, not return a match.
+	m, err := ScanBytes([]byte("some content"))
+	if err == nil {
+		t.Fatal("ScanBytes returned nil error when compileErr is set")
+	}
+	if m != nil {
+		t.Errorf("ScanBytes should return nil Match on compile error; got %+v", m)
+	}
+}
@@ -0,0 +1,3 @@
+ALTER TABLE workspaces
+    DROP COLUMN IF EXISTS broadcast_enabled,
+    DROP COLUMN IF EXISTS talk_to_user_enabled;
@@ -0,0 +1,16 @@
+-- Workspace abilities: opt-in flags that gate platform-level behaviours.
+--
+-- broadcast_enabled (default FALSE): when TRUE the workspace may call
+--   POST /workspaces/:id/broadcast to send a message to every non-removed
+--   agent workspace in the org. Off by default — only privileged
+--   orchestrator workspaces should hold this ability.
+--
+-- talk_to_user_enabled (default TRUE): when FALSE the workspace is not
+--   allowed to deliver messages to the canvas user via send_message_to_user /
+--   POST /notify. The platform returns HTTP 403 so the agent can forward its
+--   update to a parent workspace instead. Default TRUE preserves existing
+--   behaviour for all current workspaces.
+
+ALTER TABLE workspaces
+    ADD COLUMN IF NOT EXISTS broadcast_enabled    BOOLEAN NOT NULL DEFAULT FALSE,
+    ADD COLUMN IF NOT EXISTS talk_to_user_enabled BOOLEAN NOT NULL DEFAULT TRUE;
@@ -29,6 +29,7 @@ from typing import Callable
 import inbox

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


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


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

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

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

 from a2a_tools import (
+    tool_broadcast_message,
    tool_chat_history,
    tool_check_task_status,
    tool_commit_memory,
@@ -288,6 +289,44 @@ _GET_WORKSPACE_INFO = ToolSpec(
    section=A2A_SECTION,
 )

+_BROADCAST_MESSAGE = ToolSpec(
+    name="broadcast_message",
+    short=(
+        "Send a message to ALL agent workspaces in the org simultaneously. "
+        "Requires broadcast_enabled=true on this workspace (set by user/admin)."
+    ),
+    when_to_use=(
+        "Use for urgent, org-wide signals: critical status changes, emergency "
+        "stop instructions, coordinated task announcements. Every non-removed "
+        "workspace receives the message in its activity log (poll-mode agents "
+        "see it on their next poll; push-mode canvases get a real-time banner). "
+        "This tool returns an error if broadcast_enabled is false — a user or "
+        "admin must enable it via the workspace abilities settings first."
+    ),
+    input_schema={
+        "type": "object",
+        "properties": {
+            "message": {
+                "type": "string",
+                "description": (
+                    "The broadcast text. Keep it concise — every agent in the "
+                    "org receives this in their activity feed."
+                ),
+            },
+            "workspace_id": {
+                "type": "string",
+                "description": (
+                    "Optional. Multi-workspace mode: the registered workspace "
+                    "to broadcast from. Single-workspace agents omit this."
+                ),
+            },
+        },
+        "required": ["message"],
+    },
+    impl=tool_broadcast_message,
+    section=A2A_SECTION,
+)
+
 _SEND_MESSAGE_TO_USER = ToolSpec(
    name="send_message_to_user",
    short=(
@@ -603,6 +642,7 @@ TOOLS: list[ToolSpec] = [
    _CHECK_TASK_STATUS,
    _LIST_PEERS,
    _GET_WORKSPACE_INFO,
+    _BROADCAST_MESSAGE,
    _SEND_MESSAGE_TO_USER,
    # Inbox (standalone-only; in-container returns informational error)
    _WAIT_FOR_MESSAGE,
@@ -5,6 +5,7 @@
 - **check_task_status**: Poll the status of a task started with delegate_task_async; returns result when done.
 - **list_peers**: List the workspaces this agent can communicate with — name, ID, status, role for each.
 - **get_workspace_info**: Get this workspace's own info — ID, name, role, tier, parent, status.
+- **broadcast_message**: Send a message to ALL agent workspaces in the org simultaneously. Requires broadcast_enabled=true on this workspace (set by user/admin).
 - **send_message_to_user**: Send a message directly to the user's canvas chat — pushed instantly via WebSocket. Use this to: (1) acknowledge a task immediately ('Got it, I'll start working on this'), (2) send interim progress updates while doing long work, (3) deliver follow-up results after delegation completes, (4) attach files (zip, pdf, csv, image) for the user to download via the `attachments` field (NEVER paste file URLs in `message`). The message appears in the user's chat as if you're proactively reaching out.
 - **wait_for_message**: Block until the next inbound message (canvas user OR peer agent) arrives, or until ``timeout_secs`` elapses.
 - **inbox_peek**: List pending inbound messages without removing them.
@@ -26,6 +27,9 @@ Call this first when you need to delegate but don't know the target's ID. Access
 ### get_workspace_info
 Use to introspect your own identity (e.g. before reporting back to the user, or to determine whether you're a tier-0 root that can write GLOBAL memory).

+### broadcast_message
+Use for urgent, org-wide signals: critical status changes, emergency stop instructions, coordinated task announcements. Every non-removed workspace receives the message in its activity log (poll-mode agents see it on their next poll; push-mode canvases get a real-time banner). This tool returns an error if broadcast_enabled is false — a user or admin must enable it via the workspace abilities settings first.
+
 ### send_message_to_user
 Use proactively across the lifecycle of a task — early to acknowledge, mid-flight to update, late to deliver. Never paste file URLs in the message body — always pass absolute paths in `attachments` so the platform serves them as download chips (works on SaaS where external file hosts are unreachable).

@@ -1,153 +1,141 @@
-"""Unit tests for OpenClaw adapter env-var key selection and provider URL routing.
+"""Unit tests for resolve_provider_routing in adapter_base.

-The key-selection and URL-routing logic lives inline in OpenClawAdapter.setup()
-(adapter.py lines 84-92).  Since setup() carries heavy subprocess dependencies,
-these tests isolate the selection logic by reproducing the exact Python expressions
-from the adapter source — if the adapter's logic changes, these tests must be kept
-in sync.
-
-Organisation:
-  TestEnvKeyChain          — priority order of the 3 currently supported keys
-  TestProviderUrlMapping   — model-prefix → provider URL dict correctness
-  TestNegativeAndFallback  — no keys set / unsupported keys
-  xfail stubs              — AISTUDIO + QIANFAN documented as not-yet-implemented
+Covers provider routing, URL-override precedence, and the missing-key error path.
+Each adapter defines its own registry; this test file defines one inline that
+mirrors what the openclaw adapter uses.
 """
 from __future__ import annotations

-import os
-from unittest.mock import patch
-
 import pytest

+from adapter_base import ProviderRegistry, resolve_provider_routing

-# ---------------------------------------------------------------------------
-# Helpers — mirror the exact expressions from adapter.py lines 84-92.
-# Must be kept in sync with the adapter source.
-# ---------------------------------------------------------------------------
-
-def _select_key(env: dict) -> str:
-    """Mirror line 84: nested os.environ.get priority chain."""
-    return env.get("OPENAI_API_KEY",
-                   env.get("GROQ_API_KEY",
-                           env.get("OPENROUTER_API_KEY", "")))
-
-
-_PROVIDER_URLS: dict[str, str] = {
-    "openai":     "https://api.openai.com/v1",
-    "groq":       "https://api.groq.com/openai/v1",
-    "openrouter": "https://openrouter.ai/api/v1",
+# Mirror of the registry in openclaw's adapter.py — kept in sync manually.
+PROVIDER_REGISTRY: ProviderRegistry = {
+    "openai":     (("OPENAI_API_KEY",),                     "https://api.openai.com/v1"),
+    "groq":       (("GROQ_API_KEY",),                       "https://api.groq.com/openai/v1"),
+    "openrouter": (("OPENROUTER_API_KEY",),                 "https://openrouter.ai/api/v1"),
+    "qianfan":    (("QIANFAN_API_KEY", "AISTUDIO_API_KEY"), "https://qianfan.baidubce.com/v2"),
+    "minimax":    (("MINIMAX_API_KEY",),                    "https://api.minimaxi.com/v1"),
+    "moonshot":   (("KIMI_API_KEY",),                       "https://api.moonshot.ai/v1"),
 }


-def _select_url(model: str, runtime_config: dict | None = None) -> str:
-    """Mirror lines 86-92: model-prefix → provider URL with optional override."""
-    prefix = model.split(":")[0] if ":" in model else "openai"
-    return (runtime_config or {}).get(
-        "provider_url",
-        _PROVIDER_URLS.get(prefix, "https://api.openai.com/v1"),
-    )
+class TestProviderRouting:
+
+    def test_openai_key_and_url(self):
+        api_key, base_url, model_id = resolve_provider_routing(
+            "openai:gpt-4o", {"OPENAI_API_KEY": "sk-openai"}, registry=PROVIDER_REGISTRY
+        )
+        assert api_key == "sk-openai"
+        assert base_url == "https://api.openai.com/v1"
+        assert model_id == "gpt-4o"
+
+    def test_groq_key_and_url(self):
+        api_key, base_url, model_id = resolve_provider_routing(
+            "groq:llama-3.3-70b", {"GROQ_API_KEY": "sk-groq"}, registry=PROVIDER_REGISTRY
+        )
+        assert api_key == "sk-groq"
+        assert base_url == "https://api.groq.com/openai/v1"
+        assert model_id == "llama-3.3-70b"
+
+    def test_openrouter_key_and_url(self):
+        api_key, base_url, model_id = resolve_provider_routing(
+            "openrouter:anthropic/claude-sonnet-4-5", {"OPENROUTER_API_KEY": "sk-or"}, registry=PROVIDER_REGISTRY
+        )
+        assert api_key == "sk-or"
+        assert base_url == "https://openrouter.ai/api/v1"
+        assert model_id == "anthropic/claude-sonnet-4-5"
+
+    def test_qianfan_primary_key(self):
+        api_key, _, _ = resolve_provider_routing(
+            "qianfan:ernie-4.5", {"QIANFAN_API_KEY": "sk-qf", "AISTUDIO_API_KEY": "sk-ai"}, registry=PROVIDER_REGISTRY
+        )
+        assert api_key == "sk-qf"
+
+    def test_qianfan_fallback_to_aistudio(self):
+        api_key, base_url, _ = resolve_provider_routing(
+            "qianfan:ernie-4.5", {"AISTUDIO_API_KEY": "sk-ai"}, registry=PROVIDER_REGISTRY
+        )
+        assert api_key == "sk-ai"
+        assert base_url == "https://qianfan.baidubce.com/v2"
+
+    def test_minimax_key_and_url(self):
+        api_key, base_url, model_id = resolve_provider_routing(
+            "minimax:MiniMax-M2.7", {"MINIMAX_API_KEY": "sk-mm"}, registry=PROVIDER_REGISTRY
+        )
+        assert api_key == "sk-mm"
+        assert base_url == "https://api.minimaxi.com/v1"
+        assert model_id == "MiniMax-M2.7"
+
+    def test_moonshot_key_and_url(self):
+        api_key, base_url, model_id = resolve_provider_routing(
+            "moonshot:kimi-k2.5", {"KIMI_API_KEY": "sk-kimi"}, registry=PROVIDER_REGISTRY
+        )
+        assert api_key == "sk-kimi"
+        assert base_url == "https://api.moonshot.ai/v1"
+        assert model_id == "kimi-k2.5"
+
+    def test_bare_model_id_defaults_to_openai(self):
+        api_key, base_url, model_id = resolve_provider_routing(
+            "gpt-4o", {"OPENAI_API_KEY": "sk-openai"}, registry=PROVIDER_REGISTRY
+        )
+        assert base_url == "https://api.openai.com/v1"
+        assert model_id == "gpt-4o"
+
+    def test_unknown_prefix_falls_back_to_openai_url(self):
+        api_key, base_url, model_id = resolve_provider_routing(
+            "custom-shim:my-model", {"OPENAI_API_KEY": "sk-openai"}, registry=PROVIDER_REGISTRY
+        )
+        assert base_url == "https://api.openai.com/v1"
+        assert model_id == "my-model"


-# ---------------------------------------------------------------------------
-# 1. Env-var key priority chain (3 keys currently in adapter.py)
-# ---------------------------------------------------------------------------
+class TestUrlOverridePrecedence:

-class TestEnvKeyChain:
+    def test_env_base_url_beats_registry_default(self):
+        _, base_url, _ = resolve_provider_routing(
+            "minimax:MiniMax-M2.7",
+            {"MINIMAX_API_KEY": "sk-mm", "MINIMAX_BASE_URL": "https://api.minimax.chat/v1"},
+            registry=PROVIDER_REGISTRY,
+        )
+        assert base_url == "https://api.minimax.chat/v1"

-    def test_openai_key_selected(self):
-        with patch.dict(os.environ, {"OPENAI_API_KEY": "sk-openai-test"}, clear=True):
-            assert _select_key(os.environ) == "sk-openai-test"
+    def test_runtime_config_provider_url_beats_registry_default(self):
+        _, base_url, _ = resolve_provider_routing(
+            "openai:gpt-4o",
+            {"OPENAI_API_KEY": "sk-openai"},
+            registry=PROVIDER_REGISTRY,
+            runtime_config={"provider_url": "https://proxy.example.com/v1"},
+        )
+        assert base_url == "https://proxy.example.com/v1"

-    def test_groq_key_selected_when_openai_absent(self):
-        with patch.dict(os.environ, {"GROQ_API_KEY": "sk-groq-test"}, clear=True):
-            assert _select_key(os.environ) == "sk-groq-test"
-
-    def test_openrouter_key_selected_when_openai_and_groq_absent(self):
-        with patch.dict(os.environ, {"OPENROUTER_API_KEY": "sk-or-test"}, clear=True):
-            assert _select_key(os.environ) == "sk-or-test"
-
-    def test_openai_beats_groq_when_both_set(self):
-        with patch.dict(os.environ, {"OPENAI_API_KEY": "openai", "GROQ_API_KEY": "groq"}, clear=True):
-            assert _select_key(os.environ) == "openai"
-
-    def test_groq_beats_openrouter_when_openai_absent(self):
-        with patch.dict(os.environ, {"GROQ_API_KEY": "groq", "OPENROUTER_API_KEY": "or"}, clear=True):
-            assert _select_key(os.environ) == "groq"
+    def test_env_base_url_beats_runtime_config(self):
+        _, base_url, _ = resolve_provider_routing(
+            "openai:gpt-4o",
+            {"OPENAI_API_KEY": "sk-openai", "OPENAI_BASE_URL": "https://env-wins.com/v1"},
+            registry=PROVIDER_REGISTRY,
+            runtime_config={"provider_url": "https://config-loses.com/v1"},
+        )
+        assert base_url == "https://env-wins.com/v1"


-# ---------------------------------------------------------------------------
-# 2. Model-prefix → provider URL routing
-# ---------------------------------------------------------------------------
+class TestMissingKey:

-class TestProviderUrlMapping:
+    def test_raises_when_no_key_set(self):
+        with pytest.raises(RuntimeError, match="No API key found for provider 'minimax'"):
+            resolve_provider_routing("minimax:MiniMax-M2.7", {}, registry=PROVIDER_REGISTRY)

-    def test_openai_prefix_routes_to_openai(self):
-        assert _select_url("openai:gpt-4o") == "https://api.openai.com/v1"
-
-    def test_groq_prefix_routes_to_groq(self):
-        assert _select_url("groq:llama3-70b") == "https://api.groq.com/openai/v1"
-
-    def test_openrouter_prefix_routes_to_openrouter(self):
-        assert _select_url("openrouter:meta-llama/llama-3.3-70b") == "https://openrouter.ai/api/v1"
-
-    def test_runtime_config_override_wins_over_prefix(self):
-        url = _select_url("openai:gpt-4o", {"provider_url": "https://custom.example.com/v1"})
-        assert url == "https://custom.example.com/v1"
-
-    def test_unknown_prefix_falls_back_to_openai(self):
-        assert _select_url("some-unknown-model") == "https://api.openai.com/v1"
+    def test_raises_lists_checked_vars_in_message(self):
+        with pytest.raises(RuntimeError, match="MINIMAX_API_KEY"):
+            resolve_provider_routing("minimax:MiniMax-M2.7", {}, registry=PROVIDER_REGISTRY)


-# ---------------------------------------------------------------------------
-# 3. Negative / fallback cases
-# ---------------------------------------------------------------------------
+class TestRegistryCompleteness:
+    """Smoke-check that every provider in the registry has a non-empty entry."""

-class TestNegativeAndFallback:
-
-    def test_no_keys_returns_empty_string(self):
-        with patch.dict(os.environ, {}, clear=True):
-            assert _select_key(os.environ) == ""
-
-    def test_unsupported_aistudio_key_returns_empty(self):
-        """Documents that AISTUDIO_API_KEY is NOT yet in the adapter's key chain."""
-        with patch.dict(os.environ, {"AISTUDIO_API_KEY": "sk-ai"}, clear=True):
-            assert _select_key(os.environ) == ""
-
-    def test_unsupported_qianfan_key_returns_empty(self):
-        """Documents that QIANFAN_API_KEY is NOT yet in the adapter's key chain."""
-        with patch.dict(os.environ, {"QIANFAN_API_KEY": "sk-qf"}, clear=True):
-            assert _select_key(os.environ) == ""
-
-
-# ---------------------------------------------------------------------------
-# 4. AISTUDIO + QIANFAN — xfail stubs (not yet implemented in adapter.py)
-#    These fail now; they should be promoted to passing tests once the adapter
-#    adds AISTUDIO_API_KEY and QIANFAN_API_KEY to its key chain and provider_urls.
-# ---------------------------------------------------------------------------
-
-@pytest.mark.xfail(
-    strict=True,
-    reason=(
-        "AISTUDIO_API_KEY not yet in openclaw adapter env-var chain — "
-        "add to adapter.py line 84 and provider_urls dict with "
-        "URL https://generativelanguage.googleapis.com/v1beta/openai"
-    ),
-)
-def test_aistudio_key_routes_to_aistudio_url():
-    with patch.dict(os.environ, {"AISTUDIO_API_KEY": "sk-ai-test"}, clear=True):
-        assert _select_key(os.environ) == "sk-ai-test"
-    assert _select_url("gemini-2.5-flash") == "https://generativelanguage.googleapis.com/v1beta/openai"
-
-
-@pytest.mark.xfail(
-    strict=True,
-    reason=(
-        "QIANFAN_API_KEY not yet in openclaw adapter env-var chain — "
-        "add to adapter.py line 84 and provider_urls dict with "
-        "URL https://qianfan.baidubce.com/v2"
-    ),
-)
-def test_qianfan_key_routes_to_qianfan_url():
-    with patch.dict(os.environ, {"QIANFAN_API_KEY": "sk-qf-test"}, clear=True):
-        assert _select_key(os.environ) == "sk-qf-test"
-    assert _select_url("ernie-4.5") == "https://qianfan.baidubce.com/v2"
+    @pytest.mark.parametrize("prefix", PROVIDER_REGISTRY)
+    def test_all_providers_have_key_vars_and_url(self, prefix):
+        env_vars, base_url = PROVIDER_REGISTRY[prefix]
+        assert env_vars, f"{prefix}: env_vars is empty"
+        assert base_url.startswith("https://"), f"{prefix}: base_url looks wrong: {base_url}"