agentirc-cli 4.3.5__tar.gz → 4.3.7__tar.gz

{agentirc_cli-4.3.5 → agentirc_cli-4.3.7}/CHANGELOG.md

@@ -4,6 +4,43 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [4.3.7] - 2026-04-07
+
+
+### Fixed
+
+- Extract duplicate string constants (S1192, #85)
+- Remove redundant exception classes in except clauses (S5713, #86)
+- Clean up unused variables and function parameters (S1481/S1172, #88)
+- Remove f-strings without replacement fields (S3457, #89)
+- Address hardcoded credential warnings with test constants (S2068, #90)
+- Fix miscellaneous code quality issues: asyncio.timeout, nested ternaries, empty methods, CSS contrast (S7483/S3358/S1186/S7924, #91)
+
+## [4.3.6] - 2026-04-07
+
+
+### Changed
+
+- CLI module docstring updated with current subcommand sets (#147)
+
+
+### Fixed
+
+- agent message silently succeeds for nonexistent targets (#132)
+- channel message silently succeeds for nonexistent channels (#133)
+- agent sleep/wake error messages use wrong command names (#134)
+- server subcommands ignore default server, hardcode culture (#135)
+- agent start/stop inconsistent behavior with no nick argument (#137)
+- channel message and bot create accept empty strings (#138)
+- bot archive/unarchive missing --config flag (#139)
+- inconsistent error message casing in agent archive vs unarchive (#140)
+- channel commands show confusing timeout error when server is down (#141)
+- uncaught PackageNotFoundError in version fallback (#142)
+- culture --version flag not supported (#143)
+- agent/channel message silently succeeds for nonexistent or empty targets (#144)
+- channel read displays raw Unix timestamps instead of human-readable format (#145)
+- server default accepts nonexistent server names without validation (#146)
+
 ## [4.3.5] - 2026-04-07
 
 

{agentirc_cli-4.3.5 → agentirc_cli-4.3.7}/PKG-INFO

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

{agentirc_cli-4.3.5 → agentirc_cli-4.3.7}/culture/__init__.py

@@ -7,4 +7,7 @@ except PackageNotFoundError:
     try:
         __version__ = _v("agentirc-cli")
     except PackageNotFoundError:
-        __version__ = _v("agentirc")
+        try:
+            __version__ = _v("agentirc")
+        except PackageNotFoundError:
+            __version__ = "0.0.0-dev"

{agentirc_cli-4.3.5 → agentirc_cli-4.3.7}/culture/bots/bot_manager.py

@@ -6,15 +6,19 @@ import logging
 from typing import TYPE_CHECKING
 
 from culture.bots.bot import Bot
-from culture.bots.config import BOTS_DIR, BotConfig, load_bot_config, save_bot_config
+from culture.bots.config import (
+    BOT_CONFIG_FILE,
+    BOTS_DIR,
+    BotConfig,
+    load_bot_config,
+    save_bot_config,
+)
 
 if TYPE_CHECKING:
     from culture.server.ircd import IRCd
 
 logger = logging.getLogger(__name__)
 
-BOT_CONFIG_FILE = "bot.yaml"
-
 
 class BotManager:
     """Loads, starts, stops, and dispatches webhooks to bots."""

{agentirc_cli-4.3.5 → agentirc_cli-4.3.7}/culture/bots/config.py

@@ -10,6 +10,7 @@ from pathlib import Path
 import yaml
 
 BOTS_DIR = Path(os.path.expanduser("~/.culture/bots"))
+BOT_CONFIG_FILE = "bot.yaml"
 
 
 @dataclass

{agentirc_cli-4.3.5 → agentirc_cli-4.3.7}/culture/cli/__init__.py

@@ -1,11 +1,11 @@
 """Unified CLI entry point for culture.
 
 Commands are organized into noun-based groups:
-    culture agent    {create,join,start,stop,status,rename,assign,sleep,wake,learn,message,read}
-    culture server   {start,stop,status,default,rename}
+    culture agent    {create,join,start,stop,status,rename,assign,sleep,wake,learn,message,read,archive,unarchive,delete}
+    culture server   {start,stop,status,default,rename,archive,unarchive}
     culture mesh     {overview,setup,update,console}
     culture channel  {list,read,message,who}
-    culture bot      {create,start,stop,list,inspect}
+    culture bot      {create,start,stop,list,inspect,archive,unarchive}
     culture skills   {install}
 """
 
@@ -15,6 +15,7 @@ import argparse
 import logging
 import sys
 
+from culture import __version__
 from culture.cli import agent, bot, channel, mesh, server, skills
 
 GROUPS = [agent, server, mesh, channel, bot, skills]
@@ -25,6 +26,7 @@ def _build_parser() -> argparse.ArgumentParser:
         prog="culture",
         description="culture — AI agent IRC mesh",
     )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
     sub = parser.add_subparsers(dest="command")
     for group in GROUPS:
         group.register(sub)

{agentirc_cli-4.3.5 → agentirc_cli-4.3.7}/culture/cli/agent.py

@@ -399,7 +399,7 @@ def _probe_server_connection(host: str, port: int, server_name: str) -> None:
     try:
         with _socket.create_connection((host, port), timeout=2):
             pass
-    except (ConnectionRefusedError, OSError):
+    except OSError:
         hint = ""
         server_pid = read_pid(f"server-{server_name}")
         if not server_pid or not is_process_alive(server_pid):
@@ -591,10 +591,17 @@ def _resolve_agents_to_stop(config, args) -> list:
     if len(config.agents) == 0:
         print(NO_AGENTS_MSG, file=sys.stderr)
         sys.exit(1)
+    # Multiple agents: try to match by current working directory
+    cwd_real = os.path.realpath(os.getcwd())
+    cwd_matches = [a for a in config.agents if os.path.realpath(a.directory) == cwd_real]
+    if len(cwd_matches) == 1:
+        return cwd_matches
     print(
         "Multiple agents configured. Specify a nick or use --all.",
         file=sys.stderr,
     )
+    for a in config.agents:
+        print(f"  {a.nick}", file=sys.stderr)
     sys.exit(1)
 
 
@@ -763,13 +770,13 @@ def _cmd_assign(args: argparse.Namespace) -> None:
 # -----------------------------------------------------------------------
 
 
-def _resolve_ipc_targets(config, args, action_verb: str) -> list:
+def _resolve_ipc_targets(config, args, command_name: str) -> list:
     """Resolve which agents to send IPC messages to."""
     if args.nick and args.all:
         print("Cannot specify both nick and --all", file=sys.stderr)
         sys.exit(1)
     if not args.nick and not args.all:
-        print(f"Usage: culture agent {action_verb} <nick> or --all", file=sys.stderr)
+        print(f"Usage: culture agent {command_name} <nick> or --all", file=sys.stderr)
         sys.exit(1)
     if args.all:
         return config.agents
@@ -790,20 +797,22 @@ def _send_ipc(agent, msg_type: str, action_verb: str) -> None:
         print(f"{agent.nick}: failed (not running?)", file=sys.stderr)
 
 
-def _ipc_to_agents(args: argparse.Namespace, msg_type: str, action_verb: str) -> None:
+def _ipc_to_agents(
+    args: argparse.Namespace, msg_type: str, action_verb: str, command_name: str
+) -> None:
     """Send an IPC message (pause/resume) to one or all agents."""
     config = load_config_or_default(args.config)
-    targets = _resolve_ipc_targets(config, args, action_verb)
+    targets = _resolve_ipc_targets(config, args, command_name)
     for agent in targets:
         _send_ipc(agent, msg_type, action_verb)
 
 
 def _cmd_sleep(args: argparse.Namespace) -> None:
-    _ipc_to_agents(args, "pause", "paused")
+    _ipc_to_agents(args, "pause", "paused", "sleep")
 
 
 def _cmd_wake(args: argparse.Namespace) -> None:
-    _ipc_to_agents(args, "resume", "resumed")
+    _ipc_to_agents(args, "resume", "resumed", "wake")
 
 
 def _cmd_learn(args: argparse.Namespace) -> None:
@@ -838,6 +847,16 @@ def _cmd_learn(args: argparse.Namespace) -> None:
 
 
 def _cmd_message(args: argparse.Namespace) -> None:
+    if not args.target.strip():
+        print("Error: target nick cannot be empty", file=sys.stderr)
+        sys.exit(1)
+    if not args.text.strip():
+        print("Error: message text cannot be empty", file=sys.stderr)
+        sys.exit(1)
+    config = load_config_or_default(args.config)
+    if not config.get_agent(args.target):
+        print(f"Agent '{args.target}' not found in config", file=sys.stderr)
+        sys.exit(1)
     observer = get_observer(args.config)
     asyncio.run(observer.send_message(args.target, args.text))
     print(f"Sent to {args.target}")

{agentirc_cli-4.3.5 → agentirc_cli-4.3.7}/culture/cli/bot.py

@@ -49,9 +49,11 @@ def register(subparsers: argparse._SubParsersAction) -> None:
     bot_archive = bot_sub.add_parser("archive", help="Archive a bot")
     bot_archive.add_argument("name", help="Bot name to archive")
     bot_archive.add_argument("--reason", default="", help="Reason for archiving")
+    bot_archive.add_argument("--config", default=DEFAULT_CONFIG, help=_CONFIG_HELP)
 
     bot_unarchive = bot_sub.add_parser("unarchive", help="Restore an archived bot")
     bot_unarchive.add_argument("name", help="Bot name to unarchive")
+    bot_unarchive.add_argument("--config", default=DEFAULT_CONFIG, help=_CONFIG_HELP)
 
 
 def dispatch(args: argparse.Namespace) -> None:
@@ -87,6 +89,9 @@ def dispatch(args: argparse.Namespace) -> None:
 def _bot_create(args: argparse.Namespace) -> None:
     from culture.bots.config import BOTS_DIR, BotConfig, save_bot_config
 
+    if not args.name.strip():
+        print("Error: bot name cannot be empty", file=sys.stderr)
+        sys.exit(1)
     name = args.name
     config = load_config_or_default(args.config)
     server_name = config.server.name

{agentirc_cli-4.3.5 → agentirc_cli-4.3.7}/culture/cli/channel.py

@@ -50,11 +50,26 @@ def dispatch(args: argparse.Namespace) -> None:
         "who": _cmd_who,
     }
     handler = handlers.get(args.channel_command)
-    if handler:
-        handler(args)
-    else:
+    if not handler:
         print(f"Unknown channel command: {args.channel_command}", file=sys.stderr)
         sys.exit(1)
+    try:
+        handler(args)
+    except (TimeoutError, OSError) as exc:
+        msg = str(exc)
+        if (
+            "Timed out" in msg
+            or "Connection refused" in msg
+            or "Connect call failed" in msg
+            or not msg  # TimeoutError from asyncio often has empty message
+        ):
+            print(
+                "Error: cannot connect to IRC server. Is the server running?\n"
+                "  Start it with: culture server start",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        raise
 
 
 # -----------------------------------------------------------------------
@@ -76,6 +91,9 @@ def _cmd_list(args: argparse.Namespace) -> None:
 
 
 def _cmd_read(args: argparse.Namespace) -> None:
+    if not args.target.strip():
+        print("Error: channel name cannot be empty", file=sys.stderr)
+        sys.exit(1)
     observer = get_observer(args.config)
     channel = args.target if args.target.startswith("#") else f"#{args.target}"
     messages = asyncio.run(observer.read_channel(channel, limit=args.limit))
@@ -89,6 +107,12 @@ def _cmd_read(args: argparse.Namespace) -> None:
 
 
 def _cmd_message(args: argparse.Namespace) -> None:
+    if not args.target.strip():
+        print("Error: channel name cannot be empty", file=sys.stderr)
+        sys.exit(1)
+    if not args.text.strip():
+        print("Error: message text cannot be empty", file=sys.stderr)
+        sys.exit(1)
     observer = get_observer(args.config)
     target = args.target if args.target.startswith("#") else f"#{args.target}"
     asyncio.run(observer.send_message(target, args.text))
@@ -96,6 +120,9 @@ def _cmd_message(args: argparse.Namespace) -> None:
 
 
 def _cmd_who(args: argparse.Namespace) -> None:
+    if not args.target.strip():
+        print("Error: channel name cannot be empty", file=sys.stderr)
+        sys.exit(1)
     observer = get_observer(args.config)
     target = args.target
     nicks = asyncio.run(observer.who(target))

{agentirc_cli-4.3.5 → agentirc_cli-4.3.7}/culture/cli/mesh.py

@@ -15,7 +15,6 @@ from culture.clients.claude.config import (
     load_config,
     load_config_or_default,
 )
-from culture.pidfile import is_process_alive, read_pid
 
 from .shared.constants import AGENTS_YAML, CULTURE_DIR, DEFAULT_CONFIG
 from .shared.mesh import build_server_start_cmd, generate_mesh_from_agents
@@ -469,7 +468,7 @@ def _wait_for_server_port(port: int, retries: int = 50, interval: float = 0.1) -
         try:
             with _socket.create_connection(("localhost", port), timeout=1):
                 return
-        except (ConnectionRefusedError, OSError):
+        except OSError:
             time.sleep(interval)
 
 

{agentirc_cli-4.3.5 → agentirc_cli-4.3.7}/culture/cli/server.py

@@ -1,4 +1,4 @@
-"""Server subcommands: culture server {start,stop,status,default,rename}."""
+"""Server subcommands: culture server {start,stop,status,default,rename,archive,unarchive}."""
 
 from __future__ import annotations
 
@@ -14,6 +14,7 @@ import time
 from culture.pidfile import (
     is_culture_process,
     is_process_alive,
+    read_default_server,
     read_pid,
     remove_pid,
     write_pid,
@@ -32,13 +33,22 @@ logger = logging.getLogger("culture")
 
 NAME = "server"
 
+_DEFAULT_SERVER = "culture"
+
+
+def _resolve_server_name(args: argparse.Namespace) -> str:
+    """Resolve the server name from args, default server file, or fallback."""
+    if args.name is not None:
+        return args.name
+    return read_default_server() or _DEFAULT_SERVER
+
 
 def register(subparsers: argparse._SubParsersAction) -> None:
     server_parser = subparsers.add_parser("server", help="Manage the IRC server")
     server_sub = server_parser.add_subparsers(dest="server_command")
 
     srv_start = server_sub.add_parser("start", help="Start the IRC server daemon")
-    srv_start.add_argument("--name", default="culture", help=_SERVER_NAME_HELP)
+    srv_start.add_argument("--name", default=None, help=_SERVER_NAME_HELP)
     srv_start.add_argument("--host", default="0.0.0.0", help="Listen address")
     srv_start.add_argument("--port", type=int, default=6667, help="Listen port")
     srv_start.add_argument(
@@ -66,10 +76,10 @@ def register(subparsers: argparse._SubParsersAction) -> None:
     )
 
     srv_stop = server_sub.add_parser("stop", help="Stop the IRC server daemon")
-    srv_stop.add_argument("--name", default="culture", help=_SERVER_NAME_HELP)
+    srv_stop.add_argument("--name", default=None, help=_SERVER_NAME_HELP)
 
     srv_status = server_sub.add_parser("status", help="Check server daemon status")
-    srv_status.add_argument("--name", default="culture", help=_SERVER_NAME_HELP)
+    srv_status.add_argument("--name", default=None, help=_SERVER_NAME_HELP)
 
     srv_default = server_sub.add_parser("default", help="Set default server")
     srv_default.add_argument("name", help="Server name to set as default")
@@ -87,7 +97,7 @@ def register(subparsers: argparse._SubParsersAction) -> None:
     srv_archive = server_sub.add_parser(
         "archive", help="Archive the server and all its agents/bots"
     )
-    srv_archive.add_argument("--name", default="culture", help=_SERVER_NAME_HELP)
+    srv_archive.add_argument("--name", default=None, help=_SERVER_NAME_HELP)
     srv_archive.add_argument("--reason", default="", help="Reason for archiving")
     srv_archive.add_argument(
         "--config",
@@ -98,7 +108,7 @@ def register(subparsers: argparse._SubParsersAction) -> None:
     srv_unarchive = server_sub.add_parser(
         "unarchive", help="Restore an archived server and all its agents/bots"
     )
-    srv_unarchive.add_argument("--name", default="culture", help=_SERVER_NAME_HELP)
+    srv_unarchive.add_argument("--name", default=None, help=_SERVER_NAME_HELP)
     srv_unarchive.add_argument(
         "--config",
         default=DEFAULT_CONFIG,
@@ -114,6 +124,10 @@ def dispatch(args: argparse.Namespace) -> None:
         )
         sys.exit(1)
 
+    # Resolve --name for commands that use it (all except default/rename)
+    if args.server_command not in ("default", "rename") and hasattr(args, "name"):
+        args.name = _resolve_server_name(args)
+
     if args.server_command == "start":
         _server_start(args)
     elif args.server_command == "stop":
@@ -121,8 +135,40 @@ def dispatch(args: argparse.Namespace) -> None:
     elif args.server_command == "status":
         _server_status(args)
     elif args.server_command == "default":
-        from culture.pidfile import write_default_server
+        from pathlib import Path
+
+        from culture.pidfile import PID_DIR, list_servers, write_default_server
 
+        from .shared.constants import DEFAULT_CONFIG
+
+        # Accept the name if: it matches a running server, has a PID file,
+        # or matches the configured server name.
+        known_running = {s["name"] for s in list_servers()}
+        pid_dir = Path(PID_DIR)
+        known_pids = set()
+        if pid_dir.exists():
+            prefix = "server-"
+            for p in pid_dir.glob(f"{prefix}*.pid"):
+                known_pids.add(p.stem[len(prefix) :])
+        known_names = known_running | known_pids
+
+        # Also accept the configured server name
+        try:
+            from culture.clients.claude.config import load_config_or_default
+
+            config = load_config_or_default(DEFAULT_CONFIG)
+            known_names.add(config.server.name)
+        except Exception:
+            pass
+
+        if args.name not in known_names:
+            print(f"Server '{args.name}' not found.", file=sys.stderr)
+            if known_names:
+                print(
+                    f"Known servers: {', '.join(sorted(known_names))}",
+                    file=sys.stderr,
+                )
+            sys.exit(1)
         write_default_server(args.name)
         print(f"Default server set to '{args.name}'")
     elif args.server_command == "rename":

{agentirc_cli-4.3.5 → agentirc_cli-4.3.7}/culture/cli/shared/constants.py

@@ -2,6 +2,8 @@
 
 import os
 
+from culture.bots.config import BOT_CONFIG_FILE  # noqa: F401
+
 DEFAULT_CONFIG = os.path.expanduser("~/.culture/agents.yaml")
 LOG_DIR = os.path.expanduser("~/.culture/logs")
 
@@ -9,7 +11,6 @@ _CONFIG_HELP = "Config file path"
 _SERVER_NAME_HELP = "Server name"
 _BOT_NAME_HELP = "Bot name"
 
-BOT_CONFIG_FILE = "bot.yaml"
 DEFAULT_CHANNEL = "#general"
 NO_AGENTS_MSG = "No agents configured"
 CULTURE_DIR = ".culture"

agentirc_cli-4.3.7/culture/cli/shared/formatting.py

@@ -0,0 +1,5 @@
+"""Re-export formatting utilities from culture.formatting."""
+
+from culture.formatting import relative_time
+
+__all__ = ["relative_time"]

{agentirc_cli-4.3.5 → agentirc_cli-4.3.7}/culture/cli/shared/ipc.py

@@ -24,7 +24,7 @@ async def ipc_request(socket_path: str, msg_type: str, **kwargs) -> dict | None:
             asyncio.open_unix_connection(socket_path),
             timeout=3.0,
         )
-    except (ConnectionRefusedError, FileNotFoundError, OSError):
+    except OSError:
         return None
     try:
         req = make_request(msg_type, **kwargs)
@@ -40,13 +40,13 @@ async def ipc_request(socket_path: str, msg_type: str, **kwargs) -> dict | None:
             msg = decode_message(data)
             if msg and msg.get("type") == "response":
                 return msg
-    except (asyncio.TimeoutError, ConnectionError, BrokenPipeError, OSError):
+    except OSError:
         return None
     finally:
         writer.close()
         try:
             await writer.wait_closed()
-        except (ConnectionError, BrokenPipeError, OSError):
+        except OSError:
             pass
 
 

{agentirc_cli-4.3.5 → agentirc_cli-4.3.7}/culture/clients/acp/agent_runner.py

@@ -151,7 +151,8 @@ class ACPAgentRunner:
             return
         try:
             self._process.terminate()
-            await asyncio.wait_for(self._process.wait(), timeout=5)
+            async with asyncio.timeout(5):
+                await self._process.wait()
         except (asyncio.TimeoutError, ProcessLookupError):
             try:
                 self._process.kill()
@@ -209,7 +210,8 @@ class ACPAgentRunner:
         await self._process.stdin.drain()
 
         try:
-            return await asyncio.wait_for(future, timeout=timeout)
+            async with asyncio.timeout(timeout):
+                return await future
         except (asyncio.TimeoutError, asyncio.CancelledError):
             self._pending.pop(req_id, None)
             if not future.done():
@@ -244,14 +246,16 @@ class ACPAgentRunner:
         if not self._process:
             return -1
         try:
-            return await asyncio.wait_for(self._process.wait(), timeout=5)
+            async with asyncio.timeout(5):
+                return await self._process.wait()
         except asyncio.TimeoutError:
             try:
                 self._process.kill()
             except ProcessLookupError:
                 pass
             try:
-                return await asyncio.wait_for(self._process.wait(), timeout=1)
+                async with asyncio.timeout(1):
+                    return await self._process.wait()
             except asyncio.TimeoutError:
                 return -1
 

{agentirc_cli-4.3.5 → agentirc_cli-4.3.7}/culture/clients/acp/config.py

@@ -175,7 +175,7 @@ def add_agent_to_config(
     # Check for nick collision
     for existing in config.agents:
         if existing.nick == agent.nick:
-            raise ValueError(f"agent with nick {agent.nick!r} already exists in config")
+            raise ValueError(f"Agent with nick {agent.nick!r} already exists in config")
 
     config.agents.append(agent)
     save_config(path, config)
@@ -238,7 +238,7 @@ def rename_agent(
     # Check new nick doesn't collide
     for agent in config.agents:
         if agent.nick == new_nick:
-            raise ValueError(f"agent with nick {new_nick!r} already exists in config")
+            raise ValueError(f"Agent with nick {new_nick!r} already exists in config")
 
     # Find and rename
     for agent in config.agents:
@@ -247,7 +247,7 @@ def rename_agent(
             save_config(path, config)
             return
 
-    raise ValueError(f"agent {old_nick!r} not found in config")
+    raise ValueError(f"Agent {old_nick!r} not found in config")
 
 
 def remove_agent(
@@ -262,7 +262,7 @@ def remove_agent(
     """
     path = Path(path)
     if not path.exists():
-        raise ValueError(f"agent {nick!r} not found in config")
+        raise ValueError(f"Agent {nick!r} not found in config")
 
     with open(path) as f:
         raw = yaml.safe_load(f) or {}
@@ -274,4 +274,4 @@ def remove_agent(
             with open(path, "w") as f:
                 yaml.dump(raw, f, default_flow_style=False, sort_keys=False)
             return
-    raise ValueError(f"agent {nick!r} not found in config")
+    raise ValueError(f"Agent {nick!r} not found in config")

{agentirc_cli-4.3.5 → agentirc_cli-4.3.7}/culture/clients/acp/daemon.py

@@ -31,6 +31,8 @@ logger = logging.getLogger(__name__)
 
 # IPC validation error messages
 _ERR_MISSING_CHANNEL = "Missing 'channel'"
+_ERR_MISSING_CHANNEL_THREAD = "Missing 'channel' or 'thread'"
+_ERR_MISSING_CHANNEL_THREAD_MSG = "Missing 'channel', 'thread', or 'message'"
 
 MAX_CRASH_COUNT = 3
 CRASH_WINDOW_SECONDS = 300
@@ -304,7 +306,7 @@ class ACPDaemon:
         prompt = (
             f"[IRC Channel Poll: {channel}] Recent unread messages:\n"
             f"{lines}\n\n"
-            f"Respond naturally if any messages need your attention."
+            "Respond naturally if any messages need your attention."
         )
         self._mention_targets.append(channel)
         task = asyncio.create_task(self._agent_runner.send_prompt(prompt))
@@ -485,10 +487,10 @@ class ACPDaemon:
             return self.agent.system_prompt
         return (
             f"You are {self.agent.nick}, an AI agent on the culture IRC network.\n"
-            f"You have IRC tools available via the irc skill. Use them to communicate.\n"
+            "You have IRC tools available via the irc skill. Use them to communicate.\n"
             f"Your working directory is {self.agent.directory}.\n"
-            f"Check IRC channels periodically with irc_read() for new messages.\n"
-            f"When you finish a task, share results in the appropriate channel with irc_send()."
+            "Check IRC channels periodically with irc_read() for new messages.\n"
+            "When you finish a task, share results in the appropriate channel with irc_send()."
         )
 
     async def _record_crash_time(self, exit_code: int) -> None:
@@ -642,6 +644,13 @@ class ACPDaemon:
         if query and running and not self._paused:
             description = await self._query_agent_status()
 
+        if self._paused:
+            activity = "paused"
+        elif running:
+            activity = "working"
+        else:
+            activity = "idle"
+
         return make_response(
             req_id,
             ok=True,
@@ -650,7 +659,7 @@ class ACPDaemon:
                 "paused": self._paused,
                 "turn_count": turn_count,
                 "last_activation": self._last_activation,
-                "activity": "paused" if self._paused else ("working" if running else "idle"),
+                "activity": activity,
                 "description": description,
             },
         )
@@ -687,7 +696,8 @@ class ACPDaemon:
                 "[SYSTEM] Briefly describe what you are currently working on "
                 "in one sentence. Reply with just the description, no preamble."
             )
-            await asyncio.wait_for(self._status_query_event.wait(), timeout=10.0)
+            async with asyncio.timeout(10.0):
+                await self._status_query_event.wait()
             return self._truncate_first_line(self._status_query_response) or "nothing"
         except asyncio.TimeoutError:
             return "busy (no response)"
@@ -744,9 +754,7 @@ class ACPDaemon:
         thread_name = msg.get("thread", "")
         text = msg.get("message", "")
         if not channel or not thread_name or not text:
-            return make_response(
-                req_id, ok=False, error="Missing 'channel', 'thread', or 'message'"
-            )
+            return make_response(req_id, ok=False, error=_ERR_MISSING_CHANNEL_THREAD_MSG)
         assert self._transport is not None
         await self._transport.send_thread_create(channel, thread_name, text)
         return make_response(req_id, ok=True)
@@ -756,9 +764,7 @@ class ACPDaemon:
         thread_name = msg.get("thread", "")
         text = msg.get("message", "")
         if not channel or not thread_name or not text:
-            return make_response(
-                req_id, ok=False, error="Missing 'channel', 'thread', or 'message'"
-            )
+            return make_response(req_id, ok=False, error=_ERR_MISSING_CHANNEL_THREAD_MSG)
         assert self._transport is not None
         await self._transport.send_thread_reply(channel, thread_name, text)
         return make_response(req_id, ok=True)
@@ -776,7 +782,7 @@ class ACPDaemon:
         thread_name = msg.get("thread", "")
         summary = msg.get("summary", "")
         if not channel or not thread_name:
-            return make_response(req_id, ok=False, error="Missing 'channel' or 'thread'")
+            return make_response(req_id, ok=False, error=_ERR_MISSING_CHANNEL_THREAD)
         assert self._transport is not None
         await self._transport.send_thread_close(channel, thread_name, summary)
         return make_response(req_id, ok=True)
@@ -786,7 +792,7 @@ class ACPDaemon:
         thread_name = msg.get("thread", "")
         limit = int(msg.get("limit", 50))
         if not channel or not thread_name:
-            return make_response(req_id, ok=False, error="Missing 'channel' or 'thread'")
+            return make_response(req_id, ok=False, error=_ERR_MISSING_CHANNEL_THREAD)
         assert self._buffer is not None
         messages = self._buffer.read_thread(channel, thread_name, limit=limit)
         return make_response(