agents-relay 1.0.5 → 1.0.7

package/skills/chatgpt-browser-worker/scripts/create.py

@@ -1,84 +0,0 @@
-"""Create a ChatGPT thread through an injected browser-harness port."""
-from __future__ import annotations
-
-from datetime import datetime, timezone
-from typing import Any, Callable, Protocol
-
-try:
-    from .contract import ContractError, project_matches, validate_request
-except ImportError:  # Loaded directly by the lightweight skill test harness.
-    from contract import ContractError, project_matches, validate_request
-
-
-class BrowserPort(Protocol):
-    def select_project(self, project: dict[str, str]) -> dict[str, Any]: ...
-    def set_thinking_level(self, level: str) -> dict[str, Any]: ...
-    def send_prompt(self, prompt: str) -> dict[str, Any]: ...
-
-
-def _now() -> str:
-    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
-
-
-def _effective_level(observation: Any) -> str:
-    if not isinstance(observation, dict):
-        return "unknown"
-    value = observation.get("effective_thinking_level", observation.get("level"))
-    return value if value in {"default", "low", "medium", "high"} else "unknown"
-
-
-def create_thread(
-    port: BrowserPort,
-    request: Any,
-    *,
-    persist: Callable[[dict[str, Any]], None] | None = None,
-    now: Callable[[], str] = _now,
-) -> dict[str, Any]:
-    """Select the requested Project, send the first prompt, and return state.
-
-    The port returns observations from the browser.  It is deliberately not
-    responsible for durable state or contract validation.
-    """
-    request = validate_request(request)
-    if request["operation"] != "create":
-        raise ContractError("create_thread requires operation=create")
-
-    selected = port.select_project(request["project"])
-    if not project_matches(request["project"], selected):
-        raise ContractError("browser observed a different Project after selection")
-
-    thinking_observation: dict[str, Any] = {"requested": "default", "changed": False}
-    effective = "unknown"
-    if request["thinking_level"] != "default":
-        raw = port.set_thinking_level(request["thinking_level"])
-        thinking_observation = dict(raw) if isinstance(raw, dict) else {"observed": raw}
-        thinking_observation["requested"] = request["thinking_level"]
-        thinking_observation["changed"] = True
-        effective = _effective_level(raw)
-
-    sent = port.send_prompt(request["prompt"])
-    if not isinstance(sent, dict) or not isinstance(sent.get("thread_id"), str) or not sent["thread_id"].strip():
-        raise ContractError("browser did not return an observed thread_id")
-
-    timestamp = now()
-    state: dict[str, Any] = {
-        "schema_version": 1,
-        "thread_id": sent["thread_id"].strip(),
-        "project": dict(selected),
-        "status": "running",
-        "requested_thinking_level": request["thinking_level"],
-        "effective_thinking_level": effective,
-        "created_at": timestamp,
-        "updated_at": timestamp,
-        "last_error": None,
-        "evidence": {
-            "project": dict(selected),
-            "thinking": thinking_observation,
-            "thread": {key: value for key, value in sent.items() if key != "text"},
-        },
-    }
-    if "conversation_url" in sent:
-        state["conversation_url"] = sent["conversation_url"]
-    if persist is not None:
-        persist(state)
-    return state

package/skills/chatgpt-browser-worker/scripts/operate_bh.py

@@ -1,36 +0,0 @@
-#!/usr/bin/env python3
-"""Run one existing-thread operation through the authenticated browser-harness."""
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import subprocess
-import tempfile
-
-
-BH_SCRIPT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "_operate_bh.py")
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("operation", choices=("resume", "continue", "status", "result", "delete"))
-    parser.add_argument("--thread-id", required=True)
-    parser.add_argument("--project", required=True)
-    parser.add_argument("--prompt")
-    args = parser.parse_args()
-    if args.operation == "continue" and not args.prompt:
-        parser.error("continue requires --prompt")
-    config = {key: value for key, value in vars(args).items() if value is not None}
-    with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as handle:
-        json.dump(config, handle, ensure_ascii=False)
-        config_path = handle.name
-    try:
-        code = open(BH_SCRIPT, encoding="utf-8").read().replace("__CFG_PATH__", config_path)
-        return subprocess.run(["browser-harness"], input=code, text=True, timeout=180).returncode
-    finally:
-        os.unlink(config_path)
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/skills/chatgpt-browser-worker/scripts/operations.py

@@ -1,179 +0,0 @@
-"""Existing-thread operations for an injected browser-harness port."""
-from __future__ import annotations
-
-from datetime import datetime, timezone
-from typing import Any, Callable, Protocol
-
-try:
-    from .contract import ContractError, transition, validate_cleanup_observation, validate_project, validate_request, validate_result, validate_state
-except ImportError:
-    from contract import ContractError, transition, validate_cleanup_observation, validate_project, validate_request, validate_result, validate_state
-
-
-class BrowserPort(Protocol):
-    def open_thread(self, thread_id: str) -> dict[str, Any]: ...
-    def send_prompt(self, prompt: str) -> dict[str, Any]: ...
-    def read_status(self) -> dict[str, Any]: ...
-    def read_result(self) -> dict[str, Any]: ...
-    def delete_thread(self) -> dict[str, Any]: ...
-
-
-def _now() -> str:
-    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
-
-
-def _project(observation: Any) -> dict[str, Any]:
-    if not isinstance(observation, dict):
-        raise ContractError("browser did not return an observed thread")
-    project = observation.get("project", observation.get("selected_project"))
-    if project is None:
-        raise ContractError("browser did not expose the thread Project")
-    return project
-
-
-def _status(observation: Any, default: str = "awaiting_result") -> str:
-    value = observation.get("status") if isinstance(observation, dict) else None
-    return value if value in {"created", "running", "awaiting_result", "completed", "failed", "blocked"} else default
-
-
-def _same_project(left: Any, right: Any) -> bool:
-    """Compare names always; compare IDs only when both UI boundaries expose them."""
-    expected = validate_project(left)
-    observed = validate_project(right)
-    return expected["name"] == observed["name"] and (
-        "id" not in expected or "id" not in observed or expected["id"] == observed["id"]
-    )
-
-
-def _save(state: dict[str, Any], persist: Callable[[dict[str, Any]], None] | None, now: Callable[[], str]) -> dict[str, Any]:
-    state["updated_at"] = now()
-    if persist is not None:
-        persist(state)
-    return state
-
-
-def _opened(port: BrowserPort, state: dict[str, Any], *, expected_project: dict[str, Any]) -> dict[str, Any]:
-    opened = port.open_thread(state["thread_id"])
-    if not isinstance(opened, dict):
-        raise ContractError("browser did not return an observed thread")
-    observed_id = opened.get("thread_id", state["thread_id"])
-    if observed_id != state["thread_id"]:
-        raise ContractError("browser opened a different thread")
-    observed_project = _project(opened)
-    if not _same_project(expected_project, observed_project):
-        raise ContractError("observed Project does not match durable Project binding")
-    return opened
-
-
-def resume_thread(
-    port: BrowserPort,
-    request: Any,
-    *,
-    state: Any | None = None,
-    persist: Callable[[dict[str, Any]], None] | None = None,
-    now: Callable[[], str] = _now,
-) -> dict[str, Any]:
-    """Open and verify an existing thread without sending a new prompt."""
-    request = validate_request(request)
-    if request["operation"] != "resume":
-        raise ContractError("resume_thread requires operation=resume")
-    current = validate_state(state) if state is not None else {
-        "schema_version": 1,
-        "thread_id": request["thread_id"],
-        "project": request["project"],
-        "status": "created",
-        "requested_thinking_level": request.get("thinking_level", "default"),
-        "effective_thinking_level": "unknown",
-    }
-    if current["thread_id"] != request["thread_id"]:
-        raise ContractError("resume request does not match durable thread identity")
-    if current["status"] == "deleted":
-        raise ContractError("deleted thread is terminal")
-    if not _same_project(current["project"], request["project"]):
-        raise ContractError("resume Project does not match durable Project binding")
-    opened = _opened(port, current, expected_project=current["project"])
-    observed_status = _status(opened)
-    if current["status"] == "created":
-        current = transition(current, "running")
-    if observed_status != current["status"]:
-        current = transition(current, observed_status)
-    current["project"] = dict(_project(opened))
-    current.setdefault("evidence", {})["open"] = opened
-    return _save(current, persist, now)
-
-
-def continue_thread(
-    port: BrowserPort,
-    state: Any,
-    prompt: str,
-    *,
-    persist: Callable[[dict[str, Any]], None] | None = None,
-    now: Callable[[], str] = _now,
-) -> dict[str, Any]:
-    """Open a durable thread, send one follow-up prompt, and persist running state."""
-    current = validate_state(state)
-    if not isinstance(prompt, str) or not prompt.strip():
-        raise ContractError("prompt must be a non-empty string")
-    _opened(port, current, expected_project=current["project"])
-    if current["status"] != "running":
-        current = transition(current, "running")
-    sent = port.send_prompt(prompt.strip())
-    if not isinstance(sent, dict):
-        raise ContractError("browser did not acknowledge the follow-up prompt")
-    current.setdefault("evidence", {})["prompt"] = sent
-    return _save(current, persist, now)
-
-
-def inspect_thread(
-    port: BrowserPort,
-    state: Any,
-    *,
-    persist: Callable[[dict[str, Any]], None] | None = None,
-    now: Callable[[], str] = _now,
-) -> dict[str, Any]:
-    """Read the observable UI status/progress and persist its state transition."""
-    current = validate_state(state)
-    if current["status"] == "deleted":
-        raise ContractError("deleted thread is terminal")
-    observation = port.read_status()
-    observed_status = _status(observation, default="awaiting_result")
-    if observed_status != current["status"]:
-        current = transition(current, observed_status)
-    current.setdefault("evidence", {})["status"] = observation
-    return _save(current, persist, now)
-
-
-def result_thread(
-    port: BrowserPort,
-    state: Any,
-    *,
-    persist: Callable[[dict[str, Any]], None] | None = None,
-    now: Callable[[], str] = _now,
-) -> dict[str, Any]:
-    """Return only an observed, normalized assistant result and persist completion."""
-    current = validate_state(state)
-    if current["status"] == "deleted":
-        raise ContractError("deleted thread is terminal")
-    result = validate_result(port.read_result(), thread_id=current["thread_id"])
-    if current["status"] != "completed":
-        current = transition(current, "completed")
-    current.setdefault("evidence", {})["result"] = result
-    _save(current, persist, now)
-    return result
-
-
-def delete_thread(
-    port: BrowserPort,
-    state: Any,
-    *,
-    persist: Callable[[dict[str, Any]], None] | None = None,
-    now: Callable[[], str] = _now,
-) -> dict[str, Any]:
-    """Delete one durable thread and persist its terminal tombstone."""
-    current = validate_state(state)
-    if current["status"] == "deleted":
-        return current
-    observation = validate_cleanup_observation(port.delete_thread(), thread_id=current["thread_id"])
-    current = transition(current, "deleted")
-    current.setdefault("evidence", {})["cleanup"] = observation
-    return _save(current, persist, now)

package/skills/chatgpt-browser-worker/tests/fixtures/relay_lifecycle.json

@@ -1,21 +0,0 @@
-{
-  "job_id": "neo-chatgpt-browser-worker-20260919",
-  "task_id": "chatgpt-thread-1",
-  "project": {"id": "project-1", "name": "neo"},
-  "create": {
-    "operation": "create",
-    "project": {"name": "neo"},
-    "prompt": "Run the assigned task.",
-    "thinking_level": "high"
-  },
-  "thread": {
-    "thread_id": "thread-1",
-    "conversation_url": "https://chatgpt.com/c/thread-1"
-  },
-  "result": {
-    "thread_id": "thread-1",
-    "status": "completed",
-    "text": "The assigned task is complete.",
-    "message_id": "message-1"
-  }
-}

package/skills/chatgpt-browser-worker/tests/test_agent_definition.py

@@ -1,27 +0,0 @@
-from pathlib import Path
-
-
-AGENT = Path(__file__).parents[1] / "agents" / "browser-worker.agent.md"
-
-
-def test_browser_worker_agent_defines_typed_lifecycle_and_verified_result():
-    text = AGENT.read_text()
-
-    for operation in ("create", "resume", "continue", "status", "result", "delete"):
-        assert f"`{operation}`" in text
-    for field in ("thread_id", "project", "message_id", "verified", "observed_at"):
-        assert f'"{field}"' in text
-    assert "browser-harness" in text
-    assert "authentication_required" in text
-    assert "Do not report success" in text
-
-
-def test_callers_are_directed_to_launch_agent_not_helper_scripts():
-    skill = (AGENT.parents[1] / "SKILL.md").read_text()
-    orchestration = (AGENT.parents[1] / "references" / "orchestration.md").read_text()
-
-    assert "Callers launch that" in skill
-    assert "agent with a typed lifecycle intent" in skill
-    assert "must not directly call" in skill
-    assert "launches the `browser-worker` agent" in orchestration
-    assert "must not directly invoke" in orchestration

package/skills/chatgpt-browser-worker/tests/test_contract.py

@@ -1,315 +0,0 @@
-from __future__ import annotations
-
-import importlib.util
-import json
-import sys
-from pathlib import Path
-
-import pytest
-
-
-HERE = Path(__file__).resolve().parents[1]
-spec = importlib.util.spec_from_file_location("chatgpt_browser_worker_contract", HERE / "scripts/contract.py")
-assert spec and spec.loader
-contract = importlib.util.module_from_spec(spec)
-spec.loader.exec_module(contract)
-sys.modules["contract"] = contract
-
-create_spec = importlib.util.spec_from_file_location("chatgpt_browser_worker_create", HERE / "scripts/create.py")
-assert create_spec and create_spec.loader
-create = importlib.util.module_from_spec(create_spec)
-create_spec.loader.exec_module(create)
-
-operations_spec = importlib.util.spec_from_file_location("chatgpt_browser_worker_operations", HERE / "scripts/operations.py")
-assert operations_spec and operations_spec.loader
-operations = importlib.util.module_from_spec(operations_spec)
-operations_spec.loader.exec_module(operations)
-
-
-def state(status="created", project=None):
-    return {
-        "schema_version": 1,
-        "thread_id": "thread-1",
-        "project": project or {"id": "project-1", "name": "neo"},
-        "status": status,
-        "requested_thinking_level": "high",
-        "effective_thinking_level": "unknown",
-    }
-
-
-def test_create_and_resume_require_verified_project_and_preserve_level_request():
-    created = contract.validate_request(
-        {"operation": "create", "project": {"name": "neo"}, "prompt": "hello", "thinking_level": "high"}
-    )
-    resumed = contract.validate_request(
-        {"operation": "resume", "thread_id": "thread-1", "project": {"id": "project-1", "name": "neo"}}
-    )
-    assert created["project"] == {"name": "neo"}
-    assert created["thinking_level"] == "high"
-    assert resumed["thread_id"] == "thread-1"
-    with pytest.raises(contract.ContractError):
-        contract.validate_request({"operation": "create", "prompt": "hello", "thinking_level": "high"})
-
-
-def test_project_mismatch_is_rejected_and_unknown_effective_level_is_valid():
-    current = contract.validate_state(state())
-    assert current["effective_thinking_level"] == "unknown"
-    with pytest.raises(contract.ContractError, match="Project"):
-        contract.transition(current, "running", observed_project={"id": "other", "name": "other"})
-
-
-def test_project_id_is_optional_at_a_browser_boundary():
-    assert contract.project_matches({"id": "project-1", "name": "neo"}, {"name": "neo"})
-    assert not contract.project_matches({"id": "project-1", "name": "neo"}, {"id": "other", "name": "neo"})
-
-
-def test_completion_requires_explicit_transition_and_delete_is_terminal():
-    running = contract.transition(state(), "running")
-    waiting = contract.transition(running, "awaiting_result")
-    completed = contract.transition(waiting, "completed")
-    assert completed["status"] == "completed"
-    deleted = contract.transition(completed, "deleted")
-    assert deleted["status"] == "deleted"
-    with pytest.raises(contract.ContractError, match="terminal"):
-        contract.transition(deleted, "running")
-
-
-def test_result_requires_observed_assistant_message_and_matching_identity():
-    result = contract.validate_result(
-        {
-            "thread_id": "thread-1",
-            "status": "completed",
-            "text": "normalized answer",
-            "message_id": "message-1",
-        },
-        thread_id="thread-1",
-    )
-    assert result["message_id"] == "message-1"
-    with pytest.raises(contract.ContractError):
-        contract.validate_result(
-            {"thread_id": "thread-1", "status": "completed", "text": "answer"},
-            thread_id="thread-1",
-        )
-    with pytest.raises(contract.ContractError, match="different thread"):
-        contract.validate_result(
-            {
-                "thread_id": "other",
-                "status": "completed",
-                "text": "answer",
-                "message_id": "message-1",
-            },
-            thread_id="thread-1",
-        )
-
-
-def test_contract_module_has_no_browser_runtime_dependency():
-    source = (HERE / "scripts/contract.py").read_text()
-    assert "import browser_harness" not in source
-    assert "import macbridge" not in source.lower()
-
-
-class FakePort:
-    def __init__(self, project=None, sent=None):
-        self.project = project or {"id": "project-1", "name": "neo"}
-        self.sent = sent or {"thread_id": "thread-42", "conversation_url": "https://chatgpt.com/c/thread-42", "prompt_sent": True}
-        self.calls = []
-
-    def select_project(self, project):
-        self.calls.append(("select_project", project))
-        return self.project
-
-    def set_thinking_level(self, level):
-        self.calls.append(("set_thinking_level", level))
-        return {"effective_thinking_level": level, "label": level.title()}
-
-    def send_prompt(self, prompt):
-        self.calls.append(("send_prompt", prompt))
-        return self.sent
-
-
-class ExistingThreadPort:
-    def __init__(self, project=None, status="awaiting_result", result=None):
-        self.project = project or {"id": "project-1", "name": "neo"}
-        self.status = status
-        self.result = result or {
-            "thread_id": "thread-1",
-            "status": "completed",
-            "text": "done",
-            "message_id": "message-1",
-        }
-        self.calls = []
-
-    def open_thread(self, thread_id):
-        self.calls.append(("open_thread", thread_id))
-        return {"thread_id": thread_id, "project": self.project, "status": self.status}
-
-    def send_prompt(self, prompt):
-        self.calls.append(("send_prompt", prompt))
-        return {"prompt_sent": True}
-
-    def read_status(self):
-        self.calls.append(("read_status",))
-        return {"status": self.status, "progress": "visible"}
-
-    def read_result(self):
-        self.calls.append(("read_result",))
-        return self.result
-
-    def delete_thread(self):
-        self.calls.append(("delete_thread",))
-        return {"thread_id": "thread-1", "outcome": "deleted", "verified": True}
-
-
-def test_create_returns_durable_identity_project_binding_and_evidence():
-    port = FakePort()
-    persisted = []
-    result = create.create_thread(
-        port,
-        {"operation": "create", "project": {"name": "neo"}, "prompt": "hello", "thinking_level": "high"},
-        persist=persisted.append,
-        now=lambda: "2026-09-19T12:00:00Z",
-    )
-    assert result["thread_id"] == "thread-42"
-    assert result["project"] == port.project
-    assert result["effective_thinking_level"] == "high"
-    assert result["evidence"]["thread"]["prompt_sent"] is True
-    assert persisted == [result]
-    assert [call[0] for call in port.calls] == ["select_project", "set_thinking_level", "send_prompt"]
-
-
-def test_create_default_leaves_platform_thinking_unchanged():
-    port = FakePort()
-    result = create.create_thread(
-        port,
-        {"operation": "create", "project": {"name": "neo"}, "prompt": "hello", "thinking_level": "default"},
-    )
-    assert result["requested_thinking_level"] == "default"
-    assert result["effective_thinking_level"] == "unknown"
-    assert [call[0] for call in port.calls] == ["select_project", "send_prompt"]
-
-
-def test_create_rejects_unverified_project_and_missing_thread_identity():
-    with pytest.raises(contract.ContractError, match="different Project"):
-        create.create_thread(
-            FakePort(project={"name": "other"}),
-            {"operation": "create", "project": {"name": "neo"}, "prompt": "hello", "thinking_level": "default"},
-        )
-    with pytest.raises(contract.ContractError, match="thread_id"):
-        create.create_thread(
-            FakePort(sent={"prompt_sent": True}),
-            {"operation": "create", "project": {"name": "neo"}, "prompt": "hello", "thinking_level": "default"},
-        )
-
-
-def test_resume_opens_durable_thread_and_requires_observed_project():
-    port = ExistingThreadPort()
-    persisted = []
-    result = operations.resume_thread(
-        port,
-        {"operation": "resume", "thread_id": "thread-1", "project": {"name": "neo"}},
-        state=state("running"),
-        persist=persisted.append,
-        now=lambda: "2026-09-19T12:03:00Z",
-    )
-    assert result["status"] == "awaiting_result"
-    assert result["updated_at"] == "2026-09-19T12:03:00Z"
-    assert persisted == [result]
-    with pytest.raises(contract.ContractError, match="Project"):
-        operations.resume_thread(
-            ExistingThreadPort(project={"id": "other", "name": "other"}),
-            {"operation": "resume", "thread_id": "thread-1", "project": {"name": "neo"}},
-            state=state("running"),
-        )
-
-
-def test_continue_status_and_result_persist_observed_transitions():
-    port = ExistingThreadPort(status="running")
-    persisted = []
-    running = operations.continue_thread(port, state("completed"), "continue", persist=persisted.append)
-    assert running["status"] == "running"
-    observed = operations.inspect_thread(port, running, persist=persisted.append)
-    assert observed["status"] == "running"
-    port.status = "completed"
-    result = operations.result_thread(port, observed, persist=persisted.append)
-    assert result["text"] == "done"
-    assert [call[0] for call in port.calls] == ["open_thread", "send_prompt", "read_status", "read_result"]
-    assert [item["status"] for item in persisted] == ["running", "running", "completed"]
-
-
-def test_result_without_observed_assistant_message_does_not_complete_thread():
-    port = ExistingThreadPort(result={"thread_id": "thread-1", "status": "awaiting_result"})
-    with pytest.raises(contract.ContractError, match="completed"):
-        operations.result_thread(port, state("running"))
-
-
-def test_delete_persists_verified_tombstone_and_is_idempotent():
-    port = ExistingThreadPort()
-    persisted = []
-    deleted = operations.delete_thread(
-        port, state("completed"), persist=persisted.append,
-        now=lambda: "2026-09-19T12:04:00Z",
-    )
-    assert deleted["status"] == "deleted"
-    assert deleted["evidence"]["cleanup"]["verified"] is True
-    assert deleted["updated_at"] == "2026-09-19T12:04:00Z"
-    assert [call[0] for call in port.calls] == ["delete_thread"]
-
-    again = operations.delete_thread(port, deleted, persist=persisted.append)
-    assert again["status"] == "deleted"
-    assert [call[0] for call in port.calls] == ["delete_thread"]
-
-
-def test_delete_accepts_verified_not_found_for_retry_safety():
-    class MissingPort(ExistingThreadPort):
-        def delete_thread(self):
-            return {"thread_id": "thread-1", "outcome": "not_found", "verified": True}
-
-    deleted = operations.delete_thread(MissingPort(), state("failed"))
-    assert deleted["status"] == "deleted"
-
-
-def test_cleanup_rejects_unverified_or_unrelated_observations():
-    with pytest.raises(contract.ContractError, match="verified"):
-        contract.validate_cleanup_observation(
-            {"thread_id": "thread-1", "outcome": "deleted", "verified": False},
-            thread_id="thread-1",
-        )
-    with pytest.raises(contract.ContractError, match="different thread"):
-        contract.validate_cleanup_observation(
-            {"thread_id": "other", "outcome": "deleted", "verified": True},
-            thread_id="thread-1",
-        )
-
-
-def test_agents_relay_fixture_drives_one_serial_browser_thread_lifecycle():
-    fixture = json.loads((HERE / "tests" / "fixtures" / "relay_lifecycle.json").read_text())
-    port = ExistingThreadPort(status="completed", result=fixture["result"])
-    port.project = fixture["project"]
-    persisted = []
-
-    created = create.create_thread(
-        FakePort(project=fixture["project"], sent=fixture["thread"]),
-        fixture["create"],
-        persist=persisted.append,
-        now=lambda: "2026-09-19T12:00:00Z",
-    )
-    resumed = operations.resume_thread(
-        port,
-        {"operation": "resume", "thread_id": created["thread_id"], "project": fixture["project"]},
-        state=created,
-        persist=persisted.append,
-        now=lambda: "2026-09-19T12:01:00Z",
-    )
-    result = operations.result_thread(
-        port, resumed, persist=persisted.append, now=lambda: "2026-09-19T12:02:00Z"
-    )
-    deleted = operations.delete_thread(
-        port, resumed, persist=persisted.append, now=lambda: "2026-09-19T12:03:00Z"
-    )
-
-    assert fixture["job_id"] and fixture["task_id"]
-    assert created["thread_id"] == fixture["thread"]["thread_id"]
-    assert result["text"] == fixture["result"]["text"]
-    assert deleted["status"] == "deleted"
-    assert [call[0] for call in port.calls] == ["open_thread", "read_result", "delete_thread"]
-    assert [item["status"] for item in persisted] == ["running", "completed", "completed", "deleted"]