okstra 0.44.0 → 0.45.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.44.0",
+  "version": "0.45.1",
   "description": "Multi-agent cross-verification orchestrator runtime + Claude Code skills.",
   "license": "MIT",
   "author": "devonshin",

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.44.0",
-  "builtAt": "2026-06-04T05:25:22.876Z",
+  "package": "0.45.1",
+  "builtAt": "2026-06-04T08:12:55.290Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/prompts/wizard/prompts.ko.json

@@ -229,11 +229,11 @@
       }
     },
     "defaults_or_custom": {
-      "label": "기본 워커/모델로 진행할까요, 아니면 커스터마이즈할까요?",
+      "label": "역할별로 어떤 모델을 쓸지 정하는 단계입니다 (참여 워커 구성을 바꾸는 게 아닙니다).\n· 기본값으로 진행 — lead·실행자/워커·report-writer 를 모두 추천 모델로 두고 바로 진행합니다.\n· 커스터마이즈 — 역할별 모델을 직접 고르고, 추가 directive·관련 task 도 지정합니다.",
       "echo_template": "customize: {value}",
       "options": {
-        "defaults": "Use defaults",
-        "customize": "Customize"
+        "defaults": "기본값으로 진행 (역할별 추천 모델 그대로)",
+        "customize": "커스터마이즈 (역할별 모델 직접 선택)"
       }
     },
     "workers_override": {

package/runtime/python/okstra_ctl/report_views.py

@@ -300,6 +300,10 @@ def _emit_table(lines: list[str], start: int, section_path: list[str]) -> tuple[
         rows.append(_split_pipe_row(lines[i]))
         i += 1
 
+    grouped_spec = _grouped_table_spec(header_cells, section_path)
+    if grouped_spec is not None:
+        return _emit_grouped_table(header_cells, rows, grouped_spec), i - start
+
     is_clarification_table = (
         not _section_forbids_form(section_path)
         and any("Clarification Items" in h for h in section_path)
@@ -383,6 +387,172 @@ def _emit_table(lines: list[str], start: int, section_path: list[str]) -> tuple[
     return f"<table>{head}{body}</table>", i - start
 
 
+@dataclass(frozen=True)
+class _GroupedSpec:
+    """Plan for rendering a wide table as a compact grouped layout: the
+    short columns (``group_cols``) collapse into one stacked ``key:
+    value`` metadata cell led by ``headline_col``; the long columns
+    (``wide_cols``) each keep their own min-width column.
+
+    ``kind == "clarification"`` additionally re-attaches the §5 form
+    widget to the ``user_input_col`` cell and the ``data-*`` row attrs."""
+    headline_col: int
+    group_cols: tuple[int, ...]
+    wide_cols: tuple[int, ...]
+    kind: str  # "plain" | "clarification"
+    id_col: int = -1
+    kind_col: int = -1
+    status_col: int = -1
+    statement_col: int = -1
+    user_input_col: int = -1
+
+
+_FOLLOWUP_WIDE_PREFIXES: tuple[str, ...] = ("title", "scope", "reason")
+
+
+def _grouped_table_spec(
+    header_cells: list[str], section_path: list[str]
+) -> Optional[_GroupedSpec]:
+    """Return a ``_GroupedSpec`` for the three wide final-report tables
+    that benefit from the compact layout — Execution Status, §5
+    Clarification Items, §7 Follow-up Tasks — or ``None`` for every other
+    table (which keeps the default per-cell ``td-narrow`` rendering).
+
+    Each table is identified by stable header tokens (the i18n token/cost
+    columns are never used as anchors). ``wide_cols`` lists the long-prose
+    columns that must keep a guaranteed min-width; everything else short
+    collapses into the leading metadata cell."""
+    norm = [h.strip() for h in header_cells]
+
+    def _spec(headline: int, wide: tuple[int, ...], **kw) -> _GroupedSpec:
+        wide_set = set(wide)
+        group = tuple(c for c in range(len(norm)) if c != headline and c not in wide_set)
+        return _GroupedSpec(headline_col=headline, group_cols=group, wide_cols=wide, **kw)
+
+    # Execution Status by Agent — Agent … Summary of Key Findings.
+    if len(norm) >= 3 and norm[0] == "Agent" and norm[-1] == "Summary of Key Findings":
+        return _spec(0, (len(norm) - 1,), kind="plain")
+
+    # §5 Clarification Items — keep the interactive form, but collapse the
+    # short ID/Kind/Status/… columns and widen Statement + User input.
+    if (
+        any("Clarification Items" in h for h in section_path)
+        and not _section_forbids_form(section_path)
+        and "ID" in norm
+        and "User input" in norm
+        and any(h.startswith("Statement") for h in norm)
+    ):
+        statement_col = next(i for i, h in enumerate(norm) if h.startswith("Statement"))
+        user_input_col = norm.index("User input")
+        return _spec(
+            norm.index("ID"),
+            (statement_col, user_input_col),
+            kind="clarification",
+            id_col=norm.index("ID"),
+            kind_col=norm.index("Kind") if "Kind" in norm else -1,
+            status_col=norm.index("Status") if "Status" in norm else -1,
+            statement_col=statement_col,
+            user_input_col=user_input_col,
+        )
+
+    # §7 Follow-up Tasks — widen Title / Scope / Reason, collapse the rest.
+    if any("Follow-up Tasks" in h for h in section_path) and "ID" in norm:
+        wide = tuple(
+            i
+            for i, h in enumerate(norm)
+            if any(h.lower().startswith(p) for p in _FOLLOWUP_WIDE_PREFIXES)
+        )
+        if wide:
+            return _spec(norm.index("ID"), wide, kind="plain")
+
+    return None
+
+
+def _grouped_meta_cell(
+    header_cells: list[str], row: list[str], spec: _GroupedSpec
+) -> str:
+    """The leading metadata ``<td>``: a bold headline (``headline_col``)
+    above one ``key: value`` line per collapsed short column."""
+    headline = row[spec.headline_col] if spec.headline_col < len(row) else ""
+    fields = "".join(
+        '<div class="grp-field">'
+        f'<span class="grp-key">{_inline(header_cells[col])}</span>'
+        f'<span class="grp-val">{_inline(row[col] if col < len(row) else "")}</span>'
+        "</div>"
+        for col in spec.group_cols
+    )
+    return (
+        '<td class="grp-meta">'
+        f'<div class="grp-headline">{_inline(headline)}</div>'
+        f"{fields}</td>"
+    )
+
+
+def _grouped_clarification_row(
+    row: list[str], spec: _GroupedSpec
+) -> tuple[str, str]:
+    """Return ``(tr_attrs, wide_cells_html)`` for one §5 row, re-attaching
+    the form widget + ``data-*`` attrs to ``C-\\d+`` rows exactly as the
+    non-grouped path does."""
+    rid = row[spec.id_col] if 0 <= spec.id_col < len(row) else ""
+    is_form_row = bool(re.fullmatch(r"C-\d+", rid)) and spec.user_input_col >= 0
+    kind = row[spec.kind_col] if is_form_row and 0 <= spec.kind_col < len(row) else ""
+    status = row[spec.status_col] if is_form_row and 0 <= spec.status_col < len(row) else ""
+    statement = (
+        row[spec.statement_col]
+        if is_form_row and 0 <= spec.statement_col < len(row)
+        else ""
+    )
+    tr_attrs = (
+        f' data-response-id="{html.escape(rid)}" '
+        f'data-kind="{html.escape(kind)}" '
+        f'data-status="{html.escape(status)}"'
+        if is_form_row
+        else ""
+    )
+    cells: list[str] = []
+    for col in spec.wide_cols:
+        value = row[col] if col < len(row) else ""
+        if is_form_row and col == spec.user_input_col:
+            cells.append(
+                f'<td class="grp-wide grp-form">'
+                f"{_form_control(rid, kind, status, value, statement)}</td>"
+            )
+        else:
+            cells.append(f'<td class="grp-wide">{_inline(value)}</td>')
+    return tr_attrs, "".join(cells)
+
+
+def _emit_grouped_table(
+    header_cells: list[str], rows: list[list[str]], spec: _GroupedSpec
+) -> str:
+    """Render a wide table in the compact grouped layout described by
+    ``spec`` — one metadata cell plus the min-width long columns."""
+    head = (
+        "<thead><tr>"
+        f"<th>{_inline(header_cells[spec.headline_col])}</th>"
+        + "".join(
+            f'<th class="grp-wide">{_inline(header_cells[col])}</th>'
+            for col in spec.wide_cols
+        )
+        + "</tr></thead>"
+    )
+    body_rows: list[str] = []
+    for row in rows:
+        meta = _grouped_meta_cell(header_cells, row, spec)
+        if spec.kind == "clarification":
+            tr_attrs, wide_cells = _grouped_clarification_row(row, spec)
+        else:
+            tr_attrs = ""
+            wide_cells = "".join(
+                f'<td class="grp-wide">{_inline(row[col] if col < len(row) else "")}</td>'
+                for col in spec.wide_cols
+            )
+        body_rows.append(f"<tr{tr_attrs}>{meta}{wide_cells}</tr>")
+    body = "<tbody>" + "".join(body_rows) + "</tbody>"
+    return f'<table class="grouped-table">{head}{body}</table>'
+
+
 _ENUM_LETTERS = "abcde"
 _ENUM_CUE_WORDS: tuple[str, ...] = (
     "권장은", "권장 ", "추천은", "추천 ", "사유:", "사유 ", "근거:",

package/runtime/python/okstra_ctl/wizard.py

@@ -1068,23 +1068,22 @@ def _list_implementation_planning_reports(
     """
     if not state.task_group or not state.task_id or not state.project_root:
         return []
-    base = (tasks_root(state.project_root)
-            / slugify_task_segment(state.task_group)
-            / slugify_task_segment(state.task_id)
-            / "runs" / "implementation-planning")
-    if not base.is_dir():
+    # Run seq lives in the filename, not a per-run subdirectory: every
+    # implementation-planning run writes into the same flat `reports/`
+    # dir (see paths.py — `run_reports = runs/<task-type>/reports`).
+    reports_dir = (tasks_root(state.project_root)
+                   / slugify_task_segment(state.task_group)
+                   / slugify_task_segment(state.task_id)
+                   / "runs" / "implementation-planning" / "reports")
+    if not reports_dir.is_dir():
         return []
     pat = re.compile(r"^final-report-implementation-planning-(\d+)\.md$")
     found: list[tuple[int, Path]] = []
-    for run_dir in base.iterdir():
-        reports = run_dir / "reports"
-        if not reports.is_dir():
+    for child in reports_dir.iterdir():
+        m = pat.match(child.name)
+        if not m:
             continue
-        for child in reports.iterdir():
-            m = pat.match(child.name)
-            if not m:
-                continue
-            found.append((int(m.group(1)), child))
+        found.append((int(m.group(1)), child))
     found.sort(key=lambda x: -x[0])
     out: list[Path] = []
     for _, p in found[:limit]:

package/runtime/templates/reports/report.css

@@ -132,6 +132,38 @@ td.td-narrow, th.td-narrow {
   width: 5%;
   white-space: nowrap;
 }
+/* Compact grouped layout for the wide final-report tables (Execution
+ * Status, §5 Clarification Items, §7 Follow-up Tasks): the short
+ * columns collapse into one stacked `key: value` metadata cell, while
+ * each long-prose column keeps its own guaranteed min-width so it never
+ * gets squashed into a one-character ladder. */
+table.grouped-table td.grp-meta {
+  width: 24%;
+}
+table.grouped-table th.grp-wide,
+table.grouped-table td.grp-wide {
+  min-width: 18ch;
+}
+.grp-meta .grp-headline {
+  font-weight: 600;
+  margin-bottom: 0.4em;
+}
+.grp-meta .grp-field {
+  display: flex;
+  gap: 0.45em;
+  font-size: 0.88rem;
+  line-height: 1.55;
+}
+.grp-meta .grp-key {
+  color: GrayText;
+  white-space: nowrap;
+}
+.grp-meta .grp-key::after {
+  content: ":";
+}
+.grp-meta .grp-val {
+  overflow-wrap: anywhere;
+}
 thead th {
   position: sticky;
   top: 3rem;