diff --git a/Tools/clawarena-graphcode/.gitignore b/Tools/clawarena-graphcode/.gitignore
new file mode 100644
index 00000000..af199ef6
--- /dev/null
+++ b/Tools/clawarena-graphcode/.gitignore
@@ -0,0 +1,5 @@
+__pycache__/
+.venv/
+dist/
+uv.lock
+results/
diff --git a/Tools/clawarena-graphcode/README.md b/Tools/clawarena-graphcode/README.md
new file mode 100644
index 00000000..f149a3fb
--- /dev/null
+++ b/Tools/clawarena-graphcode/README.md
@@ -0,0 +1,68 @@
+# clawarena-graphcode
+
+Runs a GraphCode loop as the **main agent** (manager) of
+[ClawArena-Team](https://github.com/aiming-lab/ClawArena/tree/main/ClawArena-Team), for private
+trials. Nothing is added to ClawArena and nothing is submitted anywhere. The feasibility report,
+the comparability caveats and the cost estimate are in
+[`docs/benchmarks/clawarena-team-trial.md`](../../docs/benchmarks/clawarena-team-trial.md).
+
+## How it plugs in
+
+ClawArena scores management from its own tool traces. Every `Read`, `CreateSubagent`,
+`RunSubagent` or `Workflow` has to go through its harness, so GraphCode joins as the `main`
+*provider* rather than replacing the harness:
+
+| Piece | Role |
+|---|---|
+| `GraphCodeProvider` (`provider: graphcode`) | Each harness model call becomes one turn file; the reply names tool calls or a final answer |
+| Manager loop | A time loop with no cadence, created on the first call and woken by `graphcode node send` for later turns |
+| `.claude/settings.json` in the loop's project | Denies Bash, Agent/Task, web tools, and reads or edits of the scenario workspace, so the loop can't work around the harness |
+| `StubPoolProvider` (`provider: stub`) + scripted transport | Zero-spend dry run: no model is called anywhere |
+
+The turn files are the whole protocol: `turn-NNNN.json` carries the messages the loop has not seen
+and, when they change, the tool schemas; the loop writes `reply-NNNN.json` as
+`{"content": "...", "tool_calls": [{"name": "...", "arguments": {...}}]}`. A malformed reply gets
+one corrective turn, then a `ProviderError` (ClawArena retries the scenario).
+
+## Install
+
+The ClawArena-Team tokenizer ships in its checkout's `helper/`, so install it editable:
+
+```sh
+git clone https://github.com/aiming-lab/ClawArena   # trial pinned 630efd8a
+cd ClawArena/ClawArena-Team
+uv venv -p 3.12 .venv
+uv pip install -p .venv/bin/python -e '.[dev]' -e /path/to/GraphCode/Tools/clawarena-graphcode
+```
+
+## Zero-spend dry run
+
+A scripted manager answers through the real exchange files, and every pool key is a stub:
+
+```sh
+.venv/bin/clawarena-graphcode-dry-run -d data/clawarena-team -t s_observability_incident -o results/dry
+```
+
+It passes no rounds by construction. It shows that turns, reply parsing, harness-executed
+subagent tools, per-round checks and the report all connect.
+
+## Real run (not done: needs a subagent pool and approved spend)
+
+```sh
+.venv/bin/clawarena-graphcode run -d data/clawarena-team -t s_observability_incident \
+  --config configs/eval_base.yaml -o results/graphcode \
+  -m '{"main": {"provider": "graphcode", "model_id": "graphcode-claude-opus-5",
+                "backend": "claudeCode", "model_tier": "capable",
+                "turn_timeout_sec": 1800, "modalities": {"text": true}}}'
+```
+
+This needs a running graphcoded and a `graphcode` CLI on `PATH`, and the three pool endpoints
+from `configs/eval_base.yaml` must answer. Each scenario creates one loop in its own throwaway
+project directory, and loops are stopped when the process exits.
+
+## Tests
+
+```sh
+.venv/bin/python -m pytest /path/to/GraphCode/Tools/clawarena-graphcode/tests
+CLAWARENA_TEAM_DATA=$PWD/data/clawarena-team .venv/bin/python -m pytest /path/to/.../tests/test_dry_run.py
+```
diff --git a/Tools/clawarena-graphcode/clawarena_graphcode/__init__.py b/Tools/clawarena-graphcode/clawarena_graphcode/__init__.py
new file mode 100644
index 00000000..236f59e0
--- /dev/null
+++ b/Tools/clawarena-graphcode/clawarena_graphcode/__init__.py
@@ -0,0 +1,14 @@
+"""A GraphCode loop as the ClawArena-Team main agent."""
+
+from .provider import GraphCodeProvider, stop_all
+from .stub import StubPoolProvider
+
+
+def register() -> None:
+    from clawarena_team.provider import register_provider
+
+    register_provider(GraphCodeProvider.name, GraphCodeProvider)
+    register_provider(StubPoolProvider.name, StubPoolProvider)
+
+
+__all__ = ["GraphCodeProvider", "StubPoolProvider", "register", "stop_all"]
diff --git a/Tools/clawarena-graphcode/clawarena_graphcode/cli.py b/Tools/clawarena-graphcode/clawarena_graphcode/cli.py
new file mode 100644
index 00000000..9664be7d
--- /dev/null
+++ b/Tools/clawarena-graphcode/clawarena_graphcode/cli.py
@@ -0,0 +1,71 @@
+"""``clawarena-graphcode``: the ClawArena-Team CLI with the graphcode providers registered."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from . import register, stop_all
+
+STUB_POOL = {
+    "llm": {"provider": "stub", "model_id": "stub-llm", "modalities": {"text": True}},
+    "vlm": {
+        "provider": "stub",
+        "model_id": "stub-vlm",
+        "modalities": {"text": True, "image": 8, "video": 2},
+    },
+    "omni": {
+        "provider": "stub",
+        "model_id": "stub-omni",
+        "modalities": {"text": True, "image": 8, "audio": 4, "video": 2},
+    },
+}
+
+
+def dry_run_model_json(exchange_root: str | None = None) -> str:
+    main = {
+        "provider": "graphcode",
+        "model_id": "graphcode-scripted-dry-run",
+        "transport": "scripted",
+        "poll_interval_sec": 0.05,
+        "turn_timeout_sec": 30,
+        "modalities": {"text": True},
+    }
+    if exchange_root:
+        main["exchange_root"] = exchange_root
+    return json.dumps({"main": main, **STUB_POOL})
+
+
+def main(argv: list[str] | None = None) -> None:
+    register()
+    from clawarena_team.cli import main as clawarena_main
+
+    try:
+        clawarena_main.main(args=argv, prog_name="clawarena-graphcode")
+    finally:
+        stop_all()
+
+
+def dry_run(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="clawarena-graphcode-dry-run",
+        description="Run scenarios with a scripted manager and a stub pool: no model, no spend.",
+    )
+    parser.add_argument("-d", "--data", required=True)
+    parser.add_argument("-t", "--scenario-id", required=True)
+    parser.add_argument("-o", "--out", required=True)
+    parser.add_argument("--exchange-root")
+    args = parser.parse_args(argv if argv is not None else sys.argv[1:])
+    main(
+        [
+            "run",
+            "-d", args.data,
+            "-t", args.scenario_id,
+            "-o", args.out,
+            "--retry", "1",
+            # The probe posts real HTTP requests to each pool api_base; the stubs have none.
+            "--skip-probe",
+            "-m", dry_run_model_json(args.exchange_root),
+        ]
+    )
diff --git a/Tools/clawarena-graphcode/clawarena_graphcode/protocol.py b/Tools/clawarena-graphcode/clawarena_graphcode/protocol.py
new file mode 100644
index 00000000..94b7029a
--- /dev/null
+++ b/Tools/clawarena-graphcode/clawarena_graphcode/protocol.py
@@ -0,0 +1,189 @@
+"""The file exchange between the ClawArena harness and the manager loop.
+
+The harness owns the tools: every Read, CreateSubagent or Workflow the manager asks for is
+executed, sandboxed and scored by ClawArena. The loop only decides. Each model call the
+harness makes becomes one turn file holding the messages the loop has not seen yet; the
+loop answers with one reply file naming the tool calls it wants, or a final answer.
+
+Files carry the content because `graphcode node send` flattens newlines and clips long
+messages; the message that wakes the loop is only a pointer.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+MANAGER_PROMPT = (
+    "You are the main agent (manager) in a ClawArena-Team benchmark scenario. The benchmark "
+    "harness owns every tool; you only decide. Turns arrive as JSON files: read the turn file "
+    "named in each message. It holds the new conversation messages since your last reply "
+    "(system, user and tool results, with <system-reminder> and <task-notification> blocks) "
+    "and, when they change, the tool schemas you may call. Answer each turn by writing exactly "
+    "one JSON object to the reply path the message names: "
+    '{"content": "<text>", "tool_calls": [{"name": "<tool>", "arguments": {...}}]}. '
+    "Request tools only through tool_calls; several calls in one reply run in parallel. A "
+    "reply with no tool_calls is your final answer to the current user question. Never read, "
+    "search or edit the scenario workspace yourself, never run shell commands and never start "
+    "your own subagents: the harness scores only what goes through tool_calls, and doing any "
+    "of it directly invalidates the run. After writing the reply, end your turn and wait for "
+    "the next message."
+)
+
+_ASSISTANT = "assistant"
+_DELEGABLE_RE = re.compile(r"delegable_paths[^\n]*\n((?:[ \t]+- [^\n]+\n?)+)")
+_CWD_RE = re.compile(r"^\s*cwd: (.+)$", re.MULTILINE)
+
+
+class ReplyError(ValueError):
+    """The loop's reply cannot be turned into a model response."""
+
+
+class Exchange:
+    def __init__(self, root: Path):
+        self.root = root
+
+    def turn_path(self, turn: int) -> Path:
+        return self.root / f"turn-{turn:04d}.json"
+
+    def reply_path(self, turn: int) -> Path:
+        return self.root / f"reply-{turn:04d}.json"
+
+    def write_turn(self, turn: int, payload: dict[str, Any]) -> Path:
+        self.root.mkdir(parents=True, exist_ok=True)
+        path = self.turn_path(turn)
+        tmp = path.with_suffix(".json.tmp")
+        tmp.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+        os.replace(tmp, path)
+        return path
+
+    def read_reply(self, turn: int) -> dict[str, Any] | None:
+        """The reply once it parses; a half-written file reads as not there yet."""
+        path = self.reply_path(turn)
+        try:
+            text = path.read_text(encoding="utf-8")
+        except FileNotFoundError:
+            return None
+        try:
+            value = json.loads(_strip_fence(text))
+        except json.JSONDecodeError:
+            return None
+        if not isinstance(value, dict):
+            raise ReplyError(f"{path.name} must hold a JSON object, got {type(value).__name__}")
+        return value
+
+
+def pointer_message(exchange: Exchange, turn: int) -> str:
+    return (
+        f"ClawArena turn {turn}: read {exchange.turn_path(turn)} and write your reply JSON "
+        f"to {exchange.reply_path(turn)}."
+    )
+
+
+def unseen_messages(messages: list[dict[str, Any]], seen: int) -> list[dict[str, Any]]:
+    """Messages past ``seen``, minus the loop's own replies echoed back by the harness."""
+    return [_flatten(m) for m in messages[seen:] if m.get("role") != _ASSISTANT]
+
+
+def turn_payload(
+    *,
+    turn: int,
+    reply_path: Path,
+    messages: list[dict[str, Any]],
+    tools: list[dict[str, Any]] | None,
+    error: str | None = None,
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {"turn": turn, "reply_path": str(reply_path), "messages": messages}
+    if tools is not None:
+        payload["tools"] = tools
+    if error:
+        payload["error"] = error
+    return payload
+
+
+def parse_reply(
+    reply: dict[str, Any], *, tool_names: set[str], turn: int
+) -> tuple[str, list[dict[str, Any]]]:
+    content = reply.get("content") or ""
+    if not isinstance(content, str):
+        raise ReplyError("content must be a string")
+    raw_calls = reply.get("tool_calls") or []
+    if not isinstance(raw_calls, list):
+        raise ReplyError("tool_calls must be a list")
+    calls: list[dict[str, Any]] = []
+    for index, raw in enumerate(raw_calls):
+        if not isinstance(raw, dict):
+            raise ReplyError(f"tool_calls[{index}] must be an object")
+        name = raw.get("name")
+        if name not in tool_names:
+            raise ReplyError(f"tool_calls[{index}] names unknown tool {name!r}")
+        arguments = raw.get("arguments") or {}
+        if isinstance(arguments, str):
+            try:
+                arguments = json.loads(arguments)
+            except json.JSONDecodeError as e:
+                raise ReplyError(f"tool_calls[{index}].arguments is not JSON: {e}") from None
+        if not isinstance(arguments, dict):
+            raise ReplyError(f"tool_calls[{index}].arguments must be an object")
+        call_id = raw.get("id") or f"gc-{turn}-{index}"
+        calls.append({"id": str(call_id), "name": name, "arguments": arguments})
+    return content, calls
+
+
+def delegable_paths(messages: list[dict[str, Any]]) -> list[str]:
+    for message in messages:
+        match = _DELEGABLE_RE.search(_text(message))
+        if match:
+            return [line.strip()[2:].strip() for line in match.group(1).splitlines() if line.strip()]
+    return []
+
+
+def workspace_path(messages: list[dict[str, Any]]) -> str | None:
+    for message in messages:
+        match = _CWD_RE.search(_text(message))
+        if match:
+            return match.group(1).strip()
+    return None
+
+
+def manager_settings(workspace: str | None) -> dict[str, Any]:
+    """Claude Code permissions for the loop's project: it may read turns and write replies,
+    and nothing that would do the harness's work outside the harness."""
+    deny = ["Bash", "Agent", "Task", "WebFetch", "WebSearch", "NotebookEdit"]
+    if workspace:
+        root = "/" + workspace.lstrip("/")
+        deny += [f"Read(/{root}/**)", f"Edit(/{root}/**)", f"Glob(/{root}/**)", f"Grep(/{root}/**)"]
+    return {"permissions": {"deny": deny}}
+
+
+def _flatten(message: dict[str, Any]) -> dict[str, Any]:
+    out = {k: v for k, v in message.items() if k != "content"}
+    out["content"] = _text(message)
+    return out
+
+
+def _text(message: dict[str, Any]) -> str:
+    content = message.get("content")
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for part in content:
+            if isinstance(part, dict) and part.get("type") == "text":
+                parts.append(part.get("text", ""))
+            elif isinstance(part, dict):
+                parts.append(f"[{part.get('type', 'part')} omitted: the manager is text-only]")
+        return "\n".join(parts)
+    return ""
+
+
+def _strip_fence(text: str) -> str:
+    stripped = text.strip()
+    if stripped.startswith("```"):
+        stripped = stripped.split("\n", 1)[1] if "\n" in stripped else ""
+        if stripped.rstrip().endswith("```"):
+            stripped = stripped.rstrip()[:-3]
+    return stripped
diff --git a/Tools/clawarena-graphcode/clawarena_graphcode/provider.py b/Tools/clawarena-graphcode/clawarena_graphcode/provider.py
new file mode 100644
index 00000000..0401e66d
--- /dev/null
+++ b/Tools/clawarena-graphcode/clawarena_graphcode/provider.py
@@ -0,0 +1,189 @@
+"""ClawArena-Team provider whose every model call is answered by a GraphCode loop."""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import json
+import tempfile
+import time
+import weakref
+from pathlib import Path
+from typing import Any
+
+from clawarena_team.provider.base import BaseProvider, ProviderError
+from clawarena_team.types import ModelConfig
+
+from .protocol import (
+    MANAGER_PROMPT,
+    Exchange,
+    ReplyError,
+    manager_settings,
+    parse_reply,
+    pointer_message,
+    turn_payload,
+    unseen_messages,
+    workspace_path,
+)
+from .transport import GraphCodeCLI, Transport, TransportError
+
+_LIVE: "weakref.WeakSet[GraphCodeProvider]" = weakref.WeakSet()
+ENDED_STATES = frozenset({"stopped", "failed", "stalled", "succeeded"})
+
+
+def stop_all() -> None:
+    """Stop every loop this process started; the harness has no end-of-scenario hook."""
+    for provider in list(_LIVE):
+        provider.stop()
+
+
+class GraphCodeProvider(BaseProvider):
+    """``--model`` main entry: ``{"provider": "graphcode", "model_id": "<label>", ...}``.
+
+    Extra keys: ``project`` (graph the loop is created in; defaults to the exchange
+    directory), ``exchange_root``, ``backend``, ``model_tier`` (``fast``, ``standard`` or
+    ``capable``), ``graphcode_bin``, ``transport``
+    (``cli``, or ``scripted`` for the zero-spend dry run), ``poll_interval_sec``,
+    ``turn_timeout_sec``, ``max_reply_retries``, ``liveness_interval_sec``.
+    """
+
+    name = "graphcode"
+
+    def __init__(self, config: ModelConfig, *, transport: Transport | None = None):
+        super().__init__(config)
+        extra = config.extra
+        root = extra.get("exchange_root")
+        base = Path(root) if root else Path(tempfile.mkdtemp(prefix="clawarena-graphcode-"))
+        self.exchange = Exchange(base / f"exchange-{int(time.time() * 1000)}")
+        self.project = Path(extra.get("project") or self.exchange.root)
+        self.poll_interval = float(extra.get("poll_interval_sec", 1.0))
+        self.turn_timeout = float(extra.get("turn_timeout_sec", 1800))
+        self.max_reply_retries = int(extra.get("max_reply_retries", 1))
+        self.liveness_interval = float(extra.get("liveness_interval_sec", 30))
+        self._transport = transport or self._make_transport(extra)
+        self.node_id: str | None = None
+        self.turn = 0
+        self._seen = 0
+        self._tools_digest: str | None = None
+        _LIVE.add(self)
+
+    def _make_transport(self, extra: dict[str, Any]) -> Transport:
+        kind = extra.get("transport", "cli")
+        if kind == "scripted":
+            from .stub import ScriptedTransport
+
+            return ScriptedTransport(self.exchange)
+        if kind != "cli":
+            raise ProviderError(f"unknown graphcode transport {kind!r}")
+        return GraphCodeCLI(
+            self.project,
+            executable=extra.get("graphcode_bin", "graphcode"),
+            backend=extra.get("backend"),
+            model_tier=extra.get("model_tier"),
+        )
+
+    async def chat(
+        self,
+        *,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]] | None = None,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        tools = tools or []
+        tool_names = {t["name"] for t in tools}
+        new_messages = unseen_messages(messages, self._seen)
+        self._seen = len(messages)
+        error: str | None = None
+        for _ in range(self.max_reply_retries + 1):
+            self.turn += 1
+            turn = self.turn
+            self.exchange.write_turn(
+                turn,
+                turn_payload(
+                    turn=turn,
+                    reply_path=self.exchange.reply_path(turn),
+                    messages=[] if error else new_messages,
+                    tools=self._tools_if_changed(tools),
+                    error=error,
+                ),
+            )
+            await asyncio.to_thread(self._wake, turn, messages)
+            try:
+                reply = await self._await_reply(turn)
+                content, calls = parse_reply(reply, tool_names=tool_names, turn=turn)
+            except ReplyError as e:
+                error = f"reply {turn} rejected: {e}. Answer the same turn again."
+                continue
+            return self.normalise_response(
+                content=content,
+                tool_calls=calls,
+                extra={"graphcode_node_id": self.node_id, "graphcode_turn": turn},
+            )
+        raise ProviderError(f"graphcode manager gave no usable reply: {error}")
+
+    def stop(self) -> None:
+        if self.node_id is None:
+            return
+        node_id, self.node_id = self.node_id, None
+        try:
+            self._transport.stop(node_id)
+        except TransportError:
+            pass
+
+    def _wake(self, turn: int, messages: list[dict[str, Any]]) -> None:
+        try:
+            if self.node_id is None:
+                self._write_project_settings(workspace_path(messages))
+                prompt = f"{MANAGER_PROMPT} {pointer_message(self.exchange, turn)}"
+                self.node_id = self._transport.start(prompt)
+            else:
+                self._transport.deliver(self.node_id, pointer_message(self.exchange, turn))
+        except TransportError as e:
+            raise ProviderError(str(e)) from e
+
+    def _write_project_settings(self, workspace: str | None) -> None:
+        settings = self.project / ".claude" / "settings.json"
+        if settings.exists():
+            return
+        settings.parent.mkdir(parents=True, exist_ok=True)
+        settings.write_text(json.dumps(manager_settings(workspace), indent=2), encoding="utf-8")
+
+    async def _await_reply(self, turn: int) -> dict[str, Any]:
+        deadline = time.monotonic() + self.turn_timeout
+        next_liveness = time.monotonic() + self.liveness_interval
+        while True:
+            reply = self.exchange.read_reply(turn)
+            if reply is not None:
+                return reply
+            now = time.monotonic()
+            if now >= deadline:
+                raise ProviderError(
+                    f"graphcode manager wrote no reply to turn {turn} in {self.turn_timeout:.0f}s"
+                )
+            if now >= next_liveness:
+                next_liveness = now + self.liveness_interval
+                await self._raise_if_loop_ended(turn)
+            await asyncio.sleep(self.poll_interval)
+
+    async def _raise_if_loop_ended(self, turn: int) -> None:
+        """A loop that failed to launch or was stopped never replies; fail the call now
+        rather than after the whole turn timeout."""
+        state_of = getattr(self._transport, "state", None)
+        if state_of is None or self.node_id is None:
+            return
+        try:
+            state = await asyncio.to_thread(state_of, self.node_id)
+        except TransportError:
+            return
+        if state is None or state in ENDED_STATES:
+            raise ProviderError(
+                f"graphcode manager loop {self.node_id} is {state or 'gone'}; "
+                f"no reply to turn {turn} will come"
+            )
+
+    def _tools_if_changed(self, tools: list[dict[str, Any]]) -> list[dict[str, Any]] | None:
+        digest = hashlib.sha256(json.dumps(tools, sort_keys=True).encode()).hexdigest()
+        if digest == self._tools_digest:
+            return None
+        self._tools_digest = digest
+        return tools
diff --git a/Tools/clawarena-graphcode/clawarena_graphcode/stub.py b/Tools/clawarena-graphcode/clawarena_graphcode/stub.py
new file mode 100644
index 00000000..d01b28a4
--- /dev/null
+++ b/Tools/clawarena-graphcode/clawarena_graphcode/stub.py
@@ -0,0 +1,117 @@
+"""Zero-spend stand-ins: a scripted manager behind the real exchange, and a stub pool.
+
+Neither calls a model. A dry run with them proves the plumbing — turn files, reply
+parsing, the harness executing CreateSubagent/RunSubagent, per-round checks and the
+report — and nothing about how well any model manages.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+
+from clawarena_team.provider.base import BaseProvider
+
+from .protocol import Exchange, delegable_paths
+
+_SUBAGENT_ID_RE = re.compile(r"subagent_id=(\S+)")
+
+
+class StubPoolProvider(BaseProvider):
+    name = "stub"
+
+    async def chat(self, *, messages, tools=None, **kwargs):
+        return self.normalise_response(
+            content=f"[stub {self.config.model_id}] no model was called ({len(messages)} messages)"
+        )
+
+
+class ScriptedManager:
+    """Per user question: create one llm subagent over the first delegable path (once),
+    run it on the question, then answer with what it returned."""
+
+    def __init__(self) -> None:
+        self.subagent_id: str | None = None
+        self.delegable: list[str] = []
+        self.question = ""
+        self.phase = "idle"
+
+    def answer(self, turn: dict[str, Any]) -> dict[str, Any]:
+        messages = turn.get("messages") or []
+        self.delegable = self.delegable or delegable_paths(messages)
+        for message in messages:
+            if message.get("role") == "user" and message.get("content", "").strip():
+                self.question = message["content"].split("<system-reminder>")[0].strip()
+                self.phase = "question"
+        tool_output = "\n".join(m.get("content", "") for m in messages if m.get("role") == "tool")
+
+        if self.phase == "question":
+            if not self.delegable:
+                return self._final("no delegable paths; answered without subagents")
+            if self.subagent_id is None:
+                self.phase = "creating"
+                return self._call(
+                    "CreateSubagent",
+                    name="dry-run-reader",
+                    system_prompt="Answer from the files you were granted.",
+                    model_key="llm",
+                    tools=["Read", "Grep", "Glob"],
+                    accessible_paths=self.delegable[:1],
+                )
+            return self._run()
+        if self.phase == "creating":
+            match = _SUBAGENT_ID_RE.search(tool_output)
+            if match is None:
+                return self._final(f"CreateSubagent failed: {tool_output[:200]}")
+            self.subagent_id = match.group(1).rstrip(",.")
+            return self._run()
+        if self.phase == "running":
+            return self._final(f"dry run: subagent {self.subagent_id} returned: {tool_output[:200]}")
+        return self._final("nothing pending")
+
+    def _run(self) -> dict[str, Any]:
+        self.phase = "running"
+        return self._call(
+            "RunSubagent",
+            subagent_id=self.subagent_id,
+            description="dry-run delegation",
+            prompt=self.question[:2000] or "Summarise your files.",
+        )
+
+    def _final(self, text: str) -> dict[str, Any]:
+        self.phase = "idle"
+        return {"content": text, "tool_calls": []}
+
+    @staticmethod
+    def _call(tool: str, **arguments: Any) -> dict[str, Any]:
+        return {"content": "", "tool_calls": [{"name": tool, "arguments": arguments}]}
+
+
+class ScriptedTransport:
+    """Answers each turn file the moment it is delivered, through the same files a loop uses."""
+
+    def __init__(self, exchange: Exchange, manager: ScriptedManager | None = None):
+        self.exchange = exchange
+        self.manager = manager or ScriptedManager()
+        self.turns = 0
+        self.stopped = False
+
+    def start(self, prompt: str) -> str:
+        self._answer_pending()
+        return "scripted-manager"
+
+    def deliver(self, node_id: str, message: str) -> None:
+        self._answer_pending()
+
+    def stop(self, node_id: str) -> None:
+        self.stopped = True
+
+    def _answer_pending(self) -> None:
+        for turn_path in sorted(self.exchange.root.glob("turn-*.json")):
+            turn = json.loads(turn_path.read_text(encoding="utf-8"))
+            reply_path = self.exchange.reply_path(turn["turn"])
+            if reply_path.exists():
+                continue
+            reply_path.write_text(json.dumps(self.manager.answer(turn)), encoding="utf-8")
+            self.turns += 1
diff --git a/Tools/clawarena-graphcode/clawarena_graphcode/transport.py b/Tools/clawarena-graphcode/clawarena_graphcode/transport.py
new file mode 100644
index 00000000..f2ebe437
--- /dev/null
+++ b/Tools/clawarena-graphcode/clawarena_graphcode/transport.py
@@ -0,0 +1,101 @@
+"""How the provider reaches the manager loop."""
+
+from __future__ import annotations
+
+import subprocess
+import uuid
+from pathlib import Path
+from typing import Callable, Protocol
+
+LOOP_TITLE_PREFIX = "ClawArenaManager"
+
+
+class TransportError(RuntimeError):
+    pass
+
+
+class Transport(Protocol):
+    def start(self, prompt: str) -> str: ...
+
+    def deliver(self, node_id: str, message: str) -> None: ...
+
+    def stop(self, node_id: str) -> None: ...
+
+
+def parse_node_id(status_output: str, title: str) -> str | None:
+    """The id of the loop titled ``title`` in ``graphcode status`` output."""
+    for line in status_output.splitlines():
+        fields = line.split()
+        if len(fields) >= 4 and " ".join(fields[3:]) == title:
+            return fields[0]
+    return None
+
+
+def parse_node_state(status_output: str, node_id: str) -> str | None:
+    for line in status_output.splitlines():
+        fields = line.split()
+        if len(fields) >= 2 and fields[0] == node_id:
+            return fields[1]
+    return None
+
+
+Runner = Callable[..., subprocess.CompletedProcess]
+
+
+class GraphCodeCLI:
+    """Drives a loop through the ``graphcode`` CLI against a running graphcoded.
+
+    The loop is time-based with no cadence: it starts at once, answers the turn its prompt
+    points at, then sits idle until the next ``node send``. A goal loop would not do: on
+    Claude Code a goal is a Stop hook that keeps the session working until the goal holds,
+    which is the opposite of waiting for the harness.
+    """
+
+    def __init__(
+        self,
+        project: Path,
+        *,
+        executable: str = "graphcode",
+        backend: str | None = None,
+        model_tier: str | None = None,
+        runner: Runner = subprocess.run,
+    ):
+        self.project = project
+        self.executable = executable
+        self.backend = backend
+        self.model_tier = model_tier
+        self._run = runner
+
+    def start(self, prompt: str) -> str:
+        title = f"{LOOP_TITLE_PREFIX}{uuid.uuid4().hex[:8]}"
+        argv = ["node", "create", str(self.project), "--title", title, "--type", "time"]
+        if self.backend:
+            argv += ["--backend", self.backend]
+        if self.model_tier:
+            argv += ["--model", self.model_tier]
+        self._call(argv + ["--prompt", prompt])
+        status = self._call(["status", str(self.project)])
+        node_id = parse_node_id(status, title)
+        if node_id is None:
+            raise TransportError(f"created loop {title} is missing from graphcode status")
+        return node_id
+
+    def deliver(self, node_id: str, message: str) -> None:
+        self._call(["node", "send", str(self.project), node_id, message])
+
+    def stop(self, node_id: str) -> None:
+        self._call(["node", "stop", str(self.project), node_id])
+
+    def state(self, node_id: str) -> str | None:
+        return parse_node_state(self._call(["status", str(self.project)]), node_id)
+
+    def _call(self, argv: list[str]) -> str:
+        result = self._run(
+            [self.executable, *argv], capture_output=True, text=True, check=False
+        )
+        if result.returncode != 0:
+            raise TransportError(
+                f"graphcode {' '.join(argv[:2])} exited {result.returncode}: "
+                f"{(result.stderr or result.stdout).strip()[:500]}"
+            )
+        return result.stdout
diff --git a/Tools/clawarena-graphcode/pyproject.toml b/Tools/clawarena-graphcode/pyproject.toml
new file mode 100644
index 00000000..931270da
--- /dev/null
+++ b/Tools/clawarena-graphcode/pyproject.toml
@@ -0,0 +1,26 @@
+[project]
+name = "clawarena-graphcode"
+version = "0.1.0"
+description = "A GraphCode loop as the ClawArena-Team main agent, for private trials"
+requires-python = ">=3.10"
+# clawarena-team is installed editable from a checkout (see README): its tokenizer and
+# chat template live in the checkout's helper/, which a wheel install does not carry.
+dependencies = []
+
+[project.scripts]
+clawarena-graphcode = "clawarena_graphcode.cli:main"
+clawarena-graphcode-dry-run = "clawarena_graphcode.cli:dry_run"
+
+[dependency-groups]
+dev = ["pytest>=8", "pytest-asyncio>=0.23"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["clawarena_graphcode"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
diff --git a/Tools/clawarena-graphcode/tests/test_dry_run.py b/Tools/clawarena-graphcode/tests/test_dry_run.py
new file mode 100644
index 00000000..f7b64bd0
--- /dev/null
+++ b/Tools/clawarena-graphcode/tests/test_dry_run.py
@@ -0,0 +1,39 @@
+"""The zero-spend dry run against a real ClawArena-Team dataset.
+
+Set ``CLAWARENA_TEAM_DATA`` to ``<ClawArena-Team checkout>/data/clawarena-team`` to run it;
+it needs the checkout's bundled tokenizer, so clawarena-team must be installed editable.
+"""
+
+import json
+import os
+from pathlib import Path
+
+import pytest
+
+from clawarena_graphcode.cli import dry_run
+
+DATA = os.environ.get("CLAWARENA_TEAM_DATA")
+SCENARIO = "s_observability_incident"
+
+
+@pytest.mark.skipif(not DATA, reason="CLAWARENA_TEAM_DATA is not set")
+def test_scripted_manager_runs_a_scenario_end_to_end(tmp_path: Path):
+    with pytest.raises(SystemExit) as exit_info:
+        dry_run(["-d", DATA, "-t", SCENARIO, "-o", str(tmp_path / "out"),
+                 "--exchange-root", str(tmp_path / "exchange")])
+    assert exit_info.value.code in (0, None)
+
+    (scenario_dir,) = (tmp_path / "out").glob(f"*/{SCENARIO}")
+    metadata = json.loads((scenario_dir / "metadata.json").read_text())
+    assert metadata["models"]["main"]["provider"] == "graphcode"
+    assert len(metadata["rounds"]) == len(list((scenario_dir / "evals").glob("*.json"))) > 0
+    assert metadata["metrics"]["subagent_create_count"] >= 1
+
+    called = set()
+    for line in (scenario_dir / "sessions" / "main.jsonl").read_text().splitlines():
+        called.update(call["name"] for call in json.loads(line).get("tool_calls") or [])
+    assert {"CreateSubagent", "RunSubagent"} <= called
+
+    (exchange,) = (tmp_path / "exchange").glob("exchange-*")
+    turns = sorted(exchange.glob("turn-*.json"))
+    assert turns and len(turns) == len(list(exchange.glob("reply-*.json")))
diff --git a/Tools/clawarena-graphcode/tests/test_protocol.py b/Tools/clawarena-graphcode/tests/test_protocol.py
new file mode 100644
index 00000000..86293041
--- /dev/null
+++ b/Tools/clawarena-graphcode/tests/test_protocol.py
@@ -0,0 +1,118 @@
+import json
+
+import pytest
+
+from clawarena_graphcode.protocol import (
+    Exchange,
+    ReplyError,
+    delegable_paths,
+    manager_settings,
+    parse_reply,
+    pointer_message,
+    unseen_messages,
+    workspace_path,
+)
+
+ENV = (
+    "Environment\n"
+    "  scenario_id: s_demo\n"
+    "  cwd: /runs/s_demo/work\n"
+    "  accessible_paths (you can Read here directly):\n"
+    "    - /runs/s_demo/work/briefs\n"
+    "  delegable_paths (you CANNOT touch these yourself — delegate):\n"
+    "    - /runs/s_demo/work/code\n"
+    "    - /runs/s_demo/work/traces\n"
+    "  modalities_natively_supported: text\n"
+)
+
+
+def test_unseen_messages_skip_seen_and_assistant_echoes():
+    messages = [
+        {"role": "system", "content": "sys"},
+        {"role": "user", "content": "q1"},
+        {"role": "assistant", "content": "", "tool_calls": [{"id": "1"}]},
+        {"role": "tool", "tool_call_id": "1", "content": "result"},
+    ]
+    assert unseen_messages(messages, 2) == [{"role": "tool", "tool_call_id": "1", "content": "result"}]
+    assert [m["role"] for m in unseen_messages(messages, 0)] == ["system", "user", "tool"]
+
+
+def test_unseen_messages_flatten_multimodal_parts():
+    message = {"role": "user", "content": [{"type": "image_url"}, {"type": "text", "text": "look"}]}
+    (flat,) = unseen_messages([message], 0)
+    assert flat["content"] == "[image_url omitted: the manager is text-only]\nlook"
+
+
+def test_parse_reply_normalises_calls():
+    content, calls = parse_reply(
+        {
+            "content": "delegating",
+            "tool_calls": [
+                {"name": "CreateSubagent", "arguments": {"name": "a"}},
+                {"name": "Read", "arguments": '{"file_path": "/x"}', "id": "mine"},
+            ],
+        },
+        tool_names={"CreateSubagent", "Read"},
+        turn=3,
+    )
+    assert content == "delegating"
+    assert calls == [
+        {"id": "gc-3-0", "name": "CreateSubagent", "arguments": {"name": "a"}},
+        {"id": "mine", "name": "Read", "arguments": {"file_path": "/x"}},
+    ]
+
+
+def test_parse_reply_without_calls_is_a_final_answer():
+    assert parse_reply({"content": "done"}, tool_names=set(), turn=1) == ("done", [])
+
+
+@pytest.mark.parametrize(
+    "reply, message",
+    [
+        ({"tool_calls": [{"name": "Bash", "arguments": {}}]}, "unknown tool 'Bash'"),
+        ({"tool_calls": {"name": "Read"}}, "must be a list"),
+        ({"tool_calls": [{"name": "Read", "arguments": "{nope"}]}, "not JSON"),
+        ({"tool_calls": [{"name": "Read", "arguments": [1]}]}, "must be an object"),
+        ({"content": 7}, "content must be a string"),
+    ],
+)
+def test_parse_reply_rejects_malformed(reply, message):
+    with pytest.raises(ReplyError, match=message):
+        parse_reply(reply, tool_names={"Read"}, turn=1)
+
+
+def test_exchange_round_trip_and_partial_reply(tmp_path):
+    exchange = Exchange(tmp_path / "ex")
+    path = exchange.write_turn(1, {"turn": 1})
+    assert json.loads(path.read_text()) == {"turn": 1}
+    assert not list(exchange.root.glob("*.tmp"))
+    assert exchange.read_reply(1) is None
+    exchange.reply_path(1).write_text('{"content": "hal')
+    assert exchange.read_reply(1) is None
+    exchange.reply_path(1).write_text('```json\n{"content": "ok"}\n```')
+    assert exchange.read_reply(1) == {"content": "ok"}
+    exchange.reply_path(1).write_text("[1, 2]")
+    with pytest.raises(ReplyError):
+        exchange.read_reply(1)
+
+
+def test_pointer_message_is_one_line(tmp_path):
+    message = pointer_message(Exchange(tmp_path), 12)
+    assert "\n" not in message
+    assert "turn-0012.json" in message and "reply-0012.json" in message
+
+
+def test_environment_parsing():
+    messages = [{"role": "user", "content": "question\n\n<system-reminder>\n" + ENV + "</system-reminder>"}]
+    assert delegable_paths(messages) == ["/runs/s_demo/work/code", "/runs/s_demo/work/traces"]
+    assert workspace_path(messages) == "/runs/s_demo/work"
+    assert delegable_paths([{"role": "user", "content": "none"}]) == []
+
+
+def test_manager_settings_deny_direct_work():
+    deny = manager_settings("/runs/s_demo/work")["permissions"]["deny"]
+    for tool in ("Bash", "Agent", "Task", "WebFetch", "WebSearch"):
+        assert tool in deny
+    assert "Read(//runs/s_demo/work/**)" in deny
+    assert "Edit(//runs/s_demo/work/**)" in deny
+    assert not any("(" in rule for rule in manager_settings(None)["permissions"]["deny"])
diff --git a/Tools/clawarena-graphcode/tests/test_provider.py b/Tools/clawarena-graphcode/tests/test_provider.py
new file mode 100644
index 00000000..fffac48a
--- /dev/null
+++ b/Tools/clawarena-graphcode/tests/test_provider.py
@@ -0,0 +1,205 @@
+import asyncio
+import json
+from pathlib import Path
+
+import pytest
+
+from clawarena_team.provider.base import ProviderError
+from clawarena_team.types import ModelConfig
+
+from clawarena_graphcode.provider import GraphCodeProvider, stop_all
+from clawarena_graphcode.protocol import MANAGER_PROMPT
+from clawarena_graphcode.stub import ScriptedTransport
+
+TOOLS = [
+    {"name": "Read", "description": "", "parameters": {"type": "object"}},
+    {"name": "CreateSubagent", "description": "", "parameters": {"type": "object"}},
+]
+ENV = (
+    "<system-reminder>\nEnvironment\n  cwd: /runs/s/work\n"
+    "  delegable_paths (you CANNOT touch these yourself):\n    - /runs/s/work/code\n"
+    "  modalities_natively_supported: text\n</system-reminder>"
+)
+
+
+class QueueTransport:
+    """Writes queued replies to whichever turn was just delivered."""
+
+    def __init__(self, replies):
+        self.replies = list(replies)
+        self.provider: GraphCodeProvider | None = None
+        self.started: list[str] = []
+        self.delivered: list[str] = []
+        self.stopped: list[str] = []
+
+    def start(self, prompt):
+        self.started.append(prompt)
+        self._reply()
+        return "NODE-1"
+
+    def deliver(self, node_id, message):
+        assert node_id == "NODE-1"
+        self.delivered.append(message)
+        self._reply()
+
+    def stop(self, node_id):
+        self.stopped.append(node_id)
+
+    def _reply(self):
+        if not self.replies:
+            return
+        reply = self.replies.pop(0)
+        text = reply if isinstance(reply, str) else json.dumps(reply)
+        self.provider.exchange.reply_path(self.provider.turn).write_text(text)
+
+
+def make(tmp_path: Path, replies, **extra):
+    config = ModelConfig(
+        provider="graphcode",
+        model_id="graphcode-opus",
+        extra={"exchange_root": str(tmp_path), "poll_interval_sec": 0.01, **extra},
+    )
+    transport = QueueTransport(replies)
+    provider = GraphCodeProvider(config, transport=transport)
+    transport.provider = provider
+    return provider, transport
+
+
+def turn_file(provider: GraphCodeProvider, turn: int) -> dict:
+    return json.loads(provider.exchange.turn_path(turn).read_text())
+
+
+async def test_first_call_starts_the_loop_then_later_calls_deliver(tmp_path):
+    provider, transport = make(
+        tmp_path,
+        [
+            {"content": "", "tool_calls": [{"name": "Read", "arguments": {"file_path": "/a"}}]},
+            {"content": "final"},
+        ],
+    )
+    first = [{"role": "system", "content": "sys"}, {"role": "user", "content": "q " + ENV}]
+    resp = await provider.chat(messages=first, tools=TOOLS)
+    assert resp["tool_calls"] == [{"id": "gc-1-0", "name": "Read", "arguments": {"file_path": "/a"}}]
+    assert resp["model_id"] == "graphcode-opus"
+    assert resp["extra"] == {"graphcode_node_id": "NODE-1", "graphcode_turn": 1}
+    assert transport.started[0].startswith(MANAGER_PROMPT)
+    assert str(provider.exchange.turn_path(1)) in transport.started[0]
+    assert turn_file(provider, 1)["tools"] == TOOLS
+
+    second = first + [
+        {"role": "assistant", "content": "", "tool_calls": resp["tool_calls"]},
+        {"role": "tool", "tool_call_id": "gc-1-0", "content": "file body"},
+    ]
+    resp = await provider.chat(messages=second, tools=TOOLS)
+    assert resp["content"] == "final" and resp["tool_calls"] == []
+    payload = turn_file(provider, 2)
+    assert payload["messages"] == [{"role": "tool", "tool_call_id": "gc-1-0", "content": "file body"}]
+    assert "tools" not in payload
+    assert len(transport.delivered) == 1 and "\n" not in transport.delivered[0]
+
+
+async def test_loop_project_denies_direct_workspace_access(tmp_path):
+    provider, _ = make(tmp_path, [{"content": "ok"}])
+    await provider.chat(messages=[{"role": "user", "content": "q " + ENV}], tools=TOOLS)
+    settings = json.loads((provider.project / ".claude" / "settings.json").read_text())
+    assert "Read(//runs/s/work/**)" in settings["permissions"]["deny"]
+    assert "Agent" in settings["permissions"]["deny"]
+
+
+async def test_changed_tools_are_resent(tmp_path):
+    provider, _ = make(tmp_path, [{"content": "a"}, {"content": "b"}])
+    await provider.chat(messages=[{"role": "user", "content": "q"}], tools=TOOLS)
+    more = TOOLS + [{"name": "StructuredOutput", "description": "", "parameters": {}}]
+    await provider.chat(messages=[{"role": "user", "content": "q"}], tools=more)
+    assert turn_file(provider, 2)["tools"] == more
+
+
+async def test_rejected_reply_is_retried_as_a_new_turn(tmp_path):
+    provider, transport = make(
+        tmp_path,
+        [{"tool_calls": [{"name": "Bash", "arguments": {}}]}, {"content": "fixed"}],
+    )
+    resp = await provider.chat(messages=[{"role": "user", "content": "q"}], tools=TOOLS)
+    assert resp["content"] == "fixed"
+    retry = turn_file(provider, 2)
+    assert "unknown tool 'Bash'" in retry["error"] and retry["messages"] == []
+    assert len(transport.delivered) == 1
+
+
+async def test_gives_up_after_retries(tmp_path):
+    bad = {"tool_calls": [{"name": "Bash"}]}
+    provider, _ = make(tmp_path, [bad, bad, bad], max_reply_retries=1)
+    with pytest.raises(ProviderError, match="no usable reply"):
+        await provider.chat(messages=[{"role": "user", "content": "q"}], tools=TOOLS)
+
+
+async def test_silent_loop_times_out(tmp_path):
+    provider, _ = make(tmp_path, [], turn_timeout_sec=0.05)
+    with pytest.raises(ProviderError, match="wrote no reply to turn 1"):
+        await provider.chat(messages=[{"role": "user", "content": "q"}], tools=TOOLS)
+
+
+async def test_a_loop_that_ended_fails_the_call_before_the_timeout(tmp_path):
+    provider, transport = make(tmp_path, [], turn_timeout_sec=30, liveness_interval_sec=0.02)
+    transport.state = lambda node_id: "stopped"
+    started = asyncio.get_running_loop().time()
+    with pytest.raises(ProviderError, match="NODE-1 is stopped"):
+        await provider.chat(messages=[{"role": "user", "content": "q"}], tools=TOOLS)
+    assert asyncio.get_running_loop().time() - started < 5
+
+
+async def test_a_running_loop_is_waited_for(tmp_path):
+    provider, transport = make(tmp_path, [], liveness_interval_sec=0.01)
+    checks = []
+
+    def state(node_id):
+        checks.append(node_id)
+        if len(checks) == 3:
+            provider.exchange.reply_path(provider.turn).write_text('{"content": "late"}')
+        return "running"
+
+    transport.state = state
+    resp = await provider.chat(messages=[{"role": "user", "content": "q"}], tools=TOOLS)
+    assert resp["content"] == "late" and len(checks) >= 3
+
+
+async def test_stop_all_stops_started_loops_once(tmp_path):
+    provider, transport = make(tmp_path, [{"content": "ok"}])
+    await provider.chat(messages=[{"role": "user", "content": "q"}], tools=TOOLS)
+    stop_all()
+    stop_all()
+    assert transport.stopped == ["NODE-1"]
+
+
+async def test_scripted_manager_delegates_through_the_exchange(tmp_path):
+    config = ModelConfig(
+        provider="graphcode",
+        model_id="dry",
+        extra={"exchange_root": str(tmp_path), "transport": "scripted", "poll_interval_sec": 0.01},
+    )
+    provider = GraphCodeProvider(config)
+    assert isinstance(provider._transport, ScriptedTransport)
+    tools = TOOLS + [{"name": "RunSubagent", "description": "", "parameters": {}}]
+    history = [{"role": "user", "content": "find the root cause " + ENV}]
+
+    resp = await provider.chat(messages=history, tools=tools)
+    (create,) = resp["tool_calls"]
+    assert create["name"] == "CreateSubagent"
+    assert create["arguments"]["accessible_paths"] == ["/runs/s/work/code"]
+    assert create["arguments"]["model_key"] == "llm"
+
+    history += [
+        {"role": "assistant", "content": "", "tool_calls": resp["tool_calls"]},
+        {"role": "tool", "tool_call_id": create["id"], "content": "subagent_id=sub_42"},
+    ]
+    resp = await provider.chat(messages=history, tools=tools)
+    (run,) = resp["tool_calls"]
+    assert run["name"] == "RunSubagent" and run["arguments"]["subagent_id"] == "sub_42"
+    assert run["arguments"]["prompt"] == "find the root cause"
+
+    history += [
+        {"role": "assistant", "content": "", "tool_calls": resp["tool_calls"]},
+        {"role": "tool", "tool_call_id": run["id"], "content": "[stub stub-llm] no model"},
+    ]
+    resp = await provider.chat(messages=history, tools=tools)
+    assert resp["tool_calls"] == [] and "sub_42" in resp["content"]
diff --git a/Tools/clawarena-graphcode/tests/test_transport.py b/Tools/clawarena-graphcode/tests/test_transport.py
new file mode 100644
index 00000000..a0dd9b7e
--- /dev/null
+++ b/Tools/clawarena-graphcode/tests/test_transport.py
@@ -0,0 +1,103 @@
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from clawarena_graphcode.transport import (
+    GraphCodeCLI,
+    TransportError,
+    parse_node_id,
+    parse_node_state,
+)
+
+STATUS = """clawarena  (running)
+  7996AD03-A574-43E5-888D-4D1928D0D65C  running  goalBased  Summary Fixes
+  1C2B51C0-472F-4F13-9650-A4666BE426D5  idle  timeBased  ClawArenaManager1a2b3c4d
+"""
+
+
+def test_parse_node_id_matches_whole_title():
+    assert parse_node_id(STATUS, "ClawArenaManager1a2b3c4d") == "1C2B51C0-472F-4F13-9650-A4666BE426D5"
+    assert parse_node_id(STATUS, "Summary Fixes") == "7996AD03-A574-43E5-888D-4D1928D0D65C"
+    assert parse_node_id(STATUS, "Summary") is None
+
+
+def test_parse_node_state():
+    assert parse_node_state(STATUS, "1C2B51C0-472F-4F13-9650-A4666BE426D5") == "idle"
+    assert parse_node_state(STATUS, "missing") is None
+
+
+class FakeRunner:
+    def __init__(self, status: str = "", fail: str | None = None):
+        self.calls: list[list[str]] = []
+        self.status = status
+        self.fail = fail
+
+    def __call__(self, argv, **kwargs):
+        assert kwargs == {"capture_output": True, "text": True, "check": False}
+        self.calls.append(argv)
+        if self.fail and self.fail in argv:
+            return subprocess.CompletedProcess(argv, 2, "", "daemon unreachable")
+        if argv[1] == "node" and argv[2] == "create":
+            title = argv[argv.index("--title") + 1]
+            self.status = f"p  (running)\n  AAAA-1  running  timeBased  {title}\n"
+        stdout = self.status if argv[1] == "status" else ""
+        return subprocess.CompletedProcess(argv, 0, stdout, "")
+
+
+def test_start_creates_an_uncadenced_time_loop_and_reads_its_id(tmp_path: Path):
+    runner = FakeRunner()
+    cli = GraphCodeCLI(tmp_path, executable="/opt/graphcode", backend="claudeCode", runner=runner)
+    assert cli.start("be the manager") == "AAAA-1"
+    create, status = runner.calls
+    assert create[:4] == ["/opt/graphcode", "node", "create", str(tmp_path)]
+    assert create[create.index("--type") + 1] == "time"
+    assert create[create.index("--backend") + 1] == "claudeCode"
+    assert create[-2:] == ["--prompt", "be the manager"]
+    assert create[create.index("--title") + 1].startswith("ClawArenaManager")
+    assert "--heartbeat" not in create
+    assert status == ["/opt/graphcode", "status", str(tmp_path)]
+
+
+def test_model_tier_is_passed_only_when_set(tmp_path: Path):
+    runner = FakeRunner()
+    GraphCodeCLI(tmp_path, model_tier="capable", runner=runner).start("p")
+    create = runner.calls[0]
+    assert create[create.index("--model") + 1] == "capable"
+
+    runner = FakeRunner()
+    GraphCodeCLI(tmp_path, runner=runner).start("p")
+    assert "--model" not in runner.calls[0] and "--backend" not in runner.calls[0]
+
+
+def test_deliver_and_stop(tmp_path: Path):
+    runner = FakeRunner()
+    cli = GraphCodeCLI(tmp_path, runner=runner)
+    cli.start("p")
+    runner.calls.clear()
+    cli.deliver("AAAA-1", "ClawArena turn 2: read x")
+    cli.stop("AAAA-1")
+    assert cli.state("AAAA-1") == "running"
+    assert runner.calls == [
+        ["graphcode", "node", "send", str(tmp_path), "AAAA-1", "ClawArena turn 2: read x"],
+        ["graphcode", "node", "stop", str(tmp_path), "AAAA-1"],
+        ["graphcode", "status", str(tmp_path)],
+    ]
+
+
+def test_failures_surface_stderr(tmp_path: Path):
+    cli = GraphCodeCLI(tmp_path, runner=FakeRunner(fail="send"))
+    with pytest.raises(TransportError, match="exited 2: daemon unreachable"):
+        cli.deliver("AAAA-1", "hi")
+
+
+def test_start_fails_when_the_loop_never_appears(tmp_path: Path):
+    class Silent(FakeRunner):
+        def __call__(self, argv, **kwargs):
+            result = super().__call__(argv, **kwargs)
+            if argv[1] == "status":
+                return subprocess.CompletedProcess(argv, 0, "p  (running)\n", "")
+            return result
+
+    with pytest.raises(TransportError, match="missing from graphcode status"):
+        GraphCodeCLI(tmp_path, runner=Silent()).start("prompt")
diff --git a/docs/benchmarks/clawarena-team-trial.md b/docs/benchmarks/clawarena-team-trial.md
new file mode 100644
index 00000000..56094ad2
--- /dev/null
+++ b/docs/benchmarks/clawarena-team-trial.md
@@ -0,0 +1,152 @@
+# ClawArena-Team trial: GraphCode as the manager
+
+**Verdict:** ⚠️ Feasible as a *private, disclosed-deviation* trial. It cannot enter the leaderboard as
+a like-for-like row. The adapter and a zero-spend dry run are done. A real run is blocked on a
+subagent pool (no NVIDIA GPU here) and on approved main-agent spend.
+
+- Benchmark: [aiming-lab/ClawArena](https://github.com/aiming-lab/ClawArena), `ClawArena-Team/`, MIT,
+  pinned at `630efd8a` (2026-07-01)
+- Adapter: [`Tools/clawarena-graphcode`](../../Tools/clawarena-graphcode)
+- Nothing was submitted, posted, installed system-wide, or billed.
+
+## 1. What ClawArena-Team measures
+
+A text-only main agent completes 41 multi-round scenarios (258 rounds) that it can only finish by
+delegating to a fixed pool: `llm` and `vlm` are gemma-4-31b-it, `omni` is gemma-4-e4b-it, all on
+local vLLM. Scoring is execution-based. The headline is `SMS = TCR × (TPP + ROC + WPP + MCA) / 4`:
+task correctness discounted by least-privilege and modality-routing quality. The leaderboard ranks
+**main-agent models**. Harness, prompts, tools and pool are held fixed.
+
+## 2. How a GraphCode lead loop maps onto the manager
+
+The management metrics (TPP, ROC, WPP, MCA) are computed from the harness's own records of
+`CreateSubagent` / `RunSubagent` / `Workflow` calls, and the round checks read
+`${workspace}/sessions/main.jsonl`. Anything done outside the harness is invisible to scoring or
+counts as a violation. So GraphCode cannot use its own graph machinery here. It joins as the
+`main` **provider**:
+
+| ClawArena manager concept | Native GraphCode equivalent | What the adapter does |
+|---|---|---|
+| Main agent model call | One loop turn | Each `chat()` writes `turn-NNNN.json`; the loop replies with `reply-NNNN.json` |
+| `CreateSubagent` (prompt, model key, tools, path whitelist) | `graphcode node create` a child loop | Harness tool call. A child loop would run on Claude/Codex, not the fixed gemma pool |
+| `RunSubagent` foreground/background, resume | `node send` / handoff edge / session resume | Harness tool call |
+| `<task-notification>` on background completion | Mailroom / message edge delivery | Arrives inside the next turn file |
+| `Workflow` (`agent()`, `parallel()`, `pipeline()`) | Workflow scripts / composite loops | Harness tool call |
+| Least-privilege grants, realpath sandbox | Claude Code permissions per loop | The harness enforces; the loop's own project denies Bash, Agent/Task, web tools and workspace reads/edits |
+| Text-only perception | — | Multimodal parts reach the loop only as placeholders |
+
+The loop is a **time loop with no cadence**. On Claude Code a goal loop is a `/goal` Stop hook
+that keeps the session working until the goal holds, which is the opposite of idling between
+harness turns. A time loop starts at once, answers the turn its prompt points at, and sleeps
+until the next `graphcode node send`. Content travels in files because `node send` flattens
+newlines and clips long messages.
+
+**What this trial measures:** the manager judgement of a model *running inside a GraphCode loop*
+(Claude Code system prompt, GraphCode briefing, memory), against the same model called directly.
+**What it does not measure:** GraphCode's fan-out into child loops, edges or the Mailroom. Using
+those would bypass the fixed pool and the scoring, so they are out of scope.
+
+## 3. Leaderboard comparability
+
+| Question | Answer | Why |
+|---|---|---|
+| Is a GraphCode run a leaderboard row? | ❌ No — disclosed deviation | Rows are main-agent models under the stock harness; this is a scaffold (Claude Code + loop) around a model |
+| Are the management metrics still valid? | ✅ Yes | Every tool call is still executed, sandboxed and scored by ClawArena |
+| Is TCR still valid? | ✅ Yes | Same checks, same workspace |
+| Is the Cost column comparable? | ❌ No | The harness counts tokens on its own history with a local tokenizer; the loop's real spend (Claude Code system prompt, file reads/writes, thinking) must come from Claude Code usage instead |
+| Residual bypass risk | ⚠️ Mitigated, not proven | Per-loop deny rules plus the prompt; not yet verified against a live session. Auditing the loop transcript for any tool use outside the exchange directory should be part of a real run |
+| Meaningful result | Paired comparison | `graphcode(claude-opus-5)` vs `anthropic(claude-opus-5)` on the same pool and scenarios |
+
+## 4. Serving the pool without an NVIDIA GPU
+
+The pool config (`configs/eval_base.yaml`) points `llm`/`vlm` at gemma-4-31b-it and `omni` at
+gemma-4-e4b-it, both served by vLLM nightly with `--tool-call-parser gemma4
+--reasoning-parser gemma4`, MTP speculative decoding (31B), fp8 KV cache, `max-model-len 128000`,
+and `--limit-mm-per-prompt` image=48/video=8 (31B) and audio=4/image=24/video=4 (E4B). This Mac is
+an Apple M4 with 16 GB, which cannot hold the 31B model. vLLM, CUDA and Docker are out of bounds
+anyway.
+
+| Option | `llm`/`vlm` (31B) | `omni` (E4B, audio) | Comparability |
+|---|---|---|---|
+| OpenRouter, OpenAI-compatible (`provider: openai_compat`) | `google/gemma-4-31b-it` listed at about $0.09–0.14 / $0.34 per MTok in/out, plus a rate-limited `:free` variant | ⚠️ Not confirmed. One source says E4B is on no hosted provider; another lists 3 providers at $0.02 / $0.10 | ⚠️ Deviation: provider quantization, chat template, tool-call parsing, context and multimodal limits all differ from the vLLM recipe |
+| Google Gemini API (hosts Gemma) | `gemma-4-31b-it` documented, $0 on a rate-limited free tier | ❌ E4B not listed (only 31b and 26b-a4b) | ⚠️ Same deviation. ClawArena's probe posts OpenAI-style `/chat/completions`, so it needs Google's OpenAI-compatible endpoint (unverified for Gemma). Free-tier rate limits vs ~9k pool calls per full run make it days-long |
+| Substitute `omni` with a non-E4B model | — | Audio rounds routed elsewhere | ❌ Breaks MCA and the audio rounds; only as a labelled ablation |
+| Rent GPUs and run the published vLLM recipe | 1× ~96 GB GPU per replica | 1 small GPU | ✅ Closest to reference. Needs a cloud/GPU account — a human decision, not taken |
+
+**Hosted-pool verdict:** usable for a private paired comparison, provided **both arms use the same
+hosted pool**. The paired result stays internally valid, but no absolute number can be set beside
+the leaderboard. A calibration arm fixes that: rerun a model that already has a submission
+(`local-gemma-31b`: SMS 43.86, 146/258) on the hosted pool over a few scenarios, and report the
+drift.
+
+## 5. What was verified (zero spend)
+
+| Check | Result |
+|---|---|
+| Adapter unit tests: protocol, CLI transport argv/parsing, provider turn/retry/timeout/liveness/stop, scripted manager | ✅ 30 passed |
+| Upstream ClawArena-Team unit tests in the same venv | ✅ 320 passed, 8 skipped |
+| Dry run, `s_observability_incident` (7 rounds), scripted manager through real exchange files, stub pool | ✅ Scenario completed; metadata, per-round evals and report written |
+| — manager tool calls executed by the harness | 1 `CreateSubagent`, 7 `RunSubagent`; 15 turn/reply pairs; 7 stub subagent sessions |
+| — scores | 0/7 rounds, SMS 0, as designed: no model runs, so no output files. ROC 1.0, MCA 1.0 |
+| Dataset-gated dry-run test (`CLAWARENA_TEAM_DATA`) | ✅ passed |
+| `GraphCodeCLI` against a real graphcoded (shipped 0.1.70 binaries copied to `/tmp`, isolated support dir, daemon env scrubbed so `claude` is not found: zero spend) | ✅ `node create --type time --backend claudeCode --model capable --prompt …` accepted, the project auto-registered, and the id was parsed from `graphcode status`. The loop went `stopped: claude is not on your PATH`, as intended |
+| — `node send` to that stopped loop | Exits 1 ("isn't live right now — message staged to its memory"). The provider now also polls loop state and fails the call once the loop is `stopped`/`failed`/`stalled`/`succeeded`, instead of waiting out the 30-minute turn timeout |
+| A real manager (Claude Code in a loop) answering turns | ❌ Not run: spend |
+
+Reproduce:
+
+```sh
+cd ClawArena/ClawArena-Team   # editable installs per the adapter README
+.venv/bin/clawarena-graphcode-dry-run -d data/clawarena-team -t s_observability_incident -o results/dry
+```
+
+## 6. Cost estimate
+
+Assumption-heavy; treat every figure as ±2×. Pricing: Claude Opus 5 at $5 / $25 per MTok in/out,
+cache reads assumed at 0.1× ($0.50) and cache writes at 1.25× ($6.25); Claude Sonnet 5 at $2 / $10.
+Token volumes come from the two full-run submissions in the repo:
+
+| Full 41-scenario run | Main new input | Main output | Main cache-read | Pool new input | Pool history | Pool output |
+|---|--:|--:|--:|--:|--:|--:|
+| `local-gemma-31b` | 0.91M | 0.44M | 35.8M | 5.69M | 31.5M | 0.51M |
+| `local-qwen3.6-27b` | 1.16M | 0.65M | 45.5M | 5.07M | 26.6M | 0.71M |
+
+Main-agent calls run at roughly 50–60 per scenario (cache-read ÷ average context).
+
+### Main agent (API)
+
+| Arm | 1 scenario (smoke) | Full 41 scenarios | Basis |
+|---|--:|--:|---|
+| Control: `anthropic` provider, claude-opus-5 | ≈ $1–2 | ≈ $40–70 | ~1M new input, ~40M cache read, ~0.55M output; leaderboard `claude-sonnet-4-6` cost $39.7 at $3/$15 |
+| GraphCode loop, claude-opus-5 | ≈ $3–13 (central $6) | ≈ $130–540 (central $270) | Each harness turn costs ~2–3 session calls (read turn, write reply); ~25K fixed Claude Code + briefing prefix; turn content re-appears as file reads and reply writes |
+| GraphCode loop, claude-sonnet-5 | ≈ $1–5 | ≈ $55–220 | Same volumes at $2/$10 |
+
+If the loops run on a Claude subscription rather than an API key, the marginal charge is plan
+usage and rate limits, not dollars. The dollar column is the API-equivalent either way.
+
+### Subagent pool hosting
+
+Pool volume is ~32–37M input and ~0.5–0.7M output tokens per full run. A stronger manager may
+delegate more, so allow up to 2×.
+
+| Pool option | 1 scenario | Full 41 scenarios | Caveat |
+|---|--:|--:|---|
+| OpenRouter gemma-4-31b-it (no cache discount assumed) | ≈ $0.15–0.30 | ≈ $5–11 | E4B `omni` hosting unconfirmed |
+| Gemini API free tier (31B only) | $0 | $0 | Rate limits; no E4B; OpenAI-compatible Gemma endpoint unverified |
+| Rented GPUs running the reference vLLM recipe | ≈ $5–15 | ≈ $30–200 | Assumes $2–4 per GPU-hour, 2 GPUs, 8–24 h wall clock; needs a GPU account |
+
+**A paired run (control + GraphCode) with a hosted pool:** smoke ≈ **$5–15**, full ≈ **$180–630**,
+almost all of it main-agent API.
+
+## 7. Blockers and decisions for a human
+
+1. **Pool:** choose OpenRouter (an account and key), a GPU rental, or stop here. No option is
+   available without a new account.
+2. **Omni:** confirm a hosted gemma-4-e4b-it with audio input, or accept an ablation that drops or
+   reroutes audio rounds.
+3. **Spend:** approve a 1-scenario paired smoke (≈ $5–15) before anything larger.
+4. **Before the smoke:** check the manager loop live, zero-spend where possible. Confirm the deny
+   rules actually block workspace reads in a `bypassPermissions` session, and that a time loop with
+   no cadence stays idle between `node send` wake-ups.
+5. **Submission:** none planned. If one were ever made, it would be labelled as a scaffold entry
+   with the deviations above.