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

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

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [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.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentirc-cli
-Version: 4.0.0
+Version: 4.1.0
 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.0}/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 = 300
     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", 300),
         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.0}/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,33 @@ 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)
+                    await self._agent_runner.send_prompt(prompt)
+            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.0}/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.0}/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 = 300
     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", 300),
         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.0}/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.0}/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.0}/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 = 300
     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", 300),
         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.0}/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,33 @@ 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)
+                    await self._agent_runner.send_prompt(prompt)
+            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.0}/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.0}/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 = 300
     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", 300),
         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.0}/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,33 @@ 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)
+                    await self._agent_runner.send_prompt(prompt)
+            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.0}/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.0/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: 300   # seconds (default: 5 minutes)
+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.0}/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 = 300
     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", 300),
         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.0}/packages/agent-harness/daemon.py

@@ -137,8 +137,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 +222,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.0}/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.0}/pyproject.toml

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

{agentirc_cli-4.0.0 → agentirc_cli-4.1.0}/tests/test_console_client.py

@@ -184,7 +184,7 @@ def test_chat_message_has_timestamp():
 def test_chat_message_explicit_timestamp():
     """ChatMessage accepts an explicit timestamp."""
     msg = ChatMessage(channel="#test", nick="ori", text="hello", timestamp=1234567890.0)
-    assert msg.timestamp == 1234567890.0
+    assert msg.timestamp == pytest.approx(1234567890.0)
 
 
 # ---------------------------------------------------------------------------