feat: flag unportable tool schemas in all three clients

Closes #1005

A tool schema can be perfectly legal JSON Schema and still be rejected by
the client the server is meant to run against — Go's `jsonschema` emits a
bare `true` for `interface{}`, which the SDK accepts and Claude Code
refuses with an opaque "Invalid input". The Inspector passed it through
silently.

Adds `core/json/schemaLint.ts`, a portability lint over a tool's
inputSchema/outputSchema, and surfaces one shared verdict everywhere:
the CLI's `--strict` report (exit 6 on an error-severity finding), the
TUI's tool list marker + detail pane, and the web Tools sidebar flag +
detail section.

Deliberately not a JSON Schema validator: a census of 617 public servers
found zero that fail the SDK's own parse, so a conformance check would
report nothing on real servers. Each rule is instead a construct that is
legal JSON Schema and known to be refused or mishandled by a shipping
client — a bare boolean in a schema position, an array-form `type`, a
remote `$ref`, a schema with no validation keyword, a non-object root.

`test-servers/configs/unportable-schemas-http.json` exercises every rule,
via a new `rawToolSchemas` override — the Zod-built presets cannot emit
any of these shapes, which is the same reason a real server only hits
this when its schemas come from another generator.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UL9retfvAXRgvi6EWk4SY4
Signed-off-by: cliffhall <cliff@futurescale.com>

clients/tui/__tests__/ToolsTab.test.tsx

@@ -8,7 +8,7 @@ import type { Tool } from "@modelcontextprotocol/client";
 // renders children directly and stubs scrollBy/scrollTo/getViewportHeight.
 vi.mock("ink-scroll-view", () => import("./helpers/inkScrollViewMock.js"));
 
-import { ToolsTab } from "../src/components/ToolsTab.js";
+import { ToolsTab, schemaMarker } from "../src/components/ToolsTab.js";
 
 // Ink processes stdin keypresses asynchronously — await this after stdin.write
 // and after rerender() before asserting.
@@ -205,4 +205,84 @@ describe("ToolsTab", () => {
     await tick();
     expect(onViewDetails).toHaveBeenCalledWith(tools[0]);
   });
+
+  describe("schema portability (#1005)", () => {
+    it("marks nothing when every tool's schema is portable", () => {
+      const { lastFrame } = render(
+        <ToolsTab tools={tools} isConnected={true} width={120} height={30} />,
+      );
+      const frame = lastFrame() ?? "";
+      expect(frame).not.toContain("Schema Portability");
+    });
+
+    it("flags an offending tool in the list and details it in the pane", () => {
+      const dirty = makeTool({
+        name: "info",
+        description: undefined,
+        outputSchema: { type: "object", properties: { data: true } },
+      } as Partial<Tool>);
+      const { lastFrame } = render(
+        <ToolsTab tools={[dirty]} isConnected={true} width={140} height={30} />,
+      );
+      const frame = lastFrame() ?? "";
+      // List row carries the error glyph…
+      expect(frame).toContain("info !");
+      // …and the detail pane names the path, issue and fix.
+      expect(frame).toContain("Schema Portability (1)");
+      expect(frame).toContain("outputSchema.properties.data");
+      expect(frame).toContain("Fix:");
+    });
+
+    it("uses the warning glyph when nothing is error-severity", () => {
+      const warned = makeTool({
+        name: "warned",
+        description: undefined,
+        inputSchema: {
+          type: "object",
+          properties: { a: { type: ["null", "boolean"] } },
+        },
+      } as Partial<Tool>);
+      const { lastFrame } = render(
+        <ToolsTab
+          tools={[warned]}
+          isConnected={true}
+          width={140}
+          height={30}
+        />,
+      );
+      const frame = lastFrame() ?? "";
+      expect(frame).toContain("warned ?");
+      expect(frame).toContain("Schema Portability (1)");
+    });
+  });
+});
+
+describe("schemaMarker", () => {
+  it("returns no glyph for undefined or empty findings", () => {
+    expect(schemaMarker(undefined)).toBeUndefined();
+    expect(schemaMarker([])).toBeUndefined();
+  });
+
+  it("prefers the error glyph when both severities are present", () => {
+    expect(
+      schemaMarker([
+        {
+          rule: "type-union",
+          severity: "warning",
+          schema: "inputSchema",
+          path: "",
+          issue: "i",
+          suggestion: "s",
+        },
+        {
+          rule: "boolean-schema",
+          severity: "error",
+          schema: "inputSchema",
+          path: "",
+          issue: "i",
+          suggestion: "s",
+        },
+      ]),
+    ).toEqual({ glyph: "!", color: "red" });
+  });
 });