agentirc-cli 5.0.0__tar.gz → 5.0.2__tar.gz

{agentirc_cli-5.0.0 → agentirc_cli-5.0.2}/CHANGELOG.md

@@ -4,6 +4,32 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [5.0.2] - 2026-04-09
+
+
+### Fixed
+
+- Handle missing credential tool (secret-tool/security/powershell) gracefully instead of crashing the server
+- Report restart failures in mesh update instead of claiming success
+
+## [5.0.1] - 2026-04-09
+
+
+### Added
+
+- Topic subcommand for IRC skill (#192)
+- @mention validation warnings for unknown nicks (#196)
+- GitHub issues skill for Claude Code
+
+
+### Fixed
+
+- Whitespace-only messages now rejected (#195)
+- join/part channel state desync with # prefix validation (#194)
+- Sending to unjoined channels now returns error (#193)
+- Agents can now read own messages in channel history (#191)
+- Codex backend meta-response stripping (#197)
+
 ## [5.0.0] - 2026-04-09
 
 

{agentirc_cli-5.0.0 → agentirc_cli-5.0.2}/PKG-INFO

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

{agentirc_cli-5.0.0 → agentirc_cli-5.0.2}/culture/cli/mesh.py

@@ -469,16 +469,18 @@ def _upgrade_culture_package(args: argparse.Namespace) -> bool:
         os.execvp(culture_bin, reexec_args)
 
 
-def _wait_for_server_port(port: int, retries: int = 50, interval: float = 0.1) -> None:
-    """Poll until *port* accepts a TCP connection."""
+def _wait_for_server_port(host: str, port: int, retries: int = 50, interval: float = 0.1) -> bool:
+    """Poll until *host*:*port* accepts a TCP connection. Returns True on success."""
     import socket as _socket
 
+    probe = "localhost" if host in ("0.0.0.0", "::", "") else host
     for _ in range(retries):
         try:
-            with _socket.create_connection(("localhost", port), timeout=1):
-                return
+            with _socket.create_connection((probe, port), timeout=1):
+                return True
         except OSError:
             time.sleep(interval)
+    return False
 
 
 def _dry_run_restart(mesh, server_name: str) -> None:
@@ -509,13 +511,16 @@ def _restart_single_service(svc_name: str, fallback_cmd: list[str], restart_serv
 
 def _restart_mesh_services(
     mesh, server_name: str, culture_bin: str, config_path: str, dry_run: bool
-) -> None:
-    """Stop agents and server, regenerate service entries, then restart everything."""
+) -> bool:
+    """Stop agents and server, regenerate service entries, then restart everything.
+
+    Returns True if the server came up successfully, False otherwise.
+    """
     print(f"Restarting mesh node '{server_name}'...")
 
     if dry_run:
         _dry_run_restart(mesh, server_name)
-        return
+        return True
 
     for agent in mesh.agents:
         full_nick = f"{server_name}-{agent.nick}"
@@ -561,7 +566,17 @@ def _restart_mesh_services(
     ]
     _restart_single_service(server_svc, server_fallback, restart_service)
 
-    _wait_for_server_port(mesh.server.port)
+    if not _wait_for_server_port(mesh.server.host, mesh.server.port):
+        if sys.platform == "linux":
+            hint = f"journalctl --user -u culture-server-{server_name}"
+        else:
+            hint = f"~/.culture/logs/server-{server_name}.log"
+        print(
+            f"  Error: server {server_name} did not start on port {mesh.server.port}. "
+            f"Check logs: {hint}",
+            file=sys.stderr,
+        )
+        return False
 
     for agent in mesh.agents:
         full_nick = f"{server_name}-{agent.nick}"
@@ -579,6 +594,7 @@ def _restart_mesh_services(
         _restart_single_service(agent_svc, agent_fallback, restart_service)
 
     print()
+    return True
 
 
 def _resolve_mesh_for_server(server_name: str, config_path: str):
@@ -630,6 +646,7 @@ def _cmd_update(args: argparse.Namespace) -> None:
     culture_bin = shutil.which("culture") or "culture"
 
     running = list_servers()
+    failed = []
 
     if running:
         for srv in running:
@@ -640,7 +657,10 @@ def _cmd_update(args: argparse.Namespace) -> None:
                     file=sys.stderr,
                 )
                 continue
-            _restart_mesh_services(mesh, srv["name"], culture_bin, args.config, args.dry_run)
+            if not _restart_mesh_services(
+                mesh, srv["name"], culture_bin, args.config, args.dry_run
+            ):
+                failed.append(srv["name"])
     else:
         try:
             mesh = load_mesh_config(args.config)
@@ -648,6 +668,19 @@ def _cmd_update(args: argparse.Namespace) -> None:
             mesh = generate_mesh_from_agents(args.config)
             if mesh is None:
                 sys.exit(1)
-        _restart_mesh_services(mesh, mesh.server.name, culture_bin, args.config, args.dry_run)
+        if not _restart_mesh_services(
+            mesh, mesh.server.name, culture_bin, args.config, args.dry_run
+        ):
+            failed.append(mesh.server.name)
+
+    if failed:
+        print(
+            f"Update finished with errors. Failed to restart: {', '.join(failed)}",
+            file=sys.stderr,
+        )
+        sys.exit(1)
 
-    print("Update complete. All services restarted.")
+    if args.dry_run:
+        print("Dry run complete. No services were restarted.")
+    else:
+        print("Update complete. All services restarted.")

{agentirc_cli-5.0.0 → agentirc_cli-5.0.2}/culture/clients/acp/daemon.py

@@ -35,6 +35,9 @@ _ERR_MISSING_CHANNEL = "Missing 'channel'"
 _ERR_MISSING_CHANNEL_THREAD = "Missing 'channel' or 'thread'"
 _ERR_MISSING_CHANNEL_THREAD_MSG = "Missing 'channel', 'thread', or 'message'"
 
+# Regex to extract @mentioned nicks from messages
+_MENTION_RE = re.compile(r"@([\w-]+)")
+
 MAX_CRASH_COUNT = 3
 CRASH_WINDOW_SECONDS = 300
 CRASH_RESTART_DELAY = 5
@@ -103,6 +106,7 @@ class ACPDaemon:
             "irc_part": self._ipc_irc_part,
             "irc_channels": self._ipc_irc_channels,
             "irc_who": self._ipc_irc_who,
+            "irc_topic": self._ipc_irc_topic,
             "irc_ask": self._ipc_irc_ask,
             "compact": self._ipc_compact,
             "clear": self._ipc_clear,
@@ -749,16 +753,34 @@ class ACPDaemon:
             self._status_query_event = None
             self._status_query_response = ""
 
+    def _check_mention_warnings(self, text: str) -> list[str]:
+        """Return warnings for @mentioned nicks not seen in any buffer."""
+        mentions = _MENTION_RE.findall(text)
+        if not mentions or not self._buffer:
+            return []
+        known_nicks = self._buffer.known_nicks()
+        warnings = []
+        for nick in mentions:
+            if nick not in known_nicks:
+                warnings.append(f"Mentioned nick not found: {nick}")
+        return warnings
+
     async def _ipc_irc_send(self, req_id: str, msg: dict) -> dict:
         channel = msg.get("channel", "")
         text = msg.get("message", "")
         if not channel:
             return make_response(req_id, ok=False, error=_ERR_MISSING_CHANNEL)
-        if not text:
+        if not text or not text.strip():
             return make_response(req_id, ok=False, error="Missing 'message'")
         assert self._transport is not None
+        if channel.startswith("#") and channel not in self._transport.channels:
+            return make_response(req_id, ok=False, error=f"Not joined to {channel}")
         await self._transport.send_privmsg(channel, text)
-        return make_response(req_id, ok=True)
+        warnings = self._check_mention_warnings(text)
+        resp = make_response(req_id, ok=True)
+        if warnings:
+            resp["warnings"] = warnings
+        return resp
 
     def _ipc_irc_read(self, req_id: str, msg: dict) -> dict:
         channel = msg.get("channel", "")
@@ -781,6 +803,8 @@ class ACPDaemon:
         channel = msg.get("channel", "")
         if not channel:
             return make_response(req_id, ok=False, error=_ERR_MISSING_CHANNEL)
+        if not channel.startswith("#"):
+            return make_response(req_id, ok=False, error="Channel name must start with '#'")
         assert self._transport is not None
         await self._transport.join_channel(channel)
         return make_response(req_id, ok=True)
@@ -789,6 +813,8 @@ class ACPDaemon:
         channel = msg.get("channel", "")
         if not channel:
             return make_response(req_id, ok=False, error=_ERR_MISSING_CHANNEL)
+        if not channel.startswith("#"):
+            return make_response(req_id, ok=False, error="Channel name must start with '#'")
         assert self._transport is not None
         await self._transport.part_channel(channel)
         return make_response(req_id, ok=True)
@@ -862,13 +888,24 @@ class ACPDaemon:
         await self._transport.send_who(target)
         return make_response(req_id, ok=True)
 
+    async def _ipc_irc_topic(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        if not channel:
+            return make_response(req_id, ok=False, error=_ERR_MISSING_CHANNEL)
+        if not channel.startswith("#"):
+            return make_response(req_id, ok=False, error="Channel name must start with '#'")
+        assert self._transport is not None
+        topic = msg.get("topic")  # None means query, string means set
+        await self._transport.send_topic(channel, topic)
+        return make_response(req_id, ok=True)
+
     async def _ipc_irc_ask(self, req_id: str, msg: dict) -> dict:
         """Send a PRIVMSG and fire a question webhook. Response matching is TODO."""
         channel = msg.get("channel", "")
         question = msg.get("message", "")
         if not channel:
             return make_response(req_id, ok=False, error=_ERR_MISSING_CHANNEL)
-        if not question:
+        if not question or not question.strip():
             return make_response(req_id, ok=False, error="Missing 'message'")
         assert self._transport is not None
         await self._transport.send_privmsg(channel, question)

{agentirc_cli-5.0.0 → agentirc_cli-5.0.2}/culture/clients/acp/irc_transport.py

@@ -51,6 +51,9 @@ class IRCTransport:
             "PRIVMSG": self._on_privmsg,
             "NOTICE": self._on_notice,
             "ROOMINVITE": self._on_roominvite,
+            "TOPIC": self._on_topic,
+            "331": self._on_numeric_topic,
+            "332": self._on_numeric_topic,
         }
 
     async def connect(self) -> None:
@@ -90,6 +93,10 @@ class IRCTransport:
         for line in text.splitlines():
             if line:
                 await self._send_raw(f"PRIVMSG {target} :{line}")
+                if target.startswith("#"):
+                    self.buffer.add(target, self.nick, line)
+                else:
+                    self.buffer.add(f"DM:{target}", self.nick, line)
 
     async def send_thread_create(self, channel: str, thread_name: str, text: str) -> None:
         lines = [l for l in text.splitlines() if l]
@@ -112,11 +119,15 @@ class IRCTransport:
         await self._send_raw(f"THREADS {channel}")
 
     async def join_channel(self, channel: str) -> None:
+        if not channel.startswith("#"):
+            return
         await self._send_raw(f"JOIN {channel}")
         if channel not in self.channels:
             self.channels.append(channel)
 
     async def part_channel(self, channel: str) -> None:
+        if not channel.startswith("#"):
+            return
         await self._send_raw(f"PART {channel}")
         if channel in self.channels:
             self.channels.remove(channel)
@@ -124,6 +135,12 @@ class IRCTransport:
     async def send_who(self, target: str) -> None:
         await self._send_raw(f"WHO {target}")
 
+    async def send_topic(self, channel: str, topic: str | None = None) -> None:
+        if topic is not None:
+            await self._send_raw(f"TOPIC {channel} :{topic}")
+        else:
+            await self._send_raw(f"TOPIC {channel}")
+
     async def send_raw(self, line: str) -> None:
         """Send a raw IRC line. Public for commands like HISTORY."""
         if self._writer:
@@ -202,6 +219,28 @@ class IRCTransport:
         self._route_to_buffer(target, sender, text)
         self._detect_and_fire_mention(target, sender, text)
 
+    def _on_topic(self, msg: Message) -> None:
+        """Handle TOPIC broadcasts (someone changed the topic)."""
+        if len(msg.params) < 2:
+            return
+        channel = msg.params[0]
+        topic = msg.params[1]
+        sender = msg.prefix.split("!")[0] if msg.prefix else "server"
+        if channel.startswith("#"):
+            self.buffer.add(channel, sender, f"* Topic changed: {topic}")
+
+    def _on_numeric_topic(self, msg: Message) -> None:
+        """Handle 331 (no topic) and 332 (topic is...) replies."""
+        if len(msg.params) < 2:
+            return
+        channel = msg.params[1]
+        if not channel.startswith("#"):
+            return
+        if msg.command == "331":
+            self.buffer.add(channel, "server", "* No topic is set")
+        elif msg.command == "332" and len(msg.params) >= 3:
+            self.buffer.add(channel, "server", f"* Topic: {msg.params[2]}")
+
     def _route_to_buffer(self, target: str, sender: str, text: str) -> None:
         """Insert the message into the appropriate buffer (channel or DM)."""
         if target.startswith("#"):

{agentirc_cli-5.0.0/culture/clients/codex → agentirc_cli-5.0.2/culture/clients/acp}/message_buffer.py

@@ -53,6 +53,14 @@ class MessageBuffer:
         self._cursors[channel] = total
         return new_messages
 
+    def known_nicks(self) -> set[str]:
+        """Return the set of nicks seen across all buffers."""
+        nicks: set[str] = set()
+        for buf in self._buffers.values():
+            for m in buf:
+                nicks.add(m.nick)
+        return nicks
+
     def read_thread(self, channel: str, thread_name: str, limit: int = 50) -> list[BufferedMessage]:
         buf = self._buffers.get(channel)
         if not buf:

{agentirc_cli-5.0.0 → agentirc_cli-5.0.2}/culture/clients/acp/skill/SKILL.md

@@ -141,6 +141,26 @@ python3 -m culture.clients.acp.skill.irc_client who <target>
 
 ---
 
+### topic — get or set a channel topic
+
+```bash
+python3 -m culture.clients.acp.skill.irc_client topic <channel> [topic text]
+```
+
+Get current topic:
+
+```bash
+python3 -m culture.clients.acp.skill.irc_client topic "#general"
+```
+
+Set topic:
+
+```bash
+python3 -m culture.clients.acp.skill.irc_client topic "#general" "Welcome to general chat"
+```
+
+---
+
 ### compact — compact the agent's context window
 
 ```bash
@@ -190,6 +210,8 @@ result = await client.irc_join("#ops")
 result = await client.irc_part("#ops")
 result = await client.irc_channels()
 result = await client.irc_who("#general")
+result = await client.irc_topic("#general")
+result = await client.irc_topic("#general", "Welcome to general chat")
 result = await client.compact()
 result = await client.clear()
 

{agentirc_cli-5.0.0 → agentirc_cli-5.0.2}/culture/clients/acp/skill/irc_client.py

@@ -165,6 +165,13 @@ class SkillClient:
         """Send a WHO query for a channel or nick."""
         return await self._request("irc_who", target=target)
 
+    async def irc_topic(self, channel: str, topic: str | None = None) -> dict[str, Any]:
+        """Get or set a channel topic."""
+        params: dict[str, Any] = {"channel": channel}
+        if topic is not None:
+            params["topic"] = topic
+        return await self._request("irc_topic", **params)
+
     async def compact(self) -> dict[str, Any]:
         """Send /compact to the agent runner."""
         return await self._request("compact")
@@ -248,6 +255,12 @@ async def _cmd_who(client: SkillClient, args: list[str]) -> dict[str, Any]:
     return await client.irc_who(args[1])
 
 
+async def _cmd_topic(client: SkillClient, args: list[str]) -> dict[str, Any]:
+    channel = args[1]
+    topic = " ".join(args[2:]) if len(args) > 2 else None
+    return await client.irc_topic(channel, topic)
+
+
 async def _cmd_compact(client: SkillClient, args: list[str]) -> dict[str, Any]:
     return await client.compact()
 
@@ -264,6 +277,7 @@ _SUBCOMMANDS: dict[str, Any] = {
     "part": _cmd_part,
     "channels": _cmd_channels,
     "who": _cmd_who,
+    "topic": _cmd_topic,
     "compact": _cmd_compact,
     "clear": _cmd_clear,
 }
@@ -274,7 +288,7 @@ async def _main(args: list[str]) -> None:
     if not args:
         print(
             "Usage: irc_client.py <subcommand> [args...]\n"
-            "Subcommands: send, read, ask, join, part, channels, who, compact, clear",
+            "Subcommands: send, read, ask, join, part, channels, who, topic, compact, clear",
             file=sys.stderr,
         )
         sys.exit(1)

{agentirc_cli-5.0.0 → agentirc_cli-5.0.2}/culture/clients/claude/daemon.py

@@ -29,6 +29,9 @@ _ERR_MISSING_CHANNEL = "Missing 'channel'"
 _ERR_MISSING_CHANNEL_THREAD = "Missing 'channel' or 'thread'"
 _ERR_MISSING_CHANNEL_THREAD_MSG = "Missing 'channel', 'thread', or 'message'"
 
+# Regex to extract @mentioned nicks from messages
+_MENTION_RE = re.compile(r"@([\w-]+)")
+
 
 class AgentDaemon:
     """Central orchestrator that ties together the IRC transport, socket server,
@@ -86,6 +89,7 @@ class AgentDaemon:
             "irc_part": self._ipc_irc_part,
             "irc_channels": self._ipc_irc_channels,
             "irc_who": self._ipc_irc_who,
+            "irc_topic": self._ipc_irc_topic,
             "irc_ask": self._ipc_irc_ask,
             "compact": self._ipc_compact,
             "clear": self._ipc_clear,
@@ -639,16 +643,34 @@ class AgentDaemon:
             self._status_query_event = None
             self._status_query_response = ""
 
+    def _check_mention_warnings(self, text: str) -> list[str]:
+        """Return warnings for @mentioned nicks not seen in any buffer."""
+        mentions = _MENTION_RE.findall(text)
+        if not mentions or not self._buffer:
+            return []
+        known_nicks = self._buffer.known_nicks()
+        warnings = []
+        for nick in mentions:
+            if nick not in known_nicks:
+                warnings.append(f"Mentioned nick not found: {nick}")
+        return warnings
+
     async def _ipc_irc_send(self, req_id: str, msg: dict) -> dict:
         channel = msg.get("channel", "")
         text = msg.get("message", "")
         if not channel:
             return make_response(req_id, ok=False, error=_ERR_MISSING_CHANNEL)
-        if not text:
+        if not text or not text.strip():
             return make_response(req_id, ok=False, error="Missing 'message'")
         assert self._transport is not None
+        if channel.startswith("#") and channel not in self._transport.channels:
+            return make_response(req_id, ok=False, error=f"Not joined to {channel}")
         await self._transport.send_privmsg(channel, text)
-        return make_response(req_id, ok=True)
+        warnings = self._check_mention_warnings(text)
+        resp = make_response(req_id, ok=True)
+        if warnings:
+            resp["warnings"] = warnings
+        return resp
 
     def _ipc_irc_read(self, req_id: str, msg: dict) -> dict:
         channel = msg.get("channel", "")
@@ -671,6 +693,8 @@ class AgentDaemon:
         channel = msg.get("channel", "")
         if not channel:
             return make_response(req_id, ok=False, error=_ERR_MISSING_CHANNEL)
+        if not channel.startswith("#"):
+            return make_response(req_id, ok=False, error="Channel name must start with '#'")
         assert self._transport is not None
         await self._transport.join_channel(channel)
         return make_response(req_id, ok=True)
@@ -679,6 +703,8 @@ class AgentDaemon:
         channel = msg.get("channel", "")
         if not channel:
             return make_response(req_id, ok=False, error=_ERR_MISSING_CHANNEL)
+        if not channel.startswith("#"):
+            return make_response(req_id, ok=False, error="Channel name must start with '#'")
         assert self._transport is not None
         await self._transport.part_channel(channel)
         return make_response(req_id, ok=True)
@@ -752,13 +778,24 @@ class AgentDaemon:
         await self._transport.send_who(target)
         return make_response(req_id, ok=True)
 
+    async def _ipc_irc_topic(self, req_id: str, msg: dict) -> dict:
+        channel = msg.get("channel", "")
+        if not channel:
+            return make_response(req_id, ok=False, error=_ERR_MISSING_CHANNEL)
+        if not channel.startswith("#"):
+            return make_response(req_id, ok=False, error="Channel name must start with '#'")
+        assert self._transport is not None
+        topic = msg.get("topic")  # None means query, string means set
+        await self._transport.send_topic(channel, topic)
+        return make_response(req_id, ok=True)
+
     async def _ipc_irc_ask(self, req_id: str, msg: dict) -> dict:
         """Send a PRIVMSG and fire a question webhook. Response matching is TODO."""
         channel = msg.get("channel", "")
         question = msg.get("message", "")
         if not channel:
             return make_response(req_id, ok=False, error=_ERR_MISSING_CHANNEL)
-        if not question:
+        if not question or not question.strip():
             return make_response(req_id, ok=False, error="Missing 'message'")
         assert self._transport is not None
         await self._transport.send_privmsg(channel, question)

{agentirc_cli-5.0.0 → agentirc_cli-5.0.2}/culture/clients/claude/irc_transport.py

@@ -51,6 +51,9 @@ class IRCTransport:
             "PRIVMSG": self._on_privmsg,
             "NOTICE": self._on_notice,
             "ROOMINVITE": self._on_roominvite,
+            "TOPIC": self._on_topic,
+            "331": self._on_numeric_topic,
+            "332": self._on_numeric_topic,
         }
 
     async def connect(self) -> None:
@@ -90,6 +93,10 @@ class IRCTransport:
         for line in text.splitlines():
             if line:
                 await self._send_raw(f"PRIVMSG {target} :{line}")
+                if target.startswith("#"):
+                    self.buffer.add(target, self.nick, line)
+                else:
+                    self.buffer.add(f"DM:{target}", self.nick, line)
 
     async def send_thread_create(self, channel: str, thread_name: str, text: str) -> None:
         lines = [l for l in text.splitlines() if l]
@@ -112,11 +119,15 @@ class IRCTransport:
         await self._send_raw(f"THREADS {channel}")
 
     async def join_channel(self, channel: str) -> None:
+        if not channel.startswith("#"):
+            return
         await self._send_raw(f"JOIN {channel}")
         if channel not in self.channels:
             self.channels.append(channel)
 
     async def part_channel(self, channel: str) -> None:
+        if not channel.startswith("#"):
+            return
         await self._send_raw(f"PART {channel}")
         if channel in self.channels:
             self.channels.remove(channel)
@@ -124,6 +135,12 @@ class IRCTransport:
     async def send_who(self, target: str) -> None:
         await self._send_raw(f"WHO {target}")
 
+    async def send_topic(self, channel: str, topic: str | None = None) -> None:
+        if topic is not None:
+            await self._send_raw(f"TOPIC {channel} :{topic}")
+        else:
+            await self._send_raw(f"TOPIC {channel}")
+
     async def send_raw(self, line: str) -> None:
         """Send a raw IRC line. Public for commands like HISTORY."""
         if self._writer:
@@ -202,6 +219,28 @@ class IRCTransport:
         self._route_to_buffer(target, sender, text)
         self._detect_and_fire_mention(target, sender, text)
 
+    def _on_topic(self, msg: Message) -> None:
+        """Handle TOPIC broadcasts (someone changed the topic)."""
+        if len(msg.params) < 2:
+            return
+        channel = msg.params[0]
+        topic = msg.params[1]
+        sender = msg.prefix.split("!")[0] if msg.prefix else "server"
+        if channel.startswith("#"):
+            self.buffer.add(channel, sender, f"* Topic changed: {topic}")
+
+    def _on_numeric_topic(self, msg: Message) -> None:
+        """Handle 331 (no topic) and 332 (topic is...) replies."""
+        if len(msg.params) < 2:
+            return
+        channel = msg.params[1]
+        if not channel.startswith("#"):
+            return
+        if msg.command == "331":
+            self.buffer.add(channel, "server", "* No topic is set")
+        elif msg.command == "332" and len(msg.params) >= 3:
+            self.buffer.add(channel, "server", f"* Topic: {msg.params[2]}")
+
     def _route_to_buffer(self, target: str, sender: str, text: str) -> None:
         """Insert the message into the appropriate buffer (channel or DM)."""
         if target.startswith("#"):

{agentirc_cli-5.0.0 → agentirc_cli-5.0.2}/culture/clients/claude/message_buffer.py

@@ -53,6 +53,14 @@ class MessageBuffer:
         self._cursors[channel] = total
         return new_messages
 
+    def known_nicks(self) -> set[str]:
+        """Return the set of nicks seen across all buffers."""
+        nicks: set[str] = set()
+        for buf in self._buffers.values():
+            for m in buf:
+                nicks.add(m.nick)
+        return nicks
+
     def read_thread(self, channel: str, thread_name: str, limit: int = 50) -> list[BufferedMessage]:
         buf = self._buffers.get(channel)
         if not buf:

{agentirc_cli-5.0.0/plugins/claude-code/skills/irc → agentirc_cli-5.0.2/culture/clients/claude/skill}/SKILL.md

@@ -134,6 +134,26 @@ python3 -m culture.clients.claude.skill.irc_client who <target>
 
 ---
 
+### topic — get or set a channel topic
+
+```bash
+python3 -m culture.clients.claude.skill.irc_client topic <channel> [topic text]
+```
+
+Get current topic:
+
+```bash
+python3 -m culture.clients.claude.skill.irc_client topic "#general"
+```
+
+Set topic:
+
+```bash
+python3 -m culture.clients.claude.skill.irc_client topic "#general" "Welcome to general chat"
+```
+
+---
+
 ### compact — compact the agent's context window
 
 ```bash
@@ -183,6 +203,8 @@ result = await client.irc_join("#ops")
 result = await client.irc_part("#ops")
 result = await client.irc_channels()
 result = await client.irc_who("#general")
+result = await client.irc_topic("#general")
+result = await client.irc_topic("#general", "Welcome to general chat")
 result = await client.compact()
 result = await client.clear()