okstra 0.30.3 → 0.32.0

package/runtime/templates/reports/report.css

@@ -41,11 +41,38 @@ body {
 .report-header > div { flex: 1; font-weight: 600; }
 
 main {
-  max-width: 80ch;
+  max-width: 120ch;
   margin: 1.5rem auto;
   padding: 0 1rem 4rem;
 }
 
+nav.toc {
+  margin: 1rem 0 2rem;
+  padding: 0.6em 1em;
+  border: 1px solid color-mix(in srgb, GrayText 40%, transparent);
+  border-radius: 4px;
+  background: color-mix(in srgb, CanvasText 4%, transparent);
+}
+nav.toc .toc-title {
+  font-weight: 600;
+  margin-bottom: 0.4em;
+  font-size: 0.95rem;
+}
+nav.toc ul {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  columns: 2;
+  column-gap: 1.5em;
+}
+@media (max-width: 60ch) {
+  nav.toc ul { columns: 1; }
+}
+nav.toc li { margin: 0.15em 0; break-inside: avoid; }
+nav.toc li.toc-h3 { padding-left: 1.2em; font-size: 0.92em; }
+nav.toc a { color: inherit; text-decoration: none; }
+nav.toc a:hover { text-decoration: underline; }
+
 h1, h2, h3, h4, h5, h6 { line-height: 1.25; margin-top: 1.6em; margin-bottom: 0.4em; }
 h1 { font-size: 1.7rem; }
 h2 { font-size: 1.35rem; border-bottom: 1px solid GrayText; padding-bottom: 0.2em; }
@@ -88,6 +115,22 @@ th, td {
   padding: 0.45em 0.6em;
   vertical-align: top;
   text-align: left;
+  word-break: keep-all;
+  overflow-wrap: anywhere;
+  min-width: 5ch;
+  /* No max-width: cells that carry prose (statement / source / scope)
+   * absorb the remaining horizontal space within `main`'s 120ch. */
+}
+/* Narrow columns — header AND every body cell of this column fit
+ * within 30 plain chars (per `_narrow_columns()` in report_views.py).
+ * Examples: ID, Ticket ID, Kind, Status, Priority, Auto-spawn?,
+ * 에이전트, 역할, 모델, 상태. Pinning `width: 5%` makes these
+ * columns shrink toward the suggestion while wide neighbours absorb
+ * the remainder, so a long-prose row never squashes ID-style stacks
+ * into one-character ladders. */
+td.td-narrow, th.td-narrow {
+  width: 5%;
+  white-space: nowrap;
 }
 thead th {
   position: sticky;
@@ -105,18 +148,28 @@ tr[data-response-id][data-status="obsolete"] {
   opacity: 0.65;
 }
 
-textarea {
+textarea,
+select[data-response-id],
+input[data-response-id],
+input[data-other-for] {
   width: 100%;
-  min-height: 2.2em;
   font: inherit;
   padding: 0.3em 0.4em;
   border: 1px solid GrayText;
   border-radius: 3px;
   background: Canvas;
   color: CanvasText;
+}
+textarea {
+  min-height: 2.2em;
   resize: vertical;
 }
-textarea[disabled] { opacity: 0.55; }
+input[data-other-for] {
+  margin-top: 0.35em;
+}
+textarea[disabled],
+select[disabled],
+input[disabled] { opacity: 0.55; }
 
 button[data-action] {
   font: inherit;

package/runtime/templates/reports/report.js

@@ -1,10 +1,14 @@
 /* Client-side glue for the okstra final-report HTML view.
  *
  * Responsibilities:
- *   1. Collect <textarea> values for every <tr data-response-id> whose
- *      Status is open/answered (disabled rows are skipped automatically).
- *   2. Serialise them into markdown whose bytes are IDENTICAL to
- *      scripts/okstra_ctl/report_views.py serialize_user_response.
+ *   1. Collect entry values for every <tr data-response-id> whose
+ *      Status is open/answered (disabled rows skipped automatically).
+ *      Widgets: <select> (enum decision), <input data-other-for> (기타
+ *      input revealed when select == "__other__"), <input
+ *      data-response-id> (material/data-point single-line), <textarea>
+ *      (everything else / fallback).
+ *   2. Serialise the entries into markdown whose bytes are IDENTICAL
+ *      to scripts/okstra_ctl/report_views.py serialize_user_response.
  *   3. Write the result to <pre id="user-response-output"> and offer a
  *      [Copy] button.
  *
@@ -36,14 +40,46 @@
     return String(s == null ? "" : s).replace(/^\s+|\s+$/g, "");
   }
 
+  // Read the user-supplied value out of one clarification row. Returns
+  // the empty string when the row has no usable widget, the widget is
+  // disabled, the select sits on its blank "(선택)" placeholder, or the
+  // "기타" branch has an empty input. Caller decides whether to emit
+  // an entry.
+  function readRowValue(row) {
+    var sel = row.querySelector("select[data-response-id]");
+    if (sel) {
+      if (sel.disabled) return "";
+      var picked = sel.value;
+      if (picked === "") return "";
+      if (picked === "__other__") {
+        var rid = sel.getAttribute("data-response-id") || "";
+        var other = row.querySelector('input[data-other-for="' + rid + '"]');
+        return other ? trimMultiline(other.value) : "";
+      }
+      var opt = sel.options[sel.selectedIndex];
+      // Use the visible option text ("(a) one-time backfill") so the
+      // user-response sidecar stays human-readable, not just "a".
+      return opt ? trimMultiline(opt.textContent) : picked;
+    }
+    var ta = row.querySelector("textarea[data-response-id]");
+    if (ta) {
+      if (ta.disabled) return "";
+      return trimMultiline(ta.value);
+    }
+    var inp = row.querySelector("input[data-response-id]");
+    if (inp) {
+      if (inp.disabled) return "";
+      return trimMultiline(inp.value);
+    }
+    return "";
+  }
+
   function collectEntries() {
     var entries = [];
     var rows = document.querySelectorAll("tr[data-response-id]");
     for (var i = 0; i < rows.length; i++) {
       var row = rows[i];
-      var ta = row.querySelector("textarea[data-response-id]");
-      if (!ta || ta.disabled) continue;
-      var value = trimMultiline(ta.value);
+      var value = readRowValue(row);
       if (!value) continue;
       entries.push({
         responseId: row.getAttribute("data-response-id") || "",
@@ -55,6 +91,25 @@
     return entries;
   }
 
+  // Toggle the visibility of the "기타" companion input next to each
+  // select whose current value is "__other__". Wired at bind() time and
+  // also called once for the initial state.
+  function bindOtherInputToggle() {
+    var selects = document.querySelectorAll("select[data-response-id]");
+    for (var i = 0; i < selects.length; i++) {
+      (function (sel) {
+        var rid = sel.getAttribute("data-response-id") || "";
+        var other = document.querySelector('input[data-other-for="' + rid + '"]');
+        if (!other) return;
+        var update = function () {
+          other.hidden = sel.value !== "__other__";
+        };
+        sel.addEventListener("change", update);
+        update();
+      })(selects[i]);
+    }
+  }
+
   function buildUserResponseMarkdown(runMeta, entries, createdAt) {
     var head =
       "---\n" +
@@ -132,6 +187,7 @@
         btn.addEventListener("click", copyUserResponse);
       }
     }
+    bindOtherInputToggle();
   }
 
   if (typeof window !== "undefined") {

package/runtime/templates/reports/settings.template.json

@@ -135,6 +135,7 @@
       "Bash(npx -y okstra@latest:*)",
       "Bash($HOME/.okstra/bin/:*)",
       "Bash(STATE_FILE=:*)",
+      "Bash(ROOT=:*)",
 
       "Bash(gemini)",
       "Bash(gemini:*)",

package/runtime/validators/lib/fixtures.sh

@@ -366,21 +366,21 @@ report_lines.extend(
 report_path.parent.mkdir(parents=True, exist_ok=True)
 report_path.write_text("\n".join(report_lines) + "\n")
 
-# Phase 7 step 1.5 (BLOCKING) — render the slim/html sibling artifacts
-# next to the final-report so validate-run.py's new report-views hook
-# passes. The workflow validator's fixture predates that step; we
-# materialise both files in-place using the same single-reference-point
-# helper the CLI uses.
+# Phase 7 step 1.5 (BLOCKING) — render the html sibling artifact next
+# to the final-report so validate-run.py's report-views hook passes.
+# The workflow validator's fixture predates that step; we materialise
+# the html file in-place using the same single-reference-point helper
+# the CLI uses.
 import os
 WORKSPACE_ROOT = os.environ.get("OKSTRA_WORKSPACE_ROOT_FOR_FIXTURE", "")
 if WORKSPACE_ROOT:
     import sys as _sys
     _sys.path.insert(0, str(Path(WORKSPACE_ROOT) / "scripts"))
     try:
-        from okstra_ctl.report_views import RunMeta, render_both_views
+        from okstra_ctl.report_views import RunMeta, render_html_view
         css = (Path(WORKSPACE_ROOT) / "templates" / "reports" / "report.css").read_text(encoding="utf-8")
         js = (Path(WORKSPACE_ROOT) / "templates" / "reports" / "report.js").read_text(encoding="utf-8")
-        render_both_views(
+        render_html_view(
             report_path,
             run_meta=RunMeta(
                 task_key=str(task_manifest.get("taskKey", "validation/fixture")),

package/runtime/validators/validate-report-views.py

@@ -1,20 +1,17 @@
 #!/usr/bin/env python3
-"""Validate the two derived final-report views produced by Phase 7 step
-1.5 (``scripts/okstra-render-report-views.py``).
+"""Validate the self-contained HTML view produced by Phase 7 step 1.5
+(``scripts/okstra-render-report-views.py``).
 
 Checks, for a given final-report MD path:
-  1. ``*.slim.md`` and ``*.html`` siblings both exist.
-  2. Slim preserves every phase-required substring from ``validate-run.py``
-     byte-identically (drift fence vs the report_views module).
-  3. HTML body (``<main>`` slice) contains the same plain-text
-     substrings (after html.unescape and the markdown ``#`` prefix is
-     stripped).
-  4. HTML's §4.6 / §4.7 / §4.8 deliverable regions contain no
+  1. ``*.html`` sibling exists.
+  2. HTML's ``source-sha256`` in run-meta matches the current MD body —
+     stale html detection.
+  3. HTML's §4.6 / §4.7 / §4.8 deliverable regions contain no
      ``<textarea>`` / ``<input>`` / ``<select>`` (form-attach is
      restricted to §5 clarification rows).
-  5. HTML has no external URLs in ``<script src=>`` / ``<link href=>`` /
+  4. HTML has no external URLs in ``<script src=>`` / ``<link href=>`` /
      ``<img src=>`` — self-contained guarantee.
-  6. Every Response ID in HTML matches the §5 Clarification Items table
+  5. Every Response ID in HTML matches the §5 Clarification Items table
      of the source MD (1:1).
 
 Exit codes: 0 on success, 1 on any failure. Failures are printed one
@@ -23,12 +20,9 @@ per line to stderr.
 from __future__ import annotations
 
 import argparse
-import html as html_lib
-import importlib.util
 import re
 import sys
 from pathlib import Path
-from typing import Iterable
 
 REPO_ROOT = Path(__file__).resolve().parents[1]
 SCRIPTS_DIR = REPO_ROOT / "scripts"
@@ -37,31 +31,17 @@ if str(SCRIPTS_DIR) not in sys.path:
 
 from okstra_ctl.clarification_items import parse_clarification_items  # noqa: E402
 from okstra_ctl.report_views import (  # noqa: E402
-    _strip_leading_digest_comment,
     extract_html_digest,
-    extract_slim_digest,
-    preserved_substrings,
-    slim_markdown,
     source_digest,
 )
 
 
-def _load_validate_run() -> object:
-    """Dynamically load validate-run.py — it's a stand-alone script
-    with a hyphenated name, not an importable module. We snapshot the
-    substring lists from it so drift between the two files surfaces
-    here rather than silently in production."""
-    path = REPO_ROOT / "validators" / "validate-run.py"
-    spec = importlib.util.spec_from_file_location("_okstra_validate_run", path)
-    assert spec and spec.loader, f"cannot load {path}"
-    mod = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(mod)
-    return mod
-
+_EXTERNAL_URL_RE = re.compile(
+    r'<(?:script|link|img|iframe|source|video|audio)\s[^>]*?(?:src|href)\s*=\s*["\']https?://',
+    re.IGNORECASE,
+)
 
-def _detect_task_type(md: str) -> str | None:
-    m = re.search(r"^- Task Type:\s*(\S+)", md, re.MULTILINE)
-    return m.group(1).strip() if m else None
+_RESPONSE_ID_ATTR_RE = re.compile(r'data-response-id="(C-\d+)"')
 
 
 def _main_body(html_text: str) -> str:
@@ -72,25 +52,6 @@ def _main_body(html_text: str) -> str:
     return html_text[start + len("<main>"): end]
 
 
-def _strip_md_prefix(sub: str) -> str:
-    s = sub
-    while s.startswith("#"):
-        s = s[1:]
-    return s.strip()
-
-
-_EXTERNAL_URL_RE = re.compile(
-    r'<(?:script|link|img|iframe|source|video|audio)\s[^>]*?(?:src|href)\s*=\s*["\']https?://',
-    re.IGNORECASE,
-)
-
-_RESPONSE_ID_ATTR_RE = re.compile(r'data-response-id="(C-\d+)"')
-
-_NO_FORM_HEADING_RE = re.compile(
-    r"<h[23][^>]*>\s*(?:4\.6|4\.7|4\.8)[\s\S]*?</h[23]>"
-)
-
-
 def _no_form_sections(html_body: str) -> list[str]:
     """Return a list of strings, each being the rendered chunk of a
     no-form section (4.6 / 4.7 / 4.8) up to the next h2/h3. Used to
@@ -118,50 +79,21 @@ def validate(report_path: Path) -> list[str]:
         return [f"final-report not found: {report_path}"]
 
     md = report_path.read_text(encoding="utf-8")
-    task_type = _detect_task_type(md)
-    slim_path = report_path.with_name(report_path.stem + ".slim.md")
     html_path = report_path.with_name(report_path.stem + ".html")
 
-    # (1) sibling artifacts exist
-    if not slim_path.is_file():
-        failures.append(f"missing slim artifact: {slim_path}")
+    # (1) sibling artifact exists
     if not html_path.is_file():
-        failures.append(f"missing html artifact: {html_path}")
-    if failures:
-        return failures
+        return [f"missing html artifact: {html_path}"]
 
-    slim = slim_path.read_text(encoding="utf-8")
     html_text = html_path.read_text(encoding="utf-8")
     html_body = _main_body(html_text)
-    html_body_text = html_lib.unescape(html_body)
 
-    # (2a) source-digest staleness — both derived views must carry the
-    # sha256 of the artifact derived from the *current* MD. A mismatch
-    # means the views were rendered against an older MD body and Phase
-    # 7 step 1.5 was not re-run.
-    #   - HTML digest is over the MD body (after stripping any stale
-    #     leading digest comment), so the expected value is the digest
-    #     of the current MD itself.
-    #   - slim digest is over the slim BODY (so any byte-difference
-    #     between expected and actual slim shows up as a digest
-    #     mismatch). We recompute the expected slim and extract its
-    #     embedded digest for comparison — equivalent to but cheaper
-    #     than diffing the full body.
-    expected_md_digest = source_digest(_strip_leading_digest_comment(md))
-    expected_slim_digest = extract_slim_digest(
-        slim_markdown(md, task_type=task_type)
-    )
-    slim_digest = extract_slim_digest(slim)
+    # (2) source-digest staleness — html's run-meta source-sha256 must
+    # match the current MD's digest. Mismatch means the html was
+    # rendered against an older MD body and Phase 7 step 1.5 was not
+    # re-run.
+    expected_md_digest = source_digest(md)
     html_digest = extract_html_digest(html_text)
-    if slim_digest is None:
-        failures.append(
-            "slim missing source-sha256 header — re-render with okstra render-views"
-        )
-    elif slim_digest != expected_slim_digest:
-        failures.append(
-            f"stale slim: body sha256 {slim_digest[:12]}… does not match "
-            f"current MD's rendered slim {str(expected_slim_digest)[:12]}…"
-        )
     if html_digest is None:
         failures.append(
             "html missing source-sha256 in run-meta — re-render with okstra render-views"
@@ -172,31 +104,7 @@ def validate(report_path: Path) -> list[str]:
             f"current MD {expected_md_digest[:12]}…"
         )
 
-    # (2b) drift fence: report_views.preserved_substrings(task_type)
-    #      must agree with validate-run.py's tuples for the same task_type.
-    vr = _load_validate_run()
-    drift = _diff_substring_lists(task_type, vr)
-    failures.extend(drift)
-
-    # (3) slim preserves every required substring byte-identically
-    for sub in preserved_substrings(task_type):
-        if sub in md and sub not in slim:
-            failures.append(f"slim dropped required substring: {sub!r}")
-        # Also forward-check against validate-run.py's tuples so a
-        # future addition there fails this validator immediately.
-    for sub in _validate_run_substrings(task_type, vr):
-        if sub in md and sub not in slim:
-            failures.append(f"slim dropped validate-run substring: {sub!r}")
-
-    # (4) html preserves the same set (modulo md prefix + html.escape)
-    for sub in preserved_substrings(task_type):
-        if sub not in md:
-            continue
-        needle = _strip_md_prefix(sub)
-        if needle not in html_body_text:
-            failures.append(f"html body dropped substring: {needle!r}")
-
-    # (5) deliverable sections contain no form controls
+    # (3) deliverable sections contain no form controls
     for chunk in _no_form_sections(html_body):
         if "<textarea" in chunk or "<input" in chunk or "<select" in chunk:
             failures.append(
@@ -204,11 +112,11 @@ def validate(report_path: Path) -> list[str]:
             )
             break
 
-    # (6) no external URLs in <script src> / <link href> / etc.
+    # (4) no external URLs in <script src> / <link href> / etc.
     if _EXTERNAL_URL_RE.search(html_text):
         failures.append("html contains external URL in script/link/img — must be self-contained")
 
-    # (7) Response ID parity: HTML form rows ↔ §5 C-* rows in MD.
+    # (5) Response ID parity: HTML form rows ↔ §5 C-* rows in MD.
     # Bidirectional — catches both "MD has C-* the HTML lost" AND
     # "HTML has stale C-* that the current MD no longer declares".
     md_ids = _md_response_ids(md)
@@ -221,43 +129,6 @@ def validate(report_path: Path) -> list[str]:
     return failures
 
 
-def _validate_run_substrings(task_type: str | None, vr) -> Iterable[str]:
-    if task_type == "implementation":
-        return getattr(vr, "IMPLEMENTATION_REQUIRED_SECTIONS", ())
-    if task_type == "final-verification":
-        return getattr(vr, "FINAL_VERIFICATION_REQUIRED_SECTIONS", ())
-    return ()
-
-
-def _diff_substring_lists(task_type: str | None, vr) -> list[str]:
-    """Surface drift between report_views and validate-run substring
-    tuples. The two MUST stay in lock-step."""
-    failures: list[str] = []
-    from okstra_ctl.report_views import (
-        PRESERVED_SUBSTRINGS_IMPLEMENTATION,
-        PRESERVED_SUBSTRINGS_FINAL_VERIFICATION,
-    )
-    impl_vr = set(getattr(vr, "IMPLEMENTATION_REQUIRED_SECTIONS", ()))
-    impl_rv = set(PRESERVED_SUBSTRINGS_IMPLEMENTATION)
-    if impl_vr != impl_rv:
-        missing_in_views = impl_vr - impl_rv
-        extra_in_views = impl_rv - impl_vr
-        failures.append(
-            "drift: PRESERVED_SUBSTRINGS_IMPLEMENTATION vs validate-run "
-            f"IMPLEMENTATION_REQUIRED_SECTIONS — missing in views {missing_in_views or '∅'}, "
-            f"extra in views {extra_in_views or '∅'}"
-        )
-    fv_vr = set(getattr(vr, "FINAL_VERIFICATION_REQUIRED_SECTIONS", ()))
-    fv_rv = set(PRESERVED_SUBSTRINGS_FINAL_VERIFICATION)
-    if fv_vr != fv_rv:
-        failures.append(
-            "drift: PRESERVED_SUBSTRINGS_FINAL_VERIFICATION vs validate-run "
-            f"FINAL_VERIFICATION_REQUIRED_SECTIONS — missing in views {fv_vr - fv_rv or '∅'}, "
-            f"extra in views {fv_rv - fv_vr or '∅'}"
-        )
-    return failures
-
-
 def _md_response_ids(md: str) -> list[str]:
     items = parse_clarification_items(md) or []
     return sorted({it.row_id for it in items if re.fullmatch(r"C-\d+", it.row_id)})
@@ -265,7 +136,7 @@ def _md_response_ids(md: str) -> list[str]:
 
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(
-        description="Validate slim/html derived views of an okstra final-report."
+        description="Validate the self-contained HTML view of an okstra final-report."
     )
     parser.add_argument(
         "report_path",