create-egregore 0.20.2 → 0.21.0-runtime-mvp.2

package/runtime/claude/egregore_runtime/thread_cli.py

@@ -0,0 +1,173 @@
+"""Runtime-neutral CLI for canonical Thread intent and fold-ins."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+from uuid import uuid4
+
+from .runtime import local_runtime
+from .threads import CanonicalThreadService, THREAD_CONFIRMATION, ThreadError
+
+
+def _context():
+    root = Path(os.environ.get("EGREGORE_ROOT") or Path.cwd()).resolve()
+    runtime = local_runtime(root, push_remote=os.environ.get("EGREGORE_NO_PUSH") != "1")
+    actor = runtime.resolve_actor(
+        session_id=os.environ.get("EGREGORE_SESSION_ID", f"session_{uuid4().hex}"),
+        harness=os.environ.get("EGREGORE_RUNTIME", "shell"),
+    )
+    return runtime, actor, CanonicalThreadService(runtime, (root / "memory").resolve())
+
+
+def _row(snapshot, *, detail=False):
+    row = snapshot.projection_input()
+    row.update(
+        {
+            "id": snapshot.document.artifact.artifact_id,
+            "title": snapshot.title,
+            "canonical_path": f"memory/threads/{snapshot.slug}.md",
+        }
+    )
+    if detail:
+        row["body"] = snapshot.document.body
+    return row
+
+
+def _writeback(receipts):
+    return [receipt.to_dict() for receipt in receipts]
+
+
+def _new(args):
+    _, actor, service = _context()
+    snapshot, receipt = service.create(
+        actor,
+        title=args.title,
+        target=args.target,
+        slug=args.slug,
+        topics=args.topic,
+        people=args.person,
+        next_steps=args.next_step,
+        window_days=args.window_days,
+        review_after_days=args.review_after_days,
+        attention_ttl_days=args.ttl_days,
+        supersedes=args.supersedes,
+    )
+    print(json.dumps({"thread": _row(snapshot), "writeback": receipt.to_dict()}, ensure_ascii=False))
+    return 0 if receipt.status.value in {"accepted", "partial"} else 1
+
+
+def _show(args):
+    _, actor, service = _context()
+    print(json.dumps({"thread": _row(service.read(actor, args.slug), detail=True)}, ensure_ascii=False))
+    return 0
+
+
+def _list(args):
+    _, actor, service = _context()
+    rows = service.list(actor, include_archived=args.all)
+    print(json.dumps({"threads": [_row(row) for row in rows]}, ensure_ascii=False))
+    return 0
+
+
+def _fold(args):
+    _, actor, service = _context()
+    event = json.loads(Path(args.event_json).read_text(encoding="utf-8"))
+    receipt = service.fold(
+        actor,
+        slug=args.slug,
+        event_type=str(event["type"]),
+        field=str(event["field"]),
+        operation=str(event["op"]),
+        payload=event.get("payload"),
+        source=str(event.get("source") or f"session:{actor.session_id}"),
+        expected_revision=args.expected_revision,
+        confirmation=args.confirm,
+    )
+    print(
+        json.dumps(
+            {
+                "thread": _row(receipt.thread),
+                "event_id": receipt.event_id,
+                "writeback": _writeback(receipt.receipts),
+            },
+            ensure_ascii=False,
+        )
+    )
+    return 0 if all(row.status.value in {"accepted", "partial"} for row in receipt.receipts) else 1
+
+
+def _projection_input(args):
+    runtime, actor, service = _context()
+    rows = service.list(actor) if args.slug is None else (service.read(actor, args.slug),)
+    plan = runtime.lifecycle_plan(actor, artifact_types=("thread",))
+    lifecycle = plan.by_id
+    print(
+        json.dumps(
+            {
+                "schema_version": "egregore-thread-projection-input/v1",
+                "source_revision": actor.profile.revision,
+                "lifecycle_revision": plan.snapshot_id,
+                "threads": [
+                    {
+                        "intent": row.projection_input(),
+                        "lifecycle": lifecycle.get(row.document.artifact.artifact_id).to_dict()
+                        if lifecycle.get(row.document.artifact.artifact_id)
+                        else None,
+                    }
+                    for row in rows
+                ],
+                "projection_rule": "derived fields require as_of, confidence, and nonempty why",
+            },
+            ensure_ascii=False,
+        )
+    )
+    return 0
+
+
+def _parser():
+    parser = argparse.ArgumentParser(prog="egregore-thread")
+    commands = parser.add_subparsers(dest="command", required=True)
+    new = commands.add_parser("new")
+    new.add_argument("--title", required=True)
+    new.add_argument("--target", required=True)
+    new.add_argument("--slug")
+    new.add_argument("--topic", action="append", default=[])
+    new.add_argument("--person", action="append", default=[])
+    new.add_argument("--next-step", action="append", default=[])
+    new.add_argument("--window-days", type=int, default=45)
+    new.add_argument("--review-after-days", type=int, default=7)
+    new.add_argument("--ttl-days", type=int, default=30)
+    new.add_argument("--supersedes", action="append", default=[])
+    new.set_defaults(handler=_new)
+    show = commands.add_parser("show")
+    show.add_argument("slug")
+    show.set_defaults(handler=_show)
+    listing = commands.add_parser("list")
+    listing.add_argument("--all", action="store_true")
+    listing.set_defaults(handler=_list)
+    fold = commands.add_parser("fold")
+    fold.add_argument("slug")
+    fold.add_argument("--event-json", required=True)
+    fold.add_argument("--expected-revision", required=True)
+    fold.add_argument("--confirm", choices=(THREAD_CONFIRMATION,), required=True)
+    fold.set_defaults(handler=_fold)
+    projection = commands.add_parser("projection-input")
+    projection.add_argument("slug", nargs="?")
+    projection.set_defaults(handler=_projection_input)
+    return parser
+
+
+def main():
+    args = _parser().parse_args()
+    return args.handler(args)
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except (OSError, PermissionError, ThreadError, ValueError, json.JSONDecodeError) as exc:
+        print(f"thread: {exc}", file=os.sys.stderr)
+        raise SystemExit(1) from exc

package/runtime/claude/egregore_runtime/threads.py

@@ -0,0 +1,517 @@
+"""Runtime-owned Thread intent, fold-in events, and projection inputs.
+
+Threads deliberately keep two substances separate: mutable human intent is
+canonical Markdown/Git state, while inferred state is a disposable projection.
+Every intent mutation is accompanied by an append-only, actor-attributed event.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from datetime import UTC, datetime, timedelta
+import hashlib
+import json
+from pathlib import Path
+import re
+from typing import Any, Callable, Mapping, Sequence
+from uuid import UUID
+
+from .artifacts import (
+    ARTIFACT_SCHEMA_VERSION,
+    CanonicalDocument,
+    content_digest,
+    parse_canonical_markdown,
+)
+from .contracts import ActorContext, ArtifactRelationship, CanonicalArtifact, Permission, WritebackEvent
+from .errors import AuthorizationDenied
+from .policy import scope_allows_path
+from .runtime import EgregoreRuntime
+
+
+THREAD_SCHEMA_VERSION = "egregore-thread/v1"
+THREAD_EVENT_SCHEMA_VERSION = "egregore-thread-event/v1"
+THREAD_CONFIRMATION = "CONFIRM_THREAD_FOLD"
+THREAD_STATUSES = frozenset({"active", "paused", "shipped", "archived"})
+THREAD_EVENT_TYPES = frozenset(
+    {
+        "attach",
+        "detach",
+        "status-change",
+        "blocker-mark",
+        "facet-update",
+        "glossary-trim",
+        "pin",
+    }
+)
+THREAD_FIELDS = frozenset(
+    {
+        "target",
+        "next_steps",
+        "membership_seed",
+        "steward",
+        "stewards",
+        "status",
+        "composes_into",
+        "domain",
+        "planning_horizon",
+        "next_move",
+        "reviewed_at",
+        "facets",
+        "glossary",
+    }
+)
+
+
+class ThreadError(ValueError):
+    """A Thread operation violates its stored-intent lifecycle."""
+
+
+def _slug(value: str) -> str:
+    normalized = re.sub(r"[^a-z0-9]+", "-", value.casefold()).strip("-")[:50]
+    if not normalized:
+        raise ThreadError("thread slug must contain a letter or number")
+    return normalized
+
+
+def _iso(value: datetime) -> str:
+    return value.astimezone(UTC).isoformat().replace("+00:00", "Z")
+
+
+def _clean_strings(values: Sequence[str]) -> tuple[str, ...]:
+    return tuple(dict.fromkeys(" ".join(value.split()) for value in values if value.strip()))
+
+
+def _stable_actor_id(value: str) -> bool:
+    if value.startswith(("actor_", "person:", "service:", "agent:", "legacy-actor:")):
+        return True
+    try:
+        UUID(value)
+    except (ValueError, AttributeError, TypeError):
+        return False
+    return True
+
+
+def _as_mapping(value: Any, *, field: str) -> dict[str, Any]:
+    if value is None:
+        return {}
+    if not isinstance(value, Mapping):
+        raise ThreadError(f"{field} must be an object")
+    return dict(value)
+
+
+@dataclass(frozen=True, slots=True)
+class ThreadSnapshot:
+    slug: str
+    title: str
+    target: str
+    status: str
+    steward_id: str
+    steward_ids: tuple[str, ...]
+    next_steps: tuple[str, ...]
+    membership_seed: Mapping[str, Any]
+    composes_into: tuple[str, ...]
+    domain: str | None
+    planning_horizon: str | None
+    next_move: str | None
+    reviewed_at: str | None
+    facets: Mapping[str, Any]
+    glossary: Mapping[str, Any]
+    document: CanonicalDocument
+
+    @property
+    def revision(self) -> str:
+        return self.document.artifact.revision
+
+    def projection_input(self) -> dict[str, Any]:
+        """Return stored intent only; callers must add derived envelopes."""
+
+        return {
+            "slug": self.slug,
+            "target": self.target,
+            "status": self.status,
+            "steward": self.steward_id,
+            "stewards": list(self.steward_ids),
+            "next_steps": list(self.next_steps),
+            "membership_seed": dict(self.membership_seed),
+            "composes_into": list(self.composes_into),
+            "domain": self.domain,
+            "planning_horizon": self.planning_horizon,
+            "next_move": self.next_move,
+            "reviewed_at": self.reviewed_at,
+            "facets": dict(self.facets),
+            "glossary": dict(self.glossary),
+            "canonical_revision": self.revision,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class ThreadFoldReceipt:
+    thread: ThreadSnapshot
+    event_id: str
+    receipts: tuple[WritebackEvent, ...]
+
+
+def parse_thread_markdown(markdown: str, *, slug: str, org_id: str) -> ThreadSnapshot:
+    normalized_slug = _slug(slug)
+    document = parse_canonical_markdown(
+        markdown,
+        canonical_path=f"threads/{normalized_slug}.md",
+        default_org_id=org_id,
+    )
+    if document.artifact.artifact_type != "thread":
+        raise ThreadError("canonical Thread record has the wrong artifact type")
+    fields = document.legacy_fields
+    declared_slug = _slug(str(fields.get("slug") or normalized_slug))
+    if declared_slug != normalized_slug:
+        raise ThreadError("thread slug does not match its canonical path")
+    status = document.artifact.status.casefold()
+    if status not in THREAD_STATUSES:
+        raise ThreadError(f"invalid thread status: {status}")
+    steward_id = str(fields.get("steward_id") or fields.get("steward") or "").strip()
+    if not steward_id:
+        raise ThreadError("thread requires a stable steward actor id")
+    if not _stable_actor_id(steward_id):
+        raise ThreadError(
+            "legacy steward alias is not fold authority; migrate it to a stable actor id"
+        )
+    raw_stewards = fields.get("steward_ids") or fields.get("stewards") or [steward_id]
+    if isinstance(raw_stewards, str):
+        raw_stewards = [raw_stewards]
+    if not isinstance(raw_stewards, Sequence):
+        raise ThreadError("thread stewards must be a list of actor ids")
+    steward_ids = tuple(dict.fromkeys([steward_id, *(str(item) for item in raw_stewards)]))
+    if not all(_stable_actor_id(value) for value in steward_ids):
+        raise ThreadError(
+            "legacy steward aliases are not fold authority; migrate them to stable actor ids"
+        )
+    raw_steps = fields.get("next_steps") or ()
+    if isinstance(raw_steps, str):
+        raw_steps = [raw_steps]
+    raw_composes = fields.get("composes_into") or ()
+    if isinstance(raw_composes, str):
+        raw_composes = [raw_composes]
+    target = str(fields.get("target") or "").strip()
+    if not target:
+        raise ThreadError("thread target is required")
+    return ThreadSnapshot(
+        slug=normalized_slug,
+        title=document.artifact.title,
+        target=target,
+        status=status,
+        steward_id=steward_id,
+        steward_ids=steward_ids,
+        next_steps=tuple(str(item) for item in raw_steps if str(item).strip()),
+        membership_seed=_as_mapping(fields.get("membership_seed"), field="membership_seed"),
+        composes_into=tuple(str(item) for item in raw_composes if str(item).strip()),
+        domain=str(fields["domain"]) if fields.get("domain") else None,
+        planning_horizon=str(fields["planning_horizon"]) if fields.get("planning_horizon") else None,
+        next_move=str(fields["next_move"]) if fields.get("next_move") else None,
+        reviewed_at=str(fields["reviewed_at"]) if fields.get("reviewed_at") else None,
+        facets=_as_mapping(fields.get("facets"), field="facets"),
+        glossary=_as_mapping(fields.get("glossary"), field="glossary"),
+        document=document,
+    )
+
+
+def _body(title: str, target: str, next_steps: Sequence[str]) -> str:
+    steps = "\n".join(f"- {item}" for item in next_steps) or "- Define the next deliberate move"
+    return f"# {title}\n\n## Target\n\n{target}\n\n## Next steps\n\n{steps}\n"
+
+
+def _replace_or_append_section(body: str, heading: str, content: str) -> str:
+    """Update one level-two section without discarding richer Thread prose."""
+
+    normalized = body.rstrip() + "\n"
+    pattern = re.compile(
+        rf"(?ms)^## {re.escape(heading)}\s*\n.*?(?=^## |\Z)"
+    )
+    replacement = f"## {heading}\n\n{content.rstrip()}\n\n"
+    if pattern.search(normalized):
+        return pattern.sub(replacement, normalized, count=1).rstrip() + "\n"
+    return normalized.rstrip() + f"\n\n{replacement}"
+
+
+def _fold_body(current: ThreadSnapshot, field: str, after: Any) -> str:
+    if field == "target":
+        return _replace_or_append_section(current.document.body, "Target", str(after))
+    if field == "next_steps":
+        steps = "\n".join(f"- {item}" for item in after)
+        return _replace_or_append_section(current.document.body, "Next steps", steps)
+    return current.document.body
+
+
+class CanonicalThreadService:
+    """Own Thread authorization, intent folds, event provenance, and reads."""
+
+    def __init__(
+        self,
+        runtime: EgregoreRuntime,
+        memory_root: Path,
+        *,
+        clock: Callable[[], datetime] | None = None,
+    ) -> None:
+        self.runtime = runtime
+        self.memory_root = memory_root.resolve()
+        self.clock = clock or (lambda: datetime.now(UTC))
+
+    @staticmethod
+    def canonical_path(slug: str) -> str:
+        return f"memory/threads/{_slug(slug)}.md"
+
+    def _path(self, slug: str) -> Path:
+        return self.memory_root / "threads" / f"{_slug(slug)}.md"
+
+    def _authorize(self, actor: ActorContext, permission: Permission, resource: str, path: str) -> None:
+        decision = self.runtime.authorize(actor, permission, (resource,))
+        if not decision.allowed:
+            raise AuthorizationDenied("; ".join(decision.reasons) or f"thread {permission.value} denied")
+        if not scope_allows_path(path, decision.scopes):
+            raise AuthorizationDenied("thread path is outside the actor's authorized scope")
+
+    def read(self, actor: ActorContext, slug: str) -> ThreadSnapshot:
+        normalized = _slug(slug)
+        path = self.canonical_path(normalized)
+        self._authorize(actor, Permission.READ, f"thread:{normalized}", path)
+        source = self._path(normalized)
+        if not source.is_file():
+            raise ThreadError(f"thread does not exist: {normalized}")
+        return parse_thread_markdown(
+            source.read_text(encoding="utf-8"), slug=normalized, org_id=actor.profile.org_id
+        )
+
+    def list(self, actor: ActorContext, *, include_archived: bool = False) -> tuple[ThreadSnapshot, ...]:
+        decision = self.runtime.authorize(actor, Permission.READ, ("threads",))
+        if not decision.allowed:
+            raise AuthorizationDenied("; ".join(decision.reasons) or "thread read denied")
+        directory = self.memory_root / "threads"
+        if not directory.is_dir():
+            return ()
+        rows = []
+        for path in sorted(directory.glob("*.md")):
+            if path.name.startswith("_"):
+                continue
+            canonical = f"memory/threads/{path.name}"
+            if not scope_allows_path(canonical, decision.scopes):
+                continue
+            row = parse_thread_markdown(
+                path.read_text(encoding="utf-8"), slug=path.stem, org_id=actor.profile.org_id
+            )
+            if include_archived or row.status != "archived":
+                rows.append(row)
+        return tuple(rows)
+
+    def create(
+        self,
+        actor: ActorContext,
+        *,
+        title: str,
+        target: str,
+        slug: str | None = None,
+        topics: Sequence[str] = (),
+        people: Sequence[str] = (),
+        next_steps: Sequence[str] = (),
+        window_days: int = 45,
+        review_after_days: int = 7,
+        attention_ttl_days: int = 30,
+        supersedes: Sequence[str] = (),
+    ) -> tuple[ThreadSnapshot, WritebackEvent]:
+        clean_title = " ".join(title.split()).strip()
+        clean_target = " ".join(target.split()).strip()
+        if not clean_title or not clean_target:
+            raise ThreadError("thread title and target are required")
+        if min(window_days, review_after_days, attention_ttl_days) < 1:
+            raise ThreadError("thread windows must be positive days")
+        normalized = _slug(slug or clean_title)
+        canonical = self.canonical_path(normalized)
+        self._authorize(actor, Permission.WRITE, f"thread:{normalized}", canonical)
+        if self._path(normalized).exists():
+            raise ThreadError(f"thread already exists: {normalized}")
+        now = self.clock().astimezone(UTC)
+        steps = _clean_strings(next_steps)
+        body = _body(clean_title, clean_target, steps)
+        digest = content_digest(body)
+        artifact = CanonicalArtifact(
+            schema_version=ARTIFACT_SCHEMA_VERSION,
+            artifact_id=f"thread:{normalized}",
+            org_id=actor.profile.org_id,
+            artifact_type="thread",
+            title=clean_title,
+            created_at=now,
+            created_by=actor.actor.actor_id,
+            status="active",
+            canonical_path=f"threads/{normalized}.md",
+            revision=f"sha256:{digest[:16]}",
+            content_hash=digest,
+            supersedes=tuple(dict.fromkeys(value for value in supersedes if value)),
+        )
+        document = CanonicalDocument(
+            artifact=artifact,
+            body=body,
+            policy_hints={"human_intent_only": True, "projection_state": "disposable"},
+            legacy_fields={
+                "thread_schema": THREAD_SCHEMA_VERSION,
+                "slug": normalized,
+                "target": clean_target,
+                "next_steps": list(steps),
+                "membership_seed": {
+                    "topics": list(_clean_strings(topics)),
+                    "people": list(_clean_strings(people)),
+                    "window_days": window_days,
+                },
+                "steward_id": actor.actor.actor_id,
+                "steward_ids": [actor.actor.actor_id],
+                "steward_alias": actor.actor.display_name,
+                "review_at": _iso(now + timedelta(days=review_after_days)),
+                "attention_expires_at": _iso(now + timedelta(days=attention_ttl_days)),
+                "reviewed_at": _iso(now),
+            },
+        )
+        receipt = self.runtime.write_document(actor, document)
+        return parse_thread_markdown(
+            self._path(normalized).read_text(encoding="utf-8") if self._path(normalized).is_file() else "",
+            slug=normalized,
+            org_id=actor.profile.org_id,
+        ) if receipt.status.value != "rejected" else ThreadSnapshot(
+            normalized, clean_title, clean_target, "active", actor.actor.actor_id,
+            (actor.actor.actor_id,), steps, document.legacy_fields["membership_seed"], (),
+            None, None, None, _iso(now), {}, {}, document,
+        ), receipt
+
+    def fold(
+        self,
+        actor: ActorContext,
+        *,
+        slug: str,
+        event_type: str,
+        field: str,
+        operation: str,
+        payload: Any,
+        source: str,
+        expected_revision: str,
+        confirmation: str,
+    ) -> ThreadFoldReceipt:
+        if confirmation != THREAD_CONFIRMATION:
+            raise ThreadError("thread fold requires the exact steward confirmation")
+        if event_type not in THREAD_EVENT_TYPES:
+            raise ThreadError("unsupported thread event type")
+        if field not in THREAD_FIELDS:
+            raise ThreadError("unsupported stored-intent field")
+        if operation not in {"replace", "append", "remove"}:
+            raise ThreadError("thread fold operation must be replace, append, or remove")
+        current = self.read(actor, slug)
+        self._authorize(actor, Permission.WRITE, f"thread:{current.slug}", self.canonical_path(current.slug))
+        if actor.actor.actor_id not in current.steward_ids:
+            admin = self.runtime.authorize(actor, Permission.ADMINISTER, (f"thread:{current.slug}",))
+            admin_role = bool(
+                actor.membership
+                and {role.casefold() for role in actor.membership.roles}
+                & {"admin", "administrator", "owner", "founder"}
+            )
+            if not admin.allowed or not admin_role:
+                raise AuthorizationDenied("only a stable steward actor id may confirm this fold")
+        if current.revision != expected_revision:
+            raise ThreadError("thread revision changed; re-open it before confirming the fold")
+        intent = current.projection_input()
+        before = intent.get(field)
+        if operation == "replace":
+            after = payload
+        elif operation == "append":
+            values = list(before or [])
+            if payload not in values:
+                values.append(payload)
+            after = values
+        else:
+            values = list(before or [])
+            after = [value for value in values if value != payload]
+        if field == "status" and str(after) not in THREAD_STATUSES:
+            raise ThreadError("invalid thread status transition")
+        if field == "planning_horizon" and after not in {None, "now", "next", "later"}:
+            raise ThreadError("planning horizon must be now, next, or later")
+        if field in {"steward", "stewards"}:
+            candidates = [str(after)] if field == "steward" else [str(item) for item in after]
+            if not all(_stable_actor_id(value) for value in candidates):
+                raise ThreadError("stewards must use stable actor ids, not display aliases")
+        now = self.clock().astimezone(UTC)
+        event_payload = {
+            "thread": current.document.artifact.artifact_id,
+            "thread_revision": current.revision,
+            "occurred_at": _iso(now),
+            "actor_id": actor.actor.actor_id,
+            "actor_alias": actor.actor.display_name,
+            "type": event_type,
+            "field": field,
+            "op": operation,
+            "before": before,
+            "payload": payload,
+            "after": after,
+            "source": source.strip(),
+            "confirmed": True,
+        }
+        encoded = json.dumps(event_payload, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
+        event_hash = hashlib.sha256(encoded.encode("utf-8")).hexdigest()
+        event_id = f"thread-event:{current.slug}:{event_hash[:20]}"
+        event_body = f"# Thread fold: {current.title}\n\n```json\n{encoded}\n```\n"
+        event_document = CanonicalDocument(
+            artifact=CanonicalArtifact(
+                schema_version=ARTIFACT_SCHEMA_VERSION,
+                artifact_id=event_id,
+                org_id=actor.profile.org_id,
+                artifact_type="lifecycle-event",
+                title=f"thread fold: {current.title}",
+                created_at=now,
+                created_by=actor.actor.actor_id,
+                status="accepted",
+                canonical_path=f"threads/.events/{current.slug}/{event_hash[:20]}.md",
+                revision=f"sha256:{content_digest(event_body)[:16]}",
+                content_hash=content_digest(event_body),
+                relationships=(ArtifactRelationship("transitions", current.document.artifact.artifact_id),),
+            ),
+            body=event_body,
+            legacy_fields={
+                "lifecycle_action": "thread-fold",
+                "target_artifact_id": current.document.artifact.artifact_id,
+                "target_path": f"memory/threads/{current.slug}.md",
+                "expected_lifecycle_revision": current.revision,
+                "domain_event_schema": THREAD_EVENT_SCHEMA_VERSION,
+                "domain_event": event_payload,
+            },
+        )
+        updates = dict(current.document.legacy_fields)
+        key = "steward_id" if field == "steward" else "steward_ids" if field == "stewards" else field
+        updates[key] = after
+        updates["last_event_id"] = event_id
+        updates["reviewed_at"] = _iso(now)
+        body = _fold_body(current, field, after)
+        digest = content_digest(body)
+        thread_document = CanonicalDocument(
+            artifact=replace(
+                current.document.artifact,
+                status=str(after) if field == "status" else current.status,
+                revision=f"sha256:{digest[:16]}-{event_hash[:8]}",
+                content_hash=digest,
+            ),
+            body=body,
+            policy_hints=current.document.policy_hints,
+            legacy_fields=updates,
+            migrated_from=current.document.migrated_from,
+            warnings=current.document.warnings,
+        )
+        receipts = self.runtime.write_documents(actor, (event_document, thread_document))
+        updated = replace(
+            current,
+            target=str(after) if field == "target" else current.target,
+            status=str(after) if field == "status" else current.status,
+            steward_id=str(after) if field == "steward" else current.steward_id,
+            steward_ids=tuple(str(item) for item in after) if field == "stewards" else current.steward_ids,
+            next_steps=tuple(str(item) for item in after) if field == "next_steps" else current.next_steps,
+            membership_seed=_as_mapping(after, field=field) if field == "membership_seed" else current.membership_seed,
+            composes_into=tuple(str(item) for item in after) if field == "composes_into" else current.composes_into,
+            domain=str(after) if field == "domain" and after is not None else current.domain,
+            planning_horizon=str(after) if field == "planning_horizon" and after is not None else current.planning_horizon,
+            next_move=str(after) if field == "next_move" and after is not None else current.next_move,
+            reviewed_at=str(updates["reviewed_at"]),
+            facets=_as_mapping(after, field=field) if field == "facets" else current.facets,
+            glossary=_as_mapping(after, field=field) if field == "glossary" else current.glossary,
+            document=thread_document,
+        )
+        return ThreadFoldReceipt(updated, event_id, receipts)