okstra 0.189.1 → 0.189.3

package/runtime/python/okstra_ctl/report_html/filters.py

@@ -30,36 +30,38 @@ def _anchors_pattern(keys: tuple[str, ...]) -> re.Pattern[str] | None:
     )
 
 
-def _link_ids(escaped: str, anchors: dict) -> str:
-    """Anchor the row ids inside text that is already escaped.
+def _link_ids(escaped: str, links: dict) -> str:
+    """Link the row ids inside text that is already escaped.
 
     Running after the escape keeps this anchor the only markup in the result.
-    Only ids the document defines become links — an id with no row would point
-    at a missing anchor, and a ticket number like ``DEV-10339`` has the same
-    shape as a row id without being one.
+    ``links`` maps an id to the href that lands on it: ``#id-…`` for a row of
+    this page, or a relative page path plus fragment for a row the carry-in
+    report defines. Only ids with a link target become links — an id with no
+    row would point at a missing anchor, and a ticket number like
+    ``DEV-10339`` has the same shape as a row id without being one.
     """
-    if not anchors:
+    if not links:
         return escaped
-    pattern = _anchors_pattern(tuple(sorted(anchors)))
+    pattern = _anchors_pattern(tuple(sorted(links)))
     if pattern is None:
         return escaped
 
     def swap(match: re.Match[str]) -> str:
         token = match.group(0)
-        name = anchors.get(token)
-        return f'<a href="#{name}">{token}</a>' if name else token
+        href = links.get(token)
+        return f'<a href="{escape(href)}">{token}</a>' if href else token
 
     return pattern.sub(swap, escaped)
 
 
-def inline_code(value: object, anchors: dict | None = None) -> Markup:
+def inline_code(value: object, links: dict | None = None) -> Markup:
     """Convert paired backticks to ``<code>``, escaping everything else.
 
     Workers author report prose with Markdown conventions, so an identifier
-    arrives wrapped in backticks. ``anchors`` links the row ids cited in the
+    arrives wrapped in backticks. ``links`` links the row ids cited in the
     prose, inside backticks and out.
     """
-    index = anchors or {}
+    index = links or {}
     text = "" if value is None else str(value)
     out: list[str] = []
     cursor = 0
@@ -84,7 +86,7 @@ def _grouped_paragraphs(text: str) -> list[str]:
     ]
 
 
-def paragraphs(value: object, anchors: dict | None = None) -> Markup:
+def paragraphs(value: object, links: dict | None = None) -> Markup:
     """Split prose into ``<p>`` blocks, converting inline code inside each.
 
     ``userNarrative`` prose arrives as one unbroken run of sentences, so the
@@ -93,27 +95,27 @@ def paragraphs(value: object, anchors: dict | None = None) -> Markup:
     """
     text = "" if value is None else str(value)
     return Markup(
-        "".join(f"<p>{inline_code(block, anchors)}</p>" for block in _grouped_paragraphs(text))
+        "".join(f"<p>{inline_code(block, links)}</p>" for block in _grouped_paragraphs(text))
     )
 
 
-def evidence_refs(refs: object, anchors: object) -> Markup:
-    """Render a citation list, anchoring the entries the document defines.
+def evidence_refs(refs: object, links: object) -> Markup:
+    """Render a citation list, linking the entries that have a target.
 
     The same index the prose links against decides here too — a citation and a
     mid-sentence mention of the same id must land in the same place. No schema
     behind this filter constrains an entry to an id: most of it is prose citing
     a ``path:line``, which takes ``inline_code`` like every other prose cell.
     """
-    index = anchors if isinstance(anchors, dict) else {}
+    index = links if isinstance(links, dict) else {}
     items = refs if isinstance(refs, (list, tuple)) else []
     out: list[str] = []
     for ref in items:
-        name = index.get(str(ref))
-        if name is None:
+        href = index.get(str(ref))
+        if href is None:
             out.append(str(inline_code(ref, index)))
             continue
-        out.append(f'<a href="#{name}">{escape(str(ref))}</a>')
+        out.append(f'<a href="{escape(href)}">{escape(str(ref))}</a>')
     return Markup(", ".join(out))
 
 

package/runtime/python/okstra_ctl/report_html/render.py

@@ -17,6 +17,7 @@ from ..report_view_artifacts import user_responses_dir_for_report
 from ..usage_cells import format_duration_ms
 from ..json_boundary import load_owned_object
 from .common import anchor_index
+from .context_links import brief_end_states, carry_in_links
 from .filters import (
     code_evidence,
     enum_label,
@@ -130,17 +131,26 @@ def render_v2_html_view(
     env = Environment(loader=FileSystemLoader(str(root)), autoescape=select_autoescape(("html",)), undefined=StrictUndefined)
     env.policies["json.dumps_kwargs"] = {"sort_keys": True, "ensure_ascii": False}
     # Binding the index here is what lets a template cite an id without
-    # threading the index through every macro and call site.
-    anchors = anchor_index(data, view.omitted_fields)
+    # threading the index through every macro and call site. The record's
+    # own rows come first; the brief's end-state rows and the carry-in
+    # report's clarifications only fill ids this page has no row for.
+    links = {
+        row_id: f"#{name}"
+        for row_id, name in anchor_index(data, view.omitted_fields).items()
+    }
+    brief_rows = brief_end_states(data_path)
+    for row in brief_rows:
+        links.setdefault(row["id"], f"#id-{row['id']}")
+    links.update(carry_in_links(data, data_path, exclude=links))
     chrome = load_dictionary(lang, HTML_DICTIONARY_REL)
     translate = make_jinja_global(chrome)
     env.globals["t"] = translate
     env.filters["code_evidence"] = code_evidence
     env.filters["enum_label"] = lambda value, vocabulary: enum_label(value, vocabulary, chrome)
     env.filters["enum_legend"] = lambda vocabulary: enum_legend(vocabulary, chrome)
-    env.filters["evidence_refs"] = lambda refs: evidence_refs(refs, anchors)
-    env.filters["inline_code"] = lambda value: inline_code(value, anchors)
-    env.filters["paragraphs"] = lambda value: paragraphs(value, anchors)
+    env.filters["evidence_refs"] = lambda refs: evidence_refs(refs, links)
+    env.filters["inline_code"] = lambda value: inline_code(value, links)
+    env.filters["paragraphs"] = lambda value: paragraphs(value, links)
     response_js = (root / "report.js").read_text(encoding="utf-8")
     base_js = (root / "html/assets/base.js").read_text(encoding="utf-8")
     source_data = final_report_data_path(Path(run_meta.source_report)).as_posix()
@@ -153,6 +163,9 @@ def render_v2_html_view(
         "sourceData": source_data,
         "dataSha256": _sha256(data_path),
         "clarificationItems": data.get("clarificationItems", []),
+        # 브리프의 최종 상태 행. 모든 phase 가 EB/PB/EO 아이디를 인용하지만
+        # 문장은 브리프에만 있으므로 여기서 한 번 그려 인용에 착지점을 준다.
+        "briefEndStates": brief_rows,
         # 합의·이견 근거는 태스크 본문과 같이 기본 화면에 올린다. 근거 대장
         # 감사 모드에만 두면 판정이 사용자에게 안 보인다.
         "crossVerification": data.get("crossVerification") or {},

package/runtime/python/okstra_ctl/report_html/view_models/implementation_option_selection.py

@@ -14,6 +14,13 @@ def build_implementation_option_selection_view(data: dict) -> HumanReportView:
             selection if selection["mode"] == "candidate-comparison" else None
         ),
         "narrative": selection["userNarrative"],
+        # 기준별 가중치. 옵션 카드의 점수 표가 기준 이름 옆에 가중치를 같이
+        # 보여야 가중 점수가 어떻게 나왔는지 읽힌다.
+        "criteriaWeights": {
+            criterion["criterion"]: criterion["weight"]
+            for criterion in selection.get("evaluationCriteria") or []
+            if isinstance(criterion, dict)
+        },
         "recommendedOption": next(
             (
                 option

package/runtime/python/okstra_ctl/report_synthesis_packet.py

@@ -198,6 +198,11 @@ class ReportSynthesisPacket:
             "supplied one feasibility vote, at least "
             f"{MIN_FEASIBLE_VOTES} votes are `feasible`, and both `safetyBlockers` "
             "and `unresolvedFeasibilityFacts` are empty.",
+            "Each `feasibilityVotes` row states that analyser's own verdict, "
+            "rationale, and strongest counterevidence as its result gives them. "
+            "Two non-`uncertain` votes with identical rationale and "
+            "counterevidence are rejected as one worker's text copied under "
+            "another's name.",
             f"Rank at most {MAX_RANKED_OPTIONS} valid options by descending "
             "`requirement-fit`, `correctness-risk`, `architecture-fit`, "
             "`weightedScore`, then id. With valid options set routing to "

package/runtime/python/okstra_ctl/report_translation.py

@@ -30,6 +30,7 @@ PROSE_KEYS = frozenset({
     "approach",
     "approvalDisposition",
     "approvalEvidence",
+    "architectureBoundaries",
     "behavior",
     "blastRadius",
     "blockReason",
@@ -41,13 +42,16 @@ PROSE_KEYS = frozenset({
     "change",
     "check",
     "claim",
+    "commitment",
     "condition",
     "confirmingSignal",
     "conformanceExemption",
     "consequences",
     "constraint",
     "context",
+    "coreMechanism",
     "coreReason",
+    "counterevidence",
     "decision",
     "declinedFixRecommendations",
     "description",
@@ -66,12 +70,15 @@ PROSE_KEYS = frozenset({
     "exitContractSummary",
     "expected",
     "expectedBehaviorAfter",
+    "expectedChangeAreas",
     "expectedForm",
     "expectedOutcome",
     "expectedResult",
     "expectedVerification",
+    "fact",
     "failureHandling",
     "finalConclusion",
+    "goal",
     "headline",
     "howToStart",
     "hypothesis",
@@ -134,6 +141,7 @@ PROSE_KEYS = frozenset({
     "verification",
     "verificationMethod",
     "verificationSignal",
+    "whyItMatters",
     "workingAssumption",
 })
 

package/runtime/python/okstra_ctl/scope_provenance.py

@@ -33,7 +33,9 @@ _END_STATE_ID_RE = re.compile(r"^(?:EB|PB|EO)-\d{3}$")
 _END_STATE_HEADINGS = frozenset(
     {"Expected Behavior", "Preserved Behavior", "Expected Outcome"}
 )
-_END_STATE_BULLET_RE = re.compile(r"^-\s+(?P<id>(?:EB|PB|EO)-\d{3})\b")
+_END_STATE_BULLET_RE = re.compile(
+    r"^-\s+(?P<id>(?:EB|PB|EO)-\d{3})\b\s*(?P<statement>.*)$"
+)
 # Only `## ` closes a section, mirroring validate-brief.py's section_body
 # lookahead. `_BRIEF_HEADING_RE` above matches `#` through `######` and is for
 # heading citations, which are checked against a different reader.
@@ -89,8 +91,21 @@ def brief_headings(brief_path: Path) -> set[str]:
     return headings
 
 
-def brief_end_state_id_sequence(brief_path: Path) -> tuple[str, ...]:
-    """End-state ids the brief declares, preserving section and item order.
+@dataclass(frozen=True)
+class BriefEndState:
+    """One `- EB-001 <statement>` bullet of the brief's end-state sections."""
+
+    id: str
+    # The normalized `## ` heading the bullet sits under — one of
+    # `_END_STATE_HEADINGS`.
+    section: str
+    # The rest of the bullet line, verbatim. The brief is the only place this
+    # sentence exists; every phase cites the id and none of them repeats it.
+    statement: str
+
+
+def brief_end_state_rows(brief_path: Path) -> tuple[BriefEndState, ...]:
+    """End-state rows the brief declares, preserving section and item order.
 
     The reading rules mirror validators/validate-brief.py exactly, because that
     file checks the very same lines for their format and the two readers must
@@ -116,7 +131,7 @@ def brief_end_state_id_sequence(brief_path: Path) -> tuple[str, ...]:
     except OSError:
         return ()
 
-    ids: list[str] = []
+    rows: list[BriefEndState] = []
     section = ""
     for line in text.splitlines():
         if m := _SECTION_HEADING_RE.match(line):
@@ -126,8 +141,15 @@ def brief_end_state_id_sequence(brief_path: Path) -> tuple[str, ...]:
         if not section:
             continue
         if m := _END_STATE_BULLET_RE.match(line.strip()):
-            ids.append(m.group("id"))
-    return tuple(ids)
+            rows.append(
+                BriefEndState(m.group("id"), section, m.group("statement").strip())
+            )
+    return tuple(rows)
+
+
+def brief_end_state_id_sequence(brief_path: Path) -> tuple[str, ...]:
+    """End-state ids the brief declares, preserving section and item order."""
+    return tuple(row.id for row in brief_end_state_rows(brief_path))
 
 
 def brief_end_state_ids(brief_path: Path) -> set[str]:

package/runtime/python/okstra_ctl/worker_audit_check.py

@@ -13,8 +13,16 @@ import sys
 from pathlib import Path
 
 from okstra_ctl.worker_audit_ledger import (
-    check_worker_results_audit,
     worker_result_files,
+    worker_results_audit_findings,
+)
+
+# Phase 7 은 같은 규칙을 두 등급으로 판정한다. 여기서 그 등급을 함께 내지 않으면
+# exit 2 하나로 "run 이 실패한다" 고 읽힌다 — 2026-09-05 실측(dev-10626 stage-1)에서
+# 리드가 권고 등급의 미매칭 인용을 차단 실패로 읽고 결과를 거절·재배치했다.
+RUN_IMPACT = (
+    "blocking rows fail the run at Phase 7 (validate-run); advisory rows do not "
+    "fail the run at Phase 7 and can only be fixed now, while the worker is alive"
 )
 
 
@@ -25,16 +33,19 @@ _CLI_EPILOG = r"""Usage:
   --run-dir    the run directory; worker-results/ and prompts/ hang off it
   --worker     check only this worker (default: every worker in the run)
 
-Emits one JSON object — `{ok, failures[]}` — and exits 2 when failures[] is
-non-empty, 0 otherwise.
+Emits one JSON object — `{ok, inspected, inspectedFiles[], failures[],
+blocking[], advisory[], runImpact}` — and exits 2 when failures[] is
+non-empty, 0 otherwise. `failures` is `blocking` followed by `advisory`.
 
 Runs the Phase 7 audit-sidecar rules now, while the worker session is still
 alive: that every result file carries no `## 0. Reading Confirmation` heading,
-that its audit sidecar exists, and that every backticked `path:line` citation
-has a matching Evidence read row in that sidecar.
+that its audit sidecar exists (blocking), and that every backticked `path:line`
+citation has a matching Evidence read row in that sidecar (advisory).
 
-Call it right after collecting a worker result. The same failure at Phase 7
-leaves only a retroactive edit — which breaks the audit chain — or a failed run.
+Exit 2 means "fix it now", not "the run fails": only `blocking` rows fail the
+run at Phase 7, and `advisory` rows are the ones nothing can repair once the
+worker session is gone. Do not reject or re-dispatch a result over an advisory
+row alone.
 """
 
 
@@ -58,9 +69,10 @@ def _parser() -> argparse.ArgumentParser:
 
 def main(argv: list[str] | None = None) -> int:
     args = _parser().parse_args(argv)
-    failures = check_worker_results_audit(
+    blocking, advisory = worker_results_audit_findings(
         args.run_dir, args.task_type, args.seq, worker=args.worker
     )
+    failures = blocking + advisory
     # A selector that narrows to nothing also produces no failures, so `ok`
     # alone cannot tell a real pass from a check that judged zero files —
     # a mistyped `--worker` used to read as a clean bill of health. The count
@@ -77,6 +89,9 @@ def main(argv: list[str] | None = None) -> int:
             "inspected": len(inspected),
             "inspectedFiles": inspected,
             "failures": failures,
+            "blocking": blocking,
+            "advisory": advisory,
+            "runImpact": RUN_IMPACT,
         },
         ensure_ascii=False,
         indent=2,

package/runtime/templates/reports/html/assets/base.css

@@ -31,6 +31,16 @@ nav.report-index a { color: inherit; }
 .tone-high, .tone-important { border-left-color: #d94b4b; }
 .tone-medium { border-left-color: #d79b25; }
 .evidence-refs { color: GrayText; font-size: .85rem; }
+.section-lede { max-width: 78ch; color: GrayText; margin-top: 0; }
+/* A direction card reads as four labelled blocks — what, how, why, expected
+   outcome — so each block carries its own heading and the lists inside stay
+   tight enough that the card does not read as one long table. */
+.option-detail { margin-top: 1rem; padding-top: .8rem; border-top: 1px solid color-mix(in srgb, CanvasText 12%, transparent); }
+.option-detail h4 { margin: 0 0 .4rem; font-size: 1rem; }
+.option-detail p { margin: .3rem 0; max-width: 78ch; }
+.option-detail ul { margin: .2rem 0 .6rem; padding-left: 1.3rem; }
+.option-detail table { margin-top: .5rem; }
+.direction-goal { margin: -.4rem 0 .7rem 1.6rem; color: GrayText; font-size: .9rem; max-width: 78ch; }
 figure { margin: 1rem 0 0; }
 figcaption { display: flex; flex-wrap: wrap; justify-content: space-between; gap: .5rem; margin-bottom: .7rem; }
 .visualization { overflow-x: auto; border-radius: 12px; background: color-mix(in srgb, CanvasText 4%, Canvas); }

package/runtime/templates/reports/html/base.template.html

@@ -44,6 +44,16 @@
   </header>
   <main id="main-content" data-report-role="human-main">
     {% block human_content %}{% endblock %}
+    {% if briefEndStates %}
+    <section data-report-section="brief-end-states">
+      <h2>{{ t('base.brief-end-states') }}</h2>
+      <p class="section-lede">{{ t('base.brief-end-states-intro') }}</p>
+      <table>
+        <thead><tr><th scope="col">{{ t('macros.layout.id') }}</th><th scope="col">{{ t('base.brief-statement') }}</th></tr></thead>
+        <tbody>{% for row in briefEndStates %}<tr id="id-{{ row.id }}">{{ row_key(pairs=[(t('macros.layout.id'), row.id), (t('base.brief-section'), row.section | enum_label('briefSection'))]) }}<td>{{ row.statement | inline_code }}</td></tr>{% endfor %}</tbody>
+      </table>
+    </section>
+    {% endif %}
     {% if crossVerification.get("consensus") or crossVerification.get("differences") %}
     <section data-report-section="cross-check">
       <h2>{{ t('base.cross-check') }}</h2>

package/runtime/templates/reports/html/i18n/en.json

@@ -89,6 +89,45 @@
       "missing-information": "Missing information",
       "follow-up": "Follow-up",
       "plan-item": "Plan item"
+    },
+    "optionCriterion": {
+      "requirement-fit": "Requirement fit",
+      "architecture-fit": "Architecture fit",
+      "change-locality": "Change locality",
+      "implementation-complexity": "Implementation complexity",
+      "correctness-risk": "Correctness risk",
+      "reversibility": "Reversibility",
+      "verification-cost": "Verification cost",
+      "rollout-cost": "Rollout cost"
+    },
+    "feasibilityVerdict": {
+      "feasible": "Feasible",
+      "not-feasible": "Not feasible",
+      "uncertain": "Uncertain"
+    },
+    "commitmentKind": {
+      "user-behavior": "User behavior",
+      "code-change": "Code change",
+      "migration": "Migration",
+      "operational-change": "Operational change",
+      "preserved-behavior": "Preserved behavior",
+      "derived-work": "Derived work"
+    },
+    "coverageVerdict": {
+      "exact": "exact",
+      "under": "under",
+      "over": "over",
+      "contradicted": "contradicted"
+    },
+    "safetyCategory": {
+      "data-loss": "Data loss",
+      "security-violation": "Security violation",
+      "irreversible-migration": "Irreversible migration"
+    },
+    "briefSection": {
+      "Expected Behavior": "Expected behavior",
+      "Preserved Behavior": "Preserved behavior",
+      "Expected Outcome": "Expected outcome"
     }
   },
   "enumHint": {
@@ -122,7 +161,11 @@
     "dismiss": "Dismiss",
     "export-downloads": "Export downloads",
     "drop-that-file-into": ". Drop that file into",
-    "and-the-next-run-picks-your-answers-up-on-it": "and the next run picks your answers up on its own."
+    "and-the-next-run-picks-your-answers-up-on-it": "and the next run picks your answers up on its own.",
+    "brief-end-states": "End states the brief pinned",
+    "brief-end-states-intro": "The requirement ids this report cites (EB, PB, EO) name these brief items, quoted verbatim from the task brief.",
+    "brief-section": "Section",
+    "brief-statement": "Statement"
   },
   "runUsage": {
     "heading": "What this run cost",
@@ -342,7 +385,33 @@
       "option-id": "Option ID",
       "direction": "Direction",
       "confirmation-evidence": "Confirmation evidence",
-      "citation": "Citation"
+      "citation": "Citation",
+      "upstream-decisions": "Upstream decisions:",
+      "evaluation-criteria": "Evaluation criteria",
+      "evaluation-criteria-intro": "Every candidate is scored 1 to 5 on each criterion. The weighted score is the weight-averaged result, so a criterion with weight 5 counts five times as much as one with weight 1.",
+      "criterion": "Criterion",
+      "weight": "Weight",
+      "score": "Score",
+      "why-it-matters": "Why it matters",
+      "what-changes": "What this direction changes",
+      "goal": "Goal:",
+      "goal-column": "Goal",
+      "change-areas": "Expected change areas",
+      "commitment": "Commitment",
+      "commitment-body": "What the direction commits to",
+      "requirements": "Requirements",
+      "how-it-works": "How it is done",
+      "boundaries": "Architecture boundaries it keeps",
+      "why-this-direction": "Why this direction",
+      "feasibility-votes": "Feasibility by worker",
+      "worker": "Worker",
+      "verdict": "Verdict",
+      "counterevidence": "Strongest counterevidence",
+      "safety-blockers": "Safety blockers",
+      "unresolved-facts": "Unresolved feasibility facts",
+      "expected-outcome": "Expected outcome",
+      "coverage-line": "Covers {covered} of {total} requirements ({verdict}).",
+      "planning-invariants": "Must hold in planning"
     },
     "implementation-planning": {
       "what-the-plan-is-for": "What the plan is for",

package/runtime/templates/reports/html/i18n/ko.json

@@ -89,6 +89,45 @@
       "missing-information": "빠진 정보",
       "follow-up": "후속 작업",
       "plan-item": "계획 항목"
+    },
+    "optionCriterion": {
+      "requirement-fit": "요구사항 적합",
+      "architecture-fit": "아키텍처 적합",
+      "change-locality": "변경 국소성",
+      "implementation-complexity": "구현 복잡도",
+      "correctness-risk": "정확성 위험",
+      "reversibility": "되돌리기 쉬움",
+      "verification-cost": "검증 비용",
+      "rollout-cost": "배포 비용"
+    },
+    "feasibilityVerdict": {
+      "feasible": "실행 가능",
+      "not-feasible": "실행 불가",
+      "uncertain": "불확실"
+    },
+    "commitmentKind": {
+      "user-behavior": "사용자 동작",
+      "code-change": "코드 변경",
+      "migration": "마이그레이션",
+      "operational-change": "운영 변경",
+      "preserved-behavior": "보존 동작",
+      "derived-work": "파생 작업"
+    },
+    "coverageVerdict": {
+      "exact": "정확히 일치",
+      "under": "미달",
+      "over": "초과",
+      "contradicted": "모순"
+    },
+    "safetyCategory": {
+      "data-loss": "데이터 손실",
+      "security-violation": "보안 위반",
+      "irreversible-migration": "되돌릴 수 없는 마이그레이션"
+    },
+    "briefSection": {
+      "Expected Behavior": "기대 동작",
+      "Preserved Behavior": "보존 동작",
+      "Expected Outcome": "기대 산출"
     }
   },
   "enumHint": {
@@ -122,7 +161,11 @@
     "dismiss": "닫기",
     "export-downloads": "내보내면 다음 파일이 받아집니다",
     "drop-that-file-into": ". 그 파일을 여기에 두면",
-    "and-the-next-run-picks-your-answers-up-on-it": "다음 run 이 알아서 답변을 읽어 갑니다."
+    "and-the-next-run-picks-your-answers-up-on-it": "다음 run 이 알아서 답변을 읽어 갑니다.",
+    "brief-end-states": "브리프가 고정한 최종 상태",
+    "brief-end-states-intro": "이 리포트가 인용하는 요구사항 아이디(EB·PB·EO)는 브리프의 다음 항목입니다. 문장은 태스크 브리프 원문 그대로입니다.",
+    "brief-section": "절",
+    "brief-statement": "내용"
   },
   "runUsage": {
     "heading": "이번 실행에 든 비용",
@@ -342,7 +385,33 @@
       "option-id": "옵션 아이디",
       "direction": "방향",
       "confirmation-evidence": "확인 근거",
-      "citation": "인용"
+      "citation": "인용",
+      "upstream-decisions": "선행 결정:",
+      "evaluation-criteria": "평가 기준",
+      "evaluation-criteria-intro": "모든 후보를 기준마다 1~5점으로 매깁니다. 가중 점수는 가중치를 반영한 평균이라, 가중치 5인 기준은 가중치 1인 기준의 다섯 배로 반영됩니다.",
+      "criterion": "기준",
+      "weight": "가중치",
+      "score": "점수",
+      "why-it-matters": "왜 중요한가",
+      "what-changes": "무엇을 바꾸는가",
+      "goal": "목표:",
+      "goal-column": "목표",
+      "change-areas": "예상 변경 영역",
+      "commitment": "약속",
+      "commitment-body": "이 방향이 약속하는 것",
+      "requirements": "요구사항",
+      "how-it-works": "어떻게 구현하는가",
+      "boundaries": "지키는 아키텍처 경계",
+      "why-this-direction": "왜 이 방향인가",
+      "feasibility-votes": "작업자별 실행 가능성",
+      "worker": "작업자",
+      "verdict": "판정",
+      "counterevidence": "가장 강한 반대 근거",
+      "safety-blockers": "안전 차단 요인",
+      "unresolved-facts": "미확정 실행 가능성 사실",
+      "expected-outcome": "예상 결과",
+      "coverage-line": "요구사항 {total}개 중 {covered}개를 충족합니다({verdict}).",
+      "planning-invariants": "계획에서 지켜야 할 조건"
     },
     "implementation-planning": {
       "what-the-plan-is-for": "이 계획이 하려는 것",

package/runtime/templates/reports/html/macros/forms.html

@@ -47,6 +47,7 @@
   <fieldset><legend>{{ t('macros.forms.direction') }}</legend>
     {% for option in state.rankedOptions %}
     <input id="direction-selection-{{ option.id }}" type="radio" name="direction-selection-option" value="{{ option.id }}" data-option-name="{{ option.name }}" required><label for="direction-selection-{{ option.id }}">{{ option.id | inline_code }} · {{ option.name | inline_code }}{% if option.id == state.recommendedOptionId %} ({{ t('macros.forms.recommended') }}){% endif %}</label>
+    <p class="direction-goal">{{ option.goal | inline_code }}</p>
     {% endfor %}
   </fieldset>
   <input id="direction-selection-confirmed" type="checkbox" required><label for="direction-selection-confirmed">{{ t('macros.forms.confirmed') }}</label>