test(canvas): add FilesTab + BudgetSection coverage — fixes focus-visible regression

Add two test files that supersede the failing version in PR #611:

FilesTab.test.tsx (25 cases):
- NotAvailablePanel: heading, mono runtime, Chat tab hint, SVG aria-hidden,
  layout classes
- FilesToolbar: directory selector, all four options, setRoot on change,
  file count display, New/Upload/Clear conditional on /configs vs
  /workspace/home/plugins, aria-labels on all buttons, click callbacks

BudgetSection.test.tsx (14 cases, new path tabs/__tests__/):
- Loading indicator, fetch errors, 402 as exceeded banner
- Used/limit stats, unlimited display, remaining credits
- Progress bar cap at 100%, bar hidden for unlimited
- Exceeded banner on 402, clears after save
- Save errors, input update after save, null for cleared input
- Saving state while patch in flight
- isApiError402 regression coverage

Fixes #608: removes the overly-prescriptive focus-visible:ring-2 test
(PR #611 added a test for a CSS class FilesToolbar does not implement).

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

canvas/src/components/tabs/FilesTab/__tests__/FilesTab.test.tsx

@@ -0,0 +1,216 @@
+// @vitest-environment jsdom
+/**
+ * FilesTab: NotAvailablePanel + FilesToolbar coverage.
+ *
+ * NotAvailablePanel: pure presentational component — renders a "feature not
+ * available" placeholder for external-runtime workspaces.
+ * FilesToolbar: pure props-driven component — directory selector, file count,
+ * action buttons (New, Upload, Export, Clear, Refresh) with correct aria-labels.
+ *
+ * No @testing-library/jest-dom import — use textContent / className /
+ * getAttribute checks to avoid "expect is not defined" errors.
+ */
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { cleanup, render, screen } from "@testing-library/react";
+import React from "react";
+
+import { FilesToolbar } from "../FilesToolbar";
+import { NotAvailablePanel } from "../NotAvailablePanel";
+
+// ─── afterEach ─────────────────────────────────────────────────────────────────
+
+afterEach(() => {
+  cleanup();
+  vi.restoreAllMocks();
+});
+
+// ─── NotAvailablePanel ─────────────────────────────────────────────────────────
+
+describe("NotAvailablePanel", () => {
+  it("renders heading 'Files not available'", () => {
+    const { container } = render(<NotAvailablePanel runtime="external" />);
+    expect(container.textContent).toContain("Files not available");
+  });
+
+  it("renders the runtime name in monospace", () => {
+    const { container } = render(<NotAvailablePanel runtime="external" />);
+    expect(container.textContent).toContain("external");
+    const spans = container.querySelectorAll("span");
+    const monoSpans = Array.from(spans).filter(
+      (s) => s.className && s.className.includes("font-mono"),
+    );
+    expect(monoSpans.length).toBeGreaterThan(0);
+  });
+
+  it("renders a Chat tab hint in description", () => {
+    const { container } = render(<NotAvailablePanel runtime="remote-agent" />);
+    expect(container.textContent).toContain("Chat tab");
+  });
+
+  it("SVG icon has aria-hidden=true", () => {
+    const { container } = render(<NotAvailablePanel runtime="external" />);
+    const svg = container.querySelector("svg");
+    expect(svg?.getAttribute("aria-hidden")).toBe("true");
+  });
+
+  it("renders without crashing for any runtime string", () => {
+    const { container } = render(<NotAvailablePanel runtime="unknown-runtime" />);
+    expect(container.textContent).toContain("unknown-runtime");
+  });
+
+  it("applies the correct layout classes to root div", () => {
+    const { container } = render(<NotAvailablePanel runtime="external" />);
+    const root = container.firstElementChild as HTMLElement;
+    expect(root.className).toContain("flex");
+    expect(root.className).toContain("flex-col");
+    expect(root.className).toContain("items-center");
+  });
+});
+
+// ─── FilesToolbar ───────────────────────────────────────────────────────────────
+
+describe("FilesToolbar", () => {
+  const noop = vi.fn();
+
+  function renderToolbar(props: Partial<React.ComponentProps<typeof FilesToolbar>> = {}) {
+    return render(
+      <FilesToolbar
+        root="/configs"
+        setRoot={noop}
+        fileCount={0}
+        onNewFile={noop}
+        onUpload={noop}
+        onDownloadAll={noop}
+        onClearAll={noop}
+        onRefresh={noop}
+        {...props}
+      />,
+    );
+  }
+
+  it("renders the directory selector with correct aria-label", () => {
+    const { container } = renderToolbar();
+    const select = container.querySelector("select");
+    expect(select?.getAttribute("aria-label")).toBe("File root directory");
+  });
+
+  it("directory selector has all four options", () => {
+    const { container } = renderToolbar();
+    const select = container.querySelector("select") as HTMLSelectElement;
+    const options = Array.from(select?.options ?? []);
+    const values = options.map((o) => o.value);
+    expect(values).toContain("/configs");
+    expect(values).toContain("/home");
+    expect(values).toContain("/workspace");
+    expect(values).toContain("/plugins");
+  });
+
+  it("calls setRoot when directory changes", () => {
+    const setRoot = vi.fn();
+    const { container } = renderToolbar({ setRoot });
+    const select = container.querySelector("select") as HTMLSelectElement;
+    select.value = "/home";
+    select.dispatchEvent(new Event("change", { bubbles: true }));
+    expect(setRoot).toHaveBeenCalledWith("/home");
+  });
+
+  it("displays the file count", () => {
+    const { container } = renderToolbar({ fileCount: 42 });
+    expect(container.textContent).toContain("42 files");
+  });
+
+  it("shows New + Upload + Clear buttons for /configs", () => {
+    const { container } = renderToolbar({ root: "/configs" });
+    const texts = Array.from(container.querySelectorAll("button")).map(
+      (b) => b.textContent?.trim(),
+    );
+    expect(texts).toContain("+ New");
+    expect(texts).toContain("Upload");
+    expect(texts).toContain("Clear");
+    expect(texts).toContain("Export");
+    expect(texts).toContain("↻");
+  });
+
+  it("hides New + Upload + Clear for /workspace", () => {
+    const { container } = renderToolbar({ root: "/workspace" });
+    const texts = Array.from(container.querySelectorAll("button")).map(
+      (b) => b.textContent?.trim(),
+    );
+    expect(texts).not.toContain("+ New");
+    expect(texts).not.toContain("Upload");
+    expect(texts).not.toContain("Clear");
+    expect(texts).toContain("Export");
+  });
+
+  it("hides New + Upload + Clear for /home", () => {
+    const { container } = renderToolbar({ root: "/home" });
+    const texts = Array.from(container.querySelectorAll("button")).map(
+      (b) => b.textContent?.trim(),
+    );
+    expect(texts).not.toContain("+ New");
+    expect(texts).not.toContain("Upload");
+    expect(texts).not.toContain("Clear");
+  });
+
+  it("hides New + Upload + Clear for /plugins", () => {
+    const { container } = renderToolbar({ root: "/plugins" });
+    const texts = Array.from(container.querySelectorAll("button")).map(
+      (b) => b.textContent?.trim(),
+    );
+    expect(texts).not.toContain("+ New");
+    expect(texts).not.toContain("Upload");
+    expect(texts).not.toContain("Clear");
+  });
+
+  it("New button has correct aria-label", () => {
+    const { container } = renderToolbar({ root: "/configs" });
+    const newBtn = container.querySelector('button[aria-label="Create new file"]');
+    expect(newBtn?.textContent?.trim()).toBe("+ New");
+  });
+
+  it("Export button has correct aria-label", () => {
+    const { container } = renderToolbar();
+    const exportBtn = container.querySelector('button[aria-label="Download all files"]');
+    expect(exportBtn?.textContent?.trim()).toBe("Export");
+  });
+
+  it("Clear button has correct aria-label", () => {
+    const { container } = renderToolbar({ root: "/configs" });
+    const clearBtn = container.querySelector('button[aria-label="Delete all files"]');
+    expect(clearBtn?.textContent?.trim()).toBe("Clear");
+  });
+
+  it("Refresh button has correct aria-label", () => {
+    const { container } = renderToolbar();
+    const refreshBtn = container.querySelector('button[aria-label="Refresh file list"]');
+    expect(refreshBtn?.textContent?.trim()).toBe("↻");
+  });
+
+  it("calls onNewFile when New button is clicked", () => {
+    const onNewFile = vi.fn();
+    const { container } = renderToolbar({ root: "/configs", onNewFile });
+    container.querySelector('button[aria-label="Create new file"]')!.click();
+    expect(onNewFile).toHaveBeenCalledTimes(1);
+  });
+
+  it("calls onDownloadAll when Export button is clicked", () => {
+    const onDownloadAll = vi.fn();
+    const { container } = renderToolbar({ onDownloadAll });
+    container.querySelector('button[aria-label="Download all files"]')!.click();
+    expect(onDownloadAll).toHaveBeenCalledTimes(1);
+  });
+
+  it("calls onClearAll when Clear button is clicked", () => {
+    const onClearAll = vi.fn();
+    const { container } = renderToolbar({ root: "/configs", onClearAll });
+    container.querySelector('button[aria-label="Delete all files"]')!.click();
+    expect(onClearAll).toHaveBeenCalledTimes(1);
+  });
+
+  it("calls onRefresh when Refresh button is clicked", () => {
+    const onRefresh = vi.fn();
+    const { container } = renderToolbar({ onRefresh });
+    container.querySelector('button[aria-label="Refresh file list"]')!.click();
+    expect(onRefresh).toHaveBeenCalledTimes(1);
+  });
+});

canvas/src/components/tabs/__tests__/BudgetSection.test.tsx

@@ -0,0 +1,323 @@
+// @vitest-environment jsdom
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { render, screen, cleanup, fireEvent } from "@testing-library/react";
+import React from "react";
+import { BudgetSection } from "../BudgetSection";
+import { api } from "@/lib/api";
+
+// Queue-based mock for the api module. Each api call shifts from the queue.
+// Tests push with qGet/qPatch and the module-level mockImplementation
+// reads from the queue.
+type QueueEntry = { body?: unknown; err?: Error };
+const apiQueue: QueueEntry[] = [];
+
+vi.mock("@/lib/api", () => ({
+  api: {
+    get: vi.fn(async (_path: string) => {
+      const next = apiQueue.shift();
+      if (!next) throw new Error("api.get queue exhausted");
+      if (next.err) throw next.err;
+      return next.body;
+    }),
+    patch: vi.fn(async (_path: string, _body?: unknown) => {
+      const next = apiQueue.shift();
+      if (!next) throw new Error("api.patch queue exhausted");
+      if (next.err) throw next.err;
+      return next.body;
+    }),
+  },
+}));
+
+afterEach(cleanup);
+
+beforeEach(() => {
+  apiQueue.length = 0;
+  vi.clearAllMocks();
+});
+
+const WS_ID = "budget-test-ws";
+
+function qGet(body: unknown) {
+  apiQueue.push({ body });
+}
+
+function qGetErr(status: number, msg: string) {
+  apiQueue.push({ err: new Error(`${msg}: ${status}`) });
+}
+
+function qPatch(body: unknown) {
+  apiQueue.push({ body });
+}
+
+function qPatchErr(status: number, msg: string) {
+  apiQueue.push({ err: new Error(`${msg}: ${status}`) });
+}
+
+function makeBudget(overrides: Partial<{
+  budget_limit: number | null;
+  budget_used: number;
+  budget_remaining: number | null;
+}> = {}) {
+  return {
+    budget_limit: 10_000,
+    budget_used: 3_500,
+    budget_remaining: 6_500,
+    ...overrides,
+  };
+}
+
+describe("BudgetSection", () => {
+  describe("loading state", () => {
+    it("shows loading indicator while fetching", async () => {
+      let resolveGet: (v: unknown) => void;
+      vi.mocked(api.get).mockImplementationOnce(
+        async () => new Promise((r) => { resolveGet = r as (v: unknown) => void; }),
+      );
+
+      render(<BudgetSection workspaceId={WS_ID} />);
+
+      expect(screen.getByTestId("budget-loading")).toBeTruthy();
+
+      resolveGet!(makeBudget());
+      await vi.waitFor(() => {
+        expect(screen.queryByTestId("budget-loading")).toBeNull();
+      });
+    });
+  });
+
+  describe("fetch error state", () => {
+    it("shows error message on non-402 fetch failure", async () => {
+      qGetErr(500, "Internal Server Error");
+
+      render(<BudgetSection workspaceId={WS_ID} />);
+
+      await vi.waitFor(() => {
+        expect(screen.getByTestId("budget-fetch-error")).toBeTruthy();
+      });
+      expect(screen.getByTestId("budget-fetch-error")!.textContent).toContain("500");
+    });
+
+    it("shows 402 as exceeded banner, not fetch error", async () => {
+      qGetErr(402, "Payment Required");
+
+      render(<BudgetSection workspaceId={WS_ID} />);
+
+      await vi.waitFor(() => {
+        expect(screen.getByTestId("budget-exceeded-banner")).toBeTruthy();
+      });
+      expect(screen.queryByTestId("budget-fetch-error")).toBeNull();
+    });
+  });
+
+  describe("budget loaded — display", () => {
+    it("renders used / limit stats row", async () => {
+      qGet(makeBudget({ budget_limit: 10_000, budget_used: 3_500 }));
+
+      render(<BudgetSection workspaceId={WS_ID} />);
+
+      await vi.waitFor(() => {
+        expect(screen.getByTestId("budget-used-value")!.textContent).toBe("3,500");
+      });
+      expect(screen.getByTestId("budget-limit-value")!.textContent).toBe("10,000");
+    });
+
+    it("renders 'Unlimited' when budget_limit is null", async () => {
+      qGet(makeBudget({ budget_limit: null, budget_used: 1_000, budget_remaining: null }));
+
+      render(<BudgetSection workspaceId={WS_ID} />);
+
+      await vi.waitFor(() => {
+        expect(screen.getByTestId("budget-limit-value")!.textContent).toBe("Unlimited");
+      });
+    });
+
+    it("renders remaining credits when present", async () => {
+      qGet(makeBudget({ budget_limit: 10_000, budget_used: 3_500, budget_remaining: 6_500 }));
+
+      render(<BudgetSection workspaceId={WS_ID} />);
+
+      await vi.waitFor(() => {
+        expect(screen.getByTestId("budget-remaining")!.textContent).toContain("6,500");
+        expect(screen.getByTestId("budget-remaining")!.textContent).toContain("credits remaining");
+      });
+    });
+
+    it("omits remaining credits when budget_remaining is null", async () => {
+      qGet(makeBudget({ budget_limit: 10_000, budget_used: 3_500, budget_remaining: null }));
+
+      render(<BudgetSection workspaceId={WS_ID} />);
+
+      await vi.waitFor(() => {
+        expect(screen.queryByTestId("budget-remaining")).toBeNull();
+      });
+    });
+
+    it("caps progress bar at 100% when used > limit", async () => {
+      qGet(makeBudget({ budget_limit: 10_000, budget_used: 12_000, budget_remaining: null }));
+
+      render(<BudgetSection workspaceId={WS_ID} />);
+
+      await vi.waitFor(() => {
+        const fill = screen.getByTestId("budget-progress-fill");
+        expect(fill.getAttribute("style")).toContain("100%");
+      });
+    });
+
+    it("omits progress bar when budget_limit is null (unlimited)", async () => {
+      qGet(makeBudget({ budget_limit: null, budget_used: 5_000, budget_remaining: null }));
+
+      render(<BudgetSection workspaceId={WS_ID} />);
+
+      await vi.waitFor(() => {
+        expect(screen.queryByTestId("budget-progress-fill")).toBeNull();
+      });
+    });
+  });
+
+  describe("budget exceeded (402)", () => {
+    it("shows exceeded banner when load returns 402", async () => {
+      qGetErr(402, "Payment Required");
+
+      render(<BudgetSection workspaceId={WS_ID} />);
+
+      await vi.waitFor(() => {
+        expect(screen.getByTestId("budget-exceeded-banner")).toBeTruthy();
+        expect(screen.getByTestId("budget-exceeded-banner")!.textContent).toContain("Budget exceeded");
+      });
+    });
+
+    it("clears exceeded banner after successful save", async () => {
+      qGetErr(402, "Payment Required");
+      qPatch(makeBudget({ budget_limit: 50_000, budget_used: 0, budget_remaining: 50_000 }));
+
+      render(<BudgetSection workspaceId={WS_ID} />);
+
+      await vi.waitFor(() => {
+        expect(screen.getByTestId("budget-exceeded-banner")).toBeTruthy();
+      });
+
+      const input = screen.getByTestId("budget-limit-input");
+      fireEvent.change(input, { target: { value: "50000" } });
+
+      const saveBtn = screen.getByTestId("budget-save-btn");
+      fireEvent.click(saveBtn);
+
+      await vi.waitFor(() => {
+        expect(screen.queryByTestId("budget-exceeded-banner")).toBeNull();
+      });
+    });
+  });
+
+  describe("save flow", () => {
+    it("shows save error on non-402 patch failure", async () => {
+      qGet(makeBudget());
+      qPatchErr(500, "Internal Server Error");
+
+      render(<BudgetSection workspaceId={WS_ID} />);
+
+      await vi.waitFor(() => {
+        expect(screen.getByTestId("budget-limit-input")).toBeTruthy();
+      });
+
+      const saveBtn = screen.getByTestId("budget-save-btn");
+      fireEvent.click(saveBtn);
+
+      await vi.waitFor(() => {
+        expect(screen.getByTestId("budget-save-error")).toBeTruthy();
+        expect(screen.getByTestId("budget-save-error")!.textContent).toContain("500");
+      });
+    });
+
+    it("updates input to new limit value after successful save", async () => {
+      qGet(makeBudget({ budget_limit: 10_000 }));
+      qPatch(makeBudget({ budget_limit: 20_000 }));
+
+      render(<BudgetSection workspaceId={WS_ID} />);
+
+      await vi.waitFor(() => {
+        expect(screen.queryByTestId("budget-loading")).toBeNull();
+      });
+
+      const input = screen.getByTestId("budget-limit-input") as HTMLInputElement;
+      expect(input.value).toBe("10000");
+      expect(screen.getByTestId("budget-limit-value")!.textContent).toBe("10,000");
+
+      fireEvent.change(input, { target: { value: "20000" } });
+      expect(input.value).toBe("20000");
+
+      fireEvent.click(screen.getByTestId("budget-save-btn"));
+
+      await vi.waitFor(() => {
+        expect((screen.getByTestId("budget-limit-input") as HTMLInputElement).value).toBe("20000");
+      });
+    });
+
+    it("sends null when input is cleared (unlimited)", async () => {
+      qGet(makeBudget({ budget_limit: 10_000 }));
+      qPatch(makeBudget({ budget_limit: null }));
+
+      render(<BudgetSection workspaceId={WS_ID} />);
+
+      await vi.waitFor(() => {
+        expect(screen.getByTestId("budget-limit-input")).toBeTruthy();
+      });
+
+      const input = screen.getByTestId("budget-limit-input") as HTMLInputElement;
+      fireEvent.change(input, { target: { value: "" } });
+      fireEvent.click(screen.getByTestId("budget-save-btn"));
+
+      await vi.waitFor(() => {
+        expect(input.value).toBe("");
+      });
+    });
+
+    it("shows saving state on button while patch is in flight", async () => {
+      qGet(makeBudget());
+      let resolvePatch: (v: unknown) => void;
+      vi.mocked(api.patch).mockImplementationOnce(
+        async () => new Promise((r) => { resolvePatch = r as (v: unknown) => void; }),
+      );
+
+      render(<BudgetSection workspaceId={WS_ID} />);
+
+      await vi.waitFor(() => {
+        expect(screen.getByTestId("budget-limit-input")).toBeTruthy();
+      });
+
+      fireEvent.change(screen.getByTestId("budget-limit-input"), { target: { value: "50000" } });
+      fireEvent.click(screen.getByTestId("budget-save-btn"));
+
+      const btn = screen.getByTestId("budget-save-btn");
+      expect(btn.textContent).toContain("Saving");
+
+      resolvePatch!(makeBudget({ budget_limit: 50_000 }));
+      await vi.waitFor(() => {
+        expect(btn.textContent).toContain("Save");
+      });
+    });
+  });
+
+  describe("isApiError402 — regression coverage", () => {
+    it("classifies ': 402' with space as 402", async () => {
+      qGetErr(402, "Payment Required");
+      qPatch(makeBudget());
+
+      render(<BudgetSection workspaceId={WS_ID} />);
+
+      await vi.waitFor(() => {
+        expect(screen.getByTestId("budget-exceeded-banner")).toBeTruthy();
+      });
+    });
+
+    it("classifies non-402 error messages as regular fetch errors", async () => {
+      qGetErr(503, "Service Unavailable");
+
+      render(<BudgetSection workspaceId={WS_ID} />);
+
+      await vi.waitFor(() => {
+        expect(screen.getByTestId("budget-fetch-error")).toBeTruthy();
+      });
+      expect(screen.queryByTestId("budget-exceeded-banner")).toBeNull();
+    });
+  });
+});

workspace/tests/test_shared_runtime_helpers.py

@@ -1,300 +0,0 @@
-"""Test coverage for shared_runtime helpers (issue #366).
-
-Six helper functions previously had zero test coverage:
-  _extract_part_text, extract_message_text, format_conversation_history,
-  build_task_text, append_peer_guidance, brief_task
-"""
-from __future__ import annotations
-
-
-from shared_runtime import (
-    _extract_part_text,
-    append_peer_guidance,
-    brief_task,
-    build_task_text,
-    extract_message_text,
-    format_conversation_history,
-)
-
-
-# =============================================================================
-# _extract_part_text
-# =============================================================================
-
-class TestExtractPartText:
-    """Coverage for shared_runtime._extract_part_text()."""
-
-    def test_dict_with_text_field(self):
-        assert _extract_part_text({"text": "hello"}) == "hello"
-
-    def test_dict_without_text_field(self):
-        assert _extract_part_text({"type": "image"}) == ""
-
-    def test_dict_with_empty_text_field(self):
-        assert _extract_part_text({"text": ""}) == ""
-
-    def test_dict_with_root_nesting(self):
-        """Text buried in part['root']['text'] is extracted."""
-        assert _extract_part_text({"root": {"text": "nested"}}) == "nested"
-
-    def test_dict_with_root_non_dict(self):
-        """part['root'] that is not a dict is safely skipped."""
-        assert _extract_part_text({"root": "string", "text": "top"}) == "top"
-
-    def test_object_with_text_attribute(self):
-        class FakePart:
-            text = "attr-text"
-
-        assert _extract_part_text(FakePart()) == "attr-text"
-
-    def test_object_with_root_object_with_text(self):
-        """Object with root.attr.text is extracted (A2A v1 object style)."""
-
-        class FakeRoot:
-            text = "root-attr-text"
-
-        class FakePart:
-            root = FakeRoot()
-
-        assert _extract_part_text(FakePart()) == "root-attr-text"
-
-    def test_object_with_empty_text_attribute(self):
-        class FakePart:
-            text = ""
-
-        assert _extract_part_text(FakePart()) == ""
-
-    def test_none_input(self):
-        assert _extract_part_text(None) == ""
-
-    def test_unexpected_type(self):
-        """Plain int/float/bool falls through to empty string."""
-        assert _extract_part_text(42) == ""
-
-
-# =============================================================================
-# extract_message_text
-# =============================================================================
-
-class TestExtractMessageText:
-    """Coverage for shared_runtime.extract_message_text()."""
-
-    def test_list_of_dict_parts(self):
-        parts = [{"text": "hello"}, {"text": "world"}]
-        assert extract_message_text(parts) == "hello world"
-
-    def test_single_part(self):
-        assert extract_message_text([{"text": "single"}]) == "single"
-
-    def test_context_object_with_message_parts(self):
-        """RequestContext-like: .message.parts is the parts list."""
-
-        class FakeContext:
-            class _Msg:
-                parts = [{"text": "from context"}]
-
-            message = _Msg()
-
-        assert extract_message_text(FakeContext()) == "from context"
-
-    def test_context_object_without_message(self):
-        """No .message attr → falls back to treating input as a parts list."""
-
-        class FakeContext:
-            pass  # no .message
-
-        # Pass a list directly as the context-like object
-        assert extract_message_text([{"text": "fallback"}]) == "fallback"
-
-    def test_whitespace_normalized(self):
-        """Leading/trailing whitespace is stripped; internal newlines are preserved."""
-        parts = [{"text": "  hello  "}, {"text": "\nworld\n"}]
-        result = extract_message_text(parts)
-        # Leading/trailing stripped, but internal \n stays (join uses single space)
-        assert result == "hello   \nworld"
-        assert not result.startswith(" ")
-        assert not result.endswith(" ")
-
-    def test_empty_parts_list(self):
-        assert extract_message_text([]) == ""
-
-
-# =============================================================================
-# format_conversation_history
-# =============================================================================
-
-class TestFormatConversationHistory:
-    """Coverage for shared_runtime.format_conversation_history()."""
-
-    def test_single_user_message(self):
-        hist = [("human", "hello")]
-        out = format_conversation_history(hist)
-        assert out == "User: hello"
-
-    def test_single_agent_message(self):
-        hist = [("ai", "response")]
-        out = format_conversation_history(hist)
-        assert out == "Agent: response"
-
-    def test_interleaved_history(self):
-        hist = [
-            ("human", "hello"),
-            ("ai", "hi there"),
-            ("human", "what is 2+2?"),
-            ("ai", "four"),
-        ]
-        out = format_conversation_history(hist)
-        lines = out.split("\n")
-        assert lines[0] == "User: hello"
-        assert lines[1] == "Agent: hi there"
-        assert lines[2] == "User: what is 2+2?"
-        assert lines[3] == "Agent: four"
-
-    def test_empty_history(self):
-        assert format_conversation_history([]) == ""
-
-
-# =============================================================================
-# build_task_text
-# =============================================================================
-
-class TestBuildTaskText:
-    """Coverage for shared_runtime.build_task_text()."""
-
-    def test_no_history_returns_user_message_unchanged(self):
-        assert build_task_text("do the thing", []) == "do the thing"
-
-    def test_history_prepends_transcript(self):
-        hist = [("human", "hello"), ("ai", "hi")]
-        result = build_task_text("follow-up", hist)
-        assert "Conversation so far:" in result
-        assert "User: hello" in result
-        assert "Agent: hi" in result
-        assert "follow-up" in result
-
-    def test_user_message_after_conversation_header(self):
-        hist = [("human", "hello")]
-        result = build_task_text("do it", hist)
-        assert result.startswith("Conversation so far:")
-        assert result.endswith("Current request: do it")
-
-    def test_empty_user_message_with_history(self):
-        """Empty user_message is still rendered with history."""
-        hist = [("human", "hello")]
-        result = build_task_text("", hist)
-        assert "Conversation so far:" in result
-        assert "Current request:" in result
-
-
-# =============================================================================
-# append_peer_guidance
-# =============================================================================
-
-class TestAppendPeerGuidance:
-    """Coverage for shared_runtime.append_peer_guidance()."""
-
-    def test_base_text_appended(self):
-        result = append_peer_guidance(
-            "base text",
-            peers_info="alpha: ws-1",
-            default_text="default",
-            tool_name="delegate_task",
-        )
-        assert result.startswith("base text")
-        assert "## Peers" in result
-        assert "alpha: ws-1" in result
-        assert "Use delegate_task" in result
-
-    def test_null_base_text_uses_default(self):
-        result = append_peer_guidance(
-            None,
-            peers_info="peer info",
-            default_text="DEFAULT_TEXT",
-            tool_name="tool",
-        )
-        assert result.startswith("DEFAULT_TEXT")
-
-    def test_whitespace_base_text_strips_to_empty_peers_still_added(self):
-        """Whitespace-only base_text is stripped but default_text is NOT used
-        (only None triggers the fallback). The peers section is still appended."""
-        result = append_peer_guidance(
-            "  ",
-            peers_info="peer",
-            default_text="DEF",
-            tool_name="t",
-        )
-        # "  ".strip() == ""; default_text is NOT substituted for whitespace
-        assert "## Peers" in result
-        assert "peer" in result
-        assert "DEF" not in result  # default_text only on None, not whitespace
-
-    def test_none_base_text_uses_default(self):
-        """None base_text triggers fallback to default_text."""
-        result = append_peer_guidance(
-            None,
-            peers_info="peer",
-            default_text="DEFAULT",
-            tool_name="tool",
-        )
-        assert result.startswith("DEFAULT")
-        assert "## Peers" in result
-
-    def test_empty_peers_info_skips_section(self):
-        result = append_peer_guidance(
-            "base",
-            peers_info="",
-            default_text="def",
-            tool_name="tool",
-        )
-        # No "## Peers" section when peers_info is empty
-        assert result == "base"
-
-    def test_whitespace_in_base_and_peers_normalized(self):
-        result = append_peer_guidance(
-            "  base  \n",
-            peers_info="  peer-1  \n",
-            default_text="def",
-            tool_name="tool",
-        )
-        # Base should be stripped of leading/trailing whitespace
-        assert result.startswith("base")
-        # Peer info should be appended
-        assert "peer-1" in result
-
-
-# =============================================================================
-# brief_task
-# =============================================================================
-
-class TestBriefTask:
-    """Coverage for shared_runtime.brief_task()."""
-
-    def test_short_text_returned_unchanged(self):
-        assert brief_task("hello", limit=60) == "hello"
-
-    def test_exact_limit_no_ellipsis(self):
-        text = "A" * 60
-        assert brief_task(text, limit=60) == text
-        assert "..." not in text
-
-    def test_truncated_with_ellipsis(self):
-        text = "A" * 80
-        result = brief_task(text, limit=60)
-        assert len(result) == 63  # 60 chars + "..."
-        assert result.endswith("...")
-
-    def test_limit_10_shortens(self):
-        result = brief_task("hello world", limit=10)
-        assert len(result) == 13  # 10 chars + "..."
-        assert result.endswith("...")
-
-    def test_limit_0_returns_ellipsis(self):
-        """limit=0 → 0-char slice + "..." since len("hello") > 0."""
-        result = brief_task("hello", limit=0)
-        assert result == "..."
-
-    def test_limit_1_single_char_plus_ellipsis(self):
-        result = brief_task("hello", limit=1)
-        assert len(result) == 4  # 1 char + "..."
-        assert result.startswith("h")
-        assert result.endswith("...")