symphony-code 0.0.1__py3-none-any.whl

coding_agent/protocols/acp/server.py

@@ -0,0 +1,261 @@
+"""Agent Client Protocol host: one stdio process, any number of sessions.
+
+A thin translator. Events become ``session/update`` notifications, a
+question becomes a ``session/request_permission`` request, and the client's
+prompt, cancel, and permission reply become ``CoreHarness.submit`` ops.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from collections.abc import Sequence
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+from typing import Any, Dict, Mapping
+
+from core_harness import (
+    Answer,
+    EventSink,
+    HarnessCancelled,
+    HarnessLimitExceeded,
+    HumanInteraction,
+    Interrupt,
+    UserInput,
+)
+
+from coding_agent.config import ensure_spawn_settings
+from coding_agent.protocols.acp.mapping import (
+    PROTOCOL_VERSION,
+    permission_answer,
+    permission_request,
+    prompt_text,
+    session_updates,
+    stop_reason_for_limit,
+)
+from coding_agent.protocols.acp.transport import (
+    INTERNAL_ERROR,
+    INVALID_PARAMS,
+    INVALID_REQUEST,
+    METHOD_NOT_FOUND,
+    PARSE_ERROR,
+    Connection,
+)
+
+
+def _package() -> Any:
+    """Look names up on the package so tests can patch ``acp.build_agent``."""
+    from coding_agent.protocols import acp
+
+    return acp
+
+
+class AcpSink(EventSink):
+    """Send each event to the client in ACP terms."""
+
+    def __init__(self, connection: Connection) -> None:
+        super().__init__()
+        self.interaction = HumanInteraction(self)
+        self.connection = connection
+        self.session_id = ""
+        self.submit: Any = None
+        self._asking: set[asyncio.Task[None]] = set()
+
+    async def deliver(self, event_type: str, payload: Dict[str, Any]) -> None:
+        if event_type == "question_asked":
+            task = asyncio.create_task(self._ask(payload))
+            self._asking.add(task)
+            task.add_done_callback(self._asking.discard)
+            return
+        for update in session_updates(event_type, payload):
+            self.connection.notify("session/update", {"sessionId": self.session_id, "update": update})
+
+    async def _ask(self, payload: Mapping[str, Any]) -> None:
+        """Put one question to the client and send its answer back as an op."""
+        outcome: Any = None
+        # ACP permission requests carry options. A free-text question has
+        # none to offer, so it takes its default.
+        if payload.get("choices"):
+            reply = await self.connection.request(
+                "session/request_permission", permission_request(self.session_id, payload)
+            )
+            outcome = reply.get("outcome") if isinstance(reply, Mapping) else None
+        if callable(self.submit):
+            self.submit(Answer(str(payload.get("request_id") or ""), permission_answer(outcome, payload)))
+
+
+class Session:
+    def __init__(self, agent: Any, sink: AcpSink) -> None:
+        self.agent = agent
+        self.sink = sink
+        self.run: asyncio.Task[None] | None = None
+
+    @property
+    def busy(self) -> bool:
+        return self.run is not None and not self.run.done()
+
+
+class Server:
+    def __init__(self, *, model: str | None = None, unattended: bool = False) -> None:
+        self.connection = Connection()
+        self.sessions: Dict[str, Session] = {}
+        self.model = model
+        self.unattended = unattended
+
+    async def handle(self, message: Mapping[str, Any]) -> None:
+        """Dispatch one message from the client."""
+        method = message.get("method")
+        if method is None:
+            self.connection.resolve(message)
+            return
+        request_id = message.get("id")
+        params = message.get("params")
+        params = params if isinstance(params, Mapping) else {}
+        handler = {
+            "initialize": self._initialize,
+            "session/new": self._new_session,
+            "session/prompt": self._prompt,
+            "session/cancel": self._cancel,
+            "_symphony/steer": self._steer,
+        }.get(str(method))
+        if handler is None:
+            if request_id is not None:
+                self.connection.fail(request_id, METHOD_NOT_FOUND, f"method not found: {method}")
+            return
+        try:
+            result = await handler(params, request_id)
+        except ValueError as exc:
+            if request_id is not None:
+                self.connection.fail(request_id, INVALID_PARAMS, str(exc))
+            return
+        except Exception as exc:
+            if request_id is not None:
+                self.connection.fail(request_id, INTERNAL_ERROR, f"{type(exc).__name__}: {exc}")
+            return
+        if result is not None and request_id is not None:
+            self.connection.respond(request_id, result)
+
+    async def _initialize(self, params: Mapping[str, Any], request_id: Any) -> Dict[str, Any]:
+        del params, request_id
+        try:
+            release = version("symphony-code")
+        except PackageNotFoundError:
+            release = "unknown"
+        return {
+            "protocolVersion": PROTOCOL_VERSION,
+            "agentCapabilities": {
+                "loadSession": False,
+                "promptCapabilities": {"image": False, "audio": False, "embeddedContext": True},
+                "_meta": {"symphony": {"steer": True}},
+            },
+            "agentInfo": {"name": "symphony", "title": "Symphony", "version": release},
+            "authMethods": [],
+        }
+
+    async def _new_session(self, params: Mapping[str, Any], request_id: Any) -> Dict[str, Any]:
+        del request_id
+        cwd = params.get("cwd")
+        if not isinstance(cwd, str) or not Path(cwd).is_absolute():
+            raise ValueError("cwd must be an absolute path")
+        workspace = Path(cwd)
+        acp = _package()
+        acp.load_provider_env(workspace)
+        sink = AcpSink(self.connection)
+        agent = acp.build_agent(
+            workspace=workspace,
+            model_id=self.model,
+            sink=sink,
+            config=ensure_spawn_settings(workspace, overrides={"unattended": True}) if self.unattended else None,
+            client="acp",
+        )
+        sink.session_id = str(agent.session_id)
+        sink.submit = agent.harness.submit
+        self.sessions[sink.session_id] = Session(agent, sink)
+        return {"sessionId": sink.session_id}
+
+    def _session(self, params: Mapping[str, Any]) -> Session:
+        session = self.sessions.get(str(params.get("sessionId") or ""))
+        if session is None:
+            raise ValueError("unknown sessionId")
+        return session
+
+    async def _prompt(self, params: Mapping[str, Any], request_id: Any) -> None:
+        session = self._session(params)
+        blocks = params.get("prompt")
+        text = prompt_text(blocks) if isinstance(blocks, list) else ""
+        if not text.strip():
+            raise ValueError("prompt has no text")
+        if session.busy:
+            self.connection.fail(request_id, INVALID_REQUEST, "a prompt is already running in this session")
+            return None
+        session.run = asyncio.create_task(self._run(session, text, request_id))
+        return None
+
+    async def _run(self, session: Session, text: str, request_id: Any) -> None:
+        """Run one prompt turn and answer the request with its stop reason."""
+        try:
+            await session.agent.run(text)
+            stop = "end_turn"
+        except (HarnessCancelled, asyncio.CancelledError):
+            stop = "cancelled"
+        except HarnessLimitExceeded as exc:
+            stop = stop_reason_for_limit(exc)
+        except Exception as exc:
+            self.connection.fail(request_id, INTERNAL_ERROR, f"{type(exc).__name__}: {exc}")
+            return
+        self.connection.respond(request_id, {"stopReason": stop})
+
+    async def _cancel(self, params: Mapping[str, Any], request_id: Any) -> None:
+        del request_id
+        self._session(params).agent.harness.submit(Interrupt("user_cancel"))
+        return None
+
+    async def _steer(self, params: Mapping[str, Any], request_id: Any) -> Dict[str, Any]:
+        del request_id
+        blocks = params.get("prompt")
+        text = prompt_text(blocks) if isinstance(blocks, list) else ""
+        if not text.strip():
+            raise ValueError("prompt has no text")
+        return {"accepted": bool(self._session(params).agent.harness.submit(UserInput(text)))}
+
+    async def shutdown(self) -> None:
+        runs = [session.run for session in self.sessions.values() if session.busy]
+        for run in runs:
+            run.cancel()
+        await asyncio.gather(*runs, return_exceptions=True)
+
+
+async def serve(*, model: str | None = None, unattended: bool = False) -> int:
+    server = Server(model=model, unattended=unattended)
+    acp = _package()
+    while True:
+        line = await asyncio.to_thread(acp.sys.stdin.readline)
+        if not line:
+            await server.shutdown()
+            return 0
+        if not line.strip():
+            continue
+        try:
+            message = json.loads(line)
+        except json.JSONDecodeError:
+            server.connection.fail(None, PARSE_ERROR, "invalid JSON")
+            continue
+        if not isinstance(message, dict):
+            server.connection.fail(None, INVALID_REQUEST, "message must be an object")
+            continue
+        await server.handle(message)
+
+
+def main(argv: Sequence[str]) -> int:
+    parser = argparse.ArgumentParser(prog="symphony acp")
+    parser.add_argument("--model")
+    parser.add_argument("--unattended", action="store_true", help="Auto-approve tools subject to Symphony deny rules")
+    args = parser.parse_args(argv)
+    # Libraries may print diagnostics; stdout belongs exclusively to JSON-RPC.
+    sys.stdout = sys.stderr
+    return asyncio.run(serve(model=args.model, unattended=args.unattended))
+
+
+__all__ = ["AcpSink", "Server", "main", "serve"]

coding_agent/protocols/acp/transport.py

@@ -0,0 +1,72 @@
+"""JSON-RPC 2.0 over stdio, one message per line."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+from typing import Any, Dict, Mapping
+
+PARSE_ERROR = -32700
+INVALID_REQUEST = -32600
+METHOD_NOT_FOUND = -32601
+INVALID_PARAMS = -32602
+INTERNAL_ERROR = -32603
+
+
+def write_message(message: Mapping[str, Any]) -> None:
+    sys.__stdout__.write(json.dumps(message, default=str, ensure_ascii=False) + "\n")
+    sys.__stdout__.flush()
+
+
+def _write(message: Mapping[str, Any]) -> None:
+    """Write through the package so ``acp.write_message`` stays patchable."""
+    from coding_agent.protocols import acp
+
+    acp.write_message(message)
+
+
+class Connection:
+    """Outbound half of the connection, and the replies to our own requests."""
+
+    def __init__(self) -> None:
+        self._next_id = 0
+        self._waiting: Dict[int, asyncio.Future[Any]] = {}
+
+    def notify(self, method: str, params: Mapping[str, Any]) -> None:
+        _write({"jsonrpc": "2.0", "method": method, "params": params})
+
+    def respond(self, request_id: Any, result: Mapping[str, Any]) -> None:
+        _write({"jsonrpc": "2.0", "id": request_id, "result": result})
+
+    def fail(self, request_id: Any, code: int, message: str) -> None:
+        _write({"jsonrpc": "2.0", "id": request_id, "error": {"code": code, "message": message}})
+
+    async def request(self, method: str, params: Mapping[str, Any]) -> Any:
+        """Ask the client and wait for its result. ``None`` if it errored."""
+        self._next_id += 1
+        request_id = self._next_id
+        reply = asyncio.get_running_loop().create_future()
+        self._waiting[request_id] = reply
+        _write({"jsonrpc": "2.0", "id": request_id, "method": method, "params": params})
+        try:
+            return await reply
+        finally:
+            self._waiting.pop(request_id, None)
+
+    def resolve(self, message: Mapping[str, Any]) -> None:
+        """Deliver the client's reply to one of our requests."""
+        reply = self._waiting.get(message.get("id"))  # type: ignore[arg-type]
+        if reply is not None and not reply.done():
+            reply.set_result(message.get("result"))
+
+
+__all__ = [
+    "Connection",
+    "INTERNAL_ERROR",
+    "INVALID_PARAMS",
+    "INVALID_REQUEST",
+    "METHOD_NOT_FOUND",
+    "PARSE_ERROR",
+    "write_message",
+]

coding_agent/protocols/stdio/README.md

@@ -0,0 +1,36 @@
+# Coding agent host protocols
+
+`stdio.py` is the versioned JSONL boundary for desktop and other external
+hosts. The coding agent owns execution and persisted checkpoints. A host owns
+its composer queue and submits a single prompt per active turn.
+
+Protocol version 2 advertises `runs`, `resume`, `interrupt`, `input`, `steer`,
+`models`, `images`, `subagents`, and `commands` in its `ready` frame. A host
+sends `run`, `answer`, `interrupt`, or `steer` commands, or `model/list` with a
+`request_id`, and reads `event`, `input_requested`, `error`, `done`, and
+`models` frames. `answer`, `interrupt`, and `steer` are passed to
+`CoreHarness.submit` as `Answer`, `Interrupt`, and `UserInput` operations.
+`{"type":"steer","prompt":"..."}` adds a user message to the active run before
+its next model call and is an error when no run is active.
+
+A question arrives as the ordinary `question_asked` event, the same as in
+every other host, followed by the protocol 2 `input_requested` frame with the
+same `request_id`. Reply to either with one `answer` command.
+Unknown control-plane events can be ignored without losing the terminal
+`done` frame. A later version must change the version number when it changes
+required frame semantics.
+
+After `ready`, send `{"type":"model/list","request_id":"catalog-1"}` on stdin.
+Symphony responds with a `models` frame carrying the same `request_id`. Each
+row has a qualified
+`id` (`provider:model`), display `label`, `provider`, `description`,
+`context_limit` (tokens, or null), and `reasoning_levels`. The default ID is
+also returned as `default`; hosts should keep the qualified ID when selecting
+a model. The provider is the API route, so gateway models identify the gateway
+even when its upstream model has another vendor.
+
+Subagents use the ordinary `event` envelope: the parent emits
+`agent_spawned` with `child_id` and `tool_call_id`; child events carry that
+`child_id` as `agent_id`; the parent emits `agent_completed` or `agent_failed`
+with `child_id` when it settles. Hosts can route child traffic into a nested
+view using the spawning tool call ID.

coding_agent/protocols/stdio/__init__.py

@@ -0,0 +1,37 @@
+"""Line-delimited JSON transport for external agent managers.
+
+Only protocol frames go to stdout. Each process handles one turn; later turns
+resume the persisted Symphony session by its id.
+
+``transport`` writes frames, ``catalog`` answers model lists, and ``server``
+runs the command loop. The names below stay on this package because hosts and
+tests patch them here.
+"""
+
+import sys
+
+from coding_agent.agent import build_agent
+from coding_agent.config.credentials import load_provider_env
+from coding_agent.protocols.stdio.catalog import model_catalog
+from coding_agent.protocols.stdio.server import main, serve
+from coding_agent.protocols.stdio.transport import (
+    CAPABILITIES,
+    PROTOCOL_VERSION,
+    StdioSink,
+    user_content,
+    write_frame,
+)
+
+__all__ = [
+    "CAPABILITIES",
+    "PROTOCOL_VERSION",
+    "StdioSink",
+    "build_agent",
+    "load_provider_env",
+    "main",
+    "model_catalog",
+    "serve",
+    "sys",
+    "user_content",
+    "write_frame",
+]

coding_agent/protocols/stdio/catalog.py

@@ -0,0 +1,49 @@
+"""Model catalog frames for the stdio host."""
+
+from __future__ import annotations
+
+from core_ai.registry import ModelRegistry
+
+from coding_agent.protocols.stdio.transport import PROTOCOL_VERSION
+
+
+def model_catalog(registry: ModelRegistry, request_id: str) -> dict[str, object]:
+    import core_ai
+
+    default_model_id = core_ai.default_model_id
+
+    namespaces = registry.namespaces()
+    models = [
+        {
+            "id": info.full_id,
+            "label": info.id,
+            "provider": info.provider,
+            "description": info.provider,
+            "context_limit": info.context_limit,
+            "reasoning_levels": [level for level, _ in info.thinking_level_map if level != "off"],
+        }
+        for info in registry.models()
+        if info.provider in namespaces
+    ]
+    default = default_model_id(registry)
+    selected = next((item for item in models if item["id"] == default), None)
+    if selected is None:
+        provider, _, label = default.partition(":")
+        selected = {
+            "id": default,
+            "label": label or default,
+            "provider": provider or default,
+            "description": "Symphony default",
+            "context_limit": None,
+            "reasoning_levels": [],
+        }
+    return {
+        "type": "models",
+        "request_id": request_id,
+        "models": [selected, *[item for item in models if item["id"] != default]],
+        "default": default,
+        "protocol_version": PROTOCOL_VERSION,
+    }
+
+
+__all__ = ["model_catalog"]

coding_agent/protocols/stdio/commands.py

@@ -0,0 +1,218 @@
+"""Slash commands shared by external managers and the Symphony TUI catalog."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+from typing import Any, Sequence
+
+from coding_agent.config import ensure_spawn_settings, symphony_dir
+from coding_agent.commands.jev_argument import parse_jev_argument
+from coding_agent.config.personalities import load_personalities
+from coding_agent.addons.persistence.jsonl import JsonlPersistence
+from coding_agent.addons.persistence.artifacts import publish, safe_path
+from coding_agent.commands.catalog import EFFORTS, SLASH_COMMANDS, EFFORT_CATALOG, SlashCommand
+from coding_agent.addons.manager import addons_report
+
+
+def catalog(
+    workspace: Path | None = None,
+    extra: Sequence[SlashCommand] = (),
+) -> list[dict[str, Any]]:
+    """Built-in commands plus ``extra`` (the live agent's user-addon commands)."""
+    choices = {
+        "personality": [
+            {"value": item.id, "label": item.name, "description": item.description or ""}
+            for item in load_personalities()
+        ],
+        "effort": [{"value": item.id, "label": item.label, "description": item.description} for item in EFFORT_CATALOG],
+        "jev": [{"value": value, "label": value.title(), "description": description} for value, description in
+                [("on", "Enable the finish rule"), ("off", "Disable the finish rule"), ("toggle", "Toggle the finish rule")]],
+    }
+    descriptions = {
+        "provider": "Show provider setup instructions",
+        "langfuse": "Show telemetry setup instructions",
+        "clear": "Show how to clear the transcript in Zeron",
+        "quit": "Show how to exit Zeron",
+        "dashboard": "List active Symphony agents",
+        "reload": "Reload configuration and environment for the live agent",
+    }
+    return [
+        {"name": item.name, "description": descriptions.get(item.name, item.description),
+         "inputHint": item.argument, "options": choices.get(item.name, [])}
+        for item in (*SLASH_COMMANDS, *extra)
+    ]
+
+
+def _state_path(session_id: str) -> Path:
+    # The session id is generated by Symphony, but avoid treating it as a path.
+    import uuid
+
+    return symphony_dir() / "protocols" / f"{uuid.UUID(session_id)}.json"
+
+
+def _agent_state_path(agent: Any) -> Path:
+    try:
+        persistence = agent.persistence
+    except AttributeError:
+        return _state_path(agent.session_id)
+    if not isinstance(persistence, JsonlPersistence):
+        return _state_path(agent.session_id)
+
+    path = safe_path(persistence.session_dir(agent.session_id), "state.json")
+    if not path.exists():
+        try:
+            legacy = _state_path(agent.session_id)
+        except ValueError:
+            # JSONL sessions also support non-UUID identifiers.
+            return path
+        if legacy.is_file():
+            path.parent.mkdir(parents=True, exist_ok=True)
+            publish(path, legacy.read_bytes())
+            legacy.unlink()
+    return path
+
+
+def _reject_legacy_plan_state(data: dict[str, Any]) -> None:
+    if data.get("mode", "build") != "build":
+        raise ValueError(
+            "This session was saved with a removed or unsupported mode. "
+            "It cannot be resumed safely; explicitly start a fresh session."
+        )
+
+
+def load_state(agent: Any) -> None:
+    try:
+        path = _agent_state_path(agent)
+    except ValueError:
+        return
+    if not path.exists():
+        return
+    data = json.loads(path.read_text(encoding="utf-8"))
+    _reject_legacy_plan_state(data)
+    effort = data.get("effort")
+    if effort in EFFORTS:
+        agent.harness.reasoning_effort = None if effort == "default" else effort
+
+
+def _save_state(agent: Any, **changes: str) -> None:
+    path = _agent_state_path(agent)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    data = json.loads(path.read_text(encoding="utf-8")) if path.exists() else {}
+    _reject_legacy_plan_state(data)
+    data.pop("mode", None)
+    data.update(changes)
+    publish(path, (json.dumps(data, indent=2) + "\n").encode("utf-8"))
+
+
+def _git_diff(workspace: Path) -> str:
+    result = subprocess.run(
+        ["git", "diff", "--stat", "HEAD"], cwd=workspace, capture_output=True,
+        text=True, timeout=10, check=False,
+    )
+    return result.stdout.strip() or result.stderr.strip() or "No changes in tracked files."
+
+
+async def execute(agent: Any, value: str) -> str:
+    """Execute a command without sending it to a model."""
+    parts = value.strip()[1:].split(None, 1)
+    command = parts[0].lower() if parts else ""
+    argument = parts[1].strip() if len(parts) > 1 else ""
+    if command in {"help"}:
+        commands = (*SLASH_COMMANDS, *agent.user_addons.surface.slash_commands)
+        return "\n".join(f"{item.usage} — {item.description}" for item in commands)
+    if command == "status":
+        return (
+            f"Model: {agent.harness.model_id}\nSession: {agent.session_id}\n"
+            f"Personality: {agent.config.personality}\n"
+            f"Effort: {agent.harness.reasoning_effort or 'default'}"
+        )
+    if command == "session":
+        from coding_agent.addons.persistence.presentation import session_report
+
+        return await session_report(agent)
+    if command == "context":
+        report = await agent.context_report()
+        return str(report)
+    if command == "compact":
+        before, after = await agent.compact_conversation()
+        return f"Compacted conversation: {before} → {after} messages."
+    if command == "effort":
+        if not argument:
+            return f"Current effort: {agent.harness.reasoning_effort or 'default'}. Options: {', '.join(EFFORTS)}."
+        if argument.lower() not in EFFORTS:
+            return f"Unknown effort. Options: {', '.join(EFFORTS)}."
+        agent.harness.reasoning_effort = None if argument.lower() == "default" else argument.lower()
+        _save_state(agent, effort=argument.lower())
+        return f"Reasoning effort: {argument.lower()}."
+    if command == "personality":
+        choices = {item.id: item for item in load_personalities()}
+        if not argument:
+            return f"Current: {agent.config.personality}. Options: {', '.join(choices)}."
+        if argument not in choices:
+            return f"Unknown personality: {argument}. Options: {', '.join(choices)}."
+        agent.config = ensure_spawn_settings(agent.workspace, overrides={"personality": argument})
+        agent.apply_system_prompt()
+        return f"Personality: {choices[argument].name}."
+    if command == "jev":
+        change = parse_jev_argument(agent.config.evaluation.enabled, argument)
+        enabled = change.enabled
+        settings: dict[str, Any] = {"enabled": enabled}
+        if change.rule is not None:
+            settings["rule"] = change.rule
+        agent.config = ensure_spawn_settings(agent.workspace, overrides={"evaluation": settings})
+        agent.apply_system_prompt()
+        return f"Jev {'enabled' if enabled else 'disabled'} for the next turn."
+    if command == "model":
+        models = [item.full_id for item in agent.registry.models() if item.provider in agent.registry.namespaces()]
+        if argument:
+            return "Select the model in Zeron's model picker; it controls the model for this chat."
+        return f"Current model: {agent.harness.model_id}\nAvailable: {', '.join(models)}"
+    if command == "learning":
+        try:
+            store = agent.learning_store
+        except AttributeError:
+            store = None
+        if store is None:
+            from coding_agent.addons.learning.store import LearningStore
+
+            # Lightweight protocol hosts/tests may not expose the agent's store.
+            store = LearningStore(agent.workspace)
+        return store.to_markdown()
+    if command == "installed":
+        skills = [item.name for item in agent.skill_registry.skills]
+        plugins = [str(getattr(item, "name", item)) for item in agent.loaded_plugins]
+        return f"Skills: {', '.join(skills) or 'none'}\nPlugins: {', '.join(plugins) or 'none'}"
+    if command == "diff":
+        return _git_diff(agent.workspace)
+    if command == "dashboard":
+        root = symphony_dir() / "active"
+        entries = sorted(root.iterdir()) if root.exists() else []
+        return "\n".join(path.name for path in entries) or "No active agents."
+    if command == "reload":
+        from coding_agent.config.credentials import load_provider_env
+
+        load_provider_env(agent.workspace, reload=True)
+        agent.config = ensure_spawn_settings(agent.workspace)
+        agent.apply_system_prompt()
+        addons = agent.reload_user_addons()
+        return f"Reloaded Symphony configuration and environment for this session.\nAddons: {addons}"
+    if command == "addons":
+        return addons_report(agent.user_addons.surface, agent.user_addons.hook_failures)
+    if command == "provider":
+        return "Configure a provider with its API key in Symphony's environment, then use /model."
+    if command == "langfuse":
+        return "Configure Langfuse credentials in Symphony's .env, then restart the session to initialize telemetry."
+    if command == "new":
+        return "Use Zeron's /zeron:new to open a fresh conversation."
+    if command == "clear":
+        return "Use Zeron's conversation controls to clear the visible transcript."
+    if command == "quit":
+        return "Close the Zeron window to exit."
+    if command == "voice":
+        return "Voice mode listens in the Symphony TUI. Press ctrl+a or type /voice there."
+    reply = await agent.user_addons.run_command(command, argument)
+    if reply is not None:
+        return reply
+    raise ValueError(f"Unknown command: /{command}. Type /help to see commands.")