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

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

@@ -4,6 +4,20 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [4.1.3] - 2026-04-06
+
+
+### Fixed
+
+- mesh update now discovers and restarts all running servers instead of only the one in mesh.yaml
+
+## [4.1.2] - 2026-04-06
+
+
+### Fixed
+
+- Clean up _mention_targets deque on prompt failure to prevent misrouted responses
+
 ## [4.1.1] - 2026-04-06
 
 

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

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

{agentirc_cli-4.1.1 → agentirc_cli-4.1.3}/culture/cli/mesh.py

@@ -549,23 +549,76 @@ def _restart_mesh_services(
                 check=False,
             )
 
-    print("\nUpdate complete. All services restarted.")
-
-
-def _cmd_update(args: argparse.Namespace) -> None:
-    from culture.mesh_config import load_mesh_config
+    print()
+
+
+def _resolve_mesh_for_server(server_name: str, config_path: str):
+    """Find or build a MeshConfig for *server_name*.
+
+    Resolution order:
+    1. mesh.yaml — use directly if its server.name matches.
+    2. agents.yaml — build via from_daemon_config(), preserving host, port,
+       and links from the old mesh.yaml. Saves the updated mesh.yaml so
+       future runs are consistent.
+    """
+    from culture.mesh_config import (
+        from_daemon_config,
+        load_mesh_config,
+        merge_links,
+        save_mesh_config,
+    )
 
+    old_server = None
     try:
-        mesh = load_mesh_config(args.config)
+        old_mesh = load_mesh_config(config_path)
+        if old_mesh.server.name == server_name:
+            return old_mesh
+        old_server = old_mesh.server
     except FileNotFoundError:
-        mesh = generate_mesh_from_agents(args.config)
-        if mesh is None:
-            sys.exit(1)
+        pass
+
+    if os.path.isfile(DEFAULT_CONFIG):
+        daemon_config = load_config(DEFAULT_CONFIG)
+        if daemon_config.server.name == server_name:
+            mesh = from_daemon_config(daemon_config)
+            if old_server is not None:
+                mesh.server.host = old_server.host
+                mesh.server.port = old_server.port
+                merge_links(mesh, old_server.links)
+            save_mesh_config(mesh, config_path)
+            return mesh
+
+    return None
 
-    server_name = mesh.server.name
+
+def _cmd_update(args: argparse.Namespace) -> None:
+    from culture.mesh_config import load_mesh_config
+    from culture.pidfile import list_servers
 
     if not _upgrade_culture_package(args):
         return
 
     culture_bin = shutil.which("culture") or "culture"
-    _restart_mesh_services(mesh, server_name, culture_bin, args.config, args.dry_run)
+
+    running = list_servers()
+
+    if running:
+        for srv in running:
+            mesh = _resolve_mesh_for_server(srv["name"], args.config)
+            if mesh is None:
+                print(
+                    f"  Warning: no config found for server '{srv['name']}', skipping",
+                    file=sys.stderr,
+                )
+                continue
+            _restart_mesh_services(mesh, srv["name"], culture_bin, args.config, args.dry_run)
+    else:
+        try:
+            mesh = load_mesh_config(args.config)
+        except FileNotFoundError:
+            mesh = generate_mesh_from_agents(args.config)
+            if mesh is None:
+                sys.exit(1)
+        _restart_mesh_services(mesh, mesh.server.name, culture_bin, args.config, args.dry_run)
+
+    print("Update complete. All services restarted.")

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

@@ -33,6 +33,7 @@ class ACPAgentRunner:
         system_prompt: str = "",
         on_exit: Callable[[int], Awaitable[None]] | None = None,
         on_message: Callable[[dict[str, Any]], Awaitable[None]] | None = None,
+        on_turn_error: Callable[[], Awaitable[None]] | None = None,
     ) -> None:
         self.model = model
         self.directory = directory
@@ -40,6 +41,7 @@ class ACPAgentRunner:
         self.system_prompt = system_prompt
         self.on_exit = on_exit
         self.on_message = on_message
+        self.on_turn_error = on_turn_error
 
         self._isolated_home: str | None = None
         self._process: asyncio.subprocess.Process | None = None
@@ -384,6 +386,8 @@ class ACPAgentRunner:
 
                 except Exception:
                     logger.exception("ACP turn error")
+                    if self.on_turn_error:
+                        await self.on_turn_error()
                 finally:
                     self._busy = False
 

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

@@ -318,6 +318,11 @@ class ACPDaemon:
     # Agent runner helpers
     # ------------------------------------------------------------------
 
+    async def _on_turn_error(self) -> None:
+        """Clean up stale relay target when a prompt fails."""
+        if self._mention_targets:
+            self._mention_targets.popleft()
+
     async def _start_agent_runner(self) -> None:
         self._agent_runner = ACPAgentRunner(
             model=self.agent.model,
@@ -326,6 +331,7 @@ class ACPDaemon:
             system_prompt=self._build_system_prompt(),
             on_exit=self._on_agent_exit,
             on_message=self._on_agent_message,
+            on_turn_error=self._on_turn_error,
         )
         # Absorb the system prompt response without relaying to IRC
         self._mention_targets.append(None)

{agentirc_cli-4.1.1 → agentirc_cli-4.1.3}/culture/clients/codex/agent_runner.py

@@ -23,12 +23,14 @@ class CodexAgentRunner:
         system_prompt: str = "",
         on_exit: Callable[[int], Awaitable[None]] | None = None,
         on_message: Callable[[dict[str, Any]], Awaitable[None]] | None = None,
+        on_turn_error: Callable[[], Awaitable[None]] | None = None,
     ) -> None:
         self.model = model
         self.directory = directory
         self.system_prompt = system_prompt
         self.on_exit = on_exit
         self.on_message = on_message
+        self.on_turn_error = on_turn_error
 
         self._isolated_home: str | None = None
         self._process: asyncio.subprocess.Process | None = None
@@ -318,6 +320,8 @@ class CodexAgentRunner:
 
                 except Exception:
                     logger.exception("Codex turn error")
+                    if self.on_turn_error:
+                        await self.on_turn_error()
 
         except asyncio.CancelledError:
             raise

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

@@ -293,6 +293,11 @@ class CodexDaemon:
     # Agent runner helpers
     # ------------------------------------------------------------------
 
+    async def _on_turn_error(self) -> None:
+        """Clean up stale relay target when a prompt fails."""
+        if self._mention_targets:
+            self._mention_targets.popleft()
+
     async def _start_agent_runner(self) -> None:
         self._agent_runner = CodexAgentRunner(
             model=self.agent.model,
@@ -300,6 +305,7 @@ class CodexDaemon:
             system_prompt=self._build_system_prompt(),
             on_exit=self._on_agent_exit,
             on_message=self._on_agent_message,
+            on_turn_error=self._on_turn_error,
         )
         await self._agent_runner.start()
         logger.info("CodexAgentRunner started for %s", self.agent.nick)

{agentirc_cli-4.1.1 → agentirc_cli-4.1.3}/culture/clients/copilot/agent_runner.py

@@ -23,6 +23,7 @@ class CopilotAgentRunner:
         skill_directories: list[str] | None = None,
         on_exit: Callable[[int], Awaitable[None]] | None = None,
         on_message: Callable[[dict[str, Any]], Awaitable[None]] | None = None,
+        on_turn_error: Callable[[], Awaitable[None]] | None = None,
     ) -> None:
         self.model = model
         self.directory = directory
@@ -30,6 +31,7 @@ class CopilotAgentRunner:
         self.skill_directories = skill_directories or []
         self.on_exit = on_exit
         self.on_message = on_message
+        self.on_turn_error = on_turn_error
 
         self._isolated_home: str | None = None
         self._client: Any = None
@@ -158,6 +160,8 @@ class CopilotAgentRunner:
 
                 except Exception:
                     logger.exception("Copilot session turn error")
+                    if self.on_turn_error:
+                        await self.on_turn_error()
                     if not self._stopping:
                         self._running = False
                         if self.on_exit:

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

@@ -293,6 +293,11 @@ class CopilotDaemon:
     # Agent runner helpers
     # ------------------------------------------------------------------
 
+    async def _on_turn_error(self) -> None:
+        """Clean up stale relay target when a prompt fails."""
+        if self._mention_targets:
+            self._mention_targets.popleft()
+
     async def _start_agent_runner(self) -> None:
         # Resolve installed skill path for the Copilot session
         skill_dirs: list[str] = []
@@ -307,6 +312,7 @@ class CopilotDaemon:
             skill_directories=skill_dirs,
             on_exit=self._on_agent_exit,
             on_message=self._on_agent_message,
+            on_turn_error=self._on_turn_error,
         )
         await self._agent_runner.start()
         logger.info("CopilotAgentRunner started for %s", self.agent.nick)

{agentirc_cli-4.1.1 → agentirc_cli-4.1.3}/culture/mesh_config.py

@@ -108,6 +108,15 @@ def from_daemon_config(daemon_config: DaemonConfig) -> MeshConfig:
     return MeshConfig(server=server, agents=agents)
 
 
+def merge_links(target: MeshConfig, source_links: list[MeshLinkConfig]) -> None:
+    """Copy link configs from *source_links* into *target* if not already present."""
+    existing = {link.name for link in target.server.links}
+    for link in source_links:
+        if link.name not in existing:
+            target.server.links.append(link)
+            existing.add(link.name)
+
+
 def save_mesh_config(config: MeshConfig, path: str | Path = DEFAULT_MESH_PATH) -> None:
     """Serialize mesh config to YAML and write atomically."""
     path = Path(path)

{agentirc_cli-4.1.1 → agentirc_cli-4.1.3}/docs/operations/cli.md

@@ -288,8 +288,11 @@ walkthrough.
 
 ### `culture update`
 
-Upgrade the `culture` package and restart all mesh services defined in
-`mesh.yaml`.
+Upgrade the `culture` package and restart all running servers. The command
+discovers running servers from PID files rather than relying solely on
+`mesh.yaml`, so it restarts every server on the machine even if `mesh.yaml`
+is stale or names a different server. When no servers are running, it falls
+back to `mesh.yaml`.
 
 ```bash
 culture update                          # upgrade package + restart everything

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

@@ -258,6 +258,15 @@ class AgentDaemon:
             except Exception:
                 logger.exception("Poll loop error")
 
+    async def _on_turn_error(self) -> None:
+        """Clean up stale relay target when a prompt fails.
+
+        Wire this as the ``on_turn_error`` callback on your agent runner so
+        the ``_mention_targets`` deque stays in sync with the prompt queue.
+        """
+        if self._mention_targets:
+            self._mention_targets.popleft()
+
     def _on_mention(self, target: str, sender: str, text: str) -> None:
         """Called when the agent is @mentioned. Sends prompt to runner.
 

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

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

agentirc_cli-4.1.3/tests/test_mention_target_cleanup.py

@@ -0,0 +1,135 @@
+"""Tests for _mention_targets deque cleanup on prompt failure.
+
+When a prompt fails (timeout, error), the corresponding _mention_targets
+entry must be cleaned up so that future responses route correctly.
+"""
+
+import asyncio
+import tempfile
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from culture.clients.acp.config import (
+    AgentConfig,
+    DaemonConfig,
+    ServerConnConfig,
+)
+from culture.clients.acp.daemon import ACPDaemon
+
+
+def _make_daemon(server_port: int) -> ACPDaemon:
+    config = DaemonConfig(
+        server=ServerConnConfig(host="127.0.0.1", port=server_port),
+        poll_interval=0,
+    )
+    agent = AgentConfig(
+        nick="testserv-bot",
+        directory="/tmp",
+        channels=["#general"],
+        acp_command=["echo"],
+    )
+    sock_dir = tempfile.mkdtemp()
+    return ACPDaemon(config, agent, socket_dir=sock_dir, skip_agent=True)
+
+
+def _inject_fake_runner(daemon):
+    """Inject a fake agent runner that records prompts."""
+    runner = MagicMock()
+    runner.is_running.return_value = True
+    runner.send_prompt = AsyncMock()
+    runner.stop = AsyncMock()
+    daemon._agent_runner = runner
+    return runner
+
+
+@pytest.mark.asyncio
+async def test_on_turn_error_pops_stale_target(server):
+    """_on_turn_error should pop the front entry from _mention_targets."""
+    daemon = _make_daemon(server.config.port)
+    await daemon.start()
+
+    # Simulate: poll enqueued a target, then the prompt failed
+    daemon._mention_targets.append("#general")
+    daemon._mention_targets.append("#code-review")
+    assert len(daemon._mention_targets) == 2
+
+    await daemon._on_turn_error()
+    assert len(daemon._mention_targets) == 1
+    assert daemon._mention_targets[0] == "#code-review"
+
+    await daemon.stop()
+
+
+@pytest.mark.asyncio
+async def test_on_turn_error_empty_deque_is_safe(server):
+    """_on_turn_error should be a no-op on an empty deque."""
+    daemon = _make_daemon(server.config.port)
+    await daemon.start()
+
+    assert len(daemon._mention_targets) == 0
+    await daemon._on_turn_error()  # should not raise
+    assert len(daemon._mention_targets) == 0
+
+    await daemon.stop()
+
+
+@pytest.mark.asyncio
+async def test_relay_routes_correctly_after_error_cleanup(server, make_client):
+    """After a failed prompt is cleaned up, the next response should route correctly."""
+    daemon = _make_daemon(server.config.port)
+    await daemon.start()
+    _inject_fake_runner(daemon)
+    await asyncio.sleep(0.5)
+
+    # Simulate: system prompt enqueued None, then timed out and was cleaned up
+    daemon._mention_targets.append(None)
+    await daemon._on_turn_error()  # cleans up None
+
+    # Now simulate a real mention that succeeds
+    daemon._mention_targets.append("#general")
+
+    # Simulate agent response
+    sent_messages = []
+    original_send = daemon._transport.send_privmsg
+
+    async def capture_send(target, text):
+        sent_messages.append((target, text))
+        await original_send(target, text)
+
+    daemon._transport.send_privmsg = capture_send
+
+    msg = {
+        "type": "assistant",
+        "content": [{"type": "text", "text": "Hello from bot!"}],
+    }
+    await daemon._relay_response_to_irc(msg)
+
+    assert len(sent_messages) == 1
+    assert sent_messages[0][0] == "#general"
+    assert "Hello from bot!" in sent_messages[0][1]
+    assert len(daemon._mention_targets) == 0
+
+    await daemon.stop()
+
+
+@pytest.mark.asyncio
+async def test_multiple_errors_drain_deque_correctly(server):
+    """Multiple consecutive errors should each pop one entry."""
+    daemon = _make_daemon(server.config.port)
+    await daemon.start()
+
+    # Simulate 3 failed prompts
+    daemon._mention_targets.append(None)  # system prompt
+    daemon._mention_targets.append("#general")  # poll 1
+    daemon._mention_targets.append("#general")  # poll 2
+
+    await daemon._on_turn_error()  # pops None
+    await daemon._on_turn_error()  # pops #general
+    assert len(daemon._mention_targets) == 1
+    assert daemon._mention_targets[0] == "#general"
+
+    await daemon._on_turn_error()  # pops last #general
+    assert len(daemon._mention_targets) == 0
+
+    await daemon.stop()

{agentirc_cli-4.1.1 → agentirc_cli-4.1.3}/tests/test_mesh_config.py

@@ -11,6 +11,7 @@ from culture.mesh_config import (
     MeshServerConfig,
     from_daemon_config,
     load_mesh_config,
+    merge_links,
     save_mesh_config,
 )
 
@@ -153,3 +154,39 @@ def test_from_daemon_config_empty_agents():
     assert mesh.server.name == "test"
     assert mesh.server.port == 7000
     assert mesh.agents == []
+
+
+def test_merge_links_appends_missing():
+    """merge_links adds links not already present."""
+    target = MeshConfig(
+        server=MeshServerConfig(
+            name="spark",
+            links=[MeshLinkConfig(name="thor", host="1.2.3.4", port=6667)],
+        ),
+    )
+    source = [
+        MeshLinkConfig(name="orin", host="5.6.7.8", port=6668),
+    ]
+    merge_links(target, source)
+    assert len(target.server.links) == 2
+    assert target.server.links[1].name == "orin"
+
+
+def test_merge_links_skips_duplicates():
+    """merge_links does not duplicate links already present."""
+    target = MeshConfig(
+        server=MeshServerConfig(
+            name="spark",
+            links=[MeshLinkConfig(name="thor", host="1.2.3.4", port=6667)],
+        ),
+    )
+    source = [
+        MeshLinkConfig(name="thor", host="9.9.9.9", port=9999),
+        MeshLinkConfig(name="orin", host="5.6.7.8", port=6668),
+    ]
+    merge_links(target, source)
+    assert len(target.server.links) == 2
+    names = [l.name for l in target.server.links]
+    assert names == ["thor", "orin"]
+    # Original thor link is unchanged
+    assert target.server.links[0].host == "1.2.3.4"

agentirc_cli-4.1.3/tests/test_setup_update_cli.py

@@ -0,0 +1,185 @@
+# tests/test_setup_update_cli.py
+"""Lightweight parser tests for setup and update subcommands."""
+
+from unittest.mock import patch
+
+import pytest
+
+from culture.cli import _build_parser
+from culture.mesh_config import MeshAgentConfig, MeshConfig, MeshLinkConfig, MeshServerConfig
+
+
+def test_setup_parser():
+    """setup subcommand parses --config and --uninstall."""
+    p = _build_parser()
+    args = p.parse_args(["mesh", "setup", "--uninstall"])
+    assert args.command == "mesh"
+    assert args.mesh_command == "setup"
+    assert args.uninstall is True
+
+    args = p.parse_args(["mesh", "setup", "--config", "/tmp/mesh.yaml"])
+    assert args.config == "/tmp/mesh.yaml"
+
+
+def test_update_parser():
+    """update subcommand parses --dry-run, --skip-upgrade, --config."""
+    p = _build_parser()
+    args = p.parse_args(["mesh", "update", "--dry-run", "--skip-upgrade"])
+    assert args.command == "mesh"
+    assert args.mesh_command == "update"
+    assert args.dry_run is True
+    assert args.skip_upgrade is True
+
+    args = p.parse_args(["mesh", "update", "--config", "/tmp/mesh.yaml"])
+    assert args.config == "/tmp/mesh.yaml"
+
+
+def test_setup_in_dispatch():
+    """setup command is wired into the mesh module."""
+    from culture.cli import mesh
+
+    assert hasattr(mesh, "_cmd_setup")
+    assert callable(mesh._cmd_setup)
+
+
+def test_update_in_dispatch():
+    """update command is wired into the mesh module."""
+    from culture.cli import mesh
+
+    assert hasattr(mesh, "_cmd_update")
+    assert callable(mesh._cmd_update)
+
+
+# ---- _cmd_update behaviour tests ----
+
+_MESH_MOD = "culture.cli.mesh"
+
+
+@pytest.fixture
+def update_args(tmp_path):
+    """Minimal argparse namespace for _cmd_update."""
+    p = _build_parser()
+    config = str(tmp_path / "mesh.yaml")
+    return p.parse_args(["mesh", "update", "--skip-upgrade", "--dry-run", "--config", config])
+
+
+@patch("culture.pidfile.list_servers")
+@patch(f"{_MESH_MOD}._resolve_mesh_for_server")
+@patch(f"{_MESH_MOD}._restart_mesh_services")
+@patch(f"{_MESH_MOD}._upgrade_culture_package", return_value=True)
+def test_update_discovers_running_servers(
+    _mock_upgrade, mock_restart, mock_resolve, mock_list, update_args
+):
+    """_cmd_update restarts every running server, not just mesh.yaml."""
+    from culture.cli.mesh import _cmd_update
+
+    spark_mesh = MeshConfig(server=MeshServerConfig(name="spark"))
+    mock_list.return_value = [{"name": "spark", "pid": 1, "port": 6667}]
+    mock_resolve.return_value = spark_mesh
+
+    _cmd_update(update_args)
+
+    mock_resolve.assert_called_once_with("spark", update_args.config)
+    mock_restart.assert_called_once()
+    assert mock_restart.call_args[0][1] == "spark"
+
+
+@patch("culture.pidfile.list_servers", return_value=[])
+@patch("culture.mesh_config.load_mesh_config")
+@patch(f"{_MESH_MOD}._restart_mesh_services")
+@patch(f"{_MESH_MOD}._upgrade_culture_package", return_value=True)
+def test_update_falls_back_to_mesh_yaml_when_no_servers(
+    _mock_upgrade, mock_restart, mock_load, _mock_list, update_args
+):
+    """When no servers are running, fall back to mesh.yaml."""
+    from culture.cli.mesh import _cmd_update
+
+    mesh = MeshConfig(server=MeshServerConfig(name="culture"))
+    mock_load.return_value = mesh
+
+    _cmd_update(update_args)
+
+    mock_load.assert_called_once_with(update_args.config)
+    mock_restart.assert_called_once()
+    assert mock_restart.call_args[0][1] == "culture"
+
+
+@patch("culture.pidfile.list_servers")
+@patch(f"{_MESH_MOD}._restart_mesh_services")
+@patch(f"{_MESH_MOD}._upgrade_culture_package", return_value=True)
+def test_update_skips_server_without_config(
+    _mock_upgrade, mock_restart, mock_list, update_args, capsys
+):
+    """Servers with no matching config are skipped with a warning."""
+    from culture.cli.mesh import _cmd_update
+
+    mock_list.return_value = [{"name": "unknown", "pid": 1, "port": 6667}]
+
+    with patch(f"{_MESH_MOD}._resolve_mesh_for_server", return_value=None):
+        _cmd_update(update_args)
+
+    mock_restart.assert_not_called()
+    assert "no config found" in capsys.readouterr().err
+
+
+# ---- _resolve_mesh_for_server tests ----
+
+
+def test_resolve_uses_mesh_yaml_when_name_matches(tmp_path):
+    """_resolve_mesh_for_server returns mesh.yaml config when server name matches."""
+    from culture.cli.mesh import _resolve_mesh_for_server
+
+    mesh = MeshConfig(
+        server=MeshServerConfig(name="spark", links=[MeshLinkConfig(name="thor", host="1.2.3.4")]),
+        agents=[MeshAgentConfig(nick="claude", workdir="/tmp")],
+    )
+    config_path = str(tmp_path / "mesh.yaml")
+    from culture.mesh_config import save_mesh_config
+
+    save_mesh_config(mesh, config_path)
+
+    result = _resolve_mesh_for_server("spark", config_path)
+    assert result is not None
+    assert result.server.name == "spark"
+    assert len(result.server.links) == 1
+
+
+def test_resolve_rebuilds_from_agents_yaml_preserving_links(tmp_path):
+    """When mesh.yaml has wrong name, rebuild from agents.yaml and keep links."""
+    from culture.cli.mesh import _resolve_mesh_for_server
+    from culture.clients.claude.config import AgentConfig, DaemonConfig, ServerConnConfig
+    from culture.mesh_config import save_mesh_config
+
+    # mesh.yaml says "culture" but running server is "spark"
+    old_mesh = MeshConfig(
+        server=MeshServerConfig(
+            name="culture",
+            host="127.0.0.1",
+            port=7000,
+            links=[MeshLinkConfig(name="thor", host="1.2.3.4")],
+        ),
+    )
+    config_path = str(tmp_path / "mesh.yaml")
+    save_mesh_config(old_mesh, config_path)
+
+    # agents.yaml says "spark"
+    daemon = DaemonConfig(
+        server=ServerConnConfig(name="spark", host="localhost", port=6667),
+        agents=[AgentConfig(nick="spark-claude", agent="claude", directory="/tmp")],
+    )
+
+    with patch(f"{_MESH_MOD}.DEFAULT_CONFIG", str(tmp_path / "agents.yaml")):
+        from culture.clients.claude.config import save_config
+
+        save_config(str(tmp_path / "agents.yaml"), daemon)
+        result = _resolve_mesh_for_server("spark", config_path)
+
+    assert result is not None
+    assert result.server.name == "spark"
+    assert len(result.agents) == 1
+    assert result.agents[0].nick == "claude"
+    # Server settings from old mesh.yaml are preserved
+    assert result.server.host == "127.0.0.1"
+    assert result.server.port == 7000
+    assert len(result.server.links) == 1
+    assert result.server.links[0].name == "thor"