agentirc-cli 4.1.3__tar.gz → 4.2.1__tar.gz

{agentirc_cli-4.1.3 → agentirc_cli-4.2.1}/CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [4.2.1] - 2026-04-07
+
+
+### Changed
+
+- Update dispatch patterns to use declarative maybe_await() utility for handling both sync and async handlers
+- Remove unnecessary async keyword from ~40 handler functions that never use await
+
+
+### Fixed
+
+- SonarCloud S7503: async functions that never await (issue #83)
+
+## [4.2.0] - 2026-04-07
+
+
+### Added
+
+- Archive and unarchive commands for servers, agents, and bots
+- Cascade archive: server archive automatically archives all agents and bots
+- Visibility filtering: archived entities hidden from default status/list views
+- --all flag on status/list to reveal archived entities
+- Start guard: archived entities cannot be started until unarchived
+
 ## [4.1.3] - 2026-04-06
 
 

{agentirc_cli-4.1.3 → agentirc_cli-4.2.1}/Gemfile

@@ -4,3 +4,4 @@ gem "jekyll", "~> 4.3"
 gem "just-the-docs", "~> 0.10"
 gem "jekyll-seo-tag"
 gem "jekyll-relative-links"
+gem "jekyll-sitemap"

{agentirc_cli-4.1.3 → agentirc_cli-4.2.1}/Gemfile.lock

@@ -81,6 +81,8 @@ GEM
       sass-embedded (~> 1.75)
     jekyll-seo-tag (2.8.0)
       jekyll (>= 3.8, < 5.0)
+    jekyll-sitemap (1.4.0)
+      jekyll (>= 3.7, < 5.0)
     jekyll-watch (2.2.1)
       listen (~> 3.0)
     json (2.19.2)
@@ -171,6 +173,7 @@ DEPENDENCIES
   jekyll (~> 4.3)
   jekyll-relative-links
   jekyll-seo-tag
+  jekyll-sitemap
   just-the-docs (~> 0.10)
 
 CHECKSUMS
@@ -210,6 +213,7 @@ CHECKSUMS
   jekyll-relative-links (0.7.0) sha256=831e54c348eeae751845c0d4ac4b244bd73b664341f0e8c9f1803b16f4570835
   jekyll-sass-converter (3.1.0) sha256=83925d84f1d134410c11d0c6643b0093e82e3a3cf127e90757a85294a3862443
   jekyll-seo-tag (2.8.0) sha256=3f2ed1916d56f14ebfa38e24acde9b7c946df70cb183af2cb5f0598f21ae6818
+  jekyll-sitemap (1.4.0) sha256=0de08c5debc185ea5a8f980e1025c7cd3f8e0c35c8b6ef592f15c46235cf4218
   jekyll-watch (2.2.1) sha256=bc44ed43f5e0a552836245a54dbff3ea7421ecc2856707e8a1ee203a8387a7e1
   json (2.19.2) sha256=e7e1bd318b2c37c4ceee2444841c86539bc462e81f40d134cf97826cb14e83cf
   just-the-docs (0.12.0) sha256=15f2839ac9082898d60f33b978aa6f8e46fc50ba8fac20ae7a7f0e1fb295523e

{agentirc_cli-4.1.3 → agentirc_cli-4.2.1}/PKG-INFO

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

{agentirc_cli-4.1.3 → agentirc_cli-4.2.1}/_config.yml

@@ -24,6 +24,7 @@ footer_content: >-
 plugins:
   - jekyll-seo-tag
   - jekyll-relative-links
+  - jekyll-sitemap
 
 relative_links:
   enabled: true

agentirc_cli-4.2.1/culture/aio.py

@@ -0,0 +1,12 @@
+"""Async utilities for culture."""
+
+from __future__ import annotations
+
+import asyncio
+
+
+async def maybe_await(result):
+    """Await the result only if it's a coroutine, otherwise return directly."""
+    if asyncio.iscoroutine(result):
+        return await result
+    return result

{agentirc_cli-4.1.3 → agentirc_cli-4.2.1}/culture/bots/bot_manager.py

@@ -32,6 +32,9 @@ class BotManager:
                 continue
             try:
                 config = load_bot_config(yaml_path)
+                if config.archived:
+                    logger.info("Skipping archived bot %s", config.name)
+                    continue
                 bot = Bot(config, self.server)
                 self.bots[config.name] = bot
                 await bot.start()

{agentirc_cli-4.1.3 → agentirc_cli-4.2.1}/culture/bots/config.py

@@ -26,6 +26,9 @@ class BotConfig:
     mention: str | None = None
     template: str | None = None
     fallback: str = "json"
+    archived: bool = False
+    archived_at: str = ""
+    archived_reason: str = ""
 
     @property
     def has_handler(self) -> bool:
@@ -54,6 +57,9 @@ def load_bot_config(path: Path) -> BotConfig:
         mention=output_section.get("mention"),
         template=output_section.get("template"),
         fallback=output_section.get("fallback", "json"),
+        archived=bot_section.get("archived", False),
+        archived_at=bot_section.get("archived_at", ""),
+        archived_reason=bot_section.get("archived_reason", ""),
     )
 
 
@@ -61,13 +67,19 @@ def save_bot_config(path: Path, config: BotConfig) -> None:
     """Serialize a BotConfig to YAML and write atomically."""
     path.parent.mkdir(parents=True, exist_ok=True)
 
+    bot_section = {
+        "name": config.name,
+        "owner": config.owner,
+        "description": config.description,
+        "created": config.created,
+    }
+    if config.archived:
+        bot_section["archived"] = config.archived
+        bot_section["archived_at"] = config.archived_at
+        bot_section["archived_reason"] = config.archived_reason
+
     data = {
-        "bot": {
-            "name": config.name,
-            "owner": config.owner,
-            "description": config.description,
-            "created": config.created,
-        },
+        "bot": bot_section,
         "trigger": {
             "type": config.trigger_type,
         },

{agentirc_cli-4.1.3 → agentirc_cli-4.2.1}/culture/cli/_helpers.py

@@ -381,7 +381,9 @@ def print_agent_detail(agent, config_path: str, args: argparse.Namespace) -> Non
     print(f"  Config:     {config_path}")
 
 
-def print_agents_overview(agents: list, show_activity: bool) -> None:
+def print_agents_overview(
+    agents: list, show_activity: bool, show_archived_marker: bool = False
+) -> None:
     """Print a table of all agents with status, PID, and optionally activity."""
     if show_activity:
         print(f"{'NICK':<30} {'STATUS':<12} {'PID':<10} {'ACTIVITY'}")
@@ -391,10 +393,17 @@ def print_agents_overview(agents: list, show_activity: bool) -> None:
         print("-" * 52)
 
     for agent in agents:
-        status, pid = agent_process_status(agent)
+        archived = getattr(agent, "archived", False)
+        base_status, pid = agent_process_status(agent)
+        status = base_status
+        if archived:
+            if show_archived_marker:
+                status = f"{base_status} (archived)"
+            elif base_status == "stopped":
+                status = "archived"
         activity = "-"
 
-        if show_activity and status == "running":
+        if show_activity and base_status == "running":
             resp = asyncio.run(ipc_request(agent_socket_path(agent.nick), "status"))
             if resp and resp.get("ok"):
                 activity = resp.get("data", {}).get("description", "nothing")

{agentirc_cli-4.1.3 → agentirc_cli-4.2.1}/culture/cli/agent.py

@@ -13,9 +13,11 @@ from culture.clients.claude.config import (
     AgentConfig,
     DaemonConfig,
     add_agent_to_config,
+    archive_agent,
     load_config,
     load_config_or_default,
     sanitize_agent_name,
+    unarchive_agent,
 )
 from culture.pidfile import (
     is_process_alive,
@@ -99,6 +101,7 @@ def register(subparsers: argparse._SubParsersAction) -> None:
     status_parser.add_argument(
         "--full", action="store_true", help="Query agents for activity status"
     )
+    status_parser.add_argument("--all", action="store_true", help="Include archived agents")
     status_parser.add_argument("--config", default=DEFAULT_CONFIG, help=_CONFIG_HELP)
 
     # -- rename ---------------------------------------------------------------
@@ -144,11 +147,22 @@ def register(subparsers: argparse._SubParsersAction) -> None:
     read_parser.add_argument("--limit", "-n", type=int, default=50, help="Number of messages")
     read_parser.add_argument("--config", default=DEFAULT_CONFIG, help=_CONFIG_HELP)
 
+    # -- archive --------------------------------------------------------------
+    archive_parser = agent_sub.add_parser("archive", help="Archive an agent (stop and retire)")
+    archive_parser.add_argument("nick", help="Agent nick to archive")
+    archive_parser.add_argument("--reason", default="", help="Reason for archiving")
+    archive_parser.add_argument("--config", default=DEFAULT_CONFIG, help=_CONFIG_HELP)
+
+    # -- unarchive ------------------------------------------------------------
+    unarchive_parser = agent_sub.add_parser("unarchive", help="Restore an archived agent")
+    unarchive_parser.add_argument("nick", help="Agent nick to unarchive")
+    unarchive_parser.add_argument("--config", default=DEFAULT_CONFIG, help=_CONFIG_HELP)
+
 
 def dispatch(args: argparse.Namespace) -> None:
     if not args.agent_command:
         print(
-            "Usage: culture agent {create|join|start|stop|status|rename|assign|sleep|wake|learn|message|read}",
+            "Usage: culture agent {create|join|start|stop|status|rename|assign|sleep|wake|learn|message|read|archive|unarchive}",
             file=sys.stderr,
         )
         sys.exit(1)
@@ -166,6 +180,8 @@ def dispatch(args: argparse.Namespace) -> None:
         "learn": _cmd_learn,
         "message": _cmd_message,
         "read": _cmd_read,
+        "archive": _cmd_archive,
+        "unarchive": _cmd_unarchive,
     }
     handler = handlers.get(args.agent_command)
     if handler:
@@ -291,25 +307,42 @@ def _cmd_join(args: argparse.Namespace) -> None:
 def _resolve_agents_to_start(config, args) -> list:
     """Return the list of agents to start, or exit with an error message."""
     if args.all:
-        agents = config.agents
+        # Skip archived agents when starting --all
+        agents = [a for a in config.agents if not a.archived]
     elif args.nick:
         agent = config.get_agent(args.nick)
         if not agent:
             print(f"Agent '{args.nick}' not found in config", file=sys.stderr)
             sys.exit(1)
+        if agent.archived:
+            print(
+                f"Agent '{args.nick}' is archived. Unarchive first:",
+                file=sys.stderr,
+            )
+            print(f"  culture agent unarchive {args.nick}", file=sys.stderr)
+            sys.exit(1)
         agents = [agent]
     else:
-        if len(config.agents) == 1:
-            agents = config.agents
-        elif len(config.agents) == 0:
-            print("No agents configured. Run 'culture agent create' first.", file=sys.stderr)
+        active = [a for a in config.agents if not a.archived]
+        if len(active) == 1:
+            agents = active
+        elif len(active) == 0:
+            archived_count = sum(1 for a in config.agents if a.archived)
+            if archived_count:
+                print(
+                    f"No active agents ({archived_count} archived). "
+                    "Unarchive an agent or create a new one.",
+                    file=sys.stderr,
+                )
+            else:
+                print("No agents configured. Run 'culture agent create' first.", file=sys.stderr)
             sys.exit(1)
         else:
             print(
                 "Multiple agents configured. Specify a nick or use --all.",
                 file=sys.stderr,
             )
-            for a in config.agents:
+            for a in active:
                 print(f"  {a.nick}", file=sys.stderr)
             sys.exit(1)
 
@@ -527,9 +560,27 @@ def _cmd_status(args: argparse.Namespace) -> None:
             sys.exit(1)
 
         print_agent_detail(agent, args.config, args)
+        if agent.archived:
+            print(f"\n  [archived since {agent.archived_at}]")
+            if agent.archived_reason:
+                print(f"  Reason: {agent.archived_reason}")
+        return
+
+    show_all = getattr(args, "all", False)
+    if show_all:
+        agents = config.agents
+    else:
+        agents = [a for a in config.agents if not a.archived]
+
+    if not agents and not show_all:
+        archived_count = sum(1 for a in config.agents if a.archived)
+        if archived_count:
+            print(f"No active agents ({archived_count} archived, use --all to show)")
+        else:
+            print("No agents configured")
         return
 
-    print_agents_overview(config.agents, args.full)
+    print_agents_overview(agents, args.full, show_archived_marker=show_all)
     print_bot_listing()
 
 
@@ -738,3 +789,45 @@ def _cmd_read(args: argparse.Namespace) -> None:
     )
     print("Use 'culture channel read <channel>' for channel history.", file=sys.stderr)
     sys.exit(1)
+
+
+# -----------------------------------------------------------------------
+# Archive / Unarchive
+# -----------------------------------------------------------------------
+
+
+def _cmd_archive(args: argparse.Namespace) -> None:
+    """Archive an agent: stop if running, set archived flag."""
+    config = load_config_or_default(args.config)
+    agent = config.get_agent(args.nick)
+    if not agent:
+        print(f"Agent '{args.nick}' not found in config", file=sys.stderr)
+        sys.exit(1)
+
+    if agent.archived:
+        print(f"Agent '{args.nick}' is already archived")
+        return
+
+    # Stop the agent if it's running
+    pid = read_pid(f"agent-{args.nick}")
+    if pid and is_process_alive(pid):
+        stop_agent(args.nick)
+
+    archive_agent(args.config, args.nick, reason=args.reason)
+
+    print(f"Agent archived: {args.nick}")
+    if args.reason:
+        print(f"  Reason: {args.reason}")
+    print(f"\nTo restore: culture agent unarchive {args.nick}")
+
+
+def _cmd_unarchive(args: argparse.Namespace) -> None:
+    """Restore an archived agent."""
+    try:
+        unarchive_agent(args.config, args.nick)
+    except ValueError as exc:
+        print(str(exc), file=sys.stderr)
+        sys.exit(1)
+
+    print(f"Agent unarchived: {args.nick}")
+    print(f"\nStart with: culture agent start {args.nick}")

{agentirc_cli-4.1.3 → agentirc_cli-4.2.1}/culture/cli/bot.py

@@ -40,15 +40,26 @@ def register(subparsers: argparse._SubParsersAction) -> None:
 
     bot_list = bot_sub.add_parser("list", help="List bots")
     bot_list.add_argument("owner", nargs="?", default=None, help="Filter by owner nick")
+    bot_list.add_argument("--all", action="store_true", help="Include archived bots")
 
     bot_inspect = bot_sub.add_parser("inspect", help="Show bot details")
     bot_inspect.add_argument("name", help="Bot name")
     bot_inspect.add_argument("--config", default=DEFAULT_CONFIG, help=_CONFIG_HELP)
 
+    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_unarchive = bot_sub.add_parser("unarchive", help="Restore an archived bot")
+    bot_unarchive.add_argument("name", help="Bot name to unarchive")
+
 
 def dispatch(args: argparse.Namespace) -> None:
     if not args.bot_command:
-        print("Usage: culture bot {create|start|stop|list|inspect}", file=sys.stderr)
+        print(
+            "Usage: culture bot {create|start|stop|list|inspect|archive|unarchive}",
+            file=sys.stderr,
+        )
         sys.exit(1)
 
     handlers = {
@@ -57,6 +68,8 @@ def dispatch(args: argparse.Namespace) -> None:
         "stop": _bot_stop,
         "list": _bot_list,
         "inspect": _bot_inspect,
+        "archive": _bot_archive,
+        "unarchive": _bot_unarchive,
     }
     handler = handlers.get(args.bot_command)
     if handler:
@@ -146,6 +159,7 @@ def _bot_list(args: argparse.Namespace) -> None:
         print("No bots configured.")
         return
 
+    show_all = getattr(args, "all", False)
     bots = []
     for bot_dir in sorted(BOTS_DIR.iterdir()):
         yaml_path = bot_dir / "bot.yaml"
@@ -155,6 +169,8 @@ def _bot_list(args: argparse.Namespace) -> None:
             config = load_bot_config(yaml_path)
             if args.owner and config.owner != args.owner:
                 continue
+            if not show_all and config.archived:
+                continue
             bots.append(config)
         except Exception:
             continue
@@ -169,7 +185,10 @@ def _bot_list(args: argparse.Namespace) -> None:
     print(f"{'NAME':<35} {'TRIGGER':<10} {'CHANNELS':<20} {'OWNER':<20}")
     for config in bots:
         channels = ", ".join(config.channels) if config.channels else "-"
-        print(f"{config.name:<35} {config.trigger_type:<10} {channels:<20} {config.owner:<20}")
+        name = config.name
+        if show_all and config.archived:
+            name = f"{name} [archived]"
+        print(f"{name:<35} {config.trigger_type:<10} {channels:<20} {config.owner:<20}")
 
 
 def _bot_inspect(args: argparse.Namespace) -> None:
@@ -201,3 +220,61 @@ def _bot_inspect(args: argparse.Namespace) -> None:
             first_line = first_line[:57] + "..."
         print(f"Template:    {first_line}")
     print(f"Handler:     {'custom (handler.py)' if config.has_handler else 'template'}")
+    if config.archived:
+        print(f"Archived:    yes (since {config.archived_at})")
+        if config.archived_reason:
+            print(f"Reason:      {config.archived_reason}")
+
+
+# -----------------------------------------------------------------------
+# Archive / Unarchive
+# -----------------------------------------------------------------------
+
+
+def _bot_archive(args: argparse.Namespace) -> None:
+    import time as _time
+
+    from culture.bots.config import BOTS_DIR, load_bot_config, save_bot_config
+
+    bot_dir = BOTS_DIR / args.name
+    yaml_path = bot_dir / "bot.yaml"
+    if not yaml_path.is_file():
+        print(f"Bot '{args.name}' not found at {bot_dir}", file=sys.stderr)
+        sys.exit(1)
+
+    config = load_bot_config(yaml_path)
+    if config.archived:
+        print(f"Bot '{args.name}' is already archived")
+        return
+
+    config.archived = True
+    config.archived_at = _time.strftime("%Y-%m-%d")
+    config.archived_reason = args.reason
+    save_bot_config(yaml_path, config)
+
+    print(f"Bot archived: {args.name}")
+    if args.reason:
+        print(f"  Reason: {args.reason}")
+    print(f"\nTo restore: culture bot unarchive {args.name}")
+
+
+def _bot_unarchive(args: argparse.Namespace) -> None:
+    from culture.bots.config import BOTS_DIR, load_bot_config, save_bot_config
+
+    bot_dir = BOTS_DIR / args.name
+    yaml_path = bot_dir / "bot.yaml"
+    if not yaml_path.is_file():
+        print(f"Bot '{args.name}' not found at {bot_dir}", file=sys.stderr)
+        sys.exit(1)
+
+    config = load_bot_config(yaml_path)
+    if not config.archived:
+        print(f"Bot '{args.name}' is not archived", file=sys.stderr)
+        sys.exit(1)
+
+    config.archived = False
+    config.archived_at = ""
+    config.archived_reason = ""
+    save_bot_config(yaml_path, config)
+
+    print(f"Bot unarchived: {args.name}")

{agentirc_cli-4.1.3 → agentirc_cli-4.2.1}/culture/cli/server.py

@@ -77,10 +77,34 @@ def register(subparsers: argparse._SubParsersAction) -> None:
         help="Config file path",
     )
 
+    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")
+    srv_archive.add_argument("--reason", default="", help="Reason for archiving")
+    srv_archive.add_argument(
+        "--config",
+        default=os.path.expanduser("~/.culture/agents.yaml"),
+        help="Config file path",
+    )
+
+    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")
+    srv_unarchive.add_argument(
+        "--config",
+        default=os.path.expanduser("~/.culture/agents.yaml"),
+        help="Config file path",
+    )
+
 
 def dispatch(args: argparse.Namespace) -> None:
     if not args.server_command:
-        print("Usage: culture server {start|stop|status|default|rename}", file=sys.stderr)
+        print(
+            "Usage: culture server {start|stop|status|default|rename|archive|unarchive}",
+            file=sys.stderr,
+        )
         sys.exit(1)
 
     if args.server_command == "start":
@@ -96,6 +120,10 @@ def dispatch(args: argparse.Namespace) -> None:
         print(f"Default server set to '{args.name}'")
     elif args.server_command == "rename":
         _server_rename(args)
+    elif args.server_command == "archive":
+        _server_archive(args)
+    elif args.server_command == "unarchive":
+        _server_unarchive(args)
 
 
 # -----------------------------------------------------------------------
@@ -182,6 +210,19 @@ def _wait_for_port(
 
 
 def _server_start(args: argparse.Namespace) -> None:
+    # Check if server is archived
+    from culture.clients.claude.config import load_config_or_default
+
+    config_path = getattr(args, "config", os.path.expanduser("~/.culture/agents.yaml"))
+    config = load_config_or_default(config_path)
+    if config.server.name == args.name and config.server.archived:
+        print(
+            f"Server '{args.name}' is archived. Unarchive first:",
+            file=sys.stderr,
+        )
+        print(f"  culture server unarchive --name {args.name}", file=sys.stderr)
+        sys.exit(1)
+
     pid_name = f"server-{args.name}"
 
     existing = read_pid(pid_name)
@@ -363,3 +404,134 @@ def _server_status(args: argparse.Namespace) -> None:
     else:
         print(f"Server '{args.name}': not running (stale PID {pid})")
         remove_pid(pid_name)
+
+
+# -----------------------------------------------------------------------
+# Archive / Unarchive
+# -----------------------------------------------------------------------
+
+
+def _server_archive(args: argparse.Namespace) -> None:
+    """Archive the server and cascade to all agents and bots."""
+    from culture.bots.config import BOTS_DIR, load_bot_config, save_bot_config
+    from culture.clients.claude.config import (
+        archive_server,
+        load_config_or_default,
+    )
+
+    config = load_config_or_default(args.config)
+    server_name = config.server.name
+
+    if server_name != args.name:
+        print(
+            f"Server name mismatch: --name '{args.name}' but config has '{server_name}'",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    if config.server.archived:
+        print(f"Server '{server_name}' is already archived")
+        return
+
+    # Stop server if running
+    pid_name = f"server-{server_name}"
+    pid = read_pid(pid_name)
+    if pid and is_process_alive(pid):
+        print(f"Stopping server '{server_name}'...")
+        _server_stop(args)
+
+    # Stop all running agents
+    from culture.cli._helpers import stop_agent
+
+    for agent in config.agents:
+        agent_pid = read_pid(f"agent-{agent.nick}")
+        if agent_pid and is_process_alive(agent_pid):
+            stop_agent(agent.nick)
+
+    # Archive server + agents in config
+    archived_nicks = archive_server(args.config, reason=args.reason)
+
+    # Archive bots whose owner matches any agent on this server
+    import time as _time
+
+    today = _time.strftime("%Y-%m-%d")
+    agent_nicks = {a.nick for a in config.agents}
+    archived_bots = []
+    if BOTS_DIR.is_dir():
+        for bot_dir in BOTS_DIR.iterdir():
+            yaml_path = bot_dir / "bot.yaml"
+            if not yaml_path.is_file():
+                continue
+            try:
+                bot_config = load_bot_config(yaml_path)
+                if bot_config.owner in agent_nicks and not bot_config.archived:
+                    bot_config.archived = True
+                    bot_config.archived_at = today
+                    bot_config.archived_reason = args.reason
+                    save_bot_config(yaml_path, bot_config)
+                    archived_bots.append(bot_config.name)
+            except (OSError, ValueError) as exc:
+                print(f"  Warning: skipping bot '{bot_dir.name}': {exc}", file=sys.stderr)
+                continue
+
+    print(f"Server archived: {server_name}")
+    if args.reason:
+        print(f"  Reason: {args.reason}")
+    if archived_nicks:
+        print(f"  Agents: {', '.join(archived_nicks)}")
+    if archived_bots:
+        print(f"  Bots:   {', '.join(archived_bots)}")
+    print(f"\nTo restore: culture server unarchive --name {server_name}")
+
+
+def _server_unarchive(args: argparse.Namespace) -> None:
+    """Restore an archived server and cascade to agents and bots."""
+    from culture.bots.config import BOTS_DIR, load_bot_config, save_bot_config
+    from culture.clients.claude.config import (
+        load_config_or_default,
+        unarchive_server,
+    )
+
+    config = load_config_or_default(args.config)
+    server_name = config.server.name
+
+    if server_name != args.name:
+        print(
+            f"Server name mismatch: --name '{args.name}' but config has '{server_name}'",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    if not config.server.archived:
+        print(f"Server '{server_name}' is not archived", file=sys.stderr)
+        sys.exit(1)
+
+    # Unarchive server + agents
+    unarchived_nicks = unarchive_server(args.config)
+
+    # Unarchive bots whose owner matches any agent on this server
+    agent_nicks = {a.nick for a in config.agents}
+    unarchived_bots = []
+    if BOTS_DIR.is_dir():
+        for bot_dir in BOTS_DIR.iterdir():
+            yaml_path = bot_dir / "bot.yaml"
+            if not yaml_path.is_file():
+                continue
+            try:
+                bot_config = load_bot_config(yaml_path)
+                if bot_config.owner in agent_nicks and bot_config.archived:
+                    bot_config.archived = False
+                    bot_config.archived_at = ""
+                    bot_config.archived_reason = ""
+                    save_bot_config(yaml_path, bot_config)
+                    unarchived_bots.append(bot_config.name)
+            except (OSError, ValueError) as exc:
+                print(f"  Warning: skipping bot '{bot_dir.name}': {exc}", file=sys.stderr)
+                continue
+
+    print(f"Server unarchived: {server_name}")
+    if unarchived_nicks:
+        print(f"  Agents: {', '.join(unarchived_nicks)}")
+    if unarchived_bots:
+        print(f"  Bots:   {', '.join(unarchived_bots)}")
+    print(f"\nStart with: culture server start --name {server_name}")