okstra 0.30.3 → 0.32.0

package/runtime/python/okstra_ctl/report_views.py

@@ -1,11 +1,7 @@
-"""Render two derived views of an okstra final-report markdown.
+"""Render the self-contained HTML view of an okstra final-report markdown.
 
-Two products, one source of truth:
+Single product, single source of truth:
 
-* ``slim_markdown(src_md)`` — deterministic token-saving stripper that
-  removes presentational fluff while preserving every substring the
-  ``validators/validate-run.py`` substring checks rely on. Intended as
-  the AI consumption surface (next-phase lead prompt input).
 * ``render_html(src_md, *, run_meta)`` — deterministic self-contained
   HTML renderer for human readers. Sections §5/§6/§7 user-actionable
   rows (those reachable from §5 ``C-*`` IDs) get embedded ``<form>``
@@ -18,44 +14,9 @@ response`` button (client-side JS, single-reference-point with the
 Python ``serialize_user_response`` function below) and the user pastes
 it to ``runs/<task-type>/user-responses/user-response-<task-type>-<seq>.md``.
 
-Strip rules (deterministic):
-  - ``STRIP_TOKEN_PLACEHOLDER_ZEROS`` — remove ``$0.00`` cost rows
-    except the ``Codex/Gemini CLI 추가 비용`` row (keep, as the literal
-    zero is meaningful audit info).
-  - ``STRIP_DECORATIVE_HR`` — collapse 3+ consecutive horizontal rules
-    to a single ``---``.
-  - ``STRIP_VERDICT_DETAIL`` — drop ``### 4.5.9 Verdict details`` wide
-    matrix body when the preceding ``Verdict summary`` card is present.
-    Keep the heading line itself so heading-set invariants hold.
-  - ``STRIP_INTRO_RECIPE`` — drop the ``> **읽는 법**:`` quoted recipe
-    paragraph beneath the Token Usage Summary table. The definition is
-    audience-facing; the slim AI consumer already knows the schema.
-  - ``COLLAPSE_BLANK_LINES`` — normalise 3+ blank lines to one.
-
-Absolutely-preserve invariants (validator hard-fail prevention):
-  - ``## Verdict Card`` block content byte-identical
-  - ``## 2. Final Verdict`` table rows for ``Verdict Token`` /
-    ``Direction`` / ``Next Step``
-  - ``## 0. Clarification Response Carried In`` (when present)
-  - implementation-planning 9 substrings (Option Candidates,
-    Trade-off, Recommended Option, Stepwise Execution Order,
-    Dependency, Validation Checklist, Rollback, User Approval Request,
-    Plan Body Verification + Gate result:)
-  - implementation §4.7 8 sub-section substrings (Approved Plan
-    Reference, Commit List, Diff Summary, Out-of-plan Edits,
-    Validation Evidence, Verifier Results, Rollback Verification,
-    Routing Recommendation)
-  - final-verification §4.8 6 sub-section substrings (Source
-    Implementation Report, Acceptance Blockers, Residual Risk,
-    Validation Evidence, Read-only Command Log, Routing Recommendation)
-  - release-handoff §4.6.1–4.6.7 sub-section substrings (Source
-    Verification Report, Feature Branch & Working-Tree State, User
-    Selections, Executed Commands, Commit List, Merge Conflict Probe,
-    Pull Request Outcome, Routing Recommendation)
-
-The substring list is sourced from validate-run.py via
-``preserved_substrings()`` so a future contract change touches one
-place only.
+The next-phase lead prompt now consumes the source MD directly — the
+former ``*.slim.md`` derived artefact was removed (its strip rules
+saved no tokens worth the contract maintenance cost).
 """
 from __future__ import annotations
 
@@ -68,27 +29,12 @@ from typing import Iterable, Optional
 
 
 def source_digest(src_md: str) -> str:
-    """Stable identifier for a final-report markdown body. Both
-    derived views embed this so the validator can detect a stale
-    slim/html that was generated from an older MD."""
+    """Stable identifier for a final-report markdown body. The HTML
+    view embeds this in its run-meta block so the validator can detect
+    a stale html that was generated from an older MD."""
     return hashlib.sha256(src_md.encode("utf-8")).hexdigest()
 
 
-_SOURCE_DIGEST_COMMENT_RE = re.compile(
-    r"^<!--\s*source-sha256:\s*([0-9a-f]{64})\s*-->\s*$", re.MULTILINE
-)
-
-
-def extract_slim_digest(slim_text: str) -> Optional[str]:
-    """Return the source-sha256 token embedded in a slim MD's first
-    comment line, or None if absent (older artifacts)."""
-    first_nonblank = next(
-        (ln for ln in slim_text.splitlines() if ln.strip()), ""
-    )
-    m = _SOURCE_DIGEST_COMMENT_RE.match(first_nonblank)
-    return m.group(1) if m else None
-
-
 _HTML_DIGEST_RE = re.compile(r'"source-sha256":"([0-9a-f]{64})"')
 
 
@@ -97,15 +43,17 @@ def extract_html_digest(html_text: str) -> Optional[str]:
     return m.group(1) if m else None
 
 
-def _strip_leading_digest_comment(text: str) -> str:
-    """Remove a leading ``<!-- source-sha256: <hex> -->\\n`` line if
-    present. Used so ``slim_markdown`` and ``render_html`` can be called
-    on their own previously-stripped output without producing a
-    different digest the second time around."""
-    head, _, rest = text.partition("\n")
-    if _SOURCE_DIGEST_COMMENT_RE.match(head):
-        return rest
-    return text
+_LEADING_FRONTMATTER_RE = re.compile(
+    r"\A---\s*\n.*?\n---\s*\n?", re.DOTALL
+)
+
+
+def _strip_leading_frontmatter(text: str) -> str:
+    """Remove a leading YAML frontmatter block (``---\\n…\\n---\\n``) if
+    present. Used by ``render_html`` so the HTML view does not surface
+    the Obsidian-side frontmatter as a paragraph; the source MD keeps
+    the frontmatter for Obsidian/Templater consumers."""
+    return _LEADING_FRONTMATTER_RE.sub("", text, count=1)
 
 from .clarification_items import (
     _is_separator_row,
@@ -116,205 +64,10 @@ from .clarification_items import (
 
 
 # --------------------------------------------------------------------------- #
-# Preserved substrings (single source of truth — keep in sync with
-# validators/validate-run.py).
-# --------------------------------------------------------------------------- #
-
-PRESERVED_SUBSTRINGS_PLANNING: tuple[str, ...] = (
-    "Option Candidates",
-    "Trade-off",
-    "Recommended Option",
-    "Stepwise Execution Order",
-    "Dependency",
-    "Validation Checklist",
-    "Rollback",
-    "User Approval Request",
-    "Plan Body Verification",
-    "Gate result:",
-)
-
-PRESERVED_SUBSTRINGS_IMPLEMENTATION: tuple[str, ...] = (
-    "Approved Plan Reference",
-    "Commit List",
-    "Diff Summary",
-    "Out-of-plan Edits",
-    "Validation Evidence",
-    "Verifier Results",
-    "Rollback Verification",
-    "Routing Recommendation",
-)
-
-PRESERVED_SUBSTRINGS_FINAL_VERIFICATION: tuple[str, ...] = (
-    "Source Implementation Report",
-    "Acceptance Blockers",
-    "Residual Risk",
-    "Validation Evidence",
-    "Read-only Command Log",
-    "Routing Recommendation",
-)
-
-PRESERVED_SUBSTRINGS_RELEASE_HANDOFF: tuple[str, ...] = (
-    "Source Verification Report",
-    "Feature Branch & Working-Tree State",
-    "User Selections",
-    "Executed Commands",
-    "Commit List",
-    "Merge Conflict Probe",
-    "Pull Request Outcome",
-    "Routing Recommendation",
-)
-
-PRESERVED_HEADINGS_ALWAYS: tuple[str, ...] = (
-    "## Verdict Card",
-    "## 0. Clarification Response Carried In",
-    "## 2. Final Verdict",
-    "## 5. Clarification Items",
-    "## 6. Recommended Next Steps",
-    "## 7. Follow-up Tasks",
-)
-
-
-def preserved_substrings(task_type: Optional[str]) -> tuple[str, ...]:
-    """Return every substring slim_markdown MUST keep byte-identical."""
-    extras: tuple[str, ...] = ()
-    if task_type == "implementation-planning":
-        extras = PRESERVED_SUBSTRINGS_PLANNING
-    elif task_type == "implementation":
-        extras = PRESERVED_SUBSTRINGS_IMPLEMENTATION
-    elif task_type == "final-verification":
-        extras = PRESERVED_SUBSTRINGS_FINAL_VERIFICATION
-    elif task_type == "release-handoff":
-        extras = PRESERVED_SUBSTRINGS_RELEASE_HANDOFF
-    return PRESERVED_HEADINGS_ALWAYS + extras
-
-
-# --------------------------------------------------------------------------- #
-# Slim stripper
+# HTML renderer — minimal markdown-to-HTML converter (no external deps)
 # --------------------------------------------------------------------------- #
 
-_HR_PATTERN = re.compile(r"^-{3,}\s*$")
 _BLANK_PATTERN = re.compile(r"^\s*$")
-_RECIPE_QUOTE_PATTERN = re.compile(r"^>\s*\*\*읽는 법\*\*")
-_CLI_COST_ROW_HINT = "Codex/Gemini CLI 추가 비용"
-# Verdict details heading historically lived under ``### 4.5.9 Verdict
-# details`` and is now (post-c2c603d split) written as ``#### Verdict
-# details`` directly under §4.5.9 Plan Body Verification. Match both
-# forms so the slim stripper drops the wide matrix body regardless of
-# which template the report was generated against. The trailing ``$``
-# anchor avoids accidentally matching ``Verdict details (excerpt)`` etc.
-_VERDICT_DETAIL_RE = re.compile(
-    r"^#{3,4}\s+(?:4\.5\.9\s+)?Verdict details\s*$"
-)
-_VERDICT_SUMMARY_RE = re.compile(
-    r"^#{3,4}\s+(?:4\.5\.9\s+)?Verdict summary\s*$"
-)
-_ANY_HEADING_RE = re.compile(r"^#{1,6}\s+\S")
-
-
-def slim_markdown(src_md: str, *, task_type: Optional[str] = None) -> str:
-    """Return a slimmed copy of ``src_md`` per the rules in the module
-    docstring. Deterministic — same input always yields the same output.
-
-    Idempotency note: the returned slim begins with a
-    ``<!-- source-sha256: ... -->`` comment so the validator can detect
-    a stale slim against a later MD. Re-running slim on its own output
-    must produce a byte-identical result, so we first strip the leading
-    digest comment (if any) before re-deriving everything from the
-    normalized body.
-    """
-    src_md = _strip_leading_digest_comment(src_md)
-    lines = src_md.splitlines()
-    out: list[str] = []
-
-    hr_run = 0
-    blank_run = 0
-    in_verdict_detail = False  # inside the §4.5.9 Verdict details wide matrix
-
-    for line in lines:
-        # STRIP_VERDICT_DETAIL — drop body of Verdict details (both
-        # ``### 4.5.9 Verdict details`` and ``#### Verdict details``
-        # forms), keep the heading line itself.
-        if _VERDICT_DETAIL_RE.match(line):
-            in_verdict_detail = True
-            out.append(line)
-            continue
-        if in_verdict_detail:
-            if _ANY_HEADING_RE.match(line):
-                in_verdict_detail = False
-                # fall through and emit this heading
-            else:
-                continue
-
-        # STRIP_INTRO_RECIPE — drop the "> **읽는 법**:" quote paragraph.
-        if _RECIPE_QUOTE_PATTERN.match(line):
-            continue
-
-        # STRIP_TOKEN_PLACEHOLDER_ZEROS — drop $0.00 rows except CLI cost.
-        if _is_zero_cost_row(line) and _CLI_COST_ROW_HINT not in line:
-            continue
-
-        # STRIP_DECORATIVE_HR — collapse runs of horizontal rules.
-        if _HR_PATTERN.match(line):
-            hr_run += 1
-            if hr_run > 1:
-                continue
-        else:
-            hr_run = 0
-
-        # COLLAPSE_BLANK_LINES — collapse 3+ blank lines to one.
-        if _BLANK_PATTERN.match(line):
-            blank_run += 1
-            if blank_run > 1:
-                continue
-        else:
-            blank_run = 0
-
-        out.append(line)
-
-    result = "\n".join(out)
-    # STRIP_DECORATIVE_HR (post-process) — collapse runs of HRs that
-    # were separated only by blank lines (the line scanner above can't
-    # reach across blanks without losing blank-line semantics elsewhere).
-    result = re.sub(r"(?:^---\s*\n(?:\s*\n)*){2,}", "---\n", result, flags=re.MULTILINE)
-    if src_md.endswith("\n") and not result.endswith("\n"):
-        result += "\n"
-
-    _assert_preserved(src_md, result, task_type)
-    # Prepend the source-digest comment so the validator can detect a
-    # stale slim that was generated from an older MD. The digest is
-    # over the slim BODY itself, not over the original MD, so the
-    # validator's expected-slim recomputation embeds the same digest
-    # (any byte difference between expected and actual body shows up
-    # as a mismatched digest).
-    digest_line = f"<!-- source-sha256: {source_digest(result)} -->\n"
-    return digest_line + result
-
-
-def _is_zero_cost_row(line: str) -> bool:
-    """True iff this is a markdown table row whose cost cell is exactly
-    ``$0.00`` and no other meaningful cell content suggests audit
-    relevance.
-    """
-    if not line.lstrip().startswith("|"):
-        return False
-    if "$0.00" not in line:
-        return False
-    # Heuristic — defer to the CLI-cost guard at the caller.
-    return True
-
-
-def _assert_preserved(original: str, slim: str, task_type: Optional[str]) -> None:
-    """Raise AssertionError if any preserved substring was dropped."""
-    missing = [s for s in preserved_substrings(task_type) if s in original and s not in slim]
-    if missing:
-        raise AssertionError(
-            "slim_markdown dropped preserved substring(s): " + ", ".join(missing)
-        )
-
-
-# --------------------------------------------------------------------------- #
-# HTML renderer — minimal markdown-to-HTML converter (no external deps)
-# --------------------------------------------------------------------------- #
 
 _HEADING_PATTERN = re.compile(r"^(#{1,6})\s+(.*?)\s*$")
 _CODEFENCE_PATTERN = re.compile(r"^```(.*)$")
@@ -344,15 +97,14 @@ def render_html(src_md: str, *, run_meta: RunMeta, css: str, js: str) -> str:
     into the document (validator enforces this — see
     validate-report-views.py).
     """
-    # Normalise the input so a digest-bearing leading comment from a
-    # previous slim cycle doesn't leak into the rendered HTML body, then
-    # compute the digest over the normalised MD body. The validator
+    # Compute the digest over the source MD body. The validator
     # recomputes the same digest from the current MD and compares it to
     # the value embedded in run-meta below.
-    src_md = _strip_leading_digest_comment(src_md)
-    body_html = _markdown_to_html(src_md)
-    response_ids = sorted({item.row_id for item in (parse_clarification_items(src_md) or [])})
     digest = source_digest(src_md)
+    body_md = _strip_leading_frontmatter(src_md)
+    body_html, toc_headings = _markdown_to_html(body_md)
+    body_html = _inject_toc(body_html, toc_headings)
+    response_ids = sorted({item.row_id for item in (parse_clarification_items(body_md) or [])})
 
     title = html.escape(f"{run_meta.task_key} — {run_meta.task_type} #{run_meta.seq}")
     response_ids_json = "[" + ",".join('"' + html.escape(rid) + '"' for rid in response_ids) + "]"
@@ -391,15 +143,22 @@ def render_html(src_md: str, *, run_meta: RunMeta, css: str, js: str) -> str:
     )
 
 
-def _markdown_to_html(src_md: str) -> str:
+def _markdown_to_html(
+    src_md: str,
+) -> tuple[str, list[tuple[int, str, str]]]:
     """Tiny line-based markdown→HTML emitter. Handles only what the
     final-report template uses: headings, paragraphs, pipe tables,
     fenced code blocks, blockquotes, ordered+unordered lists, inline
     code/bold/links. Anything outside that surface is passed through
     as escaped text inside a paragraph — there are no extension points.
+
+    Returns ``(body_html, toc_headings)`` where ``toc_headings`` is a
+    list of ``(level, slug, text)`` for every emitted heading in source
+    order. Callers use this to build a navigable table of contents.
     """
     lines = src_md.splitlines()
     out: list[str] = []
+    headings: list[tuple[int, str, str]] = []
     i = 0
     n = len(lines)
     current_section_path: list[str] = []  # ['## 5. ...', '### 5.1 ...'] etc.
@@ -414,6 +173,7 @@ def _markdown_to_html(src_md: str) -> str:
             slug = _slugify(text)
             current_section_path = _update_section_path(current_section_path, level, line)
             out.append(f'<h{level} id="{slug}">{_inline(text)}</h{level}>')
+            headings.append((level, slug, text))
             i += 1
             continue
 
@@ -472,7 +232,48 @@ def _markdown_to_html(src_md: str) -> str:
         if para_lines:
             out.append("<p>" + _inline(" ".join(para_lines)) + "</p>")
 
-    return "\n".join(out)
+    return "\n".join(out), headings
+
+
+_INDEX_BLOCK_RE = re.compile(
+    r'<h2 id="index">Index</h2>\n<ul>.*?</ul>', re.DOTALL
+)
+
+
+def _build_toc(headings: list[tuple[int, str, str]]) -> str:
+    """Render a ``<nav class="toc">`` block from collected h2/h3 entries.
+    h1 (the report title) is omitted; h4+ are too granular for the TOC."""
+    items: list[str] = []
+    for level, slug, text in headings:
+        if level not in (2, 3):
+            continue
+        if slug == "index":  # skip the source "Index" heading itself
+            continue
+        cls = "toc-h2" if level == 2 else "toc-h3"
+        items.append(
+            f'<li class="{cls}"><a href="#{slug}">{_inline(text)}</a></li>'
+        )
+    if not items:
+        return ""
+    return '<nav class="toc" aria-label="Table of contents">' \
+        + '<div class="toc-title">목차</div>' \
+        + "<ul>" + "".join(items) + "</ul>" \
+        + "</nav>"
+
+
+def _inject_toc(body_html: str, headings: list[tuple[int, str, str]]) -> str:
+    """If the source had an ``## Index`` section followed by a bullet
+    list (the template's static TOC), replace it with the auto-built
+    nav. Otherwise prepend the nav at the top of the body so readers
+    still get a navigation aid. If no h2/h3 headings exist the body is
+    returned unchanged.
+    """
+    nav = _build_toc(headings)
+    if not nav:
+        return body_html
+    if _INDEX_BLOCK_RE.search(body_html):
+        return _INDEX_BLOCK_RE.sub(nav, body_html, count=1)
+    return nav + "\n" + body_html
 
 
 def _update_section_path(path: list[str], level: int, line: str) -> list[str]:
@@ -507,9 +308,20 @@ def _emit_table(lines: list[str], start: int, section_path: list[str]) -> tuple[
         and "Status" in header_cells
     )
 
+    narrow_cols = _narrow_columns(header_cells, rows)
+    # `User input` carries the embedded form widget (textarea / select /
+    # input) which needs all the horizontal space it can get; its
+    # markdown plain text is empty or a short placeholder so the auto
+    # detector would otherwise flag it as narrow. Force it wide.
+    if "User input" in header_cells:
+        narrow_cols.discard(header_cells.index("User input"))
+
     head = (
         "<thead><tr>"
-        + "".join(f"<th>{_inline(c)}</th>" for c in header_cells)
+        + "".join(
+            f"<th{_col_class(idx, narrow_cols)}>{_inline(c)}</th>"
+            for idx, c in enumerate(header_cells)
+        )
         + "</tr></thead>"
     )
 
@@ -517,6 +329,10 @@ def _emit_table(lines: list[str], start: int, section_path: list[str]) -> tuple[
     id_col = header_cells.index("ID") if "ID" in header_cells else -1
     kind_col = header_cells.index("Kind") if "Kind" in header_cells else -1
     status_col = header_cells.index("Status") if "Status" in header_cells else -1
+    statement_col = next(
+        (i for i, h in enumerate(header_cells) if h.startswith("Statement")),
+        -1,
+    )
     user_input_col = (
         header_cells.index("User input") if "User input" in header_cells else -1
     )
@@ -531,14 +347,21 @@ def _emit_table(lines: list[str], start: int, section_path: list[str]) -> tuple[
             response_id = row[id_col]
             kind = row[kind_col] if 0 <= kind_col < len(row) else ""
             status = row[status_col] if 0 <= status_col < len(row) else ""
+            statement = (
+                row[statement_col]
+                if 0 <= statement_col < len(row)
+                else ""
+            )
             cells_html: list[str] = []
             for idx, cell in enumerate(row):
                 if idx == user_input_col:
                     cells_html.append(
-                        f"<td>{_form_control(response_id, kind, status, cell)}</td>"
+                        f"<td>{_form_control(response_id, kind, status, cell, statement)}</td>"
                     )
                 else:
-                    cells_html.append(f"<td>{_inline(cell)}</td>")
+                    cells_html.append(
+                        f"<td{_col_class(idx, narrow_cols)}>{_inline(cell)}</td>"
+                    )
             body_rows.append(
                 f'<tr data-response-id="{html.escape(response_id)}" '
                 f'data-kind="{html.escape(kind)}" '
@@ -548,22 +371,109 @@ def _emit_table(lines: list[str], start: int, section_path: list[str]) -> tuple[
             )
         else:
             body_rows.append(
-                "<tr>" + "".join(f"<td>{_inline(c)}</td>" for c in row) + "</tr>"
+                "<tr>"
+                + "".join(
+                    f"<td{_col_class(idx, narrow_cols)}>{_inline(c)}</td>"
+                    for idx, c in enumerate(row)
+                )
+                + "</tr>"
             )
 
     body = "<tbody>" + "".join(body_rows) + "</tbody>"
     return f"<table>{head}{body}</table>", i - start
 
 
-def _form_control(response_id: str, kind: str, status: str, current_value: str) -> str:
+_ENUM_LETTERS = "abcde"
+_ENUM_CUE_WORDS: tuple[str, ...] = (
+    "권장은", "권장 ", "추천은", "추천 ", "사유:", "사유 ", "근거:",
+)
+
+
+def _parse_enum_options(statement: str) -> list[tuple[str, str]]:
+    """Return ``[(letter, text)]`` pairs if ``statement`` looks like a
+    ``(a) X (b) Y (c) Z`` enumeration, else ``[]``. Stops at the first
+    recommendation cue (``권장``/``추천``/``사유``/``근거``) so the
+    "(c) — recommended because ..." tail doesn't leak into the last
+    option's text. Requires ≥ 2 options to trigger select rendering.
+    """
+    if not statement:
+        return []
+    out: list[tuple[str, str]] = []
+    cursor = 0
+    for i, letter in enumerate(_ENUM_LETTERS):
+        anchor = f"({letter}) "
+        idx = statement.find(anchor, cursor)
+        if idx < 0:
+            break
+        start = idx + len(anchor)
+        end_candidates: list[int] = []
+        if i + 1 < len(_ENUM_LETTERS):
+            n_idx = statement.find(f"({_ENUM_LETTERS[i + 1]}) ", start)
+            if n_idx >= 0:
+                end_candidates.append(n_idx)
+        for cue in _ENUM_CUE_WORDS:
+            c_idx = statement.find(cue, start)
+            if c_idx >= 0:
+                end_candidates.append(c_idx)
+        end = min(end_candidates) if end_candidates else len(statement)
+        text = statement[start:end].strip(" .,—-")
+        if not text:
+            break
+        out.append((letter, text))
+        cursor = end
+    return out if len(out) >= 2 else []
+
+
+def _form_control(
+    response_id: str,
+    kind: str,
+    status: str,
+    current_value: str,
+    statement: str = "",
+) -> str:
     rid = html.escape(response_id)
     disabled = "" if status.lower() in ("open", "answered", "") else " disabled"
     safe_value = html.escape(current_value or "")
+    kind_lc = kind.lower()
     placeholder = {
         "material": "파일 경로 또는 본문",
         "decision": "선택 또는 짧은 응답",
         "data-point": "값",
-    }.get(kind.lower(), "응답")
+    }.get(kind_lc, "응답")
+
+    # decision 인 경우 statement 에서 (a)(b)(c) 후보를 추출해 select+기타 input 으로 렌더.
+    if kind_lc == "decision":
+        opts = _parse_enum_options(statement)
+        if opts:
+            select_opts = "".join(
+                f'<option value="{letter}">'
+                f'{_inline(f"({letter}) " + text)}</option>'
+                for letter, text in opts
+            )
+            select_html = (
+                f'<select name="{rid}" data-response-id="{rid}" '
+                f'data-kind="{html.escape(kind)}"{disabled}>'
+                '<option value="">(선택)</option>'
+                f"{select_opts}"
+                '<option value="__other__">기타 (직접 입력)</option>'
+                "</select>"
+            )
+            other_html = (
+                f' <input type="text" data-other-for="{rid}" '
+                f'placeholder="기타 응답"{disabled} hidden value="{safe_value}">'
+            )
+            return select_html + other_html
+
+    # material/data-point 류는 짧은 단일값. 텍스트 인풋으로.
+    if kind_lc in ("material", "data-point"):
+        return (
+            f'<input type="text" name="{rid}" data-response-id="{rid}" '
+            f'data-kind="{html.escape(kind)}" '
+            f'placeholder="{html.escape(placeholder)}"{disabled} '
+            f'value="{safe_value}">'
+        )
+
+    # 그 외 (decision-without-enum 포함) — 자유 본문은 textarea 유지.
     return (
         f'<textarea name="{rid}" data-response-id="{rid}" '
         f'data-kind="{html.escape(kind)}" rows="2" '
@@ -599,6 +509,86 @@ def _emit_list(lines: list[str], start: int) -> tuple[str, int]:
     return f"<{tag}>" + "".join(items) + f"</{tag}>", i - start
 
 
+_NARROW_COL_MAX_PLAIN_LEN = 30
+
+_INLINE_MD_STRIP_RE = re.compile(r"[`*_]")
+
+# Header-name whitelist: columns whose width is effectively fixed by
+# convention even when one row carries a long body cell (e.g. "출처"
+# starts with a short token but the prose body of a single citation
+# row may run 60+ chars). Matched as case-insensitive prefix on the
+# header's first plain token, so "Ticket ID" / "출처 (brief/source/worker)"
+# / "환산 토큰 (input 기준)" all hit the same entry. Keep this list
+# tight — every entry is a promise that the column is *always* one of
+# a handful of canonical short values across every final-report.
+_NARROW_HEADER_PREFIXES: tuple[str, ...] = (
+    # English / latin
+    "id",
+    "ticket id",
+    "kind",
+    "status",
+    "blocks",
+    "origin",
+    "priority",
+    "auto-spawn",
+    # Korean
+    "출처",
+    "에이전트",
+    "역할",
+    "모델",
+    "상태",
+    "항목",
+    "처리 토큰",
+    "환산 토큰",
+    "비용",
+)
+
+
+def _plain_len(raw_cell: str) -> int:
+    return len(_INLINE_MD_STRIP_RE.sub("", raw_cell or "").strip())
+
+
+def _matches_narrow_whitelist(header: str) -> bool:
+    plain = _INLINE_MD_STRIP_RE.sub("", header or "").strip().lower()
+    return any(plain.startswith(p) for p in _NARROW_HEADER_PREFIXES)
+
+
+def _narrow_columns(
+    header_cells: list[str], rows: list[list[str]]
+) -> set[int]:
+    """Return the set of column indices that should render with the
+    fixed-narrow ``td-narrow`` width (5% under report.css).
+
+    A column qualifies when EITHER:
+      (a) its header matches `_NARROW_HEADER_PREFIXES` — these are
+          ``ID`` / ``출처`` / ``에이전트`` etc. whose values are
+          conventionally short across every final-report even when a
+          single row drops in 60+ chars of prose; OR
+      (b) every cell in the column (header + body) fits within
+          ``_NARROW_COL_MAX_PLAIN_LEN`` plain chars — this catches
+          ad-hoc short columns that the whitelist did not anticipate.
+
+    Per-column (not per-cell) so the verdict applies uniformly across
+    the column even when one neighbouring column holds long-form text.
+    """
+    narrow: set[int] = set()
+    for col, header in enumerate(header_cells):
+        if _matches_narrow_whitelist(header):
+            narrow.add(col)
+            continue
+        max_len = _plain_len(header)
+        for row in rows:
+            if col < len(row):
+                max_len = max(max_len, _plain_len(row[col]))
+        if max_len <= _NARROW_COL_MAX_PLAIN_LEN:
+            narrow.add(col)
+    return narrow
+
+
+def _col_class(col_idx: int, narrow_cols: set[int]) -> str:
+    return ' class="td-narrow"' if col_idx in narrow_cols else ""
+
+
 def _inline(text: str) -> str:
     out = html.escape(text)
     # Restore inline markdown after escaping (we re-process the escaped
@@ -674,28 +664,17 @@ def serialize_user_response(
 # Convenience entrypoint for tests + CLI.
 # --------------------------------------------------------------------------- #
 
-def render_both_views(
+def render_html_view(
     src_md_path: Path,
     *,
     run_meta: RunMeta,
     css: str,
     js: str,
-) -> tuple[Path, Path]:
-    """Write ``*.slim.md`` and ``*.html`` next to ``src_md_path`` and
-    return their paths. Idempotent."""
+) -> Path:
+    """Write ``<stem>.html`` next to ``src_md_path`` and return its
+    path. Idempotent — overwrites the existing html sibling."""
     src_text = src_md_path.read_text(encoding="utf-8")
-
-    slim_path = src_md_path.with_suffix(".slim.md")
-    if src_md_path.suffix == ".md":
-        # ``with_suffix`` replaces the LAST suffix only; we want
-        # ``foo.md`` → ``foo.slim.md`` (insert before ``.md``).
-        slim_path = src_md_path.with_name(src_md_path.stem + ".slim.md")
-
     html_path = src_md_path.with_name(src_md_path.stem + ".html")
-
-    slim_text = slim_markdown(src_text, task_type=run_meta.task_type)
     html_text = render_html(src_text, run_meta=run_meta, css=css, js=js)
-
-    slim_path.write_text(slim_text, encoding="utf-8")
     html_path.write_text(html_text, encoding="utf-8")
-    return slim_path, html_path
+    return html_path