TODO_DEFERRED: add D10 — tier 2 REPL tests for unpythonic.net

Counterpart to mcpyrate's D5.  Tier 1 for `unpythonic.net` will
use a server-in-thread + in-process client pattern with scripted
input via `builtins.input` monkey-patch and captured stdout/
stderr via `io.StringIO`.  Single-process, fast, no subprocess
boundary needed — the server speaks TCP to `127.0.0.1` and the
client loop runs in the same pytest process.

Tier 2 would spawn both client and server as real subprocesses,
driven through pseudo-terminals via `pexpect` / `ptyprocess`, to
catch things tier 1 cannot reach: real readline bindings,
terminal escape sequences, signal handling, and the `ptyproxy`
machinery itself end-to-end (tier 1 stubs around it by running
`InteractiveConsole` against in-memory streams).

POSIX-only naturally; Windows support depends on D9 (port
`unpythonic.net` to MS Windows) landing first.  Rough shape of
the eventual `pexpect`-based invocation included.

Entry ends with: "we might never need it."  Tier 1 already
exercises most of the protocol surface; tier 2 is a safety net
for terminal-semantics and signal-path bugs specifically.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Technologicat

TODO_DEFERRED.md

@@ -1,6 +1,6 @@
 # Deferred Issues
 
-Next unused item code: D10
+Next unused item code: D11
 
 - **D5**: `dispatch.py` — moved to GitHub issue #99. Dispatch-layer improvements for parametric ABCs (warn/error on indistinguishable multimethods). Typecheck-layer part resolved.
 
@@ -31,3 +31,34 @@ Next unused item code: D10
   **Related**: the `parse_and_bind` Darwin-branch fix in `net/client.py` (2026-04-15) was a prerequisite refactor — `net/client.py` is now in the right shape for the Windows port to plug into. Also, the three-tier hybrid readline fallback pattern documented in `raven.librarian.minichat` and `mcpyrate.repl.macropython` (same session) is directly reusable for `net/client.py` once `net/client.py`'s top-level `import readline` is moved inside the client function and guarded.
 
   (Added 2026-04-15, based on audit + discussion during the Windows-CI expansion session.)
+
+
+- **D10: Tier 2 REPL tests (subprocess + pty) for `unpythonic.net` client/server**: Tier 1 coverage for `unpythonic.net.client` and `unpythonic.net.server` uses a server-in-thread + in-process client pattern (see `unpythonic/net/tests/`) with scripted input via `builtins.input` monkey-patch and captured stdout/stderr via `io.StringIO`. Fast, single-process, no subprocess boundary needed — the server speaks TCP to `127.0.0.1` and the client loop runs in the same pytest process. **We might never need tier 2.**
+
+  A second tier would spawn the server and client as real subprocesses, with each end driven through a pseudo-terminal (`pexpect` / `ptyprocess`), to catch things tier 1 cannot reach:
+
+  - Real GNU-readline binding behaviour on the client side — tab completion against the remote completer, history recall, multi-line input rendering.
+  - Terminal escape sequences from the colorizer on both sides.
+  - Signal handling — Ctrl+C from the client forwarded to the remote REPL, Ctrl+D disconnecting cleanly.
+  - The ptyproxy machinery itself, end-to-end. Tier 1 stubs around the pty by running the `InteractiveConsole` directly against in-memory streams; tier 2 would actually exercise `unpythonic.net.ptyproxy.PTYSocketProxy` with a real master/slave pair.
+
+  Cost:
+  - ~0.5–1 s startup per test × two processes per test (client + server) = ~1–2 s per test. Matters for suite size.
+  - POSIX-only naturally. Windows support depends on D9 (port `unpythonic.net` to MS Windows) landing first — no point designing tier 2 for a subsystem that doesn't run on Windows yet. If/when D9 lands, Windows tier 2 can use the same ConPTY backend that D9 introduces.
+  - `pexpect` would become a new dev dep. Small but non-zero.
+
+  **Rough shape if we ever do it:**
+  ```python
+  import pexpect
+  server = pexpect.spawn(f"{sys.executable} -m unpythonic.net.server", ...)
+  server.expect(r"Listening on \S+")
+  client = pexpect.spawn(f"{sys.executable} -m unpythonic.net.client", ...)
+  client.expect(r">>> ")
+  client.sendline("2 + 3")
+  client.expect(r"5\s*\n>>> ")
+  client.sendcontrol("d")
+  client.expect(pexpect.EOF)
+  server.terminate()
+  ```
+
+  **When to actually do it**: only if tier 1 coverage turns out to miss something important (a regression hits prod that tier 1 would not have caught). The in-thread server + scripted client approach already exercises most of the protocol surface; tier 2 is primarily a safety net for terminal-semantics and signal-path bugs. Until one of those bites, tier 1 is the main win. (Added 2026-04-15, alongside the tier 1 bring-up.)