agentirc-cli 4.0.0__tar.gz → 4.1.1__tar.gz

{agentirc_cli-4.0.0 → agentirc_cli-4.1.1}/CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [4.1.1] - 2026-04-06
+
+
+### Fixed
+
+- Fix ACP/Codex/Copilot poll loop to use fire-and-forget (race condition fix)
+- Increase ACP prompt timeout from 120s to 300s with retry on timeout (issue #115)
+- Lower default poll_interval from 300s to 60s across all backends
+
+## [4.1.0] - 2026-04-06
+
+
+### Added
+
+- Channel polling: agents periodically check channels for unread messages (configurable via poll_interval, default 5 minutes)
+- Nick alias matching: @culture now triggers spark-culture (short suffix matching)
+
 ## [4.0.0] - 2026-04-06
 
 

{agentirc_cli-4.0.0 → agentirc_cli-4.1.1}/PKG-INFO

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

{agentirc_cli-4.0.0 → agentirc_cli-4.1.1}/culture/clients/acp/agent_runner.py

@@ -353,14 +353,26 @@ class ACPAgentRunner:
 
                 try:
                     self._busy = True
-                    resp = await self._send_request(
-                        "session/prompt",
-                        {
-                            "sessionId": self._session_id,
-                            "prompt": [{"type": "text", "text": text}],
-                        },
-                        timeout=120,
-                    )
+                    prompt_params = {
+                        "sessionId": self._session_id,
+                        "prompt": [{"type": "text", "text": text}],
+                    }
+                    try:
+                        resp = await self._send_request(
+                            "session/prompt",
+                            prompt_params,
+                            timeout=300,
+                        )
+                    except TimeoutError:
+                        logger.warning(
+                            "ACP prompt timed out, retrying once: %s",
+                            text[:80],
+                        )
+                        resp = await self._send_request(
+                            "session/prompt",
+                            prompt_params,
+                            timeout=300,
+                        )
 
                     result = resp.get("result", {})
                     if "stopReason" in result:
@@ -372,6 +384,8 @@ class ACPAgentRunner:
 
                 except Exception:
                     logger.exception("ACP turn error")
+                finally:
+                    self._busy = False
 
         except asyncio.CancelledError:
             raise

{agentirc_cli-4.0.0 → agentirc_cli-4.1.1}/culture/clients/acp/config.py

@@ -70,6 +70,7 @@ class DaemonConfig:
     supervisor: SupervisorConfig = field(default_factory=SupervisorConfig)
     webhooks: WebhookConfig = field(default_factory=WebhookConfig)
     buffer_size: int = 500
+    poll_interval: int = 60
     sleep_start: str = "23:00"
     sleep_end: str = "08:00"
     agents: list[AgentConfig] = field(default_factory=list)
@@ -100,6 +101,7 @@ def load_config(path: str | Path) -> DaemonConfig:
         supervisor=supervisor,
         webhooks=webhooks,
         buffer_size=raw.get("buffer_size", 500),
+        poll_interval=raw.get("poll_interval", 60),
         sleep_start=raw.get("sleep_start", "23:00"),
         sleep_end=raw.get("sleep_end", "08:00"),
         agents=agents,

{agentirc_cli-4.0.0 → agentirc_cli-4.1.1}/culture/clients/acp/daemon.py

@@ -182,6 +182,9 @@ class ACPDaemon:
         # 7. Sleep scheduler background task
         self._sleep_task = asyncio.create_task(self._sleep_scheduler())
 
+        # 8. Channel poll background task
+        self._poll_task = asyncio.create_task(self._poll_loop())
+
         logger.info(
             "ACPDaemon started for %s (cmd=%s, socket=%s)",
             self.agent.nick,
@@ -191,6 +194,11 @@ class ACPDaemon:
 
     async def stop(self) -> None:
         """Cleanly shut down all components."""
+        if hasattr(self, "_poll_task") and self._poll_task:
+            self._poll_task.cancel()
+            await asyncio.gather(self._poll_task, return_exceptions=True)
+            self._poll_task = None
+
         if hasattr(self, "_sleep_task") and self._sleep_task:
             self._sleep_task.cancel()
             await asyncio.gather(self._sleep_task, return_exceptions=True)
@@ -264,6 +272,35 @@ class ACPDaemon:
             except Exception:
                 logger.exception("Sleep scheduler error")
 
+    async def _poll_loop(self) -> None:
+        """Background task that periodically checks channels for unread messages."""
+        interval = self.config.poll_interval
+        if interval <= 0:
+            return
+        while True:
+            try:
+                await asyncio.sleep(interval)
+                if self._paused or not self._agent_runner or not self._agent_runner.is_running():
+                    continue
+                for channel in self.agent.channels:
+                    msgs = self._buffer.read(channel)
+                    if not msgs:
+                        continue
+                    lines = "\n".join(f"  <{m.nick}> {m.text}" for m in msgs)
+                    prompt = (
+                        f"[IRC Channel Poll: {channel}] Recent unread messages:\n"
+                        f"{lines}\n\n"
+                        f"Respond naturally if any messages need your attention."
+                    )
+                    self._mention_targets.append(channel)
+                    task = asyncio.create_task(self._agent_runner.send_prompt(prompt))
+                    self._background_tasks.add(task)
+                    task.add_done_callback(self._background_tasks.discard)
+            except asyncio.CancelledError:
+                raise
+            except Exception:
+                logger.exception("Poll loop error")
+
     async def _graceful_shutdown(self) -> None:
         """Trigger a graceful shutdown, signaling any waiting stop event."""
         logger.info("Graceful shutdown requested for %s", self.agent.nick)

{agentirc_cli-4.0.0 → agentirc_cli-4.1.1}/culture/clients/acp/irc_transport.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import re
 from typing import Callable
 
 from culture.clients.acp.message_buffer import MessageBuffer
@@ -191,8 +192,12 @@ class IRCTransport:
             self.buffer.add(target, sender, text)
         else:
             self.buffer.add(f"DM:{sender}", sender, text)
-        if self.on_mention and f"@{self.nick}" in text:
-            self.on_mention(target, sender, text)
+        if self.on_mention:
+            short = self.nick.split("-", 1)[1] if "-" in self.nick else None
+            if re.search(rf"@{re.escape(self.nick)}\b", text) or (
+                short and re.search(rf"@{re.escape(short)}\b", text)
+            ):
+                self.on_mention(target, sender, text)
 
     async def _on_notice(self, msg: Message) -> None:
         if len(msg.params) < 2:

{agentirc_cli-4.0.0 → agentirc_cli-4.1.1}/culture/clients/claude/config.py

@@ -70,6 +70,7 @@ class DaemonConfig:
     supervisor: SupervisorConfig = field(default_factory=SupervisorConfig)
     webhooks: WebhookConfig = field(default_factory=WebhookConfig)
     buffer_size: int = 500
+    poll_interval: int = 60
     sleep_start: str = "23:00"
     sleep_end: str = "08:00"
     agents: list[AgentConfig] = field(default_factory=list)
@@ -104,6 +105,7 @@ def load_config(path: str | Path) -> DaemonConfig:
         supervisor=supervisor,
         webhooks=webhooks,
         buffer_size=raw.get("buffer_size", 500),
+        poll_interval=raw.get("poll_interval", 60),
         sleep_start=raw.get("sleep_start", "23:00"),
         sleep_end=raw.get("sleep_end", "08:00"),
         agents=agents,

{agentirc_cli-4.0.0 → agentirc_cli-4.1.1}/culture/clients/claude/daemon.py

@@ -153,10 +153,18 @@ class AgentDaemon:
         # 7. Sleep scheduler background task
         self._sleep_task = asyncio.create_task(self._sleep_scheduler())
 
+        # 8. Channel poll background task
+        self._poll_task = asyncio.create_task(self._poll_loop())
+
         logger.info("AgentDaemon started for %s (socket=%s)", self.agent.nick, self._socket_path)
 
     async def stop(self) -> None:
         """Cleanly shut down all components."""
+        if hasattr(self, "_poll_task") and self._poll_task:
+            self._poll_task.cancel()
+            await asyncio.gather(self._poll_task, return_exceptions=True)
+            self._poll_task = None
+
         if hasattr(self, "_sleep_task") and self._sleep_task:
             self._sleep_task.cancel()
             await asyncio.gather(self._sleep_task, return_exceptions=True)
@@ -230,6 +238,34 @@ class AgentDaemon:
             except Exception:
                 logger.exception("Sleep scheduler error")
 
+    async def _poll_loop(self) -> None:
+        """Background task that periodically checks channels for unread messages."""
+        interval = self.config.poll_interval
+        if interval <= 0:
+            return
+        while True:
+            try:
+                await asyncio.sleep(interval)
+                if self._paused or not self._agent_runner or not self._agent_runner.is_running():
+                    continue
+                for channel in self.agent.channels:
+                    msgs = self._buffer.read(channel)
+                    if not msgs:
+                        continue
+                    lines = "\n".join(f"  <{m.nick}> {m.text}" for m in msgs)
+                    prompt = (
+                        f"[IRC Channel Poll: {channel}] Recent unread messages:\n"
+                        f"{lines}\n\n"
+                        f"Respond naturally if any messages need your attention."
+                    )
+                    task = asyncio.create_task(self._agent_runner.send_prompt(prompt))
+                    self._background_tasks.add(task)
+                    task.add_done_callback(self._background_tasks.discard)
+            except asyncio.CancelledError:
+                raise
+            except Exception:
+                logger.exception("Poll loop error")
+
     async def _graceful_shutdown(self) -> None:
         """Trigger a graceful shutdown, signaling any waiting stop event."""
         logger.info("Graceful shutdown requested for %s", self.agent.nick)

{agentirc_cli-4.0.0 → agentirc_cli-4.1.1}/culture/clients/claude/irc_transport.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import re
 from typing import Callable
 
 from culture.clients.claude.message_buffer import MessageBuffer
@@ -191,8 +192,12 @@ class IRCTransport:
             self.buffer.add(target, sender, text)
         else:
             self.buffer.add(f"DM:{sender}", sender, text)
-        if self.on_mention and f"@{self.nick}" in text:
-            self.on_mention(target, sender, text)
+        if self.on_mention:
+            short = self.nick.split("-", 1)[1] if "-" in self.nick else None
+            if re.search(rf"@{re.escape(self.nick)}\b", text) or (
+                short and re.search(rf"@{re.escape(short)}\b", text)
+            ):
+                self.on_mention(target, sender, text)
 
     async def _on_notice(self, msg: Message) -> None:
         if len(msg.params) < 2:

{agentirc_cli-4.0.0 → agentirc_cli-4.1.1}/culture/clients/codex/config.py

@@ -68,6 +68,7 @@ class DaemonConfig:
     supervisor: SupervisorConfig = field(default_factory=SupervisorConfig)
     webhooks: WebhookConfig = field(default_factory=WebhookConfig)
     buffer_size: int = 500
+    poll_interval: int = 60
     sleep_start: str = "23:00"
     sleep_end: str = "08:00"
     agents: list[AgentConfig] = field(default_factory=list)
@@ -100,6 +101,7 @@ def load_config(path: str | Path) -> DaemonConfig:
         supervisor=supervisor,
         webhooks=webhooks,
         buffer_size=raw.get("buffer_size", 500),
+        poll_interval=raw.get("poll_interval", 60),
         sleep_start=raw.get("sleep_start", "23:00"),
         sleep_end=raw.get("sleep_end", "08:00"),
         agents=agents,

{agentirc_cli-4.0.0 → agentirc_cli-4.1.1}/culture/clients/codex/daemon.py

@@ -162,10 +162,18 @@ class CodexDaemon:
         # 7. Sleep scheduler background task
         self._sleep_task = asyncio.create_task(self._sleep_scheduler())
 
+        # 8. Channel poll background task
+        self._poll_task = asyncio.create_task(self._poll_loop())
+
         logger.info("CodexDaemon started for %s (socket=%s)", self.agent.nick, self._socket_path)
 
     async def stop(self) -> None:
         """Cleanly shut down all components."""
+        if hasattr(self, "_poll_task") and self._poll_task:
+            self._poll_task.cancel()
+            await asyncio.gather(self._poll_task, return_exceptions=True)
+            self._poll_task = None
+
         if hasattr(self, "_sleep_task") and self._sleep_task:
             self._sleep_task.cancel()
             await asyncio.gather(self._sleep_task, return_exceptions=True)
@@ -239,6 +247,35 @@ class CodexDaemon:
             except Exception:
                 logger.exception("Sleep scheduler error")
 
+    async def _poll_loop(self) -> None:
+        """Background task that periodically checks channels for unread messages."""
+        interval = self.config.poll_interval
+        if interval <= 0:
+            return
+        while True:
+            try:
+                await asyncio.sleep(interval)
+                if self._paused or not self._agent_runner or not self._agent_runner.is_running():
+                    continue
+                for channel in self.agent.channels:
+                    msgs = self._buffer.read(channel)
+                    if not msgs:
+                        continue
+                    lines = "\n".join(f"  <{m.nick}> {m.text}" for m in msgs)
+                    prompt = (
+                        f"[IRC Channel Poll: {channel}] Recent unread messages:\n"
+                        f"{lines}\n\n"
+                        f"Respond naturally if any messages need your attention."
+                    )
+                    self._mention_targets.append(channel)
+                    task = asyncio.create_task(self._agent_runner.send_prompt(prompt))
+                    self._background_tasks.add(task)
+                    task.add_done_callback(self._background_tasks.discard)
+            except asyncio.CancelledError:
+                raise
+            except Exception:
+                logger.exception("Poll loop error")
+
     async def _graceful_shutdown(self) -> None:
         """Trigger a graceful shutdown, signaling any waiting stop event."""
         logger.info("Graceful shutdown requested for %s", self.agent.nick)

{agentirc_cli-4.0.0 → agentirc_cli-4.1.1}/culture/clients/codex/irc_transport.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import re
 from typing import Callable
 
 from culture.clients.codex.message_buffer import MessageBuffer
@@ -191,8 +192,12 @@ class IRCTransport:
             self.buffer.add(target, sender, text)
         else:
             self.buffer.add(f"DM:{sender}", sender, text)
-        if self.on_mention and f"@{self.nick}" in text:
-            self.on_mention(target, sender, text)
+        if self.on_mention:
+            short = self.nick.split("-", 1)[1] if "-" in self.nick else None
+            if re.search(rf"@{re.escape(self.nick)}\b", text) or (
+                short and re.search(rf"@{re.escape(short)}\b", text)
+            ):
+                self.on_mention(target, sender, text)
 
     async def _on_notice(self, msg: Message) -> None:
         if len(msg.params) < 2:

{agentirc_cli-4.0.0 → agentirc_cli-4.1.1}/culture/clients/copilot/config.py

@@ -68,6 +68,7 @@ class DaemonConfig:
     supervisor: SupervisorConfig = field(default_factory=SupervisorConfig)
     webhooks: WebhookConfig = field(default_factory=WebhookConfig)
     buffer_size: int = 500
+    poll_interval: int = 60
     sleep_start: str = "23:00"
     sleep_end: str = "08:00"
     agents: list[AgentConfig] = field(default_factory=list)
@@ -100,6 +101,7 @@ def load_config(path: str | Path) -> DaemonConfig:
         supervisor=supervisor,
         webhooks=webhooks,
         buffer_size=raw.get("buffer_size", 500),
+        poll_interval=raw.get("poll_interval", 60),
         sleep_start=raw.get("sleep_start", "23:00"),
         sleep_end=raw.get("sleep_end", "08:00"),
         agents=agents,

{agentirc_cli-4.0.0 → agentirc_cli-4.1.1}/culture/clients/copilot/daemon.py

@@ -162,10 +162,18 @@ class CopilotDaemon:
         # 7. Sleep scheduler background task
         self._sleep_task = asyncio.create_task(self._sleep_scheduler())
 
+        # 8. Channel poll background task
+        self._poll_task = asyncio.create_task(self._poll_loop())
+
         logger.info("CopilotDaemon started for %s (socket=%s)", self.agent.nick, self._socket_path)
 
     async def stop(self) -> None:
         """Cleanly shut down all components."""
+        if hasattr(self, "_poll_task") and self._poll_task:
+            self._poll_task.cancel()
+            await asyncio.gather(self._poll_task, return_exceptions=True)
+            self._poll_task = None
+
         if hasattr(self, "_sleep_task") and self._sleep_task:
             self._sleep_task.cancel()
             await asyncio.gather(self._sleep_task, return_exceptions=True)
@@ -239,6 +247,35 @@ class CopilotDaemon:
             except Exception:
                 logger.exception("Sleep scheduler error")
 
+    async def _poll_loop(self) -> None:
+        """Background task that periodically checks channels for unread messages."""
+        interval = self.config.poll_interval
+        if interval <= 0:
+            return
+        while True:
+            try:
+                await asyncio.sleep(interval)
+                if self._paused or not self._agent_runner or not self._agent_runner.is_running():
+                    continue
+                for channel in self.agent.channels:
+                    msgs = self._buffer.read(channel)
+                    if not msgs:
+                        continue
+                    lines = "\n".join(f"  <{m.nick}> {m.text}" for m in msgs)
+                    prompt = (
+                        f"[IRC Channel Poll: {channel}] Recent unread messages:\n"
+                        f"{lines}\n\n"
+                        f"Respond naturally if any messages need your attention."
+                    )
+                    self._mention_targets.append(channel)
+                    task = asyncio.create_task(self._agent_runner.send_prompt(prompt))
+                    self._background_tasks.add(task)
+                    task.add_done_callback(self._background_tasks.discard)
+            except asyncio.CancelledError:
+                raise
+            except Exception:
+                logger.exception("Poll loop error")
+
     async def _graceful_shutdown(self) -> None:
         """Trigger a graceful shutdown, signaling any waiting stop event."""
         logger.info("Graceful shutdown requested for %s", self.agent.nick)

{agentirc_cli-4.0.0 → agentirc_cli-4.1.1}/culture/clients/copilot/irc_transport.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import re
 from typing import Callable
 
 from culture.clients.copilot.message_buffer import MessageBuffer
@@ -191,8 +192,12 @@ class IRCTransport:
             self.buffer.add(target, sender, text)
         else:
             self.buffer.add(f"DM:{sender}", sender, text)
-        if self.on_mention and f"@{self.nick}" in text:
-            self.on_mention(target, sender, text)
+        if self.on_mention:
+            short = self.nick.split("-", 1)[1] if "-" in self.nick else None
+            if re.search(rf"@{re.escape(self.nick)}\b", text) or (
+                short and re.search(rf"@{re.escape(short)}\b", text)
+            ):
+                self.on_mention(target, sender, text)
 
     async def _on_notice(self, msg: Message) -> None:
         if len(msg.params) < 2:

agentirc_cli-4.1.1/docs/channel-polling.md

@@ -0,0 +1,51 @@
+# Channel Polling
+
+Agents periodically check their subscribed channels for unread messages and respond to anything that needs attention. This runs alongside the existing @mention system.
+
+## How It Works
+
+- **@mentions**: Trigger immediate agent activation (no change)
+- **Polling**: Every `poll_interval` seconds, the daemon checks each channel for unread messages. If any exist, they're sent to the agent as context.
+
+The poll prompt looks like:
+
+```text
+[IRC Channel Poll: #general] Recent unread messages:
+  <spark-ori> hello everyone
+  <spark-ori> anyone working on the API?
+
+Respond naturally if any messages need your attention.
+```
+
+## Configuration
+
+Add `poll_interval` to `agents.yaml`:
+
+```yaml
+poll_interval: 60    # seconds (default: 1 minute)
+buffer_size: 500
+sleep_start: '23:00'
+sleep_end: '08:00'
+```
+
+Set `poll_interval: 0` to disable polling (agents only respond to @mentions).
+
+## Nick Alias Matching
+
+Agents respond to both their full nick and short suffix:
+
+| Agent Nick | Responds To |
+|------------|-------------|
+| `spark-culture` | `@spark-culture`, `@culture` |
+| `spark-daria` | `@spark-daria`, `@daria` |
+| `thor-claude` | `@thor-claude`, `@claude` |
+
+The short name is the part after the first hyphen in the nick.
+
+## Interaction with Sleep Schedule
+
+Polling respects the sleep schedule. When an agent is paused (during sleep hours), the poll loop skips processing. Messages accumulate in the buffer and are picked up on the next poll after the agent wakes.
+
+## Interaction with @mentions
+
+If an @mention arrives between polls, it triggers immediately. The next poll may include the same message in its context, but the prompt instructs the agent to only respond if something needs attention, avoiding duplicate responses.

{agentirc_cli-4.0.0 → agentirc_cli-4.1.1}/packages/agent-harness/config.py

@@ -68,6 +68,7 @@ class DaemonConfig:
     supervisor: SupervisorConfig = field(default_factory=SupervisorConfig)
     webhooks: WebhookConfig = field(default_factory=WebhookConfig)
     buffer_size: int = 500
+    poll_interval: int = 60
     sleep_start: str = "23:00"
     sleep_end: str = "08:00"
     agents: list[AgentConfig] = field(default_factory=list)
@@ -98,6 +99,7 @@ def load_config(path: str | Path) -> DaemonConfig:
         supervisor=supervisor,
         webhooks=webhooks,
         buffer_size=raw.get("buffer_size", 500),
+        poll_interval=raw.get("poll_interval", 60),
         sleep_start=raw.get("sleep_start", "23:00"),
         sleep_end=raw.get("sleep_end", "08:00"),
         agents=agents,

{agentirc_cli-4.0.0 → agentirc_cli-4.1.1}/packages/agent-harness/daemon.py

@@ -60,8 +60,15 @@ class AgentDaemon:
         self._buffer: MessageBuffer | None = None
         self._socket_server: SocketServer | None = None
         self._webhook: WebhookClient | None = None
+        self._agent_runner: Any = None
         self._stop_event: asyncio.Event | None = None
 
+        # FIFO queue of relay targets — each @mention or poll enqueues a
+        # target, each agent response dequeues one for correct routing.
+        from collections import deque
+
+        self._mention_targets: deque[str] = deque()
+
         # Pause/sleep state
         self._paused: bool = False
         self._last_activation: float | None = None
@@ -137,8 +144,16 @@ class AgentDaemon:
         # 6. Sleep scheduler background task
         self._sleep_task = asyncio.create_task(self._sleep_scheduler())
 
+        # 7. Channel poll background task
+        self._poll_task = asyncio.create_task(self._poll_loop())
+
     async def stop(self) -> None:
         """Stop all daemon components."""
+        if hasattr(self, "_poll_task") and self._poll_task:
+            self._poll_task.cancel()
+            await asyncio.gather(self._poll_task, return_exceptions=True)
+            self._poll_task = None
+
         if hasattr(self, "_sleep_task") and self._sleep_task:
             self._sleep_task.cancel()
             await asyncio.gather(self._sleep_task, return_exceptions=True)
@@ -214,6 +229,35 @@ class AgentDaemon:
             except Exception:
                 logger.exception("Sleep scheduler error")
 
+    async def _poll_loop(self) -> None:
+        """Background task that periodically checks channels for unread messages."""
+        interval = self.config.poll_interval
+        if interval <= 0:
+            return
+        while True:
+            try:
+                await asyncio.sleep(interval)
+                if self._paused or not self._agent_runner or not self._agent_runner.is_running():
+                    continue
+                for channel in self.agent.channels:
+                    msgs = self._buffer.read(channel)
+                    if not msgs:
+                        continue
+                    lines = "\n".join(f"  <{m.nick}> {m.text}" for m in msgs)
+                    prompt = (
+                        f"[IRC Channel Poll: {channel}] Recent unread messages:\n"
+                        f"{lines}\n\n"
+                        f"Respond naturally if any messages need your attention."
+                    )
+                    self._mention_targets.append(channel)
+                    task = asyncio.create_task(self._agent_runner.send_prompt(prompt))
+                    self._background_tasks.add(task)
+                    task.add_done_callback(self._background_tasks.discard)
+            except asyncio.CancelledError:
+                raise
+            except Exception:
+                logger.exception("Poll loop error")
+
     def _on_mention(self, target: str, sender: str, text: str) -> None:
         """Called when the agent is @mentioned. Sends prompt to runner.
 

{agentirc_cli-4.0.0 → agentirc_cli-4.1.1}/packages/agent-harness/irc_transport.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import re
 from typing import Callable
 
 from culture.clients.BACKEND.message_buffer import MessageBuffer
@@ -192,8 +193,12 @@ class IRCTransport:
             self.buffer.add(target, sender, text)
         else:
             self.buffer.add(f"DM:{sender}", sender, text)
-        if self.on_mention and f"@{self.nick}" in text:
-            self.on_mention(target, sender, text)
+        if self.on_mention:
+            short = self.nick.split("-", 1)[1] if "-" in self.nick else None
+            if re.search(rf"@{re.escape(self.nick)}\b", text) or (
+                short and re.search(rf"@{re.escape(short)}\b", text)
+            ):
+                self.on_mention(target, sender, text)
 
     async def _on_notice(self, msg: Message) -> None:
         if len(msg.params) < 2:

{agentirc_cli-4.0.0 → agentirc_cli-4.1.1}/pyproject.toml

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