okstra 0.189.0 → 0.189.2

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/run.py

@@ -38,6 +38,7 @@ from okstra_project import project_json_path, upsert_project_json
 from okstra_project.slug import slugify
 from . import fix_cycles
 from .analysis_packet import build_analysis_packet
+from . import group_context
 from .stage_ledger import (
     build_stage_ledger,
     render_stage_ledger,
@@ -1363,6 +1364,23 @@ def _validate_task_brief_preflight(
         )
 
 
+def _validate_group_context_preflight(project_root: Path, task_group: str) -> None:
+    """그룹 맥락 문서가 있으면 검증한다. 없으면 선택적 입력이라 아무 일도 없다.
+
+    채우지 않은 뼈대가 워커에 닿으면 자리표시자를 배경으로 읽으므로, 있는데 결함이면
+    prepare 를 멈추고 채우거나 지우라고 말한다."""
+    path = group_context.group_context_file(project_root, task_group)
+    if not path.is_file():
+        return
+    errors = group_context.validate_group_context(path, group_context.briefs_root(project_root))
+    if errors:
+        raise PrepareError(
+            f"task-group context failed validation ({path}): "
+            + "; ".join(errors)
+            + " — fill the file, or delete it if the group needs no context"
+        )
+
+
 def _validate_prepare_inputs(project_root: Path, inp: PrepareInputs) -> list:
     """Validate pure prepare inputs and return a final-verification stage map."""
     if not project_root.is_dir():
@@ -3599,6 +3617,14 @@ def _write_instruction_set_sources(
         )
     (instruction_set / "analysis-material.md").write_text(review_material, encoding="utf-8")
     shutil.copyfile(inp.brief_path, instruction_set / "task-brief.md")
+    # 그룹 맥락은 preflight 를 통과한 파일만 여기 온다(`_validate_group_context_preflight`).
+    group_context_source = group_context.group_context_file(
+        Path(inp.project_root), inp.task_group
+    )
+    group_context_path: Path | None = None
+    if group_context_source.is_file():
+        group_context_path = instruction_set / group_context.INSTRUCTION_SET_FILENAME
+        shutil.copyfile(group_context_source, group_context_path)
     # A rule that lives only in the conversation is one compaction away from
     # gone, with no signal that it went. On disk it survives, and the session
     # conformance check can ask afterwards whether it was read. The token is
@@ -3664,6 +3690,7 @@ def _write_instruction_set_sources(
         task_key=ctx["TASK_KEY"],
         task_type=ctx["TASK_TYPE"],
         task_brief_path=instruction_set / "task-brief.md",
+        group_context_path=group_context_path,
         analysis_profile_path=instruction_set / "analysis-profile.md",
         reference_expectations_path=instruction_set / "reference-expectations.md",
         clarification_response_path=(
@@ -4547,6 +4574,7 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
             inp.brief_path,
             assets.brief_validator,
         )
+    _validate_group_context_preflight(project_root, inp.task_group)
     selected_direction = _resolve_planning_direction(inp)
     if inp.task_type == "implementation":
         ctx_stage_map = _prepare_implementation_approved_plan(inp)

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/timeline_runs.py

@@ -0,0 +1,71 @@
+"""timeline.json 의 run 항목을 그 run 의 현재 사실로 읽는 read-side 투영.
+
+timeline 항목은 prepare 가 한 번 쓴다 — `render.render_timeline` 의 호출자는
+`run._finalize_status_and_render_manifests` 뿐이다. run 이 끝날 때 상태를 쓰는
+곳은 `validators/validate-run.py` 이고, 그 코드는 run-manifest(`status`,
+`validation`, `workflowSnapshot`)와 task-manifest 만 고친다. 그래서 timeline
+항목의 `status` 는 언제나 준비 시점 값(`prepared` / `in-progress`)이고
+`workflowSnapshot` 은 준비 시점 스냅샷이다(2026-09-04 실측, dev-10626: 항목
+6개 전부 `prepared`, 같은 run 의 run-manifest 4개는 `completed`). 같은 run 의
+현재 사실은 그 run 의 run-manifest 가 가지므로, 읽는 쪽은 그것을 권위로 삼는다.
+
+`reportRecordPath` 도 예약이다. 항목이 적는 값은 이번 run 의 기대 리포트 경로인데
+리포트 seq 는 파일 존재로 배정되므로, 준비만 되고 돌지 않은 run 의 seq 를 다음
+run 이 이어받는다(같은 실측: error-analysis run 001·002 가 같은
+`final-report-error-analysis-001.data.json` 을 적었고 파일은 002 가 썼다).
+validate-run 이 그 run 의 리포트를 검증했을 때(`validation.status` 가 `not-run`
+이 아닐 때)만 그 경로가 그 run 의 리포트다.
+
+task 단위 현재 사실(`currentStatus`, `latestRunStatus`, `workflow.*`,
+`latestReportRecordPath`)은 task-manifest 가 권위다. 이 모듈은 run 단위만 다룬다.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Mapping
+
+from .json_boundary import JsonBoundaryError, load_owned_object
+from .paths import resolve_under_root
+
+VALIDATION_NOT_RUN = "not-run"
+
+
+def current_run_facts(project_root: Path, run: Mapping[str, Any]) -> dict[str, Any]:
+    """timeline 항목에 그 run 의 run-manifest 가 기록한 현재 사실을 덮어쓴 사본.
+
+    - `status`, `workflowSnapshot`: run-manifest 값. 키가 없으면 항목 값 그대로.
+    - `reportRecordPath` / `reportPath`: run-manifest 의 `validation.status` 가
+      `not-run` 이면 비운다 — 그 run 은 리포트를 낸 적이 없고 경로는 예약이다.
+      `validation` 블록이 없는 매니페스트는 판정 근거가 없으므로 그대로 둔다.
+
+    run-manifest 가 없으면(`runManifestPath` 가 비었거나 파일이 없으면) 항목을
+    그대로 돌려준다. 있는데 읽을 수 없으면 `JsonBoundaryError` 가 그대로 올라간다
+    — 투영이 잘못된 파일을 조용히 건너뛰면 그 run 만 준비 시점 값으로 남는다.
+    """
+    entry = dict(run)
+    manifest = _run_manifest(project_root, run)
+    if manifest is None:
+        return entry
+    status = manifest.get("status")
+    if isinstance(status, str) and status:
+        entry["status"] = status
+    snapshot = manifest.get("workflowSnapshot")
+    if isinstance(snapshot, Mapping):
+        entry["workflowSnapshot"] = dict(snapshot)
+    validation = manifest.get("validation")
+    if isinstance(validation, Mapping) and validation.get("status") == VALIDATION_NOT_RUN:
+        entry["reportRecordPath"] = ""
+        entry["reportPath"] = ""
+    return entry
+
+
+def _run_manifest(project_root: Path, run: Mapping[str, Any]) -> Mapping[str, Any] | None:
+    relative = run.get("runManifestPath")
+    if not isinstance(relative, str) or not relative:
+        return None
+    path = resolve_under_root(project_root, relative)
+    if path is None:
+        raise JsonBoundaryError(Path(relative), "run manifest", "outside this project")
+    if not path.is_file():
+        return None
+    return load_owned_object(path, artifact="run manifest")

package/runtime/python/okstra_ctl/wizard.py

@@ -70,6 +70,7 @@ from okstra_ctl.role_requirements import (
 )
 from okstra_ctl.ids import slugify_task_segment
 from okstra_ctl.brief_frontmatter import read_brief_frontmatter
+from okstra_ctl.group_context import is_group_context_file
 from okstra_ctl.analysis_inputs import (
     ANALYSIS_TASK_TYPES,
     AnalysisInputError,
@@ -2525,7 +2526,7 @@ def _suggest_group_briefs(state: WizardState, limit: int = 6) -> list[str]:
     used_at_by_relpath = _recently_used_brief_times(state)
     candidates: list[tuple[float, str]] = []
     for path in root.rglob("*.md"):
-        if not path.is_file():
+        if not path.is_file() or is_group_context_file(path):
             continue
         tg_suggestion, _ = _brief_suggestions(path)
         if tg_suggestion:

package/runtime/skills/okstra-brief-gen/SKILL.md

@@ -993,10 +993,38 @@ briefs saved (N):
 next: /okstra-run            (run a separate task-key per brief — use the filename stem as task-id)
 ```
 
+### 7a. Task-group context (once per task-group)
+
+Before printing the hand-off block, check whether
+`<PROJECT_ROOT>/.okstra/briefs/<task-group>/group-context.md` exists. That
+file is the one document every task in the group shares — why the group
+exists, how its result is measured (with the denominator named), group-wide
+constraints, ticket relations — and no single brief can recover it
+(observed: a 15-brief group whose reason, "the origin keeps going down under
+attack traffic", appeared in none of them, so option selection measured a
+per-page ratio instead of origin load). If the file is absent, ask once via
+`AskUserQuestion`:
+
+- `Create the group context skeleton now (Recommended for a new task-group)`
+  → run `okstra group-context init --project-root <PROJECT_ROOT> --task-group <task-group>`
+  and echo its output verbatim. The skeleton carries one `<...>` placeholder
+  line per section; the user fills it. `/okstra-run` refuses to prepare any
+  task in the group while a placeholder line remains.
+- `Skip — this group needs no shared context`.
+
+Never fill the skeleton yourself from the tickets: a ticket summary decides
+nothing, and the sections ask for what the tickets do not say. If the file
+exists, leave it untouched and mention its path in the hand-off block.
+
 Then stop. Do not invoke `okstra-run` directly — the user chooses when to
 proceed, and they may want to edit the brief externally first. In the
 multi-brief case the user also decides the order in which tasks are
-started.
+started. When a skeleton was created in 7a, add one line to the hand-off
+block:
+
+```
+group context skeleton: <abs>/<task-group>/group-context.md   (fill before /okstra-run)
+```
 
 ## Output Rules
 

package/runtime/skills/okstra-inspect/facets/history.md

@@ -36,6 +36,7 @@ When a user selects a specific task:
 
 1. Run `okstra model-io history-input --project-root <projectRoot> --task-ref <task-key>`.
 2. Use each numbered run block for chronological status, report, run-manifest, and resume paths.
+   `Status` is the run's current status from its own run-manifest (the timeline entry itself only records the prepare-time value). `Report` is `-` for a run that never validated a report — a prepared run that was superseded before it ran — so two runs never share one report in this list.
 
 ```markdown
 ## Runs for <task-key>

package/runtime/skills/okstra-inspect/facets/recap.md

@@ -22,7 +22,7 @@ Use the CLI output as the source of truth:
 okstra model-io recap-input --project-root <projectRoot> --task-ref <resolved-target>
 ```
 
-Read the fixed-text `Run count` and repeated `Transition` blocks. Narrate each block's `From phase → To phase`, `Status`, `Last completed phase`, `Next phase`, and `Report` in the emitted chronological order. If `Run count: 0`, answer only "This task has no recorded runs." and do not claim to have read any file.
+Read the fixed-text `Run count` and repeated `Transition` blocks. Narrate each block's `From phase → To phase`, `Status`, `Last completed phase`, `Next phase`, and `Report` in the emitted chronological order. `Status`, `Last completed phase`, and `Next phase` are each run's end state from its own run-manifest, so a `prepared` transition is a run that was prepared and never ran, and it carries no `Report`. If `Run count: 0`, answer only "This task has no recorded runs." and do not claim to have read any file.
 
 `Next phase` is already a fixed scalar projection. Narrate it when non-empty, and otherwise use `Next phase status`: `pending` means that run did not settle the route, `blocked` means it stopped on something outside the run, and `terminal` means the lifecycle ended there.
 

package/runtime/templates/reports/group-context.template.md

@@ -0,0 +1,31 @@
+---
+type: group-context
+task-group: <task-group>
+created: <YYYY-MM-DD>
+generator: okstra-brief-gen
+---
+
+# Task-Group Context: <task-group>
+
+> Shared by every task in this task-group. okstra copies it into each run's
+> `instruction-set/task-group-context.md` and carries it in the analysis
+> packet's `## Task-Group Context` section, ahead of the brief extract.
+> Write only what no single ticket can recover — a summary of the tickets
+> decides nothing. Preparation refuses this file while any `<...>`
+> placeholder line remains; delete the file instead if the group needs none.
+
+## Why This Group Exists
+
+<The situation that created this group: what keeps happening, to whom, and why it takes a group of tickets rather than one. Not a summary of the tickets.>
+
+## Definition of Better
+
+<The measure the whole group is judged by, as a quantity and its direction. Name the denominator explicitly: a per-page ratio and a fleet-wide count are different measures, and a run that has only one of them will reason from it.>
+
+## Group-Wide Constraints
+
+<Rules every task in the group must respect, one bullet each, so no brief has to repeat them. Write `_(none)_` when there are none.>
+
+## Ticket Relations
+
+<Which tickets are causes, which are observation means, which depend on which. Write `_(none)_` when the briefs' Related Task Graph already says it all.>

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>