okstra 0.214.1 → 0.216.0

package/runtime/python/okstra_ctl/phases/discussion/store.py

@@ -0,0 +1,1143 @@
+"""task 단위 토론 기록 — append-only 입력 기록과 초안 읽기 모델.
+
+`<task-root>/discussion/` 아래:
+
+- `records.jsonl` — 입력 기록(시작 입력·확인된 대상과 질문·질문·답변·결정, 조사 주기·
+  워커 결과·실패·참여자 변경·주장·주기 종료·새 근거와 대안). 디렉터리 잠금 아래 다른
+  무엇보다 먼저 append 한다.
+- `draft.json` — 기록에서 다시 만든 읽기 모델. 만든 기록의 digest 를 실어, 기록보다
+  뒤처지거나 없으면 다음 읽기에서 다시 만든다.
+- `revisions/revision-NNN.json` — 사용자 완료 확인마다 한 번 쓰는 불변 확정본. 토론 결과의
+  정본이고, run 보고서는 확정본 id 와 내용 digest 만 참조한다.
+- `links.jsonl` — 후속 작업 연결과 확정본 적용 기록(`followup.py`). 후속 작업이 쓰는 확정본의
+  정본은 그 작업의 브리프이고, 이 목록은 대상 위치를 찾는 조회용이다.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterator, Optional
+
+from okstra_project.slug import slugify
+
+from okstra_ctl.json_boundary import (
+    JsonBoundaryError,
+    load_owned_object,
+    write_owned_object_atomic,
+)
+from okstra_ctl.paths import RunRef, task_dir
+from okstra_ctl.run_context import dir_flock
+
+SCHEMA_VERSION = "1.0"
+# 읽기 모델의 모양이 바뀌면 올린다 — 기록 digest 가 같아도 옛 모양의 draft 는 다시 만든다.
+DRAFT_SCHEMA_VERSION = "1.3"
+REVISION_SCHEMA_VERSION = "1.1"
+STORE_DIRNAME = "discussion"
+RECORDS_FILENAME = "records.jsonl"
+DRAFT_JSON_FILENAME = "draft.json"
+INPUT_FILENAME = "input.md"
+REVISIONS_DIRNAME = "revisions"
+LINKS_FILENAME = "links.jsonl"
+_LOCK_FILENAME = ".discussion.lock"
+
+USER = "user"
+LEADER = "leader"
+_ID_PREFIX = {
+    "start": "I",
+    "subject": "S",
+    "question": "Q",
+    "answer": "A",
+    "decision": "D",
+    "cycle": "R",
+    "result": "W",
+    "failure": "X",
+    "recovery": "P",
+    "claim": "K",
+    "close": "E",
+    "material": "M",
+    "requirement": "N",
+    "scope": "B",
+    "confirmation": "F",
+    "publication": "V",
+    "reopen": "O",
+    "withdrawal": "U",
+}
+# 중복 판정 키에 넣는 필드. 출처 run 은 빼서 재개한 run 의 재전송도 같은 기록으로 본다.
+# 조사 주기만 run 을 넣는다 — 교체 run 이 같은 입력으로 다시 연 주기는 새 주기다.
+_IDENTITY_FIELDS = {
+    "start": ("startKind", "text"),
+    "subject": ("subject", "question"),
+    "question": ("to", "text"),
+    "answer": ("questionId", "text"),
+    "decision": ("questionId", "text"),
+    "cycle": ("inputRefs", "sourceRun"),
+    "result": ("cycleId", "dispatch"),
+    "failure": ("cycleId", "questionId", "dispatch"),
+    "recovery": ("failureId", "choice"),
+    "claim": ("cycleId", "findingId"),
+    "close": ("cycleId",),
+    "material": ("materialKind", "text"),
+    "requirement": ("appliesTo", "text", "draftGeneration"),
+    "scope": ("scopeKind", "text", "draftGeneration"),
+    "confirmation": ("draftVersion", "direction", "riskAcknowledgement"),
+    "publication": ("confirmationId",),
+    "reopen": ("revisionId", "reason"),
+    "withdrawal": ("itemId", "reason", "draftGeneration"),
+}
+# 비어 있어도 되는 문자열 필드 — 질문에 묶이지 않은 결정, 주기 밖 직접 질문의 실패.
+_OPTIONAL_FIELDS = frozenset({"questionId", "cycleId"})
+# 다음 조사 입력의 참조 집합이 되는 기록 — 시작 입력·대상·답변·새 근거와 대안. 사용자 결정은
+# 방향 선택이라 넣지 않는다: 넣으면 방향을 고른 직후 같은 근거로 조사가 다시 열린다.
+# 주기의 산출물(결과·주장)은 넣지 않는다: 그것을 넣으면 같은 주장의 반복도 늘 새 입력이 된다.
+INPUT_REF_KINDS = ("start", "subject", "answer", "material")
+SCOPE_KINDS = ("in-scope", "excluded")
+ITEM_KINDS = ("requirement", "scope")
+COMMON = "common"
+# 확정본 발행 뒤에 받는 기록. 나머지는 재토론(`reopen`)이 새 초안을 연 뒤에만 받는다.
+_AFTER_COMPLETION_KINDS = frozenset({"reopen", "publication"})
+
+
+class DiscussionStoreError(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class SourceRun:
+    manifest: str
+    participants: frozenset[str]
+
+
+@dataclass(frozen=True)
+class DiscussionStore:
+    project_root: Path
+    task_key: str
+
+    @property
+    def task_root(self) -> Path:
+        _, task_group, task_id = _split_task_key(self.task_key)
+        return task_dir(self.project_root, task_group, task_id)
+
+    @property
+    def dir(self) -> Path:
+        return self.task_root / STORE_DIRNAME
+
+    @property
+    def records_path(self) -> Path:
+        return self.dir / RECORDS_FILENAME
+
+    @property
+    def draft_json_path(self) -> Path:
+        return self.dir / DRAFT_JSON_FILENAME
+
+    @property
+    def input_path(self) -> Path:
+        return self.dir / INPUT_FILENAME
+
+    @property
+    def revisions_dir(self) -> Path:
+        return self.dir / REVISIONS_DIRNAME
+
+    @property
+    def links_path(self) -> Path:
+        return self.dir / LINKS_FILENAME
+
+    def revision_path(self, sequence: int) -> Path:
+        return self.revisions_dir / f"revision-{sequence:03d}.json"
+
+
+def _split_task_key(task_key: str) -> tuple[str, str, str]:
+    parts = (task_key or "").split(":")
+    if len(parts) != 3 or not all(part.strip() for part in parts):
+        raise DiscussionStoreError(
+            f"invalid task key {task_key!r} (expected project-id:task-group:task-id)"
+        )
+    return parts[0], parts[1], parts[2]
+
+
+def same_task(left: str, right: str) -> bool:
+    """task-group·task-id 는 경로 세그먼트(slug)로 비교한다 — task 루트가 같으면 같은 task 다."""
+    try:
+        a = _split_task_key(left)
+        b = _split_task_key(right)
+    except DiscussionStoreError:
+        return False
+    return a[0] == b[0] and slugify(a[1]) == slugify(b[1]) and slugify(a[2]) == slugify(b[2])
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _project_relative(store: DiscussionStore, path: Path) -> str:
+    return path.resolve().relative_to(store.project_root.resolve()).as_posix()
+
+
+def resolve_source_run(store: DiscussionStore, manifest_path: str) -> SourceRun:
+    if not manifest_path.strip():
+        raise DiscussionStoreError("--run-manifest is required: name the discussion run manifest")
+    path = Path(manifest_path)
+    if not path.is_absolute():
+        path = store.project_root / path
+    manifests_dir = RunRef.from_task_root(store.task_root, "discussion").run_dir / "manifests"
+    try:
+        path.resolve().relative_to(manifests_dir.resolve())
+    except ValueError as exc:
+        raise DiscussionStoreError(
+            f"run manifest {manifest_path} is not a discussion run of {store.task_key}; "
+            f"records of another task are refused (expected under {manifests_dir})"
+        ) from exc
+    try:
+        manifest = load_owned_object(path, artifact="discussion run manifest")
+    except JsonBoundaryError as exc:
+        raise DiscussionStoreError(str(exc)) from exc
+    if not same_task(str(manifest.get("taskKey", "")), store.task_key):
+        raise DiscussionStoreError(
+            f"run manifest {manifest_path} belongs to {manifest.get('taskKey')!r}, "
+            f"not {store.task_key}; records of another task are refused"
+        )
+    if manifest.get("taskType") != "discussion":
+        raise DiscussionStoreError(
+            f"run manifest {manifest_path} is a {manifest.get('taskType')!r} run, not a discussion run"
+        )
+    workers = {
+        str(row["workerId"])
+        for row in manifest.get("workerAssignments") or []
+        if isinstance(row, dict) and row.get("workerId")
+    }
+    return SourceRun(
+        manifest=_project_relative(store, path),
+        participants=frozenset({LEADER, *workers}),
+    )
+
+
+def _complete_lines(raw: bytes) -> bytes:
+    """끝 개행이 없는 마지막 조각은 중단된 append 다 — 확정된 기록이 아니다."""
+    end = raw.rfind(b"\n")
+    return raw[: end + 1] if end >= 0 else b""
+
+
+def _read_records(store: DiscussionStore) -> tuple[list[dict[str, Any]], str]:
+    path = store.records_path
+    raw = path.read_bytes() if path.is_file() else b""
+    complete = _complete_lines(raw)
+    rows: list[dict[str, Any]] = []
+    for number, line in enumerate(complete.decode("utf-8").splitlines(), start=1):
+        if not line.strip():
+            continue
+        try:
+            row = json.loads(line)
+        except json.JSONDecodeError as exc:
+            raise DiscussionStoreError(
+                f"{path}:{number} is not a JSON record ({exc.msg}); the discussion record is damaged"
+            ) from exc
+        if not isinstance(row, dict) or row.get("kind") not in _ID_PREFIX:
+            raise DiscussionStoreError(f"{path}:{number} is not a discussion record")
+        if not same_task(str(row.get("taskKey", "")), store.task_key):
+            raise DiscussionStoreError(
+                f"{path}:{number} belongs to {row.get('taskKey')!r}, not {store.task_key}"
+            )
+        rows.append(row)
+    return rows, "sha256:" + hashlib.sha256(complete).hexdigest()
+
+
+def _drop_interrupted_tail(store: DiscussionStore) -> None:
+    drop_incomplete_line(store.records_path)
+
+
+def drop_incomplete_line(path: Path) -> None:
+    if not path.is_file():
+        return
+    raw = path.read_bytes()
+    complete = _complete_lines(raw)
+    if len(complete) != len(raw):
+        with path.open("r+b") as handle:
+            handle.truncate(len(complete))
+            handle.flush()
+            os.fsync(handle.fileno())
+
+
+def _identity_key(kind: str, author: str, fields: dict[str, Any]) -> str:
+    identity = {"kind": kind, "author": author}
+    identity.update({name: fields.get(name, "") for name in _IDENTITY_FIELDS[kind]})
+    encoded = json.dumps(identity, ensure_ascii=False, sort_keys=True).encode("utf-8")
+    return "sha256:" + hashlib.sha256(encoded).hexdigest()
+
+
+def _check_record(
+    kind: str, author: str, fields: dict[str, Any], rows: list[dict[str, Any]],
+    source_run: SourceRun,
+) -> None:
+    by_id = {row["recordId"]: row for row in rows}
+    completed = completed_publication(rows)
+    if completed is not None and kind not in _AFTER_COMPLETION_KINDS:
+        raise DiscussionStoreError(
+            f"the discussion is completed as {completed['revisionId']}; open a new draft with "
+            f"`okstra discussion reopen --revision {completed['revisionId']} --reason \"<why it changes>\"` "
+            "before recording more"
+        )
+    if kind == "reopen":
+        if completed is None or fields["revisionId"] != completed["revisionId"]:
+            current = completed["revisionId"] if completed else "none (the discussion is a draft)"
+            raise DiscussionStoreError(
+                f"reopen names {fields['revisionId']}, but the latest completed revision is {current}"
+            )
+        return
+    if kind == "withdrawal":
+        items = draft_items(rows)
+        withdrawn = next((row for row in items["withdrawn"] if row["recordId"] == fields["itemId"]), None)
+        if withdrawn is not None:
+            raise DiscussionStoreError(
+                f"{fields['itemId']} is already withdrawn from the current draft "
+                f"({withdrawn['withdrawal']['recordId']})"
+            )
+        if fields["itemId"] not in {row["recordId"] for row in items["effective"]}:
+            raise DiscussionStoreError(
+                f"{fields['itemId']} is not a requirement or scope item of the current draft"
+            )
+        return
+    if kind in ITEM_KINDS and author != USER and author not in source_run.participants:
+        raise DiscussionStoreError(
+            f"author {author!r} is neither the user nor a participant of {source_run.manifest}"
+        )
+    if kind == "scope" and fields["scopeKind"] not in SCOPE_KINDS:
+        raise DiscussionStoreError(f"--kind must be one of {', '.join(SCOPE_KINDS)}")
+    for name, expected in (("cycleId", "cycle"), ("failureId", "failure")):
+        ref = fields.get(name)
+        if ref and (by_id.get(ref) or {}).get("kind") != expected:
+            raise DiscussionStoreError(f"no {expected} {ref} in this discussion")
+    if kind == "recovery":
+        earlier = next(
+            (row for row in rows if row["kind"] == "recovery" and row["failureId"] == fields["failureId"]),
+            None,
+        )
+        if earlier is not None:
+            raise DiscussionStoreError(
+                f"{fields['failureId']} already has the user's choice {earlier['choice']!r} "
+                f"({earlier['recordId']}); a later failure gets its own choice"
+            )
+        return
+    if kind == "close":
+        earlier = next(
+            (row for row in rows if row["kind"] == "close" and row["cycleId"] == fields["cycleId"]),
+            None,
+        )
+        if earlier is not None:
+            raise DiscussionStoreError(
+                f"{fields['cycleId']} is already closed ({earlier['recordId']})"
+            )
+        return
+    if kind == "material" and author != USER and author not in source_run.participants:
+        raise DiscussionStoreError(
+            f"author {author!r} is neither the user nor a participant of {source_run.manifest}"
+        )
+    if kind == "question":
+        if author == USER:
+            if fields["to"] not in source_run.participants - {LEADER}:
+                raise DiscussionStoreError(
+                    f"{fields['to']!r} is not a participant of {source_run.manifest}; "
+                    f"address one of: {', '.join(sorted(source_run.participants - {LEADER}))}"
+                )
+        elif author not in source_run.participants:
+            raise DiscussionStoreError(
+                f"author {author!r} is not a participant of {source_run.manifest}"
+            )
+        return
+    if kind == "answer" and not fields.get("questionId"):
+        raise DiscussionStoreError("an answer names the question it answers (--question)")
+    if kind in ("answer", "decision") and fields.get("questionId"):
+        question = by_id.get(fields["questionId"])
+        if question is None or question["kind"] != "question":
+            raise DiscussionStoreError(f"no question {fields['questionId']} in this discussion")
+        if kind == "answer":
+            if author != question["to"]:
+                raise DiscussionStoreError(
+                    f"{fields['questionId']} is addressed to {question['to']}; "
+                    f"an answer by {author} is refused"
+                )
+            earlier = next(
+                (row for row in rows
+                 if row["kind"] == "answer" and row["questionId"] == fields["questionId"]),
+                None,
+            )
+            if earlier is not None:
+                raise DiscussionStoreError(
+                    f"{fields['questionId']} is already answered ({earlier['recordId']}); "
+                    "record a decision or ask a follow-up question instead"
+                )
+
+
+@dataclass
+class Transaction:
+    """잠금 하나 안에서 읽은 기록과, 그 위에 이어 쓰는 append."""
+
+    store: DiscussionStore
+    rows: list[dict[str, Any]] = field(default_factory=list)
+
+    def append(
+        self, kind: str, fields: dict[str, Any], *, author: str, source_run: SourceRun,
+    ) -> tuple[dict[str, Any], bool]:
+        if kind not in _ID_PREFIX:
+            raise DiscussionStoreError(f"unknown discussion record kind: {kind}")
+        for name, value in fields.items():
+            if isinstance(value, str) and name not in _OPTIONAL_FIELDS and not value.strip():
+                raise DiscussionStoreError(f"--{name} must not be empty")
+        # 재토론 초안은 같은 요구사항을 다시 적어도 새 기록이다 — 앞 확정본의 기록으로 합치지 않는다.
+        generation = next((row["recordId"] for row in reversed(self.rows) if row["kind"] == "reopen"), "")
+        key = _identity_key(
+            kind, author, {**fields, "sourceRun": source_run.manifest, "draftGeneration": generation},
+        )
+        existing = next((row for row in reversed(self.rows) if row.get("idempotencyKey") == key), None)
+        if kind in ITEM_KINDS:
+            # 철회한 항목을 다시 적으면 새 기록이다. 이월된 같은 항목은 그 기록을 그대로 돌려준다.
+            effective = draft_items(self.rows)["effective"]
+            if existing is not None and existing["recordId"] not in {row["recordId"] for row in effective}:
+                existing = None
+            existing = existing or next(
+                (row for row in effective
+                 if row["kind"] == kind and all(row.get(name) == fields.get(name) for name in fields)),
+                None,
+            )
+        if existing is not None:
+            return existing, False
+        _check_record(kind, author, fields, self.rows, source_run)
+        sequence = 1 + sum(1 for row in self.rows if row["kind"] == kind)
+        record = {
+            "schemaVersion": SCHEMA_VERSION,
+            "taskKey": self.store.task_key,
+            "recordId": f"{_ID_PREFIX[kind]}-{sequence:04d}",
+            "kind": kind,
+            "author": author,
+            **fields,
+            "sourceRun": source_run.manifest,
+            "idempotencyKey": key,
+            "recordedAt": _now_iso(),
+        }
+        line = json.dumps(record, ensure_ascii=False, separators=(",", ":")) + "\n"
+        with self.store.records_path.open("ab") as handle:
+            handle.write(line.encode("utf-8"))
+            handle.flush()
+            os.fsync(handle.fileno())
+        self.rows.append(record)
+        return record, True
+
+    def draft(self) -> dict[str, Any]:
+        _, digest = _read_records(self.store)
+        return _project(self.rows, self.store.task_key, digest)
+
+
+@contextmanager
+def transaction(store: DiscussionStore) -> Iterator[Transaction]:
+    """여러 기록을 한 판정으로 쓸 때 — 판정에 쓴 기록과 append 사이에 다른 쓰기가 끼지 않는다."""
+    with dir_flock(store.dir, _LOCK_FILENAME):
+        _drop_interrupted_tail(store)
+        rows, _ = _read_records(store)
+        txn = Transaction(store, rows)
+        try:
+            yield txn
+        finally:
+            _rebuild_locked(store)
+
+
+def append_record(
+    store: DiscussionStore,
+    kind: str,
+    fields: dict[str, Any],
+    *,
+    author: str,
+    source_run: SourceRun,
+) -> tuple[dict[str, Any], bool]:
+    with transaction(store) as txn:
+        return txn.append(kind, fields, author=author, source_run=source_run)
+
+
+_SUPPORTED = ("full-consensus", "partial-consensus")
+_DISPUTED = ("contested", "worker-unique")
+
+
+def _claim_standing(classification: Any) -> str:
+    if classification in _SUPPORTED:
+        return "supported"
+    if classification in _DISPUTED:
+        return "disputed"
+    return "unverified"
+
+
+def _of(rows: list[dict[str, Any]], kind: str) -> list[dict[str, Any]]:
+    return [row for row in rows if row["kind"] == kind]
+
+
+def _cycles(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    recoveries = {row["failureId"]: row for row in _of(rows, "recovery")}
+    closes = {row["cycleId"]: row for row in _of(rows, "close")}
+    cycles = []
+    for row in _of(rows, "cycle"):
+        cycle_id = row["recordId"]
+        failures = [
+            {**failure, "recovery": recoveries.get(failure["recordId"])}
+            for failure in _of(rows, "failure") if failure["cycleId"] == cycle_id
+        ]
+        replaced = any((f["recovery"] or {}).get("choice") == "replace" for f in failures)
+        cycles.append({
+            **row,
+            "status": "closed" if cycle_id in closes else "superseded" if replaced else "open",
+            "close": closes.get(cycle_id),
+            "results": [r for r in _of(rows, "result") if r["cycleId"] == cycle_id],
+            "failures": failures,
+            "claims": [
+                {**claim, "standing": _claim_standing(claim["classification"])}
+                for claim in _of(rows, "claim") if claim["cycleId"] == cycle_id
+            ],
+        })
+    return cycles
+
+
+def completed_publication(rows: list[dict[str, Any]]) -> Optional[dict[str, Any]]:
+    """재토론이 열리지 않은 마지막 확정본 발행 기록 — 없으면 토론은 초안이다."""
+    for row in reversed(rows):
+        if row["kind"] == "reopen":
+            return None
+        if row["kind"] == "publication":
+            return row
+    return None
+
+
+def draft_items(rows: list[dict[str, Any]]) -> dict[str, list[dict[str, Any]]]:
+    """현재 초안의 요구사항·범위 — 재토론이 연 확정본의 유효 항목을 이월하고, 이 초안의 철회와 추가를 접는다.
+
+    이월 항목은 원 기록 그대로(id·작성자·run)이고 `carriedFrom` 에 그 확정본 id 를 단다. 확정본도 같은
+    기록에서 만들어지므로 파일을 읽지 않고 기록만으로 같은 집합이 나온다.
+    """
+    effective: dict[str, dict[str, Any]] = {}
+    withdrawn: list[dict[str, Any]] = []
+    for row in rows:
+        if row["kind"] == "reopen":
+            effective = {key: {**item, "carriedFrom": row["revisionId"]} for key, item in effective.items()}
+            withdrawn = []
+        elif row["kind"] in ITEM_KINDS:
+            effective[row["recordId"]] = {**row, "carriedFrom": None}
+        elif row["kind"] == "withdrawal" and row["itemId"] in effective:
+            withdrawn.append({**effective.pop(row["itemId"]), "withdrawal": _ref(row, "reason")})
+    return {"effective": list(effective.values()), "withdrawn": withdrawn}
+
+
+def _phase(draft: dict[str, Any]) -> str:
+    """토론이 지금 기다리는 것. `completed` 는 사용자 완료 확인으로 발행한 확정본에서만 나온다."""
+    cycles = draft["cycles"]
+    last = cycles[-1] if cycles else None
+    closed = [cycle for cycle in cycles if cycle["status"] == "closed"]
+    if draft["completedRevision"] is not None:
+        return "completed"
+    if draft["subject"] is None:
+        return "framing"
+    if draft["unrecoveredFailures"]:
+        return "awaiting-recovery"
+    if last is not None and last["status"] == "open":
+        return "researching"
+    if last is not None and last["status"] == "superseded":
+        return "awaiting-new-run"
+    if draft["pendingForUser"]:
+        return "awaiting-user"
+    if draft["pendingForParticipants"]:
+        return "awaiting-participant"
+    if not closed or closed[-1]["inputRefs"] != draft["inputRefs"]:
+        return "ready-for-research"
+    return "awaiting-choice"
+
+
+def _dropped_questions(rows: list[dict[str, Any]]) -> set[str]:
+    """참여자가 답하지 못했고 사용자가 그 답 없이 계속하기로 한 질문."""
+    reduced = {row["failureId"] for row in _of(rows, "recovery") if row["choice"] == "reduce"}
+    return {
+        row["questionId"] for row in _of(rows, "failure")
+        if row.get("questionId") and row["recordId"] in reduced
+    }
+
+
+def _project(rows: list[dict[str, Any]], task_key: str, digest: str) -> dict[str, Any]:
+    dropped = _dropped_questions(rows)
+    questions = [
+        {
+            **row,
+            "answers": [a for a in rows if a["kind"] == "answer" and a["questionId"] == row["recordId"]],
+            "dropped": row["recordId"] in dropped,
+        }
+        for row in rows if row["kind"] == "question"
+    ]
+    subjects = _of(rows, "subject")
+    recovered = {row["failureId"] for row in _of(rows, "recovery")}
+    cycles = _cycles(rows)
+    closed = [cycle for cycle in cycles if cycle["status"] == "closed"]
+    pending_for_user = [q["recordId"] for q in questions if q["to"] == USER and not q["answers"]]
+    draft = {
+        "schemaVersion": DRAFT_SCHEMA_VERSION,
+        "taskKey": task_key,
+        "recordCount": len(rows),
+        "recordsDigest": digest,
+        "startInputs": _of(rows, "start"),
+        "subject": subjects[-1] if subjects else None,
+        "decisions": _of(rows, "decision"),
+        "questions": questions,
+        "pendingForUser": pending_for_user,
+        "nextForUser": pending_for_user[0] if pending_for_user else None,
+        "pendingForParticipants": [
+            q["recordId"] for q in questions if q["to"] != USER and not q["answers"] and not q["dropped"]
+        ],
+        "materials": _of(rows, "material"),
+        "cycles": cycles,
+        "failures": [
+            {**row, "recovery": next((r for r in _of(rows, "recovery") if r["failureId"] == row["recordId"]), None)}
+            for row in _of(rows, "failure")
+        ],
+        "unrecoveredFailures": [
+            row["recordId"] for row in _of(rows, "failure") if row["recordId"] not in recovered
+        ],
+        "remainingDisagreements": [
+            claim["recordId"] for claim in (closed[-1]["claims"] if closed else [])
+            if claim["standing"] != "supported"
+        ],
+        "inputRefs": [row["recordId"] for row in rows if row["kind"] in INPUT_REF_KINDS],
+    }
+    items = draft_items(rows)
+    reopens = _of(rows, "reopen")
+    completed = completed_publication(rows)
+    draft.update({
+        "requirements": _of(items["effective"], "requirement"),
+        "scope": _of(items["effective"], "scope"),
+        "withdrawn": items["withdrawn"],
+        "confirmations": _of(rows, "confirmation"),
+        "revisions": [
+            {key: row[key] for key in ("recordId", "revisionId", "sequence", "revisionPath",
+                                       "contentDigest", "confirmationId", "sourceRun")}
+            for row in _of(rows, "publication")
+        ],
+        "completedRevision": completed["revisionId"] if completed else None,
+        "basedOn": reopens[-1] if reopens and completed is None else None,
+    })
+    draft["phase"] = _phase(draft)
+    return draft
+
+
+def _rebuild_locked(store: DiscussionStore) -> dict[str, Any]:
+    rows, digest = _read_records(store)
+    draft = _project(rows, store.task_key, digest)
+    write_owned_object_atomic(store.draft_json_path, draft, artifact="discussion draft")
+    return draft
+
+
+def completed_revision(store: DiscussionStore) -> Optional[str]:
+    """쓰지 않고 읽기만 한다 — prepare 가 어떤 쓰기보다 먼저 부른다."""
+    rows, _ = _read_records(store)
+    publication = completed_publication(rows)
+    return publication["revisionId"] if publication else None
+
+
+def has_records(store: DiscussionStore) -> bool:
+    return store.records_path.is_file() and bool(_complete_lines(store.records_path.read_bytes()).strip())
+
+
+def read_draft(store: DiscussionStore) -> dict[str, Any]:
+    _, digest = _read_records(store)
+    current = _load_draft(store)
+    if (
+        current is not None
+        and current.get("recordsDigest") == digest
+        and current.get("schemaVersion") == DRAFT_SCHEMA_VERSION
+    ):
+        return current
+    with dir_flock(store.dir, _LOCK_FILENAME):
+        _drop_interrupted_tail(store)
+        return _rebuild_locked(store)
+
+
+def project_draft(store: DiscussionStore) -> dict[str, Any]:
+    """기록에서 읽기 모델을 만들기만 한다 — 다른 프로젝트를 읽는 조회(관리자·후속 연결)는 그 프로젝트에 쓰지 않는다."""
+    rows, digest = _read_records(store)
+    return _project(rows, store.task_key, digest)
+
+
+def _load_draft(store: DiscussionStore) -> Optional[dict[str, Any]]:
+    if not store.draft_json_path.is_file():
+        return None
+    try:
+        return load_owned_object(store.draft_json_path, artifact="discussion draft")
+    except JsonBoundaryError:
+        # expected-miss: 깨진 읽기 모델은 기록에서 다시 만든다.
+        return None
+
+
+_REVISION_SEPARATOR = "/revision-"
+
+
+def revision_id(task_key: str, sequence: int) -> str:
+    """확정본 id — 토론 task key 와 완료 순번. run 순번과 무관하다."""
+    return f"{task_key}{_REVISION_SEPARATOR}{sequence:03d}"
+
+
+def parse_revision_id(value: str) -> tuple[str, int]:
+    task_key, separator, number = (value or "").rpartition(_REVISION_SEPARATOR)
+    if not separator or not number.isdigit() or int(number) < 1:
+        raise DiscussionStoreError(
+            f"invalid revision id {value!r} (expected <task-key>{_REVISION_SEPARATOR}NNN)"
+        )
+    _split_task_key(task_key)
+    return task_key, int(number)
+
+
+def _digest_bytes(data: bytes) -> str:
+    return "sha256:" + hashlib.sha256(data).hexdigest()
+
+
+def _ref(row: dict[str, Any], *names: str) -> dict[str, Any]:
+    return {
+        "recordId": row["recordId"], "author": row["author"], "sourceRun": row["sourceRun"],
+        **{name: row.get(name) for name in names},
+    }
+
+
+def _claim_view(claim: dict[str, Any]) -> dict[str, Any]:
+    return {
+        **_ref(claim, "cycleId", "findingId", "summary", "classification", "standing", "evidence",
+               "discoveredBy"),
+        "verdicts": claim["verdicts"],
+    }
+
+
+def _unverified(draft: dict[str, Any], claims: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = [
+        {"recordId": claim["recordId"], "kind": "claim", "detail": claim["summary"]}
+        for claim in claims if claim["standing"] == "unverified"
+    ]
+    rows += [
+        {"recordId": failure["recordId"], "kind": "reduced-participant",
+         "detail": f"{failure['author']} failed ({failure['reason']}); the user continued without it"}
+        for failure in draft["failures"] if (failure["recovery"] or {}).get("choice") == "reduce"
+    ]
+    rows += [
+        {"recordId": cycle["recordId"], "kind": "cycle-not-cross-checked",
+         "detail": "fewer than two participants returned research, so its claims were not cross-checked"}
+        for cycle in draft["cycles"] if (cycle["close"] or {}).get("stopReason") == "auto-disabled"
+    ]
+    rows += [
+        {"recordId": question["recordId"], "kind": "dropped-question", "detail": question["text"]}
+        for question in draft["questions"] if question["dropped"]
+    ]
+    return rows
+
+
+def _build_revision(
+    store: DiscussionStore, rows: list[dict[str, Any]], confirmation: dict[str, Any], sequence: int,
+) -> dict[str, Any]:
+    """확인 기록까지의 기록에서만 만든다 — 같은 기록이면 언제 다시 만들어도 같은 바이트다."""
+    upto = rows[: next(i for i, row in enumerate(rows) if row["recordId"] == confirmation["recordId"]) + 1]
+    draft = _project(upto, store.task_key, confirmation["draftVersion"])
+    claims = [claim for cycle in draft["cycles"] for claim in cycle["claims"]]
+    disputed = set(draft["remainingDisagreements"])
+    previous = None
+    if draft["basedOn"] is not None:
+        reopen = draft["basedOn"]
+        earlier = next(row for row in _of(upto, "publication") if row["revisionId"] == reopen["revisionId"])
+        previous = {
+            "revisionId": reopen["revisionId"],
+            "contentDigest": earlier["contentDigest"],
+            "reopenRecord": reopen["recordId"],
+            "changeReason": reopen["reason"],
+        }
+    failures = draft["failures"]
+    return {
+        "schemaVersion": REVISION_SCHEMA_VERSION,
+        "revisionId": revision_id(store.task_key, sequence),
+        "sequence": sequence,
+        "taskKey": store.task_key,
+        "previousRevision": previous,
+        "confirmation": {
+            **_ref(confirmation, "draftVersion", "direction", "riskAcknowledgement"),
+            "confirmedAt": confirmation["recordedAt"],
+        },
+        "subject": _ref(draft["subject"], "subject", "question"),
+        "startInputs": [_ref(row, "startKind", "text") for row in draft["startInputs"]],
+        "materials": [_ref(row, "materialKind", "text") for row in draft["materials"]],
+        "direction": confirmation["direction"],
+        "requirements": [_ref(row, "appliesTo", "text", "carriedFrom") for row in draft["requirements"]],
+        "scope": {
+            "inScope": [_ref(row, "text", "carriedFrom") for row in draft["scope"] if row["scopeKind"] == "in-scope"],
+            "excluded": [_ref(row, "text", "carriedFrom") for row in draft["scope"] if row["scopeKind"] == "excluded"],
+        },
+        "itemChanges": _item_changes(draft),
+        "decisions": [_ref(row, "questionId", "text") for row in draft["decisions"]],
+        "answeredQuestions": [
+            {**_ref(question, "to", "text"), "answers": [_ref(answer, "text") for answer in question["answers"]]}
+            for question in draft["questions"] if question["answers"]
+        ],
+        "disagreements": [_claim_view(claim) for claim in claims if claim["recordId"] in disputed],
+        "evidence": [_claim_view(claim) for claim in claims],
+        "unverified": _unverified(draft, claims),
+        "participants": {
+            "cycles": [
+                {"cycleId": cycle["recordId"], "run": cycle["sourceRun"], "status": cycle["status"],
+                 "roster": cycle["roster"],
+                 "results": [_ref(row, "resultPath") for row in cycle["results"]]}
+                for cycle in draft["cycles"]
+            ],
+            "failures": [
+                {**_ref(row, "cycleId", "questionId", "stage", "attempts", "reason"),
+                 "recovery": _ref(row["recovery"], "choice") if row["recovery"] else None}
+                for row in failures
+            ],
+            "reducedRoster": any((row["recovery"] or {}).get("choice") == "reduce" for row in failures),
+        },
+    }
+
+
+def _item_view(row: dict[str, Any]) -> dict[str, Any]:
+    detail = "appliesTo" if row["kind"] == "requirement" else "scopeKind"
+    return {"recordId": row["recordId"], "kind": row["kind"], detail: row[detail], "text": row["text"]}
+
+
+def _item_changes(draft: dict[str, Any]) -> dict[str, Any]:
+    """이전 확정본에서 무엇을 이월·철회·추가했는가 — 첫 확정본은 이월이 없다."""
+    items = [*draft["requirements"], *draft["scope"]]
+    return {
+        "carriedFrom": draft["basedOn"]["revisionId"] if draft["basedOn"] else None,
+        "carried": [_item_view(row) for row in items if row["carriedFrom"]],
+        "added": [_item_view(row) for row in items if not row["carriedFrom"]],
+        "withdrawn": [
+            {**_item_view(row), "carriedFrom": row["carriedFrom"], "withdrawal": row["withdrawal"]}
+            for row in draft["withdrawn"]
+        ],
+    }
+
+
+def _revision_bytes(revision: dict[str, Any]) -> bytes:
+    return (json.dumps(revision, ensure_ascii=False, indent=2) + "\n").encode("utf-8")
+
+
+def _write_revision(path: Path, data: bytes) -> None:
+    """한 번만 쓴다 — 임시 파일을 끝까지 쓴 뒤 link 로 붙여, 중단돼도 반쪽 확정본이 남지 않는다."""
+    if path.exists():
+        if path.read_bytes() != data:
+            raise DiscussionStoreError(
+                f"{path} already holds different content; a published revision is never rewritten"
+            )
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temp = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+    try:
+        with temp.open("wb") as handle:
+            handle.write(data)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.chmod(temp, 0o444)
+        os.link(temp, path)
+    finally:
+        temp.unlink(missing_ok=True)
+
+
+def _publish_locked(txn: "Transaction", confirmation: dict[str, Any], source_run: SourceRun) -> dict[str, Any]:
+    from .validation import revision_errors
+
+    existing = next(
+        (row for row in _of(txn.rows, "publication") if row["confirmationId"] == confirmation["recordId"]),
+        None,
+    )
+    if existing is not None:
+        return existing
+    sequence = 1 + len(_of(txn.rows, "publication"))
+    revision = _build_revision(txn.store, txn.rows, confirmation, sequence)
+    errors = revision_errors(revision)
+    if errors:
+        raise DiscussionStoreError("the revision is incomplete: " + "; ".join(errors))
+    data = _revision_bytes(revision)
+    path = txn.store.revision_path(sequence)
+    _write_revision(path, data)
+    record, _ = txn.append(
+        "publication",
+        {
+            "confirmationId": confirmation["recordId"],
+            "revisionId": revision["revisionId"],
+            "sequence": sequence,
+            "revisionPath": _project_relative(txn.store, path),
+            "contentDigest": _digest_bytes(data),
+        },
+        author=LEADER,
+        source_run=source_run,
+    )
+    return record
+
+
+def confirm_completion(
+    store: DiscussionStore,
+    *,
+    draft_version: str,
+    direction: str,
+    risk_acknowledgement: str,
+    source_run: SourceRun,
+) -> tuple[dict[str, Any], bool]:
+    """사용자 완료 확인을 그 초안 버전에 묶어 기록하고 확정본을 발행한다.
+
+    같은 확인의 재전송은 이미 발행한 확정본을 돌려준다. 확인 뒤 기록이 하나라도 늘었으면
+    그 확인은 낡은 초안의 것이라 발행하지 않는다.
+    """
+    from .validation import completion_errors
+
+    fields = {"draftVersion": draft_version, "direction": direction,
+              "riskAcknowledgement": risk_acknowledgement}
+    with transaction(store) as txn:
+        key = _identity_key("confirmation", USER, fields)
+        earlier = next((row for row in txn.rows if row.get("idempotencyKey") == key), None)
+        if earlier is not None:
+            publication = next(
+                (row for row in _of(txn.rows, "publication") if row["confirmationId"] == earlier["recordId"]),
+                None,
+            )
+            if publication is not None:
+                return publication, False
+            later = [row["recordId"] for row in txn.rows[txn.rows.index(earlier) + 1:]]
+            if later:
+                raise DiscussionStoreError(
+                    f"{earlier['recordId']} confirmed draft version {draft_version}, but "
+                    f"{', '.join(later)} arrived after it; show the user the current draft and confirm again"
+                )
+            return _publish_locked(txn, earlier, source_run), True
+        _, current = _read_records(store)
+        if draft_version != current:
+            raise DiscussionStoreError(
+                f"the confirmation names draft version {draft_version}, but the current draft is "
+                f"{current}; show the user the current draft (`okstra discussion draft`) and confirm again"
+            )
+        draft = txn.draft()
+        if draft["completedRevision"] is not None:
+            raise DiscussionStoreError(
+                f"the discussion is already completed as {draft['completedRevision']}; "
+                "reopen it to confirm a new revision"
+            )
+        errors = completion_errors(draft, direction, risk_acknowledgement)
+        if errors:
+            raise DiscussionStoreError("the draft cannot be completed yet: " + "; ".join(errors))
+        confirmation, _ = txn.append("confirmation", fields, author=USER, source_run=source_run)
+        return _publish_locked(txn, confirmation, source_run), True
+
+
+def read_revision(store: DiscussionStore, value: str) -> tuple[dict[str, Any], bytes]:
+    """발행 기록과 파일 바이트가 맞는 확정본만 돌려준다."""
+    task_key, sequence = parse_revision_id(value)
+    if not same_task(task_key, store.task_key):
+        raise DiscussionStoreError(f"{value} is a revision of {task_key}, not of {store.task_key}")
+    rows, _ = _read_records(store)
+    publication = next((row for row in _of(rows, "publication") if row["sequence"] == sequence), None)
+    if publication is None:
+        raise DiscussionStoreError(f"no revision {value} is published in this discussion")
+    path = store.revision_path(sequence)
+    if not path.is_file():
+        raise DiscussionStoreError(f"{publication['revisionPath']} of {value} is missing")
+    data = path.read_bytes()
+    if _digest_bytes(data) != publication["contentDigest"]:
+        raise DiscussionStoreError(
+            f"{publication['revisionPath']} no longer matches the published digest {publication['contentDigest']}"
+        )
+    return publication, data
+
+
+def _attribution(row: dict[str, Any]) -> str:
+    return f"{row['recordId']} · {row['author']} · run `{row['sourceRun']}`"
+
+
+def render_draft_text(draft: dict[str, Any]) -> str:
+    lines = [
+        "# Discussion record",
+        "",
+        f"- Task: `{draft['taskKey']}`",
+        f"- Records: {draft['recordCount']} (`{draft['recordsDigest']}`)",
+        f"- Phase: {draft['phase']}",
+        f"- Draft version: `{draft['recordsDigest']}`",
+        "",
+        "## Confirmed subject and question",
+        "",
+    ]
+    subject = draft["subject"]
+    if subject is None:
+        lines.append("- Not confirmed yet. Confirm the subject and the question with the user first.")
+    else:
+        lines += [
+            f"- Subject: {subject['subject']}",
+            f"- Question: {subject['question']}",
+            f"- Confirmed: {_attribution(subject)}",
+        ]
+    lines += ["", "## Start inputs", ""]
+    lines += [
+        f"- [{row['startKind']}] {row['text']} ({_attribution(row)})"
+        for row in draft["startInputs"]
+    ] or ["- None."]
+    lines += ["", "## User decisions", ""]
+    lines += [
+        f"- {row['text']}"
+        + (f" (on {row['questionId']})" if row.get("questionId") else "")
+        + f" ({_attribution(row)})"
+        for row in draft["decisions"]
+    ] or ["- None."]
+    by_id = {q["recordId"]: q for q in draft["questions"]}
+    lines += ["", "## Questions waiting for the user", ""]
+    lines += [
+        f"- {qid} from {by_id[qid]['author']}: {by_id[qid]['text']}"
+        for qid in draft["pendingForUser"]
+    ] or ["- None."]
+    if draft["nextForUser"]:
+        lines.append(f"- Ask {draft['nextForUser']} next; put one question to the user at a time.")
+    lines += ["", "## Questions waiting for a participant", ""]
+    lines += [
+        f"- {qid} to {by_id[qid]['to']}: {by_id[qid]['text']}"
+        for qid in draft["pendingForParticipants"]
+    ] or ["- None."]
+    lines += [
+        f"- {q['recordId']} to {q['to']}: not answered — the participant failed and the user "
+        f"continued without the answer: {q['text']}"
+        for q in draft["questions"] if q["dropped"]
+    ]
+    lines += ["", "## Answered questions", ""]
+    answered = [q for q in draft["questions"] if q["answers"]]
+    if not answered:
+        lines.append("- None.")
+    for question in answered:
+        lines.append(f"### {question['recordId']} — {question['author']} to {question['to']}")
+        lines += ["", question["text"], ""]
+        for answer in question["answers"]:
+            lines += [f"Answer ({_attribution(answer)}):", "", answer["text"], ""]
+    lines += ["", "## New evidence and alternatives", ""]
+    lines += [
+        f"- [{row['materialKind']}] {row['text']} ({_attribution(row)})"
+        for row in draft["materials"]
+    ] or ["- None."]
+    lines += _render_cycles(draft)
+    lines += _render_claims(draft)
+    lines += _render_completion(draft)
+    return "\n".join(lines).rstrip("\n") + "\n"
+
+
+def _render_completion(draft: dict[str, Any]) -> list[str]:
+    lines = ["", "## Requirements of this draft", ""]
+    lines += [
+        f"- [{row['appliesTo']}] {row['text']} ({_attribution(row)}{_carried(row)})" for row in draft["requirements"]
+    ] or ["- None yet."]
+    lines += ["", "## Scope of this draft", ""]
+    lines += [
+        f"- [{row['scopeKind']}] {row['text']} ({_attribution(row)}{_carried(row)})" for row in draft["scope"]
+    ] or ["- None yet."]
+    if draft["withdrawn"]:
+        lines += ["", "## Withdrawn from this draft", ""]
+        lines += [
+            f"- {row['recordId']} [{row.get('appliesTo') or row.get('scopeKind')}] {row['text']} — withdrawn by "
+            f"{row['withdrawal']['author']} in {row['withdrawal']['recordId']}: {row['withdrawal']['reason']}"
+            for row in draft["withdrawn"]
+        ]
+    if draft["basedOn"]:
+        lines += [
+            "",
+            "Items carried from the reopened revision stay in this draft until "
+            "`okstra discussion withdraw --item <id> --reason \"<why>\"` removes them; "
+            "replace an item by withdrawing it and adding the new one.",
+        ]
+    lines += ["", "## Revisions", ""]
+    lines += [
+        f"- {row['revisionId']} (`{row['contentDigest']}`) confirmed by the user in {row['confirmationId']}"
+        for row in draft["revisions"]
+    ] or ["- None. The discussion completes only when the user confirms completion."]
+    if draft["completedRevision"]:
+        lines.append(f"- Completed as {draft['completedRevision']}; reopen it to change the outcome.")
+    if draft["basedOn"]:
+        lines.append(
+            f"- This draft reopens {draft['basedOn']['revisionId']} ({_attribution(draft['basedOn'])}): "
+            f"{draft['basedOn']['reason']}"
+        )
+    return lines
+
+
+def _carried(row: dict[str, Any]) -> str:
+    return f" · carried from {row['carriedFrom']}" if row.get("carriedFrom") else ""
+
+
+def _render_cycles(draft: dict[str, Any]) -> list[str]:
+    lines = ["", "## Research cycles", ""]
+    if not draft["cycles"]:
+        return lines + ["- None yet."]
+    for cycle in draft["cycles"]:
+        roster = ", ".join(f"{row['worker']} ({row['model']})" for row in cycle["roster"]) or "none"
+        lines += [
+            f"### {cycle['recordId']} — {cycle['status']} (run `{cycle['sourceRun']}`)",
+            "",
+            f"- Participants: {roster}",
+            f"- Input references: {', '.join(cycle['inputRefs']) or 'none'}",
+        ]
+        close = cycle["close"]
+        if close is not None:
+            lines.append(
+                f"- Verification cycle ended: convergence `{close['finalState']}` "
+                f"({close['stopReason']}) recorded in {close['recordId']}"
+            )
+            if close["stopReason"] == "auto-disabled":
+                lines.append(
+                    "- The claims of this cycle were not cross-checked: fewer than two "
+                    "participants returned research"
+                )
+        lines += [f"- Result {_attribution(row)}: `{row['resultPath']}`" for row in cycle["results"]]
+        for failure in cycle["failures"]:
+            recovery = failure["recovery"]
+            choice = (
+                f"user's choice: {recovery['choice']} ({recovery['recordId']})"
+                if recovery else "waiting for the user's choice"
+            )
+            lines.append(
+                f"- Failure {_attribution(failure)}: {failure['stage']} after "
+                f"{failure['attempts']} attempt(s) — {failure['reason']}; {choice}"
+            )
+        lines.append("")
+    return lines
+
+
+def _render_claims(draft: dict[str, Any]) -> list[str]:
+    lines = [
+        "",
+        "## Evidence claims",
+        "",
+        "Fact checks of claims about the code or external sources. They never settle the "
+        "user's intent: the user decisions above stand until the user changes them.",
+        "",
+    ]
+    claims = [claim for cycle in draft["cycles"] for claim in cycle["claims"]]
+    if not claims:
+        return lines + ["- None yet."]
+    for claim in claims:
+        lines += [
+            f"### {claim['recordId']} — {claim['standing']} ({claim['classification']}), "
+            f"{claim['findingId']} of {claim['cycleId']}",
+            "",
+            claim["summary"],
+            "",
+            f"- Claimed by: {', '.join(claim['discoveredBy'])} (origin {claim['author']}); "
+            f"evidence: {claim['evidence']}",
+        ]
+        lines += [
+            f"- Round {vote['round']} · {vote['worker']}: {vote['verdict']}"
+            + (f" ({vote['disagreeBasis']})" if vote.get("disagreeBasis") else "")
+            + f" — {vote['explanation']}"
+            for vote in claim["verdicts"]
+        ] or ["- No independent participant checked this claim."]
+        lines.append("")
+    return lines
+
+
+def render_full_record(store: DiscussionStore) -> str:
+    """토론 기록 전문 — 초안 읽기 모델에 각 참여자의 조사 결과 본문을 붙인다."""
+    draft = read_draft(store)
+    lines = [render_draft_text(draft).rstrip("\n"), "", "## Research result texts", ""]
+    results = [(cycle, row) for cycle in draft["cycles"] for row in cycle["results"]]
+    if not results:
+        lines.append("- None yet.")
+    for cycle, row in results:
+        path = store.project_root / row["resultPath"]
+        body = path.read_text(encoding="utf-8") if path.is_file() else f"(missing: `{row['resultPath']}`)\n"
+        lines += [f"### {row['recordId']} — {row['author']} in {cycle['recordId']}", "", body.rstrip("\n"), ""]
+    return "\n".join(lines).rstrip("\n") + "\n"