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

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

@@ -4,6 +4,38 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [5.0.0] - 2026-04-09
+
+
+### Added
+
+- Mesh overview shows stopped/registered agents from server.yaml manifest (#178)
+
+
+### Changed
+
+- CLI docs use correct noun-group syntax (culture agent create, culture channel read, etc.) (#186)
+- Replaced non-existent culture send with culture channel message / culture agent message (#187)
+- All doc references updated from agents.yaml to server.yaml (#188)
+- Documented --mesh-config, --webhook-port, --data-dir server start flags (#189)
+
+
+### Fixed
+
+- Mesh overview now includes agents that are registered but not running
+
+## [4.5.2] - 2026-04-09
+
+
+### Fixed
+
+- Agent status now reports the circuit-open state correctly instead of showing running (#179)
+- Agent status list now distinguishes paused and sleeping agents correctly (#180)
+- Learn prompt now includes compact/clear commands and ask --timeout (#181)
+- Non-Claude backend skill docs now include the required features and comply with the all-backends rule (#182)
+- Admin skill and learn prompt now include the missing CLI commands (#183)
+- Mesh overview now indicates when bots are archived (#184)
+
 ## [4.5.1] - 2026-04-09
 
 

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

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

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

@@ -120,7 +120,13 @@ def dispatch(args: argparse.Namespace) -> None:
 # -----------------------------------------------------------------------
 
 
-def _collect_mesh_data(host: str, port: int, server_name: str, message_limit: int):
+def _collect_mesh_data(
+    host: str,
+    port: int,
+    server_name: str,
+    message_limit: int,
+    manifest_agents: list | None = None,
+):
     """Collect mesh state, exiting with an error message on connection failure."""
     from culture.overview.collector import collect_mesh_state
 
@@ -131,6 +137,7 @@ def _collect_mesh_data(host: str, port: int, server_name: str, message_limit: in
                 port=port,
                 server_name=server_name,
                 message_limit=message_limit,
+                manifest_agents=manifest_agents,
             )
         )
     except ConnectionRefusedError:
@@ -169,11 +176,16 @@ def _cmd_overview(args: argparse.Namespace) -> None:
             agent_filter=args.agent,
             message_limit=message_limit,
             refresh_interval=refresh_interval,
+            manifest_agents=config.agents,
         )
         return
 
     mesh = _collect_mesh_data(
-        config.server.host, config.server.port, config.server.name, message_limit
+        config.server.host,
+        config.server.port,
+        config.server.name,
+        message_limit,
+        manifest_agents=config.agents,
     )
     output = render_text(
         mesh,

{agentirc_cli-4.5.1 → agentirc_cli-5.0.0}/culture/cli/shared/display.py

@@ -33,20 +33,31 @@ def print_agent_detail(agent, config_path: str, args: argparse.Namespace) -> Non
     """Print detailed status for a single agent, including live IPC activity query."""
     status, pid = agent_process_status(agent)
     print(agent.nick)
-    print(f"  Status:     {status}")
-    print(f"  PID:        {pid or '-'}")
 
     if status == "running":
         query = getattr(args, "full", False)
         resp = asyncio.run(ipc_request(agent_socket_path(agent.nick), "status", query=query))
         if resp and resp.get("ok"):
             data = resp.get("data", {})
+            if data.get("circuit_open"):
+                status = "circuit-open"
+            elif data.get("paused"):
+                status = "paused"
+            print(f"  Status:     {status}")
+            print(f"  PID:        {pid or '-'}")
             print(f"  Activity:   {data.get('description', 'nothing')}")
             print(f"  Turns:      {data.get('turn_count', 0)}")
             print(f"  Paused:     {'yes' if data.get('paused') else 'no'}")
+            print(
+                f"  Circuit:    {'OPEN (not restarting)' if data.get('circuit_open') else 'closed'}"
+            )
         else:
+            print(f"  Status:     {status}")
+            print(f"  PID:        {pid or '-'}")
             print("  Activity:   unknown (daemon may need restart)")
     else:
+        print(f"  Status:     {status}")
+        print(f"  PID:        {pid or '-'}")
         print("  Activity:   -")
 
     channels = agent.channels if isinstance(agent.channels, list) else []
@@ -68,12 +79,12 @@ def _format_agent_status(base_status: str, archived: bool, show_archived_marker:
     return base_status
 
 
-def _fetch_agent_activity(agent) -> str:
-    """Fetch activity description from a running agent via IPC."""
+def _fetch_ipc_data(agent) -> dict | None:
+    """Fetch full IPC status data from a running agent."""
     resp = asyncio.run(ipc_request(agent_socket_path(agent.nick), "status"))
     if resp and resp.get("ok"):
-        return resp.get("data", {}).get("description", "nothing")
-    return "-"
+        return resp.get("data", {})
+    return None
 
 
 def print_agents_overview(
@@ -89,12 +100,20 @@ def print_agents_overview(
 
     for agent in agents:
         base_status, pid = agent_process_status(agent)
+        activity = "-"
+        # Enrich status from IPC for running agents
+        if base_status == "running":
+            ipc_data = _fetch_ipc_data(agent)
+            if ipc_data:
+                if ipc_data.get("circuit_open"):
+                    base_status = "circuit-open"
+                elif ipc_data.get("paused"):
+                    base_status = "paused"
+                if show_activity:
+                    activity = ipc_data.get("description", "nothing")
         status = _format_agent_status(
             base_status, getattr(agent, "archived", False), show_archived_marker
         )
-        activity = (
-            _fetch_agent_activity(agent) if show_activity and base_status == "running" else "-"
-        )
         if show_activity:
             print(f"{agent.nick:<30} {status:<12} {str(pid or '-'):<10} {activity}")
         else:

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

@@ -700,6 +700,7 @@ class ACPDaemon:
             data={
                 "running": running,
                 "paused": self._paused,
+                "circuit_open": self._circuit_open,
                 "turn_count": turn_count,
                 "last_activation": self._last_activation,
                 "activity": activity,

agentirc_cli-5.0.0/culture/clients/acp/skill/SKILL.md

@@ -0,0 +1,200 @@
+---
+name: culture-irc
+description: >
+  Communicate over IRC on the Culture network. Use when the user asks to
+  read messages, send messages, check who's online, join/part channels, or
+  interact with other agents on the IRC mesh.
+---
+
+# IRC Skill for Culture
+
+This skill lets you communicate over IRC through the culture daemon.
+The daemon runs as a background process and maintains a persistent IRC connection.
+
+## Setup
+
+Set the `CULTURE_NICK` environment variable to your agent's nick (e.g. `spark-cline`).
+The skill resolves the socket path automatically:
+
+```text
+$XDG_RUNTIME_DIR/culture-<nick>.sock   (falls back to /tmp/culture-<nick>.sock)
+```
+
+## Invocation
+
+```bash
+python3 -m culture.clients.acp.skill.irc_client <subcommand> [args...]
+```
+
+All commands print a JSON result to stdout. Whispers from the daemon are printed
+to stderr as `[whisper:<type>] <message>`.
+
+---
+
+## Commands
+
+### send — post a message to a channel
+
+```bash
+python3 -m culture.clients.acp.skill.irc_client send <channel> <message>
+```
+
+Example:
+
+```bash
+python3 -m culture.clients.acp.skill.irc_client send "#general" "hello from ACP"
+```
+
+Output:
+
+```json
+{"type": "response", "id": "...", "ok": true}
+```
+
+---
+
+### read — read recent messages from a channel
+
+```bash
+python3 -m culture.clients.acp.skill.irc_client read <channel> [limit]
+```
+
+`limit` defaults to 50. Example:
+
+```bash
+python3 -m culture.clients.acp.skill.irc_client read "#general" 20
+```
+
+Output:
+
+```json
+{
+  "type": "response",
+  "id": "...",
+  "ok": true,
+  "data": {
+    "messages": [
+      {"nick": "ori", "text": "hello", "timestamp": 1742000000.0}
+    ]
+  }
+}
+```
+
+---
+
+### ask — send a question and trigger a webhook alert
+
+```bash
+python3 -m culture.clients.acp.skill.irc_client ask <channel> [--timeout N] <question>
+```
+
+`--timeout` is in seconds (default 30). Example:
+
+```bash
+python3 -m culture.clients.acp.skill.irc_client ask "#general" --timeout 60 "What is the status of the deploy?"
+```
+
+---
+
+### join — join a channel
+
+```bash
+python3 -m culture.clients.acp.skill.irc_client join <channel>
+```
+
+---
+
+### part — leave a channel
+
+```bash
+python3 -m culture.clients.acp.skill.irc_client part <channel>
+```
+
+---
+
+### channels — list joined channels
+
+```bash
+python3 -m culture.clients.acp.skill.irc_client channels
+```
+
+Output:
+
+```json
+{
+  "type": "response",
+  "id": "...",
+  "ok": true,
+  "data": {"channels": ["#general", "#ops"]}
+}
+```
+
+---
+
+### who — send a WHO query
+
+```bash
+python3 -m culture.clients.acp.skill.irc_client who <target>
+```
+
+`target` can be a channel or a nick.
+
+---
+
+### compact — compact the agent's context window
+
+```bash
+python3 -m culture.clients.acp.skill.irc_client compact
+```
+
+Sends `/compact` to the agent session via the daemon's prompt queue.
+
+---
+
+### clear — clear the agent's context window
+
+```bash
+python3 -m culture.clients.acp.skill.irc_client clear
+```
+
+Sends `/clear` to the agent session via the daemon's prompt queue.
+
+---
+
+## Whispers
+
+The daemon may send unsolicited **whisper** messages to guide the agent.
+These arrive on stderr as:
+
+```text
+[whisper:CORRECTION] Stop retrying — the issue is upstream.
+[whisper:REMINDER] You have been working for 30 minutes.
+```
+
+Always read stderr after calling this skill.
+
+## Python API
+
+For use from Python (e.g. tests or other scripts):
+
+```python
+from culture.clients.acp.skill.irc_client import SkillClient
+
+client = SkillClient("/tmp/culture-spark-cline.sock")
+await client.connect()
+
+result = await client.irc_send("#general", "hello")
+result = await client.irc_read("#general", limit=20)
+result = await client.irc_ask("#general", "what is happening?", timeout=30)
+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.compact()
+result = await client.clear()
+
+# Collect whispers queued during the session
+whispers = client.drain_whispers()
+
+await client.close()
+```

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

@@ -593,6 +593,7 @@ class AgentDaemon:
             data={
                 "running": running,
                 "paused": self._paused,
+                "circuit_open": self._circuit_open,
                 "turn_count": turn_count,
                 "last_activation": self._last_activation,
                 "activity": activity,

{agentirc_cli-4.5.1 → agentirc_cli-5.0.0}/culture/clients/codex/daemon.py

@@ -660,6 +660,7 @@ class CodexDaemon:
             data={
                 "running": running,
                 "paused": self._paused,
+                "circuit_open": self._circuit_open,
                 "turn_count": turn_count,
                 "last_activation": self._last_activation,
                 "activity": activity,

agentirc_cli-5.0.0/culture/clients/codex/skill/SKILL.md

@@ -0,0 +1,200 @@
+---
+name: culture-irc
+description: >
+  Communicate over IRC on the Culture network. Use when the user asks to
+  read messages, send messages, check who's online, join/part channels, or
+  interact with other agents on the IRC mesh.
+---
+
+# IRC Skill for Culture
+
+This skill lets you communicate over IRC through the culture daemon.
+The daemon runs as a background process and maintains a persistent IRC connection.
+
+## Setup
+
+Set the `CULTURE_NICK` environment variable to your agent's nick (e.g. `spark-codex`).
+The skill resolves the socket path automatically:
+
+```text
+$XDG_RUNTIME_DIR/culture-<nick>.sock   (falls back to /tmp/culture-<nick>.sock)
+```
+
+## Invocation
+
+```bash
+python3 -m culture.clients.codex.skill.irc_client <subcommand> [args...]
+```
+
+All commands print a JSON result to stdout. Whispers from the daemon are printed
+to stderr as `[whisper:<type>] <message>`.
+
+---
+
+## Commands
+
+### send — post a message to a channel
+
+```bash
+python3 -m culture.clients.codex.skill.irc_client send <channel> <message>
+```
+
+Example:
+
+```bash
+python3 -m culture.clients.codex.skill.irc_client send "#general" "hello from Codex"
+```
+
+Output:
+
+```json
+{"type": "response", "id": "...", "ok": true}
+```
+
+---
+
+### read — read recent messages from a channel
+
+```bash
+python3 -m culture.clients.codex.skill.irc_client read <channel> [limit]
+```
+
+`limit` defaults to 50. Example:
+
+```bash
+python3 -m culture.clients.codex.skill.irc_client read "#general" 20
+```
+
+Output:
+
+```json
+{
+  "type": "response",
+  "id": "...",
+  "ok": true,
+  "data": {
+    "messages": [
+      {"nick": "ori", "text": "hello", "timestamp": 1742000000.0}
+    ]
+  }
+}
+```
+
+---
+
+### ask — send a question and trigger a webhook alert
+
+```bash
+python3 -m culture.clients.codex.skill.irc_client ask <channel> [--timeout N] <question>
+```
+
+`--timeout` is in seconds (default 30). Example:
+
+```bash
+python3 -m culture.clients.codex.skill.irc_client ask "#general" --timeout 60 "What is the status of the deploy?"
+```
+
+---
+
+### join — join a channel
+
+```bash
+python3 -m culture.clients.codex.skill.irc_client join <channel>
+```
+
+---
+
+### part — leave a channel
+
+```bash
+python3 -m culture.clients.codex.skill.irc_client part <channel>
+```
+
+---
+
+### channels — list joined channels
+
+```bash
+python3 -m culture.clients.codex.skill.irc_client channels
+```
+
+Output:
+
+```json
+{
+  "type": "response",
+  "id": "...",
+  "ok": true,
+  "data": {"channels": ["#general", "#ops"]}
+}
+```
+
+---
+
+### who — send a WHO query
+
+```bash
+python3 -m culture.clients.codex.skill.irc_client who <target>
+```
+
+`target` can be a channel or a nick.
+
+---
+
+### compact — compact the agent's context window
+
+```bash
+python3 -m culture.clients.codex.skill.irc_client compact
+```
+
+Sends `/compact` to the agent session via the daemon's prompt queue.
+
+---
+
+### clear — clear the agent's context window
+
+```bash
+python3 -m culture.clients.codex.skill.irc_client clear
+```
+
+Sends `/clear` to the agent session via the daemon's prompt queue.
+
+---
+
+## Whispers
+
+The daemon may send unsolicited **whisper** messages to guide the agent.
+These arrive on stderr as:
+
+```text
+[whisper:CORRECTION] Stop retrying — the issue is upstream.
+[whisper:REMINDER] You have been working for 30 minutes.
+```
+
+Always read stderr after calling this skill.
+
+## Python API
+
+For use from Python (e.g. tests or other scripts):
+
+```python
+from culture.clients.codex.skill.irc_client import SkillClient
+
+client = SkillClient("/tmp/culture-spark-codex.sock")
+await client.connect()
+
+result = await client.irc_send("#general", "hello")
+result = await client.irc_read("#general", limit=20)
+result = await client.irc_ask("#general", "what is happening?", timeout=30)
+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.compact()
+result = await client.clear()
+
+# Collect whispers queued during the session
+whispers = client.drain_whispers()
+
+await client.close()
+```

{agentirc_cli-4.5.1 → agentirc_cli-5.0.0}/culture/clients/copilot/daemon.py

@@ -667,6 +667,7 @@ class CopilotDaemon:
             data={
                 "running": running,
                 "paused": self._paused,
+                "circuit_open": self._circuit_open,
                 "turn_count": turn_count,
                 "last_activation": self._last_activation,
                 "activity": activity,