Update dataset (part 4)

LICENSE

@@ -6,12 +6,9 @@ of its upstream repository, listed per task below as reported by GitHub.
 The task text and grader design, where they are not upstream code, are
 copyright 2026 Toptal, LLC. Contact Toptal, LLC for licence terms.
 
+- Automattic__mongoose-mongoose_syncindexes_contract-97c2a76f: MIT (https://github.com/Automattic/mongoose)
 - BabylonJS__Babylon.js-babylonjs_scene_remove_owner_refs_contract-382616f8: Apache-2.0 (https://github.com/BabylonJS/Babylon.js)
-- MathNya__umya-spreadsheet-umya_structural_edit_reference_owners_contract: MIT (https://github.com/MathNya/umya-spreadsheet)
-- SickChill__SickChill-sickchill_episode_metadata_files_contract-2e2a49e4: GPL-3.0 (https://github.com/SickChill/SickChill)
 - Zettlr__Zettlr-zettlr_clickable_keywords: GPL-3.0 (https://github.com/Zettlr/Zettlr)
-- agronholm__apscheduler-apscheduler-expired-job-lease: MIT (https://github.com/agronholm/apscheduler)
-- aio-libs__aioftp-aioftp-stream-abort-desynchronization: Apache-2.0 (https://github.com/aio-libs/aioftp)
 - alibaba__druid-druid_lenient_script: Apache-2.0 (https://github.com/alibaba/druid)
 - alibaba__hooks-ahooks_request_cache_races: MIT (https://github.com/alibaba/hooks)
 - apache__geode-geode_oql_index_null_semantics_contract-1c066303: Apache-2.0 (https://github.com/apache/geode)
@@ -19,14 +16,17 @@ copyright 2026 Toptal, LLC. Contact Toptal, LLC for licence terms.
 - buchgr__bazel-remote-bazel_remote_disk_eviction_accounting_contract-afe5ea56: Apache-2.0 (https://github.com/buchgr/bazel-remote)
 - celery__celery-celery_retry_expires_countdown_contract: NOASSERTION (https://github.com/celery/celery)
 - colinhacks__zod-zod-json-schema-target-legality: MIT (https://github.com/colinhacks/zod)
-- coredns__coredns-coredns__4097: Apache-2.0 (https://github.com/coredns/coredns)
 - dgraph-io__badger-journal_recovery_after_unclean_stop: Apache-2.0 (https://github.com/dgraph-io/badger)
 - dotnet__Open-XML-SDK-open_xml_sdk_deletepart_refs_contract-1c066303: MIT (https://github.com/dotnet/Open-XML-SDK)
+- go-mysql-org__go-mysql-go_mysql_mariadb_compressed_columns: MIT (https://github.com/go-mysql-org/go-mysql)
 - igniterealtime__Openfire-openfire_userdeleting_last_owner_contract-0163de9c: Apache-2.0 (https://github.com/igniterealtime/Openfire)
-- mikro-orm__mikro-orm-mikro-orm-pessimistic-locking: MIT (https://github.com/mikro-orm/mikro-orm)
+- jelmer__xandikos-xandikos_itip_recurrence_id_override_contract-c6aa163a: GPL-3.0 (https://github.com/jelmer/xandikos)
+- oauth2-proxy__oauth2-proxy-proxy_cookie_accounting: MIT (https://github.com/oauth2-proxy/oauth2-proxy)
 - ory__kratos-kratos_cleanup_stale_flows_courier_contract: Apache-2.0 (https://github.com/ory/kratos)
 - pallets__click-click-help-defaults: BSD-3-Clause (https://github.com/pallets/click)
+- pomerium__pomerium-pomerium_route_order_contract: Apache-2.0 (https://github.com/pomerium/pomerium)
 - python-rope__rope-rope_rename_all_reexport_owners_contract-1c066303: LGPL-3.0 (https://github.com/python-rope/rope)
 - sequelize__sequelize-sequelize-bulkcreate-ignore-duplicates: MIT (https://github.com/sequelize/sequelize)
+- sfackler__rust-postgres-shared_handle_abandoned_operations: Apache-2.0 (https://github.com/sfackler/rust-postgres)
 - terser__terser-retained_top_level_names_keep_their_values: NOASSERTION (https://github.com/terser/terser)
 - tsileo__microblog.pub-microblogpub_deleted_object_resurrect_lookup_contract-382616f8: AGPL-3.0 (https://github.com/tsileo/microblog.pub)

README.md

@@ -101,10 +101,10 @@ dataset_info:
     dtype: float64
   splits:
   - name: test
-    num_bytes: 16944456
+    num_bytes: 16940905
     num_examples: 24
-  download_size: 7713543
-  dataset_size: 16944456
+  download_size: 7702204
+  dataset_size: 16940905
 ---
 
 # Dataset Card for ExpertCrowd SWE (EC-SWE)
@@ -114,8 +114,8 @@ agents. Each one is a bug or missing behaviour in a real open-source repository,
 commit, with a written problem statement, a reference fix, and a weighted
 grader backed by hidden tests. The tasks were chosen to sit at the typical
 difficulty of the pool of reviewed tasks they were drawn from, measured by how
-well current frontier agents scored on them: no outliers at either end. Mean
-agent reward runs from 0.34 to 0.43, and 1.6% of agent runs scored a full 1.0.
+well current frontier agents scored on them. Mean agent reward runs from
+0.17 to 0.47, and 3.1% of agent runs scored a full 1.0.
 
 ## Dataset Details
 
@@ -180,15 +180,15 @@ hard = ds.filter(lambda r: r["difficulty"] in ("very hard", "hard"))
 ### At a glance
 
 - **Tasks:** one per repository
-- **Models those runs used:** claude-fable-5, claude-fable-5-1, claude-opus-5, gemini-3.8-flash, gpt-6-astra
+- **Models those runs used:** claude-fable-5, claude-fable-5-1, claude-opus-5, gpt-6-astra
 
 | Language | Tasks |
 | --- | --- |
-| Python | 8 |
-| TypeScript | 6 |
-| Go | 4 |
+| Python | 6 |
+| Go | 6 |
+| TypeScript | 5 |
 | Java | 3 |
-| JavaScript | 1 |
+| JavaScript | 2 |
 | Rust | 1 |
 | C# | 1 |
 
@@ -196,32 +196,29 @@ hard = ds.filter(lambda r: r["difficulty"] in ("very hard", "hard"))
 
 Difficulty is the mean reward of graded agent runs on current frontier models.
 The tasks sit around the middle of the distribution of every verified task with
-5 or more graded agent runs, so the mean and median stay close to the pool's
-while the very hard and easy tails are left out:
+5 or more graded agent runs, so the mean and median stay close to the pool's.
+The easy tail is left out, and one task comes from the very hard end:
 
 | Mean agent reward | Difficulty | All verified with agent scores | This dataset |
 | --- | --- | --- | --- |
-| 0.0 to 0.2 | very hard | (4%) | 0% |
-| 0.2 to 0.4 | hard | (49%) | 62% |
-| 0.4 to 0.6 | medium | (44%) | 38% |
+| 0.0 to 0.2 | very hard | (4%) | 4% |
+| 0.2 to 0.4 | hard | (49%) | 46% |
+| 0.4 to 0.6 | medium | (44%) | 50% |
 | 0.6 to 0.8 | easy | (2%) | 0% |
 | 0.8 to 1.0 | very easy | 0 (0%) | 0% |
-| **mean** | | **0.377** | **0.380** |
-| **median** | | **0.379** | **0.373** |
+| **mean** | | **0.377** | **0.383** |
+| **median** | | **0.379** | **0.395** |
 
 ### Tasks
 
 | Instance | Repository | Language | Difficulty | Mean reward |
 | --- | --- | --- | --- | --- |
+| `oauth2-proxy__oauth2-proxy-proxy_cookie_accounting` | oauth2-proxy/oauth2-proxy | Go | very hard | 0.17 |
 | `bashrc2__epicyon-epicyon_deleted_post_announce_cache_contract-1c066303` | bashrc2/epicyon | Python | hard | 0.34 |
 | `apache__geode-geode_oql_index_null_semantics_contract-1c066303` | apache/geode | Java | hard | 0.34 |
-| `coredns__coredns-coredns__4097` | coredns/coredns | Go | hard | 0.34 |
 | `sequelize__sequelize-sequelize-bulkcreate-ignore-duplicates` | sequelize/sequelize | TypeScript | hard | 0.34 |
-| `MathNya__umya-spreadsheet-umya_structural_edit_reference_owners_contract` | MathNya/umya-spreadsheet | Rust | hard | 0.35 |
 | `alibaba__druid-druid_lenient_script` | alibaba/druid | Java | hard | 0.35 |
-| `aio-libs__aioftp-aioftp-stream-abort-desynchronization` | aio-libs/aioftp | Python | hard | 0.35 |
 | `python-rope__rope-rope_rename_all_reexport_owners_contract-1c066303` | python-rope/rope | Python | hard | 0.35 |
-| `SickChill__SickChill-sickchill_episode_metadata_files_contract-2e2a49e4` | SickChill/SickChill | Python | hard | 0.35 |
 | `igniterealtime__Openfire-openfire_userdeleting_last_owner_contract-0163de9c` | igniterealtime/Openfire | Java | hard | 0.36 |
 | `Zettlr__Zettlr-zettlr_clickable_keywords` | Zettlr/Zettlr | TypeScript | hard | 0.36 |
 | `buchgr__bazel-remote-bazel_remote_disk_eviction_accounting_contract-afe5ea56` | buchgr/bazel-remote | Go | hard | 0.37 |
@@ -229,14 +226,17 @@ while the very hard and easy tails are left out:
 | `ory__kratos-kratos_cleanup_stale_flows_courier_contract` | ory/kratos | Go | hard | 0.38 |
 | `dotnet__Open-XML-SDK-open_xml_sdk_deletepart_refs_contract-1c066303` | dotnet/Open-XML-SDK | C# | hard | 0.39 |
 | `dgraph-io__badger-journal_recovery_after_unclean_stop` | dgraph-io/badger | Go | medium | 0.40 |
+| `pomerium__pomerium-pomerium_route_order_contract` | pomerium/pomerium | Go | medium | 0.40 |
 | `BabylonJS__Babylon.js-babylonjs_scene_remove_owner_refs_contract-382616f8` | BabylonJS/Babylon.js | TypeScript | medium | 0.40 |
 | `alibaba__hooks-ahooks_request_cache_races` | alibaba/hooks | TypeScript | medium | 0.41 |
+| `go-mysql-org__go-mysql-go_mysql_mariadb_compressed_columns` | go-mysql-org/go-mysql | Go | medium | 0.41 |
+| `sfackler__rust-postgres-shared_handle_abandoned_operations` | sfackler/rust-postgres | Rust | medium | 0.42 |
 | `celery__celery-celery_retry_expires_countdown_contract` | celery/celery | Python | medium | 0.43 |
 | `colinhacks__zod-zod-json-schema-target-legality` | colinhacks/zod | TypeScript | medium | 0.43 |
 | `pallets__click-click-help-defaults` | pallets/click | Python | medium | 0.43 |
 | `tsileo__microblog.pub-microblogpub_deleted_object_resurrect_lookup_contract-382616f8` | tsileo/microblog.pub | Python | medium | 0.43 |
-| `mikro-orm__mikro-orm-mikro-orm-pessimistic-locking` | mikro-orm/mikro-orm | TypeScript | medium | 0.43 |
-| `agronholm__apscheduler-apscheduler-expired-job-lease` | agronholm/apscheduler | Python | medium | 0.43 |
+| `jelmer__xandikos-xandikos_itip_recurrence_id_override_contract-c6aa163a` | jelmer/xandikos | Python | medium | 0.46 |
+| `Automattic__mongoose-mongoose_syncindexes_contract-97c2a76f` | Automattic/mongoose | JavaScript | medium | 0.47 |
 
 ## Running the tasks
 
@@ -245,7 +245,7 @@ Harbor on your own machine.
 
 ### On HUD
 
-Every task runs on HUD, including the nine that have no Harbor package. The tasks are
+Every task runs on HUD, including the ones that have no Harbor package. The tasks are
 published there as the taskset [`ec-swe`](https://www.hud.ai/shared/tasksets/979e6e02-d726-46f6-a066-914afc5c9f44),
 which anyone can view; it holds all 24.
 
@@ -265,7 +265,7 @@ hud eval my-ec-swe claude --full      # runs it on the platform with an agent
 Results appear as jobs and traces on hud.ai (`hud jobs`). On HUD the agent and the grader
 share one container, kept apart by file permissions, and the four tasks with a criterion
 judged by a model get that judge from HUD's gateway. The commands follow HUD's
-documentation. We deployed eighteen of the folders this way ourselves and synced the task of
+documentation. We deployed twenty-two of the folders this way ourselves and synced the task of
 every folder into the taskset above; we have not run an agent with `hud eval` from this
 folder.
 
@@ -297,13 +297,12 @@ empty change scores 0, and the reference fix scores 1.0 with every criterion
 equal to the task's original grading. The folder contains the reference fixes
 and the hidden graders, as the rows of this dataset do.
 
-4 more (geode, kratos, open-xml-sdk, zettlr) are packaged and are being re-checked; they are added
+9 more (geode, go-mysql, kratos, mongoose, oauth2-proxy, open-xml-sdk, pomerium, rust-postgres, zettlr) are being packaged or re-checked; they are added
 as each one passes.
 
-Nine tasks have no Harbor package yet: click, sequelize, druid and hooks (one criterion each
-is judged by a model), SickChill, Babylon.js, mikro-orm, aioftp and apscheduler. The folder
-holds the complete build context of each, and `harbor/README.md` says for each how it is
-built and graded and what it needs.
+Five tasks have no Harbor package yet: click, sequelize, druid and hooks (one criterion each
+is judged by a model) and Babylon.js. The folder holds the complete build context of each,
+and `harbor/README.md` says for each how it is built and graded and what it needs.
 
 ## Dataset Creation
 
@@ -334,6 +333,11 @@ models.
    reward was closest to the sample mean (0.374) were kept: every task within
    0.059 of it. The nearest task left out was 0.064 away, so the cut does not
    split a tie.
+5. **Replacement.** Six tasks of that selection were later replaced by six
+   other verified tasks from the same pool. The replacements were picked by
+   their average score across six current models, not by the rule in step 4,
+   so three of them lie outside its band (mean agent reward 0.17, 0.46
+   and 0.47).
 
 ### Source Data
 

harbor/tasks/manifest.json

@@ -4,13 +4,12 @@
     "journal_recovery_after_unclean_stop",
     "bazel_remote_disk_eviction_accounting_contract",
     "celery_retry_expires_countdown_contract",
-    "coredns_rewrite_svcb_opt",
     "epicyon_deleted_post_announce_cache_contract",
     "microblogpub_deleted_object_resurrect_lookup_contract",
     "openfire_userdeleting_last_owner_contract",
     "rope_rename_all_reexport_owners_contract",
     "retained_top_level_names_keep_their_values",
-    "umya_structural_edit_reference_owners_contract",
+    "xandikos_itip_recurrence_id_override_contract",
     "zod_json_schema_target_legality"
   ]
 }

harbor/tasks/xandikos_itip_recurrence_id_override_contract/environment/Dockerfile

@@ -0,0 +1,23 @@
+FROM ec-swe-xandikos:source-v7 AS sanitized
+USER root
+COPY sanitize.py capture.py capture_submission.py /opt/task-tools/
+RUN HUD_TELEMETRY_ENABLED=false HUD_CLI_ANALYTICS_ENABLED=0 /opt/hudvenv/bin/python /opt/task-tools/sanitize.py
+FROM scratch
+COPY --from=sanitized / /
+ENV PATH="/opt/agentvenv/bin:/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"
+ENV LANG="C.UTF-8"
+ENV PYTHONUNBUFFERED="1"
+ENV PYTHONNOUSERSITE="1"
+ENV JAVA_HOME="/opt/java/openjdk"
+ENV GRADLE_USER_HOME="/tmp/agent-home/.gradle"
+ENV PYTHONPATH="/workspace/repo"
+ENV JAVA_TOOL_OPTIONS="-XX:MaxRAMPercentage=40"
+ENV PYTHONDONTWRITEBYTECODE="1"
+ENV GRADLE_OPTS="-Xmx768m -Dorg.gradle.daemon=false"
+ENV HOME="/tmp/agent-home"
+ENV GOCACHE="/tmp/agent-home/.cache/go-build"
+ENV HUD_TELEMETRY_ENABLED="false"
+ENV HUD_CLI_ANALYTICS_ENABLED="0"
+WORKDIR /workspace/repo
+USER 1000:1000
+CMD ["sleep", "infinity"]

harbor/tasks/xandikos_itip_recurrence_id_override_contract/environment/capture.py

@@ -0,0 +1,28 @@
+"""Capture a patch against protected baseline history inside the agent sandbox."""
+
+import json
+import os
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, "/opt/task-tools")
+from capture_submission import capture_submission  # noqa: E402
+
+with tempfile.TemporaryDirectory(prefix="capture-") as directory:
+    git_dir = Path(directory) / "git"
+    shutil.copytree("/opt/task-tools/baseline.git", git_dir)
+    os.environ.update(
+        GIT_DIR=str(git_dir),
+        GIT_WORK_TREE="/workspace/repo",
+        GIT_CONFIG_NOSYSTEM="1",
+        GIT_CONFIG_GLOBAL="/dev/null",
+    )
+    print(
+        json.dumps(
+            capture_submission(
+                Path("/workspace/repo"), Path("/workspace/submissions/submitted.patch")
+            )
+        )
+    )

harbor/tasks/xandikos_itip_recurrence_id_override_contract/environment/capture_submission.py

@@ -0,0 +1,157 @@
+"""Capture tracked and new SWE files without changing the agent's Git index."""
+
+import argparse
+import hashlib
+import json
+import os
+import shlex
+import subprocess
+import tempfile
+from pathlib import Path
+
+MAX_SUBMISSION_BYTES = 32 * 1024 * 1024
+
+
+def capture_submission(
+    repository: Path, output: Path, *, max_bytes: int = MAX_SUBMISSION_BYTES
+) -> dict[str, object]:
+    """Write a bounded binary patch including nonignored new files.
+
+    Parameters
+    ----------
+    repository : Path
+        Git checkout root. HEAD must remain the task's initial commit.
+    output : Path
+        Submission path outside the checkout. Replaces any prior submission.
+    max_bytes : int, default: 33554432
+        Maximum emitted patch size. Oversized submissions fail without a patch.
+
+    Returns
+    -------
+    dict
+        Patch size, SHA-256, base commit and capture format for trial evidence.
+
+    Raises
+    ------
+    ValueError
+        If paths or the limit are invalid, or the patch exceeds the limit.
+    OSError, subprocess.CalledProcessError, RuntimeError
+        If capture fails. No partial patch is published.
+
+    Notes
+    -----
+    Uses a temporary index to combine staged, unstaged and untracked changes.
+    Ignored untracked files are excluded. This is a capture bound, not a total
+    sandbox disk quota or a security boundary against a malicious Git runtime.
+    """
+    if isinstance(max_bytes, bool) or not isinstance(max_bytes, int) or max_bytes < 1:
+        raise ValueError("max_bytes must be a positive integer")
+    repository = repository.resolve(strict=True)
+    if output.is_symlink():
+        raise ValueError("Submission output must not be a symlink")
+    output = output.resolve()
+    if output.is_relative_to(repository):
+        raise ValueError("Submission output must be outside the repository")
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.unlink(missing_ok=True)
+    root = subprocess.check_output(
+        ["git", "rev-parse", "--show-toplevel"], cwd=repository, text=True
+    ).strip()
+    if Path(root).resolve() != repository:
+        raise ValueError("repository must be the Git checkout root")
+    base = subprocess.check_output(
+        ["git", "rev-parse", "--verify", "HEAD^{commit}"], cwd=repository, text=True
+    ).strip()
+    with tempfile.TemporaryDirectory(prefix="submission-", dir=output.parent) as directory:
+        temporary = Path(directory)
+        env = {**os.environ, "GIT_INDEX_FILE": str(temporary / "index")}
+        for arguments in (["read-tree", base], ["add", "--all", "--", "."]):
+            subprocess.run(["git", *arguments], cwd=repository, env=env, check=True)
+        patch = temporary / "patch"
+        size = 0
+        digest = hashlib.sha256()
+        with (
+            patch.open("wb") as stream,
+            tempfile.TemporaryFile() as errors,
+            subprocess.Popen(
+                [
+                    "git",
+                    "diff",
+                    "--cached",
+                    "--binary",
+                    "--full-index",
+                    "--no-renames",
+                    "--no-ext-diff",
+                    "--no-textconv",
+                    "--no-color",
+                    "--src-prefix=a/",
+                    "--dst-prefix=b/",
+                    base,
+                ],
+                cwd=repository,
+                env=env,
+                stdout=subprocess.PIPE,
+                stderr=errors,
+            ) as process,
+        ):
+            assert process.stdout is not None
+            try:
+                while chunk := process.stdout.read(65536):
+                    size += len(chunk)
+                    if size > max_bytes:
+                        raise ValueError(f"Submission exceeds {max_bytes} bytes")
+                    stream.write(chunk)
+                    digest.update(chunk)
+            except BaseException:
+                process.kill()
+                process.wait()
+                raise
+            if process.wait():
+                errors.seek(0)
+                raise RuntimeError(
+                    "Git patch capture failed: " + errors.read(4096).decode(errors="replace")
+                )
+        patch.replace(output)
+    return {
+        "bytes": size,
+        "sha256": digest.hexdigest(),
+        "base_commit": base,
+        "format": "git-binary-v1",
+    }
+
+
+def submission_command(*, max_bytes: int = MAX_SUBMISSION_BYTES) -> str:
+    """Build the trusted command recorded before Harbor collects artifacts.
+
+    Parameters
+    ----------
+    max_bytes : int, default: 33554432
+        Maximum emitted patch bytes.
+
+    Returns
+    -------
+    str
+        Shell command carrying this exact helper into the solver runtime.
+
+    Raises
+    ------
+    ValueError
+        If the size limit is invalid.
+    """
+    if isinstance(max_bytes, bool) or not isinstance(max_bytes, int) or max_bytes < 1:
+        raise ValueError("max_bytes must be a positive integer")
+    return "python -c " + shlex.quote(Path(__file__).read_text()) + f" --max-bytes {max_bytes}"
+
+
+def main() -> None:
+    """Capture the submission and print its identity as trial evidence."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--repository", type=Path, default=Path("/testbed"))
+    parser.add_argument("--output", type=Path, default=Path("/workspace/submitted.patch"))
+    parser.add_argument("--max-bytes", type=int, default=MAX_SUBMISSION_BYTES)
+    args = parser.parse_args()
+    print(json.dumps(capture_submission(args.repository, args.output, max_bytes=args.max_bytes)))
+
+
+if __name__ == "__main__":
+    main()

harbor/tasks/xandikos_itip_recurrence_id_override_contract/environment/docker-compose.yaml

@@ -0,0 +1,11 @@
+services:
+  main:
+    pids_limit: 512
+    security_opt:
+      - no-new-privileges:true
+    volumes:
+      - type: tmpfs
+        target: /logs/verifier
+        tmpfs:
+          mode: 448
+          size: 1048576

harbor/tasks/xandikos_itip_recurrence_id_override_contract/environment/sanitize.py

@@ -0,0 +1,25 @@
+"""Remove private task assets and history when building the agent-only image."""
+
+import asyncio
+import os
+import shutil
+import sys
+from pathlib import Path
+
+sys.path.insert(0, "/app")
+from env import _setup  # noqa: E402
+
+asyncio.run(_setup())
+# The new history contains only the public baseline. Preserve a root-owned
+# copy so capture can ignore agent-controlled refs, hooks and Git configuration.
+shutil.copytree("/workspace/repo/.git", "/opt/task-tools/baseline.git")
+for path in Path("/opt/task-tools/baseline.git").rglob("*"):
+    os.chown(path, 0, 0)
+    path.chmod(0o755 if path.is_dir() else 0o644)
+for name in ("/hud", "/app", "/root/.cache", "/root/.hud"):
+    if Path(name).exists():
+        shutil.rmtree(name)
+# Capture runs on the base interpreter under one name, whatever the image calls it.
+os.symlink(os.path.realpath(sys.executable), "/opt/task-tools/python")
+Path("/workspace/submissions").mkdir()
+os.chown("/workspace/submissions", 1000, 1000)

harbor/tasks/xandikos_itip_recurrence_id_override_contract/instruction.md

@@ -0,0 +1,29 @@
+Please make your changes directly in /workspace/repo.
+
+Our scheduling code treats a recurring event as one thing. Clients do not, and
+it shows.
+
+Bob cancelled next Tuesday's standup — `RECURRENCE-ID:20260602T100000Z` — and
+we cancelled the whole series, the Monday before and the Wednesday after with
+it. Carol's client names the same Tuesday in Berlin time; same result. An
+organiser's revised copy of one occurrence leaves us holding that occurrence
+and nothing else, and an attendee declining one occurrence is recorded as
+declining all of them. A message that names no occurrence has always meant the
+series. One about a Saturday the series never had is a different matter;
+nobody expects us to invent one.
+
+Messages marked `RANGE=THISANDFUTURE` fare no better. A cancellation from that
+Tuesday on took Monday too. Alice moved the standup to Room 4, an hour later,
+from that Tuesday on, and all we kept of the series was Tuesday. Bob declined
+from that Tuesday on, the Wednesday Alice had already moved by itself
+included, and his answer landed on Monday as well.
+
+What we send out has the same hole. Somebody invited to one occurrence is sent
+all of them; somebody taken off one hears nothing. Bob handed a single Tuesday
+to Dave, and Dave was sent the entire series. That same save also put Dave onto
+the rest of the series, and we took it — on a one-off meeting that edit has
+never got past us.
+
+The repository's own tests stay as they are, and stay green.
+
+Finish with a final response when your changes are ready.

harbor/tasks/xandikos_itip_recurrence_id_override_contract/solution/reference.patch

@@ -0,0 +1,1862 @@
+diff --git a/tests/test_itip_per_instance.py b/tests/test_itip_per_instance.py
+new file mode 100644
+index 0000000..f562977
+--- /dev/null
++++ b/tests/test_itip_per_instance.py
+@@ -0,0 +1,769 @@
++# Xandikos
++# Copyright (C) 2016-2017 Jelmer Vernooij <jelmer@jelmer.uk>, et al.
++#
++# This program is free software; you can redistribute it and/or
++# modify it under the terms of the GNU General Public License
++# as published by the Free Software Foundation; version 3
++# of the License or (at your option) any later version of
++# the License.
++#
++# This program is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++# GNU General Public License for more details.
++#
++# You should have received a copy of the GNU General Public License
++# along with this program; if not, write to the Free Software
++# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
++# MA  02110-1301, USA.
++
++"""Scheduling messages that speak about single occurrences of a series.
++
++RFC 5546 lets a CANCEL, a REQUEST or a REPLY name one occurrence of a
++recurring event with RECURRENCE-ID, whether or not the recipient happens
++to keep a separate component for it, and RFC 5545 §3.2.13 lets it name an
++occurrence and every later one at once. RFC 6638 §3.2.6 lets an attendee
++hand one occurrence to a delegate. These exercise the whole round: what
++the inbox does with such a message, what goes out when a user makes such
++a change, and what the server records about it.
++"""
++
++import asyncio
++import datetime
++import shutil
++import tempfile
++import unittest
++from io import BytesIO
++from wsgiref.util import setup_testing_defaults
++
++from icalendar.cal import Calendar
++
++from xandikos import scheduling
++from xandikos.icalendar import expand_calendar_rrule
++from xandikos.web import (
++    SingleUserFilesystemBackend,
++    StoreBasedCollection,
++    XandikosApp,
++)
++
++ALICE = "mailto:alice@example.com"
++BOB = "mailto:bob@example.com"
++CAROL = "mailto:carol@example.com"
++DAVE = "mailto:dave@example.com"
++
++FIRST = "20260601T100000Z"
++SECOND = "20260602T100000Z"
++THIRD = "20260603T100000Z"
++
++# The same instant as SECOND, written the way a client in Berlin writes it.
++SECOND_LOCAL = "TZID=Europe/Berlin:20260602T120000"
++
++
++def recurrence_key(comp) -> str:
++    """The occurrence *comp* is about, named by its instant ("" for the series)."""
++    rid = comp.get("RECURRENCE-ID")
++    if rid is None:
++        return ""
++    value = rid.dt
++    if isinstance(value, datetime.datetime):
++        if value.tzinfo is not None:
++            value = value.astimezone(datetime.timezone.utc)
++        return value.strftime("%Y%m%dT%H%M%SZ")
++    return value.strftime("%Y%m%d")
++
++
++WINDOW = (
++    datetime.datetime(2026, 5, 1, tzinfo=datetime.timezone.utc),
++    datetime.datetime(2026, 7, 1, tzinfo=datetime.timezone.utc),
++)
++
++
++def series(*, override: bool, attendees=(BOB,)) -> bytes:
++    """A daily series of three, optionally with the second one broken out."""
++    lines = [
++        "BEGIN:VCALENDAR",
++        "VERSION:2.0",
++        "PRODID:-//Xandikos test//EN",
++        "BEGIN:VEVENT",
++        "UID:rec@example.com",
++        "DTSTAMP:20260101T120000Z",
++        "SEQUENCE:1",
++        f"DTSTART:{FIRST}",
++        "DTEND:20260601T110000Z",
++        "RRULE:FREQ=DAILY;COUNT=3",
++        "SUMMARY:Standup",
++        f"ORGANIZER:{ALICE}",
++    ]
++    lines += [f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{a}" for a in attendees]
++    lines.append("END:VEVENT")
++    if override:
++        lines += [
++            "BEGIN:VEVENT",
++            "UID:rec@example.com",
++            "DTSTAMP:20260101T120000Z",
++            "SEQUENCE:1",
++            f"RECURRENCE-ID:{SECOND}",
++            f"DTSTART:{SECOND}",
++            "DTEND:20260602T110000Z",
++            "SUMMARY:Standup (moved)",
++            f"ORGANIZER:{ALICE}",
++        ]
++        lines += [f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{a}" for a in attendees]
++        lines.append("END:VEVENT")
++    lines.append("END:VCALENDAR")
++    return ("\r\n".join(lines) + "\r\n").encode("utf-8")
++
++
++def itip_message(method: str, rid: str | None, *body: str) -> bytes:
++    lines = [
++        "BEGIN:VCALENDAR",
++        "VERSION:2.0",
++        "PRODID:-//Xandikos test//EN",
++        f"METHOD:{method}",
++        "BEGIN:VEVENT",
++        "UID:rec@example.com",
++        "DTSTAMP:20260102T120000Z",
++        f"ORGANIZER:{ALICE}",
++    ]
++    if rid is not None:
++        lines.append(f"RECURRENCE-ID;{rid}" if "=" in rid else f"RECURRENCE-ID:{rid}")
++    lines += list(body)
++    lines += ["END:VEVENT", "END:VCALENDAR"]
++    return ("\r\n".join(lines) + "\r\n").encode("utf-8")
++
++
++def series_in_a_time_zone() -> bytes:
++    """The same three-a-day series, kept in Berlin local time with its VTIMEZONE.
++
++    Its occurrences are the same instants as :func:`series` produces: noon in
++    Berlin on those days is 10:00 UTC.
++    """
++    lines = [
++        "BEGIN:VCALENDAR",
++        "VERSION:2.0",
++        "PRODID:-//Xandikos test//EN",
++        "BEGIN:VTIMEZONE",
++        "TZID:Europe/Berlin",
++        "BEGIN:DAYLIGHT",
++        "TZOFFSETFROM:+0100",
++        "TZOFFSETTO:+0200",
++        "TZNAME:CEST",
++        "DTSTART:19700329T020000",
++        "RRULE:FREQ=YEARLY;BYMONTH=3;BYDAY=-1SU",
++        "END:DAYLIGHT",
++        "BEGIN:STANDARD",
++        "TZOFFSETFROM:+0200",
++        "TZOFFSETTO:+0100",
++        "TZNAME:CET",
++        "DTSTART:19701025T030000",
++        "RRULE:FREQ=YEARLY;BYMONTH=10;BYDAY=-1SU",
++        "END:STANDARD",
++        "END:VTIMEZONE",
++        "BEGIN:VEVENT",
++        "UID:rec@example.com",
++        "DTSTAMP:20260101T120000Z",
++        "SEQUENCE:1",
++        "DTSTART;TZID=Europe/Berlin:20260601T120000",
++        "DTEND;TZID=Europe/Berlin:20260601T130000",
++        "RRULE:FREQ=DAILY;COUNT=3",
++        "SUMMARY:Standup",
++        f"ORGANIZER:{ALICE}",
++        f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}",
++        "END:VEVENT",
++        "END:VCALENDAR",
++    ]
++    return ("\r\n".join(lines) + "\r\n").encode("utf-8")
++
++
++def delegate_second_occurrence(body: bytes) -> bytes:
++    """Bob hands his seat at the second occurrence to Dave."""
++    head, marker, tail = body.decode("utf-8").partition(f"RECURRENCE-ID:{SECOND}")
++    assert marker, "the fixture has no second occurrence to delegate"
++    tail = tail.replace(
++        f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}\r\n",
++        f'ATTENDEE;PARTSTAT=DELEGATED;DELEGATED-TO="{DAVE}":{BOB}\r\n'
++        f'ATTENDEE;PARTSTAT=NEEDS-ACTION;DELEGATED-FROM="{BOB}":{DAVE}\r\n',
++        1,
++    )
++    return (head + marker + tail).encode("utf-8")
++
++
++class PerInstanceSchedulingTests(unittest.TestCase):
++    def setUp(self):
++        super().setUp()
++        self.tempdir = tempfile.mkdtemp()
++        self.addCleanup(shutil.rmtree, self.tempdir)
++        self.backend = SingleUserFilesystemBackend(self.tempdir)
++        for name in ("alice", "bob", "carol", "dave"):
++            self.backend.create_principal("/" + name, create_defaults=True)
++            self.backend.get_resource("/" + name).set_calendar_user_address_set(
++                [f"mailto:{name}@example.com"]
++            )
++
++    # -- driving the server the way a client does -------------------------
++    def put(self, path: str, body: bytes) -> str:
++        app = XandikosApp(self.backend, "user")
++        environ = {
++            "PATH_INFO": path,
++            "REQUEST_METHOD": "PUT",
++            "QUERY_STRING": "",
++            "CONTENT_TYPE": "text/calendar",
++            "CONTENT_LENGTH": str(len(body)),
++        }
++        setup_testing_defaults(environ)
++        environ["wsgi.input"] = BytesIO(body)
++        codes: list[str] = []
++        b"".join(app(environ, lambda code, headers: codes.append(code)))
++        return codes[0]
++
++    def put_ok(self, principal: str, body: bytes) -> None:
++        code = self.put(f"/{principal}/calendars/calendar/event.ics", body)
++        self.assertIn(code.split()[0], ("200", "201", "204"), code)
++
++    def deliver(self, address: str, message: bytes) -> None:
++        self.assertTrue(
++            asyncio.run(
++                scheduling.deliver_to_inbox(
++                    self.backend, address, Calendar.from_ical(message.decode("utf-8"))
++                )
++            )
++        )
++
++    # -- reading what the stores hold -------------------------------------
++    def stored(self, principal: str) -> Calendar:
++        col = self.backend.get_resource(f"/{principal}/calendars/calendar")
++        assert isinstance(col, StoreBasedCollection)
++        raw = [
++            b"".join(col.store._get_raw(name, etag))
++            for name, _ct, etag in col.store.iter_with_etag()
++        ]
++        self.assertEqual(1, len(raw))
++        return Calendar.from_ical(raw[0].decode("utf-8"))
++
++    def inbox(self, principal: str, method: str) -> list[Calendar]:
++        col = self.backend.get_resource(f"/{principal}/inbox")
++        assert isinstance(col, StoreBasedCollection)
++        out = []
++        for name, _ct, etag in col.store.iter_with_etag():
++            parsed = Calendar.from_ical(
++                b"".join(col.store._get_raw(name, etag)).decode("utf-8")
++            )
++            if str(parsed.get("METHOD", "")).upper() == method:
++                out.append(parsed)
++        return out
++
++    def occurrences(self, principal: str) -> dict:
++        """The series as a client sees it after expansion."""
++        expanded = expand_calendar_rrule(self.stored(principal), *WINDOW)
++        out = {}
++        for comp in expanded.subcomponents:
++            if comp.name != "VEVENT":
++                continue
++            attendees = comp.get("ATTENDEE", [])
++            if not isinstance(attendees, list):
++                attendees = [attendees]
++            out[recurrence_key(comp)] = {
++                "status": str(comp.get("STATUS", "")),
++                "summary": str(comp.get("SUMMARY", "")),
++                "partstat": {
++                    str(a): str(a.params.get("PARTSTAT", "")) for a in attendees
++                },
++            }
++        return out
++
++    def assertLive(self, occurrences, key):
++        self.assertIn(key, occurrences)
++        self.assertNotEqual("CANCELLED", occurrences[key]["status"].upper())
++
++    def assertNotLive(self, occurrences, key):
++        row = occurrences.get(key)
++        if row is not None:
++            self.assertEqual("CANCELLED", row["status"].upper())
++
++    # -- the inbox --------------------------------------------------------
++    def test_cancel_of_an_occurrence_without_its_own_component(self):
++        self.put_ok("bob", series(override=False))
++        self.deliver(
++            BOB,
++            itip_message(
++                "CANCEL",
++                SECOND,
++                "SEQUENCE:2",
++                f"DTSTART:{SECOND}",
++                "STATUS:CANCELLED",
++                f"ATTENDEE:{BOB}",
++            ),
++        )
++        occurrences = self.occurrences("bob")
++        self.assertLive(occurrences, FIRST)
++        self.assertLive(occurrences, THIRD)
++        self.assertNotLive(occurrences, SECOND)
++
++    def test_cancel_without_a_recurrence_id_still_ends_the_series(self):
++        self.put_ok("bob", series(override=True))
++        self.deliver(
++            BOB,
++            itip_message(
++                "CANCEL",
++                None,
++                "SEQUENCE:2",
++                f"DTSTART:{FIRST}",
++                "RRULE:FREQ=DAILY;COUNT=3",
++                "STATUS:CANCELLED",
++                f"ATTENDEE:{BOB}",
++            ),
++        )
++        for key in (FIRST, SECOND, THIRD):
++            self.assertNotLive(self.occurrences("bob"), key)
++
++    def test_cancel_this_and_future_ends_the_series_at_that_occurrence(self):
++        self.put_ok("bob", series(override=False))
++        self.deliver(
++            BOB,
++            itip_message(
++                "CANCEL",
++                f"RANGE=THISANDFUTURE:{SECOND}",
++                "SEQUENCE:2",
++                f"DTSTART:{SECOND}",
++                "STATUS:CANCELLED",
++                f"ATTENDEE:{BOB}",
++            ),
++        )
++        occurrences = self.occurrences("bob")
++        self.assertLive(occurrences, FIRST)
++        self.assertNotLive(occurrences, SECOND)
++        self.assertNotLive(occurrences, THIRD)
++
++    def test_reply_about_an_occurrence_without_its_own_component(self):
++        self.put_ok("alice", series(override=False, attendees=(BOB, CAROL)))
++        self.deliver(
++            ALICE,
++            itip_message(
++                "REPLY", SECOND, "SEQUENCE:1", f"ATTENDEE;PARTSTAT=DECLINED:{BOB}"
++            ),
++        )
++        occurrences = self.occurrences("alice")
++        self.assertEqual("DECLINED", occurrences[SECOND]["partstat"][BOB])
++        self.assertEqual("NEEDS-ACTION", occurrences[FIRST]["partstat"][BOB])
++        self.assertEqual("NEEDS-ACTION", occurrences[THIRD]["partstat"][BOB])
++        self.assertEqual("NEEDS-ACTION", occurrences[SECOND]["partstat"][CAROL])
++
++    def test_reply_without_a_recurrence_id_answers_for_the_series(self):
++        self.put_ok("alice", series(override=False, attendees=(BOB,)))
++        self.deliver(
++            ALICE,
++            itip_message(
++                "REPLY", None, "SEQUENCE:1", f"ATTENDEE;PARTSTAT=ACCEPTED:{BOB}"
++            ),
++        )
++        occurrences = self.occurrences("alice")
++        for key in (FIRST, SECOND, THIRD):
++            self.assertEqual("ACCEPTED", occurrences[key]["partstat"][BOB])
++
++    def test_the_same_instant_in_another_time_zone_is_one_occurrence(self):
++        self.put_ok("bob", series(override=True))
++        self.deliver(
++            BOB,
++            itip_message(
++                "CANCEL",
++                SECOND_LOCAL,
++                "SEQUENCE:2",
++                f"DTSTART;{SECOND_LOCAL}",
++                "STATUS:CANCELLED",
++                f"ATTENDEE:{BOB}",
++            ),
++        )
++        occurrences = self.occurrences("bob")
++        self.assertLive(occurrences, FIRST)
++        self.assertLive(occurrences, THIRD)
++        self.assertNotLive(occurrences, SECOND)
++
++    def test_a_request_for_one_occurrence_does_not_duplicate_it(self):
++        self.put_ok("bob", series(override=True))
++        self.deliver(
++            BOB,
++            itip_message(
++                "REQUEST",
++                SECOND_LOCAL,
++                "SEQUENCE:2",
++                f"DTSTART;{SECOND_LOCAL}",
++                "DTEND;TZID=Europe/Berlin:20260602T130000",
++                "SUMMARY:Standup (moved again)",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}",
++            ),
++        )
++        keys = [
++            recurrence_key(comp)
++            for comp in self.stored("bob").subcomponents
++            if comp.name == "VEVENT"
++        ]
++        self.assertEqual(sorted(keys), sorted({"", SECOND}))
++        occurrences = self.occurrences("bob")
++        self.assertEqual("Standup (moved again)", occurrences[SECOND]["summary"])
++        self.assertEqual("Standup", occurrences[FIRST]["summary"])
++
++    # -- what goes out ----------------------------------------------------
++    def test_a_delegate_is_told_about_the_delegated_occurrence_only(self):
++        self.put_ok("bob", series(override=True))
++        self.put_ok("bob", delegate_second_occurrence(series(override=True)))
++        requests = self.inbox("dave", "REQUEST")
++        self.assertEqual(1, len(requests))
++        self.assertEqual(
++            [SECOND],
++            sorted(
++                recurrence_key(comp)
++                for comp in requests[0].subcomponents
++                if comp.name == "VEVENT"
++            ),
++        )
++
++    def test_a_delegation_does_not_hide_an_uninvited_occurrence(self):
++        self.put_ok("bob", series(override=True))
++        smuggled = (
++            delegate_second_occurrence(series(override=True))
++            .decode("utf-8")
++            .replace(
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}\r\nEND:VEVENT",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}\r\n"
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{DAVE}\r\nEND:VEVENT",
++                1,
++            )
++            .encode("utf-8")
++        )
++        code = self.put("/bob/calendars/calendar/event.ics", smuggled)
++        self.assertEqual("412 Precondition Failed", code)
++        for comp in self.stored("bob").subcomponents:
++            if comp.name == "VEVENT" and recurrence_key(comp) == "":
++                attendees = comp.get("ATTENDEE", [])
++                if not isinstance(attendees, list):
++                    attendees = [attendees]
++                self.assertNotIn(DAVE, [str(a) for a in attendees])
++
++    def test_an_attendee_is_sent_the_occurrences_that_are_theirs(self):
++        self.put_ok("alice", series(override=True, attendees=(BOB, CAROL)))
++        # Carol is taken off the second occurrence only.
++        head, marker, tail = (
++            series(override=True, attendees=(BOB, CAROL))
++            .decode("utf-8")
++            .partition(f"RECURRENCE-ID:{SECOND}")
++        )
++        edited = (
++            head
++            + marker
++            + tail.replace(f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{CAROL}\r\n", "", 1)
++        ).encode("utf-8")
++        self.put_ok("alice", edited)
++        cancels = self.inbox("carol", "CANCEL")
++        self.assertEqual(1, len(cancels))
++        self.assertEqual(
++            [SECOND],
++            sorted(
++                recurrence_key(comp)
++                for comp in cancels[0].subcomponents
++                if comp.name == "VEVENT"
++            ),
++        )
++
++    def test_cancel_this_and_future_on_a_series_kept_in_a_time_zone(self):
++        """The boundary arrives in Berlin time; the series ends at that instant.
++
++        RFC 5545 §3.3.10: a series whose DTSTART carries a time zone ends on a
++        UNTIL written in UTC. Left in the sender's local time it reads as a
++        floating time, which is a different instant by the offset — far enough
++        to leave the very occurrence the message named still happening.
++        """
++        self.put_ok("bob", series_in_a_time_zone())
++        self.assertEqual(3, len(self.occurrences("bob")))
++        self.deliver(
++            BOB,
++            itip_message(
++                "CANCEL",
++                f"RANGE=THISANDFUTURE;{SECOND_LOCAL}",
++                "SEQUENCE:2",
++                "STATUS:CANCELLED",
++                f"ATTENDEE:{BOB}",
++            ),
++        )
++        occurrences = self.occurrences("bob")
++        self.assertLive(occurrences, FIRST)
++        self.assertNotLive(occurrences, SECOND)
++        self.assertNotLive(occurrences, THIRD)
++        # Ending the series is one way to do it and not the only one; if this
++        # is the way it was done, the UNTIL is the one RFC 5545 asks for.
++        for comp in self.stored("bob").subcomponents:
++            if comp.name != "VEVENT" or "RRULE" not in comp:
++                continue
++            for until in comp["RRULE"].get("UNTIL", []):
++                self.assertIsNotNone(
++                    getattr(until, "tzinfo", None),
++                    f"a series kept in a time zone was given a floating UNTIL: {until!r}",
++                )
++
++    def test_a_request_for_an_instant_the_series_never_produces(self):
++        """Half past eleven is not an occurrence of a series that meets at ten.
++
++        A message about an occurrence we hold no component for is applied by
++        breaking that occurrence out of the series. An instant the recurrence
++        set does not produce has nothing to break out, and adding it would put
++        a meeting nobody scheduled into the event.
++        """
++        self.put_ok("bob", series(override=False))
++        before = self.stored("bob").to_ical()
++        self.deliver(
++            BOB,
++            itip_message(
++                "REQUEST",
++                "20260602T113000Z",
++                "SEQUENCE:2",
++                "DTSTART:20260602T113000Z",
++                "DTEND:20260602T120000Z",
++                "SUMMARY:Invented",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}",
++            ),
++        )
++        self.assertEqual(
++            [""],
++            sorted(
++                recurrence_key(comp)
++                for comp in self.stored("bob").subcomponents
++                if comp.name == "VEVENT"
++            ),
++        )
++        self.assertEqual([FIRST, SECOND, THIRD], sorted(self.occurrences("bob")))
++        self.assertEqual(before, self.stored("bob").to_ical())
++
++    def test_a_re_request_in_another_time_zone_keeps_the_answer(self):
++        """RFC 6638 §3.2.1: a fresh REQUEST does not throw away the answers.
++
++        The organiser's client writes the second occurrence in Berlin time
++        this time. It is the same occurrence, so the PARTSTAT already given
++        for it is the PARTSTAT it keeps.
++        """
++        self.put_ok("bob", series(override=True))
++        self.deliver(
++            BOB,
++            itip_message(
++                "REPLY", SECOND, "SEQUENCE:1", f"ATTENDEE;PARTSTAT=ACCEPTED:{BOB}"
++            ),
++        )
++        self.assertEqual("ACCEPTED", self.occurrences("bob")[SECOND]["partstat"][BOB])
++        self.deliver(
++            BOB,
++            itip_message(
++                "REQUEST",
++                SECOND_LOCAL,
++                "SEQUENCE:3",
++                f"DTSTART;{SECOND_LOCAL}",
++                "DTEND;TZID=Europe/Berlin:20260602T133000",
++                "SUMMARY:Standup (later)",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}",
++            ),
++        )
++        occurrences = self.occurrences("bob")
++        self.assertEqual("Standup (later)", occurrences[SECOND]["summary"])
++        self.assertEqual("ACCEPTED", occurrences[SECOND]["partstat"][BOB])
++
++    def test_an_occurrence_the_series_names_outright_is_still_the_series(self):
++        """Refusing to invent an occurrence is not refusing to keep one.
++
++        A date named on RDATE is in the recurrence set (RFC 5545 §3.8.5.2),
++        and an object that holds occurrences and no series at all has no
++        recurrence set to be judged against. Neither is an invented occurrence.
++        """
++        lines = (
++            series(override=False)
++            .decode("utf-8")
++            .replace("RRULE:FREQ=DAILY;COUNT=3\r\n", f"RDATE:{SECOND},{THIRD}\r\n", 1)
++        )
++        self.put_ok("bob", lines.encode("utf-8"))
++        self.deliver(
++            BOB,
++            itip_message(
++                "REQUEST",
++                SECOND,
++                "SEQUENCE:2",
++                f"DTSTART:{SECOND}",
++                "DTEND:20260602T113000Z",
++                "SUMMARY:Standup (moved)",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}",
++            ),
++        )
++        self.assertEqual(
++            ["", SECOND],
++            sorted(
++                recurrence_key(comp)
++                for comp in self.stored("bob").subcomponents
++                if comp.name == "VEVENT"
++            ),
++        )
++
++        # An object built out of a message about one occurrence: no series.
++        self.deliver(
++            CAROL,
++            itip_message(
++                "REQUEST",
++                SECOND,
++                "SEQUENCE:1",
++                f"DTSTART:{SECOND}",
++                "DTEND:20260602T110000Z",
++                "SUMMARY:Standup",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{CAROL}",
++            ),
++        )
++        self.deliver(
++            CAROL,
++            itip_message(
++                "REQUEST",
++                THIRD,
++                "SEQUENCE:1",
++                f"DTSTART:{THIRD}",
++                "DTEND:20260603T110000Z",
++                "SUMMARY:Standup",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{CAROL}",
++            ),
++        )
++        self.assertEqual(
++            [SECOND, THIRD],
++            sorted(
++                recurrence_key(comp)
++                for comp in self.stored("carol").subcomponents
++                if comp.name == "VEVENT"
++            ),
++        )
++
++    def test_an_attendee_is_invited_to_the_occurrences_that_are_theirs(self):
++        """Carol is on the second occurrence only, and is sent that one."""
++        head, marker, tail = (
++            series(override=True, attendees=(BOB,))
++            .decode("utf-8")
++            .partition(f"RECURRENCE-ID:{SECOND}")
++        )
++        invited = (
++            head
++            + marker
++            + tail.replace(
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}\r\n",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}\r\n"
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{CAROL}\r\n",
++                1,
++            )
++        ).encode("utf-8")
++        self.put_ok("alice", invited)
++        requests = self.inbox("carol", "REQUEST")
++        self.assertEqual(1, len(requests))
++        self.assertEqual(
++            [SECOND],
++            sorted(
++                recurrence_key(comp)
++                for comp in requests[0].subcomponents
++                if comp.name == "VEVENT"
++            ),
++        )
++
++    # -- from one occurrence onwards: a revision and an answer --------------
++    def _starts(self, principal: str) -> dict:
++        expanded = expand_calendar_rrule(self.stored(principal), *WINDOW)
++        out = {}
++        for comp in expanded.subcomponents:
++            if comp.name == "VEVENT":
++                value = comp["DTSTART"].dt.astimezone(datetime.timezone.utc)
++                out[recurrence_key(comp)] = value.strftime("%Y%m%dT%H%M%SZ")
++        return out
++
++    def test_a_revision_from_one_occurrence_onwards(self):
++        self.put_ok("bob", series(override=False))
++        self.deliver(
++            BOB,
++            itip_message(
++                "REQUEST",
++                f"RANGE=THISANDFUTURE:{SECOND}",
++                "SEQUENCE:2",
++                "DTSTART:20260602T103000Z",
++                "DTEND:20260602T113000Z",
++                "SUMMARY:Standup (upstairs)",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}",
++            ),
++        )
++        occurrences = self.occurrences("bob")
++        self.assertEqual("Standup", occurrences[FIRST]["summary"])
++        self.assertEqual("Standup (upstairs)", occurrences[SECOND]["summary"])
++        self.assertEqual("Standup (upstairs)", occurrences[THIRD]["summary"])
++        starts = self._starts("bob")
++        self.assertEqual(FIRST, starts[FIRST])
++        self.assertEqual("20260602T103000Z", starts[SECOND])
++        self.assertEqual("20260603T103000Z", starts[THIRD])
++
++    def test_a_revision_onwards_on_an_open_ended_series(self):
++        self.put_ok(
++            "bob",
++            series(override=False).replace(
++                b"RRULE:FREQ=DAILY;COUNT=3", b"RRULE:FREQ=DAILY"
++            ),
++        )
++        self.deliver(
++            BOB,
++            itip_message(
++                "REQUEST",
++                f"RANGE=THISANDFUTURE:{SECOND}",
++                "SEQUENCE:2",
++                f"DTSTART:{SECOND}",
++                "DTEND:20260602T110000Z",
++                "SUMMARY:Standup (upstairs)",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}",
++            ),
++        )
++        occurrences = self.occurrences("bob")
++        self.assertEqual("Standup", occurrences[FIRST]["summary"])
++        self.assertEqual("Standup (upstairs)", occurrences["20260630T100000Z"]["summary"])
++
++    def test_an_answer_from_one_occurrence_onwards(self):
++        self.put_ok("alice", series(override=True, attendees=(BOB, CAROL)))
++        self.deliver(
++            ALICE,
++            itip_message(
++                "REPLY",
++                f"RANGE=THISANDFUTURE:{SECOND}",
++                "SEQUENCE:1",
++                f"ATTENDEE;PARTSTAT=TENTATIVE:{BOB}",
++            ),
++        )
++        occurrences = self.occurrences("alice")
++        self.assertEqual("NEEDS-ACTION", occurrences[FIRST]["partstat"][BOB])
++        self.assertEqual("TENTATIVE", occurrences[SECOND]["partstat"][BOB])
++        self.assertEqual("TENTATIVE", occurrences[THIRD]["partstat"][BOB])
++        # the occurrence kept as its own exception is still that occurrence
++        self.assertEqual("Standup (moved)", occurrences[SECOND]["summary"])
++        self.assertEqual("Standup", occurrences[THIRD]["summary"])
++        for key in (FIRST, SECOND, THIRD):
++            self.assertEqual("NEEDS-ACTION", occurrences[key]["partstat"][CAROL])
++
++    def test_an_answer_onwards_after_a_revision_onwards(self):
++        self.put_ok("alice", series(override=False, attendees=(BOB,)))
++        stored = self.stored("alice").to_ical().decode("utf-8")
++        # Alice's own copy after she moved the series upstairs from Tuesday on.
++        revised = stored.replace(
++            "END:VCALENDAR",
++            "BEGIN:VEVENT\r\nUID:rec@example.com\r\nDTSTAMP:20260101T120000Z\r\n"
++            f"SEQUENCE:2\r\nRECURRENCE-ID;RANGE=THISANDFUTURE:{SECOND}\r\n"
++            f"DTSTART:{SECOND}\r\nDTEND:20260602T110000Z\r\n"
++            f"SUMMARY:Standup (upstairs)\r\nORGANIZER:{ALICE}\r\n"
++            f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}\r\nEND:VEVENT\r\nEND:VCALENDAR",
++        )
++        self.put_ok("alice", revised.encode("utf-8"))
++        self.deliver(
++            ALICE,
++            itip_message(
++                "REPLY",
++                f"RANGE=THISANDFUTURE:{THIRD}",
++                "SEQUENCE:2",
++                f"ATTENDEE;PARTSTAT=DECLINED:{BOB}",
++            ),
++        )
++        occurrences = self.occurrences("alice")
++        self.assertEqual("NEEDS-ACTION", occurrences[SECOND]["partstat"][BOB])
++        self.assertEqual("DECLINED", occurrences[THIRD]["partstat"][BOB])
++        self.assertEqual("Standup (upstairs)", occurrences[THIRD]["summary"])
++
++
++if __name__ == "__main__":
++    unittest.main()
+diff --git a/xandikos/icalendar.py b/xandikos/icalendar.py
+index 3bc8aea..d3c8e03 100644
+--- a/xandikos/icalendar.py
++++ b/xandikos/icalendar.py
+@@ -2183,7 +2183,17 @@ def _expand_rrule_component(
+     start: datetime | None = None,
+     end: datetime | None = None,
+     existing: dict[str | date | datetime, Component] = {},
++    onwards: "list[tuple[date | datetime, Component]] | None" = None,
+ ) -> Iterable[Component]:
++    """Yield the occurrences of *incomp*'s recurrence set.
++
++    *existing* maps normalised RECURRENCE-IDs to the exception components
++    that replace an occurrence outright; each one is popped as it is used.
++    *onwards* lists, in order, the exceptions marked
++    ``RECURRENCE-ID;RANGE=THISANDFUTURE`` (RFC 5545 §3.8.4.4): such an
++    exception also stands for every later occurrence that has no exception
++    of its own, shifted by however far it moved its own start.
++    """
+     if "RRULE" not in incomp:
+         return
+     if "DTSTART" not in incomp:
+@@ -2258,6 +2268,12 @@ def _expand_rrule_component(
+         try:
+             outcomp = existing.pop(ts_normalized)
+         except KeyError:
++            outcomp = None
++        if outcomp is None:
++            governing = _governing_onwards(onwards, ts_normalized)
++            if governing is not None:
++                outcomp = _occurrence_from_onwards(governing, ts_for_dtstart)
++        if outcomp is None:
+             # Create new occurrence
+             outcomp = base_comp.copy()
+ 
+@@ -2302,6 +2318,74 @@ def _expand_rrule_component(
+         yield outcomp
+ 
+ 
++def _is_onwards(comp: Component) -> bool:
++    """True if *comp*'s RECURRENCE-ID carries RANGE=THISANDFUTURE."""
++    rid = comp.get("RECURRENCE-ID")
++    params = getattr(rid, "params", None) or {}
++    rng = params.get("RANGE")
++    return rng is not None and str(rng).upper() == "THISANDFUTURE"
++
++
++def _governing_onwards(
++    onwards: "list[tuple[date | datetime, Component]] | None",
++    ts_normalized: date | datetime,
++) -> "Component | None":
++    """Return the latest THISANDFUTURE exception that starts before *ts*."""
++    found = None
++    for moment, comp in onwards or ():
++        try:
++            if moment < ts_normalized:
++                found = comp
++        except TypeError:
++            # A date against a date-time: not the same recurrence set.
++            continue
++    return found
++
++
++def _occurrence_from_onwards(
++    governing: Component, ts_for_dtstart: date | datetime
++) -> Component:
++    """Derive the occurrence at *ts_for_dtstart* from a THISANDFUTURE exception.
++
++    RFC 5545 §3.8.4.4: the exception's properties hold for the later
++    occurrences too, and if it moved its own start, every later occurrence
++    moves by the same amount and keeps the exception's length.
++    """
++    outcomp = governing.copy()
++    rid = governing["RECURRENCE-ID"].dt
++    own_start_prop = governing.get("DTSTART")
++    own_start = getattr(own_start_prop, "dt", None)
++    shift = timedelta(0)
++    if own_start is not None and type(own_start) is type(rid):
++        try:
++            shift = own_start - rid
++        except TypeError:
++            # One side floating, the other zoned: no instant to measure by.
++            shift = timedelta(0)
++    new_start = ts_for_dtstart + shift
++    if (
++        isinstance(new_start, datetime)
++        and isinstance(own_start, datetime)
++        and new_start.tzinfo is not None
++        and own_start.tzinfo is not None
++    ):
++        new_start = new_start.astimezone(own_start.tzinfo)
++    new_dtstart = create_prop_from_date_or_datetime(new_start)
++    params = getattr(own_start_prop, "params", None)
++    if params:
++        new_dtstart.params = params.copy()
++    outcomp["DTSTART"] = new_dtstart
++    for end_prop in ("DTEND", "DUE"):
++        if end_prop in governing and own_start is not None:
++            length = governing[end_prop].dt - own_start
++            new_end = create_prop_from_date_or_datetime(new_start + length)
++            end_params = getattr(governing[end_prop], "params", None)
++            if end_params:
++                new_end.params = end_params.copy()
++            outcomp[end_prop] = new_end
++    return outcomp
++
++
+ def expand_calendar_rrule(
+     incal: Calendar, start: datetime | None = None, end: datetime | None = None
+ ) -> Calendar:
+@@ -2322,6 +2406,12 @@ def expand_calendar_rrule(
+             assert isinstance(rec_id.dt, date | datetime)
+             ts = asutc(rec_id.dt)
+             exceptions[ts] = comp
++    # Exceptions that speak for the rest of the series as well as their own
++    # occurrence, earliest first.
++    onwards = sorted(
++        ((ts, comp) for ts, comp in exceptions.items() if _is_onwards(comp)),
++        key=lambda item: (isinstance(item[0], datetime), str(item[0])),
++    )
+ 
+     # Process all components
+     for comp in incal.subcomponents:
+@@ -2333,7 +2423,9 @@ def expand_calendar_rrule(
+             pass
+         elif "RRULE" in comp:
+             # Expand recurring events
+-            for expanded in _expand_rrule_component(comp, start, end, exceptions):
++            for expanded in _expand_rrule_component(
++                comp, start, end, exceptions, onwards
++            ):
+                 outcal.add_component(expanded)
+         else:
+             # Include non-recurring events
+diff --git a/xandikos/itip.py b/xandikos/itip.py
+index 83e3851..71b070e 100644
+--- a/xandikos/itip.py
++++ b/xandikos/itip.py
+@@ -26,6 +26,7 @@ signature from iTIP-relevant properties — separately from the CalDAV
+ plumbing in :mod:`xandikos.scheduling` that exposes them over HTTP.
+ """
+ 
++import copy
+ import datetime
+ import hashlib
+ 
+@@ -454,20 +455,400 @@ def strip_method(itip_message: Calendar) -> Calendar:
+     return out
+ 
+ 
++def recurrence_key(comp: Component) -> str:
++    """Return a stable name for the occurrence *comp* speaks about.
++
++    RECURRENCE-ID (RFC 5545 §3.8.4.4) names one occurrence of a recurring
++    event by its original start, and the same instant has more than one
++    written form: ``20260602T100000Z``, ``TZID=Europe/Berlin:20260602T120000``
++    and ``TZID=UTC:20260602T100000`` are one occurrence between them. Keying
++    on the text would make them three, so the key comes from the parsed
++    value. The series' own component carries no RECURRENCE-ID and keys as
++    the empty string.
++    """
++    rid = comp.get("RECURRENCE-ID")
++    if rid is None:
++        return ""
++    return _instant_key(rid)
++
++
++def _instant_key(prop: PropTypes) -> str:
++    """Key one date-time property by the instant it denotes."""
++    dt = getattr(prop, "dt", None)
++    if isinstance(dt, datetime.datetime):
++        if dt.tzinfo is not None:
++            dt = dt.astimezone(datetime.timezone.utc)
++            return dt.strftime("%Y%m%dT%H%M%SZ")
++        # A floating time has no instant until a time zone is chosen; it can
++        # only be the same occurrence as another floating time.
++        return dt.strftime("%Y%m%dT%H%M%S")
++    if isinstance(dt, datetime.date):
++        return dt.strftime("%Y%m%d")
++    rendered = prop.to_ical()
++    return rendered.decode("utf-8") if isinstance(rendered, bytes) else str(rendered)
++
++
++def itip_occurrences(
++    itip_message: Component, uid: str
++) -> "dict[str, PropTypes | None]":
++    """Map occurrence key -> its RECURRENCE-ID property, for *uid* in a message.
++
++    The series' own component maps to None. Used to decide which components
++    of a stored object a message speaks about, and — for keys the stored
++    object has no component for — to break the occurrence out.
++    """
++    out: dict[str, PropTypes | None] = {}
++    for comp in itip_message.subcomponents:
++        if comp.name not in SCHEDULING_COMPONENTS:
++            continue
++        if str(comp.get("UID", "")) != uid:
++            continue
++        rid = comp.get("RECURRENCE-ID")
++        out[recurrence_key(comp)] = rid
++    return out
++
++
++def covers_series(itip_message: Component, uid: str) -> bool:
++    """True if *itip_message* carries the series itself, not single occurrences."""
++    return "" in itip_occurrences(itip_message, uid)
++
++
++def occurrences_for_attendee(cal: Component, address: str) -> "set[str]":
++    """Occurrence keys of *cal* on which *address* is an ATTENDEE."""
++    found: set[str] = set()
++    for comp in cal.subcomponents:
++        if comp.name not in SCHEDULING_COMPONENTS:
++            continue
++        if _find_attendee(comp, address) is not None:
++            found.add(recurrence_key(comp))
++    return found
++
++
++def narrow_to_occurrences(cal: Component, keys: "set[str]") -> Calendar:
++    """Return a copy of *cal* carrying only the occurrences in *keys*.
++
++    Non-scheduling components (VTIMEZONE and friends) are kept, so the
++    result is still a self-contained calendar object.
++    """
++    out = Calendar()
++    for field in cal:
++        out[field] = cal[field]
++    for comp in cal.subcomponents:
++        if comp.name not in SCHEDULING_COMPONENTS or recurrence_key(comp) in keys:
++            out.add_component(comp.copy())
++    return out
++
++
++def series_produces(cal: Calendar, uid: str, rid: PropTypes) -> bool:
++    """True if *uid*'s recurrence set in *cal* produces the occurrence *rid*.
++
++    The question a message about a single occurrence raises before anything
++    else: an occurrence the series does produce is ours to apply the message
++    to, whether or not we keep a component for it, and an instant the series
++    never produces is not ours to invent.
++    """
++    if _expand_occurrence(cal, uid, rid) is not None:
++        return True
++    return _named_by_a_recurrence_date(cal, uid, rid)
++
++
++def _named_by_a_recurrence_date(cal: Calendar, uid: str, rid: PropTypes) -> bool:
++    """True if the series names *rid* outright on an RDATE and does not exclude it.
++
++    RFC 5545 §3.8.5.2: a date named on RDATE is in the recurrence set as much
++    as one the rule produces. It is asked here rather than left to the
++    expansion because the expansion works from the rule.
++    """
++    wanted = _instant_key(rid)
++    for comp in cal.subcomponents:
++        if comp.name not in SCHEDULING_COMPONENTS:
++            continue
++        if str(comp.get("UID", "")) != uid or "RECURRENCE-ID" in comp:
++            continue
++        if wanted in _dates_named(comp, "EXDATE"):
++            return False
++        if wanted in _dates_named(comp, "RDATE"):
++            return True
++    return False
++
++
++def _dates_named(comp: Component, field: str) -> "set[str]":
++    """The instants *field* names on *comp*, keyed the way occurrences are."""
++    out: set[str] = set()
++    value = comp.get(field)
++    if value is None:
++        return out
++    for entry in value if isinstance(value, list) else [value]:
++        for item in getattr(entry, "dts", None) or []:
++            out.add(_instant_key(item))
++    return out
++
++
++def materialise_occurrence(
++    cal: Calendar, uid: str, rid: PropTypes
++) -> "Component | None":
++    """Break the occurrence *rid* out of *uid*'s series as its own component.
++
++    A scheduling message may speak about an occurrence the stored object
++    never needed a component for: the organiser never moved it, so it lives
++    inside the series' RRULE. Applying the message to that occurrence alone
++    means giving it the exception component RFC 5545 §3.8.4.4 describes,
++    derived from the series exactly as an expansion would derive it.
++
++    Returns the new component, already added to *cal*, or None if the
++    recurrence set holds no such occurrence (an occurrence that is not in
++    the series is not ours to invent).
++    """
++    occurrence = _expand_occurrence(cal, uid, rid)
++    if occurrence is None:
++        return None
++    # A deep copy: the expansion hands back property objects the series
++    # still holds, and an exception that shares its ATTENDEE entries with
++    # the series would carry every answer back into it.
++    broken_out = copy.deepcopy(occurrence)
++    # The exception describes one occurrence; the recurrence rules stay
++    # with the series.
++    for field in ("RRULE", "EXRULE", "RDATE", "EXDATE"):
++        if field in broken_out:
++            del broken_out[field]
++    cal.add_component(broken_out)
++    return broken_out
++
++
++def _expand_occurrence(cal: Calendar, uid: str, rid: PropTypes) -> "Component | None":
++    """Return the occurrence *rid* as *uid*'s series produces it, or None.
++
++    Reads the stored object; writes nothing to it.
++    """
++    from xandikos.icalendar import expand_calendar_rrule
++
++    master = None
++    for comp in cal.subcomponents:
++        if (
++            comp.name in SCHEDULING_COMPONENTS
++            and str(comp.get("UID", "")) == uid
++            and "RECURRENCE-ID" not in comp
++        ):
++            master = comp
++            break
++    if master is None or "RRULE" not in master:
++        return None
++
++    target = getattr(rid, "dt", None)
++    if isinstance(target, datetime.datetime):
++        moment = target
++    elif isinstance(target, datetime.date):
++        moment = datetime.datetime.combine(target, datetime.time())
++    else:
++        return None
++    if moment.tzinfo is None:
++        moment = moment.replace(tzinfo=datetime.timezone.utc)
++    window = datetime.timedelta(days=1)
++
++    # The series, and the exceptions that speak for the rest of it from their
++    # own occurrence on (RANGE=THISANDFUTURE): an occurrence after one of
++    # those is what that exception made of it, not what the rule alone says.
++    # Deep copies — the expansion rewrites the RECURRENCE-IDs it hands back.
++    probe = Calendar()
++    probe.add_component(copy.deepcopy(master))
++    for comp in cal.subcomponents:
++        if (
++            comp.name in SCHEDULING_COMPONENTS
++            and str(comp.get("UID", "")) == uid
++            and _speaks_onwards(comp)
++        ):
++            probe.add_component(copy.deepcopy(comp))
++    wanted = _instant_key(rid)
++    for occurrence in expand_calendar_rrule(
++        probe, moment - window, moment + window
++    ).subcomponents:
++        if occurrence.name not in SCHEDULING_COMPONENTS:
++            continue
++        if recurrence_key(occurrence) != wanted:
++            continue
++        return occurrence
++    return None
++
++
++def _speaks_onwards(comp: Component) -> bool:
++    """True if *comp*'s RECURRENCE-ID carries RANGE=THISANDFUTURE."""
++    rid = comp.get("RECURRENCE-ID")
++    if rid is None:
++        return False
++    rng = rid.params.get("RANGE")
++    return rng is not None and str(rng).upper() == "THISANDFUTURE"
++
++
++def onwards_targets(cal: Calendar, uid: str, rid: PropTypes) -> "list[Component]":
++    """Return the components that speak for *rid* and every later occurrence.
++
++    That is every component *cal* already keeps for an occurrence at or after
++    *rid*, and one more: the first occurrence from *rid* on that has no
++    component of its own is broken out of the series and marked
++    RANGE=THISANDFUTURE (RFC 5545 §3.8.4.4), so that what is applied to it
++    holds for the occurrences after it too — including the ones an open-ended
++    rule has not produced yet. An occurrence we keep as its own exception
++    stays that occurrence's own and is returned among the rest. Returns an
++    empty list when *uid* has nothing at or after *rid*.
++    """
++    boundary = _as_instant(rid)
++    if boundary is None:
++        return []
++    targets: list[Component] = []
++    held: set[str] = set()
++    master = None
++    for comp in cal.subcomponents:
++        if comp.name not in SCHEDULING_COMPONENTS:
++            continue
++        if str(comp.get("UID", "")) != uid:
++            continue
++        if "RECURRENCE-ID" not in comp:
++            master = comp
++            continue
++        held.add(recurrence_key(comp))
++        own = _as_instant(comp.get("RECURRENCE-ID"))
++        if own is not None and own >= boundary:
++            targets.append(comp)
++    if master is None or "RRULE" not in master:
++        return targets
++    from xandikos.icalendar import rruleset_from_comp, _normalize_dt_for_rrule
++
++    start = getattr(master.get("DTSTART"), "dt", None)
++    if start is None:
++        return targets
++    rules = rruleset_from_comp(master)
++    moment = rid.dt if isinstance(rid.dt, datetime.datetime) else boundary
++    probe = _normalize_dt_for_rrule(moment, start)
++    for occurrence in rules.xafter(probe, count=len(held) + 2, inc=True):
++        value = occurrence if isinstance(start, datetime.datetime) else occurrence.date()
++        name = _instant_key(vDDDTypes(value))
++        if name in held:
++            continue
++        broken_out = materialise_occurrence(cal, uid, vDDDTypes(value))
++        if broken_out is not None:
++            broken_out["RECURRENCE-ID"].params["RANGE"] = "THISANDFUTURE"
++            targets.append(broken_out)
++        break
++    return targets
++
++
++def thisandfuture_occurrence(itip_message: Component, uid: str) -> "PropTypes | None":
++    """Return the RECURRENCE-ID a message marks as standing for the tail.
++
++    RFC 5545 §3.2.13: ``RECURRENCE-ID;RANGE=THISANDFUTURE`` names the
++    occurrence it carries *and every later one*, so a message that uses it
++    speaks about a stretch of the series rather than a single occurrence.
++    Returns that property, or None when no component uses the parameter.
++    """
++    for comp in itip_message.subcomponents:
++        if comp.name not in SCHEDULING_COMPONENTS:
++            continue
++        if str(comp.get("UID", "")) != uid:
++            continue
++        rid = comp.get("RECURRENCE-ID")
++        if rid is None:
++            continue
++        rng = rid.params.get("RANGE")
++        if rng is not None and str(rng).upper() == "THISANDFUTURE":
++            return rid
++    return None
++
++
++def end_series_at(cal: Calendar, uid: str, rid: PropTypes) -> bool:
++    """Stop *uid*'s series just before *rid*, and cancel later exceptions.
++
++    The occurrences from *rid* onwards stop happening: the recurrence rule
++    is given an UNTIL that lands before them, and any exception component
++    already broken out at or after that instant is marked CANCELLED. What
++    came before is left exactly as it was. Returns False when there is
++    nothing of *uid* to do this to.
++    """
++    boundary = _as_instant(rid)
++    if boundary is None:
++        return False
++    touched = False
++    for comp in cal.subcomponents:
++        if comp.name not in SCHEDULING_COMPONENTS:
++            continue
++        if str(comp.get("UID", "")) != uid:
++            continue
++        own = (
++            _as_instant(comp.get("RECURRENCE-ID")) if "RECURRENCE-ID" in comp else None
++        )
++        if own is not None:
++            if own >= boundary:
++                comp["STATUS"] = "CANCELLED"
++                touched = True
++            continue
++        if "RRULE" in comp:
++            rrule = comp["RRULE"]
++            last = _until_beside(
++                boundary - datetime.timedelta(seconds=1), comp.get("DTSTART")
++            )
++            try:
++                del rrule["COUNT"]
++            except KeyError:
++                pass
++            # COUNT and UNTIL cannot both be present (RFC 5545 §3.3.10).
++            rrule["UNTIL"] = [last]
++            comp["RRULE"] = rrule
++            touched = True
++        else:
++            own_start = _as_instant(comp.get("DTSTART"))
++            if own_start is not None and own_start >= boundary:
++                comp["STATUS"] = "CANCELLED"
++                touched = True
++    return touched
++
++
++def _until_beside(moment: datetime.datetime, start: "PropTypes | None"):
++    """Write *moment* the way an UNTIL beside this DTSTART has to be written.
++
++    RFC 5545 §3.3.10: UNTIL takes the value type of DTSTART, and it is a UTC
++    date-time whenever DTSTART is one or carries a time zone. The boundary
++    arrives written in whatever zone the sender chose, which is the same
++    instant as ours written differently — so it is converted, not copied. A
++    local time written without its zone is a different instant for every
++    reader, and the occurrence that instant lands on is off by the offset.
++    """
++    dt = getattr(start, "dt", None)
++    if isinstance(dt, datetime.datetime):
++        moment = moment.astimezone(datetime.timezone.utc)
++        # A floating DTSTART has no zone to be an offset from; its UNTIL
++        # floats with it.
++        return moment if dt.tzinfo is not None else moment.replace(tzinfo=None)
++    if isinstance(dt, datetime.date):
++        return moment.astimezone(datetime.timezone.utc).date()
++    return moment
++
++
++def _as_instant(prop: "PropTypes | None") -> "datetime.datetime | None":
++    """Return *prop*'s value as a comparable instant, or None."""
++    dt = getattr(prop, "dt", None)
++    if isinstance(dt, datetime.datetime):
++        return dt if dt.tzinfo is not None else dt.replace(tzinfo=datetime.timezone.utc)
++    if isinstance(dt, datetime.date):
++        return datetime.datetime.combine(dt, datetime.time(), datetime.timezone.utc)
++    return None
++
++
+ def preserve_partstats(existing: Calendar, incoming: Calendar) -> Calendar:
+     """Mutate *incoming* in place so attendee PARTSTATs survive a re-REQUEST.
+ 
+     RFC 6638 §3.2.1: when an organiser sends a fresh REQUEST, the
+     attendee's prior PARTSTAT must survive. We match attendees across
+-    components by (UID, RECURRENCE-ID, ATTENDEE address). Returns the
+-    same *incoming* object for chaining.
++    components by (UID, occurrence, ATTENDEE address) — by the occurrence
++    itself, not by the text that wrote it, or the same occurrence named in
++    the sender's own time zone would look like a new one and the answer
++    already given for it would be thrown away. Returns the same *incoming*
++    object for chaining.
+     """
+     existing_partstats: dict[tuple[str, str, str], str] = {}
+     for comp in existing.subcomponents:
+         if comp.name not in SCHEDULING_COMPONENTS:
+             continue
+         uid = str(comp.get("UID", ""))
+-        rid = str(comp.get("RECURRENCE-ID", ""))
++        rid = recurrence_key(comp)
+         attendees = comp.get("ATTENDEE", [])
+         if not isinstance(attendees, list):
+             attendees = [attendees]
+@@ -480,7 +861,7 @@ def preserve_partstats(existing: Calendar, incoming: Calendar) -> Calendar:
+         if comp.name not in SCHEDULING_COMPONENTS:
+             continue
+         uid = str(comp.get("UID", ""))
+-        rid = str(comp.get("RECURRENCE-ID", ""))
++        rid = recurrence_key(comp)
+         attendees = comp.get("ATTENDEE", [])
+         if not isinstance(attendees, list):
+             attendees = [attendees]
+diff --git a/xandikos/web.py b/xandikos/web.py
+index 8b148f8..2ce619d 100644
+--- a/xandikos/web.py
++++ b/xandikos/web.py
+@@ -86,7 +86,7 @@ from xandikos.store import (
+     Store,
+ )
+ 
+-from icalendar.cal import Calendar
++from icalendar.cal import Calendar, Component
+ from icalendar.cal import Timezone as VTimezone
+ 
+ from .icalendar import CalendarFilter, ICalendarFile
+@@ -910,6 +910,19 @@ class ScheduleInbox(StoreBasedCollection, scheduling.ScheduleInbox):
+             return
+         member_name, member, existing_cal = existing
+         merged = itip.preserve_partstats(existing_cal, new_cal)
++        if not itip.covers_series(itip_message, uid):
++            # A REQUEST that names occurrences updates those occurrences; the
++            # series it does not carry is not ours to drop, and an occurrence
++            # the series does not produce is not ours to add.
++            narrowed = _occurrences_of_the_series(existing_cal, merged, uid)
++            if narrowed is None:
++                logger.info(
++                    "Inbox auto-apply: REQUEST for %s named no occurrence the "
++                    "series produces",
++                    uid,
++                )
++                return
++            merged = _splice_occurrences(existing_cal, narrowed)
+         await _replace_member_body(member, merged)
+         logger.info(
+             "Inbox auto-apply: updated %s (%s) in %s for REQUEST",
+@@ -930,14 +943,33 @@ class ScheduleInbox(StoreBasedCollection, scheduling.ScheduleInbox):
+             )
+             return
+         member_name, member, existing_cal = existing
+-        for comp in existing_cal.subcomponents:
+-            if (
+-                comp.name in itip.SCHEDULING_COMPONENTS
+-                and str(comp.get("UID", "")) == uid
+-            ):
+-                comp["STATUS"] = "CANCELLED"
++        onwards = itip.thisandfuture_occurrence(itip_message, uid)
++        if onwards is not None:
++            if not itip.end_series_at(existing_cal, uid, onwards):
++                logger.info(
++                    "Inbox auto-apply: CANCEL for %s named nothing we hold", uid
++                )
++                return
++            await _replace_member_body(member, existing_cal)
++            logger.info(
++                "Inbox auto-apply: cancelled %s (%s) from one occurrence onwards",
++                uid,
++                member_name,
++            )
++            return
++        targets = _occurrence_targets(existing_cal, itip_message, uid)
++        if not targets:
++            logger.info("Inbox auto-apply: CANCEL for %s named nothing we hold", uid)
++            return
++        for comp in targets:
++            comp["STATUS"] = "CANCELLED"
+         await _replace_member_body(member, existing_cal)
+-        logger.info("Inbox auto-apply: cancelled %s (%s)", uid, member_name)
++        logger.info(
++            "Inbox auto-apply: cancelled %d occurrence(s) of %s (%s)",
++            len(targets),
++            uid,
++            member_name,
++        )
+ 
+     async def _apply_reply(
+         self,
+@@ -952,34 +984,51 @@ class ScheduleInbox(StoreBasedCollection, scheduling.ScheduleInbox):
+             return
+         member_name, member, existing_cal = existing
+ 
+-        # Pick out the replying attendee's address + new PARTSTAT.
+-        updates: dict[str, str] = {}
++        # Pick out the replying attendee's address + new PARTSTAT, per the
++        # occurrence the answer is about.
++        updates: dict[tuple[str, str], str] = {}
+         for comp in itip_message.subcomponents:
+             if comp.name not in itip.SCHEDULING_COMPONENTS:
+                 continue
+             if str(comp.get("UID", "")) != uid:
+                 continue
++            key = itip.recurrence_key(comp)
+             attendees = comp.get("ATTENDEE", [])
+             if not isinstance(attendees, list):
+                 attendees = [attendees]
+             for a in attendees:
+                 partstat = a.params.get("PARTSTAT")
+                 if partstat is not None:
+-                    updates[str(a)] = str(partstat)
++                    updates[(key, str(a))] = str(partstat)
+         if not updates:
+             return
+ 
++        # An answer that carries the series answers for all of it; an answer
++        # that names occurrences answers for those, whether or not we already
++        # keep a component for them.
++        whole = itip.covers_series(itip_message, uid)
++        # An answer marked RANGE=THISANDFUTURE is about the occurrence it
++        # names and every later one: it lands on each of those, and on none
++        # before.
++        onwards = itip.thisandfuture_occurrence(itip_message, uid)
++        if onwards is not None:
++            onwards_key = itip._instant_key(onwards)
++            targets = itip.onwards_targets(existing_cal, uid, onwards)
++        else:
++            onwards_key = None
++            targets = _occurrence_targets(existing_cal, itip_message, uid)
+         changed = False
+-        for comp in existing_cal.subcomponents:
+-            if comp.name not in itip.SCHEDULING_COMPONENTS:
+-                continue
+-            if str(comp.get("UID", "")) != uid:
+-                continue
++        for comp in targets:
++            key = itip.recurrence_key(comp)
+             attendees = comp.get("ATTENDEE", [])
+             if not isinstance(attendees, list):
+                 attendees = [attendees]
+             for a in attendees:
+-                new_partstat = updates.get(str(a))
++                new_partstat = updates.get((key, str(a)))
++                if new_partstat is None and onwards_key is not None:
++                    new_partstat = updates.get((onwards_key, str(a)))
++                if new_partstat is None and whole:
++                    new_partstat = updates.get(("", str(a)))
+                 if (
+                     new_partstat is not None
+                     and a.params.get("PARTSTAT") != new_partstat
+@@ -992,7 +1041,10 @@ class ScheduleInbox(StoreBasedCollection, scheduling.ScheduleInbox):
+                 "Inbox auto-apply: applied REPLY to %s (%s); updated PARTSTATs: %s",
+                 uid,
+                 member_name,
+-                ", ".join(f"{addr}={ps}" for addr, ps in updates.items()),
++                ", ".join(
++                    f"{addr}={ps}" + (f" ({key})" if key else "")
++                    for (key, addr), ps in updates.items()
++                ),
+             )
+         else:
+             logger.info(
+@@ -1002,6 +1054,115 @@ class ScheduleInbox(StoreBasedCollection, scheduling.ScheduleInbox):
+             )
+ 
+ 
++def _occurrence_targets(
++    existing_cal: Calendar, itip_message: Calendar, uid: str
++) -> "list[Component]":
++    """Return the stored components an iTIP message speaks about.
++
++    A message that carries the series speaks for the whole of it. A message
++    that names occurrences speaks for exactly those — and RFC 5546 lets it
++    name an occurrence the recipient keeps no component for, because the
++    recipient holds the series as one recurring component and the organiser
++    never had reason to move that occurrence. Such an occurrence is broken
++    out of the series first, so there is something to apply the message to.
++    """
++    occurrences = itip.itip_occurrences(itip_message, uid)
++    whole = "" in occurrences
++    targets: list[Component] = []
++    seen: set[str] = set()
++    for comp in existing_cal.subcomponents:
++        if comp.name not in itip.SCHEDULING_COMPONENTS:
++            continue
++        if str(comp.get("UID", "")) != uid:
++            continue
++        key = itip.recurrence_key(comp)
++        if whole or key in occurrences:
++            targets.append(comp)
++            seen.add(key)
++    if whole:
++        return targets
++    for key, rid in occurrences.items():
++        if key in seen or rid is None:
++            continue
++        broken_out = itip.materialise_occurrence(existing_cal, uid, rid)
++        if broken_out is not None:
++            targets.append(broken_out)
++    return targets
++
++
++def _occurrences_of_the_series(
++    existing_cal: Calendar, incoming: Calendar, uid: str
++) -> "Calendar | None":
++    """Drop *incoming*'s components for occurrences the series never produces.
++
++    A message may name an occurrence we keep no component for: the organiser
++    never moved it, so it lives inside the RRULE, and it is ours to break
++    out. An instant the recurrence set does not produce at all is a
++    different matter — taking that one would put a meeting in the calendar
++    that nobody scheduled, under the UID of one that exists. Components of
++    other UIDs, and the VTIMEZONEs, travel through untouched.
++
++    Returns None when nothing of *uid* survives, so the caller can leave the
++    stored object exactly as it was.
++    """
++    held = {
++        itip.recurrence_key(comp)
++        for comp in existing_cal.subcomponents
++        if comp.name in itip.SCHEDULING_COMPONENTS and str(comp.get("UID", "")) == uid
++    }
++    if "" not in held:
++        # What we keep of this event is occurrences and no series. There is no
++        # recurrence set here to say what it does and does not produce, so
++        # there is nothing to refuse: each occurrence stands on its own.
++        return incoming
++    out = Calendar()
++    for field in incoming:
++        out[field] = incoming[field]
++    kept = 0
++    for comp in incoming.subcomponents:
++        if (
++            comp.name not in itip.SCHEDULING_COMPONENTS
++            or str(comp.get("UID", "")) != uid
++        ):
++            out.add_component(comp)
++            continue
++        rid = comp.get("RECURRENCE-ID")
++        if (
++            itip.recurrence_key(comp) in held
++            or rid is None
++            or itip.series_produces(existing_cal, uid, rid)
++        ):
++            out.add_component(comp)
++            kept += 1
++    return out if kept else None
++
++
++def _splice_occurrences(existing_cal: Calendar, incoming: Calendar) -> Calendar:
++    """Put *incoming*'s components in their place inside *existing_cal*.
++
++    Components are matched by name, UID and occurrence, so an update that
++    names one occurrence replaces that occurrence and leaves the rest of the
++    series where it was — and the same occurrence written a second way
++    replaces the first rather than joining it.
++    """
++    out = Calendar()
++    for field in existing_cal:
++        out[field] = existing_cal[field]
++    by_key: dict = {}
++    order: list = []
++    for comp in list(existing_cal.subcomponents) + list(incoming.subcomponents):
++        if comp.name in itip.SCHEDULING_COMPONENTS:
++            key = (comp.name, str(comp.get("UID", "")), itip.recurrence_key(comp))
++        else:
++            key = (comp.name, comp.to_ical())
++        if key not in by_key:
++            order.append(key)
++        by_key[key] = comp
++    for key in order:
++        out.add_component(by_key[key])
++    return out
++
++
+ async def _find_calendar_member_by_uid(
+     calendar: "CalendarCollection", uid: str
+ ) -> "tuple[str, ObjectResource, Calendar] | None":
+@@ -1522,24 +1683,26 @@ class CalendarCollection(StoreBasedCollection, caldav.Calendar):
+         new_cal: Calendar,
+         old_cal: Calendar,
+         own_addresses: set[str],
+-        new_delegates: set[str],
++        new_delegates: "set[tuple[str, str]]",
+     ) -> None:
+         """Raise if *new_cal* changes anything beyond the user's own ATTENDEE.
+ 
+         Compares scheduling signatures of *old_cal* and *new_cal* with
+         the user's own ATTENDEE parameters masked, and any newly-added
+-        delegates skipped entirely (RFC 6638 §3.2.6 lets an attendee
+-        add a delegate ATTENDEE, distinguishable by its DELEGATED-FROM
+-        pointing back at the user). If anything else differs, the user
+-        is touching organiser-owned data.
++        delegates dropped where they were added (RFC 6638 §3.2.6 lets an
++        attendee add a delegate ATTENDEE, distinguishable by its
++        DELEGATED-FROM pointing back at the user). The exception is as
++        narrow as the delegation: it covers the occurrences the user
++        actually delegated, not every occurrence that happens to mention
++        the same address. If anything else differs, the user is touching
++        organiser-owned data.
+         """
+         mask = frozenset(own_addresses)
+-        skip = frozenset(new_delegates)
+         new_masked = itip.extract_scheduling_signature(
+-            new_cal, mask_own_attendee_params=mask, skip_attendees=skip
++            _without_attendees(new_cal, new_delegates), mask_own_attendee_params=mask
+         )
+         old_masked = itip.extract_scheduling_signature(
+-            old_cal, mask_own_attendee_params=mask, skip_attendees=skip
++            old_cal, mask_own_attendee_params=mask
+         )
+         if new_masked != old_masked:
+             raise webdav.PreconditionFailure(
+@@ -1555,31 +1718,45 @@ class CalendarCollection(StoreBasedCollection, caldav.Calendar):
+         old_cal: Calendar | None,
+         new_attendees: set[str],
+         own_addresses: set[str],
+-    ) -> dict[str, str]:
+-        """Send REQUEST/CANCEL and return ``{address: SCHEDULE-STATUS code}``."""
+-        outcomes: dict[str, str] = {}
++    ) -> "dict[str, tuple[str, frozenset[str]]]":
++        """Send REQUEST/CANCEL; return ``{address: (code, occurrences sent)}``.
++
++        An attendee is invited to the occurrences that list them, which for a
++        series with exceptions need not be all of them, so each attendee is
++        sent the occurrences that are theirs. The occurrences that went out
++        travel back with the delivery outcome: the record of a delivery
++        belongs on what was delivered.
++        """
++        outcomes: dict[str, tuple[str, frozenset[str]]] = {}
+         organiser = _organiser_address(new_cal)
+-        if new_attendees:
+-            request = itip.build_itip_request(new_cal)
+-            for address in new_attendees:
+-                outcomes[address] = await _deliver_status(
++        invited = {a: itip.occurrences_for_attendee(new_cal, a) for a in new_attendees}
++        for address, keys in invited.items():
++            if not keys:
++                continue
++            request = itip.build_itip_request(itip.narrow_to_occurrences(new_cal, keys))
++            outcomes[address] = (
++                await _deliver_status(
+                     self.backend, address, request, originator=organiser
+-                )
++                ),
++                frozenset(keys),
++            )
+ 
+         if old_cal is None:
+             return outcomes
+         _, old_attendees = _organiser_attendees(old_cal, own_addresses)
+-        dropped = old_attendees - new_attendees
+-        if dropped:
+-            cancel = itip.build_itip_cancel(old_cal)
+-            for address in dropped:
+-                # Dropped attendees aren't in new_cal, so their CANCEL
+-                # delivery outcomes don't end up annotated anywhere; the
+-                # CANCEL itself is the record. Still goes through the
+-                # iMIP path for non-local recipients.
+-                await _deliver_status(
+-                    self.backend, address, cancel, originator=organiser
+-                )
++        for address in old_attendees:
++            lost = itip.occurrences_for_attendee(old_cal, address) - invited.get(
++                address, set()
++            )
++            if not lost:
++                continue
++            # An attendee who has lost an occurrence — or the whole event —
++            # is told about what they lost and nothing else. Their CANCEL
++            # outcome isn't annotated anywhere (they may not be in new_cal at
++            # all); the CANCEL itself is the record. Still goes through the
++            # iMIP path for non-local recipients.
++            cancel = itip.build_itip_cancel(itip.narrow_to_occurrences(old_cal, lost))
++            await _deliver_status(self.backend, address, cancel, originator=organiser)
+         return outcomes
+ 
+     async def _dispatch_attendee_put(
+@@ -1588,25 +1765,32 @@ class CalendarCollection(StoreBasedCollection, caldav.Calendar):
+         old_cal: Calendar | None,
+         own_addresses: set[str],
+         force_reply: set[str],
+-        new_delegates: set[str],
+-    ) -> dict[str, str]:
++        new_delegates: "set[tuple[str, str]]",
++    ) -> "dict[str, tuple[str, frozenset[str]]]":
+         """Send REPLY to organiser and REQUEST to any newly-added delegates.
+ 
+-        Returns ``{address: SCHEDULE-STATUS code}`` for the delegate
++        Returns ``{address: (code, occurrences sent)}`` for the delegate
+         deliveries; the REPLY itself isn't annotated (the user's own
+         ATTENDEE doesn't carry SCHEDULE-STATUS).
+         """
+-        outcomes: dict[str, str] = {}
++        outcomes: dict[str, tuple[str, frozenset[str]]] = {}
+         own_address = _own_attendee_address(new_cal, own_addresses)
+ 
+-        # RFC 6638 §3.2.6: when the user delegates to someone else,
+-        # the new delegate needs a REQUEST so they see the meeting.
+-        if new_delegates:
+-            request = itip.build_itip_request(new_cal)
+-            for address in new_delegates:
+-                outcomes[address] = await _deliver_status(
++        # RFC 6638 §3.2.6: when the user delegates to someone else, the new
++        # delegate needs a REQUEST so they see the meeting — the part of it
++        # they were handed, which for a single delegated occurrence is that
++        # occurrence and not the rest of the series.
++        delegated: dict[str, set[str]] = {}
++        for key, address in new_delegates:
++            delegated.setdefault(address, set()).add(key)
++        for address, keys in delegated.items():
++            request = itip.build_itip_request(itip.narrow_to_occurrences(new_cal, keys))
++            outcomes[address] = (
++                await _deliver_status(
+                     self.backend, address, request, originator=own_address
+-                )
++                ),
++                frozenset(keys),
++            )
+ 
+         if own_address is None:
+             return outcomes
+@@ -1724,24 +1908,34 @@ def _strip_mailto(address: str) -> str:
+     return address
+ 
+ 
+-def _annotate_schedule_status(cal: Calendar, outcomes: dict[str, str]) -> None:
++def _annotate_schedule_status(
++    cal: Calendar, outcomes: "dict[str, tuple[str, frozenset[str]]]"
++) -> None:
+     """Stamp SCHEDULE-STATUS on each ATTENDEE per RFC 6638 §3.2.
+ 
+-    *outcomes* maps an attendee address (as it appears in ATTENDEE) to
+-    a request-status code. Attendees absent from *outcomes* are left
+-    alone — typically the organiser themselves, who we don't deliver
++    *outcomes* maps an attendee address (as it appears in ATTENDEE) to the
++    request-status code of the delivery and the occurrences that delivery
++    carried. The stamp is the record of that delivery, so it goes on the
++    occurrences that were sent and nowhere else: an occurrence nobody was
++    told about has not been delivered. Attendees absent from *outcomes* are
++    left alone — typically the organiser themselves, who we don't deliver
+     to.
+     """
+     for comp in cal.subcomponents:
+         if comp.name not in itip.SCHEDULING_COMPONENTS:
+             continue
++        key = itip.recurrence_key(comp)
+         attendees = comp.get("ATTENDEE", [])
+         if not isinstance(attendees, list):
+             attendees = [attendees]
+         for a in attendees:
+-            status = outcomes.get(str(a))
+-            if status is not None:
+-                a.params["SCHEDULE-STATUS"] = status
++            outcome = outcomes.get(str(a))
++            if outcome is None:
++                continue
++            status, sent = outcome
++            if key not in sent:
++                continue
++            a.params["SCHEDULE-STATUS"] = status
+ 
+ 
+ def _consume_force_send(cal: Calendar) -> tuple[set[str], set[str], bool]:
+@@ -1813,19 +2007,22 @@ def _organiser_attendees(
+     return is_organiser, attendees
+ 
+ 
+-def _delegates_of(cal: Calendar, own_addresses: set[str]) -> set[str]:
+-    """Return ATTENDEE addresses delegated FROM one of *own_addresses*.
++def _delegates_of(cal: Calendar, own_addresses: set[str]) -> "set[tuple[str, str]]":
++    """Return ``(occurrence, ATTENDEE)`` pairs delegated FROM *own_addresses*.
+ 
+     RFC 5545 §3.8.4.4: an ATTENDEE may carry DELEGATED-FROM listing
+     the address(es) that delegated to them. We pick the entries
+     whose DELEGATED-FROM matches the user — those are the user's
+     delegates and the user is allowed to add them on a PUT
+-    (RFC 6638 §3.2.6).
++    (RFC 6638 §3.2.6). A delegation is made on an occurrence, so the
++    occurrence travels with the address: handing over one occurrence of a
++    series says nothing about the others.
+     """
+-    out: set[str] = set()
++    out: set[tuple[str, str]] = set()
+     for comp in cal.subcomponents:
+         if comp.name not in itip.SCHEDULING_COMPONENTS:
+             continue
++        key = itip.recurrence_key(comp)
+         comp_attendees = comp.get("ATTENDEE", [])
+         if not isinstance(comp_attendees, list):
+             comp_attendees = [comp_attendees]
+@@ -1837,7 +2034,28 @@ def _delegates_of(cal: Calendar, own_addresses: set[str]) -> set[str]:
+                 delegated_from if isinstance(delegated_from, list) else [delegated_from]
+             )
+             if any(str(src) in own_addresses for src in sources):
+-                out.add(str(a))
++                out.add((key, str(a)))
++    return out
++
++
++def _without_attendees(cal: Calendar, pairs: "set[tuple[str, str]]") -> Calendar:
++    """Return a copy of *cal* with those ``(occurrence, ATTENDEE)`` pairs gone."""
++    out = Calendar()
++    for field in cal:
++        out[field] = cal[field]
++    for comp in cal.subcomponents:
++        clone = comp.copy()
++        if clone.name in itip.SCHEDULING_COMPONENTS:
++            key = itip.recurrence_key(clone)
++            attendees = clone.get("ATTENDEE", [])
++            if not isinstance(attendees, list):
++                attendees = [attendees]
++            kept = [a for a in attendees if (key, str(a)) not in pairs]
++            if len(kept) != len(attendees):
++                del clone["ATTENDEE"]
++                for a in kept:
++                    clone.add("ATTENDEE", a)
++        out.add_component(clone)
+     return out
+ 
+ 
+@@ -1887,7 +2105,11 @@ def _partstat_changed(new_cal: Calendar, old_cal: Calendar, address: str) -> boo
+ 
+ 
+ def _user_partstats(cal: Calendar, address: str) -> dict[tuple[str, str, str], str]:
+-    """Map (component-name, UID, RECURRENCE-ID) → PARTSTAT for *address*."""
++    """Map (component-name, UID, occurrence) → PARTSTAT for *address*.
++
++    Keyed by the occurrence itself: rewriting the same occurrence in another
++    time zone is not the user answering again.
++    """
+     out: dict[tuple[str, str, str], str] = {}
+     for comp in cal.subcomponents:
+         if comp.name not in itip.SCHEDULING_COMPONENTS:
+@@ -1899,7 +2121,7 @@ def _user_partstats(cal: Calendar, address: str) -> dict[tuple[str, str, str], s
+             if str(a) != address:
+                 continue
+             uid = str(comp.get("UID", ""))
+-            rid = str(comp.get("RECURRENCE-ID", ""))
++            rid = itip.recurrence_key(comp)
+             partstat = str(a.params.get("PARTSTAT", "NEEDS-ACTION"))
+             out[(comp.name, uid, rid)] = partstat
+             break

harbor/tasks/xandikos_itip_recurrence_id_override_contract/solution/solve.sh

@@ -0,0 +1,1868 @@
+#!/bin/bash
+set -eu
+cd /workspace/repo
+git apply <<'REFERENCE_PATCH'
+diff --git a/tests/test_itip_per_instance.py b/tests/test_itip_per_instance.py
+new file mode 100644
+index 0000000..f562977
+--- /dev/null
++++ b/tests/test_itip_per_instance.py
+@@ -0,0 +1,769 @@
++# Xandikos
++# Copyright (C) 2016-2017 Jelmer Vernooij <jelmer@jelmer.uk>, et al.
++#
++# This program is free software; you can redistribute it and/or
++# modify it under the terms of the GNU General Public License
++# as published by the Free Software Foundation; version 3
++# of the License or (at your option) any later version of
++# the License.
++#
++# This program is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++# GNU General Public License for more details.
++#
++# You should have received a copy of the GNU General Public License
++# along with this program; if not, write to the Free Software
++# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
++# MA  02110-1301, USA.
++
++"""Scheduling messages that speak about single occurrences of a series.
++
++RFC 5546 lets a CANCEL, a REQUEST or a REPLY name one occurrence of a
++recurring event with RECURRENCE-ID, whether or not the recipient happens
++to keep a separate component for it, and RFC 5545 §3.2.13 lets it name an
++occurrence and every later one at once. RFC 6638 §3.2.6 lets an attendee
++hand one occurrence to a delegate. These exercise the whole round: what
++the inbox does with such a message, what goes out when a user makes such
++a change, and what the server records about it.
++"""
++
++import asyncio
++import datetime
++import shutil
++import tempfile
++import unittest
++from io import BytesIO
++from wsgiref.util import setup_testing_defaults
++
++from icalendar.cal import Calendar
++
++from xandikos import scheduling
++from xandikos.icalendar import expand_calendar_rrule
++from xandikos.web import (
++    SingleUserFilesystemBackend,
++    StoreBasedCollection,
++    XandikosApp,
++)
++
++ALICE = "mailto:alice@example.com"
++BOB = "mailto:bob@example.com"
++CAROL = "mailto:carol@example.com"
++DAVE = "mailto:dave@example.com"
++
++FIRST = "20260601T100000Z"
++SECOND = "20260602T100000Z"
++THIRD = "20260603T100000Z"
++
++# The same instant as SECOND, written the way a client in Berlin writes it.
++SECOND_LOCAL = "TZID=Europe/Berlin:20260602T120000"
++
++
++def recurrence_key(comp) -> str:
++    """The occurrence *comp* is about, named by its instant ("" for the series)."""
++    rid = comp.get("RECURRENCE-ID")
++    if rid is None:
++        return ""
++    value = rid.dt
++    if isinstance(value, datetime.datetime):
++        if value.tzinfo is not None:
++            value = value.astimezone(datetime.timezone.utc)
++        return value.strftime("%Y%m%dT%H%M%SZ")
++    return value.strftime("%Y%m%d")
++
++
++WINDOW = (
++    datetime.datetime(2026, 5, 1, tzinfo=datetime.timezone.utc),
++    datetime.datetime(2026, 7, 1, tzinfo=datetime.timezone.utc),
++)
++
++
++def series(*, override: bool, attendees=(BOB,)) -> bytes:
++    """A daily series of three, optionally with the second one broken out."""
++    lines = [
++        "BEGIN:VCALENDAR",
++        "VERSION:2.0",
++        "PRODID:-//Xandikos test//EN",
++        "BEGIN:VEVENT",
++        "UID:rec@example.com",
++        "DTSTAMP:20260101T120000Z",
++        "SEQUENCE:1",
++        f"DTSTART:{FIRST}",
++        "DTEND:20260601T110000Z",
++        "RRULE:FREQ=DAILY;COUNT=3",
++        "SUMMARY:Standup",
++        f"ORGANIZER:{ALICE}",
++    ]
++    lines += [f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{a}" for a in attendees]
++    lines.append("END:VEVENT")
++    if override:
++        lines += [
++            "BEGIN:VEVENT",
++            "UID:rec@example.com",
++            "DTSTAMP:20260101T120000Z",
++            "SEQUENCE:1",
++            f"RECURRENCE-ID:{SECOND}",
++            f"DTSTART:{SECOND}",
++            "DTEND:20260602T110000Z",
++            "SUMMARY:Standup (moved)",
++            f"ORGANIZER:{ALICE}",
++        ]
++        lines += [f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{a}" for a in attendees]
++        lines.append("END:VEVENT")
++    lines.append("END:VCALENDAR")
++    return ("\r\n".join(lines) + "\r\n").encode("utf-8")
++
++
++def itip_message(method: str, rid: str | None, *body: str) -> bytes:
++    lines = [
++        "BEGIN:VCALENDAR",
++        "VERSION:2.0",
++        "PRODID:-//Xandikos test//EN",
++        f"METHOD:{method}",
++        "BEGIN:VEVENT",
++        "UID:rec@example.com",
++        "DTSTAMP:20260102T120000Z",
++        f"ORGANIZER:{ALICE}",
++    ]
++    if rid is not None:
++        lines.append(f"RECURRENCE-ID;{rid}" if "=" in rid else f"RECURRENCE-ID:{rid}")
++    lines += list(body)
++    lines += ["END:VEVENT", "END:VCALENDAR"]
++    return ("\r\n".join(lines) + "\r\n").encode("utf-8")
++
++
++def series_in_a_time_zone() -> bytes:
++    """The same three-a-day series, kept in Berlin local time with its VTIMEZONE.
++
++    Its occurrences are the same instants as :func:`series` produces: noon in
++    Berlin on those days is 10:00 UTC.
++    """
++    lines = [
++        "BEGIN:VCALENDAR",
++        "VERSION:2.0",
++        "PRODID:-//Xandikos test//EN",
++        "BEGIN:VTIMEZONE",
++        "TZID:Europe/Berlin",
++        "BEGIN:DAYLIGHT",
++        "TZOFFSETFROM:+0100",
++        "TZOFFSETTO:+0200",
++        "TZNAME:CEST",
++        "DTSTART:19700329T020000",
++        "RRULE:FREQ=YEARLY;BYMONTH=3;BYDAY=-1SU",
++        "END:DAYLIGHT",
++        "BEGIN:STANDARD",
++        "TZOFFSETFROM:+0200",
++        "TZOFFSETTO:+0100",
++        "TZNAME:CET",
++        "DTSTART:19701025T030000",
++        "RRULE:FREQ=YEARLY;BYMONTH=10;BYDAY=-1SU",
++        "END:STANDARD",
++        "END:VTIMEZONE",
++        "BEGIN:VEVENT",
++        "UID:rec@example.com",
++        "DTSTAMP:20260101T120000Z",
++        "SEQUENCE:1",
++        "DTSTART;TZID=Europe/Berlin:20260601T120000",
++        "DTEND;TZID=Europe/Berlin:20260601T130000",
++        "RRULE:FREQ=DAILY;COUNT=3",
++        "SUMMARY:Standup",
++        f"ORGANIZER:{ALICE}",
++        f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}",
++        "END:VEVENT",
++        "END:VCALENDAR",
++    ]
++    return ("\r\n".join(lines) + "\r\n").encode("utf-8")
++
++
++def delegate_second_occurrence(body: bytes) -> bytes:
++    """Bob hands his seat at the second occurrence to Dave."""
++    head, marker, tail = body.decode("utf-8").partition(f"RECURRENCE-ID:{SECOND}")
++    assert marker, "the fixture has no second occurrence to delegate"
++    tail = tail.replace(
++        f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}\r\n",
++        f'ATTENDEE;PARTSTAT=DELEGATED;DELEGATED-TO="{DAVE}":{BOB}\r\n'
++        f'ATTENDEE;PARTSTAT=NEEDS-ACTION;DELEGATED-FROM="{BOB}":{DAVE}\r\n',
++        1,
++    )
++    return (head + marker + tail).encode("utf-8")
++
++
++class PerInstanceSchedulingTests(unittest.TestCase):
++    def setUp(self):
++        super().setUp()
++        self.tempdir = tempfile.mkdtemp()
++        self.addCleanup(shutil.rmtree, self.tempdir)
++        self.backend = SingleUserFilesystemBackend(self.tempdir)
++        for name in ("alice", "bob", "carol", "dave"):
++            self.backend.create_principal("/" + name, create_defaults=True)
++            self.backend.get_resource("/" + name).set_calendar_user_address_set(
++                [f"mailto:{name}@example.com"]
++            )
++
++    # -- driving the server the way a client does -------------------------
++    def put(self, path: str, body: bytes) -> str:
++        app = XandikosApp(self.backend, "user")
++        environ = {
++            "PATH_INFO": path,
++            "REQUEST_METHOD": "PUT",
++            "QUERY_STRING": "",
++            "CONTENT_TYPE": "text/calendar",
++            "CONTENT_LENGTH": str(len(body)),
++        }
++        setup_testing_defaults(environ)
++        environ["wsgi.input"] = BytesIO(body)
++        codes: list[str] = []
++        b"".join(app(environ, lambda code, headers: codes.append(code)))
++        return codes[0]
++
++    def put_ok(self, principal: str, body: bytes) -> None:
++        code = self.put(f"/{principal}/calendars/calendar/event.ics", body)
++        self.assertIn(code.split()[0], ("200", "201", "204"), code)
++
++    def deliver(self, address: str, message: bytes) -> None:
++        self.assertTrue(
++            asyncio.run(
++                scheduling.deliver_to_inbox(
++                    self.backend, address, Calendar.from_ical(message.decode("utf-8"))
++                )
++            )
++        )
++
++    # -- reading what the stores hold -------------------------------------
++    def stored(self, principal: str) -> Calendar:
++        col = self.backend.get_resource(f"/{principal}/calendars/calendar")
++        assert isinstance(col, StoreBasedCollection)
++        raw = [
++            b"".join(col.store._get_raw(name, etag))
++            for name, _ct, etag in col.store.iter_with_etag()
++        ]
++        self.assertEqual(1, len(raw))
++        return Calendar.from_ical(raw[0].decode("utf-8"))
++
++    def inbox(self, principal: str, method: str) -> list[Calendar]:
++        col = self.backend.get_resource(f"/{principal}/inbox")
++        assert isinstance(col, StoreBasedCollection)
++        out = []
++        for name, _ct, etag in col.store.iter_with_etag():
++            parsed = Calendar.from_ical(
++                b"".join(col.store._get_raw(name, etag)).decode("utf-8")
++            )
++            if str(parsed.get("METHOD", "")).upper() == method:
++                out.append(parsed)
++        return out
++
++    def occurrences(self, principal: str) -> dict:
++        """The series as a client sees it after expansion."""
++        expanded = expand_calendar_rrule(self.stored(principal), *WINDOW)
++        out = {}
++        for comp in expanded.subcomponents:
++            if comp.name != "VEVENT":
++                continue
++            attendees = comp.get("ATTENDEE", [])
++            if not isinstance(attendees, list):
++                attendees = [attendees]
++            out[recurrence_key(comp)] = {
++                "status": str(comp.get("STATUS", "")),
++                "summary": str(comp.get("SUMMARY", "")),
++                "partstat": {
++                    str(a): str(a.params.get("PARTSTAT", "")) for a in attendees
++                },
++            }
++        return out
++
++    def assertLive(self, occurrences, key):
++        self.assertIn(key, occurrences)
++        self.assertNotEqual("CANCELLED", occurrences[key]["status"].upper())
++
++    def assertNotLive(self, occurrences, key):
++        row = occurrences.get(key)
++        if row is not None:
++            self.assertEqual("CANCELLED", row["status"].upper())
++
++    # -- the inbox --------------------------------------------------------
++    def test_cancel_of_an_occurrence_without_its_own_component(self):
++        self.put_ok("bob", series(override=False))
++        self.deliver(
++            BOB,
++            itip_message(
++                "CANCEL",
++                SECOND,
++                "SEQUENCE:2",
++                f"DTSTART:{SECOND}",
++                "STATUS:CANCELLED",
++                f"ATTENDEE:{BOB}",
++            ),
++        )
++        occurrences = self.occurrences("bob")
++        self.assertLive(occurrences, FIRST)
++        self.assertLive(occurrences, THIRD)
++        self.assertNotLive(occurrences, SECOND)
++
++    def test_cancel_without_a_recurrence_id_still_ends_the_series(self):
++        self.put_ok("bob", series(override=True))
++        self.deliver(
++            BOB,
++            itip_message(
++                "CANCEL",
++                None,
++                "SEQUENCE:2",
++                f"DTSTART:{FIRST}",
++                "RRULE:FREQ=DAILY;COUNT=3",
++                "STATUS:CANCELLED",
++                f"ATTENDEE:{BOB}",
++            ),
++        )
++        for key in (FIRST, SECOND, THIRD):
++            self.assertNotLive(self.occurrences("bob"), key)
++
++    def test_cancel_this_and_future_ends_the_series_at_that_occurrence(self):
++        self.put_ok("bob", series(override=False))
++        self.deliver(
++            BOB,
++            itip_message(
++                "CANCEL",
++                f"RANGE=THISANDFUTURE:{SECOND}",
++                "SEQUENCE:2",
++                f"DTSTART:{SECOND}",
++                "STATUS:CANCELLED",
++                f"ATTENDEE:{BOB}",
++            ),
++        )
++        occurrences = self.occurrences("bob")
++        self.assertLive(occurrences, FIRST)
++        self.assertNotLive(occurrences, SECOND)
++        self.assertNotLive(occurrences, THIRD)
++
++    def test_reply_about_an_occurrence_without_its_own_component(self):
++        self.put_ok("alice", series(override=False, attendees=(BOB, CAROL)))
++        self.deliver(
++            ALICE,
++            itip_message(
++                "REPLY", SECOND, "SEQUENCE:1", f"ATTENDEE;PARTSTAT=DECLINED:{BOB}"
++            ),
++        )
++        occurrences = self.occurrences("alice")
++        self.assertEqual("DECLINED", occurrences[SECOND]["partstat"][BOB])
++        self.assertEqual("NEEDS-ACTION", occurrences[FIRST]["partstat"][BOB])
++        self.assertEqual("NEEDS-ACTION", occurrences[THIRD]["partstat"][BOB])
++        self.assertEqual("NEEDS-ACTION", occurrences[SECOND]["partstat"][CAROL])
++
++    def test_reply_without_a_recurrence_id_answers_for_the_series(self):
++        self.put_ok("alice", series(override=False, attendees=(BOB,)))
++        self.deliver(
++            ALICE,
++            itip_message(
++                "REPLY", None, "SEQUENCE:1", f"ATTENDEE;PARTSTAT=ACCEPTED:{BOB}"
++            ),
++        )
++        occurrences = self.occurrences("alice")
++        for key in (FIRST, SECOND, THIRD):
++            self.assertEqual("ACCEPTED", occurrences[key]["partstat"][BOB])
++
++    def test_the_same_instant_in_another_time_zone_is_one_occurrence(self):
++        self.put_ok("bob", series(override=True))
++        self.deliver(
++            BOB,
++            itip_message(
++                "CANCEL",
++                SECOND_LOCAL,
++                "SEQUENCE:2",
++                f"DTSTART;{SECOND_LOCAL}",
++                "STATUS:CANCELLED",
++                f"ATTENDEE:{BOB}",
++            ),
++        )
++        occurrences = self.occurrences("bob")
++        self.assertLive(occurrences, FIRST)
++        self.assertLive(occurrences, THIRD)
++        self.assertNotLive(occurrences, SECOND)
++
++    def test_a_request_for_one_occurrence_does_not_duplicate_it(self):
++        self.put_ok("bob", series(override=True))
++        self.deliver(
++            BOB,
++            itip_message(
++                "REQUEST",
++                SECOND_LOCAL,
++                "SEQUENCE:2",
++                f"DTSTART;{SECOND_LOCAL}",
++                "DTEND;TZID=Europe/Berlin:20260602T130000",
++                "SUMMARY:Standup (moved again)",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}",
++            ),
++        )
++        keys = [
++            recurrence_key(comp)
++            for comp in self.stored("bob").subcomponents
++            if comp.name == "VEVENT"
++        ]
++        self.assertEqual(sorted(keys), sorted({"", SECOND}))
++        occurrences = self.occurrences("bob")
++        self.assertEqual("Standup (moved again)", occurrences[SECOND]["summary"])
++        self.assertEqual("Standup", occurrences[FIRST]["summary"])
++
++    # -- what goes out ----------------------------------------------------
++    def test_a_delegate_is_told_about_the_delegated_occurrence_only(self):
++        self.put_ok("bob", series(override=True))
++        self.put_ok("bob", delegate_second_occurrence(series(override=True)))
++        requests = self.inbox("dave", "REQUEST")
++        self.assertEqual(1, len(requests))
++        self.assertEqual(
++            [SECOND],
++            sorted(
++                recurrence_key(comp)
++                for comp in requests[0].subcomponents
++                if comp.name == "VEVENT"
++            ),
++        )
++
++    def test_a_delegation_does_not_hide_an_uninvited_occurrence(self):
++        self.put_ok("bob", series(override=True))
++        smuggled = (
++            delegate_second_occurrence(series(override=True))
++            .decode("utf-8")
++            .replace(
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}\r\nEND:VEVENT",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}\r\n"
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{DAVE}\r\nEND:VEVENT",
++                1,
++            )
++            .encode("utf-8")
++        )
++        code = self.put("/bob/calendars/calendar/event.ics", smuggled)
++        self.assertEqual("412 Precondition Failed", code)
++        for comp in self.stored("bob").subcomponents:
++            if comp.name == "VEVENT" and recurrence_key(comp) == "":
++                attendees = comp.get("ATTENDEE", [])
++                if not isinstance(attendees, list):
++                    attendees = [attendees]
++                self.assertNotIn(DAVE, [str(a) for a in attendees])
++
++    def test_an_attendee_is_sent_the_occurrences_that_are_theirs(self):
++        self.put_ok("alice", series(override=True, attendees=(BOB, CAROL)))
++        # Carol is taken off the second occurrence only.
++        head, marker, tail = (
++            series(override=True, attendees=(BOB, CAROL))
++            .decode("utf-8")
++            .partition(f"RECURRENCE-ID:{SECOND}")
++        )
++        edited = (
++            head
++            + marker
++            + tail.replace(f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{CAROL}\r\n", "", 1)
++        ).encode("utf-8")
++        self.put_ok("alice", edited)
++        cancels = self.inbox("carol", "CANCEL")
++        self.assertEqual(1, len(cancels))
++        self.assertEqual(
++            [SECOND],
++            sorted(
++                recurrence_key(comp)
++                for comp in cancels[0].subcomponents
++                if comp.name == "VEVENT"
++            ),
++        )
++
++    def test_cancel_this_and_future_on_a_series_kept_in_a_time_zone(self):
++        """The boundary arrives in Berlin time; the series ends at that instant.
++
++        RFC 5545 §3.3.10: a series whose DTSTART carries a time zone ends on a
++        UNTIL written in UTC. Left in the sender's local time it reads as a
++        floating time, which is a different instant by the offset — far enough
++        to leave the very occurrence the message named still happening.
++        """
++        self.put_ok("bob", series_in_a_time_zone())
++        self.assertEqual(3, len(self.occurrences("bob")))
++        self.deliver(
++            BOB,
++            itip_message(
++                "CANCEL",
++                f"RANGE=THISANDFUTURE;{SECOND_LOCAL}",
++                "SEQUENCE:2",
++                "STATUS:CANCELLED",
++                f"ATTENDEE:{BOB}",
++            ),
++        )
++        occurrences = self.occurrences("bob")
++        self.assertLive(occurrences, FIRST)
++        self.assertNotLive(occurrences, SECOND)
++        self.assertNotLive(occurrences, THIRD)
++        # Ending the series is one way to do it and not the only one; if this
++        # is the way it was done, the UNTIL is the one RFC 5545 asks for.
++        for comp in self.stored("bob").subcomponents:
++            if comp.name != "VEVENT" or "RRULE" not in comp:
++                continue
++            for until in comp["RRULE"].get("UNTIL", []):
++                self.assertIsNotNone(
++                    getattr(until, "tzinfo", None),
++                    f"a series kept in a time zone was given a floating UNTIL: {until!r}",
++                )
++
++    def test_a_request_for_an_instant_the_series_never_produces(self):
++        """Half past eleven is not an occurrence of a series that meets at ten.
++
++        A message about an occurrence we hold no component for is applied by
++        breaking that occurrence out of the series. An instant the recurrence
++        set does not produce has nothing to break out, and adding it would put
++        a meeting nobody scheduled into the event.
++        """
++        self.put_ok("bob", series(override=False))
++        before = self.stored("bob").to_ical()
++        self.deliver(
++            BOB,
++            itip_message(
++                "REQUEST",
++                "20260602T113000Z",
++                "SEQUENCE:2",
++                "DTSTART:20260602T113000Z",
++                "DTEND:20260602T120000Z",
++                "SUMMARY:Invented",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}",
++            ),
++        )
++        self.assertEqual(
++            [""],
++            sorted(
++                recurrence_key(comp)
++                for comp in self.stored("bob").subcomponents
++                if comp.name == "VEVENT"
++            ),
++        )
++        self.assertEqual([FIRST, SECOND, THIRD], sorted(self.occurrences("bob")))
++        self.assertEqual(before, self.stored("bob").to_ical())
++
++    def test_a_re_request_in_another_time_zone_keeps_the_answer(self):
++        """RFC 6638 §3.2.1: a fresh REQUEST does not throw away the answers.
++
++        The organiser's client writes the second occurrence in Berlin time
++        this time. It is the same occurrence, so the PARTSTAT already given
++        for it is the PARTSTAT it keeps.
++        """
++        self.put_ok("bob", series(override=True))
++        self.deliver(
++            BOB,
++            itip_message(
++                "REPLY", SECOND, "SEQUENCE:1", f"ATTENDEE;PARTSTAT=ACCEPTED:{BOB}"
++            ),
++        )
++        self.assertEqual("ACCEPTED", self.occurrences("bob")[SECOND]["partstat"][BOB])
++        self.deliver(
++            BOB,
++            itip_message(
++                "REQUEST",
++                SECOND_LOCAL,
++                "SEQUENCE:3",
++                f"DTSTART;{SECOND_LOCAL}",
++                "DTEND;TZID=Europe/Berlin:20260602T133000",
++                "SUMMARY:Standup (later)",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}",
++            ),
++        )
++        occurrences = self.occurrences("bob")
++        self.assertEqual("Standup (later)", occurrences[SECOND]["summary"])
++        self.assertEqual("ACCEPTED", occurrences[SECOND]["partstat"][BOB])
++
++    def test_an_occurrence_the_series_names_outright_is_still_the_series(self):
++        """Refusing to invent an occurrence is not refusing to keep one.
++
++        A date named on RDATE is in the recurrence set (RFC 5545 §3.8.5.2),
++        and an object that holds occurrences and no series at all has no
++        recurrence set to be judged against. Neither is an invented occurrence.
++        """
++        lines = (
++            series(override=False)
++            .decode("utf-8")
++            .replace("RRULE:FREQ=DAILY;COUNT=3\r\n", f"RDATE:{SECOND},{THIRD}\r\n", 1)
++        )
++        self.put_ok("bob", lines.encode("utf-8"))
++        self.deliver(
++            BOB,
++            itip_message(
++                "REQUEST",
++                SECOND,
++                "SEQUENCE:2",
++                f"DTSTART:{SECOND}",
++                "DTEND:20260602T113000Z",
++                "SUMMARY:Standup (moved)",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}",
++            ),
++        )
++        self.assertEqual(
++            ["", SECOND],
++            sorted(
++                recurrence_key(comp)
++                for comp in self.stored("bob").subcomponents
++                if comp.name == "VEVENT"
++            ),
++        )
++
++        # An object built out of a message about one occurrence: no series.
++        self.deliver(
++            CAROL,
++            itip_message(
++                "REQUEST",
++                SECOND,
++                "SEQUENCE:1",
++                f"DTSTART:{SECOND}",
++                "DTEND:20260602T110000Z",
++                "SUMMARY:Standup",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{CAROL}",
++            ),
++        )
++        self.deliver(
++            CAROL,
++            itip_message(
++                "REQUEST",
++                THIRD,
++                "SEQUENCE:1",
++                f"DTSTART:{THIRD}",
++                "DTEND:20260603T110000Z",
++                "SUMMARY:Standup",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{CAROL}",
++            ),
++        )
++        self.assertEqual(
++            [SECOND, THIRD],
++            sorted(
++                recurrence_key(comp)
++                for comp in self.stored("carol").subcomponents
++                if comp.name == "VEVENT"
++            ),
++        )
++
++    def test_an_attendee_is_invited_to_the_occurrences_that_are_theirs(self):
++        """Carol is on the second occurrence only, and is sent that one."""
++        head, marker, tail = (
++            series(override=True, attendees=(BOB,))
++            .decode("utf-8")
++            .partition(f"RECURRENCE-ID:{SECOND}")
++        )
++        invited = (
++            head
++            + marker
++            + tail.replace(
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}\r\n",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}\r\n"
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{CAROL}\r\n",
++                1,
++            )
++        ).encode("utf-8")
++        self.put_ok("alice", invited)
++        requests = self.inbox("carol", "REQUEST")
++        self.assertEqual(1, len(requests))
++        self.assertEqual(
++            [SECOND],
++            sorted(
++                recurrence_key(comp)
++                for comp in requests[0].subcomponents
++                if comp.name == "VEVENT"
++            ),
++        )
++
++    # -- from one occurrence onwards: a revision and an answer --------------
++    def _starts(self, principal: str) -> dict:
++        expanded = expand_calendar_rrule(self.stored(principal), *WINDOW)
++        out = {}
++        for comp in expanded.subcomponents:
++            if comp.name == "VEVENT":
++                value = comp["DTSTART"].dt.astimezone(datetime.timezone.utc)
++                out[recurrence_key(comp)] = value.strftime("%Y%m%dT%H%M%SZ")
++        return out
++
++    def test_a_revision_from_one_occurrence_onwards(self):
++        self.put_ok("bob", series(override=False))
++        self.deliver(
++            BOB,
++            itip_message(
++                "REQUEST",
++                f"RANGE=THISANDFUTURE:{SECOND}",
++                "SEQUENCE:2",
++                "DTSTART:20260602T103000Z",
++                "DTEND:20260602T113000Z",
++                "SUMMARY:Standup (upstairs)",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}",
++            ),
++        )
++        occurrences = self.occurrences("bob")
++        self.assertEqual("Standup", occurrences[FIRST]["summary"])
++        self.assertEqual("Standup (upstairs)", occurrences[SECOND]["summary"])
++        self.assertEqual("Standup (upstairs)", occurrences[THIRD]["summary"])
++        starts = self._starts("bob")
++        self.assertEqual(FIRST, starts[FIRST])
++        self.assertEqual("20260602T103000Z", starts[SECOND])
++        self.assertEqual("20260603T103000Z", starts[THIRD])
++
++    def test_a_revision_onwards_on_an_open_ended_series(self):
++        self.put_ok(
++            "bob",
++            series(override=False).replace(
++                b"RRULE:FREQ=DAILY;COUNT=3", b"RRULE:FREQ=DAILY"
++            ),
++        )
++        self.deliver(
++            BOB,
++            itip_message(
++                "REQUEST",
++                f"RANGE=THISANDFUTURE:{SECOND}",
++                "SEQUENCE:2",
++                f"DTSTART:{SECOND}",
++                "DTEND:20260602T110000Z",
++                "SUMMARY:Standup (upstairs)",
++                f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}",
++            ),
++        )
++        occurrences = self.occurrences("bob")
++        self.assertEqual("Standup", occurrences[FIRST]["summary"])
++        self.assertEqual("Standup (upstairs)", occurrences["20260630T100000Z"]["summary"])
++
++    def test_an_answer_from_one_occurrence_onwards(self):
++        self.put_ok("alice", series(override=True, attendees=(BOB, CAROL)))
++        self.deliver(
++            ALICE,
++            itip_message(
++                "REPLY",
++                f"RANGE=THISANDFUTURE:{SECOND}",
++                "SEQUENCE:1",
++                f"ATTENDEE;PARTSTAT=TENTATIVE:{BOB}",
++            ),
++        )
++        occurrences = self.occurrences("alice")
++        self.assertEqual("NEEDS-ACTION", occurrences[FIRST]["partstat"][BOB])
++        self.assertEqual("TENTATIVE", occurrences[SECOND]["partstat"][BOB])
++        self.assertEqual("TENTATIVE", occurrences[THIRD]["partstat"][BOB])
++        # the occurrence kept as its own exception is still that occurrence
++        self.assertEqual("Standup (moved)", occurrences[SECOND]["summary"])
++        self.assertEqual("Standup", occurrences[THIRD]["summary"])
++        for key in (FIRST, SECOND, THIRD):
++            self.assertEqual("NEEDS-ACTION", occurrences[key]["partstat"][CAROL])
++
++    def test_an_answer_onwards_after_a_revision_onwards(self):
++        self.put_ok("alice", series(override=False, attendees=(BOB,)))
++        stored = self.stored("alice").to_ical().decode("utf-8")
++        # Alice's own copy after she moved the series upstairs from Tuesday on.
++        revised = stored.replace(
++            "END:VCALENDAR",
++            "BEGIN:VEVENT\r\nUID:rec@example.com\r\nDTSTAMP:20260101T120000Z\r\n"
++            f"SEQUENCE:2\r\nRECURRENCE-ID;RANGE=THISANDFUTURE:{SECOND}\r\n"
++            f"DTSTART:{SECOND}\r\nDTEND:20260602T110000Z\r\n"
++            f"SUMMARY:Standup (upstairs)\r\nORGANIZER:{ALICE}\r\n"
++            f"ATTENDEE;PARTSTAT=NEEDS-ACTION:{BOB}\r\nEND:VEVENT\r\nEND:VCALENDAR",
++        )
++        self.put_ok("alice", revised.encode("utf-8"))
++        self.deliver(
++            ALICE,
++            itip_message(
++                "REPLY",
++                f"RANGE=THISANDFUTURE:{THIRD}",
++                "SEQUENCE:2",
++                f"ATTENDEE;PARTSTAT=DECLINED:{BOB}",
++            ),
++        )
++        occurrences = self.occurrences("alice")
++        self.assertEqual("NEEDS-ACTION", occurrences[SECOND]["partstat"][BOB])
++        self.assertEqual("DECLINED", occurrences[THIRD]["partstat"][BOB])
++        self.assertEqual("Standup (upstairs)", occurrences[THIRD]["summary"])
++
++
++if __name__ == "__main__":
++    unittest.main()
+diff --git a/xandikos/icalendar.py b/xandikos/icalendar.py
+index 3bc8aea..d3c8e03 100644
+--- a/xandikos/icalendar.py
++++ b/xandikos/icalendar.py
+@@ -2183,7 +2183,17 @@ def _expand_rrule_component(
+     start: datetime | None = None,
+     end: datetime | None = None,
+     existing: dict[str | date | datetime, Component] = {},
++    onwards: "list[tuple[date | datetime, Component]] | None" = None,
+ ) -> Iterable[Component]:
++    """Yield the occurrences of *incomp*'s recurrence set.
++
++    *existing* maps normalised RECURRENCE-IDs to the exception components
++    that replace an occurrence outright; each one is popped as it is used.
++    *onwards* lists, in order, the exceptions marked
++    ``RECURRENCE-ID;RANGE=THISANDFUTURE`` (RFC 5545 §3.8.4.4): such an
++    exception also stands for every later occurrence that has no exception
++    of its own, shifted by however far it moved its own start.
++    """
+     if "RRULE" not in incomp:
+         return
+     if "DTSTART" not in incomp:
+@@ -2258,6 +2268,12 @@ def _expand_rrule_component(
+         try:
+             outcomp = existing.pop(ts_normalized)
+         except KeyError:
++            outcomp = None
++        if outcomp is None:
++            governing = _governing_onwards(onwards, ts_normalized)
++            if governing is not None:
++                outcomp = _occurrence_from_onwards(governing, ts_for_dtstart)
++        if outcomp is None:
+             # Create new occurrence
+             outcomp = base_comp.copy()
+ 
+@@ -2302,6 +2318,74 @@ def _expand_rrule_component(
+         yield outcomp
+ 
+ 
++def _is_onwards(comp: Component) -> bool:
++    """True if *comp*'s RECURRENCE-ID carries RANGE=THISANDFUTURE."""
++    rid = comp.get("RECURRENCE-ID")
++    params = getattr(rid, "params", None) or {}
++    rng = params.get("RANGE")
++    return rng is not None and str(rng).upper() == "THISANDFUTURE"
++
++
++def _governing_onwards(
++    onwards: "list[tuple[date | datetime, Component]] | None",
++    ts_normalized: date | datetime,
++) -> "Component | None":
++    """Return the latest THISANDFUTURE exception that starts before *ts*."""
++    found = None
++    for moment, comp in onwards or ():
++        try:
++            if moment < ts_normalized:
++                found = comp
++        except TypeError:
++            # A date against a date-time: not the same recurrence set.
++            continue
++    return found
++
++
++def _occurrence_from_onwards(
++    governing: Component, ts_for_dtstart: date | datetime
++) -> Component:
++    """Derive the occurrence at *ts_for_dtstart* from a THISANDFUTURE exception.
++
++    RFC 5545 §3.8.4.4: the exception's properties hold for the later
++    occurrences too, and if it moved its own start, every later occurrence
++    moves by the same amount and keeps the exception's length.
++    """
++    outcomp = governing.copy()
++    rid = governing["RECURRENCE-ID"].dt
++    own_start_prop = governing.get("DTSTART")
++    own_start = getattr(own_start_prop, "dt", None)
++    shift = timedelta(0)
++    if own_start is not None and type(own_start) is type(rid):
++        try:
++            shift = own_start - rid
++        except TypeError:
++            # One side floating, the other zoned: no instant to measure by.
++            shift = timedelta(0)
++    new_start = ts_for_dtstart + shift
++    if (
++        isinstance(new_start, datetime)
++        and isinstance(own_start, datetime)
++        and new_start.tzinfo is not None
++        and own_start.tzinfo is not None
++    ):
++        new_start = new_start.astimezone(own_start.tzinfo)
++    new_dtstart = create_prop_from_date_or_datetime(new_start)
++    params = getattr(own_start_prop, "params", None)
++    if params:
++        new_dtstart.params = params.copy()
++    outcomp["DTSTART"] = new_dtstart
++    for end_prop in ("DTEND", "DUE"):
++        if end_prop in governing and own_start is not None:
++            length = governing[end_prop].dt - own_start
++            new_end = create_prop_from_date_or_datetime(new_start + length)
++            end_params = getattr(governing[end_prop], "params", None)
++            if end_params:
++                new_end.params = end_params.copy()
++            outcomp[end_prop] = new_end
++    return outcomp
++
++
+ def expand_calendar_rrule(
+     incal: Calendar, start: datetime | None = None, end: datetime | None = None
+ ) -> Calendar:
+@@ -2322,6 +2406,12 @@ def expand_calendar_rrule(
+             assert isinstance(rec_id.dt, date | datetime)
+             ts = asutc(rec_id.dt)
+             exceptions[ts] = comp
++    # Exceptions that speak for the rest of the series as well as their own
++    # occurrence, earliest first.
++    onwards = sorted(
++        ((ts, comp) for ts, comp in exceptions.items() if _is_onwards(comp)),
++        key=lambda item: (isinstance(item[0], datetime), str(item[0])),
++    )
+ 
+     # Process all components
+     for comp in incal.subcomponents:
+@@ -2333,7 +2423,9 @@ def expand_calendar_rrule(
+             pass
+         elif "RRULE" in comp:
+             # Expand recurring events
+-            for expanded in _expand_rrule_component(comp, start, end, exceptions):
++            for expanded in _expand_rrule_component(
++                comp, start, end, exceptions, onwards
++            ):
+                 outcal.add_component(expanded)
+         else:
+             # Include non-recurring events
+diff --git a/xandikos/itip.py b/xandikos/itip.py
+index 83e3851..71b070e 100644
+--- a/xandikos/itip.py
++++ b/xandikos/itip.py
+@@ -26,6 +26,7 @@ signature from iTIP-relevant properties — separately from the CalDAV
+ plumbing in :mod:`xandikos.scheduling` that exposes them over HTTP.
+ """
+ 
++import copy
+ import datetime
+ import hashlib
+ 
+@@ -454,20 +455,400 @@ def strip_method(itip_message: Calendar) -> Calendar:
+     return out
+ 
+ 
++def recurrence_key(comp: Component) -> str:
++    """Return a stable name for the occurrence *comp* speaks about.
++
++    RECURRENCE-ID (RFC 5545 §3.8.4.4) names one occurrence of a recurring
++    event by its original start, and the same instant has more than one
++    written form: ``20260602T100000Z``, ``TZID=Europe/Berlin:20260602T120000``
++    and ``TZID=UTC:20260602T100000`` are one occurrence between them. Keying
++    on the text would make them three, so the key comes from the parsed
++    value. The series' own component carries no RECURRENCE-ID and keys as
++    the empty string.
++    """
++    rid = comp.get("RECURRENCE-ID")
++    if rid is None:
++        return ""
++    return _instant_key(rid)
++
++
++def _instant_key(prop: PropTypes) -> str:
++    """Key one date-time property by the instant it denotes."""
++    dt = getattr(prop, "dt", None)
++    if isinstance(dt, datetime.datetime):
++        if dt.tzinfo is not None:
++            dt = dt.astimezone(datetime.timezone.utc)
++            return dt.strftime("%Y%m%dT%H%M%SZ")
++        # A floating time has no instant until a time zone is chosen; it can
++        # only be the same occurrence as another floating time.
++        return dt.strftime("%Y%m%dT%H%M%S")
++    if isinstance(dt, datetime.date):
++        return dt.strftime("%Y%m%d")
++    rendered = prop.to_ical()
++    return rendered.decode("utf-8") if isinstance(rendered, bytes) else str(rendered)
++
++
++def itip_occurrences(
++    itip_message: Component, uid: str
++) -> "dict[str, PropTypes | None]":
++    """Map occurrence key -> its RECURRENCE-ID property, for *uid* in a message.
++
++    The series' own component maps to None. Used to decide which components
++    of a stored object a message speaks about, and — for keys the stored
++    object has no component for — to break the occurrence out.
++    """
++    out: dict[str, PropTypes | None] = {}
++    for comp in itip_message.subcomponents:
++        if comp.name not in SCHEDULING_COMPONENTS:
++            continue
++        if str(comp.get("UID", "")) != uid:
++            continue
++        rid = comp.get("RECURRENCE-ID")
++        out[recurrence_key(comp)] = rid
++    return out
++
++
++def covers_series(itip_message: Component, uid: str) -> bool:
++    """True if *itip_message* carries the series itself, not single occurrences."""
++    return "" in itip_occurrences(itip_message, uid)
++
++
++def occurrences_for_attendee(cal: Component, address: str) -> "set[str]":
++    """Occurrence keys of *cal* on which *address* is an ATTENDEE."""
++    found: set[str] = set()
++    for comp in cal.subcomponents:
++        if comp.name not in SCHEDULING_COMPONENTS:
++            continue
++        if _find_attendee(comp, address) is not None:
++            found.add(recurrence_key(comp))
++    return found
++
++
++def narrow_to_occurrences(cal: Component, keys: "set[str]") -> Calendar:
++    """Return a copy of *cal* carrying only the occurrences in *keys*.
++
++    Non-scheduling components (VTIMEZONE and friends) are kept, so the
++    result is still a self-contained calendar object.
++    """
++    out = Calendar()
++    for field in cal:
++        out[field] = cal[field]
++    for comp in cal.subcomponents:
++        if comp.name not in SCHEDULING_COMPONENTS or recurrence_key(comp) in keys:
++            out.add_component(comp.copy())
++    return out
++
++
++def series_produces(cal: Calendar, uid: str, rid: PropTypes) -> bool:
++    """True if *uid*'s recurrence set in *cal* produces the occurrence *rid*.
++
++    The question a message about a single occurrence raises before anything
++    else: an occurrence the series does produce is ours to apply the message
++    to, whether or not we keep a component for it, and an instant the series
++    never produces is not ours to invent.
++    """
++    if _expand_occurrence(cal, uid, rid) is not None:
++        return True
++    return _named_by_a_recurrence_date(cal, uid, rid)
++
++
++def _named_by_a_recurrence_date(cal: Calendar, uid: str, rid: PropTypes) -> bool:
++    """True if the series names *rid* outright on an RDATE and does not exclude it.
++
++    RFC 5545 §3.8.5.2: a date named on RDATE is in the recurrence set as much
++    as one the rule produces. It is asked here rather than left to the
++    expansion because the expansion works from the rule.
++    """
++    wanted = _instant_key(rid)
++    for comp in cal.subcomponents:
++        if comp.name not in SCHEDULING_COMPONENTS:
++            continue
++        if str(comp.get("UID", "")) != uid or "RECURRENCE-ID" in comp:
++            continue
++        if wanted in _dates_named(comp, "EXDATE"):
++            return False
++        if wanted in _dates_named(comp, "RDATE"):
++            return True
++    return False
++
++
++def _dates_named(comp: Component, field: str) -> "set[str]":
++    """The instants *field* names on *comp*, keyed the way occurrences are."""
++    out: set[str] = set()
++    value = comp.get(field)
++    if value is None:
++        return out
++    for entry in value if isinstance(value, list) else [value]:
++        for item in getattr(entry, "dts", None) or []:
++            out.add(_instant_key(item))
++    return out
++
++
++def materialise_occurrence(
++    cal: Calendar, uid: str, rid: PropTypes
++) -> "Component | None":
++    """Break the occurrence *rid* out of *uid*'s series as its own component.
++
++    A scheduling message may speak about an occurrence the stored object
++    never needed a component for: the organiser never moved it, so it lives
++    inside the series' RRULE. Applying the message to that occurrence alone
++    means giving it the exception component RFC 5545 §3.8.4.4 describes,
++    derived from the series exactly as an expansion would derive it.
++
++    Returns the new component, already added to *cal*, or None if the
++    recurrence set holds no such occurrence (an occurrence that is not in
++    the series is not ours to invent).
++    """
++    occurrence = _expand_occurrence(cal, uid, rid)
++    if occurrence is None:
++        return None
++    # A deep copy: the expansion hands back property objects the series
++    # still holds, and an exception that shares its ATTENDEE entries with
++    # the series would carry every answer back into it.
++    broken_out = copy.deepcopy(occurrence)
++    # The exception describes one occurrence; the recurrence rules stay
++    # with the series.
++    for field in ("RRULE", "EXRULE", "RDATE", "EXDATE"):
++        if field in broken_out:
++            del broken_out[field]
++    cal.add_component(broken_out)
++    return broken_out
++
++
++def _expand_occurrence(cal: Calendar, uid: str, rid: PropTypes) -> "Component | None":
++    """Return the occurrence *rid* as *uid*'s series produces it, or None.
++
++    Reads the stored object; writes nothing to it.
++    """
++    from xandikos.icalendar import expand_calendar_rrule
++
++    master = None
++    for comp in cal.subcomponents:
++        if (
++            comp.name in SCHEDULING_COMPONENTS
++            and str(comp.get("UID", "")) == uid
++            and "RECURRENCE-ID" not in comp
++        ):
++            master = comp
++            break
++    if master is None or "RRULE" not in master:
++        return None
++
++    target = getattr(rid, "dt", None)
++    if isinstance(target, datetime.datetime):
++        moment = target
++    elif isinstance(target, datetime.date):
++        moment = datetime.datetime.combine(target, datetime.time())
++    else:
++        return None
++    if moment.tzinfo is None:
++        moment = moment.replace(tzinfo=datetime.timezone.utc)
++    window = datetime.timedelta(days=1)
++
++    # The series, and the exceptions that speak for the rest of it from their
++    # own occurrence on (RANGE=THISANDFUTURE): an occurrence after one of
++    # those is what that exception made of it, not what the rule alone says.
++    # Deep copies — the expansion rewrites the RECURRENCE-IDs it hands back.
++    probe = Calendar()
++    probe.add_component(copy.deepcopy(master))
++    for comp in cal.subcomponents:
++        if (
++            comp.name in SCHEDULING_COMPONENTS
++            and str(comp.get("UID", "")) == uid
++            and _speaks_onwards(comp)
++        ):
++            probe.add_component(copy.deepcopy(comp))
++    wanted = _instant_key(rid)
++    for occurrence in expand_calendar_rrule(
++        probe, moment - window, moment + window
++    ).subcomponents:
++        if occurrence.name not in SCHEDULING_COMPONENTS:
++            continue
++        if recurrence_key(occurrence) != wanted:
++            continue
++        return occurrence
++    return None
++
++
++def _speaks_onwards(comp: Component) -> bool:
++    """True if *comp*'s RECURRENCE-ID carries RANGE=THISANDFUTURE."""
++    rid = comp.get("RECURRENCE-ID")
++    if rid is None:
++        return False
++    rng = rid.params.get("RANGE")
++    return rng is not None and str(rng).upper() == "THISANDFUTURE"
++
++
++def onwards_targets(cal: Calendar, uid: str, rid: PropTypes) -> "list[Component]":
++    """Return the components that speak for *rid* and every later occurrence.
++
++    That is every component *cal* already keeps for an occurrence at or after
++    *rid*, and one more: the first occurrence from *rid* on that has no
++    component of its own is broken out of the series and marked
++    RANGE=THISANDFUTURE (RFC 5545 §3.8.4.4), so that what is applied to it
++    holds for the occurrences after it too — including the ones an open-ended
++    rule has not produced yet. An occurrence we keep as its own exception
++    stays that occurrence's own and is returned among the rest. Returns an
++    empty list when *uid* has nothing at or after *rid*.
++    """
++    boundary = _as_instant(rid)
++    if boundary is None:
++        return []
++    targets: list[Component] = []
++    held: set[str] = set()
++    master = None
++    for comp in cal.subcomponents:
++        if comp.name not in SCHEDULING_COMPONENTS:
++            continue
++        if str(comp.get("UID", "")) != uid:
++            continue
++        if "RECURRENCE-ID" not in comp:
++            master = comp
++            continue
++        held.add(recurrence_key(comp))
++        own = _as_instant(comp.get("RECURRENCE-ID"))
++        if own is not None and own >= boundary:
++            targets.append(comp)
++    if master is None or "RRULE" not in master:
++        return targets
++    from xandikos.icalendar import rruleset_from_comp, _normalize_dt_for_rrule
++
++    start = getattr(master.get("DTSTART"), "dt", None)
++    if start is None:
++        return targets
++    rules = rruleset_from_comp(master)
++    moment = rid.dt if isinstance(rid.dt, datetime.datetime) else boundary
++    probe = _normalize_dt_for_rrule(moment, start)
++    for occurrence in rules.xafter(probe, count=len(held) + 2, inc=True):
++        value = occurrence if isinstance(start, datetime.datetime) else occurrence.date()
++        name = _instant_key(vDDDTypes(value))
++        if name in held:
++            continue
++        broken_out = materialise_occurrence(cal, uid, vDDDTypes(value))
++        if broken_out is not None:
++            broken_out["RECURRENCE-ID"].params["RANGE"] = "THISANDFUTURE"
++            targets.append(broken_out)
++        break
++    return targets
++
++
++def thisandfuture_occurrence(itip_message: Component, uid: str) -> "PropTypes | None":
++    """Return the RECURRENCE-ID a message marks as standing for the tail.
++
++    RFC 5545 §3.2.13: ``RECURRENCE-ID;RANGE=THISANDFUTURE`` names the
++    occurrence it carries *and every later one*, so a message that uses it
++    speaks about a stretch of the series rather than a single occurrence.
++    Returns that property, or None when no component uses the parameter.
++    """
++    for comp in itip_message.subcomponents:
++        if comp.name not in SCHEDULING_COMPONENTS:
++            continue
++        if str(comp.get("UID", "")) != uid:
++            continue
++        rid = comp.get("RECURRENCE-ID")
++        if rid is None:
++            continue
++        rng = rid.params.get("RANGE")
++        if rng is not None and str(rng).upper() == "THISANDFUTURE":
++            return rid
++    return None
++
++
++def end_series_at(cal: Calendar, uid: str, rid: PropTypes) -> bool:
++    """Stop *uid*'s series just before *rid*, and cancel later exceptions.
++
++    The occurrences from *rid* onwards stop happening: the recurrence rule
++    is given an UNTIL that lands before them, and any exception component
++    already broken out at or after that instant is marked CANCELLED. What
++    came before is left exactly as it was. Returns False when there is
++    nothing of *uid* to do this to.
++    """
++    boundary = _as_instant(rid)
++    if boundary is None:
++        return False
++    touched = False
++    for comp in cal.subcomponents:
++        if comp.name not in SCHEDULING_COMPONENTS:
++            continue
++        if str(comp.get("UID", "")) != uid:
++            continue
++        own = (
++            _as_instant(comp.get("RECURRENCE-ID")) if "RECURRENCE-ID" in comp else None
++        )
++        if own is not None:
++            if own >= boundary:
++                comp["STATUS"] = "CANCELLED"
++                touched = True
++            continue
++        if "RRULE" in comp:
++            rrule = comp["RRULE"]
++            last = _until_beside(
++                boundary - datetime.timedelta(seconds=1), comp.get("DTSTART")
++            )
++            try:
++                del rrule["COUNT"]
++            except KeyError:
++                pass
++            # COUNT and UNTIL cannot both be present (RFC 5545 §3.3.10).
++            rrule["UNTIL"] = [last]
++            comp["RRULE"] = rrule
++            touched = True
++        else:
++            own_start = _as_instant(comp.get("DTSTART"))
++            if own_start is not None and own_start >= boundary:
++                comp["STATUS"] = "CANCELLED"
++                touched = True
++    return touched
++
++
++def _until_beside(moment: datetime.datetime, start: "PropTypes | None"):
++    """Write *moment* the way an UNTIL beside this DTSTART has to be written.
++
++    RFC 5545 §3.3.10: UNTIL takes the value type of DTSTART, and it is a UTC
++    date-time whenever DTSTART is one or carries a time zone. The boundary
++    arrives written in whatever zone the sender chose, which is the same
++    instant as ours written differently — so it is converted, not copied. A
++    local time written without its zone is a different instant for every
++    reader, and the occurrence that instant lands on is off by the offset.
++    """
++    dt = getattr(start, "dt", None)
++    if isinstance(dt, datetime.datetime):
++        moment = moment.astimezone(datetime.timezone.utc)
++        # A floating DTSTART has no zone to be an offset from; its UNTIL
++        # floats with it.
++        return moment if dt.tzinfo is not None else moment.replace(tzinfo=None)
++    if isinstance(dt, datetime.date):
++        return moment.astimezone(datetime.timezone.utc).date()
++    return moment
++
++
++def _as_instant(prop: "PropTypes | None") -> "datetime.datetime | None":
++    """Return *prop*'s value as a comparable instant, or None."""
++    dt = getattr(prop, "dt", None)
++    if isinstance(dt, datetime.datetime):
++        return dt if dt.tzinfo is not None else dt.replace(tzinfo=datetime.timezone.utc)
++    if isinstance(dt, datetime.date):
++        return datetime.datetime.combine(dt, datetime.time(), datetime.timezone.utc)
++    return None
++
++
+ def preserve_partstats(existing: Calendar, incoming: Calendar) -> Calendar:
+     """Mutate *incoming* in place so attendee PARTSTATs survive a re-REQUEST.
+ 
+     RFC 6638 §3.2.1: when an organiser sends a fresh REQUEST, the
+     attendee's prior PARTSTAT must survive. We match attendees across
+-    components by (UID, RECURRENCE-ID, ATTENDEE address). Returns the
+-    same *incoming* object for chaining.
++    components by (UID, occurrence, ATTENDEE address) — by the occurrence
++    itself, not by the text that wrote it, or the same occurrence named in
++    the sender's own time zone would look like a new one and the answer
++    already given for it would be thrown away. Returns the same *incoming*
++    object for chaining.
+     """
+     existing_partstats: dict[tuple[str, str, str], str] = {}
+     for comp in existing.subcomponents:
+         if comp.name not in SCHEDULING_COMPONENTS:
+             continue
+         uid = str(comp.get("UID", ""))
+-        rid = str(comp.get("RECURRENCE-ID", ""))
++        rid = recurrence_key(comp)
+         attendees = comp.get("ATTENDEE", [])
+         if not isinstance(attendees, list):
+             attendees = [attendees]
+@@ -480,7 +861,7 @@ def preserve_partstats(existing: Calendar, incoming: Calendar) -> Calendar:
+         if comp.name not in SCHEDULING_COMPONENTS:
+             continue
+         uid = str(comp.get("UID", ""))
+-        rid = str(comp.get("RECURRENCE-ID", ""))
++        rid = recurrence_key(comp)
+         attendees = comp.get("ATTENDEE", [])
+         if not isinstance(attendees, list):
+             attendees = [attendees]
+diff --git a/xandikos/web.py b/xandikos/web.py
+index 8b148f8..2ce619d 100644
+--- a/xandikos/web.py
++++ b/xandikos/web.py
+@@ -86,7 +86,7 @@ from xandikos.store import (
+     Store,
+ )
+ 
+-from icalendar.cal import Calendar
++from icalendar.cal import Calendar, Component
+ from icalendar.cal import Timezone as VTimezone
+ 
+ from .icalendar import CalendarFilter, ICalendarFile
+@@ -910,6 +910,19 @@ class ScheduleInbox(StoreBasedCollection, scheduling.ScheduleInbox):
+             return
+         member_name, member, existing_cal = existing
+         merged = itip.preserve_partstats(existing_cal, new_cal)
++        if not itip.covers_series(itip_message, uid):
++            # A REQUEST that names occurrences updates those occurrences; the
++            # series it does not carry is not ours to drop, and an occurrence
++            # the series does not produce is not ours to add.
++            narrowed = _occurrences_of_the_series(existing_cal, merged, uid)
++            if narrowed is None:
++                logger.info(
++                    "Inbox auto-apply: REQUEST for %s named no occurrence the "
++                    "series produces",
++                    uid,
++                )
++                return
++            merged = _splice_occurrences(existing_cal, narrowed)
+         await _replace_member_body(member, merged)
+         logger.info(
+             "Inbox auto-apply: updated %s (%s) in %s for REQUEST",
+@@ -930,14 +943,33 @@ class ScheduleInbox(StoreBasedCollection, scheduling.ScheduleInbox):
+             )
+             return
+         member_name, member, existing_cal = existing
+-        for comp in existing_cal.subcomponents:
+-            if (
+-                comp.name in itip.SCHEDULING_COMPONENTS
+-                and str(comp.get("UID", "")) == uid
+-            ):
+-                comp["STATUS"] = "CANCELLED"
++        onwards = itip.thisandfuture_occurrence(itip_message, uid)
++        if onwards is not None:
++            if not itip.end_series_at(existing_cal, uid, onwards):
++                logger.info(
++                    "Inbox auto-apply: CANCEL for %s named nothing we hold", uid
++                )
++                return
++            await _replace_member_body(member, existing_cal)
++            logger.info(
++                "Inbox auto-apply: cancelled %s (%s) from one occurrence onwards",
++                uid,
++                member_name,
++            )
++            return
++        targets = _occurrence_targets(existing_cal, itip_message, uid)
++        if not targets:
++            logger.info("Inbox auto-apply: CANCEL for %s named nothing we hold", uid)
++            return
++        for comp in targets:
++            comp["STATUS"] = "CANCELLED"
+         await _replace_member_body(member, existing_cal)
+-        logger.info("Inbox auto-apply: cancelled %s (%s)", uid, member_name)
++        logger.info(
++            "Inbox auto-apply: cancelled %d occurrence(s) of %s (%s)",
++            len(targets),
++            uid,
++            member_name,
++        )
+ 
+     async def _apply_reply(
+         self,
+@@ -952,34 +984,51 @@ class ScheduleInbox(StoreBasedCollection, scheduling.ScheduleInbox):
+             return
+         member_name, member, existing_cal = existing
+ 
+-        # Pick out the replying attendee's address + new PARTSTAT.
+-        updates: dict[str, str] = {}
++        # Pick out the replying attendee's address + new PARTSTAT, per the
++        # occurrence the answer is about.
++        updates: dict[tuple[str, str], str] = {}
+         for comp in itip_message.subcomponents:
+             if comp.name not in itip.SCHEDULING_COMPONENTS:
+                 continue
+             if str(comp.get("UID", "")) != uid:
+                 continue
++            key = itip.recurrence_key(comp)
+             attendees = comp.get("ATTENDEE", [])
+             if not isinstance(attendees, list):
+                 attendees = [attendees]
+             for a in attendees:
+                 partstat = a.params.get("PARTSTAT")
+                 if partstat is not None:
+-                    updates[str(a)] = str(partstat)
++                    updates[(key, str(a))] = str(partstat)
+         if not updates:
+             return
+ 
++        # An answer that carries the series answers for all of it; an answer
++        # that names occurrences answers for those, whether or not we already
++        # keep a component for them.
++        whole = itip.covers_series(itip_message, uid)
++        # An answer marked RANGE=THISANDFUTURE is about the occurrence it
++        # names and every later one: it lands on each of those, and on none
++        # before.
++        onwards = itip.thisandfuture_occurrence(itip_message, uid)
++        if onwards is not None:
++            onwards_key = itip._instant_key(onwards)
++            targets = itip.onwards_targets(existing_cal, uid, onwards)
++        else:
++            onwards_key = None
++            targets = _occurrence_targets(existing_cal, itip_message, uid)
+         changed = False
+-        for comp in existing_cal.subcomponents:
+-            if comp.name not in itip.SCHEDULING_COMPONENTS:
+-                continue
+-            if str(comp.get("UID", "")) != uid:
+-                continue
++        for comp in targets:
++            key = itip.recurrence_key(comp)
+             attendees = comp.get("ATTENDEE", [])
+             if not isinstance(attendees, list):
+                 attendees = [attendees]
+             for a in attendees:
+-                new_partstat = updates.get(str(a))
++                new_partstat = updates.get((key, str(a)))
++                if new_partstat is None and onwards_key is not None:
++                    new_partstat = updates.get((onwards_key, str(a)))
++                if new_partstat is None and whole:
++                    new_partstat = updates.get(("", str(a)))
+                 if (
+                     new_partstat is not None
+                     and a.params.get("PARTSTAT") != new_partstat
+@@ -992,7 +1041,10 @@ class ScheduleInbox(StoreBasedCollection, scheduling.ScheduleInbox):
+                 "Inbox auto-apply: applied REPLY to %s (%s); updated PARTSTATs: %s",
+                 uid,
+                 member_name,
+-                ", ".join(f"{addr}={ps}" for addr, ps in updates.items()),
++                ", ".join(
++                    f"{addr}={ps}" + (f" ({key})" if key else "")
++                    for (key, addr), ps in updates.items()
++                ),
+             )
+         else:
+             logger.info(
+@@ -1002,6 +1054,115 @@ class ScheduleInbox(StoreBasedCollection, scheduling.ScheduleInbox):
+             )
+ 
+ 
++def _occurrence_targets(
++    existing_cal: Calendar, itip_message: Calendar, uid: str
++) -> "list[Component]":
++    """Return the stored components an iTIP message speaks about.
++
++    A message that carries the series speaks for the whole of it. A message
++    that names occurrences speaks for exactly those — and RFC 5546 lets it
++    name an occurrence the recipient keeps no component for, because the
++    recipient holds the series as one recurring component and the organiser
++    never had reason to move that occurrence. Such an occurrence is broken
++    out of the series first, so there is something to apply the message to.
++    """
++    occurrences = itip.itip_occurrences(itip_message, uid)
++    whole = "" in occurrences
++    targets: list[Component] = []
++    seen: set[str] = set()
++    for comp in existing_cal.subcomponents:
++        if comp.name not in itip.SCHEDULING_COMPONENTS:
++            continue
++        if str(comp.get("UID", "")) != uid:
++            continue
++        key = itip.recurrence_key(comp)
++        if whole or key in occurrences:
++            targets.append(comp)
++            seen.add(key)
++    if whole:
++        return targets
++    for key, rid in occurrences.items():
++        if key in seen or rid is None:
++            continue
++        broken_out = itip.materialise_occurrence(existing_cal, uid, rid)
++        if broken_out is not None:
++            targets.append(broken_out)
++    return targets
++
++
++def _occurrences_of_the_series(
++    existing_cal: Calendar, incoming: Calendar, uid: str
++) -> "Calendar | None":
++    """Drop *incoming*'s components for occurrences the series never produces.
++
++    A message may name an occurrence we keep no component for: the organiser
++    never moved it, so it lives inside the RRULE, and it is ours to break
++    out. An instant the recurrence set does not produce at all is a
++    different matter — taking that one would put a meeting in the calendar
++    that nobody scheduled, under the UID of one that exists. Components of
++    other UIDs, and the VTIMEZONEs, travel through untouched.
++
++    Returns None when nothing of *uid* survives, so the caller can leave the
++    stored object exactly as it was.
++    """
++    held = {
++        itip.recurrence_key(comp)
++        for comp in existing_cal.subcomponents
++        if comp.name in itip.SCHEDULING_COMPONENTS and str(comp.get("UID", "")) == uid
++    }
++    if "" not in held:
++        # What we keep of this event is occurrences and no series. There is no
++        # recurrence set here to say what it does and does not produce, so
++        # there is nothing to refuse: each occurrence stands on its own.
++        return incoming
++    out = Calendar()
++    for field in incoming:
++        out[field] = incoming[field]
++    kept = 0
++    for comp in incoming.subcomponents:
++        if (
++            comp.name not in itip.SCHEDULING_COMPONENTS
++            or str(comp.get("UID", "")) != uid
++        ):
++            out.add_component(comp)
++            continue
++        rid = comp.get("RECURRENCE-ID")
++        if (
++            itip.recurrence_key(comp) in held
++            or rid is None
++            or itip.series_produces(existing_cal, uid, rid)
++        ):
++            out.add_component(comp)
++            kept += 1
++    return out if kept else None
++
++
++def _splice_occurrences(existing_cal: Calendar, incoming: Calendar) -> Calendar:
++    """Put *incoming*'s components in their place inside *existing_cal*.
++
++    Components are matched by name, UID and occurrence, so an update that
++    names one occurrence replaces that occurrence and leaves the rest of the
++    series where it was — and the same occurrence written a second way
++    replaces the first rather than joining it.
++    """
++    out = Calendar()
++    for field in existing_cal:
++        out[field] = existing_cal[field]
++    by_key: dict = {}
++    order: list = []
++    for comp in list(existing_cal.subcomponents) + list(incoming.subcomponents):
++        if comp.name in itip.SCHEDULING_COMPONENTS:
++            key = (comp.name, str(comp.get("UID", "")), itip.recurrence_key(comp))
++        else:
++            key = (comp.name, comp.to_ical())
++        if key not in by_key:
++            order.append(key)
++        by_key[key] = comp
++    for key in order:
++        out.add_component(by_key[key])
++    return out
++
++
+ async def _find_calendar_member_by_uid(
+     calendar: "CalendarCollection", uid: str
+ ) -> "tuple[str, ObjectResource, Calendar] | None":
+@@ -1522,24 +1683,26 @@ class CalendarCollection(StoreBasedCollection, caldav.Calendar):
+         new_cal: Calendar,
+         old_cal: Calendar,
+         own_addresses: set[str],
+-        new_delegates: set[str],
++        new_delegates: "set[tuple[str, str]]",
+     ) -> None:
+         """Raise if *new_cal* changes anything beyond the user's own ATTENDEE.
+ 
+         Compares scheduling signatures of *old_cal* and *new_cal* with
+         the user's own ATTENDEE parameters masked, and any newly-added
+-        delegates skipped entirely (RFC 6638 §3.2.6 lets an attendee
+-        add a delegate ATTENDEE, distinguishable by its DELEGATED-FROM
+-        pointing back at the user). If anything else differs, the user
+-        is touching organiser-owned data.
++        delegates dropped where they were added (RFC 6638 §3.2.6 lets an
++        attendee add a delegate ATTENDEE, distinguishable by its
++        DELEGATED-FROM pointing back at the user). The exception is as
++        narrow as the delegation: it covers the occurrences the user
++        actually delegated, not every occurrence that happens to mention
++        the same address. If anything else differs, the user is touching
++        organiser-owned data.
+         """
+         mask = frozenset(own_addresses)
+-        skip = frozenset(new_delegates)
+         new_masked = itip.extract_scheduling_signature(
+-            new_cal, mask_own_attendee_params=mask, skip_attendees=skip
++            _without_attendees(new_cal, new_delegates), mask_own_attendee_params=mask
+         )
+         old_masked = itip.extract_scheduling_signature(
+-            old_cal, mask_own_attendee_params=mask, skip_attendees=skip
++            old_cal, mask_own_attendee_params=mask
+         )
+         if new_masked != old_masked:
+             raise webdav.PreconditionFailure(
+@@ -1555,31 +1718,45 @@ class CalendarCollection(StoreBasedCollection, caldav.Calendar):
+         old_cal: Calendar | None,
+         new_attendees: set[str],
+         own_addresses: set[str],
+-    ) -> dict[str, str]:
+-        """Send REQUEST/CANCEL and return ``{address: SCHEDULE-STATUS code}``."""
+-        outcomes: dict[str, str] = {}
++    ) -> "dict[str, tuple[str, frozenset[str]]]":
++        """Send REQUEST/CANCEL; return ``{address: (code, occurrences sent)}``.
++
++        An attendee is invited to the occurrences that list them, which for a
++        series with exceptions need not be all of them, so each attendee is
++        sent the occurrences that are theirs. The occurrences that went out
++        travel back with the delivery outcome: the record of a delivery
++        belongs on what was delivered.
++        """
++        outcomes: dict[str, tuple[str, frozenset[str]]] = {}
+         organiser = _organiser_address(new_cal)
+-        if new_attendees:
+-            request = itip.build_itip_request(new_cal)
+-            for address in new_attendees:
+-                outcomes[address] = await _deliver_status(
++        invited = {a: itip.occurrences_for_attendee(new_cal, a) for a in new_attendees}
++        for address, keys in invited.items():
++            if not keys:
++                continue
++            request = itip.build_itip_request(itip.narrow_to_occurrences(new_cal, keys))
++            outcomes[address] = (
++                await _deliver_status(
+                     self.backend, address, request, originator=organiser
+-                )
++                ),
++                frozenset(keys),
++            )
+ 
+         if old_cal is None:
+             return outcomes
+         _, old_attendees = _organiser_attendees(old_cal, own_addresses)
+-        dropped = old_attendees - new_attendees
+-        if dropped:
+-            cancel = itip.build_itip_cancel(old_cal)
+-            for address in dropped:
+-                # Dropped attendees aren't in new_cal, so their CANCEL
+-                # delivery outcomes don't end up annotated anywhere; the
+-                # CANCEL itself is the record. Still goes through the
+-                # iMIP path for non-local recipients.
+-                await _deliver_status(
+-                    self.backend, address, cancel, originator=organiser
+-                )
++        for address in old_attendees:
++            lost = itip.occurrences_for_attendee(old_cal, address) - invited.get(
++                address, set()
++            )
++            if not lost:
++                continue
++            # An attendee who has lost an occurrence — or the whole event —
++            # is told about what they lost and nothing else. Their CANCEL
++            # outcome isn't annotated anywhere (they may not be in new_cal at
++            # all); the CANCEL itself is the record. Still goes through the
++            # iMIP path for non-local recipients.
++            cancel = itip.build_itip_cancel(itip.narrow_to_occurrences(old_cal, lost))
++            await _deliver_status(self.backend, address, cancel, originator=organiser)
+         return outcomes
+ 
+     async def _dispatch_attendee_put(
+@@ -1588,25 +1765,32 @@ class CalendarCollection(StoreBasedCollection, caldav.Calendar):
+         old_cal: Calendar | None,
+         own_addresses: set[str],
+         force_reply: set[str],
+-        new_delegates: set[str],
+-    ) -> dict[str, str]:
++        new_delegates: "set[tuple[str, str]]",
++    ) -> "dict[str, tuple[str, frozenset[str]]]":
+         """Send REPLY to organiser and REQUEST to any newly-added delegates.
+ 
+-        Returns ``{address: SCHEDULE-STATUS code}`` for the delegate
++        Returns ``{address: (code, occurrences sent)}`` for the delegate
+         deliveries; the REPLY itself isn't annotated (the user's own
+         ATTENDEE doesn't carry SCHEDULE-STATUS).
+         """
+-        outcomes: dict[str, str] = {}
++        outcomes: dict[str, tuple[str, frozenset[str]]] = {}
+         own_address = _own_attendee_address(new_cal, own_addresses)
+ 
+-        # RFC 6638 §3.2.6: when the user delegates to someone else,
+-        # the new delegate needs a REQUEST so they see the meeting.
+-        if new_delegates:
+-            request = itip.build_itip_request(new_cal)
+-            for address in new_delegates:
+-                outcomes[address] = await _deliver_status(
++        # RFC 6638 §3.2.6: when the user delegates to someone else, the new
++        # delegate needs a REQUEST so they see the meeting — the part of it
++        # they were handed, which for a single delegated occurrence is that
++        # occurrence and not the rest of the series.
++        delegated: dict[str, set[str]] = {}
++        for key, address in new_delegates:
++            delegated.setdefault(address, set()).add(key)
++        for address, keys in delegated.items():
++            request = itip.build_itip_request(itip.narrow_to_occurrences(new_cal, keys))
++            outcomes[address] = (
++                await _deliver_status(
+                     self.backend, address, request, originator=own_address
+-                )
++                ),
++                frozenset(keys),
++            )
+ 
+         if own_address is None:
+             return outcomes
+@@ -1724,24 +1908,34 @@ def _strip_mailto(address: str) -> str:
+     return address
+ 
+ 
+-def _annotate_schedule_status(cal: Calendar, outcomes: dict[str, str]) -> None:
++def _annotate_schedule_status(
++    cal: Calendar, outcomes: "dict[str, tuple[str, frozenset[str]]]"
++) -> None:
+     """Stamp SCHEDULE-STATUS on each ATTENDEE per RFC 6638 §3.2.
+ 
+-    *outcomes* maps an attendee address (as it appears in ATTENDEE) to
+-    a request-status code. Attendees absent from *outcomes* are left
+-    alone — typically the organiser themselves, who we don't deliver
++    *outcomes* maps an attendee address (as it appears in ATTENDEE) to the
++    request-status code of the delivery and the occurrences that delivery
++    carried. The stamp is the record of that delivery, so it goes on the
++    occurrences that were sent and nowhere else: an occurrence nobody was
++    told about has not been delivered. Attendees absent from *outcomes* are
++    left alone — typically the organiser themselves, who we don't deliver
+     to.
+     """
+     for comp in cal.subcomponents:
+         if comp.name not in itip.SCHEDULING_COMPONENTS:
+             continue
++        key = itip.recurrence_key(comp)
+         attendees = comp.get("ATTENDEE", [])
+         if not isinstance(attendees, list):
+             attendees = [attendees]
+         for a in attendees:
+-            status = outcomes.get(str(a))
+-            if status is not None:
+-                a.params["SCHEDULE-STATUS"] = status
++            outcome = outcomes.get(str(a))
++            if outcome is None:
++                continue
++            status, sent = outcome
++            if key not in sent:
++                continue
++            a.params["SCHEDULE-STATUS"] = status
+ 
+ 
+ def _consume_force_send(cal: Calendar) -> tuple[set[str], set[str], bool]:
+@@ -1813,19 +2007,22 @@ def _organiser_attendees(
+     return is_organiser, attendees
+ 
+ 
+-def _delegates_of(cal: Calendar, own_addresses: set[str]) -> set[str]:
+-    """Return ATTENDEE addresses delegated FROM one of *own_addresses*.
++def _delegates_of(cal: Calendar, own_addresses: set[str]) -> "set[tuple[str, str]]":
++    """Return ``(occurrence, ATTENDEE)`` pairs delegated FROM *own_addresses*.
+ 
+     RFC 5545 §3.8.4.4: an ATTENDEE may carry DELEGATED-FROM listing
+     the address(es) that delegated to them. We pick the entries
+     whose DELEGATED-FROM matches the user — those are the user's
+     delegates and the user is allowed to add them on a PUT
+-    (RFC 6638 §3.2.6).
++    (RFC 6638 §3.2.6). A delegation is made on an occurrence, so the
++    occurrence travels with the address: handing over one occurrence of a
++    series says nothing about the others.
+     """
+-    out: set[str] = set()
++    out: set[tuple[str, str]] = set()
+     for comp in cal.subcomponents:
+         if comp.name not in itip.SCHEDULING_COMPONENTS:
+             continue
++        key = itip.recurrence_key(comp)
+         comp_attendees = comp.get("ATTENDEE", [])
+         if not isinstance(comp_attendees, list):
+             comp_attendees = [comp_attendees]
+@@ -1837,7 +2034,28 @@ def _delegates_of(cal: Calendar, own_addresses: set[str]) -> set[str]:
+                 delegated_from if isinstance(delegated_from, list) else [delegated_from]
+             )
+             if any(str(src) in own_addresses for src in sources):
+-                out.add(str(a))
++                out.add((key, str(a)))
++    return out
++
++
++def _without_attendees(cal: Calendar, pairs: "set[tuple[str, str]]") -> Calendar:
++    """Return a copy of *cal* with those ``(occurrence, ATTENDEE)`` pairs gone."""
++    out = Calendar()
++    for field in cal:
++        out[field] = cal[field]
++    for comp in cal.subcomponents:
++        clone = comp.copy()
++        if clone.name in itip.SCHEDULING_COMPONENTS:
++            key = itip.recurrence_key(clone)
++            attendees = clone.get("ATTENDEE", [])
++            if not isinstance(attendees, list):
++                attendees = [attendees]
++            kept = [a for a in attendees if (key, str(a)) not in pairs]
++            if len(kept) != len(attendees):
++                del clone["ATTENDEE"]
++                for a in kept:
++                    clone.add("ATTENDEE", a)
++        out.add_component(clone)
+     return out
+ 
+ 
+@@ -1887,7 +2105,11 @@ def _partstat_changed(new_cal: Calendar, old_cal: Calendar, address: str) -> boo
+ 
+ 
+ def _user_partstats(cal: Calendar, address: str) -> dict[tuple[str, str, str], str]:
+-    """Map (component-name, UID, RECURRENCE-ID) → PARTSTAT for *address*."""
++    """Map (component-name, UID, occurrence) → PARTSTAT for *address*.
++
++    Keyed by the occurrence itself: rewriting the same occurrence in another
++    time zone is not the user answering again.
++    """
+     out: dict[tuple[str, str, str], str] = {}
+     for comp in cal.subcomponents:
+         if comp.name not in itip.SCHEDULING_COMPONENTS:
+@@ -1899,7 +2121,7 @@ def _user_partstats(cal: Calendar, address: str) -> dict[tuple[str, str, str], s
+             if str(a) != address:
+                 continue
+             uid = str(comp.get("UID", ""))
+-            rid = str(comp.get("RECURRENCE-ID", ""))
++            rid = itip.recurrence_key(comp)
+             partstat = str(a.params.get("PARTSTAT", "NEEDS-ACTION"))
+             out[(comp.name, uid, rid)] = partstat
+             break
+
+REFERENCE_PATCH

harbor/tasks/xandikos_itip_recurrence_id_override_contract/task.toml

@@ -0,0 +1,26 @@
+version = "1.0"
+artifacts = ["/workspace/submissions/submitted.patch"]
+[metadata]
+task = "xandikos_itip_recurrence_id_override_contract"
+validation_revision = "coding-rubric-v2"
+[agent]
+timeout_sec = 1800
+user = "1000:1000"
+[environment]
+build_timeout_sec = 1800
+cpus = 2
+memory_mb = 8192
+network_mode = "no-network"
+[verifier]
+timeout_sec = 7200
+user = "0"
+environment_mode = "separate"
+[verifier.environment]
+build_timeout_sec = 1800
+cpus = 2
+memory_mb = 8192
+network_mode = "no-network"
+[[verifier.collect]]
+command = "/opt/task-tools/python -I /opt/task-tools/capture.py"
+user = "0"
+timeout_sec = 900

harbor/tasks/xandikos_itip_recurrence_id_override_contract/tests/Dockerfile

@@ -0,0 +1,9 @@
+FROM ec-swe-xandikos:source-v7
+USER root
+RUN grep -q '^[^:]*:[^:]*:1000:' /etc/passwd || echo 'grader:x:1000:1000::/tmp/agent-home:/bin/sh' >> /etc/passwd; grep -q '^[^:]*:[^:]*:1000:' /etc/group || echo 'grader:x:1000:' >> /etc/group
+ENV HUD_TELEMETRY_ENABLED=false HUD_CLI_ANALYTICS_ENABLED=0 HUD_FILE_TRACKING_ENABLED=false
+RUN rm -f /hud/gold.diff
+COPY verify.py evidence.py config.json test.sh /tests/
+RUN chmod 755 /tests/test.sh
+WORKDIR /app
+CMD ["sleep", "infinity"]

harbor/tasks/xandikos_itip_recurrence_id_override_contract/tests/config.json

@@ -0,0 +1,154 @@
+{
+  "revision": "coding-rubric-v2",
+  "task_id": "xandikos_itip_recurrence_id_override_contract",
+  "arguments": {},
+  "grader_version": "0.6.15",
+  "source_image": "ec-swe-xandikos:source-v7",
+  "source_image_id": "sha256:303351c10fb1888c091fd0f23b2cf28b0b39a3f4b79b78a055e5d7d587facf5f",
+  "provenance": {
+    "repository": "jelmer/xandikos",
+    "environment_id": "372a37cc-b31d-4523-9ffc-8ecc64a3fddb",
+    "build": 7,
+    "build_id": "acd4eec1-b215-40c7-a378-bd216baac6b5",
+    "hosted_task": "xandikos_itip_recurrence_id_override_contract-c6aa163a",
+    "task_version": "ef0272f8-7c28-4c25-a433-56b44da3aa32",
+    "source_archive_sha256": "53d61bc9e61cd485df1f6fddc33d023338eb7695ad508eaeac38978df8c109dd",
+    "hosted_revision_argument": "not recorded; the scenario does not read it"
+  },
+  "criteria": [
+    [
+      "one_occurrence_is_not_the_whole_series",
+      0.045,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "cancel_names_one_occurrence_of_the_series",
+      0.045,
+      true,
+      "bash",
+      600
+    ],
+    [
+      "reply_answers_for_one_occurrence",
+      0.045,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "the_same_instant_written_differently",
+      0.045,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "delegate_hears_about_the_delegated_occurrence",
+      0.045,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "delegation_does_not_hide_an_uninvited_occurrence",
+      0.045,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "cancel_from_one_occurrence_onwards",
+      0.135,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "a_revision_from_one_occurrence_onwards",
+      0.135,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "later_occurrences_move_with_that_one",
+      0.135,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "an_answer_from_one_occurrence_onwards",
+      0.135,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "an_answer_onwards_reaches_an_occurrence_moved_on_its_own",
+      0.135,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "a_day_the_series_never_had_is_not_invented",
+      0.045,
+      false,
+      "bash",
+      600
+    ],
+    [
+      "gate_repo_suite_green_and_tests_untouched",
+      0.01,
+      true,
+      "bash",
+      900
+    ]
+  ],
+  "gates": [],
+  "reward_rule": "weighted_cap",
+  "local_hostname": false,
+  "fault_exit": 3,
+  "grader_readable": [],
+  "grader_writable": [],
+  "blocker_cap": 0.6,
+  "empty_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "verifier_files": {
+    "/app/env.py": "4c802d6298c4339bdf8284deacb54c1f6812eecc48d50b9c2c07fe60dbf5567f",
+    "/app/tasks.py": "6e97d968d30d89326bb220ea473efb5be5cc1820b4e4a8859eb292e8879efd27",
+    "/app/coding/github.py": "dfb450735dd44af94d51088ccd37df0470a4bf7c1339f5277aea2419bd64c694",
+    "/app/coding/repo.py": "b1366540d1ea28ccb7cc578a311662ef4a2b9e7e5a4c27543dcbd594cc6d86da",
+    "/app/coding/swe_bench_pro.py": "9b1131236eb514c62ba3a3bfb7aba61bad29df18a0293afc1bcb8a277c4ff929",
+    "/app/coding/__init__.py": "9ba11441d392f54835f33527d4a098f48528824a8f8c3c255cf4c140f89523bf",
+    "/app/task/prompt.md": "a0db17267577e9da6539913c1d63605eda8ca93614b62102ae361f75f7990245",
+    "/hud/grader/run_grading.sh": "0fc5276c4fbf084f29af16663af161beb8ca504618c24e686ef68a9d280dd02a",
+    "/hud/grader/suite_deselect.txt": "f8399d13d30a10a972d549421ecf802f65f7ed1adee4e5996b61229883794b07",
+    "/hud/grader/cells/spec_cells.py": "984a3fd75b9cbfc688be5ad867bf666c50fded513efc45d52e2bf415e190476b"
+  },
+  "preflight": [
+    [
+      "/bin/bash",
+      "--version"
+    ],
+    [
+      "setpriv",
+      "--version"
+    ],
+    [
+      "git",
+      "--version"
+    ],
+    [
+      "bash",
+      "-c",
+      "bash -lc 'python --version' || python --version"
+    ],
+    [
+      "/opt/agentvenv/bin/python",
+      "--version"
+    ]
+  ]
+}

harbor/tasks/xandikos_itip_recurrence_id_override_contract/tests/docker-compose.yaml

@@ -0,0 +1,6 @@
+services:
+  main:
+    network_mode: none
+    pids_limit: 512
+    security_opt:
+      - no-new-privileges:true

harbor/tasks/xandikos_itip_recurrence_id_override_contract/tests/evidence.py

@@ -0,0 +1,123 @@
+"""Validate complete coding-rubric evidence without importing the grader library or Harbor."""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+REVISION = "coding-rubric-v2"
+
+
+def _number(value: Any) -> float:
+    if isinstance(value, bool) or not isinstance(value, (float, int)):
+        raise ValueError("Expected numeric rubric evidence")
+    if not math.isfinite(value) or not 0 <= value <= 1:
+        raise ValueError("Rubric values must be finite and within [0, 1]")
+    return float(value)
+
+
+def validate_report(report: dict[str, Any], config: dict[str, Any], digest: str) -> None:
+    """Check provenance, criterion coverage, weights, caps and command outcomes.
+
+    Parameters
+    ----------
+    report, config : dict
+        Fresh verifier evidence and the trusted prepared task configuration.
+    digest : str
+        SHA-256 of the submission collected by Harbor.
+
+    Raises
+    ------
+    ValueError
+        If evidence is missing, inconsistent or reports infrastructure failure.
+    """
+    if (
+        report.get("revision") != REVISION
+        or report.get("task_id") != config["task_id"]
+        or report.get("patch_sha256") != digest
+        or report.get("grader_version") != config["grader_version"]
+    ):
+        raise ValueError("Verifier evidence provenance mismatch")
+    result = report.get("result", {})
+    reward = _number(result.get("reward"))
+    # A rubric may flag its own result when a grader could not judge. That is
+    # admitted only together with proof, checked below, that the same grader
+    # reaches a verdict on the untouched repository.
+    fault_exit = config.get("fault_exit")
+    faults = {
+        row["name"]
+        for row in report.get("commands", [])
+        if fault_exit is not None and (row.get("info") or {}).get("exit_code") == fault_exit
+    }
+    flagged = result.get("isError", False)
+    if (flagged and not faults) or result.get("done", True) is not True:
+        raise ValueError("Grader returned an incomplete or failed evaluation")
+    status = report.get("status")
+    if status == "rejected_patch":
+        if reward != 0 or not report.get("patch_error") or result.get("subscores"):
+            raise ValueError("Invalid rejected-patch evidence")
+        return
+    if status == "empty_patch":
+        credited = any(_number(row["value"]) for row in result.get("subscores") or [])
+        if reward != 0 or digest != config["empty_sha256"] or report.get("commands") or credited:
+            raise ValueError("Invalid empty-patch evidence")
+        return
+    if status != "graded":
+        raise ValueError("Verifier did not complete")
+    scores = result.get("subscores")
+    expected = {row[0]: row for row in config["criteria"]}
+    if not isinstance(scores, list) or len(scores) != len(expected):
+        raise ValueError("Missing rubric criteria")
+    names = [row["name"] for row in scores]
+    if len(set(names)) != len(names) or set(names) != set(expected):
+        raise ValueError("Duplicate or unexpected rubric criteria")
+    raw = 0.0
+    values = {}
+    for score in scores:
+        name = score["name"]
+        value, weight = _number(score["value"]), _number(score["weight"])
+        if not math.isclose(weight, expected[name][1], abs_tol=1e-12):
+            raise ValueError("Criterion weights changed")
+        raw += value * weight
+        values[name] = value
+    commands = report.get("commands", [])
+    command_names = [row["name"] for row in commands]
+    expected_commands = set(expected) | set(config["gates"])
+    if len(command_names) != len(set(command_names)) or set(command_names) != expected_commands:
+        raise ValueError("Missing or duplicate grader command evidence")
+    for command in commands:
+        info = command.get("info") or {}
+        code = info.get("exit_code")
+        verdict = type(code) is int and (code in (0, 1) or command["name"] in faults)
+        if not verdict or info.get("timed_out"):
+            raise ValueError("Grader command failed outside its verdict contract")
+        if _number(command["value"]) != float(code == 0):
+            raise ValueError("Command exit code disagrees with score")
+    probes = {row["name"]: row for row in report.get("fault_probes") or []}
+    if set(probes) != faults or any(
+        row.get("timed_out") or row.get("exit_code") not in (0, 1) for row in probes.values()
+    ):
+        raise ValueError(
+            "A grader could not judge and the untouched repository does not explain it"
+        )
+    if any(values.get(name, 0) for name in faults):
+        raise ValueError("A criterion its grader could not judge is credited")
+    info = result.get("info") or {}
+    if info.get("aggregate_mismatch") or info.get("git_apply"):
+        raise ValueError("Grader reported inconsistent grading")
+    if config.get("reward_rule") == "authored":
+        # The task's own function decides the reward. It may take credit away
+        # (a cap, a criterion that pays only with progress) but never add any.
+        passed = {row["name"]: row["value"] for row in commands}
+        if any(values[name] > passed[name] for name in expected):
+            raise ValueError("A criterion is credited although its command failed")
+        if reward > raw + 1e-9:
+            raise ValueError("Grader reward exceeds its weighted criteria")
+        return
+    failed = {name for name, row in expected.items() if row[2] and values[name] < 1}
+    gate_failed = {
+        row["name"] for row in commands if row["name"] in config["gates"] and row["value"] < 1
+    }
+    expected_reward = min(raw, config["blocker_cap"]) if failed or gate_failed else raw
+    if not math.isclose(reward, expected_reward, abs_tol=1e-9):
+        raise ValueError("Grader reward disagrees with original weights and blocker cap")

harbor/tasks/xandikos_itip_recurrence_id_override_contract/tests/test.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euo pipefail
+/opt/hudvenv/bin/python /tests/verify.py

harbor/tasks/xandikos_itip_recurrence_id_override_contract/tests/verify.py

@@ -0,0 +1,235 @@
+"""Run the original trusted coding rubric in a fresh, offline verifier container."""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import importlib
+import importlib.metadata
+import json
+import os
+import shlex
+import shutil
+import signal
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+from evidence import REVISION, validate_report
+
+OUT = Path("/logs/verifier")
+PRIVATE = Path("/var/lib/task-evidence")
+CONFIG = Path("/tests/config.json")
+PATCH = Path("/workspace/submissions/submitted.patch")
+GRADER_HOME = "/tmp/agent-home"
+
+
+def _run(command: list[str], **kwargs: Any) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(command, text=True, capture_output=True, timeout=300, **kwargs)
+
+
+def _preflight(config: dict[str, Any]) -> None:
+    if importlib.metadata.version("hud") != config["grader_version"]:
+        raise RuntimeError("Grader library version does not match the task")
+    for filename, expected in config["verifier_files"].items():
+        if hashlib.sha256(Path(filename).read_bytes()).hexdigest() != expected:
+            raise RuntimeError(f"Verifier source changed: {filename}")
+    for command in config["preflight"]:
+        completed = _run(command, cwd="/workspace/repo")
+        if completed.returncode:
+            raise RuntimeError(f"Prerequisite failed: {command}: {completed.stderr[-2000:]}")
+
+
+def _readable_mode(path: Path) -> int:
+    # World-readable, keeping what is executable so: a grader may ship tools.
+    return 0o755 if path.is_dir() or path.stat().st_mode & 0o111 else 0o644
+
+
+def _permissions() -> None:
+    # The orchestrator owns reports and rubric definitions. Grader commands,
+    # and so the candidate's code, run as uid 1000: the user the task installed
+    # its toolchain and caches for. They cannot read gold/vault or overwrite
+    # the rubric or the result files, which stay root's.
+    Path("/hud").chmod(0o711)
+    for root in (Path("/hud/grader"), Path("/hud/base"), Path("/hud/base-src")):
+        if root.exists():
+            root.chmod(0o755)
+            for path in root.rglob("*"):
+                if not path.is_symlink():
+                    path.chmod(_readable_mode(path))
+    home = Path(GRADER_HOME)
+    home.mkdir(parents=True, exist_ok=True)
+    os.chown(home, 1000, 1000)
+    for directory in ("/hud/logs", "/hud/gocache", "/hud/grader/runner"):
+        path = Path(directory)
+        path.mkdir(parents=True, exist_ok=True)
+        for item in (path, *path.rglob("*")):
+            if not item.is_symlink():
+                os.chown(item, 1000, 1000)
+                item.chmod(_readable_mode(item))
+
+
+def _hand_over_checkout() -> None:
+    # The original grader runs as root and may run the candidate's own suite in
+    # place, which writes into the tree. The rubric resets and re-applies the
+    # candidate as root, so give what root touched back to the grading user.
+    # Installed dependency trees are large and already that user's.
+    subprocess.run(
+        [
+            "find",
+            "/workspace/repo",
+            "-path",
+            "*/node_modules",
+            "-prune",
+            "-o",
+            "!",
+            "-user",
+            "1000",
+            "-exec",
+            "chown",
+            "-h",
+            "1000:1000",
+            "{}",
+            "+",
+        ],
+        check=True,
+        capture_output=True,
+        timeout=3600,
+    )
+
+
+async def _grade(config: dict[str, Any], record: dict[str, Any]) -> None:
+    _preflight(config)
+    sys.path.insert(0, "/app")
+    task: Any = importlib.import_module("tasks")
+    await task._setup()
+    _permissions()
+    patch = PATCH.read_bytes()
+    if patch:
+        checked = _run(["git", "apply", "--check", str(PATCH)], cwd="/workspace/repo")
+        if checked.returncode:
+            record.update(
+                status="rejected_patch",
+                patch_error=checked.stderr[-4000:],
+                result={"reward": 0.0, "subscores": None},
+            )
+            return
+        _run(["git", "apply", str(PATCH)], cwd="/workspace/repo", check=True)
+    original = task.BashGrader
+    fault_exit = config.get("fault_exit")
+    faulted: list[tuple[tuple[Any, ...], dict[str, Any], str]] = []
+
+    class ObservedGrader:
+        @classmethod
+        async def grade(cls, *args: Any, **kwargs: Any) -> Any:
+            command = kwargs["command"]
+            _hand_over_checkout()
+            kwargs["command"] = (
+                "setpriv --reuid 1000 --regid 1000 --clear-groups --no-new-privs "
+                f"env HOME={GRADER_HOME} bash -lc " + shlex.quote(command)
+            )
+            score = await original.grade(*args, **kwargs)
+            snapshot = score.model_dump(mode="json")
+            record["commands"].append(snapshot)
+            (PRIVATE / "commands.json").write_text(json.dumps(record["commands"], indent=2))
+            info = snapshot.get("info") or {}
+            if info.get("timed_out") or type(info.get("exit_code")) is not int:
+                raise RuntimeError(f"Grader infrastructure failure: {snapshot['name']}")
+            if fault_exit is not None and info["exit_code"] == fault_exit:
+                # The grader says it could not judge. Whether the submission or
+                # the environment is the reason is settled after grading.
+                faulted.append((args, dict(kwargs), snapshot["name"]))
+            elif info["exit_code"] not in (0, 1):
+                raise RuntimeError(f"Grader command exit {info['exit_code']}: {snapshot['name']}")
+            return score
+
+    task.BashGrader = ObservedGrader
+    result = await task._grade(None)
+    if faulted:
+        # Ask the same commands about the untouched repository. A verdict there
+        # means the grader works here and the submission is what it could not
+        # judge, so the criterion stays unmet. No verdict there means the
+        # environment is at fault, and the attempt is invalid.
+        await task.repo_lib.git(task.REPO_DIR, "reset", "--hard", "HEAD")
+        await task.repo_lib.git(task.REPO_DIR, "clean", "-fd")
+        # Graders keep state between criteria, some of them a copy of the tree
+        # they judged. It describes the submission, so it goes too.
+        for leftover in Path(getattr(task, "LOGS_DIR", "/hud/logs")).iterdir():
+            if leftover.is_dir() and not leftover.is_symlink():
+                shutil.rmtree(leftover)
+            else:
+                leftover.unlink()
+        record["fault_probes"] = []
+        for args, kwargs, name in faulted:
+            _hand_over_checkout()
+            probe = (await original.grade(*args, **kwargs)).model_dump(mode="json")
+            info = probe.get("info") or {}
+            record["fault_probes"].append(
+                {
+                    "name": name,
+                    "exit_code": info.get("exit_code"),
+                    "timed_out": info.get("timed_out"),
+                    "stdout": (info.get("stdout") or "")[-2000:],
+                }
+            )
+            (PRIVATE / "fault_probes.json").write_text(json.dumps(record["fault_probes"], indent=2))
+            if info.get("timed_out") or info.get("exit_code") not in (0, 1):
+                raise RuntimeError(f"Grader cannot judge the untouched repository: {name}")
+    record["result"] = result.model_dump(mode="json")
+    # A rubric may answer an empty change without running any criterion.
+    record["status"] = "empty_patch" if not patch and not record["commands"] else "graded"
+
+
+def _stop_candidate_processes() -> None:
+    # A candidate may fork. End its UID's processes before publishing evidence
+    # to a host bind mount, whose permissions may differ on Docker Desktop.
+    for directory in Path("/proc").iterdir():
+        if not directory.name.isdecimal():
+            continue
+        try:
+            status = (directory / "status").read_text()
+            uid = next(line.split()[1] for line in status.splitlines() if line.startswith("Uid:"))
+            if uid == "1000":
+                os.kill(int(directory.name), signal.SIGKILL)
+        except (FileNotFoundError, ProcessLookupError):
+            pass
+
+
+def main() -> None:
+    """Persist structured evidence and publish reward only after validation."""
+    OUT.mkdir(parents=True, exist_ok=True)
+    PRIVATE.mkdir(parents=True, exist_ok=True, mode=0o700)
+    PRIVATE.chmod(0o700)
+    reward_path = OUT / "reward.txt"
+    reward_path.unlink(missing_ok=True)
+    config = json.loads(CONFIG.read_text())
+    shutil.copy2(CONFIG, OUT / "config.json")
+    record: dict[str, Any] = {
+        "revision": REVISION,
+        "task_id": config["task_id"],
+        "grader_version": importlib.metadata.version("hud"),
+        "commands": [],
+        "status": "error",
+    }
+    try:
+        if PATCH.is_symlink() or not PATCH.is_file() or PATCH.stat().st_size > 32 * 1024 * 1024:
+            raise ValueError("Missing, oversized or symlink submission")
+        record["patch_sha256"] = hashlib.sha256(PATCH.read_bytes()).hexdigest()
+        try:
+            asyncio.run(_grade(config, record))
+        finally:
+            _stop_candidate_processes()
+        reward_path.unlink(missing_ok=True)
+        validate_report(record, config, record["patch_sha256"])
+        (OUT / "report.json").write_text(json.dumps(record, indent=2))
+        reward_path.write_text(str(record["result"]["reward"]) + "\n")
+    except BaseException as error:
+        reward_path.unlink(missing_ok=True)
+        record.update(status="error", error={"type": type(error).__name__, "message": str(error)})
+        (OUT / "report.json").write_text(json.dumps(record, indent=2))
+        raise
+
+
+if __name__ == "__main__":
+    main()