symphony-code 0.0.1__py3-none-any.whl

coding_agent/addons/manager/report.py

@@ -0,0 +1,33 @@
+"""Plain-text body of the /addons command (TUI and stdio)."""
+
+from __future__ import annotations
+
+from core_harness.extensions import AddonFailure
+
+from coding_agent.addons.manager.bridge import AddonSurface
+
+
+def addons_report(surface: AddonSurface, hook_failures: tuple[AddonFailure, ...] = ()) -> str:
+    exposed_tools = surface.tool_names
+    exposed_commands = {item.name for item in surface.commands}
+    lines = ["Loaded addons:"]
+    for addon in surface.snapshot.loaded:
+        tools = ", ".join(tool.name for tool in addon.tools if tool.name in exposed_tools) or "none"
+        commands = ", ".join(
+            f"/{item.name}" for item in addon.commands if item.name in exposed_commands
+        ) or "none"
+        lines.append(f"  {addon.name} {addon.version} · tools: {tools} · commands: {commands}")
+    if not surface.snapshot.loaded:
+        lines.append("  none")
+    failures = surface.snapshot.failed + hook_failures
+    lines.append("Failed addons:")
+    lines.extend(f"  {item.name} · {item.phase} · {item.error}" for item in failures)
+    if not failures:
+        lines.append("  none")
+    if surface.notices:
+        lines.append("Notices:")
+        lines.extend(f"  {notice}" for notice in surface.notices)
+    return "\n".join(lines)
+
+
+__all__ = ["addons_report"]

coding_agent/addons/manager/runtime.py

@@ -0,0 +1,76 @@
+"""The live user-addon state of one agent.
+
+Holds the current ``AddonSurface``, forwards sink events to addon
+handlers, and runs the /reload swap: build the new snapshot, dispose the
+old addons, then swap. A reload asked for during a run waits for the run
+to end.
+"""
+
+from __future__ import annotations
+
+import inspect
+from typing import Any, Callable, Collection, Mapping
+
+from core_harness.extensions import AddonFailure, dispatch_event, dispose_addons
+
+from coding_agent.addons.manager.bridge import AddonSurface, build_surface
+from coding_agent.addons.manager.discovery import load_user_addons
+from coding_agent.addons.manager.tool_changes import tool_change_notice
+
+Loader = Callable[[Collection[str]], Any]
+
+
+class UserAddonRuntime:
+    def __init__(
+        self,
+        *,
+        builtin_tool_names: Collection[str],
+        reserved_names: Collection[str] = (),
+        loader: Loader = load_user_addons,
+    ) -> None:
+        self.builtin_tool_names = frozenset(builtin_tool_names)
+        self.reserved_names = frozenset(reserved_names)
+        self.loader = loader
+        self.surface: AddonSurface = self.build()
+        self.hook_failures: tuple[AddonFailure, ...] = ()
+        self.reload_pending = False
+
+    def build(self) -> AddonSurface:
+        return build_surface(self.loader(self.reserved_names), builtin_tool_names=self.builtin_tool_names)
+
+    def on_event(self, event: str, payload: Mapping[str, Any]) -> None:
+        """Sink listener. Never raises; failures are kept for /addons."""
+        failures = dispatch_event(self.surface.snapshot, event, payload)
+        if failures:
+            self.hook_failures = (self.hook_failures + failures)[-20:]
+
+    def dispose(self) -> tuple[AddonFailure, ...]:
+        failures = dispose_addons(self.surface.snapshot.loaded)
+        self.hook_failures = (self.hook_failures + failures)[-20:]
+        return failures
+
+    def swap(self, surface: AddonSurface) -> str:
+        """Dispose the current addons, install ``surface`` and describe the tool change."""
+        before = self.surface.tool_names
+        self.dispose()
+        self.surface = surface
+        return tool_change_notice(before, surface.tool_names)
+
+    async def run_command(self, name: str, argument: str) -> str | None:
+        """Run an addon command. ``None`` when no addon owns ``name``."""
+        command = self.surface.command(name)
+        if command is None:
+            return None
+        try:
+            reply = command.handler(argument)
+            if inspect.isawaitable(reply):
+                reply = await reply
+        except Exception as exc:  # noqa: BLE001 - addon code is untrusted
+            self.hook_failures = (self.hook_failures + (
+                AddonFailure(command.name, "command", f"{type(exc).__name__}: {exc}"),
+            ))[-20:]
+            return f"/{name} failed · {type(exc).__name__}: {exc}"
+        return str(reply)
+
+
+__all__ = ["UserAddonRuntime"]

coding_agent/addons/manager/tool_changes.py

@@ -0,0 +1,16 @@
+"""The notice shown after /reload swaps user addons."""
+
+from __future__ import annotations
+
+from typing import Collection
+
+
+def tool_change_notice(before: Collection[str], after: Collection[str]) -> str:
+    added = len(set(after) - set(before))
+    removed = len(set(before) - set(after))
+    if not added and not removed:
+        return "no tool changes"
+    return f"tools changed (+{added}/-{removed}): prompt cache will rebuild"
+
+
+__all__ = ["tool_change_notice"]

coding_agent/addons/persistence/__init__.py

@@ -0,0 +1,41 @@
+"""Coding-agent persistence backends."""
+
+from coding_agent.addons.persistence.collection import (
+    COLLECTABLE_EVENT_TYPES,
+    TERMINAL_EVENT_TYPES,
+    apply_collection,
+    collectable_from_events,
+    collected_keys,
+    event_key,
+    is_collectable_event,
+    is_collected,
+)
+from coding_agent.addons.persistence.active import (
+    ActiveSession,
+    active_dir,
+    active_session_ids,
+    list_active,
+    register_active,
+    release_active,
+)
+from coding_agent.addons.persistence.jsonl import JsonlPersistence, SessionSummary, sessions_dir
+
+__all__ = [
+    "ActiveSession",
+    "COLLECTABLE_EVENT_TYPES",
+    "JsonlPersistence",
+    "SessionSummary",
+    "TERMINAL_EVENT_TYPES",
+    "active_dir",
+    "active_session_ids",
+    "apply_collection",
+    "collectable_from_events",
+    "collected_keys",
+    "event_key",
+    "is_collectable_event",
+    "is_collected",
+    "list_active",
+    "register_active",
+    "release_active",
+    "sessions_dir",
+]

coding_agent/addons/persistence/active.py

@@ -0,0 +1,132 @@
+"""Live registry of Symphony processes that currently own a session.
+
+Resume should not offer a conversation another process is still using. Each
+running agent writes one small JSON file under ``~/.symphony/active`` and
+removes it on a clean exit. A file whose process is gone is stale and ignored.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+def active_dir() -> Path:
+    """Directory that holds one registry file per live Symphony process."""
+    target = (Path.home() / ".symphony" / "active").expanduser()
+    target.mkdir(parents=True, exist_ok=True)
+    return target
+
+
+def _path(pid: int) -> Path:
+    return active_dir() / f"{pid}.json"
+
+
+@dataclass(frozen=True)
+class ActiveSession:
+    """One Symphony process and the session it currently owns."""
+
+    session_id: str
+    pid: int
+    kind: str
+    workspace: str
+    model_id: str = ""
+    label: str = ""
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "session_id": self.session_id,
+            "pid": self.pid,
+            "kind": self.kind,
+            "workspace": self.workspace,
+            "model_id": self.model_id,
+            "label": self.label,
+        }
+
+
+def register_active(
+    session_id: str,
+    *,
+    workspace: str | Path,
+    kind: str,
+    model_id: str = "",
+    label: str = "",
+    pid: int | None = None,
+) -> ActiveSession:
+    """Record that this process owns ``session_id``. Replaces any prior record."""
+    record = ActiveSession(
+        session_id=session_id,
+        pid=os.getpid() if pid is None else pid,
+        kind=kind,
+        workspace=str(workspace),
+        model_id=model_id,
+        label=label,
+    )
+    path = _path(record.pid)
+    temporary = path.with_suffix(".json.tmp")
+    temporary.write_text(json.dumps(record.as_dict()), encoding="utf-8")
+    temporary.replace(path)
+    return record
+
+
+def release_active(pid: int | None = None) -> None:
+    """Drop this process's registry file. Missing files are fine."""
+    path = _path(os.getpid() if pid is None else pid)
+    try:
+        path.unlink()
+    except FileNotFoundError:
+        return
+
+
+def _load(path: Path) -> ActiveSession | None:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    if not isinstance(payload, dict):
+        return None
+    session_id = str(payload.get("session_id") or "")
+    try:
+        pid = int(payload.get("pid") or 0)
+    except (TypeError, ValueError):
+        return None
+    if not session_id or pid <= 0:
+        return None
+    return ActiveSession(
+        session_id=session_id,
+        pid=pid,
+        kind=str(payload.get("kind") or "agent"),
+        workspace=str(payload.get("workspace") or ""),
+        model_id=str(payload.get("model_id") or ""),
+        label=str(payload.get("label") or ""),
+    )
+
+
+def list_active(*, include_dead: bool = False) -> list[ActiveSession]:
+    """Return live sessions, dropping registry files whose process has exited."""
+    from coding_agent.resources.usage import process_alive
+
+    records: list[ActiveSession] = []
+    for path in sorted(active_dir().glob("*.json")):
+        record = _load(path)
+        if record is None:
+            continue
+        if process_alive(record.pid):
+            records.append(record)
+            continue
+        if include_dead:
+            records.append(record)
+            continue
+        try:
+            path.unlink()
+        except OSError:
+            pass
+    return records
+
+
+def active_session_ids() -> set[str]:
+    """Session ids currently owned by a live Symphony process."""
+    return {record.session_id for record in list_active()}

coding_agent/addons/persistence/artifacts.py

@@ -0,0 +1,110 @@
+"""Safe session artifact paths and atomic publication helpers."""
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from pathlib import Path
+from typing import Any
+
+
+def safe_path(root: Path, *parts: str) -> Path:
+    """Reject symlinks, including links that happen to point inside the root."""
+    path = root
+    if root.is_symlink():
+        raise ValueError(f"unsafe artifact directory: {root}")
+    for part in parts:
+        component = Path(part)
+        if component.is_absolute() or any(p in {".", ".."} for p in component.parts):
+            raise ValueError(f"unsafe artifact path: {part!r}")
+        for name in component.parts:
+            path = path / name
+            if path.is_symlink():
+                raise ValueError(f"unsafe artifact symlink: {path}")
+    if not path.resolve().is_relative_to(root.resolve()):
+        raise ValueError(f"artifact path escapes root: {path}")
+    return path
+
+
+def fsync_dir(directory: Path) -> None:
+    """Make a rename or create durable. The file fsync alone does not."""
+    fd = os.open(directory, os.O_RDONLY)
+    try:
+        os.fsync(fd)
+    finally:
+        os.close(fd)
+
+
+def publish(path: Path, payload: bytes) -> None:
+    """Publish a complete file using a unique sibling temporary file."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.is_symlink():
+        raise ValueError(f"unsafe artifact symlink: {path}")
+    fd, temporary = tempfile.mkstemp(prefix=f".{path.name}.", suffix=".tmp", dir=path.parent)
+    replaced = False
+    try:
+        with os.fdopen(fd, "wb") as handle:
+            handle.write(payload)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temporary, path)
+        replaced = True
+        fsync_dir(path.parent)
+    finally:
+        if not replaced:
+            Path(temporary).unlink(missing_ok=True)
+
+
+def append_bytes(path: Path, payload: bytes) -> None:
+    """Append one durable record. The line is fsynced before this returns.
+
+    The directory is fsynced only when this call created the file: appending
+    to an existing file adds no directory entry, and the file fsync already
+    makes the new length durable.
+    """
+    if not payload:
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.is_symlink():
+        raise ValueError(f"unsafe artifact symlink: {path}")
+    created = not path.exists()
+    flags = os.O_APPEND | os.O_CREAT | os.O_WRONLY
+    if hasattr(os, "O_NOFOLLOW"):
+        flags |= os.O_NOFOLLOW
+    fd = os.open(path, flags, 0o644)
+    try:
+        view = payload
+        while view:
+            written = os.write(fd, view)
+            if written <= 0:
+                raise OSError(f"short write to {path}")
+            view = view[written:]
+        os.fsync(fd)
+    finally:
+        os.close(fd)
+    if created:
+        fsync_dir(path.parent)
+
+
+def _snapshot_bytes(payload: dict[str, Any]) -> bytes:
+    return (json.dumps(payload, ensure_ascii=False) + "\n").encode("utf-8")
+
+
+def snapshot(path: Path, payload: dict[str, Any]) -> None:
+    publish(path, _snapshot_bytes(payload))
+
+
+def refresh_snapshot(path: Path, payload: dict[str, Any]) -> None:
+    """Publish ``payload`` only when the file is missing or holds other bytes.
+
+    Re-reading a journal repairs artifacts a crash left stale. When they are
+    already current this costs one small read instead of two fsyncs.
+    """
+    encoded = _snapshot_bytes(payload)
+    if not path.is_symlink():
+        try:
+            if path.read_bytes() == encoded:
+                return
+        except OSError:
+            pass
+    publish(path, encoded)

coding_agent/addons/persistence/collection.py

@@ -0,0 +1,166 @@
+"""Mark mid-run control-plane events as collected after a run finishes.
+
+The JSONL journal is append-only, so collection never rewrites historical
+entries. A later ``collected`` record points at the original ``(run_id, seq)``
+and stays sticky: once tagged, an event remains collected on every later load.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Iterable, Mapping, Sequence
+
+# Events that belong to the work between the user message and the final
+# assistant reply. Token-delta types are never persisted, so they are omitted.
+COLLECTABLE_EVENT_TYPES = frozenset(
+    {
+        "turn_started",
+        "turn_completed",
+        "model_retry_scheduled",
+        "tool_call_started",
+        "tool_execution_started",
+        "tool_execution_completed",
+        "usage",
+        "context",
+        "context_warning",
+        "compaction_started",
+        "compaction_completed",
+        "message_injected",
+        "waiting_for_children",
+        "agent_spawned",
+        "agent_completed",
+        "agent_failed",
+    }
+)
+
+TERMINAL_EVENT_TYPES = frozenset(
+    {
+        "run_completed",
+        "run_failed",
+        "run_cancelled",
+        "run_limit_exceeded",
+    }
+)
+
+
+def is_collected(payload: Mapping[str, Any] | None) -> bool:
+    """True when a payload (or a later overlay) has ``collected: true``."""
+    return bool(payload and payload.get("collected") is True)
+
+
+def event_key(payload: Mapping[str, Any] | None) -> tuple[str, int] | None:
+    """Stable identity for a stamped harness event."""
+    if not payload:
+        return None
+    run_id = payload.get("run_id")
+    seq = payload.get("seq")
+    if run_id and isinstance(seq, int):
+        return (str(run_id), seq)
+    return None
+
+
+def is_collectable_event(event_type: str, payload: Mapping[str, Any] | None = None) -> bool:
+    """True for mid-run events that the TUI folds after the final reply."""
+    if event_type not in COLLECTABLE_EVENT_TYPES:
+        return False
+    if is_collected(payload):
+        return False
+    return True
+
+
+def collected_keys(events: Iterable[tuple[str, Mapping[str, Any]]]) -> set[tuple[str, int]]:
+    """Return every ``(run_id, seq)`` that has been tagged collected."""
+    keys: set[tuple[str, int]] = set()
+    for event_type, payload in events:
+        key = event_key(payload)
+        if key is None:
+            continue
+        if event_type == "collected" or is_collected(payload):
+            keys.add(key)
+    return keys
+
+
+def apply_collection(
+    events: Sequence[tuple[str, Mapping[str, Any]]],
+    *,
+    collected: Iterable[tuple[str, int]] | None = None,
+) -> list[tuple[str, dict[str, Any]]]:
+    """Overlay ``collected: true`` onto events that have been tagged.
+
+    Overlay records (``event_type == "collected"``) are consumed and not
+    returned; the original event keeps its type and gains the flag.
+    """
+    tagged = set(collected) if collected is not None else collected_keys(events)
+    applied: list[tuple[str, dict[str, Any]]] = []
+    for event_type, payload in events:
+        if event_type == "collected":
+            continue
+        outgoing = dict(payload)
+        key = event_key(outgoing)
+        if key is not None and key in tagged:
+            outgoing["collected"] = True
+        applied.append((event_type, outgoing))
+    return applied
+
+
+def collectable_from_events(
+    events: Sequence[tuple[str, Mapping[str, Any]]],
+    *,
+    run_id: str | None = None,
+) -> list[tuple[str, int]]:
+    """Keys of mid-run events that should be collected for a finished run.
+
+    Collection covers events from ``run_started`` (exclusive) up to the
+    terminal run event (exclusive). The user prompt and the final assistant
+    output stay uncollected so the TUI can keep them as visible transcript
+    rows. When ``run_id`` is omitted, the most recent terminal event's run
+    is collected.
+    """
+    if run_id is None:
+        run_id = _latest_terminal_run_id(events)
+    if not run_id:
+        return []
+    started = False
+    keys: list[tuple[str, int]] = []
+    seen: set[tuple[str, int]] = set()
+    for event_type, payload in events:
+        payload_run = str(payload.get("run_id") or "")
+        if payload_run != run_id:
+            continue
+        if event_type == "run_started":
+            started = True
+            continue
+        if not started:
+            continue
+        if event_type in TERMINAL_EVENT_TYPES:
+            break
+        if not is_collectable_event(event_type, payload):
+            continue
+        key = event_key(payload)
+        if key is None or key in seen:
+            continue
+        seen.add(key)
+        keys.append(key)
+    return keys
+
+
+def _latest_terminal_run_id(
+    events: Sequence[tuple[str, Mapping[str, Any]]],
+) -> str | None:
+    for event_type, payload in reversed(list(events)):
+        if event_type in TERMINAL_EVENT_TYPES:
+            run_id = payload.get("run_id")
+            if run_id:
+                return str(run_id)
+    return None
+
+
+__all__ = [
+    "COLLECTABLE_EVENT_TYPES",
+    "TERMINAL_EVENT_TYPES",
+    "apply_collection",
+    "collectable_from_events",
+    "collected_keys",
+    "event_key",
+    "is_collectable_event",
+    "is_collected",
+]

coding_agent/addons/persistence/compatibility.py

@@ -0,0 +1,30 @@
+"""Fail closed when resuming sessions saved with retired execution modes."""
+
+import json
+from pathlib import Path
+from uuid import UUID
+
+from coding_agent.config import symphony_dir
+from coding_agent.addons.persistence.artifacts import safe_path
+
+
+def validate_session_workflow(directory: Path | None, session_id: str) -> None:
+    """Check before any model/tool execution, including direct and headless runs.
+
+    Never rewrite saved state or delete the user's archived plans. The bundle
+    takes precedence over the legacy protocol state, as in protocol loading.
+    """
+    path = safe_path(directory, "state.json") if directory is not None else None
+    if path is None or not path.exists():
+        try:
+            path = symphony_dir() / "protocols" / f"{UUID(session_id)}.json"
+        except ValueError:
+            return
+    if not path.exists():
+        return
+    data = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict) or 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."
+        )