chore: sync staging-v6 to main HEAD (PRs #1045 + workspace-server image rebuild)

Merge main into staging-v6, bringing in:
- PR #1041: async DB users race test fix + expandWithEnv rewrite
- PR #1043: staticcheck De Morgan simplification

Conflict resolved:
- org_helpers.go: comment update — kept main version

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

.gitea/scripts/sop-checklist.py

@@ -109,58 +109,57 @@ def normalize_slug(raw: str, numeric_aliases: dict[int, str] | None = None) -> s
 # Optional trailing note after the slug for /sop-ack and required reason
 # for /sop-revoke (RFC#351 open question 4 — reason is captured but not
 # yet validated; future iteration may require a min-length).
-#
-# /sop-n/a <gate> [reason] — declares a gate as not-applicable.
-#   <gate> is a canonical gate name (qa-review, security-review).
-#   The declaring user must be in one of the gate's required_teams.
-#   Most-recent per-user declaration wins (revoke semantics mirror ack).
 _DIRECTIVE_RE = re.compile(
     r"^[ \t]*/(sop-ack|sop-revoke)[ \t]+([A-Za-z0-9_\- ]+?)(?:[ \t]+(.*))?[ \t]*$",
     re.MULTILINE,
 )
-_NA_DIRECTIVE_RE = re.compile(
-    r"^[ \t]*/sop-n/?a[ \t]+([A-Za-z0-9_\-]+)(?:[ \t]+(.*))?[ \t]*$",
-    re.MULTILINE,
-)
 
 
 def parse_directives(
     comment_body: str,
     numeric_aliases: dict[int, str],
-) -> tuple[list[tuple[str, str, str]], list[tuple[str, str, str]]]:
-    """Extract /sop-ack, /sop-revoke, and /sop-n/a directives from a comment body.
+) -> list[tuple[str, str, str]]:
+    """Extract /sop-ack and /sop-revoke directives from a comment body.
 
-    Returns a tuple of two lists:
-      0. list of (kind, canonical_slug, note) for sop-ack/sop-revoke
-      1. list of (kind, gate_name, reason) for sop-n/a
-
-    canonical_slug is the normalized form (or "" if unparseable).
-    note/reason is the trailing free-text (may be "").
+    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 "")
     """
     out: list[tuple[str, str, str]] = []
-    na_out: list[tuple[str, str, str]] = []
     if not comment_body:
-        return out, na_out
+        return out
     for m in _DIRECTIVE_RE.finditer(comment_body):
         kind = m.group(1)
         raw_slug = (m.group(2) or "").strip()
+        # If the raw match included trailing words, the regex non-greedy
+        # captured only the first token; strip again for safety.
+        # We split on whitespace to keep the FIRST word as the slug, and
+        # everything after as the note.
         parts = raw_slug.split()
         if not parts:
             continue
         first = parts[0]
+        # If the slug-capture greedily matched multiple words (e.g.
+        # "comprehensive testing"), preserve normalize behavior: join
+        # the WHOLE first-word-token only; trailing words get appended to
+        # the note. The regex limits group(2) to [A-Za-z0-9_\- ] so we
+        # may have multi-word forms here — normalize handles them.
         if len(parts) > 1:
+            # User wrote "/sop-ack comprehensive testing extra-note"
+            # → treat "comprehensive testing" as the slug source if it
+            # normalizes to a known item; otherwise treat "comprehensive"
+            # as slug and "testing extra-note" as note. We defer the
+            # disambiguation to the caller via the returned canonical
+            # slug. For simplicity: try the WHOLE captured string first.
             canonical = normalize_slug(raw_slug, numeric_aliases)
         else:
             canonical = normalize_slug(first, numeric_aliases)
         note_from_group = (m.group(3) or "").strip()
+        # If we collapsed multi-word slug into kebab and there's a
+        # trailing-text group too, append it.
         out.append((kind, canonical, note_from_group))
-
-    for m in _NA_DIRECTIVE_RE.finditer(comment_body):
-        gate = (m.group(1) or "").strip().lower()
-        reason = (m.group(2) or "").strip()
-        na_out.append(("sop-n/a", gate, reason))
-
-    return out, na_out
+    return out
 
 
 # ---------------------------------------------------------------------------
@@ -231,8 +230,9 @@ def compute_ack_state(
        {
          "comprehensive-testing": {
            "ackers": ["bob"],         # non-author, team-verified
-           "rejected": {
+           "rejected_ackers": {        # debugging info
              "self_ack": ["alice"],
+             "unknown_slug": [],
              "not_in_team": ["eve"],
            }
          },
@@ -249,8 +249,7 @@ def compute_ack_state(
         user = (c.get("user") or {}).get("login", "")
         if not user:
             continue
-        directives, _na_directives = parse_directives(body, numeric_aliases)
-        for kind, slug, _note in directives:
+        for kind, slug, _note in parse_directives(body, numeric_aliases):
             if not slug:
                 unparseable_per_user[user] = unparseable_per_user.get(user, 0) + 1
                 continue
@@ -260,19 +259,25 @@ def compute_ack_state(
     # Filter out self-acks and unknown slugs.
     ackers_per_slug: dict[str, list[str]] = {s: [] for s in items_by_slug}
     rejected_self: dict[str, list[str]] = {s: [] for s in items_by_slug}
+    rejected_unknown: dict[str, list[str]] = {s: [] for s in items_by_slug}
     pending_team_check: dict[str, list[str]] = {s: [] for s in items_by_slug}
 
     for (user, slug), kind in latest_directive.items():
         if kind != "sop-ack":
             continue  # revokes leave the (user,slug) state as "no ack"
         if slug not in items_by_slug:
+            # Slug normalized to something not in our config — store
+            # under a synthetic key for diagnostic surfacing. Don't add
+            # to any item.
             continue
         if user == pr_author:
             rejected_self[slug].append(user)
             continue
         pending_team_check[slug].append(user)
 
-    # Step 3: team membership probe per slug.
+    # Step 3: team membership probe per slug (batched per slug to keep
+    # API call count down — same user may ack multiple items but the
+    # required_teams differ per item, so we MUST probe per (user, item)).
     rejected_not_in_team: dict[str, list[str]] = {s: [] for s in items_by_slug}
     for slug, candidates in pending_team_check.items():
         if not candidates:
@@ -281,6 +286,7 @@ def compute_ack_state(
         approved = team_membership_probe(slug, candidates)  # returns subset
         rejected_not_in_team[slug] = [u for u in candidates if u not in approved]
         ackers_per_slug[slug] = approved
+        # Stash required teams for description rendering.
         items_by_slug[slug]["_required_resolved"] = required
 
     return {
@@ -295,113 +301,6 @@ def compute_ack_state(
     }
 
 
-def compute_na_state(
-    comments: list[dict[str, Any]],
-    pr_author: str,
-    na_gates: dict[str, dict[str, Any]],
-    numeric_aliases: dict[int, str],
-    team_membership_probe: "callable[[str, list[str]], list[str]]",
-    client: "GiteaClient",
-    org: str,
-) -> dict[str, dict[str, Any]]:
-    """Compute per-gate N/A declaration state.
-
-    Returns a dict keyed by gate name:
-       {
-         "qa-review": {
-           "declared":  ["alice"],      # non-author, team-verified, not revoked
-           "rejected": ["eve (not-in-team)", "bob (self-decl)"],
-           "reason":   "pure-infra change — no qa surface",
-         },
-         ...
-       }
-    A gate is N/A-satisfied when at least one declaration from a valid
-    team member exists and has not been revoked by the same user.
-    """
-    if not na_gates:
-        return {}
-
-    # Collapse directives per (commenter, gate) — most recent wins.
-    latest_na: dict[tuple[str, str], str] = {}   # (user, gate) → "sop-n/a"
-    latest_na_reason: dict[tuple[str, str], str] = {}  # (user, gate) → reason
-    for c in comments:
-        body = c.get("body", "") or ""
-        user = (c.get("user") or {}).get("login", "")
-        if not user:
-            continue
-        _directives, na_directives = parse_directives(body, numeric_aliases)
-        for _kind, gate, reason in na_directives:
-            if gate not in na_gates:
-                continue
-            latest_na[(user, gate)] = "sop-n/a"
-            latest_na_reason[(user, gate)] = reason
-
-    # Determine candidate declarers per gate.
-    na_state: dict[str, dict[str, Any]] = {
-        gate: {"declared": [], "rejected": [], "reason": ""}
-        for gate in na_gates
-    }
-    pending_per_gate: dict[str, list[str]] = {gate: [] for gate in na_gates}
-
-    for (user, gate), kind in latest_na.items():
-        if kind != "sop-n/a":
-            continue
-        if user == pr_author:
-            na_state[gate]["rejected"].append(f"{user} (self-decl)")
-            continue
-        pending_per_gate[gate].append(user)
-
-    # Probe team membership per gate using that gate's required_teams.
-    for gate, candidates in pending_per_gate.items():
-        if not candidates:
-            continue
-        required_teams = na_gates[gate].get("required_teams", [])
-        # Resolve team names → ids using the client's resolver.
-        team_ids: list[int] = []
-        for tn in required_teams:
-            tid = client.resolve_team_id(org, tn)
-            if tid is not None:
-                team_ids.append(tid)
-        if not team_ids:
-            na_state[gate]["rejected"].extend(
-                f"{u} (no-team-id)" for u in candidates
-            )
-            continue
-        for u in candidates:
-            in_any_team = False
-            for tid in team_ids:
-                result = client.is_team_member(tid, u)
-                if result is True:
-                    in_any_team = True
-                    break
-                if result is None:
-                    # 403 — token owner not in team. Fail-closed.
-                    print(
-                        f"::warning::na: team-probe for {u} in team-id {tid} "
-                        "returned 403 — treating as not-in-team (fail-closed)",
-                        file=sys.stderr,
-                    )
-            if in_any_team:
-                na_state[gate]["declared"].append(u)
-            else:
-                na_state[gate]["rejected"].append(f"{u} (not-in-team)")
-
-    # Build per-gate reason string from declared users.
-    for gate in na_gates:
-        decl = na_state[gate]["declared"]
-        if decl:
-            reasons: list[str] = []
-            for u in decl:
-                r = latest_na_reason.get((u, gate), "")
-                if r:
-                    reasons.append(f"{u}: {r}")
-                else:
-                    reasons.append(u)
-            na_state[gate]["reason"] = "; ".join(reasons)
-
-    return na_state
-
-
 # ---------------------------------------------------------------------------
 # Gitea API client
 # ---------------------------------------------------------------------------
@@ -799,7 +698,6 @@ def main(argv: list[str] | None = None) -> int:
     numeric_aliases = {
         int(it["numeric_alias"]): it["slug"] for it in items if it.get("numeric_alias")
     }
-    na_gates: dict[str, dict[str, Any]] = cfg.get("n/a_gates") or {}
 
     client = GiteaClient(args.gitea_host, token) if token else None
     if not client:
@@ -819,8 +717,6 @@ def main(argv: list[str] | None = None) -> int:
         print("::error::PR payload missing user.login or head.sha", file=sys.stderr)
         return 1
 
-    target_url = f"https://{args.gitea_host}/{args.owner}/{args.repo}/pulls/{args.pr}"
-
     comments = client.get_issue_comments(args.owner, args.repo, args.pr)
 
     # Build team-membership probe closure that caches results per
@@ -878,47 +774,6 @@ def main(argv: list[str] | None = None) -> int:
     ack_state = compute_ack_state(comments, author, items_by_slug, numeric_aliases, probe)
     body_state = {it["slug"]: section_marker_present(body, it["pr_section_marker"]) for it in items}
 
-    # --- N/A gate state (RFC#324 §N/A follow-up) ---
-    na_state: dict[str, dict[str, Any]] = {}
-    if na_gates:
-        na_state = compute_na_state(
-            comments, author, na_gates, numeric_aliases,
-            probe, client, args.owner,
-        )
-        # Post N/A declarations status (read by review-check.sh).
-        na_satisfied = [g for g, s in na_state.items() if s["declared"]]
-        na_missing   = [g for g, s in na_state.items() if not s["declared"]]
-        if na_satisfied:
-            na_desc = f"N/A: {', '.join(na_satisfied)}"
-            na_post_state = "success"
-        elif na_missing:
-            na_desc = f"awaiting /sop-n/a declaration for: {', '.join(na_missing)}"
-            na_post_state = "pending"
-        else:
-            # Configured but no declarations yet.
-            na_desc = "no /sop-n/a declarations yet"
-            na_post_state = "pending"
-        na_context = "sop-checklist / na-declarations (pull_request)"
-        print(f"::notice::na-declarations status: {na_post_state} — {na_desc}")
-        if not args.dry_run:
-            client.post_status(
-                args.owner, args.repo, head_sha,
-                state=na_post_state, context=na_context,
-                description=na_desc,
-                target_url=target_url,
-            )
-            print(f"::notice::na-declarations status posted: {na_context} → {na_post_state}")
-        # Log per-gate diagnostics.
-        for gate in na_gates:
-            s = na_state.get(gate, {})
-            if s.get("declared"):
-                print(f"::notice::  [PASS] gate={gate} — N/A declared by {','.join(s['declared'])}"
-                      + (f" ({s['reason']})" if s.get("reason") else ""))
-            else:
-                extra = f" — rejected: {', '.join(s.get('rejected', []))}" if s.get("rejected") else ""
-                print(f"::notice::  [WAIT] gate={gate} — no valid N/A declaration yet{extra}")
-
-
     state, description = render_status(items, ack_state, body_state)
     mode = get_tier_mode(pr, cfg)
     if mode == "soft":
@@ -953,6 +808,7 @@ def main(argv: list[str] | None = None) -> int:
             return 0 if state in ("success", "pending") else 1
         return 0
 
+    target_url = f"https://{args.gitea_host}/{args.owner}/{args.repo}/pulls/{args.pr}"
     client.post_status(
         args.owner, args.repo, head_sha,
         state=state, context=args.status_context,

canvas/src/components/MissingKeysModal.tsx

@@ -344,7 +344,7 @@ function ProviderPickerModal({
   // wrapper's bounds instead of the viewport.
   if (typeof document === "undefined") return null;
 
-  const allSaved = entries.every((e) => e.saved);
+  const allSaved = entries.length > 0 && entries.every((e) => e.saved);
   const anySaving = entries.some((e) => e.saving);
   const runtimeLabel = runtime
     .replace(/[-_]/g, " ")
@@ -616,7 +616,7 @@ function AllKeysModal({
   if (!open) return null;
   if (typeof document === "undefined") return null;
 
-  const allSaved = entries.every((e) => e.saved);
+  const allSaved = entries.length > 0 && entries.every((e) => e.saved);
   const anySaving = entries.some((e) => e.saving);
   const runtimeLabel = runtime
     .replace(/[-_]/g, " ")

canvas/src/components/WorkspaceNode.tsx

@@ -13,20 +13,17 @@ import { isExternalLikeRuntime } from "@/lib/externalRuntimes";
 
 /** Descendant count for the "N sub" badge — children are first-class nodes
  *  rendered as full cards inside this one via React Flow's native parentId,
- *  so we don't need to subscribe to the actual child list here.
- *  Selecting `nodes` stably avoids a new selector reference on every store
- *  update (React error #185 / Zustand + React 19 Object.is strictness). */
+ *  so we don't need to subscribe to the actual child list here. */
 function useDescendantCount(nodeId: string): number {
-  const nodes = useCanvasStore((s) => s.nodes);
-  return useMemo(() => countDescendants(nodeId, nodes), [nodeId, nodes]);
+  return useCanvasStore(
+    useCallback((s) => countDescendants(nodeId, s.nodes), [nodeId])
+  );
 }
 
-/** Boolean flag used to drive min-size and NodeResizer dimensions.
- *  Selecting `nodes` stably avoids re-render loops (same issue as
- *  useDescendantCount). */
 function useHasChildren(nodeId: string): boolean {
-  const nodes = useCanvasStore((s) => s.nodes);
-  return useMemo(() => nodes.some((n) => n.data.parentId === nodeId), [nodes, nodeId]);
+  return useCanvasStore(
+    useCallback((s) => s.nodes.some((n) => n.data.parentId === nodeId), [nodeId])
+  );
 }
 
 /** Eject/extract arrow icon — visually distinct from delete ✕ */

canvas/src/components/canvas/DropTargetBadge.tsx

@@ -24,20 +24,16 @@ import {
  */
 export function DropTargetBadge() {
   const dragOverNodeId = useCanvasStore((s) => s.dragOverNodeId);
-  // Select nodes stably first — deriving targetName and childCount inside
-  // the same selector creates a new return value on every store mutation
-  // even when neither has changed (React error #185 / Zustand Object.is).
-  const nodes = useCanvasStore((s) => s.nodes);
-  const targetName = (() => {
-    if (!dragOverNodeId) return null;
-    const n = nodes.find((nn) => nn.id === dragOverNodeId);
+  const targetName = useCanvasStore((s) => {
+    if (!s.dragOverNodeId) return null;
+    const n = s.nodes.find((nn) => nn.id === s.dragOverNodeId);
     return (n?.data as WorkspaceNodeData | undefined)?.name ?? null;
-  })();
-  const childCount = (() =>
-    !dragOverNodeId
+  });
+  const childCount = useCanvasStore((s) =>
+    !s.dragOverNodeId
       ? 0
-      : nodes.filter((n) => n.parentId === dragOverNodeId).length
-  )();
+      : s.nodes.filter((n) => n.parentId === s.dragOverNodeId).length,
+  );
   const { getInternalNode, flowToScreenPosition } = useReactFlow();
   if (!dragOverNodeId || !targetName) return null;
   const internal = getInternalNode(dragOverNodeId);

canvas/src/components/canvas/useCanvasViewport.ts

@@ -1,6 +1,6 @@
 "use client";
 
-import { useCallback, useEffect, useMemo, useRef } from "react";
+import { useCallback, useEffect, useRef } from "react";
 import { useReactFlow } from "@xyflow/react";
 import { useCanvasStore } from "@/store/canvas";
 import { appendClass, removeClass } from "@/store/classNames";
@@ -153,17 +153,10 @@ export function useCanvasViewport() {
   // fit, the user has to manually pan + zoom to find what they just
   // created. Only fires when TRANSITIONING from some-provisioning to
   // zero-provisioning — not on every re-render.
-  //
-  // Selecting `nodes` stably (array reference) avoids the
-  // `.filter().length` anti-pattern which creates a new number on every
-  // store update and breaks the wasProvisioning/hasProvisioning
-  // transition detection (React error #185 / Zustand + React 19).
-  const nodes = useCanvasStore((s) => s.nodes);
-  const provisioningCount = useMemo(
-    () => nodes.filter((n) => n.data.status === "provisioning").length,
-    [nodes],
+  const provisioningCount = useCanvasStore(
+    (s) => s.nodes.filter((n) => n.data.status === "provisioning").length,
   );
-  const nodeCount = nodes.length;
+  const nodeCount = useCanvasStore((s) => s.nodes.length);
 
   useEffect(() => {
     const hasProvisioning = provisioningCount > 0;

canvas/src/components/mobile/MobileChat.tsx

@@ -5,7 +5,7 @@
 // that the desktop ChatTab uses, but with a slimmer surface: no
 // attachments, no A2A topology overlay, no conversation tracing.
 
-import { useEffect, useMemo, useRef, useState } from "react";
+import { useEffect, useRef, useState } from "react";
 
 import { api } from "@/lib/api";
 import { useCanvasStore } from "@/store/canvas";
@@ -49,10 +49,7 @@ export function MobileChat({
   onBack: () => void;
 }) {
   const p = usePalette(dark);
-  // Selecting `nodes` stably avoids the `.find()` anti-pattern that
-  // creates a new return value on every store update (React error #185).
-  const nodes = useCanvasStore((s) => s.nodes);
-  const node = useMemo(() => nodes.find((n) => n.id === agentId), [nodes, agentId]);
+  const node = useCanvasStore((s) => s.nodes.find((n) => n.id === agentId));
   // Bootstrap from the canvas store's per-workspace message buffer so the
   // user sees their prior thread on entry. The store is updated by the
   // socket → ChatTab flows the desktop runs; on mobile we read from the

canvas/src/components/mobile/MobileDetail.tsx

@@ -2,7 +2,7 @@
 
 // 03 · Agent detail — pills + tabbed content (Overview/Activity/Config/Memory).
 
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useState } from "react";
 
 import { api } from "@/lib/api";
 import { useCanvasStore } from "@/store/canvas";
@@ -32,10 +32,7 @@ export function MobileDetail({
   onChat: () => void;
 }) {
   const p = usePalette(dark);
-  // Selecting `nodes` stably avoids the `.find()` anti-pattern that
-  // creates a new return value on every store update (React error #185).
-  const nodes = useCanvasStore((s) => s.nodes);
-  const node = useMemo(() => nodes.find((n) => n.id === agentId), [nodes, agentId]);
+  const node = useCanvasStore((s) => s.nodes.find((n) => n.id === agentId));
   const [tab, setTab] = useState<TabId>("overview");
 
   if (!node) {

workspace-server/internal/handlers/a2a_queue_test.go

@@ -85,54 +85,6 @@ func TestExtractIdempotencyKey_emptyOnMissing(t *testing.T) {
 	}
 }
 
-// ──────────────────────────────────────────────────────────────────────────────
-// extractExpiresInSeconds
-// ──────────────────────────────────────────────────────────────────────────────
-
-func TestExtractExpiresInSeconds_valid(t *testing.T) {
-	cases := []struct {
-		name string
-		body string
-		want int
-	}{
-		{"positive int", `{"params":{"expires_in_seconds":30}}`, 30},
-		{"zero", `{"params":{"expires_in_seconds":0}}`, 0},
-		{"large TTL", `{"params":{"expires_in_seconds":3600}}`, 3600},
-		{"nested message — not affected", `{"params":{"message":{"role":"user"},"expires_in_seconds":60}}`, 60},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			if got := extractExpiresInSeconds([]byte(tc.body)); got != tc.want {
-				t.Errorf("extractExpiresInSeconds = %d, want %d", got, tc.want)
-			}
-		})
-	}
-}
-
-func TestExtractExpiresInSeconds_invalidOrMissing(t *testing.T) {
-	cases := []struct {
-		name string
-		body string
-		want int
-	}{
-		{"negative → 0", `{"params":{"expires_in_seconds":-5}}`, 0},
-		{"missing expires_in_seconds", `{"params":{"message":{"role":"user"}}}`, 0},
-		{"no params at all", `{"method":"message/send"}`, 0},
-		{"malformed JSON", `not json`, 0},
-		{"empty body", ``, 0},
-		{"null value", `{"params":{"expires_in_seconds":null}}`, 0},
-		{"string value", `{"params":{"expires_in_seconds":"30"}}`, 0},
-		{"float value", `{"params":{"expires_in_seconds":30.5}}`, 30},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			if got := extractExpiresInSeconds([]byte(tc.body)); got != tc.want {
-				t.Errorf("extractExpiresInSeconds(%q) = %d, want %d", tc.body, got, tc.want)
-			}
-		})
-	}
-}
-
 func TestExtractDelegationIDFromBody(t *testing.T) {
 	cases := []struct {
 		name string

workspace-server/internal/handlers/org.go

@@ -271,62 +271,6 @@ func (e EnvRequirement) IsSatisfied(configured map[string]struct{}) bool {
 	return false
 }
 
-// perWorkspaceUnsatisfied records a single unsatisfied RequiredEnv for a
-// specific workspace during org import preflight.
-type perWorkspaceUnsatisfied struct {
-	Workspace   string
-	FilesDir    string
-	Unsatisfied EnvRequirement
-}
-
-// collectPerWorkspaceUnsatisfied walks the workspace tree and returns every
-// RequiredEnv that is neither in `configured` (global secrets) nor resolvable
-// from the org root or workspace-level .env file. An empty orgBaseDir skips
-// the .env walk so all requirements appear unsatisfied (used by tests to
-// isolate the global-only path).
-func collectPerWorkspaceUnsatisfied(
-	workspaces []OrgWorkspace,
-	orgBaseDir string,
-	configured map[string]struct{},
-) []perWorkspaceUnsatisfied {
-	var result []perWorkspaceUnsatisfied
-	for _, ws := range workspaces {
-		result = append(result, checkWorkspaceRequiredEnv(ws, orgBaseDir, configured)...)
-	}
-	return result
-}
-
-func checkWorkspaceRequiredEnv(
-	ws OrgWorkspace,
-	orgBaseDir string,
-	configured map[string]struct{},
-) []perWorkspaceUnsatisfied {
-	var result []perWorkspaceUnsatisfied
-	// Merge in .env vars from the org root and the workspace-specific dir.
-	// Workspace-level vars override org-root vars, just as loadWorkspaceEnv
-	// implements: org root first, then ws dir on top.
-	if orgBaseDir != "" {
-		wsEnv := loadWorkspaceEnv(orgBaseDir, ws.FilesDir)
-		for k, v := range wsEnv {
-			configured[k] = struct{}{}
-			_ = v // value only used for merging into configured map
-		}
-	}
-	for _, req := range ws.RequiredEnv {
-		if !req.IsSatisfied(configured) {
-			result = append(result, perWorkspaceUnsatisfied{
-				Workspace:   ws.Name,
-				FilesDir:    ws.FilesDir,
-				Unsatisfied: req,
-			})
-		}
-	}
-	for _, child := range ws.Children {
-		result = append(result, checkWorkspaceRequiredEnv(child, orgBaseDir, configured)...)
-	}
-	return result
-}
-
 // UnmarshalYAML accepts either a scalar (string → single) or a map
 // with an `any_of` list (→ group).
 func (e *EnvRequirement) UnmarshalYAML(value *yaml.Node) error {

workspace-server/internal/handlers/org_helpers.go

@@ -15,6 +15,7 @@ import (
 
 	"gopkg.in/yaml.v3"
 )
+
 // resolvePromptRef reads a prompt body from either an inline string or a
 // file ref relative to the workspace's files_dir. Inline always wins when
 // both are non-empty (caller-provided inline is more authoritative than a
@@ -64,9 +65,7 @@ func resolvePromptRef(inline, fileRef, orgBaseDir, filesDir string) (string, err
 
 // envVarRefPattern matches actual ${VAR} or $VAR references (not literal $).
 // Used to detect unresolved placeholders without false positives like "$5".
-// Requires [a-zA-Z_] as the first char after $ so $100 stays literal.
-// Two capture groups: (1) ${VAR} form, (2) $VAR form.
-var envVarRefPattern = regexp.MustCompile(`\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}|\$([a-zA-Z_][a-zA-Z0-9_]*)`)
+var envVarRefPattern = regexp.MustCompile(`\$\{?[A-Za-z_][A-Za-z0-9_]*\}?`)
 
 // hasUnresolvedVarRef returns true if the original string had a ${VAR} or $VAR
 // reference that the expanded string didn't fully replace (i.e. the var was unset).
@@ -80,23 +79,81 @@ func hasUnresolvedVarRef(original, expanded string) bool {
 }
 
 // expandWithEnv expands ${VAR} and $VAR references in s using the env map.
-// Falls back to the platform process env if a var isn't in the map.
-// Shell variables must start with a letter or '_' per POSIX; invalid identifiers
-// are returned literally so that "$100" and "$5" stay as-is.
+// Falls back to the platform process env only when the whole value is a
+// single variable reference; embedded process-env expansion is too broad for
+// imported org YAML because host variables such as HOME are not template data.
 func expandWithEnv(s string, env map[string]string) string {
-	return os.Expand(s, func(key string) string {
-		if len(key) == 0 {
-			return "$"
+	if s == "" {
+		return ""
+	}
+	var b strings.Builder
+	for i := 0; i < len(s); {
+		if s[i] != '$' {
+			b.WriteByte(s[i])
+			i++
+			continue
 		}
-		c := key[0]
-		if !((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_') {
-			return "$" + key // not a valid shell identifier — return literal
+
+		if i+1 >= len(s) {
+			b.WriteByte('$')
+			i++
+			continue
 		}
-		if v, ok := env[key]; ok {
-			return v
+
+		if s[i+1] == '{' {
+			end := strings.IndexByte(s[i+2:], '}')
+			if end < 0 {
+				b.WriteByte('$')
+				i++
+				continue
+			}
+			end += i + 2
+			key := s[i+2 : end]
+			ref := s[i : end+1]
+			b.WriteString(expandEnvRef(key, ref, s, env))
+			i = end + 1
+			continue
 		}
+
+		if !isEnvIdentStart(s[i+1]) {
+			b.WriteByte('$')
+			i++
+			continue
+		}
+		j := i + 2
+		for j < len(s) && isEnvIdentPart(s[j]) {
+			j++
+		}
+		key := s[i+1 : j]
+		ref := s[i:j]
+		b.WriteString(expandEnvRef(key, ref, s, env))
+		i = j
+	}
+	return b.String()
+}
+
+func expandEnvRef(key, ref, whole string, env map[string]string) string {
+	if key == "" {
+		return "$"
+	}
+	if !isEnvIdentStart(key[0]) {
+		return "$" + key
+	}
+	if v, ok := env[key]; ok {
+		return v
+	}
+	if ref == whole {
 		return os.Getenv(key)
-	})
+	}
+	return ref
+}
+
+func isEnvIdentStart(c byte) bool {
+	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_'
+}
+
+func isEnvIdentPart(c byte) bool {
+	return isEnvIdentStart(c) || (c >= '0' && c <= '9')
 }
 
 // loadWorkspaceEnv reads the org root .env and the workspace-specific .env
@@ -351,11 +408,7 @@ func resolveInsideRoot(root, userPath string) (string, error) {
 		return "", fmt.Errorf("root abs: %w", err)
 	}
 	joined := filepath.Join(absRoot, userPath)
-	// filepath.Join preserves "." components when root is absolute; clean
-	// them before computing the final absolute path so "./subdir/./file.txt"
-	// resolves to root/subdir/file.txt (not root/./subdir/./file.txt).
-	cleaned := filepath.Clean(joined)
-	absJoined, err := filepath.Abs(cleaned)
+	absJoined, err := filepath.Abs(joined)
 	if err != nil {
 		return "", fmt.Errorf("joined abs: %w", err)
 	}

workspace-server/internal/handlers/org_import.go

@@ -952,6 +952,54 @@ type PerWorkspaceUnsatisfied struct {
 
 // collectPerWorkspaceUnsatisfied recursively walks workspaces and returns
 // per-workspace RequiredEnv entries that are not covered by (a) a global
+// secret key or (b) a key present in the workspace's .env file(s) (org root
+// .env + per-workspace <files_dir>/.env). This complements
+// collectOrgEnv + loadConfiguredGlobalSecretKeys, which together only
+// validate global-level RequiredEnv against global_secrets. The .env
+// lookup mirrors the runtime resolution in createWorkspaceTree so that
+// the preflight result matches what the container actually receives at
+// start time.
+func collectPerWorkspaceUnsatisfied(workspaces []OrgWorkspace, orgBaseDir string, globalSecrets map[string]struct{}) []PerWorkspaceUnsatisfied {
+	var out []PerWorkspaceUnsatisfied
+	var walk func([]OrgWorkspace)
+	walk = func(wsList []OrgWorkspace) {
+		for _, ws := range wsList {
+			// Build the set of keys available to this workspace from .env.
+			// This is the same three-source stack that createWorkspaceTree
+			// injects into the container:
+			//   1. Org root .env (parseEnvFile, no filesDir)
+			//   2. Workspace <files_dir>/.env (if filesDir is set)
+			//   3. Persona bootstrap env (MOLECULE_PERSONA_ROOT/<filesDir>/env)
+			// Items 1+2 are on-disk and testable; item 3 is host-only and
+			// skipped here (persona env does NOT satisfy required_env —
+			// it carries identity tokens, not workspace LLM keys).
+			envFromFiles := loadWorkspaceEnv(orgBaseDir, ws.FilesDir)
+			// Convert map[string]string (from .env files) to map[string]struct{}
+			// to match IsSatisfied's signature.
+			envSet := make(map[string]struct{}, len(envFromFiles))
+			for k := range envFromFiles {
+				envSet[k] = struct{}{}
+			}
+			for _, req := range ws.RequiredEnv {
+				if req.IsSatisfied(globalSecrets) {
+					continue // covered by a global secret
+				}
+				if req.IsSatisfied(envSet) {
+					continue // covered by a per-workspace .env file
+				}
+				out = append(out, PerWorkspaceUnsatisfied{
+					Workspace:   ws.Name,
+					FilesDir:    ws.FilesDir,
+					Unsatisfied: req,
+				})
+			}
+			walk(ws.Children)
+		}
+	}
+	walk(workspaces)
+	return out
+}
+
 func loadConfiguredGlobalSecretKeys(ctx context.Context) (map[string]struct{}, error) {
 	rows, err := db.DB.QueryContext(ctx,
 		`SELECT key FROM global_secrets WHERE octet_length(encrypted_value) > 0 LIMIT $1`,

workspace-server/internal/handlers/org_plugin_allowlist.go

@@ -17,9 +17,6 @@ import (
 // when one exists, or the workspace's own ID when it is the org root.
 // Returns an empty string if the workspace is not found.
 func resolveOrgID(ctx context.Context, workspaceID string) (string, error) {
-	if db.DB == nil {
-		return "", nil // nil in unit tests
-	}
 	var parentID sql.NullString
 	err := db.DB.QueryRowContext(ctx,
 		`SELECT parent_id FROM workspaces WHERE id = $1`,

workspace-server/internal/handlers/plugins_atomic_test.go

@@ -215,9 +215,6 @@ func TestTarWalk_EmptyDirectory(t *testing.T) {
 	}
 }
 
-// TestTarWalk_NestedDirs is defined in plugins_atomic_tar_test.go to avoid
-// redeclaration. Deeply nested directory walk is tested there.
-
 // TestTarWalk_DirEntryHasTrailingSlash: directory entries must end with '/'
 // per tar format; tar.Header.Typeflag '5' (dir) must produce "name/" not "name".
 func TestTarWalk_DirEntryHasTrailingSlash(t *testing.T) {

workspace-server/internal/handlers/plugins_tracking.go

@@ -86,9 +86,6 @@ func recordWorkspacePluginInstall(
 // pair. Called by the uninstall path so the row doesn't persist with a stale
 // installed_sha after the plugin has been removed from the container.
 func deleteWorkspacePluginRow(ctx context.Context, workspaceID, pluginName string) error {
-	if db.DB == nil {
-		return nil // nil in unit tests; no-op since the row is test-only
-	}
 	_, err := db.DB.ExecContext(ctx, `
 		DELETE FROM workspace_plugins WHERE workspace_id = $1 AND plugin_name = $2
 	`, workspaceID, pluginName)

workspace-server/internal/handlers/schedules_handler_test.go

@@ -6,11 +6,12 @@ import (
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
+	"regexp"
 	"strings"
 	"testing"
 	"time"
 
-	"github.com/DATA-DOG/go-sqlmock"
+	sqlmock "github.com/DATA-DOG/go-sqlmock"
 	"github.com/gin-gonic/gin"
 )
 
@@ -170,18 +171,29 @@ func TestScheduleHandler_Create_InvalidCron(t *testing.T) {
 }
 
 func TestScheduleHandler_Create_CRLFStripped(t *testing.T) {
-	// Use setupTestDBForQueueTests which sets up QueryMatcherEqual for exact
-	// string matching. The INSERT statement is deterministic enough for that.
-	customSqlmock := setupTestDBForQueueTests(t)
-
+	mock := setupTestDB(t)
 	handler := NewScheduleHandler()
 
 	// Prompt with CRLF from a Windows-committed org-template file.
 	// The handler strips \r before inserting so agent doesn't see empty responses.
 	promptWithCRLF := "check\r\ndocs\r\nbefore merge"
 
-	// The handler strips \r → query should receive the LF-only version.
-	customSqlmock.ExpectQuery("INSERT INTO workspace_schedules (workspace_id, name, cron_expr, timezone, prompt, enabled, next_run_at, source) VALUES ($1, $2, $3, $4, $5, $6, $7, 'runtime') RETURNING id").
+	// Use a custom matcher that captures the prompt argument so we can assert
+	// it has no \r characters.
+	matcher := sqlmock.NewArgMatcher(func(a interface{}) bool {
+		if s, ok := a.(string); ok {
+			// This will be called for multiple args; capture the prompt (5th arg).
+			return strings.Contains(s, "check\ndocs\nbefore merge")
+		}
+		return true
+	})
+	customMock, _, _ := sqlmock.New(sqlmock.QueryMatcherOption(matcher))
+	t.Cleanup(func() { customMock.Close() })
+	prevDB := db.DB
+	db.DB = customMock
+	t.Cleanup(func() { db.DB = prevDB })
+
+	customMock.ExpectQuery("INSERT INTO workspace_schedules").
 		WithArgs("ws-crlf", "", "0 9 * * *", "UTC", "check\ndocs\nbefore merge", true, sqlmock.AnyArg()).
 		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow("sched-crlf"))
 
@@ -201,9 +213,6 @@ func TestScheduleHandler_Create_CRLFStripped(t *testing.T) {
 	if w.Code != http.StatusCreated {
 		t.Errorf("expected 201, got %d: %s", w.Code, w.Body.String())
 	}
-	if err := customSqlmock.ExpectationsWereMet(); err != nil {
-		t.Errorf("sqlmock expectations not met: %v", err)
-	}
 }
 
 func TestScheduleHandler_Create_DefaultEnabled(t *testing.T) {
@@ -367,16 +376,16 @@ func TestScheduleHandler_Create_NextRunAtReturned(t *testing.T) {
 // ==================== Update ====================
 
 func TestScheduleHandler_Update_PartialRecomputeCron(t *testing.T) {
-	// Uses QueryMatcherEqual so query strings are compared verbatim — no escaping needed.
-	mock := setupTestDBForQueueTests(t)
+	mock := setupTestDB(t)
 	handler := NewScheduleHandler()
 
-	mock.ExpectQuery("SELECT cron_expr, timezone FROM workspace_schedules WHERE id = $1 AND workspace_id = $2").
+	// Changing cron_expr → handler SELECTs current cron+tz, recomputes next_run_at.
+	mock.ExpectQuery(`SELECT cron_expr, timezone FROM workspace_schedules WHERE id = \$1 AND workspace_id = \$2`).
 		WithArgs("sched-recompute-cron", "ws-1").
 		WillReturnRows(sqlmock.NewRows([]string{"cron_expr", "timezone"}).
 			AddRow("0 8 * * *", "UTC"))
 
-	mock.ExpectExec(`UPDATE workspace_schedules SET name = COALESCE($2, name), cron_expr = COALESCE($3, cron_expr), timezone = COALESCE($4, timezone), prompt = COALESCE($5, prompt), enabled = COALESCE($6, enabled), next_run_at = COALESCE($7, next_run_at), updated_at = now() WHERE id = $1 AND workspace_id = $8`).
+	mock.ExpectExec(regexp.MustCompile(`UPDATE workspace_schedules SET[\s\S]+WHERE id = \$1 AND workspace_id = \$8`)).
 		WithArgs("sched-recompute-cron", nil, "0 6 * * *", nil, nil, nil, sqlmock.AnyArg(), "ws-1").
 		WillReturnResult(sqlmock.NewResult(0, 1))
 
@@ -399,15 +408,15 @@ func TestScheduleHandler_Update_PartialRecomputeCron(t *testing.T) {
 }
 
 func TestScheduleHandler_Update_PartialRecomputeTimezone(t *testing.T) {
-	mock := setupTestDBForQueueTests(t)
+	mock := setupTestDB(t)
 	handler := NewScheduleHandler()
 
-	mock.ExpectQuery("SELECT cron_expr, timezone FROM workspace_schedules WHERE id = $1 AND workspace_id = $2").
+	mock.ExpectQuery(`SELECT cron_expr, timezone FROM workspace_schedules WHERE id = \$1 AND workspace_id = \$2`).
 		WithArgs("sched-recompute-tz", "ws-1").
 		WillReturnRows(sqlmock.NewRows([]string{"cron_expr", "timezone"}).
 			AddRow("0 9 * * *", "UTC"))
 
-	mock.ExpectExec(`UPDATE workspace_schedules SET name = COALESCE($2, name), cron_expr = COALESCE($3, cron_expr), timezone = COALESCE($4, timezone), prompt = COALESCE($5, prompt), enabled = COALESCE($6, enabled), next_run_at = COALESCE($7, next_run_at), updated_at = now() WHERE id = $1 AND workspace_id = $8`).
+	mock.ExpectExec(regexp.MustCompile(`UPDATE workspace_schedules SET[\s\S]+WHERE id = \$1 AND workspace_id = \$8`)).
 		WithArgs("sched-recompute-tz", nil, nil, "America/New_York", nil, nil, sqlmock.AnyArg(), "ws-1").
 		WillReturnResult(sqlmock.NewResult(0, 1))
 
@@ -430,10 +439,10 @@ func TestScheduleHandler_Update_PartialRecomputeTimezone(t *testing.T) {
 }
 
 func TestScheduleHandler_Update_InvalidTimezone(t *testing.T) {
-	mock := setupTestDBForQueueTests(t)
+	mock := setupTestDB(t)
 	handler := NewScheduleHandler()
 
-	mock.ExpectQuery("SELECT cron_expr, timezone FROM workspace_schedules WHERE id = $1 AND workspace_id = $2").
+	mock.ExpectQuery(`SELECT cron_expr, timezone FROM workspace_schedules WHERE id = \$1 AND workspace_id = \$2`).
 		WithArgs("sched-bad-tz", "ws-1").
 		WillReturnRows(sqlmock.NewRows([]string{"cron_expr", "timezone"}).
 			AddRow("0 9 * * *", "UTC"))
@@ -462,10 +471,10 @@ func TestScheduleHandler_Update_InvalidTimezone(t *testing.T) {
 }
 
 func TestScheduleHandler_Update_InvalidCron(t *testing.T) {
-	mock := setupTestDBForQueueTests(t)
+	mock := setupTestDB(t)
 	handler := NewScheduleHandler()
 
-	mock.ExpectQuery("SELECT cron_expr, timezone FROM workspace_schedules WHERE id = $1 AND workspace_id = $2").
+	mock.ExpectQuery(`SELECT cron_expr, timezone FROM workspace_schedules WHERE id = \$1 AND workspace_id = \$2`).
 		WithArgs("sched-bad-cron", "ws-1").
 		WillReturnRows(sqlmock.NewRows([]string{"cron_expr", "timezone"}).
 			AddRow("0 9 * * *", "UTC"))
@@ -489,11 +498,11 @@ func TestScheduleHandler_Update_InvalidCron(t *testing.T) {
 }
 
 func TestScheduleHandler_Update_NotFound(t *testing.T) {
-	mock := setupTestDBForQueueTests(t)
+	mock := setupTestDB(t)
 	handler := NewScheduleHandler()
 
-	mock.ExpectExec(`UPDATE workspace_schedules SET name = COALESCE($2, name), cron_expr = COALESCE($3, cron_expr), timezone = COALESCE($4, timezone), prompt = COALESCE($5, prompt), enabled = COALESCE($6, enabled), next_run_at = COALESCE($7, next_run_at), updated_at = now() WHERE id = $1 AND workspace_id = $8`).
-		WithArgs("sched-missing", "renamed", nil, nil, nil, nil, nil, "ws-1").
+	mock.ExpectExec(regexp.MustCompile(`UPDATE workspace_schedules SET[\s\S]+WHERE id = \$1 AND workspace_id = \$8`)).
+		WithArgs("sched-missing", nil, nil, nil, nil, nil, nil, "ws-1").
 		WillReturnResult(sqlmock.NewResult(0, 0)) // no rows affected
 
 	body, _ := json.Marshal(map[string]string{"name": "renamed"})
@@ -515,11 +524,11 @@ func TestScheduleHandler_Update_NotFound(t *testing.T) {
 }
 
 func TestScheduleHandler_Update_DBError(t *testing.T) {
-	mock := setupTestDBForQueueTests(t)
+	mock := setupTestDB(t)
 	handler := NewScheduleHandler()
 
-	mock.ExpectExec(`UPDATE workspace_schedules SET name = COALESCE($2, name), cron_expr = COALESCE($3, cron_expr), timezone = COALESCE($4, timezone), prompt = COALESCE($5, prompt), enabled = COALESCE($6, enabled), next_run_at = COALESCE($7, next_run_at), updated_at = now() WHERE id = $1 AND workspace_id = $8`).
-		WithArgs("sched-update-err", "updated", nil, nil, nil, nil, nil, "ws-1").
+	mock.ExpectExec(regexp.MustCompile(`UPDATE workspace_schedules SET[\s\S]+WHERE id = \$1 AND workspace_id = \$8`)).
+		WithArgs("sched-update-err", nil, nil, nil, nil, nil, nil, "ws-1").
 		WillReturnError(sql.ErrConnDone)
 
 	body, _ := json.Marshal(map[string]string{"name": "updated"})
@@ -541,12 +550,12 @@ func TestScheduleHandler_Update_DBError(t *testing.T) {
 }
 
 func TestScheduleHandler_Update_PromptCRLFStripped(t *testing.T) {
-	mock := setupTestDBForQueueTests(t)
+	mock := setupTestDB(t)
 	handler := NewScheduleHandler()
 
 	// Changing prompt with CRLF → handler strips \r before the UPDATE.
-	mock.ExpectExec(`UPDATE workspace_schedules SET name = COALESCE($2, name), cron_expr = COALESCE($3, cron_expr), timezone = COALESCE($4, timezone), prompt = COALESCE($5, prompt), enabled = COALESCE($6, enabled), next_run_at = COALESCE($7, next_run_at), updated_at = now() WHERE id = $1 AND workspace_id = $8`).
-		WithArgs("sched-crlf-upd", nil, nil, nil, "fix\nthat", nil, nil, "ws-1").
+	mock.ExpectExec(regexp.MustCompile(`UPDATE workspace_schedules SET[\s\S]+WHERE id = \$1 AND workspace_id = \$8`)).
+		WithArgs("sched-crlf-upd", nil, nil, nil, "fix\r\nthat", nil, nil, "ws-1").
 		WillReturnResult(sqlmock.NewResult(0, 1))
 
 	body, _ := json.Marshal(map[string]string{"prompt": "fix\r\nthat"})
@@ -570,10 +579,10 @@ func TestScheduleHandler_Update_PromptCRLFStripped(t *testing.T) {
 // ==================== Delete ====================
 
 func TestScheduleHandler_Delete_Success(t *testing.T) {
-	mock := setupTestDBForQueueTests(t)
+	mock := setupTestDB(t)
 	handler := NewScheduleHandler()
 
-	mock.ExpectExec(`DELETE FROM workspace_schedules WHERE id = $1 AND workspace_id = $2`).
+	mock.ExpectExec(regexp.MustCompile(`DELETE FROM workspace_schedules WHERE id = \$1 AND workspace_id = \$2`)).
 		WithArgs("sched-del", "ws-1").
 		WillReturnResult(sqlmock.NewResult(0, 1))
 
@@ -593,11 +602,11 @@ func TestScheduleHandler_Delete_Success(t *testing.T) {
 }
 
 func TestScheduleHandler_Delete_NotFound(t *testing.T) {
-	mock := setupTestDBForQueueTests(t)
+	mock := setupTestDB(t)
 	handler := NewScheduleHandler()
 
 	// IDOR guard: row belongs to different workspace → 0 rows affected → 404.
-	mock.ExpectExec(`DELETE FROM workspace_schedules WHERE id = $1 AND workspace_id = $2`).
+	mock.ExpectExec(regexp.MustCompile(`DELETE FROM workspace_schedules WHERE id = \$1 AND workspace_id = \$2`)).
 		WithArgs("sched-idor", "ws-1").
 		WillReturnResult(sqlmock.NewResult(0, 0))
 
@@ -617,10 +626,10 @@ func TestScheduleHandler_Delete_NotFound(t *testing.T) {
 }
 
 func TestScheduleHandler_Delete_DBError(t *testing.T) {
-	mock := setupTestDBForQueueTests(t)
+	mock := setupTestDB(t)
 	handler := NewScheduleHandler()
 
-	mock.ExpectExec(`DELETE FROM workspace_schedules WHERE id = $1 AND workspace_id = $2`).
+	mock.ExpectExec(regexp.MustCompile(`DELETE FROM workspace_schedules WHERE id = \$1 AND workspace_id = \$2`)).
 		WithArgs("sched-del-err", "ws-1").
 		WillReturnError(sql.ErrConnDone)
 

workspace-server/internal/handlers/terminal.go

@@ -109,11 +109,9 @@ func (h *TerminalHandler) HandleConnect(c *gin.Context) {
 	// provisionWorkspaceCP → migration 038). Null instance_id means the
 	// workspace runs as a local Docker container on this tenant.
 	var instanceID string
-	if db.DB != nil {
-		db.DB.QueryRowContext(ctx,
-			`SELECT COALESCE(instance_id, '') FROM workspaces WHERE id = $1`,
-			workspaceID).Scan(&instanceID)
-	}
+	db.DB.QueryRowContext(ctx,
+		`SELECT COALESCE(instance_id, '') FROM workspaces WHERE id = $1`,
+		workspaceID).Scan(&instanceID)
 
 	if instanceID != "" {
 		h.handleRemoteConnect(c, workspaceID, instanceID)
@@ -145,7 +143,7 @@ func (h *TerminalHandler) handleLocalConnect(c *gin.Context, workspaceID string)
 
 	// Look up workspace name for manual container naming
 	var wsName string
-	if db.DB != nil && h.docker != nil {
+	if _, err := h.docker.Ping(ctx); err == nil {
 		db.DB.QueryRowContext(ctx, `SELECT LOWER(REPLACE(name, ' ', '-')) FROM workspaces WHERE id = $1`, workspaceID).Scan(&wsName)
 		if wsName != "" {
 			candidates = append(candidates, wsName)

workspace-server/internal/handlers/workspace_crud.go

@@ -149,19 +149,6 @@ func (h *WorkspaceHandler) Update(c *gin.Context) {
 		}
 	}
 
-	// Validate workspace_dir early so invalid paths are rejected before the
-	// existence check (consistent with name/role/runtime validation above).
-	if wsDir, ok := body["workspace_dir"]; ok {
-		if wsDir != nil {
-			if dirStr, isStr := wsDir.(string); isStr && dirStr != "" {
-				if err := validateWorkspaceDir(dirStr); err != nil {
-					c.JSON(http.StatusBadRequest, gin.H{"error": "invalid workspace directory"})
-					return
-				}
-			}
-		}
-	}
-
 	ctx := c.Request.Context()
 
 	// Auth is fully enforced at the router layer (WorkspaceAuth middleware, #680).
@@ -219,8 +206,15 @@ func (h *WorkspaceHandler) Update(c *gin.Context) {
 	}
 	needsRestart := false
 	if wsDir, ok := body["workspace_dir"]; ok {
-		// ValidateWorkspaceDir was already called above before the existence check;
-		// the UPDATE itself is unconditional.
+		// Allow null to clear workspace_dir
+		if wsDir != nil {
+			if dirStr, isStr := wsDir.(string); isStr && dirStr != "" {
+				if err := validateWorkspaceDir(dirStr); err != nil {
+					c.JSON(http.StatusBadRequest, gin.H{"error": "invalid workspace directory"})
+					return
+				}
+			}
+		}
 		if _, err := db.DB.ExecContext(ctx, `UPDATE workspaces SET workspace_dir = $2, updated_at = now() WHERE id = $1`, id, wsDir); err != nil {
 			log.Printf("Update workspace_dir error for %s: %v", id, err)
 		}

workspace-server/internal/handlers/workspace_crud_test.go

@@ -187,43 +187,57 @@ func TestState_QueryError(t *testing.T) {
 // ---------- Update ----------
 
 func TestUpdate_InvalidUUID(t *testing.T) {
-	err := validateWorkspaceID("not-a-uuid")
-	if err == nil {
-		t.Error("expected error for invalid UUID in PATCH path")
+	_, _ = setupWorkspaceCrudTest(t)
+	h := newWorkspaceCrudHandler(t)
+	r2 := gin.New()
+	r2.PATCH("/workspaces/:id", h.Update)
+
+	body := map[string]interface{}{"name": "Test"}
+	b, _ := json.Marshal(body)
+	req, _ := http.NewRequest("PATCH", "/workspaces/not-a-uuid", bytes.NewReader(b))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	r2.ServeHTTP(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("expected 400, got %d: %s", w.Code, w.Body.String())
 	}
 }
 
 func TestUpdate_InvalidBody(t *testing.T) {
-	_, r := setupWorkspaceCrudTest(t)
+	_, _ = setupWorkspaceCrudTest(t)
 	h := newWorkspaceCrudHandler(t)
-	r.PATCH("/workspaces/:id", h.Update)
+	r2 := gin.New()
+	r2.PATCH("/workspaces/:id", h.Update)
 
 	req, _ := http.NewRequest("PATCH", "/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", bytes.NewReader([]byte("not json")))
 	req.Header.Set("Content-Type", "application/json")
 	w := httptest.NewRecorder()
-	r.ServeHTTP(w, req)
+	r2.ServeHTTP(w, req)
 
 	if w.Code != http.StatusBadRequest {
-		t.Errorf("expected 400 for malformed JSON, got %d: %s", w.Code, w.Body.String())
+		t.Errorf("expected 400, got %d", w.Code)
 	}
 }
 
 func TestUpdate_WorkspaceNotFound(t *testing.T) {
-	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
-	mock, r := setupWorkspaceCrudTest(t)
+	mock, _ := setupWorkspaceCrudTest(t)
 	h := newWorkspaceCrudHandler(t)
-	r.PATCH("/workspaces/:id", h.Update)
+	r2 := gin.New()
+	r2.PATCH("/workspaces/:id", h.Update)
+
+	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
 
 	mock.ExpectQuery(`SELECT EXISTS\(SELECT 1 FROM workspaces WHERE id = \$1\)`).
 		WithArgs(wsID).
-		WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(0))
+		WillReturnRows(sqlmock.NewRows([]string{"exists"}).AddRow(false))
 
 	body := map[string]interface{}{"name": "New Name"}
 	b, _ := json.Marshal(body)
 	req, _ := http.NewRequest("PATCH", "/workspaces/"+wsID, bytes.NewReader(b))
 	req.Header.Set("Content-Type", "application/json")
 	w := httptest.NewRecorder()
-	r.ServeHTTP(w, req)
+	r2.ServeHTTP(w, req)
 
 	if w.Code != http.StatusNotFound {
 		t.Errorf("expected 404, got %d: %s", w.Code, w.Body.String())
@@ -231,78 +245,163 @@ func TestUpdate_WorkspaceNotFound(t *testing.T) {
 }
 
 func TestUpdate_NameTooLong(t *testing.T) {
+	_, _ = setupWorkspaceCrudTest(t)
+	h := newWorkspaceCrudHandler(t)
+	r2 := gin.New()
+	r2.PATCH("/workspaces/:id", h.Update)
+
 	longName := make([]byte, 256)
 	for i := range longName {
 		longName[i] = 'x'
 	}
-	err := validateWorkspaceFields(string(longName), "", "", "")
-	if err == nil {
-		t.Error("expected error for name > 255 chars")
+	body := map[string]interface{}{"name": string(longName)}
+	b, _ := json.Marshal(body)
+	req, _ := http.NewRequest("PATCH", "/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", bytes.NewReader(b))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	r2.ServeHTTP(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("expected 400 for name too long, got %d: %s", w.Code, w.Body.String())
 	}
 }
 
 func TestUpdate_RoleTooLong(t *testing.T) {
+	_, _ = setupWorkspaceCrudTest(t)
+	h := newWorkspaceCrudHandler(t)
+	r2 := gin.New()
+	r2.PATCH("/workspaces/:id", h.Update)
+
 	longRole := make([]byte, 1001)
 	for i := range longRole {
 		longRole[i] = 'x'
 	}
-	err := validateWorkspaceFields("", string(longRole), "", "")
-	if err == nil {
-		t.Error("expected error for role > 1000 chars")
+	body := map[string]interface{}{"role": string(longRole)}
+	b, _ := json.Marshal(body)
+	req, _ := http.NewRequest("PATCH", "/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", bytes.NewReader(b))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	r2.ServeHTTP(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("expected 400 for role too long, got %d: %s", w.Code, w.Body.String())
 	}
 }
 
 func TestUpdate_NameWithNewline(t *testing.T) {
-	err := validateWorkspaceFields("Name\nwith newline", "", "", "")
-	if err == nil {
-		t.Error("expected error for newline in name")
+	_, _ = setupWorkspaceCrudTest(t)
+	h := newWorkspaceCrudHandler(t)
+	r2 := gin.New()
+	r2.PATCH("/workspaces/:id", h.Update)
+
+	body := map[string]interface{}{"name": "Name\nwith newline"}
+	b, _ := json.Marshal(body)
+	req, _ := http.NewRequest("PATCH", "/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", bytes.NewReader(b))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	r2.ServeHTTP(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("expected 400 for newline in name, got %d: %s", w.Code, w.Body.String())
 	}
 }
 
 func TestUpdate_NameWithYAMLSpecialChars(t *testing.T) {
-	for _, ch := range "{}[]|>*&!" {
-		err := validateWorkspaceFields("namewith"+string(ch), "", "", "")
-		if err == nil {
-			t.Errorf("expected error for YAML special char %c in name", ch)
-		}
+	_, _ = setupWorkspaceCrudTest(t)
+	h := newWorkspaceCrudHandler(t)
+	r2 := gin.New()
+	r2.PATCH("/workspaces/:id", h.Update)
+
+	body := map[string]interface{}{"name": "Name with [brackets]"}
+	b, _ := json.Marshal(body)
+	req, _ := http.NewRequest("PATCH", "/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", bytes.NewReader(b))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	r2.ServeHTTP(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("expected 400 for YAML special chars in name, got %d: %s", w.Code, w.Body.String())
 	}
 }
 
 func TestUpdate_WorkspaceDirSystemPath(t *testing.T) {
-	err := validateWorkspaceDir("/etc/my-workspace")
-	if err == nil {
-		t.Error("expected error for /etc/ system path in workspace_dir")
+	_, _ = setupWorkspaceCrudTest(t)
+	h := newWorkspaceCrudHandler(t)
+	r2 := gin.New()
+	r2.PATCH("/workspaces/:id", h.Update)
+
+	body := map[string]interface{}{"workspace_dir": "/etc/my-workspace"}
+	b, _ := json.Marshal(body)
+	req, _ := http.NewRequest("PATCH", "/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", bytes.NewReader(b))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	r2.ServeHTTP(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("expected 400 for system path workspace_dir, got %d: %s", w.Code, w.Body.String())
 	}
 }
 
 func TestUpdate_WorkspaceDirTraversal(t *testing.T) {
-	err := validateWorkspaceDir("/workspace/../../../etc")
-	if err == nil {
-		t.Error("expected error for traversal in workspace_dir")
+	_, _ = setupWorkspaceCrudTest(t)
+	h := newWorkspaceCrudHandler(t)
+	r2 := gin.New()
+	r2.PATCH("/workspaces/:id", h.Update)
+
+	body := map[string]interface{}{"workspace_dir": "/workspace/../../../etc"}
+	b, _ := json.Marshal(body)
+	req, _ := http.NewRequest("PATCH", "/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", bytes.NewReader(b))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	r2.ServeHTTP(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("expected 400 for traversal in workspace_dir, got %d: %s", w.Code, w.Body.String())
 	}
 }
 
 func TestUpdate_WorkspaceDirRelativePath(t *testing.T) {
-	err := validateWorkspaceDir("relative/path")
-	if err == nil {
-		t.Error("expected error for relative workspace_dir")
+	_, _ = setupWorkspaceCrudTest(t)
+	h := newWorkspaceCrudHandler(t)
+	r2 := gin.New()
+	r2.PATCH("/workspaces/:id", h.Update)
+
+	body := map[string]interface{}{"workspace_dir": "relative/path"}
+	b, _ := json.Marshal(body)
+	req, _ := http.NewRequest("PATCH", "/workspaces/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", bytes.NewReader(b))
+	req.Header.Set("Content-Type", "application/json")
+	w := httptest.NewRecorder()
+	r2.ServeHTTP(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("expected 400 for relative workspace_dir, got %d: %s", w.Code, w.Body.String())
 	}
 }
 
 // ---------- Delete ----------
 
 func TestDelete_InvalidUUID(t *testing.T) {
-	err := validateWorkspaceID("not-a-uuid")
-	if err == nil {
-		t.Error("expected error for invalid UUID in DELETE path")
+	_, _ = setupWorkspaceCrudTest(t)
+	h := newWorkspaceCrudHandler(t)
+	r2 := gin.New()
+	r2.DELETE("/workspaces/:id", h.Delete)
+
+	req, _ := http.NewRequest("DELETE", "/workspaces/not-a-uuid", nil)
+	w := httptest.NewRecorder()
+	r2.ServeHTTP(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("expected 400, got %d: %s", w.Code, w.Body.String())
 	}
 }
 
 func TestDelete_HasChildrenWithoutConfirm(t *testing.T) {
-	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
-	mock, r := setupWorkspaceCrudTest(t)
+	mock, _ := setupWorkspaceCrudTest(t)
 	h := newWorkspaceCrudHandler(t)
-	r.DELETE("/workspaces/:id", h.Delete)
+	r2 := gin.New()
+	r2.DELETE("/workspaces/:id", h.Delete)
+
+	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
 
 	mock.ExpectQuery(`SELECT id, name FROM workspaces WHERE parent_id = \$1 AND status != 'removed'`).
 		WithArgs(wsID).
@@ -312,7 +411,7 @@ func TestDelete_HasChildrenWithoutConfirm(t *testing.T) {
 	req, _ := http.NewRequest("DELETE", "/workspaces/"+wsID, nil)
 	// No ?confirm=true
 	w := httptest.NewRecorder()
-	r.ServeHTTP(w, req)
+	r2.ServeHTTP(w, req)
 
 	if w.Code != http.StatusConflict {
 		t.Errorf("expected 409, got %d: %s", w.Code, w.Body.String())
@@ -331,10 +430,12 @@ func TestDelete_HasChildrenWithoutConfirm(t *testing.T) {
 }
 
 func TestDelete_ChildrenCheckQueryError(t *testing.T) {
-	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
-	mock, r := setupWorkspaceCrudTest(t)
+	mock, _ := setupWorkspaceCrudTest(t)
 	h := newWorkspaceCrudHandler(t)
-	r.DELETE("/workspaces/:id", h.Delete)
+	r2 := gin.New()
+	r2.DELETE("/workspaces/:id", h.Delete)
+
+	wsID := "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
 
 	mock.ExpectQuery(`SELECT id, name FROM workspaces WHERE parent_id = \$1 AND status != 'removed'`).
 		WithArgs(wsID).
@@ -342,7 +443,7 @@ func TestDelete_ChildrenCheckQueryError(t *testing.T) {
 
 	req, _ := http.NewRequest("DELETE", "/workspaces/"+wsID, nil)
 	w := httptest.NewRecorder()
-	r.ServeHTTP(w, req)
+	r2.ServeHTTP(w, req)
 
 	if w.Code != http.StatusInternalServerError {
 		t.Errorf("expected 500, got %d", w.Code)

workspace-server/internal/handlers/workspace_provision.go

@@ -258,7 +258,7 @@ func (h *WorkspaceHandler) buildProvisionerConfig(
 	// present) wins, matching the existing WorkspaceDir precedence.
 	workspacePath := payload.WorkspaceDir
 	workspaceAccess := payload.WorkspaceAccess
-	if (workspacePath == "" || workspaceAccess == "") && db.DB != nil {
+	if workspacePath == "" || workspaceAccess == "" {
 		var dbDir, dbAccess string
 		if err := db.DB.QueryRow(
 			`SELECT COALESCE(workspace_dir, ''), COALESCE(workspace_access, 'none') FROM workspaces WHERE id = $1`,

workspace/a2a_mcp_server.py

@@ -686,8 +686,8 @@ def _format_channel_content(
 # --- MCP Server (JSON-RPC over stdio) ---
 
 
-def _assert_stdio_is_pipe_compatible(stdin_fd: int = 0, stdout_fd: int = 1) -> None:
-    """Assert that stdio fds are pipe/socket/char-device compatible.
+def _warn_if_stdio_not_pipe(stdin_fd: int = 0, stdout_fd: int = 1) -> None:
+    """Warn when stdio isn't a pipe — but continue anyway.
 
     The legacy asyncio.connect_read_pipe / connect_write_pipe transport
     rejected regular files, PTYs, and sockets with:
@@ -711,10 +711,6 @@ def _assert_stdio_is_pipe_compatible(stdin_fd: int = 0, stdout_fd: int = 1) -> N
             )
 
 
-# Deprecated alias — the canonical name is _assert_stdio_is_pipe_compatible.
-_warn_if_stdio_not_pipe = _assert_stdio_is_pipe_compatible
-
-
 async def main():  # pragma: no cover
     """Run MCP server on stdio — reads JSON-RPC requests, writes responses.
 
@@ -971,7 +967,7 @@ def cli_main(transport: str = "stdio", port: int = 9100) -> None:  # pragma: no
     if transport == "http":
         asyncio.run(_run_http_server(port))
     else:
-        _assert_stdio_is_pipe_compatible()
+        _warn_if_stdio_not_pipe()
         asyncio.run(main())
 
 

workspace/tests/test_a2a_mcp_server.py

@@ -1826,8 +1826,8 @@ def test_inbox_bridge_swallows_closed_loop_runtime_error():
 
 
 class TestStdioPipeAssertion:
-    """Pin _assert_stdio_is_pipe_compatible — the canonical function name.
-    _warn_if_stdio_not_pipe is a deprecated alias.
+    """Pin _warn_if_stdio_not_pipe — the diagnostic warning that replaces
+    the old fatal _assert_stdio_is_pipe_compatible guard.
 
     The universal stdio transport now works with ANY file descriptor
     (pipes, regular files, PTYs, sockets), so the old exit-2 behavior
@@ -1838,12 +1838,12 @@ class TestStdioPipeAssertion:
 
     def test_pipe_pair_passes_silently(self, caplog):
         """Happy path — both fds are pipes. No warning emitted."""
-        from a2a_mcp_server import _assert_stdio_is_pipe_compatible
+        from a2a_mcp_server import _warn_if_stdio_not_pipe
 
         r, w = os.pipe()
         try:
             with caplog.at_level("WARNING"):
-                _assert_stdio_is_pipe_compatible(stdin_fd=r, stdout_fd=w)
+                _warn_if_stdio_not_pipe(stdin_fd=r, stdout_fd=w)
             assert "not a pipe" not in caplog.text
         finally:
             os.close(r)
@@ -1852,14 +1852,14 @@ class TestStdioPipeAssertion:
     def test_regular_file_stdout_warns(self, tmp_path, caplog):
         """Reproducer for runtime#61: stdout redirected to a regular file.
         Now emits a warning instead of exiting."""
-        from a2a_mcp_server import _assert_stdio_is_pipe_compatible
+        from a2a_mcp_server import _warn_if_stdio_not_pipe
 
         r, _w = os.pipe()
         regular = tmp_path / "captured.log"
         f = open(regular, "wb")
         try:
             with caplog.at_level("WARNING"):
-                _assert_stdio_is_pipe_compatible(stdin_fd=r, stdout_fd=f.fileno())
+                _warn_if_stdio_not_pipe(stdin_fd=r, stdout_fd=f.fileno())
             assert "stdout" in caplog.text
             assert "not a pipe" in caplog.text
         finally:
@@ -1868,7 +1868,7 @@ class TestStdioPipeAssertion:
 
     def test_regular_file_stdin_warns(self, tmp_path, caplog):
         """Symmetric case — stdin redirected from a regular file."""
-        from a2a_mcp_server import _assert_stdio_is_pipe_compatible
+        from a2a_mcp_server import _warn_if_stdio_not_pipe
 
         regular = tmp_path / "input.json"
         regular.write_bytes(b'{"jsonrpc":"2.0","id":1,"method":"initialize"}\n')
@@ -1876,7 +1876,7 @@ class TestStdioPipeAssertion:
         _r, w = os.pipe()
         try:
             with caplog.at_level("WARNING"):
-                _assert_stdio_is_pipe_compatible(stdin_fd=f.fileno(), stdout_fd=w)
+                _warn_if_stdio_not_pipe(stdin_fd=f.fileno(), stdout_fd=w)
             assert "stdin" in caplog.text
             assert "not a pipe" in caplog.text
         finally:
@@ -1886,13 +1886,13 @@ class TestStdioPipeAssertion:
     def test_closed_fd_warns_about_stat_error(self, caplog):
         """If stdio is closed, os.fstat raises OSError. Warning is
         skipped silently (can't stat the fd)."""
-        from a2a_mcp_server import _assert_stdio_is_pipe_compatible
+        from a2a_mcp_server import _warn_if_stdio_not_pipe
 
         r, w = os.pipe()
         os.close(w)  # Now `w` is a stale fd — fstat will fail.
         try:
             with caplog.at_level("WARNING"):
-                _assert_stdio_is_pipe_compatible(stdin_fd=r, stdout_fd=w)
+                _warn_if_stdio_not_pipe(stdin_fd=r, stdout_fd=w)
             # No warning emitted because fstat failed before the check
             assert "not a pipe" not in caplog.text
         finally: