Add Harbor-format task: rental/renewal_negotiation_repair_rental

Synced from https://github.com/evolvent-ai/VibeLifeBench/tree/cd21b2cb5d18a81b0fcdb4a948889a2148f48958/harbor/rental/renewal_negotiation_repair_rental (482 files, byte-identical to GitHub cd21b2cb).

harbor/rental/renewal_negotiation_repair_rental/environment/Dockerfile

@@ -0,0 +1,57 @@
+# Must stay buildable from a public base alone: this bundle is built by whoever
+# receives it, on a machine that has none of the author's local images. A
+# `FROM <locally-built-image>` here fails with "pull access denied" there, and a
+# structural delivery check cannot catch it — such checks inspect compose's
+# `image:` keys, never a Dockerfile FROM.
+#
+# The default base is therefore public and the build needs nothing else. The ARG
+# exists only so a caller who has pre-baked a heavier base (node + the agent CLI,
+# to save time across repeated local runs) can opt in at build time:
+#
+#   docker build --build-arg BASE_IMAGE=<your-prebaked-image> \
+#     -f environment/Dockerfile -t <tag> environment/
+#
+# Override the ARG; never edit FROM.
+ARG BASE_IMAGE=python:3.12-slim
+FROM ${BASE_IMAGE}
+
+# Idempotent: a no-op when the pre-baked base already carries these.
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+        bash ca-certificates coreutils curl jq procps sqlite3 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Core mcp only. The task's client code uses ClientSession and
+# streamablehttp_client; the [cli] extra pulls a typer/rich chain that cannot be
+# resolved against mcp 1.25.0's pydantic pin, so requesting it makes this image
+# unbuildable while adding nothing the task uses.
+RUN pip install --no-cache-dir \
+    "mcp==1.25.0" \
+    "PyYAML==6.0.3"
+
+# Codex tuning, baked into Codex's Unix system layer so the package is
+# self-contained. Harbor recreates /tmp/codex-home for each step, writes its
+# base URL and MCP settings to that user layer, then removes $CODEX_HOME in the
+# step cleanup. A config baked there therefore disappears before the first
+# `codex exec resume --last`; /etc/codex/config.toml survives that lifecycle,
+# and Codex merges it with Harbor's per-step user config.
+#
+# model_auto_compact_token_limit: every step resumes the same session, so the
+# conversation grows monotonically. Measured on this task set it reaches the
+# 196,608-token window around step 20; compacting at 150,000 keeps later steps
+# from repeatedly processing a full window. Compaction replacement history is
+# persisted in the session and is available to later resume processes.
+#
+# web_search: this task talks only to vendored mocks. Codex 0.146.0 expects the
+# top-level enum `web_search = "disabled"`; the deprecated boolean form
+# `[tools] web_search = false` is accepted but silently deserializes to no
+# override, so do not replace this with that form.
+RUN mkdir -p /etc/codex \
+    && printf 'model = "sub2api-gpt-5.6-sol"\nmodel_reasoning_effort = "xhigh"\nmodel_auto_compact_token_limit = 150000\nweb_search = "disabled"\n' \
+       > /etc/codex/config.toml
+
+COPY evidence-collector /opt/evidence-collector
+RUN chmod +x /opt/evidence-collector/collect
+
+WORKDIR /workspace
+USER root

harbor/rental/renewal_negotiation_repair_rental/environment/docker-compose.yaml

@@ -0,0 +1,139 @@
+services:
+  main:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    depends_on:
+      workspace-init: {condition: service_completed_successfully}
+      world-controller: {condition: service_healthy}
+      calendar: {condition: service_healthy}
+      email: {condition: service_healthy}
+      legal-search: {condition: service_healthy}
+      listing-platform: {condition: service_healthy}
+      maps: {condition: service_healthy}
+      notification-hub: {condition: service_healthy}
+      notion: {condition: service_healthy}
+      review-platform: {condition: service_healthy}
+    volumes:
+      - workspace-state:/workspace
+      - eval-evidence:/harbor/evidence:ro
+      - world-clock:/world-clock:ro
+    environment:
+      WORLD_CLOCK_FILE: /world-clock/current.json
+      NO_PROXY: localhost,127.0.0.1,::1,world-controller,calendar,email,legal-search,listing-platform,maps,notification-hub,notion,review-platform
+      no_proxy: localhost,127.0.0.1,::1,world-controller,calendar,email,legal-search,listing-platform,maps,notification-hub,notion,review-platform
+
+  workspace-init:
+    build:
+      context: .
+      dockerfile: workspace-init/Dockerfile
+    volumes: [workspace-state:/target]
+    restart: "no"
+
+  calendar:
+    build: {context: ./servers/calendar_mock}
+    volumes: [./seeds/calendar:/env-seed:ro, calendar-env:/env, world-clock:/world-clock:ro]
+    expose: ["8000"]
+    environment: {WORLD_CLOCK_FILE: /world-clock/current.json}
+    healthcheck: &health
+      test: [CMD, python, -c, "import socket; s=socket.create_connection(('127.0.0.1',8000),2); s.close()"]
+      interval: 2s
+      timeout: 5s
+      retries: 30
+      start_period: 3s
+  email:
+    build: {context: ./servers/email_mock}
+    volumes: [./seeds/email:/env-seed:ro, email-env:/env, world-clock:/world-clock:ro]
+    expose: ["8000"]
+    environment: {WORLD_CLOCK_FILE: /world-clock/current.json}
+    healthcheck: *health
+  legal-search:
+    build: {context: ./servers/legal_search_mock}
+    volumes: [./seeds/legal_search:/env-seed:ro, legal-search-env:/env, world-clock:/world-clock:ro]
+    expose: ["8000"]
+    environment: {WORLD_CLOCK_FILE: /world-clock/current.json}
+    healthcheck: *health
+  listing-platform:
+    build: {context: ./servers/listing_platform_mock}
+    volumes: [./seeds/listing_platform:/env-seed:ro, listing-platform-env:/env, world-clock:/world-clock:ro]
+    expose: ["8000"]
+    environment: {WORLD_CLOCK_FILE: /world-clock/current.json}
+    healthcheck: *health
+  maps:
+    build: {context: ./servers/maps_mock}
+    volumes: [./seeds/maps:/env-seed:ro, maps-env:/env, world-clock:/world-clock:ro]
+    expose: ["8000"]
+    environment: {WORLD_CLOCK_FILE: /world-clock/current.json}
+    healthcheck: *health
+  notification-hub:
+    build: {context: ./servers/notification_hub_mock}
+    volumes: [./seeds/notification_hub:/env-seed:ro, notification-hub-env:/env, world-clock:/world-clock:ro]
+    expose: ["8000"]
+    environment: {WORLD_CLOCK_FILE: /world-clock/current.json}
+    healthcheck: *health
+  notion:
+    build: {context: ./servers/notion_mock}
+    volumes: [./seeds/notion:/env-seed:ro, notion-env:/env, world-clock:/world-clock:ro]
+    expose: ["8000"]
+    environment: {WORLD_CLOCK_FILE: /world-clock/current.json}
+    healthcheck: *health
+  review-platform:
+    build: {context: ./servers/review_platform_mock}
+    volumes: [./seeds/review_platform:/env-seed:ro, review-platform-env:/env, world-clock:/world-clock:ro]
+    expose: ["8000"]
+    environment: {WORLD_CLOCK_FILE: /world-clock/current.json}
+    healthcheck: *health
+
+  world-controller:
+    build:
+      context: .
+      dockerfile: world-controller/Dockerfile
+    depends_on:
+      workspace-init: {condition: service_completed_successfully}
+      calendar: {condition: service_healthy}
+      email: {condition: service_healthy}
+      legal-search: {condition: service_healthy}
+      listing-platform: {condition: service_healthy}
+      maps: {condition: service_healthy}
+      notification-hub: {condition: service_healthy}
+      notion: {condition: service_healthy}
+      review-platform: {condition: service_healthy}
+    environment:
+      HEALTH_TOKEN: rental-health-6fd1289b
+      CLOCK_TOKEN: renewal-negotiation-repair-rental-clock-v1
+      WORLD_CLOCK_FILE: /world-clock/current.json
+      WORLD_CLOCK_REQUIRED: "1"
+    volumes:
+      - calendar-env:/calendar-env
+      - email-env:/email-env
+      - legal-search-env:/legal-search-env
+      - listing-platform-env:/listing-platform-env
+      - maps-env:/maps-env
+      - notification-hub-env:/notification-hub-env
+      - notion-env:/notion-env
+      - review-platform-env:/review-platform-env
+      - controller-state:/controller-state
+      - workspace-state:/workspace-source:ro
+      - eval-evidence:/evidence
+      - world-clock:/world-clock
+    expose: ["8090"]
+    healthcheck:
+      test: [CMD, python, -c, "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8090/health', timeout=2).read()"]
+      interval: 2s
+      timeout: 5s
+      retries: 30
+      start_period: 3s
+
+volumes:
+  workspace-state:
+  eval-evidence:
+  world-clock:
+  controller-state:
+  calendar-env:
+  email-env:
+  legal-search-env:
+  listing-platform-env:
+  maps-env:
+  notification-hub-env:
+  notion-env:
+  review-platform-env:

harbor/rental/renewal_negotiation_repair_rental/environment/evidence-collector/collect

@@ -0,0 +1,3 @@
+#!/bin/sh
+set -eu
+exec python /opt/evidence-collector/collector.py "$@"

harbor/rental/renewal_negotiation_repair_rental/environment/evidence-collector/collector.py

@@ -0,0 +1,345 @@
+"""Trusted main-service collector for one Harbor turn.
+
+This program runs only from Harbor's verifier collect phase, after Harbor has
+uploaded the current agent logs and before the world-controller sidecar freezes
+them.  It replaces, rather than merges with, the agent-writable staging bundle.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import sys
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+HERE = Path(__file__).resolve().parent
+if str(HERE) not in sys.path:
+    sys.path.insert(0, str(HERE))
+
+SCENARIO_CLOCK_PATH = Path(
+    os.environ.get("WORLD_CLOCK_FILE", "/world-clock/current.json")
+)
+SCENARIO_CLOCK_REQUIRED = os.environ.get("WORLD_CLOCK_REQUIRED", "0") == "1"
+
+ORACLE_STDOUT_FILE = "oracle.txt"
+ORACLE_EXIT_CODE_FILE = "exit-code.txt"
+
+from response_capture import (  # noqa: E402
+    _codex_current_turn_rows,
+    _codex_session_items,
+    _jsonable,
+    _load_trajectory,
+    _tool_result_success,
+    atif_step_slice,
+    step_text_and_calls,
+)
+
+def scenario_clock() -> dict[str, Any]:
+    try:
+        payload = json.loads(SCENARIO_CLOCK_PATH.read_text(encoding="utf-8"))
+        if not isinstance(payload.get("step"), str) or not isinstance(payload.get("now"), str):
+            raise ValueError("invalid scenario clock payload")
+        parsed = datetime.fromisoformat(payload["now"].replace("Z", "+00:00"))
+        if parsed.tzinfo is None:
+            raise ValueError("scenario clock must include an offset")
+        return {
+            "schema_version": 1,
+            "step": payload["step"],
+            "now": parsed.isoformat(),
+        }
+    except Exception as exc:
+        if SCENARIO_CLOCK_REQUIRED:
+            raise RuntimeError(
+                f"required scenario clock unavailable at {SCENARIO_CLOCK_PATH}: {exc}"
+            ) from exc
+        now = datetime.now(timezone.utc).isoformat()
+        return {"schema_version": 1, "step": "unknown", "now": now}
+
+
+def utc_now() -> str:
+    return scenario_clock()["now"]
+
+
+def _write_json(path: Path, payload: Any) -> None:
+    path.write_text(
+        json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False)
+        + "\n",
+        encoding="utf-8",
+    )
+
+
+def _latest_session(logs_root: Path) -> Path | None:
+    candidates = [
+        path
+        for pattern in ("sessions/**/rollout-*.jsonl", "sessions/**/*.jsonl")
+        for path in logs_root.glob(pattern)
+        if path.is_file() and not path.is_symlink()
+    ]
+    return max(candidates, key=lambda path: path.stat().st_mtime_ns) if candidates else None
+
+
+def _oracle_run_marker(workspace_root: Path, logs_root: Path) -> bool:
+    """Legacy compatibility hook; workspace files never identify Oracle runs.
+
+    Evidence source selection is trajectory-first for both Oracle and real
+    agents.  Harbor owns the lifecycle around ``oracle.txt``/``exit-code.txt``;
+    a file created by the agent in ``/workspace`` is never sufficient.
+    """
+    return False
+
+
+def _oracle_exit_code(logs_root: Path) -> None:
+    """Fail closed when Harbor recorded a non-zero Oracle solution exit."""
+    path = logs_root / ORACLE_EXIT_CODE_FILE
+    if not path.is_file():
+        return
+    raw = path.read_text(encoding="utf-8").strip()
+    try:
+        code = int(raw)
+    except ValueError as exc:
+        raise RuntimeError(f"invalid Oracle exit code in {path}: {raw!r}") from exc
+    if code != 0:
+        raise RuntimeError(f"Oracle solution exited with code {code}")
+
+
+
+
+def _empty_atif_bytes() -> bytes:
+    return (
+        json.dumps(
+            {"schema_version": "ATIF-v1.7", "steps": []},
+            ensure_ascii=False,
+            sort_keys=True,
+            allow_nan=False,
+        )
+        + "\n"
+    ).encode("utf-8")
+
+
+def _trajectory_document_valid(trajectory: Any) -> bool:
+    """Accept the ATIF/legacy containers emitted by Harbor, not arbitrary JSON."""
+    if not isinstance(trajectory, dict):
+        return False
+    steps = trajectory.get("steps")
+    messages = trajectory.get("messages")
+    return isinstance(steps, list) or isinstance(messages, list)
+
+
+def _validate_session_jsonl(path: Path) -> None:
+    """Fail closed when a discovered Codex session is empty or malformed."""
+    try:
+        lines = [line for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]
+    except OSError as exc:
+        raise RuntimeError(f"unreadable Harbor session log: {path}") from exc
+    if not lines:
+        raise RuntimeError(f"empty Harbor session log: {path}")
+    for line_number, line in enumerate(lines, start=1):
+        try:
+            row = json.loads(line)
+        except json.JSONDecodeError as exc:
+            raise RuntimeError(
+                f"invalid Harbor session JSONL at {path}:{line_number}"
+            ) from exc
+        if not isinstance(row, dict):
+            raise RuntimeError(
+                f"invalid Harbor session record at {path}:{line_number}"
+            )
+
+
+def _trajectory_and_items(
+    logs_root: Path, step_name: str, source_event_id: str, *, workspace_root: Path | None = None
+) -> tuple[bytes, str, list[dict[str, Any]], str, Path | None]:
+    workspace_root = Path(workspace_root) if workspace_root is not None else Path("/workspace")
+    # Oracle and real agents publish the same native trajectory contract.  Do
+    # not inspect or trust any workspace call log when choosing the source.
+    _oracle_exit_code(logs_root)
+
+    if not logs_root.is_dir():
+        raise RuntimeError(f"Harbor agent log directory is unavailable: {logs_root}")
+    if not any(logs_root.iterdir()):
+        # Harbor's native NopAgent intentionally emits no files. Preserve that
+        # fact as an explicit empty turn instead of treating it as telemetry loss.
+        return _empty_atif_bytes(), "", [], "empty-agent-log", None
+
+    trajectory_path = logs_root / "trajectory.json"
+    trajectory_valid = False
+    if trajectory_path.exists():
+        if not trajectory_path.is_file() or trajectory_path.is_symlink():
+            raise RuntimeError(f"invalid Harbor trajectory path: {trajectory_path}")
+        raw = trajectory_path.read_bytes()
+        trajectory = _load_trajectory(trajectory_path)
+        trajectory_valid = _trajectory_document_valid(trajectory)
+        if not trajectory_valid:
+            raise RuntimeError(f"invalid Harbor trajectory: {trajectory_path}")
+        # Freeze only this step's turns; see atif_step_slice for why. Falls back
+        # to the raw bytes whenever the document is a valid legacy container.
+        sliced = atif_step_slice(trajectory)
+        if sliced is not None:
+            raw = (
+                json.dumps(sliced, ensure_ascii=False, sort_keys=True, allow_nan=False)
+                + "\n"
+            ).encode("utf-8")
+        text, calls = step_text_and_calls(trajectory, step_name, source_event_id)
+        if text.strip() or calls:
+            # codex rental detail unified_exec rental detail MCP callrental detail exec rental detail JS rental detail，ATIF onlyrental detail
+            # function_name="exec"，rental detail trace rental detail MCP rental detailno，rental detail
+            # *_servers rental detail False。rental detailrecordonlyrental detail session jsonl rental detail
+            # event_msg/item_completed rental detail，rental detail。rental detail docstring。
+            session_path = _latest_session(logs_root)
+            if session_path is not None:
+                try:
+                    calls = calls + _session_mcp_calls(session_path, source_event_id)
+                except (OSError, ValueError):
+                    # rental detail：rental detail，rental detaildo notrental detailfailurerental detail
+                    # "agent rental detailtool"rental detail。
+                    pass
+            return raw, text, calls, "trajectory.json", None
+    else:
+        raw = _empty_atif_bytes()
+
+    session_path = _latest_session(logs_root)
+    if session_path is not None:
+        _validate_session_jsonl(session_path)
+        text, calls = _codex_session_items(session_path)
+        for call in calls:
+            call["event_id"] = source_event_id
+        calls.extend(_session_mcp_calls(session_path, source_event_id))
+        return raw, text, calls, "session.jsonl", session_path
+    if trajectory_valid:
+        # A valid empty ATIF document is legitimate for a no-op/empty response.
+        return raw, "", [], "trajectory.json", None
+    raise RuntimeError("Harbor produced neither a valid trajectory nor a session log")
+
+
+def _replace_directory(tmp: Path, target: Path) -> None:
+    old: Path | None = None
+    if target.exists() or target.is_symlink():
+        old = target.parent / f".{target.name}.old-{os.getpid()}"
+        if old.exists() or old.is_symlink():
+            if old.is_dir() and not old.is_symlink():
+                shutil.rmtree(old)
+            else:
+                old.unlink()
+        os.replace(target, old)
+    try:
+        os.replace(tmp, target)
+    except Exception:
+        if old is not None and old.exists() and not target.exists():
+            os.replace(old, target)
+        raise
+    if old is not None:
+        if old.is_dir() and not old.is_symlink():
+            shutil.rmtree(old)
+        elif old.exists() or old.is_symlink():
+            old.unlink()
+
+
+def collect_turn(
+    *,
+    workspace_root: Path,
+    logs_root: Path,
+    step_name: str,
+    virtual_stage: int,
+    source_event_id: str,
+    stage_boundary: bool,
+) -> Path:
+    """Replace the current staging bundle with evidence from this Harbor turn."""
+    workspace_root = Path(workspace_root)
+    logs_root = Path(logs_root)
+    stage_root = workspace_root / ".harbor-stage"
+    stage_root.mkdir(parents=True, exist_ok=True)
+    tmp = Path(tempfile.mkdtemp(prefix=".current.tmp-", dir=stage_root))
+    target = stage_root / "current"
+    try:
+        raw, text, calls, trajectory_source, session_path = _trajectory_and_items(
+            logs_root, step_name, source_event_id, workspace_root=workspace_root
+        )
+        (tmp / "trajectory.json").write_bytes(raw)
+        (tmp / "response.txt").write_text(text, encoding="utf-8")
+        _write_json(tmp / "trace.json", calls)
+        if session_path is not None:
+            shutil.copy2(session_path, tmp / "session.jsonl")
+
+
+        metadata = {
+            "schema_version": 1,
+            "step": step_name,
+            "virtual_stage": virtual_stage,
+            "source_event_id": source_event_id,
+            "stage_boundary": bool(stage_boundary),
+            "trajectory_source": trajectory_source,
+            "captured_at": utc_now(),
+            "scenario_clock": scenario_clock(),
+        }
+        _write_json(tmp / "metadata.json", metadata)
+        _replace_directory(tmp, target)
+        return target
+    finally:
+        if tmp.exists():
+            shutil.rmtree(tmp)
+
+
+def _session_mcp_calls(path: Path, event_id: str | None) -> list[dict[str, Any]]:
+    """Extract completed MCP calls from the current Codex rollout turn."""
+    out: list[dict[str, Any]] = []
+    seen_ids: set[str] = set()
+    for row in _codex_current_turn_rows(path):
+        if row.get("type") != "event_msg":
+            continue
+        payload = row.get("payload") or {}
+        if payload.get("type") != "item_completed":
+            continue
+        item = payload.get("item") or {}
+        if item.get("type") != "McpToolCall":
+            continue
+        server = str(item.get("server") or "")
+        tool = str(item.get("tool") or "")
+        if not server or not tool or server == "codex":
+            continue
+        call_id = str(item.get("id") or ("mcp-%d" % len(out)))
+        if call_id in seen_ids:
+            continue
+        seen_ids.add(call_id)
+        arguments = item.get("arguments")
+        if isinstance(arguments, str):
+            try:
+                arguments = json.loads(arguments)
+            except json.JSONDecodeError:
+                arguments = {}
+        result = item.get("result")
+        out.append(
+            {
+                "event_id": event_id,
+                "id": call_id,
+                "name": f"{server}__{tool}",
+                "arguments": arguments if isinstance(arguments, dict) else {},
+                "success": item.get("status") == "completed"
+                and _tool_result_success({"content": result}),
+                "result": _jsonable(result),
+            }
+        )
+    return out
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("step_name")
+    parser.add_argument("virtual_stage", type=int)
+    parser.add_argument("source_event_id")
+    parser.add_argument("stage_boundary", choices=("0", "1"))
+    args = parser.parse_args(argv)
+    collect_turn(
+        workspace_root=Path("/workspace"),
+        logs_root=Path("/logs/agent"),
+        step_name=args.step_name,
+        virtual_stage=args.virtual_stage,
+        source_event_id=args.source_event_id,
+        stage_boundary=args.stage_boundary == "1",
+    )
+    return 0
+if __name__ == "__main__":
+    raise SystemExit(main())

harbor/rental/renewal_negotiation_repair_rental/environment/evidence-collector/harbor_env.py

@@ -0,0 +1,179 @@
+"""Live world access for the trusted evidence collector — capture side only.
+
+This module belongs to the **collector**, which runs during Harbor's verifier
+collect phase and freezes the world at each stage boundary. It is the one place
+that is *supposed* to touch live state:
+
+* ``getattr(env, f"{server}_mock").call_tool(tool, **kwargs)`` — real MCP reads
+  against the running services, used by ``snapshot_capture.py`` to build each
+  stage's ``snapshot.json``.
+* ``env.workspace.fs`` — a read-only view of the live agent workspace at
+  ``/workspace``, captured into the same snapshot.
+
+**Do not confuse this with the scoring side.** ``tests/`` has no adapter at all:
+rubrics there read frozen evidence through ``tests/harbor_evidence.py``, which
+has no MCP client by construction. Scoring a historical stage against live state
+would silently re-score every earlier stage against the *final* world, rewarding
+last-turn back-fill and punishing an agent that correctly superseded stale
+values. Capture reads the live world; scoring never does.
+
+Anything outside the slice is intentionally absent: a rubric reaching for it
+should fail loudly rather than silently score zero.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+# Ordered: the first existing root wins. /workspace is the live agent workspace
+# (present when the verifier shares the main service); the evidence copy is the
+# collected snapshot used for offline replay.
+DEFAULT_WORKSPACE_ROOT = Path(os.environ.get("HARBOR_WORKSPACE_ROOT", "/workspace"))
+
+
+def _service_host(server: str) -> str:
+    """docker-compose hostnames are the underscore-free capability name."""
+    return server.replace("_", "-")
+
+
+def _unwrap_mcp(result: Any) -> Any:
+    """Decode a FastMCP CallToolResult into native Python.
+
+    Mirrors ``capabilities/base.py::_unwrap_mcp`` so the captured snapshot has
+    byte-identical shapes to the source capture — the rubrics match on nested
+    fields, so a different wrapper shape would fail every check.
+    """
+    if result is None:
+        return None
+    sc = getattr(result, "structuredContent", None) or getattr(result, "structured_content", None)
+    if isinstance(sc, dict) and "result" in sc:
+        value = sc["result"]
+        return json.loads(value) if isinstance(value, str) else value
+    for block in getattr(result, "content", None) or []:
+        text = getattr(block, "text", None)
+        if text:
+            try:
+                return json.loads(text)
+            except json.JSONDecodeError:
+                return text
+    return result
+
+
+class _McpCapability:
+    """Read-side MCP capability used during trusted collection."""
+
+    def __init__(self, server: str) -> None:
+        self.server = server
+        host = os.environ.get(f"MCP_HOST_{server.upper()}", _service_host(server))
+        port = os.environ.get("MCP_PORT", "8000")
+        self.url = f"http://{host}:{port}/mcp"
+
+    async def _call_async(self, name: str, **kwargs: Any) -> Any:
+        from mcp import ClientSession
+        from mcp.client.streamable_http import streamablehttp_client
+
+        async with streamablehttp_client(self.url) as (read, write, _meta):
+            async with ClientSession(read, write) as session:
+                await session.initialize()
+                result = await session.call_tool(name, kwargs)
+        return _unwrap_mcp(result)
+
+    def call_tool(self, name: str, **kwargs: Any) -> Any:
+        return asyncio.run(self._call_async(name, **kwargs))
+
+    async def _call_sequence_async(self, requests: list[tuple[str, dict[str, Any]]]) -> list[Any]:
+        from mcp import ClientSession
+        from mcp.client.streamable_http import streamablehttp_client
+
+        results: list[Any] = []
+        async with streamablehttp_client(self.url) as (read, write, _meta):
+            async with ClientSession(read, write) as session:
+                await session.initialize()
+                for name, kwargs in requests:
+                    try:
+                        results.append(_unwrap_mcp(await session.call_tool(name, kwargs)))
+                    except BaseException as exc:  # noqa: BLE001 - parity with call_tool
+                        results.append({"error": f"{type(exc).__name__}: {exc}"})
+        return results
+
+    def call_tool_sequence(self, requests: list[tuple[str, dict[str, Any]]]) -> list[Any]:
+        """Batched counterpart of :meth:`call_tool` for snapshot capture.
+
+        Every ``call_tool`` pays a full streamable-HTTP handshake plus
+        ``initialize`` for a single read. The stage snapshot issues hundreds of
+        such reads (per-message email details, per-page Notion children), and at
+        one-session-per-call that exceeds the collect hook budget. This method
+        reuses one session for the whole sequence while degrading each failed
+        call into the same ``{"error": ...}`` envelope ``call_tool`` produces,
+        so callers observe identical shapes.
+        """
+        if not requests:
+            return []
+        try:
+            return asyncio.run(self._call_sequence_async(requests))
+        except BaseException as exc:  # noqa: BLE001 - parity with call_tool
+            return [{"error": f"{type(exc).__name__}: {exc}"} for _ in requests]
+
+
+class _Fs:
+    """Live read-only workspace adapter used only during trusted collection."""
+
+    def __init__(self, workspace_root: Path | str = DEFAULT_WORKSPACE_ROOT) -> None:
+        self.workspace_root = Path(workspace_root)
+
+    def _candidate(self, path: str) -> Path:
+        raw = str(path).rstrip("/") or "/"
+        # Bare "/workspace" must resolve to the root itself. Falling through to
+        # the generic branch below would append "workspace/" and silently yield
+        # an empty listing — and because the rubrics only ask whether *any*
+        # workspace value is non-empty, that produces zero captured evidence
+        # instead of an error.
+        if raw == "/workspace":
+            return self.workspace_root
+        if raw.startswith("/workspace/"):
+            return self.workspace_root / raw[len("/workspace/") :]
+        return self.workspace_root / raw.lstrip("/")
+
+    def read_file(self, path: str) -> bytes:
+        candidate = self._candidate(path)
+        if not candidate.is_file() or candidate.is_symlink():
+            raise FileNotFoundError(path)
+        return candidate.read_bytes()
+
+    def exists(self, path: str) -> bool:
+        candidate = self._candidate(path)
+        return candidate.exists() and not candidate.is_symlink()
+
+    def list_dir(self, path: str) -> list[str]:
+        candidate = self._candidate(path)
+        if not candidate.is_dir() or candidate.is_symlink():
+            return []
+        return sorted(child.name for child in candidate.iterdir() if not child.is_symlink())
+
+    def write_file(self, path: str, data: bytes) -> None:
+        raise PermissionError("trusted collector workspace view is read-only")
+
+
+class _Workspace:
+    def __init__(self, workspace_root: Path | str = DEFAULT_WORKSPACE_ROOT) -> None:
+        self.fs = _Fs(workspace_root)
+
+
+class HarborEnv:
+    """Duck-typed ``env`` exposing ``<server>_mock`` and ``workspace``."""
+
+    def __init__(
+        self, servers: list[str], workspace_root: Path | str = DEFAULT_WORKSPACE_ROOT
+    ) -> None:
+        self.workspace = _Workspace(workspace_root)
+        self._caps: dict[str, _McpCapability] = {}
+        for server in servers:
+            cap = _McpCapability(server)
+            self._caps[server] = cap
+            setattr(self, f"{server}_mock", cap)
+
+    def capability(self, server: str) -> _McpCapability | None:
+        return self._caps.get(server)

harbor/rental/renewal_negotiation_repair_rental/environment/evidence-collector/response_capture.py

@@ -0,0 +1,392 @@
+"""Parse the current Harbor trajectory into response and tool-call evidence.
+
+This module is deliberately read-only: it never merges prior workspace files
+and never writes historical evidence. The world-controller performs all
+private event accumulation after this parser returns the current turn only.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Iterable
+
+
+def _field(obj: Any, name: str, default: Any = None) -> Any:
+    return obj.get(name, default) if isinstance(obj, dict) else getattr(obj, name, default)
+
+
+def _jsonable(value: Any) -> Any:
+    try:
+        json.dumps(value, ensure_ascii=False)
+    except (TypeError, ValueError):
+        return str(value)
+    return value
+
+
+def _errorish(value: Any) -> bool:
+    """True when a decoded payload has the mocks' error-response shape."""
+    if isinstance(value, str):
+        text = value.strip()
+        if not (text.startswith("{") or text.startswith("[")):
+            return False
+        try:
+            value = json.loads(text)
+        except json.JSONDecodeError:
+            return False
+    if isinstance(value, list):
+        return any(_errorish(item) for item in value)
+    if not isinstance(value, dict):
+        return False
+    if value.get("isError") is True or value.get("is_error") is True:
+        return True
+    if str(value.get("status", "")).lower() == "error":
+        return True
+    # ``error_response`` emits {"error": <message>, "code": <CODE>}. Require a
+    # non-empty error field so a row with error=None/"" is not counted.
+    return bool(value.get("error")) and "code" in value
+
+
+def _tool_result_success(block: Any) -> bool:
+    """Whether a tool call succeeded, judged structurally.
+
+    A call is a failure only when the transport flags it, or when the payload
+    itself has the mocks' error shape. The previous implementation scanned the
+    serialized text for phrases like "not found", so a *successful* call whose
+    results merely contained that wording was recorded as failed.
+    """
+    if _field(block, "is_error", False) or _field(block, "isError", False):
+        return False
+    if _errorish(block):
+        return False
+    content = _field(block, "content", "")
+    return not _errorish(content)
+
+
+def _content_blocks(message: Any) -> list[Any]:
+    content = _field(message, "content", "")
+    if isinstance(content, list):
+        return content
+    return []
+
+
+def extract_assistant_text(messages: Iterable[Any]) -> str:
+    """Port of the source ``_extract_assistant_text`` (joins with ``\\n``)."""
+    chunks: list[str] = []
+    for message in messages or []:
+        if _field(message, "role") != "assistant":
+            continue
+        content = _field(message, "content", "")
+        if isinstance(content, str):
+            if content:
+                chunks.append(content)
+            continue
+        for block in content or []:
+            if _field(block, "type") == "text":
+                text = _field(block, "text", "") or ""
+                if text:
+                    chunks.append(text)
+    return "\n".join(chunks)
+
+
+def extract_tool_calls(messages: Iterable[Any], event_id: str | None = None) -> list[dict[str, Any]]:
+    """Port of the source ``_extract_tool_calls`` over ``role``/``content``."""
+    calls: list[dict[str, Any]] = []
+    by_id: dict[str, dict[str, Any]] = {}
+    for message in messages or []:
+        role = _field(message, "role")
+        if role == "assistant":
+            for block in _content_blocks(message):
+                if _field(block, "type", "") not in ("toolCall", "tool_call", "tool_use"):
+                    continue
+                call = {
+                    "event_id": event_id,
+                    "id": _field(block, "id", _field(block, "tool_call_id", _field(block, "toolCallId"))),
+                    "name": _field(block, "name"),
+                    "arguments": _jsonable(_field(block, "arguments", _field(block, "input", {}))),
+                    "success": None,
+                    "result": None,
+                }
+                calls.append(call)
+                if call["id"] is not None:
+                    by_id[str(call["id"])] = call
+        blocks = _content_blocks(message)
+        if role in ("user", "tool", "toolResult", "tool_result") and not blocks:
+            blocks = [message]
+        for block in blocks:
+            typ = _field(block, "type", "")
+            if typ not in ("toolResult", "tool_result") and role not in (
+                "tool",
+                "toolResult",
+                "tool_result",
+            ):
+                continue
+            tool_id = _field(
+                block,
+                "tool_use_id",
+                _field(block, "tool_call_id", _field(block, "toolCallId", _field(block, "id"))),
+            )
+            if tool_id is None:
+                continue
+            call = by_id.get(str(tool_id))
+            if call is not None:
+                call["success"] = _tool_result_success(block)
+                call["result"] = _jsonable(_field(block, "content", ""))
+    return calls
+
+
+def _is_atif(trajectory: Any) -> bool:
+    steps = trajectory.get("steps") if isinstance(trajectory, dict) else None
+    return isinstance(steps, list) and any(
+        isinstance(step, dict) and "source" in step for step in steps
+    )
+
+
+def _atif_window(trajectory: dict[str, Any]) -> list[dict[str, Any]]:
+    """Turns after the last user turn — the work belonging to this step.
+
+    Earlier turns belong to earlier steps; including them would replay every
+    previous step's prose and tool calls into each later stage.
+    """
+    steps = [step for step in trajectory.get("steps") or [] if isinstance(step, dict)]
+    last_user = -1
+    for index, step in enumerate(steps):
+        if str(step.get("source", "")).lower() == "user":
+            last_user = index
+    return steps[last_user + 1 :]
+
+
+def atif_step_slice(trajectory: Any) -> dict[str, Any] | None:
+    """This step's own turns, in the ATIF envelope the verifier expects.
+
+    Harbor rewrites ``trajectory.json`` as the whole cumulative session on every
+    step, so step N carries steps 1..N-1 verbatim. Freezing that per stage costs
+    O(steps^2) on disk for no scoring value: the rubrics read only ``response``
+    and ``trace``, and the last step's copy already holds the full session.
+    Keep the envelope (``schema_version``/``session_id``/``agent``) so the file
+    stays a valid ATIF document. The prompt turn itself is deliberately excluded
+    because evidence records the agent's work after the prompt.
+
+    Returns None for non-ATIF input, leaving the caller on its raw-bytes path.
+    """
+    if not _is_atif(trajectory):
+        return None
+    steps = [step for step in trajectory.get("steps") or [] if isinstance(step, dict)]
+    last_user = -1
+    for index, step in enumerate(steps):
+        if str(step.get("source", "")).lower() == "user":
+            last_user = index
+    window = steps[last_user + 1 :] if last_user >= 0 else steps
+    sliced = {key: value for key, value in trajectory.items() if key != "steps"}
+    sliced["steps"] = window
+    return sliced
+
+
+def _atif_text(trajectory: dict[str, Any]) -> str:
+    chunks: list[str] = []
+    for step in _atif_window(trajectory):
+        if str(step.get("source", "")).lower() != "agent":
+            continue
+        message = step.get("message")
+        if isinstance(message, str) and message.strip():
+            chunks.append(message)
+        elif isinstance(message, list):
+            for block in message:
+                if isinstance(block, dict) and block.get("type") == "text":
+                    text = block.get("text") or ""
+                    if text:
+                        chunks.append(text)
+    return "\n".join(chunks)
+
+
+def _atif_tool_calls(trajectory: dict[str, Any], event_id: str | None) -> list[dict[str, Any]]:
+    """Pair ATIF ``tool_calls`` with ``observation.results`` by ``source_call_id``."""
+    ordered: list[str] = []
+    calls: dict[str, dict[str, Any]] = {}
+    results: dict[str, Any] = {}
+    for step in _atif_window(trajectory):
+        if str(step.get("source", "")).lower() != "agent":
+            continue
+        for call in step.get("tool_calls") or []:
+            if not isinstance(call, dict):
+                continue
+            call_id = str(call.get("tool_call_id") or call.get("id") or "")
+            if not call_id or call_id in calls:
+                continue
+            name = call.get("function_name") or call.get("name")
+            function = call.get("function")
+            if isinstance(function, dict):
+                name = name or function.get("name")
+                arguments = function.get("arguments", call.get("arguments", {}))
+            else:
+                arguments = call.get("arguments", {})
+            if isinstance(arguments, str):
+                try:
+                    arguments = json.loads(arguments)
+                except json.JSONDecodeError:
+                    arguments = {}
+            calls[call_id] = {
+                "event_id": event_id,
+                "id": call_id,
+                "name": str(name or ""),
+                "arguments": arguments if isinstance(arguments, dict) else {},
+                "success": None,
+                "result": None,
+            }
+            ordered.append(call_id)
+        observation = step.get("observation")
+        rows = observation.get("results", []) if isinstance(observation, dict) else []
+        for row in rows:
+            if not isinstance(row, dict):
+                continue
+            call_id = str(row.get("source_call_id") or row.get("tool_call_id") or "")
+            if call_id:
+                results[call_id] = row.get("content")
+    out: list[dict[str, Any]] = []
+    for call_id in ordered:
+        call = calls[call_id]
+        if call_id in results:
+            content = results[call_id]
+            call["success"] = _tool_result_success({"content": content})
+            call["result"] = _jsonable(content)
+        out.append(call)
+    return out
+
+
+def _messages_for_step(trajectory: Any, step_name: str) -> list[Any]:
+    """``role``/``content`` messages for this step, for non-ATIF dialects."""
+    if not isinstance(trajectory, dict):
+        return []
+    steps = trajectory.get("steps")
+    if isinstance(steps, list):
+        for step in steps:
+            if isinstance(step, dict) and step.get("name") == step_name:
+                messages = step.get("messages")
+                return messages if isinstance(messages, list) else []
+        return []
+    messages = trajectory.get("messages")
+    return messages if isinstance(messages, list) else []
+
+
+def _codex_is_user_turn(row: Any) -> bool:
+    """Whether a Codex rollout record starts a new user turn."""
+    if not isinstance(row, dict):
+        return False
+    payload = row.get("payload") or {}
+    if row.get("type") == "event_msg":
+        return str(payload.get("type", "")).lower() in {
+            "user_message",
+            "user_turn",
+            "user",
+        }
+    if row.get("type") == "response_item":
+        return payload.get("type") == "message" and str(payload.get("role", "")).lower() == "user"
+    return False
+
+
+def _codex_session_rows(path: Path) -> list[dict[str, Any]]:
+    """Read valid JSON objects from a Codex rollout JSONL file."""
+    try:
+        lines = path.read_text(encoding="utf-8").splitlines()
+    except OSError:
+        return []
+    rows: list[dict[str, Any]] = []
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            row = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(row, dict):
+            rows.append(row)
+    return rows
+
+
+def _codex_current_turn_rows(path: Path) -> list[dict[str, Any]]:
+    """Return only records after the final user turn in a cumulative rollout."""
+    rows = _codex_session_rows(path)
+    last_user = -1
+    for index, row in enumerate(rows):
+        if _codex_is_user_turn(row):
+            last_user = index
+    return rows[last_user + 1 :]
+
+
+def _codex_session_items(path: Path) -> tuple[str, list[dict[str, Any]]]:
+    """Read a Codex session JSONL into (prose, tool calls).
+
+    Harbor's codex agent converts sessions to ATIF *on the host*, so the
+    container only ever has ``/logs/agent/sessions/**/rollout-*.jsonl``. Reading
+    it directly is what keeps the Tool Call and Final buckets scorable — without
+    this the verifier sees an empty trajectory and those 20 points are
+    unreachable no matter what the agent did.
+    """
+    texts: list[str] = []
+    calls: dict[str, dict[str, Any]] = {}
+    order: list[str] = []
+    outputs: dict[str, Any] = {}
+    for row in _codex_current_turn_rows(path):
+        if row.get("type") != "response_item":
+            continue
+        payload = row.get("payload") or {}
+        kind = payload.get("type")
+        if kind == "message" and payload.get("role") == "assistant":
+            for block in payload.get("content") or []:
+                if isinstance(block, dict):
+                    text = block.get("text") or ""
+                    if text:
+                        texts.append(text)
+        elif kind == "function_call":
+            call_id = str(payload.get("call_id") or "")
+            if not call_id:
+                continue
+            args = payload.get("arguments")
+            if isinstance(args, str):
+                try:
+                    args = json.loads(args)
+                except json.JSONDecodeError:
+                    args = {}
+            calls[call_id] = {
+                "event_id": None,
+                "id": call_id,
+                "name": str(payload.get("name") or ""),
+                "arguments": args if isinstance(args, dict) else {},
+                "success": None,
+                "result": None,
+            }
+            order.append(call_id)
+        elif kind == "function_call_output":
+            call_id = str(payload.get("call_id") or "")
+            if call_id:
+                outputs[call_id] = payload.get("output")
+    out: list[dict[str, Any]] = []
+    for call_id in order:
+        call = calls[call_id]
+        if call_id in outputs:
+            content = outputs[call_id]
+            call["success"] = _tool_result_success({"content": content})
+            call["result"] = _jsonable(content)
+        out.append(call)
+    return "\n".join(texts), out
+
+
+def _load_trajectory(path: Path) -> Any:
+    if not path.is_file():
+        return None
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+def step_text_and_calls(
+    trajectory: Any, step_name: str, event_id: str | None
+) -> tuple[str, list[dict[str, Any]]]:
+    """Prose and tool calls for one Harbor step, whichever dialect was written."""
+    if not isinstance(trajectory, dict):
+        return "", []
+    if _is_atif(trajectory):
+        return _atif_text(trajectory), _atif_tool_calls(trajectory, event_id)
+    messages = _messages_for_step(trajectory, step_name)
+    return extract_assistant_text(messages), extract_tool_calls(messages, event_id)

harbor/rental/renewal_negotiation_repair_rental/environment/evidence-collector/snapshot_capture.py

@@ -0,0 +1,490 @@
+"""Capture the authoritative stage-boundary world through MCP.
+
+The world-controller invokes this module only in its sidecar phase. All world
+mutations visible to the step were applied before the agent turn; no trailing
+mutation is allowed between response collection and snapshot publication. The returned dictionary is written directly into the
+private evidence volume; this module never materializes historical files in the
+agent workspace.
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+SCENARIO_CLOCK_PATH = Path(
+    os.environ.get("WORLD_CLOCK_FILE", "/world-clock/current.json")
+)
+SCENARIO_CLOCK_REQUIRED = os.environ.get("WORLD_CLOCK_REQUIRED", "0") == "1"
+
+USER_ID = "usr_lin_che"
+CALENDAR_ID = "cal_lin_primary"
+
+
+def scenario_clock() -> dict[str, Any]:
+    try:
+        payload = json.loads(SCENARIO_CLOCK_PATH.read_text(encoding="utf-8"))
+        if not isinstance(payload.get("step"), str) or not isinstance(payload.get("now"), str):
+            raise ValueError("invalid scenario clock payload")
+        return {"schema_version": 1, "step": payload["step"], "now": payload["now"]}
+    except Exception as exc:
+        if SCENARIO_CLOCK_REQUIRED:
+            raise RuntimeError(
+                f"required scenario clock unavailable at {SCENARIO_CLOCK_PATH}: {exc}"
+            ) from exc
+        return {"schema_version": 1, "step": "unknown", "now": ""}
+
+
+# Copied verbatim from the source task.py. The rubrics assert on these exact ids.
+TRACKED_JOB_IDS = (
+    "job_mj_214",
+    "job_yr_098",
+    "job_qs_507",
+    "job_lh_332",
+    "job_jh_126",
+    "job_ba_773",
+    "job_eb2508",
+    "job_4437d4",
+    "job_08caa9",
+    "job_fbc2b6",
+    "job_86f824",
+    "job_361030",
+    "job_541371",
+    "job_adcf31",
+)
+
+TRACKED_APPLICATION_IDS = (
+    "app_mj_001",
+    "app_39f15c",
+    "app_9cfb94",
+    "app_a935d7",
+    "app_b323c6",
+    "app_ca54c7",
+    "app_308e6e",
+    "app_0a108f",
+    "app_6ebad5",
+    "app_bc0d7e",
+)
+
+TRACKED_LEGAL_IDS = {
+    "cases": (
+        "case_noncompete_comp",
+        "case_probation_salary",
+        "case_employee_work",
+        "case_customer_data",
+        "case_clause_scope",
+        "case_confidentiality",
+        "case_0b9fb5e5",
+        "case_91df21d0",
+        "case_32e71e2d",
+        "case_c202b143",
+        "case_9e37bba0",
+    ),
+    "statutes": (
+        "stat_labor_contract",
+        "stat_personal_info",
+        "stat_civil_code",
+        "stat_52e9ebd7",
+        "stat_b8e3b12b",
+        "stat_aa45041c",
+        "stat_53e861d3",
+        "stat_8f9c2ba0",
+        "stat_fdb02184",
+        "stat_fb08641d",
+    ),
+    "articles": (
+        "art_labor_19",
+        "art_labor_20",
+        "art_labor_23",
+        "art_labor_24",
+        "art_pipl_6",
+        "art_civil_privacy",
+        "art_87d7abfc",
+        "art_4cb3c589",
+        "art_314eb23c",
+        "art_41be0315",
+        "art_a67caa73",
+        "art_c6e4419e",
+    ),
+}
+
+# Workspace files shipped as baseline context. The source snapshot excludes them
+# so that seeded prose can never be mistaken for the agent's own writing. The
+# exclusion is content-aware: ARTIFACT_CONTRACT.md makes some of these files
+# (BUDGET_LEDGER.md among them) agent-maintained deliverables, so a file that
+# diverged from the shipped baseline is the agent's own writing and is captured.
+BASELINE_WORKSPACE_NAMES = {
+    "AGENTS.md",
+    "ARTIFACT_CONTRACT.md",
+    "AUTHORIZATION.md",
+    "BUDGET_LEDGER.md",
+    "COMPENSATION.md",
+    "COMMUTE_POLICY.md",
+    "IDENTITY.md",
+    "INTERVIEW_PREP.md",
+    "LEASE_CHECKLIST_TEMPLATE.md",
+    "PERSONA.md",
+    "PRIVACY_POLICY.md",
+    "REFERENCES.md",
+    "RENTAL_REQUIREMENTS.md",
+    "RESUME_PROFILE.md",
+    "SOUL.md",
+    "TRACKER_TEMPLATE.md",
+    "TOOLS.md",
+    "USER.md",
+}
+# Pristine copies of the seeded workspace, baked into the world-controller
+# image (see world-controller/Dockerfile). Content comparison against these
+# decides whether a baseline-named file is still seed text or agent work.
+BASELINE_WORKSPACE_ROOT = Path(
+    os.environ.get("WORLD_BASELINE_WORKSPACE", "/opt/workspace-baseline")
+)
+ALLOWED_WORKSPACE_SUFFIXES = (".md", ".txt", ".json", ".csv")
+
+
+def _decode(value: Any) -> Any:
+    """Mirror of the source ``_decode_tool_value`` for JSON-in-string results."""
+    if isinstance(value, str):
+        try:
+            return json.loads(value)
+        except json.JSONDecodeError:
+            return value
+    return value
+
+
+def _unwrap_envelope(value: Any, fetch_page: Any = None) -> Any:
+    """Normalize the canonical paginated MCP envelope into a complete list."""
+    if not isinstance(value, dict):
+        return value
+    rows = value.get("items")
+    if not isinstance(rows, list) or ("total" not in value and "has_more" not in value):
+        return value
+    merged = list(rows)
+    total = value.get("total")
+    page = int(value.get("page") or 1)
+    size = int(value.get("page_size") or len(rows) or 1)
+    while value.get("has_more") and fetch_page is not None:
+        page += 1
+        nxt = fetch_page(page)
+        if not isinstance(nxt, dict) or not isinstance(nxt.get("items"), list):
+            value["_pagination_incomplete"] = True
+            break
+        fresh = nxt["items"]
+        merged.extend(fresh)
+        value = nxt
+        if total is not None and len(merged) >= int(total):
+            break
+    if total is not None and len(merged) < int(total):
+        value["_pagination_incomplete"] = True
+    return merged
+
+
+def _call(env: Any, server: str, tool: str, **kwargs: Any) -> Any:
+    """Mirror of the source ``_snapshot_call``: never raise, record the error.
+
+    A failed capability read must land in the snapshot as ``{"error": ...}``
+    exactly as the source recorded it, so a broken server produces failing checks
+    with a diagnosable cause instead of aborting the whole verifier.
+    """
+    cap = getattr(env, f"{server}_mock", None)
+    if cap is None:
+        return {"error": f"missing capability: {server}"}
+    try:
+        decoded = _decode(cap.call_tool(tool, **kwargs))
+        return _unwrap_envelope(decoded, lambda page: _decode(cap.call_tool(tool, **{**kwargs, "page": page})))
+    except BaseException as exc:  # noqa: BLE001 - parity with source behaviour
+        return {"error": f"{type(exc).__name__}: {exc}"}
+
+
+def _batch_call(env: Any, server: str, requests: list[tuple[str, dict[str, Any]]]) -> list[Any]:
+    """Run many reads against one server while paying for a single session.
+
+    Same never-raise contract as :func:`_call`: a missing capability or a dead
+    connection degrades into one ``{"error": ...}`` envelope per request instead
+    of aborting the capture. Results keep positional order.
+    """
+    cap = getattr(env, f"{server}_mock", None)
+    if cap is None:
+        return [{"error": f"missing capability: {server}"} for _ in requests]
+    batch = getattr(cap, "call_tool_sequence", None)
+    if batch is None:
+        return [_call(env, server, name, **kwargs) for name, kwargs in requests]
+    try:
+        results = batch([(name, dict(kwargs)) for name, kwargs in requests])
+    except BaseException as exc:  # noqa: BLE001 - parity with _call behaviour
+        return [{"error": f"{type(exc).__name__}: {exc}"} for _ in requests]
+    return [
+        value
+        if isinstance(value, dict) and set(value) == {"error"}
+        else _unwrap_envelope(_decode(value))
+        for value in results
+    ]
+
+
+def _paged_call(
+    env: Any, server: str, tool: str, *, rows_key: str, id_keys: tuple[str, ...], **kwargs: Any
+) -> Any:
+    """Walk every page of a paginated tool and merge the rows.
+
+    The email mock clamps ``page_size`` to 50 (``utils/validators.py``) and
+    signals the clamp only by echoing the applied value, so one large request
+    silently returns a prefix: the seeded INBOX holds 193 messages, of which a
+    single request captures 50. Evidence that never enters the snapshot can
+    never be scored, so the walk continues until the accumulated rows reach the
+    reported total. Rows are merged back into the first page's envelope, leaving
+    the stored shape unchanged for consumers.
+    """
+    first = _call(env, server, tool, page=1, page_size=200, **kwargs)
+    if not isinstance(first, dict):
+        return first
+
+    def _row_id(row: Any) -> str:
+        if not isinstance(row, dict):
+            return ""
+        for key in id_keys:
+            if row.get(key) is not None:
+                return str(row[key])
+        return ""
+
+    merged = [row for row in (first.get(rows_key) or []) if isinstance(row, dict)]
+    applied = int(first.get("page_size") or 0) or max(len(merged), 1)
+    raw_total = first.get("total_results", first.get("total"))
+    total = int(raw_total) if isinstance(raw_total, (int, float)) else None
+    seen = {_row_id(row) for row in merged}
+    page = 2
+    # The folder cannot need more pages than it has rows; +1 tolerates a total
+    # that grew between calls rather than silently stopping short.
+    max_pages = ((total + applied - 1) // applied + 1) if total else 1
+    while total is not None and len(merged) < total and page <= max_pages:
+        nxt = _call(env, server, tool, page=page, page_size=applied, **kwargs)
+        if not isinstance(nxt, dict):
+            break
+        # An out-of-range page is clamped to the last page rather than returning
+        # empty, so stop on the first page that yields nothing new.
+        fresh = [
+            row
+            for row in (nxt.get(rows_key) or [])
+            if isinstance(row, dict) and _row_id(row) not in seen
+        ]
+        if not fresh:
+            break
+        seen.update(_row_id(row) for row in fresh)
+        merged.extend(fresh)
+        page += 1
+    first[rows_key] = merged
+    first["captured_count"] = len(merged)
+    if total is not None:
+        first["captured_complete"] = len(merged) >= total
+    return first
+
+
+def _email_listing(env: Any, folder: str) -> Any:
+    return _paged_call(
+        env, "email", "get_emails",
+        rows_key="emails", id_keys=("email_id", "id"), folder=folder,
+    )
+
+
+def _email_snapshot(env: Any, folder: str, *, include_body: bool) -> dict[str, Any]:
+    """Capture a folder's listing plus per-message detail.
+
+    Detail merges ``read_email`` (body) with ``get_email_headers``
+    (``in_reply_to`` / ``references``). Both calls are required: the mock's
+    ``read_email`` projection deliberately omits threading headers, but
+    ``_helpers.sent_message_matches`` matches ``thread_message_id`` against
+    ``in_reply_to``/``references``. Capturing only ``read_email`` therefore makes
+    every threaded-reply check unreachable no matter what the agent does — the
+    reply is in Sent, correctly threaded in the database, and still scores zero.
+
+    The per-message calls are issued as one batched sequence over a single MCP
+    session (see ``_McpCapability.call_tool_sequence``). At one session per
+    call, the seeded INBOX alone costs roughly 2 x 193 full HTTP handshakes per
+    stage, which is what pushed the collect hook past its timeout budget.
+    """
+    listing = _email_listing(env, folder)
+    if not include_body or not isinstance(listing, dict):
+        return {"listing": listing, "details": []}
+    email_ids: list[str] = []
+    for item in listing.get("emails") or []:
+        if not isinstance(item, dict):
+            continue
+        email_id = item.get("email_id") or item.get("id")
+        if email_id is None:
+            continue
+        email_ids.append(str(email_id))
+    detail_results = _batch_call(
+        env, "email", [("read_email", {"email_id": email_id}) for email_id in email_ids]
+    )
+    header_results = _batch_call(
+        env, "email", [("get_email_headers", {"email_id": email_id}) for email_id in email_ids]
+    )
+    details: list[Any] = []
+    for detail, headers in zip(detail_results, header_results):
+        if isinstance(detail, dict) and isinstance(headers, dict):
+            for key in ("in_reply_to", "references", "references_header", "headers", "thread_id"):
+                if headers.get(key) is not None:
+                    detail.setdefault(key, headers[key])
+        details.append(detail)
+    return {"listing": listing, "details": details}
+
+
+def _baseline_unchanged(name: str, path: str, fs: Any) -> bool:
+    """True when a baseline-named workspace file still matches the shipped seed.
+
+    Unreadable entries stay excluded, matching the legacy behaviour for
+    anything that is not a readable file; a missing shipped baseline is also
+    treated as unchanged so the capture degrades to the legacy exclusion rather
+    than freezing unverifiable content.
+    """
+    try:
+        raw = fs.read_file(path)
+    except Exception:  # noqa: BLE001 - directories and unreadable paths
+        return True
+    try:
+        seed = (BASELINE_WORKSPACE_ROOT / name).read_bytes()
+    except OSError:
+        return True
+    data = raw if isinstance(raw, bytes) else str(raw).encode("utf-8", errors="replace")
+    return data == seed
+
+
+def _workspace_snapshot(env: Any) -> dict[str, str]:
+    """Agent-authored workspace files, unchanged baseline context excluded."""
+    fs = getattr(getattr(env, "workspace", None), "fs", None)
+    if fs is None:
+        return {}
+    out: dict[str, str] = {}
+    seen: set[str] = set()
+
+    def visit(path: str, depth: int) -> None:
+        if path in seen or len(out) >= 200:
+            return
+        seen.add(path)
+        name = path.rsplit("/", 1)[-1]
+        if name in BASELINE_WORKSPACE_NAMES and _baseline_unchanged(name, path, fs):
+            return
+        # Harness/verifier scratch is not agent output. Capturing it would let
+        # the reference oracle's own bookkeeping satisfy content checks that are
+        # supposed to be earned by the durable ledger.
+        if name.startswith("."):
+            return
+        if name.lower().endswith(ALLOWED_WORKSPACE_SUFFIXES):
+            try:
+                raw = fs.read_file(path)
+            except Exception:  # noqa: BLE001
+                raw = None
+            if raw is not None:
+                text = raw.decode("utf-8", errors="replace") if isinstance(raw, bytes) else str(raw)
+                if text.strip():
+                    out[path] = text[:200000]
+                return
+        if depth <= 0:
+            return
+        try:
+            children = fs.list_dir(path)
+        except Exception:  # noqa: BLE001
+            return
+        for child in children:
+            visit(f"{path.rstrip('/')}/{child}", depth - 1)
+
+    # Harbor mounts the agent workspace at /workspace; the captured keys are
+    # therefore Harbor-native paths. The rubrics treat this map opaquely (they
+    # only read its values), so the key spelling is free to be native.
+    visit("/workspace", 4)
+    return out
+
+
+def _notion_snapshot(env: Any) -> dict[str, Any]:
+    """Pages plus database rows and their children.
+
+    ``API-post-search`` returns pages/databases but not database rows, so rows
+    are queried explicitly and their children captured separately — without this
+    the ledger checks read an empty Notion and fail for the wrong reason.
+
+    The per-object child reads go out as batched sequences over one session;
+    hundreds of single-session calls here were a second large contributor to
+    the stage collect timeout.
+    """
+    page_search = _call(
+        env,
+        "notion",
+        "API-post-search",
+        query="",
+        filter={"value": "page", "property": "object"},
+        page_size=100,
+    )
+    database_search = _call(
+        env,
+        "notion",
+        "API-post-search",
+        query="",
+        filter={"value": "database", "property": "object"},
+        page_size=100,
+    )
+
+    def _ids(payload: Any) -> list[str]:
+        if not isinstance(payload, dict):
+            return []
+        return [
+            str(item["id"])
+            for item in payload.get("results") or []
+            if isinstance(item, dict) and item.get("id")
+        ]
+
+    page_ids = _ids(page_search)
+    page_results = _batch_call(
+        env,
+        "notion",
+        [
+            ("API-get-block-children", {"block_id": page_id, "page_size": 100})
+            for page_id in page_ids
+        ],
+    )
+    page_blocks = dict(zip(page_ids, page_results))
+
+    database_rows: dict[str, Any] = {}
+    row_children: dict[str, Any] = {}
+    database_ids = _ids(database_search)
+    db_results = _batch_call(
+        env,
+        "notion",
+        [
+            ("API-post-database-query", {"database_id": database_id, "page_size": 100})
+            for database_id in database_ids
+        ],
+    )
+    row_ids: list[str] = []
+    row_requests: list[tuple[str, dict[str, Any]]] = []
+    for database_id, rows in zip(database_ids, db_results):
+        database_rows[database_id] = rows
+        for row_id in _ids(rows):
+            row_ids.append(row_id)
+            row_requests.append(("API-get-block-children", {"block_id": row_id, "page_size": 100}))
+    row_results = _batch_call(env, "notion", row_requests)
+    row_children = dict(zip(row_ids, row_results))
+    return {
+        "pages": page_search,
+        "databases": database_search,
+        "page_blocks": page_blocks,
+        "database_rows": database_rows,
+        "row_children": row_children,
+    }
+
+
+def capture_stage_snapshot(env: Any, stage_idx: int) -> dict[str, Any]:
+    """Capture all task services at a stage boundary."""
+    listing_ids = ("bjr_4f2a9c1e", "bjr_8d71c4b0", "bjr_2c9e6a57", "bjr_9a5d0c73")
+    place_ids = ("bjp_61c4f20a", "bjp_7ad2e985", "bjp_3f8c1b76", "bjp_84e1c7d3")
+    merchant_ids = ("bjm_41d7a2c9", "bjm_72c4e8a1", "bjm_93a5d0f6")
+    return {
+        "stage": stage_idx, "scenario_clock": scenario_clock(),
+        "listing_platform": {"search": _call(env, "listing_platform", "search_listings", category="rent", city="Beijing", limit=200), "details": {i: _call(env, "listing_platform", "get_listing_detail", listing_id=i) for i in listing_ids}},
+        "maps": {"places": {i: _call(env, "maps", "get_place_details", place_id=i) for i in place_ids}},
+        "calendar": {"events": _call(env, "calendar", "list_events", calendar_id="cal_hanqi_main", max_results=500)},
+        "email": {"inbox": _email_snapshot(env, "INBOX", include_body=True), "sent": _email_snapshot(env, "Sent", include_body=True), "drafts": _paged_call(env, "email", "get_drafts", rows_key="drafts", id_keys=("draft_id", "id"))},
+        "notification_hub": {"subscriptions": _call(env, "notification_hub", "list_subscriptions", user_id="hanqi_rental"), "notifications": _call(env, "notification_hub", "list_notifications", user_id="hanqi_rental", limit=500)},
+        "review_platform": {"merchants": {i: _call(env, "review_platform", "get_merchant", merchant_id=i) for i in merchant_ids}, "reviews": {i: _call(env, "review_platform", "list_reviews", merchant_id=i, limit=100) for i in merchant_ids}},
+        "legal_search": {"cases": _call(env, "legal_search", "search_cases", keyword="lease", limit=100), "statutes": _call(env, "legal_search", "search_statutes", keyword="rental", limit=100)},
+        "workspace": _workspace_snapshot(env), "notion": _notion_snapshot(env),
+    }

harbor/rental/renewal_negotiation_repair_rental/environment/seeds/calendar/README.md

@@ -0,0 +1,19 @@
+# calendar env for renewal_negotiation_repair_rental
+
+rental detail：renewalrental detailrepair responsibilityrental detail。rental detail 2026-07-12 rental detail 2026-08-16，rental detail Asia/Shanghai。
+
+rental detail：rr007_current_home、rr007_low_price_risk、rr007_backup_viable、pl_rr007_work、pl_rr007_current、pl_rr007_backup、rv_rr007_current、rv_rr007_backup。rental detaillistingrental detail、commute、repairrisk、rental detail、statusrefreshrental detailfinal archive。
+
+rental detail task/rubric rental detail：rubric rental detailtool trace、rental detailstatusrental detail agent rental detailrefresh、rental detailchangerental detail。
+
+statusrental detail：rental detail minor CNYrental detail；850000 rental detail 8500 CNY。statusrental detail active、delisted、pending、draft rental detail。
+
+rental detail：
+
+| rental detail | rental detail | rental detail | rental detail/check | rental detail | rental detail |
+|---|---|---:|---|---|---|
+| `events` | rental detail | 225 | renewalrental detail、repair responsibility、commute/rental detail/rental detail/notificationrental detail | rental detailretainrental detailprice、rental detail、ID、rental detailstatusrental detail，rental detailevidencestillrental detail | rental detail |
+
+rental detail smoke test：server rental detail init.sql；rental detail MCP list/search/get toolreadrental detail。
+
+rental detailsource：rental detail，rental detail。

harbor/rental/renewal_negotiation_repair_rental/environment/seeds/email/README.md

@@ -0,0 +1,19 @@
+# email env for renewal_negotiation_repair_rental
+
+rental detail：renewalrental detailrepair responsibilityrental detail。rental detail 2026-07-12 rental detail 2026-08-16，rental detail Asia/Shanghai。
+
+rental detail：rr007_current_home、rr007_low_price_risk、rr007_backup_viable、pl_rr007_work、pl_rr007_current、pl_rr007_backup、rv_rr007_current、rv_rr007_backup。rental detaillistingrental detail、commute、repairrisk、rental detail、statusrefreshrental detailfinal archive。
+
+rental detail task/rubric rental detail：rubric rental detailtool trace、rental detailstatusrental detail agent rental detailrefresh、rental detailchangerental detail。
+
+statusrental detail：rental detail minor CNYrental detail；850000 rental detail 8500 CNY。statusrental detail active、delisted、pending、draft rental detail。
+
+rental detail：
+
+| rental detail | rental detail | rental detail | rental detail/check | rental detail | rental detail |
+|---|---|---:|---|---|---|
+| `messages` | rental detail | 213 | renewalrental detail、repair responsibility、commute/rental detail/rental detail/notificationrental detail | rental detailretainrental detailprice、rental detail、ID、rental detailstatusrental detail，rental detailevidencestillrental detail | rental detail |
+
+rental detail smoke test：server rental detail init.sql；rental detail MCP list/search/get toolreadrental detail。
+
+rental detailsource：rental detail，rental detail。

harbor/rental/renewal_negotiation_repair_rental/environment/seeds/legal_search/README.md

@@ -0,0 +1,19 @@
+# legal_search env for renewal_negotiation_repair_rental
+
+rental detail：renewalrental detailrepair responsibilityrental detail。rental detail 2026-07-12 rental detail 2026-08-16，rental detail Asia/Shanghai。
+
+rental detail：rr007_current_home、rr007_low_price_risk、rr007_backup_viable、pl_rr007_work、pl_rr007_current、pl_rr007_backup、rv_rr007_current、rv_rr007_backup。rental detaillistingrental detail、commute、repairrisk、rental detail、statusrefreshrental detailfinal archive。
+
+rental detail task/rubric rental detail：rubric rental detailtool trace、rental detailstatusrental detail agent rental detailrefresh、rental detailchangerental detail。
+
+statusrental detail：rental detail minor CNYrental detail；850000 rental detail 8500 CNY。statusrental detail active、delisted、pending、draft rental detail。
+
+rental detail：
+
+| rental detail | rental detail | rental detail | rental detail/check | rental detail | rental detail |
+|---|---|---:|---|---|---|
+| `cases` | rental detail | 213 | renewalrental detail、repair responsibility、commute/rental detail/rental detail/notificationrental detail | rental detailretainrental detailprice、rental detail、ID、rental detailstatusrental detail，rental detailevidencestillrental detail | rental detail |
+
+rental detail smoke test：server rental detail init.sql；rental detail MCP list/search/get toolreadrental detail。
+
+rental detailsource：rental detail，rental detail。

harbor/rental/renewal_negotiation_repair_rental/environment/seeds/listing_platform/README.md

@@ -0,0 +1,19 @@
+# listing_platform env for renewal_negotiation_repair_rental
+
+rental detail：renewalrental detailrepair responsibilityrental detail。rental detail 2026-07-12 rental detail 2026-08-16，rental detail Asia/Shanghai。
+
+rental detail：rr007_current_home、rr007_low_price_risk、rr007_backup_viable、pl_rr007_work、pl_rr007_current、pl_rr007_backup、rv_rr007_current、rv_rr007_backup。rental detaillistingrental detail、commute、repairrisk、rental detail、statusrefreshrental detailfinal archive。
+
+rental detail task/rubric rental detail：rubric rental detailtool trace、rental detailstatusrental detail agent rental detailrefresh、rental detailchangerental detail。
+
+statusrental detail：rental detail minor CNYrental detail；850000 rental detail 8500 CNY。statusrental detail active、delisted、pending、draft rental detail。
+
+rental detail：
+
+| rental detail | rental detail | rental detail | rental detail/check | rental detail | rental detail |
+|---|---|---:|---|---|---|
+| `listings` | rental detail | 240 | renewalrental detail、repair responsibility、commute/rental detail/rental detail/notificationrental detail | rental detailretainrental detailprice、rental detail、ID、rental detailstatusrental detail，rental detailevidencestillrental detail | rental detail |
+
+rental detail smoke test：server rental detail init.sql；rental detail MCP list/search/get toolreadrental detail。
+
+rental detailsource：rental detail，rental detail。

harbor/rental/renewal_negotiation_repair_rental/environment/seeds/maps/README.md

@@ -0,0 +1,19 @@
+# maps env for renewal_negotiation_repair_rental
+
+rental detail：renewalrental detailrepair responsibilityrental detail。rental detail 2026-07-12 rental detail 2026-08-16，rental detail Asia/Shanghai。
+
+rental detail：rr007_current_home、rr007_low_price_risk、rr007_backup_viable、pl_rr007_work、pl_rr007_current、pl_rr007_backup、rv_rr007_current、rv_rr007_backup。rental detaillistingrental detail、commute、repairrisk、rental detail、statusrefreshrental detailfinal archive。
+
+rental detail task/rubric rental detail：rubric rental detailtool trace、rental detailstatusrental detail agent rental detailrefresh、rental detailchangerental detail。
+
+statusrental detail：rental detail minor CNYrental detail；850000 rental detail 8500 CNY。statusrental detail active、delisted、pending、draft rental detail。
+
+rental detail：
+
+| rental detail | rental detail | rental detail | rental detail/check | rental detail | rental detail |
+|---|---|---:|---|---|---|
+| `places` | rental detail | 230 | renewalrental detail、repair responsibility、commute/rental detail/rental detail/notificationrental detail | rental detailretainrental detailprice、rental detail、ID、rental detailstatusrental detail，rental detailevidencestillrental detail | rental detail |
+
+rental detail smoke test：server rental detail init.sql；rental detail MCP list/search/get toolreadrental detail。
+
+rental detailsource：rental detail，rental detail。

harbor/rental/renewal_negotiation_repair_rental/environment/seeds/notification_hub/README.md

@@ -0,0 +1,19 @@
+# notification_hub env for renewal_negotiation_repair_rental
+
+rental detail：renewalrental detailrepair responsibilityrental detail。rental detail 2026-07-12 rental detail 2026-08-16，rental detail Asia/Shanghai。
+
+rental detail：rr007_current_home、rr007_low_price_risk、rr007_backup_viable、pl_rr007_work、pl_rr007_current、pl_rr007_backup、rv_rr007_current、rv_rr007_backup。rental detaillistingrental detail、commute、repairrisk、rental detail、statusrefreshrental detailfinal archive。
+
+rental detail task/rubric rental detail：rubric rental detailtool trace、rental detailstatusrental detail agent rental detailrefresh、rental detailchangerental detail。
+
+statusrental detail：rental detail minor CNYrental detail；850000 rental detail 8500 CNY。statusrental detail active、delisted、pending、draft rental detail。
+
+rental detail：
+
+| rental detail | rental detail | rental detail | rental detail/check | rental detail | rental detail |
+|---|---|---:|---|---|---|
+| `notifications` | rental detail | 220 | renewalrental detail、repair responsibility、commute/rental detail/rental detail/notificationrental detail | rental detailretainrental detailprice、rental detail、ID、rental detailstatusrental detail，rental detailevidencestillrental detail | rental detail |
+
+rental detail smoke test：server rental detail init.sql；rental detail MCP list/search/get toolreadrental detail。
+
+rental detailsource：rental detail，rental detail。

harbor/rental/renewal_negotiation_repair_rental/environment/seeds/notion/README.md

@@ -0,0 +1,20 @@
+# notion env for renewal_negotiation_repair_rental
+
+rental detail：rental detailrental housingworkspacerental detailnoise，agent rental detail tracker、budget、risk、auth、lease rental detail final rental detail。rental detail 2026-07-12 rental detail 2026-08-16，rental detail Asia/Shanghai。
+
+rental detail task/rubric rental detail：Notion rental detaillistingrental detailentrance，rental detailstatusrental detail；seed rental detailonlyrental detailrental housingrental detailnoise，rental detail `rr007_current_home`、`rr007_backup_viable`、850000/858000 rental detailquoteconclusion。checker stillrental detail stage-local notion tool trace、workspace rental detail MCP rental detail agent rental detail。
+
+statusrental detail：pages rental detail `reference/background/archive/noise` rental detailstatus；rental detail Notion seed。
+
+rental detail：
+
+| rental detail | rental detail | rental detail | rental detail/check | rental detail | rental detail |
+|---|---|---:|---|---|---|
+| `pages` | rental detail | 221 | Notion rental detailstatusrental detail、rental detailnoise / `s0_*`、`s2_tracker_persisted`、`s5_*`、`s20_*`、`s23_*` | 220 rental detailonlyrental detailrental housingrental detaildo not、statusrental detailcity，rental detaillisting ID、quoterental detailconclusion；agent rental detail last_edited_time updatedrental detail | rental detail |
+| `users` | rental detail | 1 | rental detail | rental detail | rental detail |
+| `workspaces` | rental detail | 1 | rental detail | rental detail | rental detail |
+| `counters` | rental detail | 1 | rental detail | rental detail | rental detail |
+
+rental detail smoke test：server rental detail init.sql；rental detail `API-post-search` searchrental detail，rental detail agent rental detailupdatedrental detail last_edited_time rental detailnoisebefore。
+
+rental detailsource：rental detail，rental detail。

harbor/rental/renewal_negotiation_repair_rental/environment/seeds/review_platform/README.md

@@ -0,0 +1,19 @@
+# review_platform env for renewal_negotiation_repair_rental
+
+rental detail：renewalrental detailrepair responsibilityrental detail。rental detail 2026-07-12 rental detail 2026-08-16，rental detail Asia/Shanghai。
+
+rental detail：rr007_current_home、rr007_low_price_risk、rr007_backup_viable、pl_rr007_work、pl_rr007_current、pl_rr007_backup、rv_rr007_current、rv_rr007_backup。rental detaillistingrental detail、commute、repairrisk、rental detail、statusrefreshrental detailfinal archive。
+
+rental detail task/rubric rental detail：rubric rental detailtool trace、rental detailstatusrental detail agent rental detailrefresh、rental detailchangerental detail。
+
+statusrental detail：rental detail minor CNYrental detail；850000 rental detail 8500 CNY。statusrental detail active、delisted、pending、draft rental detail。
+
+rental detail：
+
+| rental detail | rental detail | rental detail | rental detail/check | rental detail | rental detail |
+|---|---|---:|---|---|---|
+| `reviews` | rental detail | 445 | renewalrental detail、repair responsibility、commute/rental detail/rental detail/notificationrental detail | rental detailretainrental detailprice、rental detail、ID、rental detailstatusrental detail，rental detailevidencestillrental detail | rental detail |
+
+rental detail smoke test：server rental detail init.sql；rental detail MCP list/search/get toolreadrental detail。
+
+rental detailsource：rental detail，rental detail。

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/.gitignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.venv/
+.uv/
+*.db
+*.db-wal
+*.db-shm
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+build/
+dist/

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+COPY pyproject.toml README.md ./
+COPY src ./src
+RUN pip install --no-cache-dir .
+
+EXPOSE 8000
+
+ENTRYPOINT ["/bin/sh", "-c", "mkdir -p /env && cp -r /env-seed/. /env/ && exec calendar-mock --host 0.0.0.0 --port 8000 --env /env"]

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mock-env contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/README.md

@@ -0,0 +1,83 @@
+# calendar-mock
+
+A FastMCP-based, fully-offline mock of a Google-Calendar-style backend. Runs
+over **streamable-HTTP** (no stdio) with a local SQLite database. Replaces
+the legacy Node + PostgreSQL `Calendar-Autoauth-MCP-Server` with the same
+agent-facing surface.
+
+See [SPEC.md](./SPEC.md) for the full implementer-facing specification.
+
+## Tools (agent-facing)
+
+- `list_calendars(user_id)` — calendars owned by a user.
+- `list_events(time_min?, time_max?, calendar_id?, max_results=20, order_by="startTime")`
+- `get_event(event_id, calendar_id?)` — full detail incl. attendees + reminders.
+- `create_event(summary, start, end, description?, location?, calendar_id?, attendees?, reminders?)`
+- `update_event(event_id, summary?, start?, end?, description?, location?, calendar_id?, status?)`
+- `delete_event(event_id, calendar_id?)`
+- `search_events(query, time_min?, time_max?, max_results=50)` — substring
+  match over summary / description / location / attendee email or name.
+
+No admin tool / no clock. Recurring events store an `recurrence_rule` for
+round-tripping but are not auto-materialized — env init.sql is responsible
+for inserting whichever concrete child rows the task needs.
+
+`start` / `end` are ISO 8601 datetimes (e.g. `2026-05-08T18:30:00+08:00`).
+
+## Quick start
+
+### Direct (Python)
+
+```bash
+# From this directory
+pip install -e .
+
+# Run against the bundled env.
+calendar-mock \
+  --port 8000 \
+  --env ../../envs/calendar/li_wei_may
+```
+
+The server writes a fresh `runtime.db` inside the env directory on every
+cold start, applies the bundled schema, then executes
+`<env>/init.sql` if present.
+
+### Docker
+
+```bash
+docker build -t calendar-mock .
+docker run --rm -p 8000:8000 \
+  -v $PWD/../../envs/calendar/li_wei_may:/env-seed:ro \
+  calendar-mock
+```
+
+The streamable-HTTP endpoint is at `http://<host>:<port>/mcp`.
+
+## CLI flags
+
+- `--host` (default `0.0.0.0`)
+- `--port` (pass `8000` for Docker/Terrarium parity)
+- `--env PATH` — env directory (`runtime.db` lives inside; optional `init.sql` is applied)
+- `--debug` — verbose logging
+
+To boot stateless, point `--env` at `../../envs/calendar/empty`.
+
+## Smoke test
+
+```bash
+python3 scripts/smoke_http.py
+```
+
+Spins up the server in a subprocess on a free port, applies
+`envs/calendar/li_wei_may/init.sql`, and round-trips
+`list_calendars`, `list_events`, `get_event`, `search_events`,
+`create_event`, `update_event`, `delete_event`, plus error paths. Prints
+`PASS` or `FAIL`.
+
+## Errors
+
+Every tool returns valid JSON. Errors come back as
+`{"error": "<msg>", "code": "<CODE>"}` — never as exceptions. Stable codes:
+
+`EVENT_NOT_FOUND`, `CALENDAR_NOT_FOUND`, `BAD_TIME_RANGE`, `BAD_DATE`,
+`OVERLAPPING_EVENT`, `BAD_ARG`.

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/SPEC.md

@@ -0,0 +1,196 @@
+# calendar_mock — Specification
+
+Status: v1 (implementer-facing)
+Scope: implementation spec for the `calendar-mock` MCP server.
+
+## 1. Purpose
+
+`calendar_mock` is a self-contained, fully-offline mock of a
+Google-Calendar-style backend — calendars, events, attendees, reminders,
+recurring rules. It replaces the legacy Node+PostgreSQL
+`Calendar-Autoauth-MCP-Server` with the same agent surface so that
+benchmark tasks can exercise an agent's ability to read schedule state,
+create/update/delete events, search across events, and react to
+deterministic state changes the task orchestrator injects via out-of-band
+SQL mutations.
+
+The server makes **no** network calls and ships **no** bundled seed data —
+state enters only through `<env>/init.sql` (v3 contract).
+
+Non-goals:
+
+- No real Google Calendar API. Field names mirror the Google shape where
+  it's free, but the server is not API-compatible.
+- No multi-user permissions or sharing. Identity is whatever the caller
+  passes as `user_id` on `list_calendars`.
+- No timezone math beyond storing the string. ISO 8601 with an offset is
+  the input/output form.
+- No i18n.
+
+## 2. Stack
+
+- Python ≥ 3.12, stdlib `sqlite3`, `fastmcp ≥ 2.10.5`, `mcp[cli] ≥ 1.11.0`.
+- No network libraries in the package.
+- Transport: **streamable-HTTP only** at path `/mcp`. No stdio.
+
+## 3. Tools
+
+All tools are `async def`, return `json.dumps(result, ensure_ascii=False)`,
+and surface errors as `{"error": "...", "code": "..."}` rather than raising
+across the MCP boundary. Datetimes are ISO 8601 strings; dates are
+`YYYY-MM-DD`. IDs are domain-prefixed strings (`cal_…`, `evt_…`).
+
+### 3.1 `list_calendars(user_id) -> str`
+
+```json
+[
+  {"calendar_id": "cal_000001", "user_id": "usr_li_wei",
+   "name": "Personal", "color": "#4285F4", "timezone": "Asia/Shanghai",
+   "is_primary": true, "created_at": "2024-01-01T00:00:00Z"},
+  ...
+]
+```
+
+Order: `is_primary DESC, created_at ASC, calendar_id ASC`.
+
+### 3.2 `list_events(time_min?, time_max?, calendar_id?, max_results=20, order_by="startTime") -> str`
+
+Returns events overlapping the half-open window `[time_min, time_max)`.
+An event overlaps the window if `end_dt > time_min AND start_dt < time_max`.
+Without `time_min`/`time_max` no bound is applied. `calendar_id`, if
+present, scopes to a single calendar. `order_by` is one of `startTime`
+(ASC) or `updated` (DESC). `max_results` defaults to 20, clamped to 500.
+
+Each item has the same shape as `get_event` below.
+
+### 3.3 `get_event(event_id, calendar_id?) -> str`
+
+Full event detail, attendees + reminders included.
+
+```json
+{
+  "event_id": "evt_00000001",
+  "calendar_id": "cal_000001",
+  "summary": "Mom's birthday",
+  "description": "...",
+  "location": "...",
+  "start": {"dateTime": "2026-05-08T18:30:00+08:00"},
+  "end":   {"dateTime": "2026-05-08T21:00:00+08:00"},
+  "all_day": false,
+  "status": "confirmed",
+  "created_at": "2026-04-01T09:00:00Z",
+  "updated_at": "2026-04-01T09:00:00Z",
+  "recurrence_rule": null,
+  "parent_event_id": null,
+  "attendees": [
+    {"email": "zhangfang@example.com", "name": "Mom", "response_status": "accepted"},
+    ...
+  ],
+  "reminders": [
+    {"method": "email", "minutes_before": 1440},
+    {"method": "popup", "minutes_before": 60}
+  ]
+}
+```
+
+If `calendar_id` is supplied and does not match, returns `EVENT_NOT_FOUND`.
+
+### 3.4 `create_event(summary, start, end, description?, location?, calendar_id?, attendees?, reminders?) -> str`
+
+`start` and `end` are ISO 8601 datetime strings. `end` must be strictly
+after `start` (`BAD_TIME_RANGE` otherwise). If `calendar_id` is omitted
+the user's primary calendar is used; if no primary exists the oldest
+calendar wins. If no calendars exist at all, `BAD_ARG`.
+
+`attendees` is `[{email, name?, response_status?}]` where
+`response_status` ∈ `{needsAction, accepted, declined, tentative}`
+(default `needsAction`).
+
+`reminders` is `[{minutes_before, method?}]` where `method` ∈
+`{popup, email}` (default `popup`) and `minutes_before` is a non-negative
+integer.
+
+Returns the same shape as `get_event`.
+
+### 3.5 `update_event(event_id, summary?, start?, end?, description?, location?, calendar_id?, status?) -> str`
+
+Only the supplied fields change. `description` and `location` accept the
+empty string to clear the value (the field is overwritten only when the
+argument is explicitly provided — `None` means "don't touch"). If both
+`start` and `end` are touched they're validated together; if only one is
+touched, validation uses the existing value of the other.
+
+`status` ∈ `{confirmed, tentative, cancelled}`. To move an event between
+calendars set `calendar_id`. Returns the updated event.
+
+### 3.6 `delete_event(event_id, calendar_id?) -> str`
+
+Hard delete. Cascades to `attendees` and `reminders` via FK. If
+`calendar_id` is supplied and does not match, returns `EVENT_NOT_FOUND`.
+
+```json
+{"event_id": "evt_...", "deleted": true}
+```
+
+### 3.7 `search_events(query, time_min?, time_max?, max_results=50) -> str`
+
+Case-insensitive substring match across `summary`, `description`,
+`location`, and joined `attendees.email`/`attendees.name`. Optional
+time-window restricts to overlap (same predicate as `list_events`). Same
+return shape as `list_events`.
+
+## 4. Storage
+
+SQLite, one file per server (`<env>/runtime.db`). `PRAGMA foreign_keys=ON; PRAGMA journal_mode=WAL`.
+
+| table        | purpose                                                              |
+| ------------ | -------------------------------------------------------------------- |
+| `calendars`  | per-user calendars                                                   |
+| `events`     | event rows; `recurrence_rule` is stored verbatim (no materialization) |
+| `attendees`  | per-event invitee rows; cascade-deleted with the event               |
+| `reminders`  | per-event reminders; cascade-deleted with the event                  |
+| `_counters`  | atomic seq counters used to mint stable IDs                          |
+
+Indices: `(calendar_id, start_dt)` and `start_dt` on `events`,
+`parent_event_id` on `events`, `event_id` on `attendees` / `reminders`.
+
+The server carries no notion of "today"; date comparisons fall back to the
+literal datetime strings the agent supplies.
+
+## 5. State injection
+
+On cold start the server writes a fresh `<env>/runtime.db`, applies the
+bundled schema, then executes `<env>/init.sql` if present. The package
+ships no bundled seed data.
+
+## 6. Stage progression
+
+No in-server clock walk. Date-keyed rows are pre-baked by `init.sql`.
+Stage transitions arrive through the orchestrator's event-overlay
+channel as raw SQL applied directly against `runtime.db`.
+
+## 7. Logging & ops
+
+- `logging.getLogger(__name__)` everywhere; handler attached to stderr only.
+- No `print()` in the package.
+
+## 8. Appendix — error codes
+
+| code                | meaning                                                              |
+| ------------------- | -------------------------------------------------------------------- |
+| `EVENT_NOT_FOUND`   | `event_id` does not exist (or does not belong to `calendar_id`)      |
+| `CALENDAR_NOT_FOUND`| `calendar_id` does not exist                                         |
+| `BAD_TIME_RANGE`    | `end` is not strictly after `start`                                  |
+| `BAD_DATE`          | non-ISO date/datetime string                                         |
+| `OVERLAPPING_EVENT` | reserved (not raised in v1)                                          |
+| `BAD_ARG`           | catch-all for malformed inputs                                       |
+
+## 9. Out of scope
+
+- No iCalendar import / export.
+- No RRULE expansion. `recurrence_rule` is stored verbatim for round-tripping; the server does not materialize child instances.
+- No pagination cursors (`max_results` only).
+- No conflict detection between events (the `OVERLAPPING_EVENT` code is
+  reserved for a future version).
+- No real auth, no permission enforcement beyond `user_id` scoping on
+  `list_calendars`.

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "calendar-mock"
+version = "0.1.0"
+description = "FastMCP-based mock Google-Calendar-style server (SQLite, streamable-HTTP, offline)"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "fastmcp>=2.10.5",
+    "mcp[cli]>=1.11.0,<2.0.0",
+    "typing-extensions>=4.9.0",
+]
+
+[project.scripts]
+calendar-mock = "calendar_mock.server:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/calendar_mock"]
+
+[tool.hatch.build]
+include = [
+    "src/calendar_mock/**/*.py",
+]

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/__main__.py

@@ -0,0 +1,4 @@
+from .server import main
+
+if __name__ == "__main__":
+    main()

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/backends/__init__.py

@@ -0,0 +1,7 @@
+from .db import get_conn, init_schema, next_counter
+
+__all__ = [
+    "get_conn",
+    "init_schema",
+    "next_counter",
+]

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/backends/db.py

@@ -0,0 +1,118 @@
+"""SQLite backend for calendar_mock.
+
+Schema-only — no bundled seed data. State is injected by callers via
+``<env>/init.sql`` (INSERTs run after schema creation).
+
+v3: dropped the simulated-clock singleton and the recurrence-materialized
+log table. Recurring
+events still carry an ``recurrence_rule`` column for round-tripping
+through ``get_event``, but expansion is not performed by the server —
+init.sql either pre-bakes the child rows directly or the agent treats
+recurring rows as opaque single events.
+"""
+import logging
+import os
+import sqlite3
+
+logger = logging.getLogger(__name__)
+
+
+SCHEMA_SQL = """
+CREATE TABLE IF NOT EXISTS calendars (
+  calendar_id   TEXT PRIMARY KEY,
+  user_id       TEXT NOT NULL,
+  name          TEXT NOT NULL,
+  color         TEXT,
+  timezone      TEXT NOT NULL DEFAULT 'UTC',
+  is_primary    INTEGER NOT NULL DEFAULT 0,
+  created_at    TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_calendars_user ON calendars(user_id);
+
+CREATE TABLE IF NOT EXISTS events (
+  event_id        TEXT PRIMARY KEY,
+  calendar_id     TEXT NOT NULL,
+  summary         TEXT NOT NULL,
+  description     TEXT,
+  location        TEXT,
+  start_dt        TEXT NOT NULL,
+  end_dt          TEXT NOT NULL,
+  all_day         INTEGER NOT NULL DEFAULT 0,
+  status          TEXT NOT NULL CHECK(status IN ('confirmed','tentative','cancelled')) DEFAULT 'confirmed',
+  created_at      TEXT NOT NULL,
+  updated_at      TEXT NOT NULL,
+  recurrence_rule TEXT,
+  parent_event_id TEXT,
+  FOREIGN KEY (calendar_id) REFERENCES calendars(calendar_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_calendar_start ON events(calendar_id, start_dt);
+CREATE INDEX IF NOT EXISTS idx_events_start ON events(start_dt);
+CREATE INDEX IF NOT EXISTS idx_events_parent ON events(parent_event_id);
+
+CREATE TABLE IF NOT EXISTS attendees (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  event_id        TEXT NOT NULL,
+  email           TEXT NOT NULL,
+  name            TEXT,
+  response_status TEXT NOT NULL CHECK(response_status IN
+                    ('needsAction','accepted','declined','tentative')) DEFAULT 'needsAction',
+  FOREIGN KEY (event_id) REFERENCES events(event_id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_attendees_event ON attendees(event_id);
+
+CREATE TABLE IF NOT EXISTS reminders (
+  id             INTEGER PRIMARY KEY AUTOINCREMENT,
+  event_id       TEXT NOT NULL,
+  method         TEXT NOT NULL CHECK(method IN ('popup','email')) DEFAULT 'popup',
+  minutes_before INTEGER NOT NULL,
+  FOREIGN KEY (event_id) REFERENCES events(event_id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_reminders_event ON reminders(event_id);
+
+CREATE TABLE IF NOT EXISTS _counters (
+  key   TEXT PRIMARY KEY,
+  value INTEGER NOT NULL DEFAULT 0
+);
+"""
+
+
+def get_conn(db_path: str) -> sqlite3.Connection:
+    """Open a SQLite connection with the project's PRAGMA defaults."""
+    parent = os.path.dirname(os.path.abspath(db_path))
+    if parent:
+        os.makedirs(parent, exist_ok=True)
+    conn = sqlite3.connect(db_path, isolation_level=None, check_same_thread=False)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA foreign_keys = ON;")
+    conn.execute("PRAGMA journal_mode = WAL;")
+    conn.execute("PRAGMA synchronous = NORMAL;")
+    # Out-wait an external writer (the task world-controller holds
+    # BEGIN IMMEDIATE across service databases with its own 10s busy_timeout).
+    # Without this the server inherits sqlite3's 5s default and loses the race,
+    # surfacing "database is locked" for a write that would have succeeded.
+    conn.execute("PRAGMA busy_timeout = 20000;")
+    return conn
+
+
+def init_schema(conn: sqlite3.Connection) -> None:
+    """Create schema (idempotent)."""
+    conn.executescript(SCHEMA_SQL)
+
+
+def next_counter(conn: sqlite3.Connection, key: str) -> int:
+    """Atomically bump and return a counter's new value."""
+    conn.execute(
+        "INSERT INTO _counters (key, value) VALUES (?, 0) ON CONFLICT(key) DO NOTHING",
+        (key,),
+    )
+    conn.execute(
+        "UPDATE _counters SET value = value + 1 WHERE key = ?", (key,)
+    )
+    row = conn.execute(
+        "SELECT value FROM _counters WHERE key = ?", (key,)
+    ).fetchone()
+    return int(row["value"])

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/models/__init__.py

@@ -0,0 +1,9 @@
+from .calendar import Calendar
+from .event import Event, Attendee, Reminder
+
+__all__ = [
+    "Calendar",
+    "Event",
+    "Attendee",
+    "Reminder",
+]

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/models/calendar.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class Calendar:
+    """A named calendar owned by a user (e.g. 'Personal', 'Work')."""
+    calendar_id: str
+    user_id: str
+    name: str
+    color: Optional[str]
+    timezone: str
+    is_primary: bool
+    created_at: str

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/models/event.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class Event:
+    """A calendar event. ``start_dt`` / ``end_dt`` are ISO 8601 strings."""
+    event_id: str
+    calendar_id: str
+    summary: str
+    description: Optional[str]
+    location: Optional[str]
+    start_dt: str
+    end_dt: str
+    all_day: bool
+    status: str  # confirmed | tentative | cancelled
+    created_at: str
+    updated_at: str
+    recurrence_rule: Optional[str]
+    parent_event_id: Optional[str] = None
+
+
+@dataclass
+class Attendee:
+    """An invitee on an event."""
+    id: int
+    event_id: str
+    email: str
+    name: Optional[str]
+    response_status: str  # needsAction | accepted | declined | tentative
+
+
+@dataclass
+class Reminder:
+    """A pre-event reminder for the calendar owner."""
+    id: int
+    event_id: str
+    method: str  # popup | email
+    minutes_before: int

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/server.py

@@ -0,0 +1,99 @@
+"""calendar_mock MCP server entry point (streamable-HTTP transport only)."""
+import argparse
+import logging
+import os
+import sys
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+from .backends import get_conn, init_schema
+from .services import CalendarService, EventService
+from .tools import register_calendar_tools, register_event_tools
+
+
+def setup_logging(debug: bool = False) -> None:
+    level = logging.DEBUG if debug else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        handlers=[logging.StreamHandler(sys.stderr)],
+        force=True,
+    )
+
+
+def build_server(env_dir: Path) -> FastMCP:
+    """Open a fresh runtime DB inside the env, apply schema + init.sql, return FastMCP."""
+    logger = logging.getLogger(__name__)
+
+    db_file = env_dir / "runtime.db"
+    for sidecar in (db_file, db_file.with_suffix(db_file.suffix + "-wal"),
+                    db_file.with_suffix(db_file.suffix + "-shm")):
+        if sidecar.exists():
+            sidecar.unlink()
+
+    conn = get_conn(str(db_file))
+    init_schema(conn)
+
+    init_sql = env_dir / "init.sql"
+    if init_sql.exists():
+        logger.info("Applying init_sql from %s", init_sql)
+        conn.executescript(init_sql.read_text(encoding="utf-8"))
+
+    calendar_service = CalendarService(conn)
+    event_service = EventService(conn)
+
+    mcp = FastMCP("calendar-mock", host="0.0.0.0")
+    register_calendar_tools(mcp, calendar_service)
+    register_event_tools(mcp, event_service)
+    return mcp
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="calendar_mock MCP server (streamable-HTTP)")
+    parser.add_argument("--host", default="0.0.0.0")
+    parser.add_argument("--port", type=int, default=8007)
+    parser.add_argument(
+        "--env", type=str, default=os.environ.get("XHS_ENV"),
+        help="Path to envs/<server>/<env_name>/ directory (falls back to $XHS_ENV)",
+    )
+    parser.add_argument("--transport", choices=["streamable-http", "stdio"],
+                        default="streamable-http",
+                        help="streamable-http for Terrarium/containers; stdio for local .mcp.json debugging")
+    parser.add_argument("--debug", action="store_true")
+    args = parser.parse_args()
+
+    setup_logging(args.debug)
+    logger = logging.getLogger(__name__)
+
+    if not args.env:
+        parser.error("--env is required (pass --env <dir> or set $XHS_ENV)")
+    env_dir = Path(args.env).resolve()
+    if not env_dir.is_dir():
+        logger.error("env path is not a directory: %s", env_dir)
+        sys.exit(2)
+
+    try:
+        mcp = build_server(env_dir)
+        if args.transport == "stdio":
+            logger.info("Starting calendar-mock on stdio (env=%s)", env_dir)
+            mcp.run(transport="stdio")
+        else:
+            mcp.settings.host = args.host
+            mcp.settings.port = args.port
+            logger.info(
+                "Starting calendar-mock on http://%s:%d/mcp (streamable-http, env=%s)",
+                args.host,
+                args.port,
+                env_dir,
+            )
+            mcp.run(transport="streamable-http")
+    except KeyboardInterrupt:
+        logger.info("Server shutdown requested")
+    except Exception as e:
+        logger.exception("Server startup failed: %s", e)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/services/__init__.py

@@ -0,0 +1,7 @@
+from .calendar_service import CalendarService
+from .event_service import EventService
+
+__all__ = [
+    "CalendarService",
+    "EventService",
+]

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/services/_common.py

@@ -0,0 +1,95 @@
+"""Shared row-formatting helpers for calendar services."""
+import sqlite3
+from typing import List, Optional
+
+from ..utils.exceptions import CalendarNotFoundError, EventNotFoundError
+
+
+def fetch_calendar(conn: sqlite3.Connection, calendar_id: str) -> sqlite3.Row:
+    row = conn.execute(
+        "SELECT * FROM calendars WHERE calendar_id = ?", (calendar_id,)
+    ).fetchone()
+    if not row:
+        raise CalendarNotFoundError(f"calendar not found: {calendar_id}")
+    return row
+
+
+def fetch_event_row(
+    conn: sqlite3.Connection,
+    event_id: str,
+    calendar_id: Optional[str] = None,
+) -> sqlite3.Row:
+    if calendar_id:
+        row = conn.execute(
+            "SELECT * FROM events WHERE event_id = ? AND calendar_id = ?",
+            (event_id, calendar_id),
+        ).fetchone()
+    else:
+        row = conn.execute(
+            "SELECT * FROM events WHERE event_id = ?", (event_id,)
+        ).fetchone()
+    if not row:
+        raise EventNotFoundError(f"event not found: {event_id}")
+    return row
+
+
+def load_attendees(conn: sqlite3.Connection, event_id: str) -> List[dict]:
+    rows = conn.execute(
+        "SELECT email, name, response_status FROM attendees "
+        "WHERE event_id = ? ORDER BY id ASC",
+        (event_id,),
+    ).fetchall()
+    return [
+        {
+            "email": r["email"],
+            "name": r["name"],
+            "response_status": r["response_status"],
+        }
+        for r in rows
+    ]
+
+
+def load_reminders(conn: sqlite3.Connection, event_id: str) -> List[dict]:
+    rows = conn.execute(
+        "SELECT method, minutes_before FROM reminders "
+        "WHERE event_id = ? ORDER BY minutes_before DESC, id ASC",
+        (event_id,),
+    ).fetchall()
+    return [
+        {"method": r["method"], "minutes_before": int(r["minutes_before"])}
+        for r in rows
+    ]
+
+
+def format_event(conn: sqlite3.Connection, row: sqlite3.Row) -> dict:
+    """Format a DB event row + its attendees/reminders into the JSON shape."""
+    event_id = row["event_id"]
+    return {
+        "event_id": event_id,
+        "calendar_id": row["calendar_id"],
+        "summary": row["summary"],
+        "description": row["description"],
+        "location": row["location"],
+        "start": {"dateTime": row["start_dt"]},
+        "end": {"dateTime": row["end_dt"]},
+        "all_day": bool(int(row["all_day"])),
+        "status": row["status"],
+        "created_at": row["created_at"],
+        "updated_at": row["updated_at"],
+        "recurrence_rule": row["recurrence_rule"],
+        "parent_event_id": row["parent_event_id"],
+        "attendees": load_attendees(conn, event_id),
+        "reminders": load_reminders(conn, event_id),
+    }
+
+
+def format_calendar(row: sqlite3.Row) -> dict:
+    return {
+        "calendar_id": row["calendar_id"],
+        "user_id": row["user_id"],
+        "name": row["name"],
+        "color": row["color"],
+        "timezone": row["timezone"],
+        "is_primary": bool(int(row["is_primary"])),
+        "created_at": row["created_at"],
+    }

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/services/calendar_service.py

@@ -0,0 +1,27 @@
+"""Calendar listing service."""
+import logging
+import sqlite3
+from typing import List
+
+from ..utils.exceptions import BadArgError
+from ._common import format_calendar
+
+logger = logging.getLogger(__name__)
+
+
+class CalendarService:
+    def __init__(self, conn: sqlite3.Connection) -> None:
+        self.conn = conn
+
+    def list_calendars(self, user_id: str) -> List[dict]:
+        if not user_id:
+            raise BadArgError("user_id is required")
+        rows = self.conn.execute(
+            """
+            SELECT calendar_id, user_id, name, color, timezone, is_primary, created_at
+            FROM calendars WHERE user_id = ?
+            ORDER BY is_primary DESC, created_at ASC, calendar_id ASC
+            """,
+            (user_id,),
+        ).fetchall()
+        return [format_calendar(r) for r in rows]

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/services/event_service.py

@@ -0,0 +1,320 @@
+"""Event CRUD + listing/search service."""
+import logging
+import sqlite3
+from typing import List, Optional
+
+from ..backends.db import next_counter
+from ..utils.dates import (
+    assert_time_range,
+    now_iso_z,
+    parse_datetime,
+    to_storage_offset,
+)
+from ..utils.exceptions import BadArgError
+from ..utils.ids import event_id as make_event_id
+from ._common import (
+    fetch_calendar,
+    fetch_event_row,
+    format_event,
+)
+
+logger = logging.getLogger(__name__)
+
+VALID_STATUS = ("confirmed", "tentative", "cancelled")
+VALID_ATTENDEE_RESPONSE = ("needsAction", "accepted", "declined", "tentative")
+VALID_REMINDER_METHOD = ("popup", "email")
+VALID_ORDER_BY = ("startTime", "updated")
+
+
+class EventService:
+    def __init__(self, conn: sqlite3.Connection) -> None:
+        self.conn = conn
+
+    # ---- list / get / search --------------------------------------------
+    def list_events(
+        self,
+        time_min: Optional[str] = None,
+        time_max: Optional[str] = None,
+        calendar_id: Optional[str] = None,
+        max_results: int = 20,
+        order_by: str = "startTime",
+        page: int = 1,
+    ) -> dict:
+        if order_by not in VALID_ORDER_BY:
+            raise BadArgError(f"order_by must be one of {VALID_ORDER_BY}")
+        if max_results is None or int(max_results) < 1:
+            raise BadArgError("max_results must be >= 1")
+        max_results = min(int(max_results), 500)
+        if page is None or page < 1:
+            raise BadArgError("page must be >= 1")
+        # Validate, then rewrite each bound into the stored offset so the TEXT
+        # comparison below matches on the instant rather than on the spelling.
+        if time_min:
+            time_min = to_storage_offset(time_min)
+        if time_max:
+            time_max = to_storage_offset(time_max)
+        if calendar_id:
+            fetch_calendar(self.conn, calendar_id)
+
+        # `max_results` is a page size, not a data-loss cap: the matching set is
+        # materialised as a COUNT first, then sliced, and `has_more` signals
+        # whether a later page exists.
+        where = ["1=1"]
+        args: List = []
+        if calendar_id:
+            where.append("calendar_id = ?")
+            args.append(calendar_id)
+        if time_min:
+            # An event overlaps the window if its end is after time_min.
+            where.append("end_dt > ?")
+            args.append(time_min)
+        if time_max:
+            where.append("start_dt < ?")
+            args.append(time_max)
+
+        total = int(self.conn.execute(
+            f"SELECT COUNT(*) AS n FROM events WHERE {' AND '.join(where)}", args
+        ).fetchone()["n"])
+
+        if order_by == "updated":
+            order = "ORDER BY updated_at DESC, event_id DESC"
+        else:
+            order = "ORDER BY start_dt ASC, event_id ASC"
+
+        offset = (page - 1) * max_results
+        rows = self.conn.execute(
+            f"SELECT * FROM events WHERE {' AND '.join(where)} {order} LIMIT ? OFFSET ?",
+            args + [max_results, offset],
+        ).fetchall()
+        return {
+            "items": [format_event(self.conn, r) for r in rows],
+            "total": total,
+            "page": int(page),
+            "page_size": max_results,
+            "has_more": page * max_results < total,
+        }
+
+    def get_event(
+        self, event_id: str, calendar_id: Optional[str] = None
+    ) -> dict:
+        row = fetch_event_row(self.conn, event_id, calendar_id)
+        return format_event(self.conn, row)
+
+    def search_events(
+        self,
+        query: str,
+        time_min: Optional[str] = None,
+        time_max: Optional[str] = None,
+        max_results: int = 50,
+        page: int = 1,
+    ) -> dict:
+        if not query or not isinstance(query, str):
+            raise BadArgError("query is required")
+        # Validate, then rewrite each bound into the stored offset so the TEXT
+        # comparison below matches on the instant rather than on the spelling.
+        if time_min:
+            time_min = to_storage_offset(time_min)
+        if time_max:
+            time_max = to_storage_offset(time_max)
+        max_results = min(max(int(max_results or 50), 1), 500)
+        if page is None or page < 1:
+            raise BadArgError("page must be >= 1")
+        like = f"%{query.lower()}%"
+
+        where = (
+            "(LOWER(COALESCE(e.summary,'')) LIKE ? "
+            " OR LOWER(COALESCE(e.description,'')) LIKE ? "
+            " OR LOWER(COALESCE(e.location,'')) LIKE ? "
+            " OR LOWER(COALESCE(a.email,'')) LIKE ? "
+            " OR LOWER(COALESCE(a.name,'')) LIKE ?)"
+        )
+        args: List = [like, like, like, like, like]
+        if time_min:
+            where += " AND e.end_dt > ?"
+            args.append(time_min)
+        if time_max:
+            where += " AND e.start_dt < ?"
+            args.append(time_max)
+
+        # The search joins attendees, so a matching event can fan out to many
+        # rows; COUNT(DISTINCT event_id) is the true size of the result set.
+        total = int(self.conn.execute(
+            "SELECT COUNT(DISTINCT e.event_id) AS n FROM events e "
+            "LEFT JOIN attendees a ON a.event_id = e.event_id "
+            f"WHERE {where}", args
+        ).fetchone()["n"])
+
+        offset = (page - 1) * max_results
+        rows = self.conn.execute(
+            "SELECT DISTINCT e.* FROM events e "
+            "LEFT JOIN attendees a ON a.event_id = e.event_id "
+            f"WHERE {where} ORDER BY e.start_dt ASC, e.event_id ASC LIMIT ? OFFSET ?",
+            args + [max_results, offset],
+        ).fetchall()
+        return {
+            "items": [format_event(self.conn, r) for r in rows],
+            "total": total,
+            "page": int(page),
+            "page_size": max_results,
+            "has_more": page * max_results < total,
+        }
+
+    # ---- create / update / delete ---------------------------------------
+    def create_event(
+        self,
+        summary: str,
+        start: str,
+        end: str,
+        description: Optional[str] = None,
+        location: Optional[str] = None,
+        calendar_id: Optional[str] = None,
+        attendees: Optional[List[dict]] = None,
+        reminders: Optional[List[dict]] = None,
+    ) -> dict:
+        if not summary or not isinstance(summary, str):
+            raise BadArgError("summary is required")
+        assert_time_range(start, end)
+        cal_id = self._resolve_calendar(calendar_id)
+        attendees = attendees or []
+        reminders = reminders or []
+        self._validate_attendees(attendees)
+        self._validate_reminders(reminders)
+
+        seq = next_counter(self.conn, "event_seq")
+        new_id = make_event_id(seq)
+        now = now_iso_z()
+        self.conn.execute(
+            """
+            INSERT INTO events
+              (event_id, calendar_id, summary, description, location,
+               start_dt, end_dt, all_day, status,
+               created_at, updated_at, recurrence_rule, parent_event_id)
+            VALUES (?, ?, ?, ?, ?, ?, ?, 0, 'confirmed', ?, ?, NULL, NULL)
+            """,
+            (new_id, cal_id, summary, description, location,
+             start, end, now, now),
+        )
+        for att in attendees:
+            self.conn.execute(
+                """
+                INSERT INTO attendees (event_id, email, name, response_status)
+                VALUES (?, ?, ?, ?)
+                """,
+                (new_id, att["email"], att.get("name"),
+                 att.get("response_status", "needsAction")),
+            )
+        for rem in reminders:
+            self.conn.execute(
+                """
+                INSERT INTO reminders (event_id, method, minutes_before)
+                VALUES (?, ?, ?)
+                """,
+                (new_id, rem.get("method", "popup"), int(rem["minutes_before"])),
+            )
+        row = fetch_event_row(self.conn, new_id)
+        return format_event(self.conn, row)
+
+    def update_event(
+        self,
+        event_id: str,
+        summary: Optional[str] = None,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        description: Optional[str] = None,
+        location: Optional[str] = None,
+        calendar_id: Optional[str] = None,
+        status: Optional[str] = None,
+    ) -> dict:
+        existing = fetch_event_row(self.conn, event_id)
+        new_start = start if start is not None else existing["start_dt"]
+        new_end = end if end is not None else existing["end_dt"]
+        if start is not None or end is not None:
+            assert_time_range(new_start, new_end)
+        if status is not None and status not in VALID_STATUS:
+            raise BadArgError(f"status must be one of {VALID_STATUS}")
+        new_cal = (
+            self._resolve_calendar(calendar_id)
+            if calendar_id is not None
+            else existing["calendar_id"]
+        )
+
+        self.conn.execute(
+            """
+            UPDATE events
+            SET summary = COALESCE(?, summary),
+                description = CASE WHEN ? = 1 THEN ? ELSE description END,
+                location    = CASE WHEN ? = 1 THEN ? ELSE location END,
+                start_dt = ?,
+                end_dt = ?,
+                calendar_id = ?,
+                status = COALESCE(?, status),
+                updated_at = ?
+            WHERE event_id = ?
+            """,
+            (
+                summary,
+                1 if description is not None else 0, description,
+                1 if location is not None else 0, location,
+                new_start, new_end, new_cal, status,
+                now_iso_z(), event_id,
+            ),
+        )
+        row = fetch_event_row(self.conn, event_id)
+        return format_event(self.conn, row)
+
+    def delete_event(
+        self, event_id: str, calendar_id: Optional[str] = None
+    ) -> dict:
+        fetch_event_row(self.conn, event_id, calendar_id)
+        self.conn.execute("DELETE FROM events WHERE event_id = ?", (event_id,))
+        return {"event_id": event_id, "deleted": True}
+
+    # ---- internals -------------------------------------------------------
+    def _resolve_calendar(self, calendar_id: Optional[str]) -> str:
+        if calendar_id:
+            fetch_calendar(self.conn, calendar_id)
+            return calendar_id
+        row = self.conn.execute(
+            "SELECT calendar_id FROM calendars WHERE is_primary = 1 "
+            "ORDER BY created_at ASC, calendar_id ASC LIMIT 1"
+        ).fetchone()
+        if row:
+            return row["calendar_id"]
+        row = self.conn.execute(
+            "SELECT calendar_id FROM calendars "
+            "ORDER BY created_at ASC, calendar_id ASC LIMIT 1"
+        ).fetchone()
+        if not row:
+            raise BadArgError(
+                "no calendars exist; pass calendar_id or seed one first"
+            )
+        return row["calendar_id"]
+
+    def _validate_attendees(self, attendees: List[dict]) -> None:
+        for att in attendees:
+            if not isinstance(att, dict) or "email" not in att:
+                raise BadArgError(
+                    "each attendee must be {email, name?, response_status?}"
+                )
+            rs = att.get("response_status", "needsAction")
+            if rs not in VALID_ATTENDEE_RESPONSE:
+                raise BadArgError(
+                    f"attendee response_status must be one of {VALID_ATTENDEE_RESPONSE}"
+                )
+
+    def _validate_reminders(self, reminders: List[dict]) -> None:
+        for rem in reminders:
+            if not isinstance(rem, dict) or "minutes_before" not in rem:
+                raise BadArgError(
+                    "each reminder must be {minutes_before, method?}"
+                )
+            method = rem.get("method", "popup")
+            if method not in VALID_REMINDER_METHOD:
+                raise BadArgError(
+                    f"reminder method must be one of {VALID_REMINDER_METHOD}"
+                )
+            try:
+                if int(rem["minutes_before"]) < 0:
+                    raise ValueError
+            except (TypeError, ValueError):
+                raise BadArgError("reminder minutes_before must be a non-negative integer")

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/tools/__init__.py

@@ -0,0 +1,7 @@
+from .calendar_tools import register_calendar_tools
+from .event_tools import register_event_tools
+
+__all__ = [
+    "register_calendar_tools",
+    "register_event_tools",
+]

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/tools/_common.py

@@ -0,0 +1,39 @@
+import functools
+import json
+import logging
+from typing import Any
+
+from ..utils.exceptions import CalendarMockError
+
+logger = logging.getLogger(__name__)
+
+
+def dumps(value: Any) -> str:
+    return json.dumps(value, ensure_ascii=False)
+
+
+def error_response(message: str, code: str) -> str:
+    return dumps({"error": message, "code": code})
+
+
+def handle_errors(fn):
+    """Decorator: map CalendarMockError to structured JSON responses.
+
+    Uses functools.wraps so FastMCP introspects the wrapped function's
+    real parameter signature (not the wrapper's ``*args, **kwargs``).
+    """
+    @functools.wraps(fn)
+    async def wrapper(*args, **kwargs):
+        try:
+            return await fn(*args, **kwargs)
+        except CalendarMockError as e:
+            logger.info("tool error [%s]: %s", e.code, e.message)
+            return error_response(e.message, e.code)
+        except Exception as e:  # pragma: no cover — defensive
+            # Not BAD_ARG: an unexpected exception here is a server-side fault
+            # (e.g. sqlite3.OperationalError "database is locked"), not a
+            # problem with the caller's arguments. Reporting it as BAD_ARG tells
+            # the agent to fix its input for a condition a retry would clear.
+            logger.exception("unexpected tool error")
+            return error_response(f"internal error: {e}", "INTERNAL")
+    return wrapper

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/tools/calendar_tools.py

@@ -0,0 +1,13 @@
+from mcp.server.fastmcp import FastMCP
+
+from ..services.calendar_service import CalendarService
+from ._common import dumps, handle_errors
+
+
+def register_calendar_tools(mcp: FastMCP, calendar_service: CalendarService) -> None:
+
+    @mcp.tool()
+    @handle_errors
+    async def list_calendars(user_id: str) -> str:
+        """List a user's calendars (e.g. Personal, Work). Returns id, name, color, timezone, and whether it is the primary."""
+        return dumps(calendar_service.list_calendars(user_id))

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/tools/event_tools.py

@@ -0,0 +1,119 @@
+from typing import Any, List, Optional
+
+from mcp.server.fastmcp import FastMCP
+
+from ..services.event_service import EventService
+from ._common import dumps, handle_errors
+
+
+def register_event_tools(mcp: FastMCP, event_service: EventService) -> None:
+
+    @mcp.tool()
+    @handle_errors
+    async def list_events(
+        time_min: Optional[str] = None,
+        time_max: Optional[str] = None,
+        calendar_id: Optional[str] = None,
+        max_results: int = 20,
+        order_by: str = "startTime",
+        page: int = 1,
+    ) -> str:
+        """List events overlapping a time window (ISO 8601). Optional `calendar_id` restricts to a single calendar; without it, all calendars are searched. `order_by` is `startTime` or `updated`. Paginated: `max_results` (1-500, default 20) is the page size, `page` (≥1) selects which page. Returns an envelope {items, total, page, page_size, has_more}; pass page=2,3,… while has_more is true to read the full result set."""
+        return dumps(
+            event_service.list_events(
+                time_min=time_min,
+                time_max=time_max,
+                calendar_id=calendar_id,
+                max_results=int(max_results),
+                order_by=order_by,
+                page=int(page),
+            )
+        )
+
+    @mcp.tool()
+    @handle_errors
+    async def get_event(
+        event_id: str, calendar_id: Optional[str] = None
+    ) -> str:
+        """Return full detail for a single event, including attendees and reminders. `calendar_id` is optional but, when supplied, scopes the lookup."""
+        return dumps(event_service.get_event(event_id, calendar_id))
+
+    @mcp.tool()
+    @handle_errors
+    async def create_event(
+        summary: str,
+        start: str,
+        end: str,
+        description: Optional[str] = None,
+        location: Optional[str] = None,
+        calendar_id: Optional[str] = None,
+        attendees: Optional[List[dict]] = None,
+        reminders: Optional[List[dict]] = None,
+    ) -> str:
+        """Create a new calendar event. `start`/`end` are ISO 8601 datetimes (e.g. `2026-05-10T09:00:00+08:00`). If `calendar_id` is omitted, the primary calendar is used. `attendees` is a list of `{email, name?, response_status?}` and `reminders` a list of `{minutes_before, method?}` where method is `popup` or `email`."""
+        return dumps(
+            event_service.create_event(
+                summary=summary,
+                start=start,
+                end=end,
+                description=description,
+                location=location,
+                calendar_id=calendar_id,
+                attendees=attendees,
+                reminders=reminders,
+            )
+        )
+
+    @mcp.tool()
+    @handle_errors
+    async def update_event(
+        event_id: str,
+        summary: Optional[str] = None,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        description: Optional[str] = None,
+        location: Optional[str] = None,
+        calendar_id: Optional[str] = None,
+        status: Optional[str] = None,
+    ) -> str:
+        """Patch an event. Only the supplied fields change. `status` is one of `confirmed`, `tentative`, `cancelled`. To move between calendars set `calendar_id`."""
+        return dumps(
+            event_service.update_event(
+                event_id=event_id,
+                summary=summary,
+                start=start,
+                end=end,
+                description=description,
+                location=location,
+                calendar_id=calendar_id,
+                status=status,
+            )
+        )
+
+    @mcp.tool()
+    @handle_errors
+    async def delete_event(
+        event_id: str, calendar_id: Optional[str] = None
+    ) -> str:
+        """Delete an event. Returns EVENT_NOT_FOUND if the id is unknown (or does not belong to the supplied calendar_id, if given)."""
+        return dumps(event_service.delete_event(event_id, calendar_id))
+
+    @mcp.tool()
+    @handle_errors
+    async def search_events(
+        query: str,
+        time_min: Optional[str] = None,
+        time_max: Optional[str] = None,
+        max_results: int = 50,
+        page: int = 1,
+    ) -> str:
+        """Substring search over event summary, description, location, and attendee name/email. Case-insensitive. Optional `time_min`/`time_max` (ISO 8601) restrict the window. Paginated: `max_results` (1-500, default 50) is the page size, `page` (≥1) selects which page. Returns an envelope {items, total, page, page_size, has_more}; pass page=2,3,… while has_more is true to read the full result set."""
+        return dumps(
+            event_service.search_events(
+                query=query,
+                time_min=time_min,
+                time_max=time_max,
+                max_results=int(max_results),
+                page=int(page),
+            )
+        )

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/utils/dates.py

@@ -0,0 +1,114 @@
+"""Date / datetime parsing helpers.
+
+Event start / end times are ISO 8601 datetimes (``YYYY-MM-DDTHH:MM:SS``
+with optional ``Z`` or ``±HH:MM`` offset). Stored as text and compared
+lexicographically thanks to the ISO ordering property.
+"""
+from datetime import date, datetime, timedelta, timezone
+from typing import Optional
+
+from .exceptions import BadDateError
+from .world_clock import now as _world_now, now_iso as _world_now_iso, now_iso_z as _world_now_iso_z, today_utc as _world_today_utc
+
+DATE_FMT = "%Y-%m-%d"
+
+
+def parse_date(s: str) -> date:
+    try:
+        return datetime.strptime(s, DATE_FMT).date()
+    except (TypeError, ValueError) as e:
+        raise BadDateError(f"invalid date '{s}': {e}")
+
+
+def fmt(d: date) -> str:
+    return d.strftime(DATE_FMT)
+
+
+def add_days(d: str, n: int) -> str:
+    return fmt(parse_date(d) + timedelta(days=n))
+
+
+def parse_datetime(s: str) -> datetime:
+    """Parse an ISO 8601 datetime. Accepts trailing ``Z`` (treated as UTC)
+    and ``±HH:MM`` offsets. Naive datetimes are returned as-is."""
+    if not isinstance(s, str) or not s:
+        raise BadDateError(f"invalid datetime: {s!r}")
+    txt = s.strip()
+    if txt.endswith("Z"):
+        txt = txt[:-1] + "+00:00"
+    try:
+        return datetime.fromisoformat(txt)
+    except ValueError as e:
+        raise BadDateError(f"invalid datetime '{s}': {e}")
+
+
+def datetime_to_iso(dt: datetime) -> str:
+    """Format ``dt`` as ISO 8601. Aware datetimes use ``+HH:MM``; naive
+    datetimes are written without an offset (caller's responsibility)."""
+    return dt.isoformat(timespec="seconds")
+
+
+# Datetime columns are TEXT and every ordering/range filter compares them as
+# strings, so a single stored offset form is required for those comparisons to
+# agree with real time. All seed data and every world-controller mutation write
+# +08:00; emitting Z here would sort every server-written row against the seed
+# purely on the offset character ('+' 0x2B < digits < 'Z' 0x5A) rather than on
+# the instant, silently inverting "newest first" and window filters.
+WRITE_TZ = timezone(timedelta(hours=8))
+
+
+def now_iso_z() -> str:
+    """Current time as an ISO 8601 string in the corpus offset (+08:00).
+
+    Named for the historical Z form it replaced; the name is kept so the
+    existing call sites stay untouched.
+    """
+    return _world_now_iso()
+
+
+def to_storage_offset(s: str) -> str:
+    """Rewrite an ISO datetime into the stored offset, preserving the instant.
+
+    Window filters compare against TEXT columns, so the comparison is a byte
+    comparison: the same instant written ``...T16:00:00Z`` and
+    ``...T00:00:00+08:00`` compares differently even though both are legal
+    inputs per SPEC.md ("ISO 8601 with an offset is the input/output form").
+    Normalising the caller's bound to the offset the rows are stored in makes
+    the string comparison agree with chronological order.
+
+    A naive datetime carries no instant to convert, so it is passed through and
+    compared as written.
+    """
+    dt = parse_datetime(s)
+    if dt.tzinfo is None:
+        return s
+    return dt.astimezone(WRITE_TZ).isoformat(timespec="seconds")
+
+
+def date_of(dt_str: str) -> str:
+    """Return the YYYY-MM-DD portion of an ISO datetime string."""
+    # The first 10 chars of any valid ISO 8601 form are the date.
+    parse_datetime(dt_str)  # validates
+    return dt_str[:10]
+
+
+def assert_time_range(start: str, end: str) -> None:
+    """Raise BadTimeRangeError if ``end`` is not strictly after ``start``."""
+    from .exceptions import BadTimeRangeError
+    s = parse_datetime(start)
+    e = parse_datetime(end)
+    # Both aware or both naive — normalise to comparable form.
+    if (s.tzinfo is None) != (e.tzinfo is None):
+        # Treat naive as UTC for the comparison only.
+        if s.tzinfo is None:
+            s = s.replace(tzinfo=timezone.utc)
+        if e.tzinfo is None:
+            e = e.replace(tzinfo=timezone.utc)
+    if e <= s:
+        raise BadTimeRangeError(
+            f"end ({end}) must be strictly after start ({start})"
+        )
+
+
+def opt_parse_datetime(s: Optional[str]) -> Optional[datetime]:
+    return parse_datetime(s) if s else None

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/utils/exceptions.py

@@ -0,0 +1,41 @@
+from typing import Optional
+
+
+class CalendarMockError(Exception):
+    """Base exception for the calendar mock server.
+
+    Mapped to ``{"error": ..., "code": ...}`` JSON by the tool decorator;
+    never raised across the MCP boundary.
+    """
+
+    code: str = "BAD_ARG"
+
+    def __init__(self, message: str, code: Optional[str] = None) -> None:
+        super().__init__(message)
+        self.message = message
+        if code:
+            self.code = code
+
+
+class BadArgError(CalendarMockError):
+    code = "BAD_ARG"
+
+
+class BadDateError(CalendarMockError):
+    code = "BAD_DATE"
+
+
+class BadTimeRangeError(CalendarMockError):
+    code = "BAD_TIME_RANGE"
+
+
+class EventNotFoundError(CalendarMockError):
+    code = "EVENT_NOT_FOUND"
+
+
+class CalendarNotFoundError(CalendarMockError):
+    code = "CALENDAR_NOT_FOUND"
+
+
+class OverlappingEventError(CalendarMockError):
+    code = "OVERLAPPING_EVENT"

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/utils/ids.py

@@ -0,0 +1,14 @@
+def event_id(seq: int) -> str:
+    return f"evt_{seq:08d}"
+
+
+def calendar_id(seq: int) -> str:
+    return f"cal_{seq:06d}"
+
+
+def attendee_id(seq: int) -> str:
+    return f"att_{seq:08d}"
+
+
+def reminder_id(seq: int) -> str:
+    return f"rem_{seq:08d}"

harbor/rental/renewal_negotiation_repair_rental/environment/servers/calendar_mock/src/calendar_mock/utils/world_clock.py

@@ -0,0 +1,85 @@
+"""Shared virtual world-clock contract for mock server audit timestamps.
+
+The Harbor world-controller owns ``WORLD_CLOCK_FILE`` and updates it at step
+boundaries. ``WORLD_NOW`` is intentionally a secondary static override for
+unit tests and local debugging. When neither is configured, reads fail closed.
+"""
+from __future__ import annotations
+
+import json
+import os
+from datetime import date, datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any
+
+WRITE_TZ = timezone(timedelta(hours=8))
+WORLD_CLOCK_FILE_ENV = "WORLD_CLOCK_FILE"
+WORLD_NOW_ENV = "WORLD_NOW"
+
+
+class WorldClockError(RuntimeError):
+    """Raised when a configured virtual clock cannot be read safely."""
+
+
+def _parse_timestamp(raw: Any, source: str) -> datetime:
+    if not isinstance(raw, str) or not raw.strip():
+        raise WorldClockError(f"{source} must contain a non-empty ISO timestamp")
+    try:
+        parsed = datetime.fromisoformat(raw.strip().replace("Z", "+00:00"))
+    except ValueError as exc:
+        raise WorldClockError(f"{source} is not a valid ISO timestamp: {raw!r}") from exc
+    if parsed.tzinfo is None or parsed.utcoffset() is None:
+        raise WorldClockError(f"{source} must include an explicit timezone offset")
+    return parsed.astimezone(WRITE_TZ).replace(microsecond=0)
+
+
+def _read_clock_file(path: Path) -> datetime:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError as exc:
+        raise WorldClockError(f"configured world clock file is missing: {path}") from exc
+    except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+        raise WorldClockError(f"configured world clock file is unreadable: {path}: {exc}") from exc
+    if not isinstance(payload, dict) or not ("world_now" in payload or "now" in payload):
+        raise WorldClockError(f"configured world clock file must contain a JSON object: {path}")
+    return _parse_timestamp(payload.get("world_now") or payload.get("now"), f"world_now in {path}")
+
+
+def is_configured() -> bool:
+    """Whether Harbor or a caller supplied a virtual clock source."""
+    return bool(os.environ.get(WORLD_CLOCK_FILE_ENV) or os.environ.get(WORLD_NOW_ENV))
+
+
+def now() -> datetime:
+    """Return the current world time as an aware datetime in ``+08:00``."""
+    clock_file = os.environ.get(WORLD_CLOCK_FILE_ENV)
+    if clock_file:
+        return _read_clock_file(Path(clock_file))
+
+    static_now = os.environ.get(WORLD_NOW_ENV)
+    if static_now:
+        return _parse_timestamp(static_now, WORLD_NOW_ENV)
+
+    raise WorldClockError(
+        "world clock not configured: set WORLD_CLOCK_FILE (world-controller) "
+        "or WORLD_NOW (tests); refusing to fall back to host wall clock")
+
+
+def now_iso() -> str:
+    """Return the current world time in the corpus offset form."""
+    return now().isoformat()
+
+
+def now_iso_z() -> str:
+    """Return the current world time as a UTC ``Z`` timestamp."""
+    return now().astimezone(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+
+
+def today_utc() -> str:
+    """Return the current world date in UTC as ``YYYY-MM-DD``."""
+    return now().astimezone(timezone.utc).date().isoformat()
+
+
+def today_local() -> date:
+    """Return the current world date in the corpus offset."""
+    return now().date()