agentirc-cli 6.2.0__tar.gz → 6.2.2__tar.gz

{agentirc_cli-6.2.0 → agentirc_cli-6.2.2}/CHANGELOG.md

@@ -4,6 +4,29 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [6.2.2] - 2026-04-14
+
+
+### Fixed
+
+- console: handle BrokenPipeError/ConnectionResetError in _send_raw; surface a red system notice in the chat panel instead of letting the asyncio task crash (#230)
+
+## [6.2.1] - 2026-04-13
+
+
+### Added
+
+- Copy-paste guidance in help screen (Shift+drag bypasses TUI mouse capture in modern terminals)
+
+
+### Fixed
+
+- #227: Tab now cycles channels (added priority=True to override Textual Screen focus-cycling)
+- #226: Alt+Left/Right jump by word in chat input; Alt+Backspace deletes previous word
+- #225: `culture channel message` interprets literal \n, \t, and \\ (escape-an-escape); observer splits multi-line text into one PRIVMSG per line and rejects all-empty-after-interpretation input with a non-zero exit
+- #224: Exiting overview now reloads the current channel history (was empty)
+- Help screen now opens on F1 (Ctrl+H stays as secondary — most terminals forward it as Backspace)
+
 ## [6.2.0] - 2026-04-12
 
 

{agentirc_cli-6.2.0 → agentirc_cli-6.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentirc-cli
-Version: 6.2.0
+Version: 6.2.2
 Summary: Legacy alias for culture — install culture instead
 Project-URL: Homepage, https://github.com/OriNachum/culture
 Author: Ori Nachum

{agentirc_cli-6.2.0 → agentirc_cli-6.2.2}/culture/cli/channel.py

@@ -208,6 +208,40 @@ def _cmd_read(args: argparse.Namespace) -> None:
         print(msg)
 
 
+def _interpret_escapes(text: str) -> str:
+    """Convert shell-literal ``\\n`` / ``\\t`` / ``\\\\`` sequences to real chars.
+
+    Walks the string left-to-right so a preceding backslash escapes the next
+    character — ``\\\\n`` stays as the two chars ``\\`` + ``n``, while ``\\n``
+    becomes a real newline. Supported escapes: ``\\n`` → newline, ``\\t`` →
+    tab, ``\\\\`` → single backslash. Any other ``\\x`` pair is passed through
+    unchanged so we don't surprise users with ``\\x..`` / ``\\u....`` style
+    interpretation that ``codecs.decode(..., "unicode_escape")`` would do.
+    """
+    out: list[str] = []
+    i = 0
+    n = len(text)
+    while i < n:
+        ch = text[i]
+        if ch == "\\" and i + 1 < n:
+            nxt = text[i + 1]
+            if nxt == "n":
+                out.append("\n")
+                i += 2
+                continue
+            if nxt == "t":
+                out.append("\t")
+                i += 2
+                continue
+            if nxt == "\\":
+                out.append("\\")
+                i += 2
+                continue
+        out.append(ch)
+        i += 1
+    return "".join(out)
+
+
 def _cmd_message(args: argparse.Namespace) -> None:
     if not args.target.strip():
         print("Error: channel name cannot be empty", file=sys.stderr)
@@ -216,14 +250,23 @@ def _cmd_message(args: argparse.Namespace) -> None:
         print("Error: message text cannot be empty", file=sys.stderr)
         sys.exit(1)
     target = args.target if args.target.startswith("#") else f"#{args.target}"
+    text = _interpret_escapes(args.text)
+
+    # After escape interpretation, reject input that has no non-empty line —
+    # otherwise we'd print "Sent to ..." while nothing actually goes out.
+    if not any(line.strip() for line in text.split("\n")):
+        print(
+            "Error: message text has no non-empty line after escape interpretation", file=sys.stderr
+        )
+        sys.exit(1)
 
-    resp = _try_ipc("irc_send", channel=target, message=args.text)
+    resp = _try_ipc("irc_send", channel=target, message=text)
     if resp and resp.get("ok"):
         print(f"Sent to {target}")
         return
 
     observer = get_observer(args.config)
-    asyncio.run(observer.send_message(target, args.text))
+    asyncio.run(observer.send_message(target, text))
     print(f"Sent to {target}")
 
 

{agentirc_cli-6.2.0 → agentirc_cli-6.2.2}/culture/console/app.py

@@ -13,7 +13,7 @@ from textual.containers import Horizontal
 from textual.widgets import Footer, Header
 
 from culture.aio import maybe_await
-from culture.console.client import ConsoleIRCClient
+from culture.console.client import ConsoleConnectionLost, ConsoleIRCClient
 from culture.console.commands import CommandType, parse_command
 from culture.console.status import query_all_agents
 from culture.console.widgets.chat import ChatPanel
@@ -35,11 +35,15 @@ class ConsoleApp(App):
     BINDINGS = [
         Binding("ctrl+o", "show_overview", "Overview", show=True),
         Binding("ctrl+s", "show_status", "Status", show=True),
-        Binding("ctrl+h", "show_help", "Help", show=True),
+        Binding("f1", "show_help", "Help", show=True),
+        # Most terminals send 0x08 (backspace) for Ctrl+H, so this secondary
+        # bind only fires under terminals with modifyOtherKeys enabled.
+        Binding("ctrl+h", "show_help", "Help", show=False),
         Binding("escape", "back_to_chat", "Chat", show=True),
         Binding("ctrl+q", "quit_app", "Quit", show=True),
-        Binding("tab", "next_channel", "Next channel", show=False),
-        Binding("shift+tab", "prev_channel", "Prev channel", show=False),
+        # priority=True so Tab wins against Screen's default focus-cycling.
+        Binding("tab", "next_channel", "Next channel", show=False, priority=True),
+        Binding("shift+tab", "prev_channel", "Prev channel", show=False, priority=True),
     ]
 
     DEFAULT_CSS = """
@@ -70,6 +74,10 @@ class ConsoleApp(App):
         self._background_tasks: set[asyncio.Task] = set()
         self._status_poll_task: asyncio.Task | None = None
 
+        # Once the connection drops, show the "connection lost" notice exactly
+        # once — subsequent failing commands/channel-switches stay quiet.
+        self._connection_lost_notified: bool = False
+
         # Dispatch table for command execution
         self._command_handlers: dict[CommandType, Any] = {
             CommandType.CHAT: self._handle_chat,
@@ -201,13 +209,29 @@ class ConsoleApp(App):
     async def _execute_command(self, cmd) -> None:  # noqa: ANN001
         """Dispatch a ParsedCommand to the appropriate handler."""
         handler = self._command_handlers.get(cmd.type)
-        if handler:
-            await maybe_await(handler(cmd))
-        elif cmd.type in (CommandType.START, CommandType.STOP, CommandType.RESTART):
-            self._handle_agent_management(cmd)
-        elif cmd.type == CommandType.UNKNOWN:
-            chat: ChatPanel = self.query_one(ChatPanel)
-            chat.add_message(time.time(), "", "system", f"[red]Unknown command: {cmd.text}[/]")
+        try:
+            if handler:
+                await maybe_await(handler(cmd))
+            elif cmd.type in (CommandType.START, CommandType.STOP, CommandType.RESTART):
+                self._handle_agent_management(cmd)
+            elif cmd.type == CommandType.UNKNOWN:
+                chat: ChatPanel = self.query_one(ChatPanel)
+                chat.add_message(time.time(), "", "system", f"[red]Unknown command: {cmd.text}[/]")
+        except ConsoleConnectionLost:
+            self._notify_connection_lost()
+
+    def _notify_connection_lost(self) -> None:
+        """Post the 'connection lost' notice once per disconnect."""
+        if self._connection_lost_notified:
+            return
+        self._connection_lost_notified = True
+        chat: ChatPanel = self.query_one(ChatPanel)
+        chat.add_message(
+            time.time(),
+            "",
+            "system",
+            "[red]Connection to server lost. Restart the console to reconnect.[/]",
+        )
 
     # ------------------------------------------------------------------
     # Command handlers
@@ -413,11 +437,19 @@ class ConsoleApp(App):
             "[bold $warning]KEYBINDINGS[/]",
             "",
             "  [bold]Tab / Shift+Tab[/]        Cycle channels",
+            "  [bold]Alt+←/→[/]                Jump by word in input",
+            "  [bold]Alt+Backspace[/]          Delete previous word",
             "  [bold]Ctrl+O[/]                 Overview",
             "  [bold]Ctrl+S[/]                 Status",
-            "  [bold]Ctrl+H[/]                 Help",
+            "  [bold]F1[/]                     Help (Ctrl+H on terminals that forward it)",
             "  [bold]Escape[/]                 Back to chat",
             "  [bold]Ctrl+Q[/]                 Quit",
+            "",
+            "[bold $warning]COPY-PASTE[/]",
+            "",
+            "  Hold [bold]Shift[/] while dragging with the mouse to select text for copy-paste.",
+            "  Most modern terminals (iTerm2, Kitty, Alacritty, WezTerm, GNOME Terminal,",
+            "  Windows Terminal) let Shift bypass the TUI's mouse capture.",
         ]
         chat.set_content("Help", lines)
 
@@ -567,15 +599,17 @@ class ConsoleApp(App):
         ]
         sidebar.entities = entity_items
 
-    def action_back_to_chat(self) -> None:
-        """Return to the normal chat view."""
+    async def action_back_to_chat(self) -> None:
+        """Return to the normal chat view, reloading current channel history."""
         if self._current_view == "chat":
             return
+        if self._current_channel:
+            # Delegate: resets view, shows input, and reloads recent history —
+            # equivalent to running /read on the current channel.
+            await self._switch_to_channel(self._current_channel)
+            return
+        # No channel yet — just restore chat view and show the input.
         self._current_view = "chat"
-        chat: ChatPanel = self.query_one(ChatPanel)
-        chat.set_channel(self._current_channel)
-
-        # Re-show input
         try:
             input_widget = self.query_one(self._CHAT_INPUT_ID)
             input_widget.display = True
@@ -675,7 +709,11 @@ class ConsoleApp(App):
             pass
 
         # Fetch recent history
-        entries = await self._client.history(channel, limit=20)
+        try:
+            entries = await self._client.history(channel, limit=20)
+        except ConsoleConnectionLost:
+            self._notify_connection_lost()
+            return
         # Stale check: if user switched away during fetch, discard results
         if self._current_channel != channel:
             return

{agentirc_cli-6.2.0 → agentirc_cli-6.2.2}/culture/console/client.py

@@ -24,6 +24,10 @@ QUERY_TIMEOUT = 10.0
 REGISTER_TIMEOUT = 15.0
 
 
+class ConsoleConnectionLost(ConnectionError):
+    """Raised by ConsoleIRCClient when the underlying socket is broken mid-send."""
+
+
 @dataclass
 class ChatMessage:
     """A buffered chat message from a channel or DM."""
@@ -100,35 +104,49 @@ class ConsoleIRCClient:
             timeout=REGISTER_TIMEOUT,
         )
 
-        await self._send_raw(f"NICK {self.nick}")
-        await self._send_raw(f"USER {self.nick} 0 * :{self.nick}")
-
-        # Wait for RPL_WELCOME (001) before proceeding
-        welcome_future: asyncio.Future[Message] = asyncio.get_running_loop().create_future()
-        self._pending["001"] = welcome_future
+        try:
+            await self._send_raw(f"NICK {self.nick}")
+            await self._send_raw(f"USER {self.nick} 0 * :{self.nick}")
 
-        # Start the read loop so the future can be resolved
-        self._read_task = asyncio.create_task(self._read_loop())
+            # Wait for RPL_WELCOME (001) before proceeding
+            welcome_future: asyncio.Future[Message] = asyncio.get_running_loop().create_future()
+            self._pending["001"] = welcome_future
 
-        try:
-            await asyncio.wait_for(welcome_future, timeout=REGISTER_TIMEOUT)
-        except asyncio.TimeoutError:
-            self._pending.clear()
-            if self._read_task:
-                self._read_task.cancel()
-            if self._writer:
-                self._writer.close()
-                self._writer = None
-                self._reader = None
-            raise ConnectionError("Timed out waiting for server welcome (001)")
+            # Start the read loop so the future can be resolved
+            self._read_task = asyncio.create_task(self._read_loop())
 
-        # Set user mode
-        if self.mode:
-            await self._send_raw(f"MODE {self.nick} +{self.mode}")
+            try:
+                await asyncio.wait_for(welcome_future, timeout=REGISTER_TIMEOUT)
+            except asyncio.TimeoutError as e:
+                raise ConnectionError("Timed out waiting for server welcome (001)") from e
+
+            # Set user mode
+            if self.mode:
+                await self._send_raw(f"MODE {self.nick} +{self.mode}")
+
+            # Send ICON if provided
+            if self.icon:
+                await self._send_raw(f"ICON {self.icon}")
+        except BaseException:
+            # Any failure after open_connection: tear down the half-open state.
+            await self._teardown_connection()
+            raise
 
-        # Send ICON if provided
-        if self.icon:
-            await self._send_raw(f"ICON {self.icon}")
+    async def _teardown_connection(self) -> None:
+        """Close writer, cancel reader, clear pending futures. Idempotent."""
+        self._pending.clear()
+        if self._read_task:
+            self._read_task.cancel()
+            await asyncio.gather(self._read_task, return_exceptions=True)
+            self._read_task = None
+        if self._writer:
+            try:
+                self._writer.close()
+                await self._writer.wait_closed()
+            except OSError:
+                pass
+        self._writer = None
+        self._reader = None
 
     async def disconnect(self) -> None:
         """Send QUIT and close the connection."""
@@ -186,18 +204,24 @@ class ConsoleIRCClient:
         Returns a sorted list of channel names.
         """
         key = "LIST"
+        pending_key = "323"
         self._collect_buffers[key] = []
         end_future: asyncio.Future[None] = asyncio.get_running_loop().create_future()
-        self._pending["323"] = end_future
+        self._pending[pending_key] = end_future
 
-        await self._send_raw("LIST")
+        try:
+            await self._send_raw("LIST")
+        except ConsoleConnectionLost:
+            self._pending.pop(pending_key, None)
+            self._collect_buffers.pop(key, None)
+            raise
 
         try:
             await asyncio.wait_for(end_future, timeout=QUERY_TIMEOUT)
         except asyncio.TimeoutError:
             pass
         finally:
-            self._pending.pop("323", None)
+            self._pending.pop(pending_key, None)
 
         channels = self._collect_buffers.pop(key, [])
         return sorted(channels)
@@ -208,18 +232,24 @@ class ConsoleIRCClient:
         Returns a list of dicts with nick, user, host, server, flags, realname.
         """
         key = f"WHO {target}"
+        pending_key = f"315:{target}"
         self._collect_buffers[key] = []
         end_future: asyncio.Future[None] = asyncio.get_running_loop().create_future()
-        self._pending[f"315:{target}"] = end_future
+        self._pending[pending_key] = end_future
 
-        await self._send_raw(f"WHO {target}")
+        try:
+            await self._send_raw(f"WHO {target}")
+        except ConsoleConnectionLost:
+            self._pending.pop(pending_key, None)
+            self._collect_buffers.pop(key, None)
+            raise
 
         try:
             await asyncio.wait_for(end_future, timeout=QUERY_TIMEOUT)
         except asyncio.TimeoutError:
             pass
         finally:
-            self._pending.pop(f"315:{target}", None)
+            self._pending.pop(pending_key, None)
 
         entries = self._collect_buffers.pop(key, [])
         return entries
@@ -230,18 +260,24 @@ class ConsoleIRCClient:
         Returns a list of dicts with channel, nick, timestamp, text.
         """
         key = f"HISTORY {channel}"
+        pending_key = f"HISTORYEND:{channel}"
         self._collect_buffers[key] = []
         end_future: asyncio.Future[None] = asyncio.get_running_loop().create_future()
-        self._pending[f"HISTORYEND:{channel}"] = end_future
+        self._pending[pending_key] = end_future
 
-        await self._send_raw(f"HISTORY RECENT {channel} {limit}")
+        try:
+            await self._send_raw(f"HISTORY RECENT {channel} {limit}")
+        except ConsoleConnectionLost:
+            self._pending.pop(pending_key, None)
+            self._collect_buffers.pop(key, None)
+            raise
 
         try:
             await asyncio.wait_for(end_future, timeout=QUERY_TIMEOUT)
         except asyncio.TimeoutError:
             pass
         finally:
-            self._pending.pop(f"HISTORYEND:{channel}", None)
+            self._pending.pop(pending_key, None)
 
         entries = self._collect_buffers.pop(key, [])
         return entries
@@ -252,9 +288,15 @@ class ConsoleIRCClient:
 
     async def _send_raw(self, line: str) -> None:
         """Write a raw IRC line to the socket."""
-        if self._writer:
+        if not self._writer:
+            return
+        try:
             self._writer.write(f"{line}\r\n".encode())
             await self._writer.drain()
+        except (BrokenPipeError, ConnectionResetError, ConnectionAbortedError) as e:
+            self.connected = False
+            logger.warning("ConsoleIRCClient: send failed (%s)", e.__class__.__name__)
+            raise ConsoleConnectionLost(str(e)) from e
 
     async def _read_loop(self) -> None:
         """Background task: read lines from socket and dispatch to _handle."""

{agentirc_cli-6.2.0 → agentirc_cli-6.2.2}/culture/console/widgets/chat.py

@@ -5,12 +5,35 @@ from __future__ import annotations
 from datetime import datetime
 
 from textual.app import ComposeResult
+from textual.binding import Binding
 from textual.containers import Vertical
 from textual.message import Message
 from textual.widget import Widget
 from textual.widgets import Input, RichLog, Static
 
 
+class ChatInput(Input):
+    """Input with Alt+Arrow word-jump and Alt+Backspace word-delete."""
+
+    BINDINGS = [
+        Binding("alt+left", "cursor_left_word", "Word left", show=False),
+        Binding("alt+right", "cursor_right_word", "Word right", show=False),
+        Binding(
+            "alt+shift+left",
+            "cursor_left_word(True)",
+            "Select word left",
+            show=False,
+        ),
+        Binding(
+            "alt+shift+right",
+            "cursor_right_word(True)",
+            "Select word right",
+            show=False,
+        ),
+        Binding("alt+backspace", "delete_left_word", "Delete word", show=False),
+    ]
+
+
 class ChatPanel(Widget):
     """Center panel showing the message log and an input field.
 
@@ -75,7 +98,7 @@ class ChatPanel(Widget):
         yield Static("", id="chat-header")
         with Vertical():
             yield RichLog(id="chat-log", markup=True, wrap=True, highlight=False)
-        yield Input(placeholder="Type a message or /command…", id="chat-input")
+        yield ChatInput(placeholder="Type a message or /command…", id="chat-input")
 
     def on_mount(self) -> None:
         self._channel = ""

{agentirc_cli-6.2.0 → agentirc_cli-6.2.2}/culture/observer.py

@@ -205,11 +205,23 @@ class IRCObserver:
     async def send_message(self, target: str, text: str) -> None:
         """Send a PRIVMSG to a channel or nick, then disconnect.
 
+        ``text`` is split on real ``\\n`` bytes into one PRIVMSG per line,
+        since an IRC PRIVMSG must be single-line per RFC 2812. Empty lines
+        (and any embedded ``\\r``) are dropped — IRC can't carry an empty
+        PRIVMSG body, and this keeps multi-line output from emitting no-op
+        frames. If every line is empty, the method returns without
+        connecting.
+
         Uses the same ephemeral connection pattern as the read commands.
         """
-        # Sanitize CR/LF to prevent IRC command injection
+        # Strip CR and LF from the target to prevent IRC command injection
+        # (a newline in the target would let an attacker smuggle a second
+        # protocol line).
         target = target.replace("\r", "").replace("\n", "")
-        text = text.replace("\r", "").replace("\n", " ")
+        # Split on real newlines; drop empty lines and strip CRs
+        lines = [ln for ln in text.replace("\r", "").split("\n") if ln]
+        if not lines:
+            return
 
         reader, writer, nick = await self._connect_and_register()
         try:
@@ -220,7 +232,8 @@ class IRCObserver:
                 # Drain join responses
                 await self._recv_lines(reader, timeout=1.0)
 
-            writer.write(f"PRIVMSG {target} :{text}\r\n".encode())
+            for line in lines:
+                writer.write(f"PRIVMSG {target} :{line}\r\n".encode())
             await writer.drain()
         finally:
             await self._disconnect(writer)

{agentirc_cli-6.2.0 → agentirc_cli-6.2.2}/docs/reference/cli/index.md

@@ -244,6 +244,23 @@ culture channel message "#general" "hello from the CLI"
 
 Uses an ephemeral IRC connection — no daemon required.
 
+**Multi-line messages.** The message text interprets `\n` as a newline and
+`\t` as a tab, so the shell can pass multi-line input without needing
+`$'...'` quoting. Each line is sent as a separate IRC `PRIVMSG` (required by
+RFC 2812 — a single `PRIVMSG` can't span lines). Empty lines are dropped.
+
+```bash
+culture channel message "#general" "line one\nline two\nline three"
+# → three separate PRIVMSG lines on the channel
+```
+
+To send a literal backslash-n (two characters) escape the backslash:
+
+```bash
+culture channel message "#general" "use \\n in your string"
+# → sends the text: use \n in your string
+```
+
 ### `culture agent message`
 
 Send a message directly to an agent.

{agentirc_cli-6.2.0 → agentirc_cli-6.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentirc-cli"
-version = "6.2.0"
+version = "6.2.2"
 description = "Legacy alias for culture — install culture instead"
 readme = "README.md"
 license = "MIT"

{agentirc_cli-6.2.0 → agentirc_cli-6.2.2}/tests/test_console_client.py

@@ -10,7 +10,7 @@ import asyncio
 
 import pytest
 
-from culture.console.client import ChatMessage, ConsoleIRCClient
+from culture.console.client import ChatMessage, ConsoleConnectionLost, ConsoleIRCClient
 
 # ---------------------------------------------------------------------------
 # Helpers
@@ -296,3 +296,101 @@ async def test_history_returns_messages(server, make_client):
     assert any(e.get("text") == "history test message" for e in entries)
 
     await client.disconnect()
+
+
+# ---------------------------------------------------------------------------
+# Broken-pipe handling (issue #230)
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_send_raw_raises_console_connection_lost_when_socket_broken(server):
+    """Writes to a broken socket surface as ConsoleConnectionLost, not BrokenPipeError.
+
+    Reproduces issue #230: iTerm / idle disconnects caused asyncio's
+    `StreamWriter.drain()` to raise `BrokenPipeError` which was never caught,
+    crashing the console command task. The fix wraps the write in
+    `_send_raw` and re-raises a typed `ConsoleConnectionLost`.
+    """
+    nick = "testserv-pipetest"
+    client = make_console_client(server, nick=nick)
+    await client.connect()
+    assert client.connected is True
+
+    # Force-close the server side of this client's socket. The server
+    # retains the asyncio StreamWriter on its Client object; closing it
+    # sends FIN to the console client and the next drain() there fails.
+    server_client = server.clients[nick]
+    server_client.writer.close()
+    try:
+        await server_client.writer.wait_closed()
+    except OSError:
+        pass
+
+    # Repeated writes are required — the first drain() often succeeds because
+    # data lands in the local kernel buffer before the RST is observed.
+    with pytest.raises(ConsoleConnectionLost):
+        for _ in range(20):
+            await client.send_privmsg("#nowhere", "x" * 512)
+            await asyncio.sleep(0.02)
+
+    assert client.connected is False
+    await client.disconnect()
+
+
+@pytest.mark.asyncio
+async def test_history_cleans_up_pending_buffers_on_connection_lost(server):
+    """A failed history() send must not leak _pending / _collect_buffers entries."""
+    nick = "testserv-histleak"
+    client = make_console_client(server, nick=nick)
+    await client.connect()
+
+    # Break the socket from the server side.
+    server.clients[nick].writer.close()
+    try:
+        await server.clients[nick].writer.wait_closed()
+    except OSError:
+        pass
+
+    # Drain writes until ConsoleConnectionLost is raised by history().
+    raised = False
+    for _ in range(20):
+        try:
+            await client.history("#ghost", limit=5)
+        except ConsoleConnectionLost:
+            raised = True
+            break
+        await asyncio.sleep(0.02)
+
+    assert raised, "history() should eventually raise ConsoleConnectionLost"
+    # No stale state left behind — would otherwise hang future queries / leak memory.
+    assert "HISTORYEND:#ghost" not in client._pending
+    assert "HISTORY #ghost" not in client._collect_buffers
+    await client.disconnect()
+
+
+@pytest.mark.asyncio
+async def test_connect_cleans_up_on_registration_failure(monkeypatch, server):
+    """A ConsoleConnectionLost mid-registration must close the writer, not leak it."""
+    client = make_console_client(server, nick="testserv-leaktest")
+
+    # Simulate a server drop between open_connection and the first NICK write.
+    original_send_raw = client._send_raw
+    calls = {"n": 0}
+
+    async def failing_send_raw(line: str) -> None:
+        calls["n"] += 1
+        if calls["n"] == 1:
+            raise ConsoleConnectionLost("simulated drop during registration")
+        await original_send_raw(line)
+
+    monkeypatch.setattr(client, "_send_raw", failing_send_raw)
+
+    with pytest.raises(ConsoleConnectionLost):
+        await client.connect()
+
+    # After failure, no half-open socket or dangling state.
+    assert client._writer is None
+    assert client._reader is None
+    assert client._read_task is None
+    assert client._pending == {}