Fix Worker.run()'s --unix Windows dispatch: named pipe, not AF_UNIX

vgi.worker.Worker's _run() classmethod (the CLI entry point every
Worker subclass's `main()` goes through) called serve_unix()
unconditionally for --unix, regardless of platform - crashing outright
on Windows:

  AttributeError: module 'socket' has no attribute 'AF_UNIX'

(from vgi_rpc.rpc._transport.serve_unix's own
socket.socket(socket.AF_UNIX, ...) call, itself correct - AF_UNIX
genuinely doesn't exist in this code path on Windows, since CPython
has no socket.AF_UNIX there in general use).

This is a real, live bug, not theoretical: found via vgi-sqlite's own
Windows CI, whose launch: locations pass --unix a \\.\pipe\...-
formatted named pipe name on Windows (per docs/launcher-protocol.md's
own "Platform: Windows" section) - every Worker subclass fixture
(vgi-fixture-simple-writable-worker, vgi-sqlite's own row_transform
fixture) crashed near-instantly on startup as a result, while
vgi._test_fixtures.worker (used by the main vgi-fixture-worker,
built directly against vgi_rpc.rpc.run_server rather than this
classmethod) worked fine - because run_server (vgi_rpc/rpc/__init__.py)
already has the correct sys.platform == "win32" dispatch to
serve_named_pipe. This classmethod is a separate, parallel serving
path (it also handles Sentry/OTel setup and cls-specific worker
construction) that never got the same fix when run_server's was added,
so it silently diverged.

Fixed by mirroring run_server's own dispatch exactly: sys.platform ==
"win32" calls serve_named_pipe(server, unix, ...) and emits
"PIPE:<name>" on stdout; every other platform keeps the existing
serve_unix(server, os.path.abspath(unix), ...) / "UNIX:<path>" behavior
unchanged.

Not touched (a separate, narrower gap, not exercised by any of the
Windows CI failures this fix addresses): vgi/transactor/server.py's
own serve_unix() call, used only by the fuller `writable` fixture's
transactor subprocess (needs the optional transactor extra) - no test
currently reaches it on Windows.

Verified on a real Windows/MSVC box (europa): manually invoking
vgi-fixture-simple-writable-worker --unix \\.\pipe\... now correctly
emits "PIPE:\\.\pipe\..." instead of crashing. vgi-sqlite's full
Windows integration suite (test/integration, driving the built
extension via launch: locations for all three fixture workers)
re-run clean after this fix: 52 passed, 7 skipped (HTTP transport,
needs the http extra) - up from 17 failures (all in the
simple_writable- and row_transform-backed test files) before it.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GSuWTdDRYPk2TziYXR4GVV

Author: rustyconover

vgi/worker.py

@@ -1613,10 +1613,23 @@ def _run(
                     max_externalized_response_bytes=max_externalized_response_bytes,
                 )
             elif unix is not None:
-                # AF_UNIX launcher path.  Bind to the requested socket,
-                # print UNIX:<abs_path> on stdout, idle-shutdown after
-                # idle_timeout seconds.
-                from vgi_rpc.rpc import serve_unix
+                # AF_UNIX launcher path on POSIX; Windows has no
+                # socket.AF_UNIX in this code path, so --unix there
+                # carries a named-pipe name (\\.\pipe\...) instead - the
+                # launcher constructs whichever one is appropriate for the
+                # platform it's running on. Mirrors vgi_rpc.rpc.run_server's
+                # own platform dispatch (vgi_rpc/rpc/__init__.py) exactly -
+                # this classmethod has its own, separate serving path (not
+                # a call to run_server) because it also handles Sentry/OTel
+                # setup and cls-specific worker construction, but the
+                # transport-level platform choice must stay identical
+                # between the two, or a worker built against this
+                # classmethod (e.g. any vgi.worker.Worker subclass) crashes
+                # on Windows with "AttributeError: module 'socket' has no
+                # attribute 'AF_UNIX'" while one built directly against
+                # run_server works fine - confirmed as a real, live bug
+                # this way, not theoretical.
+                from vgi_rpc.rpc import serve_named_pipe, serve_unix
 
                 from vgi.serve import _maybe_init_sentry, _resolve_otel_config
 
@@ -1629,20 +1642,36 @@ def _run(
 
                     instrument_server(server, otel_config)
                     worker._vgi_tracer = VgiTracer.create(otel_config)
-                abs_path = os.path.abspath(unix)
                 effective_idle = idle_timeout if idle_timeout > 0 else None
 
-                def _emit(bound: str) -> None:
-                    print(f"UNIX:{bound}", flush=True)
+                if sys.platform == "win32":
+                    pipe_name = unix
 
-                serve_unix(
-                    server,
-                    abs_path,
-                    threaded=True,
-                    max_connections=max_connections,
-                    idle_timeout=effective_idle,
-                    on_bound=_emit,
-                )
+                    def _emit(bound: str) -> None:
+                        print(f"PIPE:{bound}", flush=True)
+
+                    serve_named_pipe(
+                        server,
+                        pipe_name,
+                        threaded=True,
+                        max_connections=max_connections,
+                        idle_timeout=effective_idle,
+                        on_bound=_emit,
+                    )
+                else:
+                    abs_path = os.path.abspath(unix)
+
+                    def _emit(bound: str) -> None:
+                        print(f"UNIX:{bound}", flush=True)
+
+                    serve_unix(
+                        server,
+                        abs_path,
+                        threaded=True,
+                        max_connections=max_connections,
+                        idle_timeout=effective_idle,
+                        on_bound=_emit,
+                    )
             elif tcp is not None:
                 # TCP launcher path.  Bind to [HOST:]PORT, print
                 # TCP:<host>:<port> on stdout (mirrors run_server's