agentirc-cli 6.2.1__tar.gz → 6.2.3__tar.gz

agentirc_cli-6.2.3/.claude/agents/doc-test-alignment.md

@@ -0,0 +1,154 @@
+---
+name: doc-test-alignment
+description: Audits a staged/branch diff for new public API surface (exceptions, classes, public functions, CLI commands, IRC protocol verbs, backend config fields) and reports whether `docs/` and `protocol/extensions/` mention them. Use at the end of a plan, before the first push, or when the user says "doc audit", "doc-test alignment", "check docs coverage".
+tools: Read, Grep, Glob, Bash
+model: sonnet
+color: cyan
+---
+
+# Doc-Test Alignment Auditor
+
+You audit a code change for **doc drift**: new public API surface that
+`docs/` doesn't mention. Run at the end of a plan (after tests pass, before
+push). Your job is to surface omissions, not to write docs.
+
+## Step 1 — Determine the diff
+
+If the caller passed a specific ref or file list, use that. Otherwise, audit
+the current branch against `main`:
+
+```bash
+git diff --name-only main...HEAD
+git diff main...HEAD -- '*.py' 'culture/cli/*' 'culture/agentirc/*'
+```
+
+If the branch has no commits ahead of `main`, fall back to staged changes:
+
+```bash
+git diff --cached --name-only
+git diff --cached -- '*.py'
+```
+
+If neither yields a diff, report "no changes to audit" and stop.
+
+## Step 2 — Extract new public API surface
+
+Run the patterns via the **Grep tool** (ripgrep / Rust regex engine — the
+Claude Code default). Patterns below are written in the Rust regex flavor
+that ripgrep accepts without any extra flags: `\s`, `(?:...)`, and character
+classes all work as written. Do **not** pipe these into POSIX `grep` / BRE
+— they will silently fail to match.
+
+Save the diff first, then search it:
+
+```bash
+git diff main...HEAD -- '*.py' 'culture/cli/*' 'culture/agentirc/*' > /tmp/branch-diff.patch
+```
+
+Then feed `/tmp/branch-diff.patch` to the Grep tool with each pattern below.
+
+| Surface type | Ripgrep pattern |
+|--------------|-----------------|
+| New exception class | `^\+class [A-Z][A-Za-z0-9_]*(\(.*(?:Error\|Exception).*\))?:` |
+| New public class | `^\+class [A-Z][A-Za-z0-9_]*` (exclude leading `_`) |
+| New public function | `^\+(async )?def [a-z][a-z0-9_]*\(` (exclude leading `_`) |
+| New CLI command | `^\+.*add_parser\(['"]` in `culture/cli/` |
+| New IRC verb | `^\+.*(_msg_handlers\[['"]\|commands\s*=).*['"][A-Z0-9]+['"]` |
+| New config field | `^\+.*@dataclass` or `^\+\s+[a-z_]+:\s+[A-Z].*=` in config modules |
+
+Ignore private symbols (leading `_`), test helpers (inside `tests/`), and
+internal-only classes (docstring contains "internal" or "private").
+
+List every match with:
+
+- symbol name
+- file path + starting line
+- kind (exception / class / function / CLI command / IRC verb / config field)
+
+## Step 3 — Check doc coverage
+
+For each extracted symbol, grep the documentation tree for a mention:
+
+```bash
+grep -r -l '<symbol>' docs/ protocol/extensions/ 2>/dev/null
+```
+
+Match rules:
+
+- **Exception**: must be referenced in at least one `docs/**/*.md` page. If
+  it's a new public exception raised across module boundaries, that's a
+  stronger obligation — flag loudly.
+- **CLI command**: must appear in `docs/` (user-facing command reference)
+  AND in the command's own module docstring.
+- **IRC verb / protocol extension**: MUST have a page under
+  `protocol/extensions/` (per the repository-root `CLAUDE.md`: "Extensions
+  use new verbs (never redefine existing commands), documented in
+  `protocol/extensions/`").
+- **Config field**: must appear in the relevant backend's `culture.yaml`
+  reference under `packages/agent-harness/culture.yaml` or
+  `docs/configuration.md`.
+- **Public function/class**: soft obligation — flag if the symbol is
+  imported from outside its module, skip if it's used only within its
+  package.
+
+## Step 4 — Check test coverage (light)
+
+For each public surface symbol, grep `tests/` for at least one reference:
+
+```bash
+grep -r -l '<symbol>' tests/ 2>/dev/null
+```
+
+If zero test files reference the symbol, flag it. This is a weak signal —
+the caller may have tested behavior without naming the symbol directly.
+Report as "likely untested" rather than "untested".
+
+## Step 5 — All-backends check (culture-specific)
+
+If the diff touches `culture/clients/<backend>/` OR `packages/agent-harness/`,
+list the other backends (`claude`, `codex`, `copilot`, `acp`) and report
+whether the same change appears in each. This enforces the project's
+"all-backends rule" (per the repository-root `CLAUDE.md`). A change in
+only one backend is a bug.
+
+## Step 6 — Report
+
+Output a concise table. Factual only: what symbols, what's missing,
+what's drifted. Do **not** write prose narration and do **not** suggest
+what the docs should say — leave doc wording to the caller. A brief
+counts-only summary line at the end is fine; skip it if everything is
+clean.
+
+```text
+## Doc-Test Alignment — <branch> vs main
+
+### New public API surface
+| Symbol | Kind | Location | Docs | Tests |
+|--------|------|----------|------|-------|
+| ConsoleConnectionLost | exception | culture/console/client.py:42 | MISSING | test_console_client.py |
+| _handle_reconnect | private | culture/console/app.py:412 | (skip — private) | — |
+
+### Protocol extensions
+(none in this diff)
+
+### All-backends drift
+Change touches `packages/agent-harness/irc_transport.py`:
+- claude: ✓ updated
+- codex: ✓ updated
+- copilot: ✗ NOT updated (divergent)
+- acp: ✗ NOT updated (divergent)
+
+### Summary
+Doc gaps: 1 · Likely untested: 0 · Backend drift: 2
+```
+
+If nothing is missing, output one line: `Doc-test alignment clean — no gaps detected.`
+
+## What NOT to do
+
+- Do not write documentation. Report gaps only.
+- Do not modify code or tests.
+- Do not fail loudly on borderline cases (internal-only helpers, test
+  utilities) — the caller is smarter than the heuristics; your value is in
+  catching the obvious omissions.
+- Do not re-run the test suite — `/run-tests` is the tool for that.

{agentirc_cli-6.2.1 → agentirc_cli-6.2.3}/.claude/skills/pr-review/SKILL.md

@@ -171,7 +171,15 @@ bash ~/.claude/skills/pr-review/scripts/pr-reply.sh --resolve <PR_NUMBER> <COMME
 - Always use `--resolve` to resolve the thread after replying
 - Every comment must get a reply — no silent fixes
 
-## Step 9 — Wait for merge
+## Step 9 — Check SonarCloud before declaring ready
+
+After CI is green and all inline threads are resolved, query SonarCloud
+for the branch via the `/sonarclaude` skill. SonarCloud findings do not
+always arrive as inline PR comments — a fully-resolved thread list plus an
+all-green `gh pr checks` is **not** sufficient evidence that the PR is
+clean. If `/sonarclaude` surfaces new findings, loop back to Step 7.
+
+## Step 10 — Wait for merge
 
 **Never merge the PR yourself.** The PR is merged manually on the GitHub site.
 

{agentirc_cli-6.2.1 → agentirc_cli-6.2.3}/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [6.2.3] - 2026-04-15
+
+
+### Changed
+
+- docs: post-#231 retrospective — CLAUDE.md guidance for pre-branch checklist, format-before-commit, pre-push code review, SonarCloud pre-ready; new doc-test-alignment subagent; /pr-review skill step for SonarCloud query
+
+## [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
 
 

{agentirc_cli-6.2.1 → agentirc_cli-6.2.3}/CLAUDE.md

@@ -49,13 +49,18 @@ Each backend has its own `culture.yaml` in `culture/clients/<backend>/`.
 
 When implementing features, write a corresponding markdown doc in `docs/` describing the feature — its purpose, usage, and any protocol details. Keep `docs/` as the living reference for the project.
 
+Before the first push on a branch that adds public API surface (new exceptions, CLI commands, IRC verbs, backend config fields), invoke the `doc-test-alignment` subagent to surface doc gaps: `Agent(subagent_type="doc-test-alignment", ...)`. It reads the branch diff and reports missing `docs/` coverage, missing protocol extension pages, and all-backends drift — it does not write docs, only flags omissions.
+
 ## Git Workflow
 
+- **Before branching, run `git status`.** If `CHANGELOG.md`, any `CLAUDE.md`, or other files carry pre-existing unstaged changes on `main`, decide up front whether to stash, commit separately, or hand-split. `/version-bump` inserts a new section at the top of `CHANGELOG.md` and will interleave awkwardly with an existing `[Unreleased]` block if you don't.
 - Branch out for all changes
-- **Bump the version before creating a PR** — use `/version-bump patch` (bug fix), `minor` (new feature), or `major` (breaking change). This updates `pyproject.toml`, `culture/__init__.py`, and `CHANGELOG.md` in one step. Forgetting will fail the version-check CI job.
+- **Bump the version before creating a PR** — use `/version-bump patch` (bug fix), `minor` (new feature), or `major` (breaking change). This updates `pyproject.toml` and `CHANGELOG.md` (and `uv.lock` when applicable) in one step. Forgetting will fail the version-check CI job.
+- **Pre-push review for library/protocol code.** When the diff touches shared choke points (transport, `_send_raw`-style I/O, protocol parsers, anything in `packages/` or `culture/agentirc/`), invoke a code reviewer on the staged diff before the first push — typed exceptions and new error paths routinely create caller cleanup obligations that Qodo/human reviewers otherwise surface in the first review round. Use `Agent(subagent_type="superpowers:code-reviewer", ...)` or `/review-and-fix`.
 - Push to GitHub for agentic code review
 - Pull review comments, address feedback, push fixes
 - Reply to comments after pushing, resolve threads
+- **Before declaring the PR ready**, check SonarCloud for the branch via the `/sonarclaude` skill. SonarCloud findings do not always arrive as inline PR comments, so an all-green `gh pr checks` + all-resolved threads is not sufficient.
 
 ## Testing
 
@@ -64,6 +69,10 @@ When implementing features, write a corresponding markdown doc in `docs/` descri
 - No mocks for the server — tests spin up real server instances on random ports with real TCP connections
 - Validate each layer with real IRC clients (weechat/irssi)
 
+## Format Before Commit
+
+Pre-commit runs `black`, `isort`, `flake8`, `pylint`, `bandit`. `black`/`isort` failures reformat the file and reject the commit — you then have to `git add` the reformatted file and commit again. To avoid the re-commit loop, run `uv run black <files>` and `uv run isort <files>` on staged Python files **before** `git commit`.
+
 ## Nick Format
 
 `<server>-<agent>` (e.g., `thor-claude`, `spark-ori`). Globally unique by construction.

{agentirc_cli-6.2.1 → agentirc_cli-6.2.3}/PKG-INFO

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

{agentirc_cli-6.2.1 → agentirc_cli-6.2.3}/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
@@ -74,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,
@@ -205,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
@@ -689,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.1 → agentirc_cli-6.2.3}/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.1 → agentirc_cli-6.2.3}/pyproject.toml

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

{agentirc_cli-6.2.1 → agentirc_cli-6.2.3}/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 == {}

{agentirc_cli-6.2.1 → agentirc_cli-6.2.3}/uv.lock

@@ -561,7 +561,7 @@ wheels = [
 
 [[package]]
 name = "culture"
-version = "6.2.1"
+version = "6.2.3"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },