okstra 0.220.1 → 0.222.0

package/runtime/python/okstra_ctl/domain/wizard/interaction.py

@@ -33,7 +33,13 @@ class WizardPrompt:
 
 @dataclass(frozen=True)
 class AnswerProtocol:
-    kind: Literal["exact-value", "numbered", "group-json", "numbered-group-json"]
+    kind: Literal[
+        "exact-value",
+        "numbered",
+        "selected-labels",
+        "group-json",
+        "numbered-group-json",
+    ]
     multi: bool = False
 
 
@@ -120,6 +126,76 @@ def _normalize_numbered_answer(
     )
 
 
+_LABEL_SEPARATOR = ", "
+
+
+def labels_decode_uniquely(labels: tuple[str, ...]) -> bool:
+    """이 라벨들을 `", "` 로 이은 어떤 선택이든 한 가지로만 되쪼개지는가.
+
+    네이티브 다중 선택 호스트는 고른 라벨을 `", "` 로 이어 돌려주는데 라벨 자체도
+    `", "` 를 품을 수 있다. 선택 문자열은 `label + ", "` 낱말의 연접이므로 그
+    낱말 집합에 대한 Sardinas-Patterson 유일 복호 판정이다.
+    """
+    words = {label + _LABEL_SEPARATOR for label in labels}
+    if len(words) != len(labels):
+        return False
+
+    def dangling(prefixes: set[str], strings: set[str]) -> set[str]:
+        return {
+            string[len(prefix):]
+            for prefix in prefixes
+            for string in strings
+            if string != prefix and string.startswith(prefix)
+        }
+
+    seen: set[str] = set()
+    suffixes = dangling(words, words)
+    while suffixes:
+        if suffixes & words:
+            return False
+        seen |= suffixes
+        suffixes = (dangling(words, suffixes) | dangling(suffixes, words)) - seen
+    return True
+
+
+def _normalize_selected_labels(prompt: WizardPrompt, answer: str) -> str:
+    text = answer or ""
+    if not text.strip():
+        return ""
+    target = text + _LABEL_SEPARATOR
+    words = tuple(option.label + _LABEL_SEPARATOR for option in prompt.options)
+    # ways[i] 는 target[i:] 를 쪼개는 방법 수(2 에서 멈춤), first[i] 는 방법이
+    # 하나일 때 그 첫 옵션 위치다.
+    ways = [0] * len(target) + [1]
+    first = [-1] * (len(target) + 1)
+    for start in range(len(target) - 1, -1, -1):
+        for index, word in enumerate(words):
+            if target.startswith(word, start) and ways[start + len(word)]:
+                ways[start] = min(2, ways[start] + ways[start + len(word)])
+                first[start] = index
+    if ways[0] == 0:
+        values = {option.value for option in prompt.options}
+        # 라벨 대신 값 CSV 를 낸 제출(직접 CLI 입력, 값으로 바꿔 내는 리드)도 받는다.
+        if all(item.strip() in values for item in text.split(",")):
+            return ",".join(item.strip() for item in text.split(","))
+        raise WizardAnswerError(
+            f"multi-select answer is not a {_LABEL_SEPARATOR!r}-joined list "
+            f"of option labels: {text}"
+        )
+    if ways[0] > 1:
+        raise WizardAnswerError(f"multi-select answer labels are ambiguous: {text}")
+    selected: set[int] = set()
+    position = 0
+    while position < len(target):
+        selected.add(first[position])
+        position += len(words[first[position]])
+    return ",".join(
+        option.value
+        for index, option in enumerate(prompt.options)
+        if index in selected
+    )
+
+
 def _group_answers(answer: str) -> dict[str, object]:
     try:
         answers = json.loads(answer or "{}")
@@ -137,19 +213,22 @@ def _normalize_group_answer(
     numbered: bool,
 ) -> str:
     answers = _group_answers(answer)
-    if not numbered:
-        return json.dumps(answers, ensure_ascii=False, separators=(",", ":"))
     questions = {question.step: question for question in prompt.questions}
     normalized = dict(answers)
     for step, raw_answer in answers.items():
         question = questions.get(step)
         if question is None:
             continue
-        normalized[step] = _normalize_numbered_answer(
-            question,
-            str(raw_answer or ""),
-            multi=question.multi,
-        )
+        if numbered:
+            normalized[step] = _normalize_numbered_answer(
+                question,
+                str(raw_answer or ""),
+                multi=question.multi,
+            )
+        elif question.multi:
+            normalized[step] = _normalize_selected_labels(
+                question, str(raw_answer or "")
+            )
     return json.dumps(normalized, ensure_ascii=False, separators=(",", ":"))
 
 
@@ -162,6 +241,8 @@ def normalize_planned_answer(
         return answer
     if protocol.kind == "numbered":
         return _normalize_numbered_answer(prompt, answer, multi=protocol.multi)
+    if protocol.kind == "selected-labels":
+        return _normalize_selected_labels(prompt, answer)
     if protocol.kind in {"group-json", "numbered-group-json"}:
         return _normalize_group_answer(
             prompt,

package/runtime/python/okstra_ctl/file_size_cap.py

@@ -0,0 +1,142 @@
+"""File-size thresholds for source and test files an implementation stage writes.
+
+Every later agent that touches a file loads all of it into context, so a stage that
+grows one file past a few hundred lines makes every following run pay for it. Both
+thresholds are measured on the stage diff: 300 lines is the target, reported as an
+advisory finding, and 400 lines is the limit, a blocking finding the correction round
+fixes by splitting the file (`_implementation-deliverable.md` §"Correction round").
+
+A line is a physical line, as `wc -l` and an editor's line numbers count it, plus an
+unterminated last line. The cost being capped is what an agent reads, and comments and
+blank lines are read too; it also lets the executor check the number with any tool.
+
+Only source and test files are capped: the extensions in `self_mock_signals.EXT_TO_LANG`,
+the languages okstra's coding preflight has rules for. Lockfiles, JSON / YAML data,
+snapshots, Markdown, SQL and config fall outside by extension. Inside that set, vendored,
+fixture, snapshot, generated and `.okstra` paths are exempt, and so is a file whose head
+declares itself generated.
+"""
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+
+from .self_mock_signals import EXT_TO_LANG
+
+FILE_LINE_TARGET = 300
+FILE_LINE_LIMIT = 400
+
+_EXEMPT_SEGMENTS = frozenset({
+    ".okstra", "node_modules", "vendor", "fixtures", "__fixtures__", "__snapshots__",
+    "generated", "__generated__",
+})
+_GENERATED_MARKERS = (b"@generated", b"do not edit")
+_MARKER_HEAD_LINES = 5
+
+
+@dataclass(frozen=True)
+class FileSizeViolation:
+    path: str
+    before: int | None
+    after: int
+    kind: str
+    threshold: int
+
+    @property
+    def blocking(self) -> bool:
+        return self.threshold == FILE_LINE_LIMIT
+
+    @property
+    def finding_id(self) -> str:
+        prefix = "FILE-SIZE" if self.blocking else "FILE-SIZE-ADVISORY"
+        return f"{prefix}:{self.path}"
+
+    def line(self) -> str:
+        before = "new" if self.before is None else str(self.before)
+        label = "limit" if self.blocking else "target"
+        return (
+            f"{self.finding_id}:{self.threshold + 1} {before}->{self.after} lines "
+            f"({self.kind}; {label} {self.threshold})"
+        )
+
+
+def capped_path(path: str) -> bool:
+    """True when the cap applies to this repository-relative path."""
+    pure = PurePosixPath(path)
+    if EXT_TO_LANG.get(pure.suffix) is None or ".min." in pure.name:
+        return False
+    return not any(part in _EXEMPT_SEGMENTS for part in pure.parts[:-1])
+
+
+def physical_lines(data: bytes) -> int:
+    return data.count(b"\n") + (1 if data and not data.endswith(b"\n") else 0)
+
+
+def _declares_generated(data: bytes) -> bool:
+    head = b"\n".join(data.split(b"\n", _MARKER_HEAD_LINES)[:_MARKER_HEAD_LINES]).lower()
+    return any(marker in head for marker in _GENERATED_MARKERS)
+
+
+def _git(repo: Path, *args: str) -> bytes:
+    return subprocess.run(
+        ["git", "-C", str(repo), *args], check=True, capture_output=True,
+    ).stdout
+
+
+def _blob(repo: Path, rev: str, path: str) -> bytes:
+    return _git(repo, "show", f"{rev}:{path}")
+
+
+def _changed(repo: Path, base: str, head: str) -> list[tuple[str, str | None, str]]:
+    """(status letter, path at base or None, path at head) for each added or modified file."""
+    fields = _git(repo, "diff", "--name-status", "-z", "-M", f"{base}..{head}").split(b"\0")
+    rows: list[tuple[str, str | None, str]] = []
+    index = 0
+    while index < len(fields) and fields[index]:
+        status = fields[index].decode()[0]
+        if status == "R":
+            rows.append((status, fields[index + 1].decode(), fields[index + 2].decode()))
+            index += 3
+            continue
+        path = fields[index + 1].decode()
+        if status in "AM":
+            rows.append((status, path if status == "M" else None, path))
+        index += 2
+    return rows
+
+
+def _breach(before: int | None, after: int, threshold: int) -> str:
+    """Which way the diff breaks `threshold`, or '' when it does not."""
+    if after <= threshold:
+        return ""
+    if before is None:
+        return f"new file over {threshold}"
+    if before <= threshold:
+        return f"crossed {threshold}"
+    return f"grew a file over {threshold}" if after > before else ""
+
+
+def file_size_violations(repo: Path, base: str, head: str = "HEAD") -> list[FileSizeViolation]:
+    """Files the `base..head` diff leaves over a threshold, in diff order.
+
+    A new file over a threshold, an existing file the diff takes over it, and a file
+    already over it that the diff grows. A file already over it that the diff leaves the
+    same size or shrinks is not this stage's to split. A file that breaks the limit is
+    reported once, as blocking; one that breaks only the target is advisory.
+    """
+    violations: list[FileSizeViolation] = []
+    for _status, old_path, path in _changed(repo, base, head):
+        if not capped_path(path):
+            continue
+        data = _blob(repo, head, path)
+        after = physical_lines(data)
+        if after <= FILE_LINE_TARGET or _declares_generated(data):
+            continue
+        before = None if old_path is None else physical_lines(_blob(repo, base, old_path))
+        for threshold in (FILE_LINE_LIMIT, FILE_LINE_TARGET):
+            kind = _breach(before, after, threshold)
+            if kind:
+                violations.append(FileSizeViolation(path, before, after, kind, threshold))
+                break
+    return violations

package/runtime/python/okstra_ctl/fix_cycles.py

@@ -17,7 +17,9 @@ from __future__ import annotations
 import json
 import re
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Mapping, Optional
+
+from okstra_project.phase_pointer import promote
 
 from .run_context import dir_flock
 from .jsonl import append_jsonl
@@ -33,6 +35,17 @@ FIX_CYCLE_ENTRY_PHASES = (
 )
 
 
+def delivery_completed(workflow: Mapping[str, Any]) -> bool:
+    """release-handoff 가 전달까지 끝냈는가. fix cycle 을 열고 닫는 조건이다.
+
+    skip·미전달 stage 가 남은 handoff 는 다음 phase 포인터를 다시
+    release-handoff 로 둔다(`next_phase.project`).
+    """
+    if workflow.get("lastCompletedPhase") != "release-handoff":
+        return False
+    return promote(workflow.get("nextRecommendedPhase"))["phase"] != "release-handoff"
+
+
 def fix_cycles_path(task_root: Path) -> Path:
     return Path(task_root) / "history" / FIX_CYCLES_FILENAME
 

package/runtime/python/okstra_ctl/git_reconcile.py

@@ -165,13 +165,20 @@ class ReconcileError(Exception):
     pass
 
 
+# 최신 done 행이 last-wins 라, 보정 행이 이 필드를 안 옮기면 stage 의 보고서·carry 가 사라진다.
+_COMPLETION_FIELDS = ("report_path", "carry_path", "completed_at")
+
+
 def _record_reconciled(plan_run_root: Path, *, impl_task_key: str, stage: int,
                        new_commit: str, replaced: str, reason: str) -> None:
-    from .consumers import append_consumer
+    from .consumers import append_consumer, latest_done_by_stage, read_consumers
+    previous = latest_done_by_stage(read_consumers(plan_run_root)).get(stage) or {}
+    completion = {k: previous[k] for k in _COMPLETION_FIELDS if previous.get(k)}
     append_consumer(
         plan_run_root, impl_task_key=impl_task_key, stage=stage,
         status="done", force_reappend=True, head_commit=new_commit,
         reconciled=True, reconcile_reason=reason, replaced_commit=replaced,
+        **completion,
     )
 
 
@@ -195,12 +202,19 @@ def auto_reconcile(*, project_root: Path, plan_run_root: Path,
     return applied
 
 
-def guidance(*, plan_run_root: Path, project_id: str, task_group: str,
+def _command(*, plan_run_root: Path, project_id: str, task_group: str,
              task_id: str, work_category: str) -> str:
-    """PrepareError 에 첨부하는 회복 안내 (명령 예시 포함)."""
-    base = (f"okstra git-reconcile --plan-run-root {plan_run_root} "
+    return (f"okstra git-reconcile --plan-run-root {plan_run_root} "
             f"--project-id {project_id} --task-group {task_group} "
             f"--task-id {task_id} --work-category {work_category}")
+
+
+def guidance(*, plan_run_root: Path, project_id: str, task_group: str,
+             task_id: str, work_category: str) -> str:
+    """PrepareError 에 첨부하는 회복 안내 (명령 예시 포함)."""
+    base = _command(plan_run_root=plan_run_root, project_id=project_id,
+                    task_group=task_group, task_id=task_id,
+                    work_category=work_category)
     return ("Recorded stage SHAs no longer match the git history "
             "(external rebase/squash/amend?). Inspect and reconcile:\n"
             f"  {base} --check --text\n"
@@ -224,6 +238,32 @@ def _apply_user_ref(project_root: Path, plan_run_root: Path,
     return {"stage": stage, "new_commit": sha}
 
 
+def _anchor_warning(*, project_root: Path, plan_run_root: Path, project_id: str,
+                    task_group: str, task_id: str, work_category: str,
+                    stage: int, new_commit: str) -> str:
+    """보정한 head 가 anchor 를 담지 않으면 whole-task diff 의 base 가 틀린다.
+    anchor 는 --reset-anchor 로만 옮기므로 경고와 명령만 낸다."""
+    from . import worktree_registry as _reg
+
+    anchor = _reg.get_implementation_base(project_id, task_group, task_id) or ""
+    if not _resolve_commit_sha(project_root, anchor):
+        return ""
+    if _git(project_root, "merge-base", "--is-ancestor",
+            anchor, new_commit).returncode == 0:
+        return ""
+    entry = _reg.lookup(project_id, task_group, task_id)
+    base_ref = entry.base_ref if entry else ""
+    new_base = (_git(project_root, "merge-base", base_ref, new_commit).stdout.strip()
+                if base_ref else "")
+    command = _command(plan_run_root=plan_run_root, project_id=project_id,
+                       task_group=task_group, task_id=task_id,
+                       work_category=work_category)
+    return (f"stage {stage} head {new_commit} does not contain the implementation "
+            f"anchor {anchor}; whole-task final-verification would diff from the "
+            f"old base. Move the anchor after confirming the new base:\n"
+            f"  {command} --apply --reset-anchor {new_base or '<new-base-commit>'}")
+
+
 def apply_reconcile(*, project_root: Path, plan_run_root: Path,
                     project_id: str, task_group: str, task_id: str,
                     work_category: str, stage: Optional[int] = None,
@@ -239,6 +279,7 @@ def apply_reconcile(*, project_root: Path, plan_run_root: Path,
     from .consumers import read_consumers, latest_done_by_stage
 
     applied: List[dict] = []
+    warnings: List[str] = []
     if reset_anchor:
         sha = _resolve_commit_sha(project_root, reset_anchor)
         if not sha:
@@ -247,8 +288,16 @@ def apply_reconcile(*, project_root: Path, plan_run_root: Path,
         applied.append({"anchor": sha})
     if use_ref:
         latest = latest_done_by_stage(read_consumers(plan_run_root))
-        applied.append(_apply_user_ref(
-            project_root, plan_run_root, latest, stage, use_ref))
+        recorded = _apply_user_ref(
+            project_root, plan_run_root, latest, stage, use_ref)
+        applied.append(recorded)
+        warning = _anchor_warning(
+            project_root=project_root, plan_run_root=plan_run_root,
+            project_id=project_id, task_group=task_group, task_id=task_id,
+            work_category=work_category, stage=stage,
+            new_commit=recorded["new_commit"])
+        if warning:
+            warnings.append(warning)
     items = classify_task(
         project_root=project_root, plan_run_root=plan_run_root,
         project_id=project_id, task_group=task_group, task_id=task_id,
@@ -264,7 +313,8 @@ def apply_reconcile(*, project_root: Path, plan_run_root: Path,
         applied.append({"stage": item.stage, "new_commit": item.suggested_commit})
     remaining = [i for i in items if i.classification == "confirm"
                  and not (use_ref and i.stage == stage)]
-    return {"applied": applied, "remaining_confirm": remaining}
+    return {"applied": applied, "remaining_confirm": remaining,
+            "warnings": warnings}
 
 
 def _items_as_json(items: List[StaleItem]) -> list:
@@ -345,6 +395,9 @@ def render_git_reconcile_text(payload: dict) -> str:
         rows.append(line(f"Item {index} kind", item.get("kind")))
         rows.append(line(f"Item {index} classification", item.get("classification")))
         rows.append(line(f"Item {index} reason", item.get("reason")))
+    warnings = payload.get("warnings") if isinstance(payload.get("warnings"), list) else []
+    for index, warning in enumerate(warnings, 1):
+        rows.append(line(f"Warning {index}", warning))
     if "error" in payload:
         rows.append(line("Failure reason", payload.get("error")))
     return "".join(rows)
@@ -362,7 +415,8 @@ def main(argv: Optional[list] = None) -> int:
             result = apply_reconcile(**kw, stage=a.stage, use_ref=a.use_ref,
                                      reset_anchor=a.reset_anchor)
             out = {"applied": result["applied"],
-                   "remaining_confirm": _items_as_json(result["remaining_confirm"])}
+                   "remaining_confirm": _items_as_json(result["remaining_confirm"]),
+                   "warnings": result["warnings"]}
             _emit_result(out, as_json=a.json, as_text=a.text)
             return 2 if result["remaining_confirm"] else 0
         items = classify_task(**kw)

package/runtime/python/okstra_ctl/initial_prompt_materialization.py

@@ -25,7 +25,6 @@ from .agent.invocation import (
     verify_agent_invocation,
 )
 from .path_hints import hydrate_active_run_context
-from .report_language import resolve_report_language
 from .report_inputs import report_narrative_path, uses_report_contract_v3
 from .report_synthesis_packet import (
     ReportSynthesisPacketError,
@@ -708,11 +707,9 @@ def _prompt_body(
             context.active_context,
             context.team_state,
             worker.model,
-            resolve_report_language(
-                context.project_root,
-                context.manifest,
-                context.active_context,
-            ),
+            # 조립이 `meta.reportLanguage` 로 옮기는 매니페스트 값. 설정을 다시 읽으면
+            # prepare 뒤의 설정 변경이 프롬프트와 리포트의 언어를 가른다.
+            str(context.manifest.get("reportLanguage") or "en"),
             synthesis_packet_path,
         )
     return analysis_prompt_body(

package/runtime/python/okstra_ctl/manager_cli.py

@@ -139,6 +139,11 @@ def _render_list(command: str, items: list[dict]) -> list[str]:
     return rows
 
 
+def _age_text(seconds: int) -> str:
+    hours, rest = divmod(int(seconds), 3600)
+    return f"{hours}h {rest // 60}m"
+
+
 def _render_manager_status(payload: dict) -> list[str]:
     rows: list[str] = []
     manifest = payload.get("manifest") if isinstance(payload.get("manifest"), dict) else {}
@@ -148,6 +153,10 @@ def _render_manager_status(payload: dict) -> list[str]:
     summary = payload.get("summary") if isinstance(payload.get("summary"), dict) else {}
     for key in ("planned", "missing", "running", "done", "blocked", "discussion"):
         rows.append(line(f"Summary {key}", summary.get(key)))
+    rows.append(line("Synced at", payload.get("syncedAt") or "never"))
+    if "syncAgeSeconds" in payload:
+        rows.append(line("Sync age", _age_text(payload["syncAgeSeconds"])))
+    rows.append(line("Changed since sync count", payload.get("changedSinceSyncCount", 0)))
     children = payload.get("children") if isinstance(payload.get("children"), list) else []
     for index, child in enumerate(children, 1):
         if not isinstance(child, dict):
@@ -156,7 +165,8 @@ def _render_manager_status(payload: dict) -> list[str]:
                            ("current phase", "currentPhase"), ("work status", "workStatus"),
                            ("summary", "summaryBucket"), ("project linked", "projectLinked"),
                            ("ticket", "ticketId"), ("brief path", "briefPath"),
-                           ("report path", "latestReportRecordPath"), ("error", "error")):
+                           ("report path", "latestReportRecordPath"),
+                           ("changed since sync", "changedSinceSync"), ("error", "error")):
             if key in child:
                 value = child.get(key)
                 rows.append(line(f"Child {index} {label}", ("yes" if value else "no") if isinstance(value, bool) else value))

package/runtime/python/okstra_ctl/manager_sync.py

@@ -1,9 +1,11 @@
 """Read project-local okstra state into manager-owned snapshots."""
 from __future__ import annotations
 
+from datetime import datetime
 from pathlib import Path
 
 from okstra_project import TASKS_RELATIVE, StateError, parse_task_key, read_task_catalog, read_task_manifest, slugify
+from okstra_project.dirs import TASK_MANIFEST_FILENAME
 
 from . import next_phase
 from .next_phase import STATUS_BLOCKED, STATUS_TERMINAL
@@ -168,12 +170,35 @@ def summary_bucket(row: dict) -> str:
     return _POINTER_STATUS_BUCKETS.get(pointer_status, "running")
 
 
-def status_task(home: Path, manager_id: str, task_group: str, task_id: str) -> dict:
+def _epoch(value: str) -> int | None:
+    if not value:
+        return None
+    return int(datetime.fromisoformat(value.replace("Z", "+00:00")).timestamp())
+
+
+def _manifest_changed_since(project: dict | None, task_key: str, synced: int | None) -> bool:
+    """프로젝트의 task-manifest 가 마지막 sync 뒤에 바뀌었는지 — 파일 시각만 본다."""
+    if project is None or not task_key:
+        return False
+    root = Path(str(project.get("projectRoot") or ""))
+    if not root.is_dir():
+        return False
+    task_dir = _resolve_task_root_read_only(root, task_key)
+    manifest_path = task_dir / TASK_MANIFEST_FILENAME if task_dir is not None else None
+    if manifest_path is None or not manifest_path.is_file():
+        return False
+    # syncedAt 은 초 단위라 mtime 도 초로 내려 같은 초에 쓴 파일을 변경으로 세지 않는다.
+    return synced is None or int(manifest_path.stat().st_mtime) > synced
+
+
+def status_task(home: Path, manager_id: str, task_group: str, task_id: str, *, now: str | None = None) -> dict:
     manifest = _read_json(task_manifest_path(home, manager_id, task_group, task_id))
     children = _read_json_default(children_json_path(home, manager_id, task_group, task_id), {"children": []})
     snapshot = _read_json_default(snapshots_json_path(home, manager_id, task_group, task_id), {"children": []})
     by_key = {row.get("taskKey"): row for row in snapshot.get("children", []) if isinstance(row, dict)}
     linked = _project_map(home, manager_id)
+    synced_at = str(snapshot.get("syncedAt") or "")
+    synced = _epoch(synced_at)
     rows = []
     summary = {"planned": 0, "missing": 0, "running": 0, "done": 0, "blocked": 0, "discussion": 0}
     for child in children.get("children", []):
@@ -184,6 +209,17 @@ def status_task(home: Path, manager_id: str, task_group: str, task_id: str) -> d
         row["summaryBucket"] = "planned" if snapshot_row is None else summary_bucket(row)
         # `remove project` 는 하위 태스크를 남긴다. 등록 목록에 없으면 해제된 프로젝트의 것이다.
         row["projectLinked"] = str(child.get("projectId") or "") in linked
+        try:
+            row["changedSinceSync"] = _manifest_changed_since(
+                linked.get(str(child.get("projectId") or "")), str(child.get("taskKey") or ""), synced)
+        except StateError as exc:
+            row["changedSinceSync"] = True
+            row["error"] = str(exc)
         summary[row["summaryBucket"]] += 1
         rows.append(row)
-    return {"manifest": manifest, "summary": summary, "children": rows, "lastSnapshot": snapshot}
+    payload = {"manifest": manifest, "summary": summary, "children": rows, "lastSnapshot": snapshot,
+               "syncedAt": synced_at,
+               "changedSinceSyncCount": sum(1 for row in rows if row["changedSinceSync"])}
+    if synced is not None:
+        payload["syncAgeSeconds"] = max(0, (_epoch(now or _now_iso()) or 0) - synced)
+    return payload