okstra 0.172.0 → 0.174.0

package/runtime/python/okstra_ctl/report_views.py

@@ -111,6 +111,8 @@ class RunMeta:
     task_type: str
     seq: str
     source_report: str  # relative path of the .md the HTML is derived from
+    source_data: str = ""
+    source_data_sha256: str = ""
 
 
 @dataclass(frozen=True)
@@ -154,7 +156,9 @@ def _infer_run_meta_from_body(text: str) -> dict:
 
 def infer_run_meta(report_path: Path, *, task_key: Optional[str] = None,
                    task_type: Optional[str] = None, seq: Optional[str] = None,
-                   source_report: Optional[str] = None) -> RunMeta:
+                   source_report: Optional[str] = None,
+                   source_data: Optional[str] = None,
+                   source_data_sha256: Optional[str] = None) -> RunMeta:
     """Derive a ``RunMeta`` from a final-report path/body, honouring any
     explicit override.
 
@@ -166,11 +170,22 @@ def infer_run_meta(report_path: Path, *, task_key: Optional[str] = None,
     """
     text = report_path.read_text(encoding="utf-8")
     inferred = {**_infer_run_meta_from_path(report_path), **_infer_run_meta_from_body(text)}
+    resolved_source_report = source_report or report_path.name
+    data_path = final_report_data_path(report_path)
+    inferred_source_data = ""
+    inferred_source_data_sha256 = ""
+    if data_path.is_file():
+        inferred_source_data = final_report_data_path(
+            Path(resolved_source_report)
+        ).as_posix()
+        inferred_source_data_sha256 = hashlib.sha256(data_path.read_bytes()).hexdigest()
     return RunMeta(
         task_key=task_key or inferred.get("task_key") or "unknown",
         task_type=task_type or inferred.get("task_type") or "unknown",
         seq=seq or inferred.get("seq") or "000",
-        source_report=source_report or report_path.name,
+        source_report=resolved_source_report,
+        source_data=source_data or inferred_source_data,
+        source_data_sha256=source_data_sha256 or inferred_source_data_sha256,
     )
 
 
@@ -271,6 +286,32 @@ def render_report_view_model(
     sidecar_name = html.escape(model.sidecar_name)
     sidecar_dir = html.escape(model.sidecar_dir)
     run_meta = model.run_meta
+    source_data_json = (
+        f'"source-data":"{html.escape(run_meta.source_data)}",'
+        if run_meta.source_data else ""
+    )
+    source_data_sha256_json = (
+        f'"source-data-sha256":"{html.escape(run_meta.source_data_sha256)}",'
+        if run_meta.source_data_sha256 else ""
+    )
+    reentry_only = bool(
+        model.approval_ctx and model.approval_ctx.reentry_command
+    )
+    export_header = (
+        '  <button type="button" data-action="export-user-response">Export user response</button>\n'
+        if not reentry_only else ""
+    )
+    export_footer = (
+        f'<footer class="report-footer">\n'
+        f'  <button type="button" data-action="export-user-response">Export user response</button>\n'
+        f'  <p class="user-response-hint">Export 클릭 시 <code>{sidecar_name}</code> 가 다운로드됩니다 — '
+        f'<code>{sidecar_dir}</code> 에 저장하면 resume-clarification 이 자동으로 첨부합니다.</p>\n'
+        f'  <pre id="user-response-output" aria-live="polite"></pre>\n'
+        f'  <button type="button" data-action="copy-user-response">Copy</button>\n'
+        f'  <button type="button" data-action="dismiss-user-response" class="user-response-dismiss" aria-label="출력 닫기" title="닫기" hidden>×</button>\n'
+        f'</footer>\n'
+        if not reentry_only else ""
+    )
     return (
         f"<!DOCTYPE html>\n"
         f"<html lang=\"ko\">\n"
@@ -283,24 +324,19 @@ def render_report_view_model(
         f"<body>\n"
         f"<header class=\"report-header\">\n"
         f"  <div>{title}</div>\n"
-        f"  <button type=\"button\" data-action=\"export-user-response\">Export user response</button>\n"
+        f"{export_header}"
         f"</header>\n"
         f"<main>{_reader_dashboard(model.reader_ctx)}{model.body_html}</main>\n"
         f"{_plan_approval_section(model.approval_ctx, run_meta) if model.approval_ctx else ''}"
         f"{_analysis_review_section(model.analysis_review_ctx) if model.analysis_review_ctx else ''}"
-        f"<footer class=\"report-footer\">\n"
-        f"  <button type=\"button\" data-action=\"export-user-response\">Export user response</button>\n"
-        f"  <p class=\"user-response-hint\">Export 클릭 시 <code>{sidecar_name}</code> 가 다운로드됩니다 — "
-        f"<code>{sidecar_dir}</code> 에 저장하면 resume-clarification 이 자동으로 첨부합니다.</p>\n"
-        f"  <pre id=\"user-response-output\" aria-live=\"polite\"></pre>\n"
-        f"  <button type=\"button\" data-action=\"copy-user-response\">Copy</button>\n"
-        f"  <button type=\"button\" data-action=\"dismiss-user-response\" class=\"user-response-dismiss\" aria-label=\"출력 닫기\" title=\"닫기\" hidden>×</button>\n"
-        f"</footer>\n"
+        f"{export_footer}"
         f"<script id=\"run-meta\" type=\"application/json\">"
         f"{{\"task-key\":\"{html.escape(run_meta.task_key)}\","
         f"\"task-type\":\"{html.escape(run_meta.task_type)}\","
         f"\"seq\":\"{html.escape(run_meta.seq)}\","
         f"\"source-report\":\"{html.escape(run_meta.source_report)}\","
+        f"{source_data_json}"
+        f"{source_data_sha256_json}"
         f"\"source-sha256\":\"{model.source_digest}\","
         f"\"response-ids\":{response_ids_json}}}"
         f"</script>\n"
@@ -1062,6 +1098,15 @@ class UserPlanDecision:
     reason: str = ""
 
 
+@dataclass(frozen=True)
+class UserDirectionSelection:
+    option_id: str
+    option_name: str
+    confirmed: bool
+    selection_note: str = ""
+    constraints: str = ""
+
+
 @dataclass(frozen=True)
 class UserResponseAnalysisReview:
     status: str
@@ -1084,6 +1129,44 @@ _PLAN_DECISION_STATUSES = frozenset({
     "rejected",
 })
 
+_DIRECTION_IDENTITY_WHITESPACE = frozenset(
+    "\u0009\u000a\u000b\u000c\u000d"
+    "\u001c\u001d\u001e\u001f\u0020\u0085\u00a0\u1680"
+    "\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a"
+    "\u2028\u2029\u202f\u205f\u3000\ufeff"
+)
+_DIRECTION_IDENTITY_ERROR = (
+    "DIRECTION SELECTION Option-ID and Option-Name must be "
+    "non-empty single-line values"
+)
+
+
+def _trim_direction_identity(value: str) -> str:
+    start = 0
+    end = len(value)
+    while start < end and value[start] in _DIRECTION_IDENTITY_WHITESPACE:
+        start += 1
+    while end > start and value[end - 1] in _DIRECTION_IDENTITY_WHITESPACE:
+        end -= 1
+    return value[start:end]
+
+
+def normalize_direction_selection_identity(
+    option_id: str, option_name: str,
+) -> tuple[str, str]:
+    if (
+        "\r" in option_id
+        or "\n" in option_id
+        or "\r" in option_name
+        or "\n" in option_name
+    ):
+        raise ValueError(_DIRECTION_IDENTITY_ERROR)
+    normalized_id = _trim_direction_identity(option_id)
+    normalized_name = _trim_direction_identity(option_name)
+    if not normalized_id or not normalized_name:
+        raise ValueError(_DIRECTION_IDENTITY_ERROR)
+    return normalized_id, normalized_name
+
 
 def _quoted_sidecar_field(label: str, value: str) -> str:
     cleaned = value.strip()
@@ -1125,6 +1208,23 @@ def _serialize_plan_decision(decision: UserPlanDecision) -> str:
     return chunk
 
 
+def _serialize_direction_selection(selection: UserDirectionSelection) -> str:
+    option_id, option_name = normalize_direction_selection_identity(
+        selection.option_id, selection.option_name
+    )
+    if not selection.confirmed:
+        raise ValueError("DIRECTION SELECTION requires Confirmed: true")
+    return (
+        "\n## DIRECTION SELECTION\n"
+        "- Status: selected\n"
+        f"- Option-ID: {option_id}\n"
+        f"- Option-Name: {option_name}\n"
+        "- Confirmed: true\n"
+        f"{_quoted_sidecar_field('Selection-Note', selection.selection_note)}"
+        f"{_quoted_sidecar_field('Constraints', selection.constraints)}"
+    )
+
+
 def serialize_user_response(
     *,
     run_meta: RunMeta,
@@ -1132,18 +1232,27 @@ def serialize_user_response(
     created_at: str,
     plan_decision: UserPlanDecision | None = None,
     analysis_review: UserResponseAnalysisReview | None = None,
+    direction_selection: UserDirectionSelection | None = None,
 ) -> str:
     """Return the canonical markdown text the HTML 'Export user
     response' button must produce. Used by validators to confirm that
     pasted sidecar files conform to the schema and that the JS
     serialiser stayed in sync.
     """
+    source_data_lines = ""
+    if run_meta.source_data:
+        source_data_lines += f"source-data: {run_meta.source_data}\n"
+    if run_meta.source_data_sha256:
+        source_data_lines += (
+            f"source-data-sha256: {run_meta.source_data_sha256}\n"
+        )
     head = (
         "---\n"
         f"task-key: {run_meta.task_key}\n"
         f"task-type: {run_meta.task_type}\n"
         f"seq: {run_meta.seq}\n"
         f"source-report: {run_meta.source_report}\n"
+        f"{source_data_lines}"
         "created-by: user\n"
         f"created-at: {created_at}\n"
         "---\n"
@@ -1152,6 +1261,7 @@ def serialize_user_response(
     )
     has_plan_decision = plan_decision is not None
     has_analysis_review = analysis_review is not None
+    has_direction_selection = direction_selection is not None
     body_chunks: list[str] = []
     for e in entries:
         chunk = f"\n## {e.response_id}\n- Kind: {e.kind}\n"
@@ -1162,12 +1272,19 @@ def serialize_user_response(
         if e.rationale:
             chunk += f"- Rationale: {e.rationale.strip()}\n"
         body_chunks.append(chunk)
-    if not entries and not has_plan_decision and not has_analysis_review:
+    if (
+        not entries
+        and not has_plan_decision
+        and not has_analysis_review
+        and not has_direction_selection
+    ):
         body_chunks.append("\n_(No user responses recorded.)_\n")
     if plan_decision is not None:
         body_chunks.append(_serialize_plan_decision(plan_decision))
     if analysis_review is not None:
         body_chunks.append(_serialize_analysis_review(analysis_review))
+    if direction_selection is not None:
+        body_chunks.append(_serialize_direction_selection(direction_selection))
     return head + "".join(body_chunks)
 
 
@@ -1263,6 +1380,8 @@ def plan_approval_context(src_md_path: Path) -> PlanApprovalContext | None:
         recommended_option=state.recommended_option,
         disabled_reason=reason,
         blocker_ids=blocker_ids,
+        show_option_selector=state.show_option_selector,
+        reentry_command=state.reentry_command,
     )
 
 
@@ -1352,6 +1471,16 @@ def _approval_blocked_guidance(ctx: PlanApprovalContext, run_meta: RunMeta) -> s
     """disabled 사유를 화면에서 바로 따라할 수 있는 단계별 안내로 렌더한다.
     핵심: 이 화면에서 답을 입력하는 것만으로는 승인이 풀리지 않으며,
     Export → 저장 → resume-clarification → 재렌더 라운드트립이 필요하다는 것."""
+    if ctx.reentry_command:
+        command = (
+            f"/okstra-run task-key={run_meta.task_key} "
+            "task-type=implementation-option-selection"
+        )
+        return (
+            '<p class="approval-disabled-reason">선택 방향이 무효화되어 이 계획은 '
+            "승인할 수 없습니다. 구현 방향 선택 단계에 다시 진입하세요: "
+            f"<code>{html.escape(command)}</code></p>"
+        )
     if not ctx.blocker_ids:  # unreadable 사유 — 재렌더 외에 따라할 단계가 없다.
         return f'<p class="approval-disabled-reason">{html.escape(ctx.disabled_reason)}</p>'
     sidecar_dir = f"runs/{run_meta.task_type}/user-responses/"
@@ -1379,6 +1508,13 @@ def _approval_blocked_guidance(ctx: PlanApprovalContext, run_meta: RunMeta) -> s
 
 
 def _plan_approval_section(ctx: PlanApprovalContext, run_meta: RunMeta) -> str:
+    if ctx.reentry_command:
+        return (
+            '<section id="plan-approval">\n'
+            "  <h2>선택 방향 무효화</h2>\n"
+            f"  {_approval_blocked_guidance(ctx, run_meta)}\n"
+            "</section>\n"
+        )
     disabled = " disabled" if ctx.disabled_reason else ""
     opts: list[str] = []
     for name in ctx.option_names: