okstra 0.220.1 → 0.221.0

package/runtime/python/okstra_ctl/analysis_packet.py

@@ -65,6 +65,7 @@ WORKER_PROFILE_SECTIONS_BY_TASK_TYPE = {
         "Worker direction-selection procedure",
         "Pre-selection context exploration",
         "Option evaluation rules",
+        "Technical evidence loop",
     ),
     "implementation-planning": (
         "Brief consumption",
@@ -114,6 +115,8 @@ def build_analysis_packet(
     business_knowledge_text: str = "",
     coverage_census_text: str = "",
     has_selected_direction: bool = False,
+    mcp_servers_text: str = "",
+    technical_evidence_text: str = "",
 ) -> str:
     """Return the primary compact input for Claude/Codex/Antigravity analysers.
 
@@ -130,6 +133,12 @@ def build_analysis_packet(
 
     `coverage_census_text` is the `## Coverage Census` block
     `coverage_census.render_census_section` rendered; empty means no census.
+
+    `mcp_servers_text` 는 prepare 가 provider 별 도달성까지 렌더한 선언 서버
+    목록이다. 빈 문자열이면 선언이 없는 것이고 절을 싣지 않는다.
+
+    `technical_evidence_text` 는 carry-in 이 technical-verification 결과일 때
+    `technical_evidence_packet_block` 이 렌더한 증거 위치 절이다.
     """
     brief_text = task_brief_path.read_text(encoding="utf-8")
     group_context_text = _read_optional(group_context_path) if group_context_path else ""
@@ -150,6 +159,9 @@ def build_analysis_packet(
             has_selected_direction,
         )
     )
+    # 짧은 포인터 절이라 46KB 에서 잘리는 읽기에서도 도착하도록 브리프보다 앞에 둔다.
+    if technical_evidence_text:
+        parts.extend(["", technical_evidence_text])
     # 그룹 문서는 사람 절과 okstra 메모리 영역으로 갈라 싣는다. 사람 절("왜")은
     # 브리프 발췌보다 앞 — 짧고, 46KB 에서 잘리는 읽기(agy view_file)에서도
     # 도착해야 한다. 형제 task 의 결론은 브리프 뒤 — 브리프를 밀어내면 안 된다.
@@ -158,6 +170,8 @@ def build_analysis_packet(
     )
     parts.extend(_group_context_block(group_human))
     parts.extend(_brief_block(brief_text))
+    if mcp_servers_text:
+        parts.extend(["", "## Available MCP Servers", "", mcp_servers_text])
     if direct_work_text:
         parts.extend(["", direct_work_text, ""])
     parts.extend(_group_memory_block(

package/runtime/python/okstra_ctl/correction_cli.py

@@ -2,23 +2,46 @@
 from __future__ import annotations
 
 import argparse
+import subprocess
 import sys
 from pathlib import Path
 
 from .convergence import canonical_run_state_artifact, validated_run_authority
 from .correction_round import CorrectionRoundError, correction_instruction
+from .file_size_cap import FILE_LINE_LIMIT, FILE_LINE_TARGET, file_size_violations
 
 
 _CLI_EPILOG = r"""Usage:
   okstra correction prompt --run-manifest <path> --round <N> --role <executor|verifier> \
-    --base <sha> --finding <F-id> [--finding <F-id> ...]
+    --base <sha> [--finding <F-id> ...] [--stage-base <sha>]
+  okstra correction file-size --base <stage base sha> [--head <rev>] [--repo <path>]
 
-Prints the instruction body for one correction-round prompt; pass it to
+`prompt` prints the instruction body for one correction-round prompt; pass it to
 `okstra agent-prompt materialize --instruction` with --dispatch-kind correction-r<N>.
-Findings are read from the run's convergence record. Exit 1 on a refusal.
+Findings are read from the run's convergence record; --stage-base adds the file-size
+findings of `<stage-base>..<base>` (the 400-line limit only). Exit 1 on a refusal.
+
+`file-size` prints one `FILE-SIZE:<path>:401` line per file the stage diff leaves over
+the 400-line limit (blocking) and one `FILE-SIZE-ADVISORY:<path>:301` line per file it
+leaves over only the 300-line target, then `QA-RESULT: PASS|FAIL`; only a limit line
+fails. Exit 1 on FAIL, 2 when git cannot read the range.
 """
 
 
+def _file_size(args: argparse.Namespace) -> int:
+    try:
+        violations = file_size_violations(Path(args.repo), args.base, args.head)
+    except subprocess.CalledProcessError as exc:
+        print(f"error: git: {exc.stderr.decode(errors='replace').strip()}", file=sys.stderr)
+        return 2
+    for violation in violations:
+        print(violation.line())
+    failed = any(v.blocking for v in violations)
+    print(f"QA-RESULT: {'FAIL' if failed else 'PASS'} "
+          f"(file-size limit {FILE_LINE_LIMIT}, target {FILE_LINE_TARGET})")
+    return 1 if failed else 0
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(
         prog="okstra correction",
@@ -33,9 +56,17 @@ def main(argv: list[str] | None = None) -> int:
     prompt.add_argument("--role", choices=("executor", "verifier"), required=True)
     prompt.add_argument("--base", required=True,
                         help="the stage HEAD before this round")
-    prompt.add_argument("--finding", action="append", default=[], required=True,
+    prompt.add_argument("--finding", action="append", default=[],
                         help="a convergence finding id to fix; repeat for several")
+    prompt.add_argument("--stage-base", default="",
+                        help="the stage base commit; adds the stage diff's file-size limit findings")
+    size = commands.add_parser("file-size", help="check the stage diff against the file-size limit and target")
+    size.add_argument("--base", required=True, help="the stage base commit")
+    size.add_argument("--head", default="HEAD")
+    size.add_argument("--repo", default=".", help="the stage worktree (default: cwd)")
     args = parser.parse_args(argv)
+    if args.command == "file-size":
+        return _file_size(args)
 
     try:
         authority = validated_run_authority(args.run_manifest)
@@ -45,10 +76,18 @@ def main(argv: list[str] | None = None) -> int:
             authority, manifest_field="convergenceStatePath", prefix="convergence",
             label="convergence state",
         )
+        size_violations = [
+            v for v in file_size_violations(Path.cwd(), args.stage_base, args.base)
+            if v.blocking
+        ] if args.stage_base else []
         print(correction_instruction(
             convergence_path=convergence_path, round_number=args.round, role=args.role,
-            base=args.base, finding_ids=args.finding,
+            base=args.base, finding_ids=args.finding, stage_base=args.stage_base,
+            size_violations=size_violations,
         ))
+    except subprocess.CalledProcessError as exc:
+        print(f"error: git: {exc.stderr.decode(errors='replace').strip()}", file=sys.stderr)
+        return 1
     except (CorrectionRoundError, OSError, ValueError) as exc:
         print(f"error: {exc}", file=sys.stderr)
         return 1

package/runtime/python/okstra_ctl/correction_round.py

@@ -14,6 +14,7 @@ from pathlib import Path
 from typing import Mapping, Sequence
 
 from .execution_identity import ExecutionManifest
+from .file_size_cap import FILE_LINE_LIMIT, FileSizeViolation
 from .json_boundary import load_owned_object
 
 MAX_CORRECTION_ROUNDS = 2
@@ -101,17 +102,11 @@ def _finding_lines(findings: Sequence[Mapping[str, object]]) -> list[str]:
     return lines
 
 
-def correction_instruction(
-    *, convergence_path: Path, round_number: int, role: str, base: str,
-    finding_ids: Sequence[str],
-) -> str:
-    """The instruction body one correction-round prompt carries, read from the convergence record."""
-    if not 1 <= round_number <= MAX_CORRECTION_ROUNDS:
-        raise CorrectionRoundError(f"--round must be 1..{MAX_CORRECTION_ROUNDS}")
+def _convergence_findings(
+    convergence_path: Path, finding_ids: Sequence[str],
+) -> list[Mapping[str, object]]:
     if not finding_ids:
-        raise CorrectionRoundError("name at least one --finding")
-    if not base.strip():
-        raise CorrectionRoundError("--base is required: the stage HEAD before this round")
+        return []
     record = load_owned_object(convergence_path, artifact="convergence record")
     by_id = {
         str(row.get("findingId")): row for row in record.get("findings") or []
@@ -123,14 +118,40 @@ def correction_instruction(
             f"findings not in {convergence_path.name}: {', '.join(missing)}; "
             f"it holds {', '.join(sorted(by_id)) or 'none'}"
         )
-    findings = [by_id[fid] for fid in finding_ids]
+    return [by_id[fid] for fid in finding_ids]
+
+
+def correction_instruction(
+    *, convergence_path: Path, round_number: int, role: str, base: str,
+    finding_ids: Sequence[str], stage_base: str = "",
+    size_violations: Sequence[FileSizeViolation] = (),
+) -> str:
+    """The instruction body one correction-round prompt carries.
+
+    Verifier findings are read from the convergence record. File-size findings come from
+    `file_size_cap.file_size_violations` over `stage_base..base`, so they need no verifier
+    to have reported them.
+    """
+    if not 1 <= round_number <= MAX_CORRECTION_ROUNDS:
+        raise CorrectionRoundError(f"--round must be 1..{MAX_CORRECTION_ROUNDS}")
+    if not finding_ids and not size_violations:
+        raise CorrectionRoundError(
+            "name at least one --finding, or pass --stage-base for a stage whose diff "
+            "breaks the 400-line file-size limit"
+        )
+    if not base.strip():
+        raise CorrectionRoundError("--base is required: the stage HEAD before this round")
+    findings = _convergence_findings(convergence_path, finding_ids)
     results_dir = convergence_path.parent.parent / "worker-results"
+    stage_base_ref = stage_base.strip() or "<the stage base>"
     header = [
         f"- Convergence record: `{convergence_path}`",
         f"- Verifier results (each finding's suggested fix): `{results_dir}`",
         f"- Stage HEAD before this round: `{base.strip()}`",
+        *([f"- Stage base (file-size limit): `{stage_base.strip()}`"] if stage_base.strip() else []),
         "- Findings:",
         *("  " + line for line in _finding_lines(findings)),
+        *(f"  - `{v.finding_id}` (file-size limit; okstra): {v.line()}" for v in size_violations),
         "",
     ]
     if role == "executor":
@@ -144,6 +165,11 @@ def correction_instruction(
             "dependency, or a schema or migration change is not fixed here: stop and say so.",
             "- Update a test's expected value only where the finding shows the oracle itself is "
             "wrong; never weaken or delete an assertion to make a test pass.",
+            f"- A `FILE-SIZE:` finding is fixed by moving whole responsibilities (a group of "
+            f"functions, a class, a `describe` block) into new files beside the oversized one; "
+            f"those files count as inside this stage. Never compress code or drop comments to "
+            f"meet the number. Done when `okstra correction file-size --base {stage_base_ref}` "
+            f"prints `QA-RESULT: PASS` (limit {FILE_LINE_LIMIT} lines; aim for 300).",
             "- Follow the executor sidecar's TDD, pre-commit diff review and self-check, and "
             "commit with a Conventional Commit whose body names the finding ids.",
             "- Re-run the plan validation commands that cover the fix, and end with a "
@@ -161,6 +187,9 @@ def correction_instruction(
             "the stage was reviewed in the initial round.",
             "- Re-run every plan validation command, as the verifier sidecar's Fix-run "
             "incremental scope requires.",
+            f"- Run `okstra correction file-size --base {stage_base_ref}` against the stage base, "
+            "not this round's base: each `FILE-SIZE:` line it prints is a blocking finding, and each "
+            "`FILE-SIZE-ADVISORY:` line a recommendation.",
             "- Verdict `PASS` when every finding is fixed and no blocking check hits the "
             "correction diff; otherwise `FAIL`, with each remaining or new finding in the "
             "usual format.",

package/runtime/python/okstra_ctl/domain/mcp.py

@@ -0,0 +1,43 @@
+"""provider 어댑터와 핵심 판정이 함께 쓰는 벤더 중립 MCP 목록 값."""
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Literal
+
+McpServerState = Literal["enabled", "disabled", "needs-auth"]
+
+
+@dataclass(frozen=True)
+class VisibleMcpServer:
+    name: str
+    state: McpServerState
+
+
+@dataclass(frozen=True)
+class McpInventory:
+    """``listed`` 가 False 면 목록 자체를 못 얻은 것이라 선언 서버를 ``missing``
+    이 아니라 ``unknown`` 으로 판정한다."""
+
+    listed: bool
+    servers: tuple[VisibleMcpServer, ...] = ()
+    note: str = ""
+
+    @classmethod
+    def unavailable(cls, note: str) -> McpInventory:
+        return cls(listed=False, note=note)
+
+
+McpInventoryParser = Callable[[str], McpInventory]
+
+
+@dataclass(frozen=True)
+class McpInventoryProbe:
+    """추론 호출 없이 MCP 서버를 나열하는 명령과 그 출력 파서.
+
+    실행은 어댑터가 아니라 핵심 코드가 맡아 모든 provider 에 같은 타임아웃과
+    cwd(프로젝트 루트)를 적용한다.
+    """
+
+    argv: tuple[str, ...]
+    parse: McpInventoryParser

package/runtime/python/okstra_ctl/domain/provider.py

@@ -5,6 +5,7 @@ from collections.abc import Callable
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Literal, Mapping, Optional, Protocol
 
+from .mcp import McpInventoryProbe
 from .role import RoleCatalogError, normalize_role, ROLE_CATALOG
 from .worker_exec import WorkerWriteCapability
 
@@ -195,6 +196,7 @@ class ProviderSpec:
     exec_strategy: Optional["ExecutionStrategy"] = None
     execution_normalizer: Optional[ExecutionNormalizer] = None
     served_model_normalizer: ServedModelNormalizer = unavailable_served_model
+    mcp_inventory: Optional[McpInventoryProbe] = None
     _legacy_role_restriction: frozenset[str] = field(
         init=False,
         repr=False,

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/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))