okstra 0.189.1 → 0.189.2

package/docs/architecture.md

@@ -877,6 +877,8 @@ The Phase 7 `render-views` step accepts either a final-report data.json or its M
 - **Human summary**: `humanSummary` is the sole v2 top-level human summary contract. It is not copied into AI Markdown. Each task view decides how to present it together with the task deliverable instead of sharing a generic dashboard body.
 - **Audit isolation**: worker execution, convergence, and token/cost material remain available for traceability but are subordinate to the user's findings and decisions. They never replace the task analysis narrative.
 - **Implementation-planning activity**: activity-contract reports show each agent's task, summary, and outcome in the default view. Commands, exit codes, file-and-line evidence, and result paths remain inside expandable detail. Approval decision cards link to the relevant `id-A-NNN` activity anchors and preserve each option's disposition in the exported user response.
+- **Cited ids resolve to a home**: every id the record defines is an in-page anchor (`#id-<id>`; cross-check consensus and dissent cards are `#id-xv-<id>`), and prose, citation lists, and table cells link to it (`report_html/common.py` `anchor_index`, `report_html/filters.py`). Two id families are cited everywhere and defined nowhere in the record, so the renderer follows the two pointers the run pinned (`report_html/context_links.py`): the brief's end-state rows (`EB`/`PB`/`EO`) are read from `<task>/instruction-set/task-brief.md` and rendered once as the "End states the brief pinned" section with `#id-EB-001` anchors, and the clarification ids a previous run settled link to that run's page through `clarificationCarryIn.sourceFile` (`../../<type>/reports/final-report-<type>-<seq>.html#id-C-005`). A missing file yields no rows and no links, never a render failure. An id several rows of the task block share — a direction's `IC-`/`PI-` rows are numbered from 001 inside each direction — has no single home and stays plain text.
+- **Implementation-option-selection cards**: each ranked direction reads as four blocks — what it changes (goal, expected change areas, scope commitments), how it is done (core mechanism, architecture boundaries), why it ranks where it does (criterion scores beside the criterion weights, feasibility votes with counterevidence, safety blockers, unresolved facts), and the expected outcome (coverage count and verdict, requirement coverage, planning invariants). The evaluation criteria and their weights render as their own section before the ranking, the direction picker shows each option's goal, and the candidate audit shows each rejected candidate's goal.
 - **Schema v1 compatibility**: existing v1 data and quick Markdown reports keep the legacy conditional renderer, including `readerSummary`, reader modes, and the original Markdown-parsing path.
 - **`C-*` select option order (schema v1)**: the legacy renderer parses `Expected form`, puts the `Recommended:` answer **first**, and relabels the `Alternatives:` items consecutively as `(a)`, `(b)`, and so on (the original character labels are not retained). Schema v2 parses nothing here — a `Kind=decision` row carries `options[]`, and the presentation order is the array order with the `role: recommended` entry first.
 

package/docs/cli.md

@@ -841,7 +841,7 @@ The `okstra` Node CLI (`bin/okstra`) provides both installer/admin commands and
 | `okstra team dispatch --project-root <dir> --run-manifest <path> [--workers <csv>] [--jobs-file <path>] [--dry-run]` / `okstra team await --project-root <dir> --run-manifest <path> [--json]` / `okstra team teardown --project-root <dir> --run-manifest <path> [--dry-run] [--json]` | Read a `leadRuntime=external` run manifest and dispatch, await, or tear down pane-backed workers. Default dispatch excludes report writer; Phase 6 selects it explicitly, and mixed analysis/report jobs are rejected. If a pane cannot be opened, gracefully degrade to the CLI wrapper and record the fallback in `workerDispatches[].degradedFrom` |
 | `okstra agent-activity append --project-root <dir> --run-manifest <path> --kind <kind> --agent <assigned-id> (--summary <text>\|--summary-file <markdown>) --outcome <outcome> [--plan-item-id <current-id>]… [--command <text> --command-cwd <dir> --command-exit-code <n> --command-output-file <markdown>] [--request-ref <returned-ref>]` | Append one structured activity after checking the agent against this run's role assignments and every plan item against its current convergence state. Python returns an `activityRequestRef`; supply only that returned value with `--request-ref` to retry idempotently. A new call without it remains a distinct activity even with identical contents. Legacy JSON command records remain automation compatibility only. |
 | `okstra agent-activity project --project-root <dir> --run-manifest <path> --data <data.json>` | Project this run's canonical activity events into `agentActivity[]`. The command preserves event order, rejects duplicate or decreasing activity IDs, and replaces no other report field. A historical manifest without `activityContractVersion: 1` returns an empty projection and leaves data.json unchanged. Normal Phase 7 execution reaches this behavior through `report-finalize`; use the standalone command only for diagnostics. |
-| `okstra approval-decision <open\|resolve\|carry> --ledger <approval-decisions.json> …` | Write the lead-owned clarification and approval ledger. `open` validates classification-specific dispositions and complete option fields, `resolve` requires real `A-NNN` check references, and `carry` keeps prior resolved decisions outside the active clarification list. `carry --from-responses <instruction-set/clarification-response.md>` is the source of truth for an answer given in an earlier run: the bundle is task-level and cumulative, each response section names the report that posed the question, and `--clarification-id` repeats to carry several ids in one call. `carry --source-ledger` remains for a prior run's ledger that is still on disk and needs `--source-run-ref`. |
+| `okstra approval-decision <open\|resolve\|carry> --ledger <approval-decisions.json> …` | Write the lead-owned clarification and approval ledger. `open` validates classification-specific dispositions and complete option fields, `resolve` requires real `A-NNN` check references, and `carry` keeps prior resolved decisions outside the active clarification list. `carry --from-responses <instruction-set/clarification-response.md>` is the source of truth for an answer given in an earlier run: the bundle is task-level and cumulative, each response section names the report that posed the question, and `--clarification-id` repeats to carry several ids in one call. `carry --source-ledger` remains for a prior run's ledger that is still on disk and needs `--source-run-ref`. Prepare seeds `carriedDecisions[]` itself when it creates a run's ledger from a `--clarification-response` that names a report record — every row that record answered or resolved, plus rows its user-responses sidecars answered (`scripts/okstra_ctl/approval_decisions.py` `seed_carried_decisions`) — so `carry` is for ids that record does not answer. |
 | `okstra design-snapshot --narrative <report-narrative.md> --output <design-preparation.json>` | Detect implementation-planning design surfaces and write the detector-owned snapshot consumed by final report assembly. |
 | `okstra plan-verify --narrative <report-narrative.md> --state <plan-body-verification.json>` | Recompute the plan-body gate from the convergence-owned state before `data.json` publication. `--report <historical-data.json>` remains the v2 reader. |
 | `okstra report-finalize --project-root <dir> --run-manifest <path> --report <final-report.md>` | Run Phase 7 in the manifest's contract order. Contract v3 collects usage into team state, assembles all single-owner inputs into `data.json` once, then checks, renders, spawns follow-ups, validates, and tears down eligible stage worktrees. Contract v2 retains its historical in-place projection sequence as a read-only compatibility path. A failed step still runs every later check through `validate-run`; only `teardown-stages` is skipped so a failed run does not reclaim worktrees. Reports each step and prints the ordered `--only` recovery tail from the earliest failure. This is the shared path for every lead adapter. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.189.1",
+  "version": "0.189.2",
   "description": "Host-aware multi-provider cross-verification orchestrator runtime and agent skills.",
   "license": "MIT",
   "author": "devonshin",

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.189.1",
-  "builtAt": "2026-09-04T19:05:25.979Z",
+  "package": "0.189.2",
+  "builtAt": "2026-09-04T22:24:35.201Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/prompts/duties/direction-selection-worker.md

@@ -13,7 +13,7 @@ Compare feasible directions before planning in `candidate-comparison` mode, or v
 
 ## Required conduct
 
-In `candidate-comparison` mode, inspect the evidence needed to distinguish candidates, submit no more than three candidates, state the strongest counterevidence for each one, and map every candidate to the stable brief end-state IDs it satisfies, preserves, or leaves unresolved. In `preselected-validation` mode, validate the one preselected direction against that evidence and mapping; the worker must not generate new candidates.
+In `candidate-comparison` mode, inspect the evidence needed to distinguish candidates, submit no more than three candidates, give each one a feasibility verdict (`feasible`, `not-feasible`, or `uncertain`) with a one-sentence rationale, state the strongest counterevidence for each one, and map every candidate to the stable brief end-state IDs it satisfies, preserves, or leaves unresolved. In `preselected-validation` mode, validate the one preselected direction against that evidence and mapping with the same verdict; the worker must not generate new candidates.
 
 ## Decision principles
 
@@ -33,7 +33,7 @@ Reason independently from other workers. Do not collapse overlapping candidates
 
 ## Completion criteria
 
-In `candidate-comparison` mode, every submitted candidate has a criterion score, counterevidence, and stable requirement mapping. In `preselected-validation` mode, the one preselected direction has a validation result, counterevidence, and stable requirement mapping. Rejected candidates retain their audit reason and evidence.
+In `candidate-comparison` mode, every submitted candidate has a criterion score, a feasibility verdict with its rationale, counterevidence, and stable requirement mapping. In `preselected-validation` mode, the one preselected direction has a validation result, a feasibility verdict with its rationale, counterevidence, and stable requirement mapping. Rejected candidates retain their audit reason and evidence.
 
 ## Forbidden conduct
 

package/runtime/prompts/lead/report-writer.md

@@ -24,7 +24,7 @@ Report assembly reads the role-owned inputs, validates them, derives links and s
 
 An active clarification exists only in `activeClarifications[]`. A decision carried from a previous run exists only in `carriedDecisions[]`; do not recreate it as an active question.
 
-A carried plan row's `requirementCoverage[].decisionRefs` may name a `C-NNN` this run never asked. Carry it before assembly: `okstra approval-decision carry --ledger <approvalDecisionsPath> --from-responses <instruction-set/clarification-response.md> --clarification-id C-NNN` — repeat `--clarification-id` to take several in one call. That bundle is the source of truth for an earlier run's answer: it is task-level and cumulative, so no prior run seq has to be located, and each response section names the report that posed the question, which is where the row's `statement`, `expectedForm`, and options come from. A carried row lands as `answered`, not `resolved` — it was resolved in another run, and `resolution.checkRefs` names *this* run's activity rows. Carrying an answer also obliges a `supersessionLedger` entry for it.
+Prepare seeds `carriedDecisions[]` when it creates the ledger: every clarification the run's carry-in record answered or resolved, plus every row that record's user-responses sidecars answered, arrives carried (`scripts/okstra_ctl/approval_decisions.py` `seed_carried_decisions`). A carried plan row's `requirementCoverage[].decisionRefs` may still name a `C-NNN` the carry-in record does not answer — a decision from an older run. Carry it before assembly: `okstra approval-decision carry --ledger <approvalDecisionsPath> --from-responses <instruction-set/clarification-response.md> --clarification-id C-NNN` — repeat `--clarification-id` to take several in one call. That bundle is the source of truth for an earlier run's answer: it is task-level and cumulative, so no prior run seq has to be located, and each response section names the report that posed the question, which is where the row's `statement`, `expectedForm`, and options come from. A carried row lands as `answered`, not `resolved` — it was resolved in another run, and `resolution.checkRefs` names *this* run's activity rows. Carrying an answer also obliges a `supersessionLedger` entry for it.
 
 Each decision option has `role`, `answer`, `rationale`, `disposition`, `reach`, optional `scopeEffects`, `addedWork`, and `directionChange`. `reach` is exactly one of `in-repo` or `cross-repo`. `scopeEffects` may contain `new-schema` and `deferrable`. A `correctness-critical` option cannot use `select` or `accept-risk`; a `noncritical-dissent` option cannot use `select`.
 

package/runtime/prompts/profiles/_clarification-recommendation.md

@@ -8,7 +8,7 @@
     - `directionChange` — one sentence naming what this choice reverses: an approved plan item, a recorded decision, an earlier answer. Name that item. When it reverses nothing, say so.
     - `disposition` — the effect of selecting the option. Use `select` for `user-decision`. Use `accept-risk` on any classification, including `correctness-critical`, when the user ends the gate and leaves the DISAGREE on the record. Use `request-revision` or `reject` when the option sends the plan back.
   - report assembly derives `approvalContext`, status, and resolution. `approvalContext` contains only `classification`, `unblockCondition`, and `recommendedDisposition`; it never copies plan or activity identifiers.
-  - a `C-NNN` you name outside the row itself must be a row that exists. One place is checked: a `blocked` `endStateCoverage` row's `blockedBy.ref`, when its `kind` is `clarification` — see each phase profile's `blockedBy` rule and `validators/validate-run.py` `_validate_end_state_blocked_by`. Everywhere else — `coveredBy`, `rationale`, `verdictCard.nextStep`, `finalVerdict.nextStep`, `humanSummary.actions[]`, `recommendedNextSteps[].text` — is free prose and stays uncheckable: a shipped report legitimately writes `C-057 through C-068 are applied or carried` or `C-201 does not apply`, and a validator scanning those fields for ids would fail 15 of the 56 reports on disk. There it is on you not to send a reader after an id with no row. An id an earlier run already answered is admitted with `okstra approval-decision carry`, not by citing it bare. `crossVerification` rows are numbered `CV-NNN` so a `C-NNN` has exactly one meaning.
+  - a `C-NNN` you name outside the row itself must be a row that exists. One place is checked: a `blocked` `endStateCoverage` row's `blockedBy.ref`, when its `kind` is `clarification` — see each phase profile's `blockedBy` rule and `validators/validate-run.py` `_validate_end_state_blocked_by`. Everywhere else — `coveredBy`, `rationale`, `verdictCard.nextStep`, `finalVerdict.nextStep`, `humanSummary.actions[]`, `recommendedNextSteps[].text` — is free prose and stays uncheckable: a shipped report legitimately writes `C-057 through C-068 are applied or carried` or `C-201 does not apply`, and a validator scanning those fields for ids would fail 15 of the 56 reports on disk. There it is on you not to send a reader after an id with no row. An id an earlier run already answered reaches this report as a carried decision — prepare seeds `carriedDecisions[]` from the run's carry-in record, and `okstra approval-decision carry` admits one that record does not answer — never by citing it bare. `crossVerification` rows are numbered `CV-NNN` so a `C-NNN` has exactly one meaning.
   - the three impact fields answer three different questions — how far the change reaches, what new work it creates, and what it overturns. Someone choosing between options needs all three, so never fold them into one sentence: whichever axis is easiest to write would silently stand in for the other two.
   - a row that omits `options[]`, offers fewer than two, or marks zero or two options as `recommended` is incomplete and must be completed before the report is finalised.
   - `expectedForm` states only the *shape* of the answer — one of the options, a file path, a number, a date. It never lists the choices again; two sources for one fact leave consumers disagreeing about which is authoritative.

package/runtime/prompts/profiles/implementation-option-selection.md

@@ -34,9 +34,9 @@ roles:
   - Apply the shared reporter-confirmation precondition exactly as written. Unresolved `intent-check:` and `conversion-block:` rows use `Blocks=next-phase`.
   - Treat each stable brief end-state ID as a required evaluation target. A missing ID is a preparation failure; do not invent a replacement requirement.
 - Worker direction-selection procedure:
-  - In `candidate-comparison` mode, produce candidate, supporting and contradicting evidence, criterion scores, and requirement mappings.
+  - In `candidate-comparison` mode, produce candidate, supporting and contradicting evidence, criterion scores, and requirement mappings. For every candidate, state one feasibility verdict — `feasible`, `not-feasible`, or `uncertain` — with a one-sentence rationale and the strongest counterevidence, each citing inspected evidence. The report's `feasibilityVotes` row for this worker is built from that statement, so a candidate without one leaves the writer nothing but another worker's words.
   - In `candidate-comparison` mode only, submit at most three candidates. A candidate must be feasible from inspected evidence, not from an assumed future change.
-  - In `preselected-validation` mode, receive one preselected direction from the lead and validate its evidence, counterevidence, criterion scores, and requirement mappings. The worker must not generate new candidates.
+  - In `preselected-validation` mode, receive one preselected direction from the lead and validate its evidence, counterevidence, criterion scores, and requirement mappings, and state the same feasibility verdict with its rationale and counterevidence. The worker must not generate new candidates.
   - Do not produce detailed file lists, stage maps, execution commands, or a plan approval request.
 - Pre-selection context exploration:
   - In `candidate-comparison` mode, inspect the code paths, interfaces, tests, and constraints needed to distinguish candidates before assigning scores.

package/runtime/python/okstra_ctl/approval_decisions.py

@@ -12,6 +12,7 @@ from pathlib import Path
 from typing import Any, Mapping, Sequence
 
 from .clarification_items.sidecars import (
+    sidecar_answers,
     attached_response_sections,
     response_source_report,
 )
@@ -286,6 +287,90 @@ def carry_decision(
     write_json_atomic(ledger_path, ledger)
 
 
+_CARRIED_STATUSES = frozenset({"answered", "resolved"})
+
+
+def _carried_answer(row: Mapping[str, Any], sidecar_answer: str) -> str:
+    """The answer a prior report's row carries, or an empty string.
+
+    The user-responses sidecar wins over the row: it is the later writing,
+    and a row the report left `open` is answered only there. A `resolved`
+    row keeps its answer in `resolution.userText`; an `answered` row in
+    `userInput`.
+    """
+    if sidecar_answer.strip():
+        return sidecar_answer.strip()
+    user_input = row.get("userInput")
+    if isinstance(user_input, str) and user_input.strip():
+        return user_input.strip()
+    resolution = row.get("resolution")
+    if isinstance(resolution, Mapping):
+        text = resolution.get("userText")
+        if isinstance(text, str) and text.strip():
+            return text.strip()
+    return ""
+
+
+def seed_carried_decisions(
+    ledger_path: Path, source: Path, *, source_run_ref: str,
+) -> list[str]:
+    """Carry every clarification the carry-in report already settled.
+
+    Prepare calls this when it creates a run's ledger and the run was
+    launched with a carry-in. The lead used to carry each id by hand and
+    mostly did not (2026-09-04, dev-10626: the error-analysis ledgers carried
+    six rows, the option-selection and planning ledgers none), so the report
+    cited `C-005` in its prose and had no row for it. Carrying is a copy with
+    no judgement in it — the prior record already holds the question, its
+    options, and the answer — which is why it lives here rather than in the
+    lead's procedure.
+
+    Only a structured report record (or the Markdown sibling of one) seeds:
+    an answers-only file has no question rows to copy, and there
+    ``okstra approval-decision carry --from-responses`` remains the path.
+    A row is carried when it is `answered` or `resolved`, or when the
+    record's user-responses sidecars answer it; an `open` row nobody
+    answered and an `obsolete` row are not decisions. Returns the carried
+    ids in record order.
+    """
+    from .clarification_items.rows import _structured_report_data
+
+    data = _structured_report_data(source)
+    if data is None:
+        return []
+    rows = data.get("clarificationItems")
+    if not isinstance(rows, list):
+        return []
+    answers = sidecar_answers(source)
+    carried: list[str] = []
+    for row in rows:
+        if not isinstance(row, Mapping):
+            continue
+        clarification_id = row.get("id")
+        if not isinstance(clarification_id, str) or not clarification_id:
+            continue
+        status = str(row.get("status") or "")
+        answer = _carried_answer(row, answers.get(clarification_id, ""))
+        if status == "obsolete" or not answer:
+            continue
+        if status not in _CARRIED_STATUSES and clarification_id not in answers:
+            continue
+        decision = {key: row[key] for key in _QUESTION_FIELDS if key in row}
+        if isinstance(decision.get("options"), list):
+            decision["options"] = [
+                _contract_v3_option(option, clarification_id)
+                for option in decision["options"]
+                if isinstance(option, Mapping)
+            ]
+        if "approvalContext" in row:
+            decision["approval"] = row["approvalContext"]
+        decision["userConfirmation"] = "asked-and-answered"
+        decision["userInput"] = answer
+        carry_decision(ledger_path, source_run_ref=source_run_ref, decision=decision)
+        carried.append(clarification_id)
+    return carried
+
+
 def _options_from_args(args: argparse.Namespace) -> tuple[DecisionOption, ...]:
     fields = (
         args.option_role, args.option_answer, args.option_rationale,

package/runtime/python/okstra_ctl/implementation_options.py

@@ -244,14 +244,49 @@ def _validate_option_feasibility(
         errors.append(f"{option_id} safetyBlockers must be empty")
     if require_valid and option.get("unresolvedFeasibilityFacts"):
         errors.append(f"{option_id} unresolvedFeasibilityFacts must be empty")
+    copied = _copied_votes(votes)
+    for first, second in copied:
+        errors.append(
+            f"{option_id} feasibilityVotes for {first} and {second} are identical; "
+            "each vote carries that analyser's own rationale and counterevidence"
+        )
     return (
         all_participated
         and feasible >= MIN_FEASIBLE_VOTES
         and not option.get("safetyBlockers")
         and not option.get("unresolvedFeasibilityFacts")
+        and not copied
     )
 
 
+def _copied_votes(votes: Sequence[object]) -> list[tuple[str, str]]:
+    """Pairs of analysers whose votes share one rationale and counterevidence.
+
+    A vote is that analyser's own finding. The writer synthesizes the row from
+    each result, and a run (2026-09-04, dev-10626) shipped three votes whose
+    sentences matched to the letter — one worker's text copied under the other
+    two names — so the votes said nothing a single vote did not. `uncertain`
+    votes are exempt: two analysers that never evaluated a candidate say so in
+    the same words legitimately.
+    """
+    seen: dict[tuple[str, str], str] = {}
+    copied: list[tuple[str, str]] = []
+    for vote in votes:
+        if not isinstance(vote, Mapping) or vote.get("verdict") == "uncertain":
+            continue
+        key = (
+            str(vote.get("rationale") or "").strip(),
+            str(vote.get("counterevidence") or "").strip(),
+        )
+        if not any(key):
+            continue
+        worker = str(vote.get("worker") or "?")
+        first = seen.setdefault(key, worker)
+        if first != worker:
+            copied.append((first, worker))
+    return copied
+
+
 def _validate_candidate(
     option: Mapping[str, object],
     original_ids: Sequence[str],

package/runtime/python/okstra_ctl/render.py

@@ -1962,6 +1962,19 @@ def _initialize_report_ledgers(ctx: Mapping[str, Any], manifest: Mapping[str, An
             "activeClarifications": [],
             "carriedDecisions": [],
         })
+        # 이월 결정은 여기서 심는다. 리드가 손으로 carry 하던 동안 대부분의
+        # run 이 빈 채로 갔고, 리포트는 행 없는 C-NNN 을 인용했다.
+        response_value = str(ctx.get("CLARIFICATION_RESPONSE_PATH") or "")
+        if response_value:
+            from .approval_decisions import seed_carried_decisions
+
+            seed_carried_decisions(
+                approval_path,
+                Path(response_value),
+                source_run_ref=str(
+                    ctx.get("CLARIFICATION_RESPONSE_RELATIVE_PATH") or response_value
+                ),
+            )
     activity_value = str(ctx.get("LEAD_EVENTS_PATH") or "")
     activity_path = Path(activity_value)
     if activity_value and not activity_path.is_file():

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

@@ -199,6 +199,49 @@ def _anchorable(row_id: str) -> bool:
     return bool(row_id) and " " not in row_id and "/" not in row_id
 
 
+def _count_ids(value: object, counts: dict[str, int]) -> None:
+    if isinstance(value, dict):
+        for key in ("id", "activityId", "clarificationId"):
+            row_id = value.get(key)
+            if isinstance(row_id, str) and row_id:
+                counts[row_id] = counts.get(row_id, 0) + 1
+        for nested in value.values():
+            _count_ids(nested, counts)
+    elif isinstance(value, list):
+        for nested in value:
+            _count_ids(nested, counts)
+
+
+def _shared_task_block_ids(data: dict, omitted_fields: tuple[str, ...]) -> set[str]:
+    """Ids several rows of the task block carry, so no single row owns them.
+
+    A direction's scope commitments are numbered `IC-001` … inside each
+    direction, and its planning invariants `PI-001` … likewise; the same id
+    sits in every ranked option and every audited candidate. A link to
+    `#id-IC-001` would land on whichever card came first, so the id stays
+    plain text. A clarification id the block repeats (a requirements report
+    lists `C-001` under two unresolved requirements) is not affected: the
+    clarification article is its one home and keeps the anchor.
+    """
+    from ..report_contract import TASK_TYPE_DATA_PROPERTY
+
+    property_name = TASK_TYPE_DATA_PROPERTY.get(
+        (data.get("header") or {}).get("taskType", "")
+    )
+    block = data.get(property_name) if property_name else None
+    if not isinstance(block, dict):
+        return set()
+    counts: dict[str, int] = {}
+    _count_ids(
+        {key: value for key, value in block.items() if key not in omitted_fields},
+        counts,
+    )
+    owned_elsewhere: set[str] = set()
+    _collect_ids(data.get("clarificationItems", []), owned_elsewhere)
+    _collect_ids(data.get("agentActivity", []), owned_elsewhere)
+    return {row_id for row_id, n in counts.items() if n > 1} - owned_elsewhere
+
+
 def anchor_index(data: dict, omitted_fields: tuple[str, ...] = ()) -> dict[str, str]:
     """Map every row a reader can reach to the anchor name that lands on it.
 
@@ -211,15 +254,28 @@ def anchor_index(data: dict, omitted_fields: tuple[str, ...] = ()) -> dict[str,
     It stops there. `summary` is the AI-facing digest and
     `analysisCommon.scope` describes the analysis target rather than listing
     rows; neither renders, so a link to one would land nowhere.
+
+    Cross-check rows are anchored `id-xv-<id>` by the base template — the
+    prefix keeps a legacy consensus row still numbered `C-NNN` from sharing
+    an element id with the clarification of that number — so they carry that
+    name here, and a legacy row whose id a clarification already owns keeps
+    pointing at the clarification.
     """
-    found = _own_section_ids(data, omitted_fields) | set(
-        evidence_index(data, omitted_fields)
-    )
-    return {
+    found = (
+        _own_section_ids(data, omitted_fields)
+        - _shared_task_block_ids(data, omitted_fields)
+    ) | set(evidence_index(data, omitted_fields))
+    index = {
         row_id: f"id-{row_id}"
         for row_id in sorted(found)
         if isinstance(row_id, str) and _anchorable(row_id)
     }
+    for block in ("consensus", "differences"):
+        for row in _dig(data, ("crossVerification", block)):
+            row_id = row.get("id") if isinstance(row, dict) else None
+            if isinstance(row_id, str) and _anchorable(row_id) and row_id not in index:
+                index[row_id] = f"id-xv-{row_id}"
+    return index
 
 
 def analysis_review_ids(data: dict) -> tuple[str, ...]:

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

@@ -0,0 +1,137 @@
+"""Rows and links for the ids a report cites but does not define.
+
+The human HTML renders from ``data.json``, and every id the record defines
+gets an anchor there. Two id families are cited on almost every page and
+defined on none of them:
+
+* the brief's end-state ids (``EB-001``, ``PB-001``, ``EO-001``) — the
+  denominator of every requirement-coverage table. The sentence behind each
+  id exists only in the task brief; no phase repeats it.
+* the clarification ids a previous run settled (``C-005``) — the record points
+  at that run through ``clarificationCarryIn.sourceFile`` and cites the ids
+  in its prose, but only the lead's ``carriedDecisions`` put a row for them
+  in this record, and a run that carried none leaves the ids as dead text.
+
+Both homes are okstra-owned files inside the same task directory, so the
+renderer follows the two pointers the run pinned — ``taskBriefPath`` is
+always ``<task>/instruction-set/task-brief.md`` (``path_hints.py``), and the
+carry-in record is named by the report itself — and only to give a cited id
+a place to land. Neither read is a precondition: a missing or unreadable file
+yields no rows and no links, never a render failure.
+"""
+from __future__ import annotations
+
+import os
+import re
+from collections.abc import Container
+from pathlib import Path
+
+from ..json_boundary import JsonBoundaryError, load_owned_object
+from ..report_view_artifacts import html_view_path
+from ..scope_provenance import brief_end_state_rows
+
+_USER_RESPONSE_RE = re.compile(r"^user-response-(?P<task_type>.+)-(?P<seq>\d{3,})\.md$")
+
+
+def _task_dir(data_path: Path) -> Path | None:
+    """The task directory a report lives under, or None outside the layout.
+
+    A report sits at ``<task>/runs/<type>/reports/`` — or one level deeper
+    for an implementation stage, ``runs/implementation/stage-<N>/reports/`` —
+    so the nearest ``runs`` ancestor names the task directory either way.
+    """
+    for parent in data_path.resolve().parents:
+        if parent.name == "runs":
+            return parent.parent
+    return None
+
+
+def _project_root(data_path: Path) -> Path | None:
+    """The project root, or None when the report is not under ``.okstra/``.
+
+    Every okstra-owned artifact lives under ``<PROJECT_ROOT>/.okstra/``, and a
+    carry-in ``sourceFile`` is recorded relative to that root.
+    """
+    for parent in data_path.resolve().parents:
+        if parent.name == ".okstra":
+            return parent.parent
+    return None
+
+
+def brief_end_states(data_path: Path) -> list[dict[str, str]]:
+    """The brief's end-state rows, in brief order, as template-ready dicts."""
+    task_dir = _task_dir(data_path)
+    if task_dir is None:
+        return []
+    brief = task_dir / "instruction-set" / "task-brief.md"
+    return [
+        {"id": row.id, "section": row.section, "statement": row.statement}
+        for row in brief_end_state_rows(brief)
+    ]
+
+
+def _carry_in_record(source: Path) -> Path | None:
+    """The report record a carry-in pointer resolves to.
+
+    The pointer names either the prior run's record itself or the
+    user-responses sidecar exported from that run's page; the sidecar sits in
+    ``runs/<type>/user-responses/`` beside the run's ``reports/`` directory
+    and carries the run's task type and seq in its name.
+    """
+    if source.name.endswith(".data.json"):
+        return source
+    match = _USER_RESPONSE_RE.match(source.name)
+    if match is None or source.parent.name != "user-responses":
+        return None
+    task_type, seq = match.group("task_type"), match.group("seq")
+    return source.parent.parent / "reports" / f"final-report-{task_type}-{seq}.data.json"
+
+
+def _clarification_ids(record: Path) -> list[str]:
+    """The clarification ids the carry-in record defines, or none.
+
+    The record is read through the owned-JSON boundary like every report
+    record; a record that fails it is a record this page cannot link into,
+    not a reason to refuse this page.
+    """
+    try:
+        payload = load_owned_object(record, artifact="carry-in report record")
+    except JsonBoundaryError:
+        return []
+    rows = payload.get("clarificationItems")
+    if not isinstance(rows, list):
+        return []
+    return [
+        row["id"]
+        for row in rows
+        if isinstance(row, dict) and isinstance(row.get("id"), str) and row["id"]
+    ]
+
+
+def carry_in_links(
+    data: dict, data_path: Path, *, exclude: Container[str] = ()
+) -> dict[str, str]:
+    """Map each clarification id the carry-in record defines to its anchor
+    on that record's HTML page, as an href relative to this report's page.
+
+    ``exclude`` names the ids this document already anchors — a row the lead
+    did carry keeps its in-page link, and the prior run's page is only for
+    the ids this page has no row for.
+    """
+    carry_in = data.get("clarificationCarryIn")
+    source_value = carry_in.get("sourceFile") if isinstance(carry_in, dict) else None
+    if not isinstance(source_value, str) or not source_value.strip():
+        return {}
+    root = _project_root(data_path)
+    if root is None:
+        return {}
+    record = _carry_in_record(root / source_value.strip())
+    if record is None or not record.is_file():
+        return {}
+    page = html_view_path(record)
+    href = Path(os.path.relpath(page, data_path.resolve().parent)).as_posix()
+    return {
+        cid: f"{href}#id-{cid}"
+        for cid in _clarification_ids(record)
+        if cid not in exclude
+    }

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

package/runtime/templates/reports/html/tasks/implementation-option-selection.template.html

@@ -2,6 +2,51 @@
 {% from "html/macros/layout.html" import narrative as render_narrative, summary_card, row_key %}
 {% from "html/macros/forms.html" import direction_selection %}
 
+{# One direction, read top to bottom as what it changes, how, why it ranks
+   where it does, and what the reader should expect afterwards. Every block
+   is a field the writer already fills; the card used to show the goal line
+   and the coverage table and left the mechanism, scores, votes, commitments
+   and invariants in the record only. #}
+{% macro option_card(row, rank, criteria) -%}
+<article class="summary-card" id="id-{{ row.id }}">
+    <p class="eyebrow">#{{ rank }} · {{ row.id | inline_code }} · {{ t('macros.layout.proposed-by') }} {{ row.proposedBy | inline_code }}</p>
+    <h3>{{ row.name | inline_code }}</h3>
+    <div class="option-detail">
+      <h4>{{ t('tasks.implementation-option-selection.what-changes') }}</h4>
+      <p><strong>{{ t('tasks.implementation-option-selection.goal') }}</strong> {{ row.goal | inline_code }}</p>
+      <p><strong>{{ t('tasks.implementation-option-selection.change-areas') }}</strong></p>
+      <ul>{% for area in row.expectedChangeAreas %}<li>{{ area | inline_code }}</li>{% endfor %}</ul>
+      <table data-report-field="implementationOptionSelection.rankedOptions.scopeCommitments"><thead><tr><th>{{ t('tasks.implementation-option-selection.commitment') }}</th><th>{{ t('tasks.implementation-option-selection.commitment-body') }}</th><th>{{ t('tasks.implementation-option-selection.requirements') }}</th></tr></thead><tbody>{% for item in row.scopeCommitments %}<tr>{{ row_key(pairs=[(t('macros.layout.id'), item.id), (t('macros.layout.kind'), item.kind | enum_label('commitmentKind'))]) }}<td>{{ item.commitment | inline_code }}</td><td>{{ item.requirementIds | join(", ") | inline_code }}</td></tr>{% endfor %}</tbody></table>
+    </div>
+    <div class="option-detail">
+      <h4>{{ t('tasks.implementation-option-selection.how-it-works') }}</h4>
+      <p>{{ row.coreMechanism | inline_code }}</p>
+      <p><strong>{{ t('tasks.implementation-option-selection.boundaries') }}</strong></p>
+      <ul>{% for boundary in row.architectureBoundaries %}<li>{{ boundary | inline_code }}</li>{% endfor %}</ul>
+    </div>
+    <div class="option-detail">
+      <h4>{{ t('tasks.implementation-option-selection.why-this-direction') }}</h4>
+      <p><strong>{{ t('tasks.implementation-option-selection.weighted-score') }}</strong> {{ row.weightedScore }} / 5</p>
+      <table data-report-field="implementationOptionSelection.rankedOptions.criterionScores"><thead><tr><th>{{ t('tasks.implementation-option-selection.criterion') }}</th><th class="figure">{{ t('tasks.implementation-option-selection.weight') }}</th><th class="figure">{{ t('tasks.implementation-option-selection.score') }}</th><th>{{ t('tasks.implementation-option-selection.reason') }}</th></tr></thead><tbody>{% for score in row.criterionScores %}<tr><td>{{ score.criterion | enum_label('optionCriterion') }}</td><td class="figure">{{ criteria.get(score.criterion, '') }}</td><td class="figure">{{ score.score }}</td><td>{{ score.rationale | inline_code }}</td></tr>{% endfor %}</tbody></table>
+      <p><strong>{{ t('tasks.implementation-option-selection.feasibility-votes') }}</strong></p>
+      <table data-report-field="implementationOptionSelection.rankedOptions.feasibilityVotes"><thead><tr><th>{{ t('tasks.implementation-option-selection.worker') }}</th><th>{{ t('tasks.implementation-option-selection.reason') }}</th><th>{{ t('tasks.implementation-option-selection.counterevidence') }}</th></tr></thead><tbody>{% for vote in row.feasibilityVotes %}<tr>{{ row_key(pairs=[(t('tasks.implementation-option-selection.worker'), vote.worker)], status_name=t('tasks.implementation-option-selection.verdict'), status_raw=vote.verdict, status_text=vote.verdict | enum_label('feasibilityVerdict')) }}<td>{{ vote.rationale | inline_code }}</td><td>{{ vote.counterevidence | inline_code }}</td></tr>{% endfor %}</tbody></table>
+      {% if row.safetyBlockers %}<p><strong>{{ t('tasks.implementation-option-selection.safety-blockers') }}</strong></p>
+      <ul>{% for blocker in row.safetyBlockers %}<li><span class="status status-risk">{{ blocker.category | enum_label('safetyCategory') }}</span> {{ blocker.statement | inline_code }} <span class="evidence-refs">{{ t('macros.layout.evidence') }} {{ blocker.evidence | evidence_refs }}</span></li>{% endfor %}</ul>{% endif %}
+      {% if row.unresolvedFeasibilityFacts %}<p><strong>{{ t('tasks.implementation-option-selection.unresolved-facts') }}</strong></p>
+      <ul>{% for fact in row.unresolvedFeasibilityFacts %}<li>{{ fact.fact | inline_code }} — {{ t('tasks.implementation-option-selection.why-it-matters') }} {{ fact.whyItMatters | inline_code }} <span class="evidence-refs">{{ t('macros.layout.evidence') }} {{ fact.evidence | evidence_refs }}</span></li>{% endfor %}</ul>{% endif %}
+    </div>
+    <div class="option-detail">
+      <h4>{{ t('tasks.implementation-option-selection.expected-outcome') }}</h4>
+      <div data-report-field="implementationOptionSelection.rankedOptions.coverageSummary"><p>{{ t('tasks.implementation-option-selection.coverage-line') | replace('{covered}', row.coverageSummary.coveredCount) | replace('{total}', row.coverageSummary.totalCount) | replace('{verdict}', row.coverageSummary.coverageVerdict | enum_label('coverageVerdict')) }}</p>
+      <p><strong>{{ t('macros.layout.coverage-percent') }}</strong> <span data-report-metric="coveragePercent">{{ row.coverageSummary.coveragePercent }}</span>% · <strong>{{ t('macros.layout.scope-precision-percent') }}</strong> <span data-report-metric="scopePrecisionPercent">{{ row.coverageSummary.scopePrecisionPercent }}</span>%</p></div>
+      <table data-report-field="implementationOptionSelection.rankedOptions.requirementCoverage"><thead><tr><th>{{ t('tasks.implementation-option-selection.requirement') }}</th><th>{{ t('tasks.implementation-option-selection.satisfaction') }}</th><th>{{ t('tasks.implementation-option-selection.verification') }}</th></tr></thead><tbody>{% for coverage in row.requirementCoverage %}<tr>{{ row_key(pairs=[(t('macros.layout.id'), coverage.requirementId), (t('macros.layout.status'), coverage.status)]) }}<td>{{ coverage.satisfaction | inline_code }}</td><td>{{ coverage.expectedVerification | inline_code }}</td></tr>{% endfor %}</tbody></table>
+      {% if row.planningInvariants %}<p><strong>{{ t('tasks.implementation-option-selection.planning-invariants') }}</strong></p>
+      <ul data-report-field="implementationOptionSelection.rankedOptions.planningInvariants">{% for invariant in row.planningInvariants %}<li>{{ invariant.id | inline_code }} · {{ invariant.statement | inline_code }} ({{ invariant.requirementIds | join(", ") | inline_code }})</li>{% endfor %}</ul>{% endif %}
+    </div>
+    <p class="evidence-refs">{{ t('macros.layout.evidence') }} {{ row.codeEvidence | evidence_refs }}</p>
+</article>
+{%- endmacro %}
+
 {% block human_content %}
 <section data-report-section="selection-status">
   <h2>{{ t('tasks.implementation-option-selection.selection-status') }}</h2>
@@ -21,29 +66,28 @@
   {{ render_narrative(narrative.comparisonOverview, "implementationOptionSelection.userNarrative.comparisonOverview") }}
   <p data-report-field="implementationOptionSelection.decisionContext.originalRequirementIds"><strong>{{ t('tasks.implementation-option-selection.requirement-ids') }}</strong> {{ selection.decisionContext.originalRequirementIds | join(", ") | inline_code }}</p>
   {% if selection.decisionContext.leadingCauseRefs %}<p><strong>{{ t('tasks.implementation-option-selection.leading-causes') }}</strong> {{ selection.decisionContext.leadingCauseRefs | join(", ") | inline_code }}</p>{% endif %}
+  {% if selection.decisionContext.upstreamDecisionRefs %}<p><strong>{{ t('tasks.implementation-option-selection.upstream-decisions') }}</strong> {{ selection.decisionContext.upstreamDecisionRefs | join(", ") | inline_code }}</p>{% endif %}
+</section>
+
+<section data-report-section="evaluation-criteria" data-report-field="implementationOptionSelection.evaluationCriteria">
+  <h2>{{ t('tasks.implementation-option-selection.evaluation-criteria') }}</h2>
+  <p class="section-lede">{{ t('tasks.implementation-option-selection.evaluation-criteria-intro') }}</p>
+  <table><thead><tr><th>{{ t('tasks.implementation-option-selection.criterion') }}</th><th class="figure">{{ t('tasks.implementation-option-selection.weight') }}</th><th>{{ t('tasks.implementation-option-selection.why-it-matters') }}</th></tr></thead><tbody>{% for criterion in selection.evaluationCriteria %}<tr><td>{{ criterion.criterion | enum_label('optionCriterion') }}</td><td class="figure">{{ criterion.weight }}</td><td>{{ criterion.rationale | inline_code }}</td></tr>{% endfor %}</tbody></table>
 </section>
 
 <section data-report-section="ranked-options" data-report-field="implementationOptionSelection.rankedOptions">
   <h2>{{ t('tasks.implementation-option-selection.ranked-options') }}</h2>
   {{ render_narrative(narrative.rankingExplanation, "implementationOptionSelection.userNarrative.rankingExplanation") }}
-  <div class="summary-grid">{% for row in selection.rankedOptions %}<article class="summary-card" id="id-{{ row.id }}">
-    <p class="eyebrow">#{{ loop.index }} · {{ row.id | inline_code }}</p>
-    <h3>{{ row.name | inline_code }}</h3>
-    <p>{{ row.goal | inline_code }}</p>
-    <div data-report-field="implementationOptionSelection.rankedOptions.coverageSummary"><p><strong>{{ t('macros.layout.coverage-percent') }}</strong> <span data-report-metric="coveragePercent">{{ row.coverageSummary.coveragePercent }}</span></p>
-    <p><strong>{{ t('macros.layout.scope-precision-percent') }}</strong> <span data-report-metric="scopePrecisionPercent">{{ row.coverageSummary.scopePrecisionPercent }}</span></p></div>
-    <p><strong>{{ t('tasks.implementation-option-selection.weighted-score') }}</strong> {{ row.weightedScore }}</p>
-    <table data-report-field="implementationOptionSelection.rankedOptions.requirementCoverage"><thead><tr><th>{{ t('tasks.implementation-option-selection.requirement') }}</th><th>{{ t('tasks.implementation-option-selection.satisfaction') }}</th><th>{{ t('tasks.implementation-option-selection.verification') }}</th></tr></thead><tbody>{% for coverage in row.requirementCoverage %}<tr>{{ row_key(pairs=[(t('macros.layout.id'), coverage.requirementId), (t('macros.layout.status'), coverage.status)]) }}<td>{{ coverage.satisfaction | inline_code }}</td><td>{{ coverage.expectedVerification | inline_code }}</td></tr>{% endfor %}</tbody></table>
-  </article>{% else %}<p>{{ t('tasks.implementation-option-selection.no-valid-options') }}</p>{% endfor %}</div>
+  <div class="summary-grid">{% for row in selection.rankedOptions %}{{ option_card(row, loop.index, criteriaWeights) }}{% else %}<p>{{ t('tasks.implementation-option-selection.no-valid-options') }}</p>{% endfor %}</div>
 </section>
 
 <section data-report-section="recommendation" data-report-field="implementationOptionSelection.recommendedOptionId">
   <h2>{{ t('tasks.implementation-option-selection.recommended-direction') }}</h2>
-  {% if recommendedOption %}{{ summary_card(recommendedOption.id ~ " · " ~ recommendedOption.name, recommendedOption.coreMechanism, "important") }}{% else %}<p>{{ t('tasks.implementation-option-selection.no-recommendation') }}</p>{% endif %}
+  {% if recommendedOption %}{{ summary_card(recommendedOption.id ~ " · " ~ recommendedOption.name, recommendedOption.goal ~ " " ~ recommendedOption.coreMechanism, "important") }}{% else %}<p>{{ t('tasks.implementation-option-selection.no-recommendation') }}</p>{% endif %}
 </section>
 
 <section data-report-section="candidate-audit" data-report-field="implementationOptionSelection.candidateAudit">
   <h2>{{ t('tasks.implementation-option-selection.candidate-audit') }}</h2>
-  <table><thead><tr><th>{{ t('tasks.implementation-option-selection.candidate') }}</th><th>{{ t('tasks.implementation-option-selection.disposition') }}</th><th>{{ t('tasks.implementation-option-selection.reason') }}</th><th>{{ t('macros.layout.coverage-percent') }}</th><th>{{ t('macros.layout.scope-precision-percent') }}</th></tr></thead><tbody>{% for row in selection.candidateAudit %}<tr id="id-{{ row.id }}">{{ row_key(pairs=[(t('macros.layout.id'), row.id), (t('macros.layout.proposed-by'), row.proposedBy)]) }}<td>{{ row.disposition }}</td><td>{{ row.reason | inline_code }}</td><td>{{ row.coverageSummary.coveragePercent }}</td><td>{{ row.coverageSummary.scopePrecisionPercent }}</td></tr>{% else %}<tr><td colspan="6">{{ t('tasks.implementation-option-selection.no-audit-entries') }}</td></tr>{% endfor %}</tbody></table>
+  <table><thead><tr><th>{{ t('tasks.implementation-option-selection.candidate') }}</th><th>{{ t('tasks.implementation-option-selection.goal-column') }}</th><th>{{ t('tasks.implementation-option-selection.disposition') }}</th><th>{{ t('tasks.implementation-option-selection.reason') }}</th><th>{{ t('macros.layout.coverage-percent') }}</th><th>{{ t('macros.layout.scope-precision-percent') }}</th></tr></thead><tbody>{% for row in selection.candidateAudit %}<tr id="id-{{ row.id }}">{{ row_key(pairs=[(t('macros.layout.id'), row.id), (t('macros.layout.proposed-by'), row.proposedBy)]) }}<td>{{ row.goal | inline_code }}</td><td>{{ row.disposition }}{% if row.mergedInto %} → {{ row.mergedInto | inline_code }}{% endif %}</td><td>{{ row.reason | inline_code }}</td><td>{{ row.coverageSummary.coveragePercent }}</td><td>{{ row.coverageSummary.scopePrecisionPercent }}</td></tr>{% else %}<tr><td colspan="6">{{ t('tasks.implementation-option-selection.no-audit-entries') }}</td></tr>{% endfor %}</tbody></table>
 </section>
 {% endblock %}