okstra 0.180.0 → 0.183.2

package/runtime/python/okstra_ctl/pr_template.py

@@ -21,6 +21,7 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from okstra_project.dirs import okstra_home, project_json_path
+from .json_boundary import JsonBoundaryError, load_owned_object
 
 _DEFAULT_FILENAME = "pr-body.template.md"
 
@@ -49,8 +50,8 @@ def _read_json_field(path: Path, field: str) -> str:
     if not path.is_file():
         return ""
     try:
-        data = json.loads(path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
+        data = load_owned_object(path, artifact="PR template configuration")
+    except JsonBoundaryError:
         return ""
     if not isinstance(data, dict):
         return ""

package/runtime/python/okstra_ctl/project_meta.py

@@ -1,11 +1,11 @@
 """프로젝트 meta.json 업서트."""
 from __future__ import annotations
 
-import json
-import os
 from pathlib import Path
 from typing import Optional
 
+from .json_boundary import load_owned_object, write_owned_object_atomic
+
 
 def _project_meta_path(home: Path, project_id: str) -> Path:
     return home / "projects" / project_id / "meta.json"
@@ -16,7 +16,7 @@ def load_project_meta(home: Path, project_id: str) -> Optional[dict]:
     p = _project_meta_path(home, project_id)
     if not p.is_file():
         return None
-    return json.loads(p.read_text())
+    return load_owned_object(p, artifact="project metadata")
 
 
 def upsert_project_meta(home: Path, project_id: str, *,
@@ -29,7 +29,7 @@ def upsert_project_meta(home: Path, project_id: str, *,
     target = _project_meta_path(home, project_id)
     target.parent.mkdir(parents=True, exist_ok=True)
     if target.is_file():
-        meta = json.loads(target.read_text())
+        meta = load_owned_object(target, artifact="project metadata")
     else:
         meta = {
             "projectId": project_id,
@@ -46,6 +46,4 @@ def upsert_project_meta(home: Path, project_id: str, *,
         meta["activeCount"] = int(meta.get("activeCount", 0)) + 1
     if finished:
         meta["activeCount"] = max(0, int(meta.get("activeCount", 0)) - 1)
-    tmp = target.with_suffix(".json.tmp")
-    tmp.write_text(json.dumps(meta, indent=2) + "\n")
-    os.replace(tmp, target)
+    write_owned_object_atomic(target, meta, artifact="project metadata")

package/runtime/python/okstra_ctl/recap.py

@@ -15,6 +15,8 @@ from okstra_ctl import next_phase
 from okstra_ctl.clarification_items import sidecar_answers, user_response_sidecars
 from okstra_ctl.ids import slugify_task_segment
 from okstra_ctl.incremental_scope import preview_link_availability_for_report
+from okstra_ctl.json_boundary import JsonBoundaryError, load_owned_object
+from okstra_ctl.jsonl import append_jsonl
 from okstra_ctl.paths import task_timeline_file
 from okstra_project import read_task_key
 from okstra_ctl.run_context import dir_flock
@@ -29,8 +31,8 @@ def _load_timeline(task_root: Path) -> list[dict]:
     if not path.is_file():
         return []
     try:
-        data = json.loads(path.read_text(encoding="utf-8"))
-    except Exception:
+        data = load_owned_object(path, artifact="task timeline")
+    except (JsonBoundaryError, OSError):
         return []
     runs = data.get("runs", [])
     return runs if isinstance(runs, list) else []
@@ -150,8 +152,7 @@ def append_recap_entry(task_root, project_root, *, kind, mode, question,
     # 과 같은 append-only idiom — 데이터 fd 가 아닌 별도 .lock 파일을 잠가야
     # flush 가 락 안에서 끝난다).
     with dir_flock(recap_dir, ".recap-log.lock"):
-        with log_path.open("a", encoding="utf-8") as fh:
-            fh.write(json.dumps(entry, ensure_ascii=False) + "\n")
+        append_jsonl(log_path, entry, ensure_ascii=False, compact=False)
     return {"logPath": project_rel(log_path, project_root), "entry": entry}
 
 

package/runtime/python/okstra_ctl/reconcile.py

@@ -1,17 +1,16 @@
 """reconciliation/normalization."""
 from __future__ import annotations
 
-import json
-import os
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional
 
-from .jsonl import append_jsonl, rotate_recent_if_needed
+from .jsonl import append_jsonl, rewrite_jsonl, rotate_recent_if_needed
 from .locks import central_lock
 from .paths import resolve_under_root
 from .project_meta import upsert_project_meta
 from .run_index_row import read_run_index, slim_run_row
+from .json_boundary import JsonBoundaryError, load_owned_object
 
 
 DEFAULT_ABORT_AFTER_SECONDS = 12 * 3600  # 12시간 무진척이면 aborted 로 간주
@@ -70,8 +69,8 @@ def _read_run_manifest_validation(project_root: Path, run_dir_rel: str,
     if not manifest.is_file():
         return "not-run"
     try:
-        data = json.loads(manifest.read_text())
-    except (OSError, json.JSONDecodeError):
+        data = load_owned_object(manifest, artifact="run manifest")
+    except JsonBoundaryError:
         return "not-run"
     validation = data.get("validation")
     if isinstance(validation, dict):
@@ -94,11 +93,7 @@ def _sync_project_index(home: Path, project_id: str, updated_rows: list) -> None
         src = by_id.get(er.get("runId"))
         if src:
             er.update({k: src[k] for k in ("status", "finishedAt", "validation")})
-    tmp = proj_index.with_suffix(".jsonl.tmp")
-    with tmp.open("w") as f:
-        for er in existing:
-            f.write(json.dumps(slim_run_row(er), separators=(",", ":")) + "\n")
-    os.replace(tmp, proj_index)
+    rewrite_jsonl(proj_index, [slim_run_row(row) for row in existing])
 
 
 def reconcile_active(home: Path, *,
@@ -116,6 +111,20 @@ def reconcile_active(home: Path, *,
                                         project=project)
 
 
+def _publish_promoted(
+    home: Path, active: Path, survivors: list[dict], promoted: list[dict]
+) -> None:
+    rewrite_jsonl(active, [slim_run_row(row) for row in survivors])
+    for row in promoted:
+        append_jsonl(home / "recent.jsonl", slim_run_row(row))
+        _sync_project_index(home, row["projectId"], [row])
+        upsert_project_meta(
+            home, row["projectId"], project_root=row["projectRoot"],
+            when=row["finishedAt"], finished=True,
+        )
+    rotate_recent_if_needed(home)
+
+
 def _reconcile_active_locked(home: Path, *,
                              abort_after_seconds: int,
                              project: Optional[str] = None) -> dict:
@@ -171,18 +180,7 @@ def _reconcile_active_locked(home: Path, *,
         summary["running"] += 1
     if not promoted:
         return summary
-    tmp = active.with_suffix(".jsonl.tmp")
-    with tmp.open("w") as f:
-        for row in survivors:
-            f.write(json.dumps(slim_run_row(row), separators=(",", ":")) + "\n")
-    os.replace(tmp, active)
-    for row in promoted:
-        append_jsonl(home / "recent.jsonl", slim_run_row(row))
-        _sync_project_index(home, row["projectId"], [row])
-        upsert_project_meta(home, row["projectId"],
-                            project_root=row["projectRoot"],
-                            when=row["finishedAt"], finished=True)
-    rotate_recent_if_needed(home)
+    _publish_promoted(home, active, survivors, promoted)
     return summary
 
 
@@ -225,11 +223,7 @@ def _reconcile_recent_locked(home: Path, *, project: Optional[str] = None) -> di
         summary["completed" if new_status == "completed" else "failed"] += 1
     if not updated_by_project:
         return summary
-    tmp = recent.with_suffix(".jsonl.tmp")
-    with tmp.open("w") as f:
-        for row in rows:
-            f.write(json.dumps(slim_run_row(row), separators=(",", ":")) + "\n")
-    os.replace(tmp, recent)
+    rewrite_jsonl(recent, [slim_run_row(row) for row in rows])
     for pid, urows in updated_by_project.items():
         _sync_project_index(home, pid, urows)
     return summary

package/runtime/python/okstra_ctl/registry/host_discovery.py

@@ -7,6 +7,7 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from ..domain.host import HostAdapterContractError
+from ..json_boundary import JsonBoundaryError, load_owned_object
 
 
 @dataclass(frozen=True)
@@ -66,8 +67,8 @@ def _read_manifest(manifest_path: Path) -> HostManifest:
 
 def _read_json_object(manifest_path: Path) -> dict[str, object]:
     try:
-        raw = json.loads(manifest_path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError) as exc:
+        raw = load_owned_object(manifest_path, artifact="host adapter manifest")
+    except JsonBoundaryError as exc:
         raise HostAdapterContractError(
             f"invalid host manifest: {manifest_path}"
         ) from exc

package/runtime/python/okstra_ctl/registry/provider_registry.py

@@ -9,6 +9,7 @@ from pathlib import Path
 from okstra_project.dirs import okstra_home
 
 from ..domain.provider import ProviderSpec, UnknownProviderError
+from ..json_boundary import JsonBoundaryError, load_owned_object
 from .factory_loader import FactoryLoadError, load_relative_factory
 
 
@@ -121,8 +122,8 @@ def _manifest_paths(roots: Iterable[Path]) -> tuple[Path, ...]:
 
 def _read_manifest(manifest_path: Path) -> tuple[str, str]:
     try:
-        raw = json.loads(manifest_path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError) as exc:
+        raw = load_owned_object(manifest_path, artifact="provider adapter manifest")
+    except JsonBoundaryError as exc:
         raise ProviderAdapterContractError(f"invalid provider manifest: {manifest_path}") from exc
     if not isinstance(raw, dict) or raw.get("schemaVersion") != 1:
         raise ProviderAdapterContractError(f"invalid provider manifest: {manifest_path}")

package/runtime/python/okstra_ctl/render.py

@@ -46,6 +46,7 @@ from .registry.host_registry import default_host_registry
 from .registry.provider_registry import default_provider_registry
 from .path_hints import compact_active_run_context, hydrate_run_context
 from .paths import task_timeline_file
+from .json_boundary import JsonBoundaryError, load_owned_object, write_owned_object_atomic
 from .report_contract import CURRENT_REPORT_SCHEMA_VERSION
 from .worker_artifacts import artifacts_from_context
 from .workflow import PHASE_SEQUENCE
@@ -74,7 +75,9 @@ def _load_ctx(ctx_arg: str) -> dict:
     s = ctx_arg.lstrip()
     if s.startswith("{"):
         return hydrate_run_context(json.loads(ctx_arg))
-    return hydrate_run_context(json.loads(Path(ctx_arg).read_text(encoding="utf-8")))
+    return hydrate_run_context(
+        load_owned_object(Path(ctx_arg), artifact="render context")
+    )
 
 
 def _write_text(path: Path, text: str) -> None:
@@ -83,7 +86,7 @@ def _write_text(path: Path, text: str) -> None:
 
 
 def _write_json(path: Path, payload: dict) -> None:
-    _write_text(path, json.dumps(payload, indent=2, ensure_ascii=False) + "\n")
+    write_owned_object_atomic(path, payload, artifact="rendered runtime object")
 
 
 def _execution_identity(ctx: Mapping[str, object]) -> dict:
@@ -874,7 +877,7 @@ def render_task_catalog_discovery(output_path: str, ctx: dict) -> None:
     entries = []
     for manifest_path in sorted(tasks_root.rglob(TASK_MANIFEST_FILENAME)):
         try:
-            manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+            manifest = load_owned_object(manifest_path, artifact="task manifest")
         except Exception:
             continue
         if not isinstance(manifest, dict):
@@ -892,7 +895,7 @@ def render_task_catalog_discovery(output_path: str, ctx: dict) -> None:
         latest_run = {}
         if timeline_file.is_file():
             try:
-                payload = json.loads(timeline_file.read_text(encoding="utf-8"))
+                payload = load_owned_object(timeline_file, artifact="task timeline")
             except Exception:
                 payload = {}
             runs = payload.get("runs", []) if isinstance(payload, dict) else []
@@ -982,7 +985,9 @@ def render_latest_task_discovery(output_path: str, ctx: dict) -> None:
     task_manifest = {}
     if task_manifest_path.exists():
         try:
-            task_manifest = json.loads(task_manifest_path.read_text(encoding="utf-8"))
+            task_manifest = load_owned_object(
+                task_manifest_path, artifact="task manifest"
+            )
         except Exception:
             task_manifest = {}
     workflow = (
@@ -1344,7 +1349,7 @@ def render_task_manifest(manifest_path: str, ctx: dict) -> None:
     existing = {}
     if path.exists():
         try:
-            existing = json.loads(path.read_text(encoding="utf-8"))
+            existing = load_owned_object(path, artifact="task manifest")
         except Exception:
             existing = {}
     reviewers = _resolve_workers(ctx)
@@ -1646,21 +1651,23 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
     existing_run_manifest = {}
     if run_manifest_exists:
         try:
-            loaded_run_manifest = json.loads(
-                run_manifest_file.read_text(encoding="utf-8")
+            loaded_run_manifest = load_owned_object(
+                run_manifest_file, artifact="run manifest"
             )
             existing_run_manifest = (
                 loaded_run_manifest
                 if isinstance(loaded_run_manifest, dict)
                 else {}
             )
-        except (OSError, json.JSONDecodeError):
+        except JsonBoundaryError:
             existing_run_manifest = {}
     task_manifest_path = Path(ctx.get("TASK_MANIFEST_PATH", ""))
     task_manifest = {}
     if task_manifest_path.exists():
         try:
-            task_manifest = json.loads(task_manifest_path.read_text(encoding="utf-8"))
+            task_manifest = load_owned_object(
+                task_manifest_path, artifact="task manifest"
+            )
         except Exception:
             task_manifest = {}
     reviewers = _resolve_workers(ctx)
@@ -2086,7 +2093,9 @@ def render_timeline(timeline_path: str, ctx: dict) -> None:
     task_manifest = {}
     if task_manifest_path.exists():
         try:
-            task_manifest = json.loads(task_manifest_path.read_text(encoding="utf-8"))
+            task_manifest = load_owned_object(
+                task_manifest_path, artifact="task manifest"
+            )
         except Exception:
             task_manifest = {}
     reviewers = _resolve_workers(ctx)
@@ -2095,7 +2104,7 @@ def render_timeline(timeline_path: str, ctx: dict) -> None:
     existing = {}
     if path.exists():
         try:
-            existing = json.loads(path.read_text(encoding="utf-8"))
+            existing = load_owned_object(path, artifact="task timeline")
         except Exception:
             existing = {}
     runs = existing.get("runs", [])
@@ -2190,7 +2199,9 @@ def render_task_index(template_path: str, output_path: str, ctx: dict) -> None:
     task_manifest = {}
     if task_manifest_path.exists():
         try:
-            task_manifest = json.loads(task_manifest_path.read_text(encoding="utf-8"))
+            task_manifest = load_owned_object(
+                task_manifest_path, artifact="task manifest"
+            )
         except Exception:
             task_manifest = {}
     workflow = (
@@ -2385,8 +2396,8 @@ def build_available_mcp_servers_block(project_root: Path) -> str:
     """
     config_path = project_json_path(project_root)
     try:
-        raw = json.loads(config_path.read_text(encoding="utf-8"))
-    except (FileNotFoundError, json.JSONDecodeError):
+        raw = load_owned_object(config_path, artifact="project config")
+    except JsonBoundaryError:
         return _NO_MCP_SERVERS_LINE
     servers = raw.get("mcpServers") if isinstance(raw, dict) else None
     if not isinstance(servers, list) or not servers:

package/runtime/python/okstra_ctl/render_final_report.py

@@ -49,6 +49,7 @@ from okstra_ctl.final_report_schema import (
     load_schema_for_data,
     validate as schema_validate,
 )
+from okstra_ctl.json_boundary import JsonBoundaryError, load_owned_object
 from okstra_ctl.i18n import I18nError, SUPPORTED_LANGS, load_dictionary, make_jinja_global
 from okstra_ctl.md_table import UNESCAPED_PIPE_RE, to_cell_text
 from okstra_ctl.models import UnknownModelError, resolve_model_metadata
@@ -803,8 +804,8 @@ def render_to_file(
     if not data_path.is_file():
         raise FinalReportRenderError(f"data file not found: {data_path}")
     try:
-        data = json.loads(data_path.read_text(encoding="utf-8"))
-    except json.JSONDecodeError as exc:
+        data = load_owned_object(data_path, artifact="final report record")
+    except JsonBoundaryError as exc:
         raise FinalReportRenderError(f"invalid JSON in {data_path}: {exc}") from exc
 
     # 템플릿은 data.json 위치가 아니라 이 모듈(설치본은 ~/.okstra/lib/python,

package/runtime/python/okstra_ctl/report_assembly.py

@@ -6,12 +6,17 @@ import os
 import tempfile
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Callable, Mapping
+from typing import Any, Callable, Mapping, Sequence
 
 from .agent_activity import agent_activity_rows
 from .final_report_schema import load_schema_version, validate
 from .report_inputs import ReportInputPath, report_input_paths, uses_report_contract_v3
+from .json_boundary import JsonBoundaryError, load_owned_object, serialize_owned_object
 from .report_narrative import parse_narrative
+from .report_synthesis_packet import (
+    report_synthesis_packet_paths,
+    verify_report_synthesis_packet_sources,
+)
 from .report_projections import (
     ReportProjectionError,
     project_convergence,
@@ -32,12 +37,20 @@ class AssemblyIssue:
 class ReportAssemblyError(ValueError):
     """게시 전 입력 검증 실패와 실제 소유자를 전달한다."""
 
-    def __init__(self, issue: AssemblyIssue) -> None:
-        self.issue = issue
-        super().__init__(
-            f"owner={issue.owner} artifactPath={issue.artifact_path} "
-            f"fieldPath={issue.field_path} reason={issue.reason}"
-        )
+    def __init__(self, issues: AssemblyIssue | Sequence[AssemblyIssue]) -> None:
+        rows = (issues,) if isinstance(issues, AssemblyIssue) else tuple(issues)
+        if not rows:
+            raise ValueError("report assembly error requires at least one issue")
+        self.issues = rows
+        self.issue = rows[0]
+        super().__init__("; ".join(_issue_message(issue) for issue in rows))
+
+
+def _issue_message(issue: AssemblyIssue) -> str:
+    return (
+        f"owner={issue.owner} artifactPath={issue.artifact_path} "
+        f"fieldPath={issue.field_path} reason={issue.reason}"
+    )
 
 
 def _fail(owner: str, path: Path, field: str, reason: object) -> None:
@@ -48,8 +61,8 @@ def _read_json(row: ReportInputPath) -> dict[str, Any]:
     if not row.path.is_file():
         _fail(row.owner, row.path, "$", "required input is missing")
     try:
-        value = json.loads(row.path.read_text(encoding="utf-8"))
-    except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+        value = load_owned_object(row.path, artifact=f"{row.owner} report input")
+    except JsonBoundaryError as exc:
         _fail(row.owner, row.path, "$", exc)
     if not isinstance(value, dict):
         _fail(row.owner, row.path, "$", "input must be a JSON object")
@@ -63,6 +76,39 @@ def _input_map(project_root: Path, manifest: Mapping[str, Any]) -> dict[str, Rep
         _fail("orchestrator", project_root, "manifest", exc)
 
 
+def _input_preflight_issues(
+    inputs: Mapping[str, ReportInputPath],
+    schema: Mapping[str, Any],
+) -> tuple[AssemblyIssue, ...]:
+    issues: list[AssemblyIssue] = []
+    for row in inputs.values():
+        if not row.path.is_file():
+            issues.append(
+                AssemblyIssue(
+                    row.owner,
+                    str(row.path),
+                    "$",
+                    "required input is missing",
+                )
+            )
+            continue
+        try:
+            if row.key == "narrative":
+                parse_narrative(row.path.read_text(encoding="utf-8"), schema)
+            elif row.key == "agent-activity":
+                row.path.read_text(encoding="utf-8")
+            else:
+                value = load_owned_object(
+                    row.path,
+                    artifact=f"{row.owner} report input",
+                )
+                if not isinstance(value, dict):
+                    raise ValueError("input must be a JSON object")
+        except (JsonBoundaryError, OSError, UnicodeError, ValueError) as exc:
+            issues.append(AssemblyIssue(row.owner, str(row.path), "$", str(exc)))
+    return tuple(issues)
+
+
 def _narrative(row: ReportInputPath, schema: Mapping[str, Any]) -> dict[str, Any]:
     if not row.path.is_file():
         _fail(row.owner, row.path, "$", "required input is missing")
@@ -90,6 +136,81 @@ def _clarifications(
     ]
 
 
+def _project_relative(project_root: Path, path: Path) -> str:
+    try:
+        return path.relative_to(project_root).as_posix()
+    except ValueError:
+        return str(path)
+
+
+def _clarification_response_value(
+    project_root: Path,
+    manifest: Mapping[str, Any],
+) -> str:
+    direct = manifest.get("clarificationResponsePath")
+    if isinstance(direct, str) and direct.strip():
+        return direct.strip()
+    context_value = manifest.get("activeRunContextPath")
+    if isinstance(context_value, str) and context_value.strip():
+        context_path = Path(context_value)
+        if not context_path.is_absolute():
+            context_path = project_root / context_path
+        context = _read_json(
+            ReportInputPath("active-run-context", "orchestrator", context_path)
+        )
+        instruction_set = context.get("instructionSet")
+        value = (
+            instruction_set.get("clarificationResponsePath")
+            if isinstance(instruction_set, Mapping)
+            else ""
+        )
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return _latest_user_response_value(project_root, manifest)
+
+
+def _latest_user_response_value(
+    project_root: Path,
+    manifest: Mapping[str, Any],
+) -> str:
+    record_value = manifest.get("expectedReportRecordPath")
+    if not isinstance(record_value, str) or not record_value.strip():
+        return ""
+    record_path = Path(record_value)
+    if not record_path.is_absolute():
+        record_path = project_root / record_path
+    if record_path.parent.name != "reports":
+        return ""
+    task_type = str(manifest.get("taskType") or "").strip()
+    if not task_type:
+        return ""
+    responses = sorted(
+        path
+        for path in (record_path.parent.parent / "user-responses").glob(
+            f"user-response-{task_type}-*.md"
+        )
+        if path.is_file()
+    )
+    if not responses:
+        return ""
+    return _project_relative(project_root, responses[-1])
+
+
+def _clarification_carry_in(
+    project_root: Path,
+    manifest: Mapping[str, Any],
+) -> dict[str, str] | None:
+    value = _clarification_response_value(project_root, manifest)
+    if not value:
+        return None
+    path = Path(value)
+    if not path.is_absolute():
+        path = project_root / path
+    if not path.is_file():
+        _fail("user", path, "$", "attached clarification response is missing")
+    return {"sourceFile": _project_relative(project_root, path)}
+
+
 def _clarification_row(
     source: Mapping[str, Any], activities: Mapping[object, Mapping[str, Any]], path: Path,
 ) -> dict[str, Any]:
@@ -148,10 +269,12 @@ def _attach_plan_backlinks(data: dict[str, Any], activities: list[dict[str, Any]
 
 
 def _compose(
-    project_root: Path, manifest_path: Path, manifest: Mapping[str, Any],
+    project_root: Path,
+    manifest_path: Path,
+    manifest: Mapping[str, Any],
+    inputs: Mapping[str, ReportInputPath],
+    schema: Mapping[str, Any],
 ) -> dict[str, Any]:
-    schema = load_schema_version("3.0")
-    inputs = _input_map(project_root, manifest)
     narrative = _narrative(inputs["narrative"], schema)
     ledger = _read_json(inputs["approval-decisions"])
     team_state = _read_json(inputs["execution-status"])
@@ -175,6 +298,9 @@ def _compose(
     data["tokenUsage"] = usage
     data["crossVerification"] = convergence_data["crossVerification"]
     data["clarificationItems"] = _clarifications(ledger, activities, inputs["approval-decisions"].path)
+    carry_in = _clarification_carry_in(project_root, manifest)
+    if carry_in is not None:
+        data["clarificationCarryIn"] = carry_in
     data["agentActivity"] = activities
     data["evidence"] = {"primary": _promoted_evidence(convergence_data)}
     data["missingInformation"] = []
@@ -317,11 +443,11 @@ def _publish(
     target: Path, data: Mapping[str, Any], replace: Callable[[str, str], None],
 ) -> None:
     target.parent.mkdir(parents=True, exist_ok=True)
+    serialized = serialize_owned_object(target, data, artifact="final report record")
     descriptor, name = tempfile.mkstemp(prefix=f".{target.name}.", dir=target.parent)
     try:
         with os.fdopen(descriptor, "w", encoding="utf-8") as handle:
-            json.dump(data, handle, ensure_ascii=False, indent=2)
-            handle.write("\n")
+            handle.write(serialized)
             handle.flush()
             os.fsync(handle.fileno())
         replace(name, str(target))
@@ -339,12 +465,41 @@ def assemble_report(
     manifest = _read_json(manifest_row)
     if not uses_report_contract_v3(manifest):
         _fail("orchestrator", manifest_path, "reportContractVersion", "requires 3.0")
-    data = _compose(project_root, manifest_path, manifest)
-    errors = validate(data, load_schema_version("3.0"))
+    schema = load_schema_version("3.0")
+    inputs = _input_map(project_root, manifest)
+    input_issues = list(_input_preflight_issues(inputs, schema))
+    packet_data_path, _ = report_synthesis_packet_paths(inputs["narrative"].path)
+    if packet_data_path.is_file():
+        input_issues.extend(
+            AssemblyIssue(
+                issue.owner,
+                str(issue.path),
+                f"sources.{issue.label}",
+                issue.reason,
+            )
+            for issue in verify_report_synthesis_packet_sources(
+                project_root,
+                packet_data_path,
+            )
+        )
+    if input_issues:
+        raise ReportAssemblyError(tuple(input_issues))
+    data = _compose(project_root, manifest_path, manifest, inputs, schema)
+    errors = validate(data, schema)
     if errors:
         target = Path(str(manifest.get("expectedReportRecordPath") or "data.json"))
         target = target if target.is_absolute() else project_root / target
-        _fail(_schema_owner(errors[0]), target, errors[0].split(" ", 1)[0], errors[0])
+        raise ReportAssemblyError(
+            tuple(
+                AssemblyIssue(
+                    _schema_owner(error),
+                    str(target),
+                    error.split(" ", 1)[0],
+                    error,
+                )
+                for error in errors
+            )
+        )
     value = manifest.get("expectedReportRecordPath")
     if not isinstance(value, str) or not value:
         _fail("orchestrator", manifest_path, "expectedReportRecordPath", "required")