okstra 0.30.2 → 0.31.0

package/runtime/python/okstra_ctl/report_views.py

@@ -107,6 +107,19 @@ def _strip_leading_digest_comment(text: str) -> str:
         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 slim markdown
+    keeps the frontmatter for Obsidian/Templater consumers."""
+    return _LEADING_FRONTMATTER_RE.sub("", text, count=1)
+
 from .clarification_items import (
     _is_separator_row,
     _section_5_slice,
@@ -350,9 +363,11 @@ def render_html(src_md: str, *, run_meta: RunMeta, css: str, js: str) -> str:
     # 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 +406,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 +436,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 +495,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]:
@@ -509,7 +573,7 @@ def _emit_table(lines: list[str], start: int, section_path: list[str]) -> tuple[
 
     head = (
         "<thead><tr>"
-        + "".join(f"<th>{_inline(c)}</th>" for c in header_cells)
+        + "".join(f"<th{_cell_class(c)}>{_inline(c)}</th>" for c in header_cells)
         + "</tr></thead>"
     )
 
@@ -517,6 +581,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 +599,19 @@ 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{_cell_class(cell)}>{_inline(cell)}</td>")
             body_rows.append(
                 f'<tr data-response-id="{html.escape(response_id)}" '
                 f'data-kind="{html.escape(kind)}" '
@@ -548,22 +621,106 @@ 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{_cell_class(c)}>{_inline(c)}</td>" for c in 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 +756,25 @@ def _emit_list(lines: list[str], start: int) -> tuple[str, int]:
     return f"<{tag}>" + "".join(items) + f"</{tag}>", i - start
 
 
+_TIGHT_CELL_MAX_PLAIN_LEN = 20
+
+_INLINE_MD_STRIP_RE = re.compile(r"[`*_]")
+
+
+def _cell_class(raw_cell: str) -> str:
+    """Return ``" class=\\"td-tight\\""`` when the cell's plain content
+    is short enough to fit on one line (<= 20 chars after stripping
+    inline markdown punctuation). Empty string otherwise.
+
+    Threshold mirrors the user-visible rule "td columns under 20 chars
+    should render on a single line".
+    """
+    plain = _INLINE_MD_STRIP_RE.sub("", raw_cell or "").strip()
+    if 0 < len(plain) <= _TIGHT_CELL_MAX_PLAIN_LEN:
+        return ' class="td-tight"'
+    return ""
+
+
 def _inline(text: str) -> str:
     out = html.escape(text)
     # Restore inline markdown after escaping (we re-process the escaped

package/runtime/python/okstra_ctl/run.py

@@ -549,7 +549,7 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
         pr_template_source = resolved_tpl.source
 
     # ---- model assignments ----
-    lead_default = _default("OKSTRA_DEFAULT_LEAD_MODEL", "opus")
+    lead_default = _default("OKSTRA_DEFAULT_LEAD_MODEL", "opus-4-6")
     claude_default = _default("OKSTRA_DEFAULT_CLAUDE_MODEL", "sonnet")
     codex_default = _default("OKSTRA_DEFAULT_CODEX_MODEL", "gpt-5.5")
     gemini_default = _default("OKSTRA_DEFAULT_GEMINI_MODEL", "auto")

package/runtime/python/okstra_ctl/wizard.py

@@ -37,6 +37,7 @@ from okstra_ctl.workers import (
     ALLOWED_WORKERS,
     WorkersError,
     normalize_workers,
+    resolve_optional_workers,
     resolve_profile_workers,
     validate_workers_against_profile,
 )
@@ -215,6 +216,7 @@ class WizardState:
     # task-type + dependents
     task_type: str = ""
     profile_workers: list[str] = field(default_factory=list)
+    profile_optional_workers: list[str] = field(default_factory=list)
 
     # brief
     keep_existing_brief: Optional[bool] = None
@@ -278,6 +280,7 @@ class Prompt:
     options: list[Option] = field(default_factory=list)
     help: str = ""
     echo_template: str = ""  # e.g. "task-group: {value}"
+    multi: bool = False  # only meaningful when kind == "pick"
 
     def to_json(self) -> dict[str, Any]:
         return {
@@ -287,6 +290,7 @@ class Prompt:
             "options": [asdict(o) for o in self.options],
             "help": self.help,
             "echoTemplate": self.echo_template,
+            "multi": self.multi,
         }
 
 
@@ -401,6 +405,12 @@ def _load_profile_workers(workspace_root: Path, task_type: str) -> list[str]:
     return resolve_profile_workers(_profile_path(workspace_root, task_type))
 
 
+def _load_profile_optional_workers(
+    workspace_root: Path, task_type: str
+) -> list[str]:
+    return resolve_optional_workers(_profile_path(workspace_root, task_type))
+
+
 def _resolved_roster(state: WizardState) -> list[str]:
     """Effective worker list AFTER override. Implementation: profile default
     (caller never asks for override). Others: override or profile default."""
@@ -628,6 +638,9 @@ def _submit_task_type(state: WizardState, value: str) -> Optional[str]:
     state.profile_workers = _load_profile_workers(
         Path(state.workspace_root), value
     )
+    state.profile_optional_workers = _load_profile_optional_workers(
+        Path(state.workspace_root), value
+    )
     # Reuse-worktree is decided once identity is final. Recompute here so
     # subsequent base-ref step knows whether to apply.
     state.reuse_worktree = _resolve_reuse_worktree(state)
@@ -932,25 +945,43 @@ def _submit_defaults_or_custom(state: WizardState, value: str) -> Optional[str]:
 
 
 def _build_workers_override(state: WizardState) -> Prompt:
-    csv = ",".join(state.profile_workers)
+    """분석 워커 멀티픽. report-writer 는 옵션에서 빼고 항상 결과에 강제
+    포함시킨다(프로필이 report-writer 를 Required 로 가질 때)."""
+    analyser_choices = [
+        w for w in (state.profile_workers + state.profile_optional_workers)
+        if w != "report-writer"
+    ]
+    options: list[Option] = []
+    for w in analyser_choices:
+        is_optional = w in state.profile_optional_workers
+        label = f"{w} (옵션)" if is_optional else w
+        options.append(_opt(value=w, label=label))
     return Prompt(
-        step=S_WORKERS_OVERRIDE, kind="text",
-        label=(f"참여 워커 목록을 쉼표로 구분해서 적어주세요. "
-               f"빈 줄이면 프로필 기본값 [{csv}] 을 그대로 씁니다. "
-               f"사용 가능한 워커: {csv}"),
+        step=S_WORKERS_OVERRIDE, kind="pick", multi=True,
+        label=("참여시킬 분석 워커를 선택해주세요 (최소 1개). "
+               "report-writer 는 항상 포함됩니다."),
+        options=options,
         echo_template="workers: {value}",
     )
 
 
 def _submit_workers_override(state: WizardState, value: str) -> Optional[str]:
-    if not (value or "").strip():
-        state.workers_override = ""
-        return f"workers: (profile default: {','.join(state.profile_workers)})"
+    raw = (value or "").strip()
     try:
-        chosen = normalize_workers(value)
-        validate_workers_against_profile(chosen, state.profile_workers)
+        chosen = normalize_workers(raw) if raw else []
+        if not chosen:
+            raise WizardError("워커를 최소 1개 선택해주세요")
+        validate_workers_against_profile(
+            chosen,
+            state.profile_workers,
+            state.profile_optional_workers,
+        )
     except WorkersError as exc:
         raise WizardError(str(exc))
+    # report-writer 는 프로필이 Required 로 선언했을 때만 강제 포함.
+    if ("report-writer" in state.profile_workers
+            and "report-writer" not in chosen):
+        chosen.append("report-writer")
     state.workers_override = ",".join(chosen)
     return f"workers: {state.workers_override}"
 
@@ -1173,6 +1204,7 @@ STEPS: list[Step] = [
          build=_build_task_pick, submit=_submit_task_pick,
          owns=("is_new_task", "task_group", "task_id", "task_type",
                "existing_brief_path", "profile_workers",
+               "profile_optional_workers",
                "task_group_suggestion", "task_id_suggestion",
                "task_group_pending_text", "task_id_pending_text")),
     Step(S_BRIEF_PATH,
@@ -1228,7 +1260,8 @@ STEPS: list[Step] = [
                             and (s.is_new_task is False or bool(s.task_id))
                             and S_TASK_TYPE not in s.answered),
          build=_build_task_type, submit=_submit_task_type,
-         owns=("task_type", "profile_workers", "reuse_worktree")),
+         owns=("task_type", "profile_workers", "profile_optional_workers",
+               "reuse_worktree")),
     Step(S_BRIEF_KEEP,
          applies=lambda s: (not s.is_new_task
                             and bool(s.existing_brief_path)
@@ -1281,11 +1314,16 @@ STEPS: list[Step] = [
                             and s.use_defaults is None),
          build=_build_defaults_or_custom, submit=_submit_defaults_or_custom,
          owns=("use_defaults",)),
-    # Customize branch — workers override only when non-empty profile + not impl.
+    # Customize branch — workers override only when the profile actually
+    # has analyser-candidate workers (required ∪ optional, minus report-writer).
     Step(S_WORKERS_OVERRIDE,
          applies=lambda s: (s.use_defaults is False
                             and s.task_type != "implementation"
-                            and bool(s.profile_workers)
+                            and any(
+                                w != "report-writer"
+                                for w in (s.profile_workers
+                                          + s.profile_optional_workers)
+                            )
                             and S_WORKERS_OVERRIDE not in s.answered),
          build=_build_workers_override, submit=_submit_workers_override,
          owns=("workers_override",)),
@@ -1446,7 +1484,8 @@ _FIELD_DEFAULTS: dict[str, Any] = {
     "existing_brief_path": "", "task_type": "",
     "task_group_suggestion": "", "task_id_suggestion": "",
     "task_group_pending_text": False, "task_id_pending_text": False,
-    "profile_workers": [], "keep_existing_brief": None,
+    "profile_workers": [], "profile_optional_workers": [],
+    "keep_existing_brief": None,
     "brief_path": "", "reuse_worktree": None, "base_ref": "",
     "base_ref_pending_text": False, "approved_plan_path": "",
     "approved_plan_pending_text": False,

package/runtime/python/okstra_ctl/workers.py

@@ -16,16 +16,20 @@ PROFILE_BULLET_HEADERS = {
     "- Reviewers:",
     "- Analysers:",
 }
+PROFILE_BULLET_HEADERS_OPTIONAL = {
+    "- Optional workers:",
+    "- Optional workers (opt-in via `--workers`):",
+}
 
 
 class WorkersError(Exception):
     """invalid worker selection — surface to user."""
 
 
-def resolve_profile_workers(profile_path: Path) -> list[str]:
-    """`prompts/profiles/<task-type>.md` 본문의 `- Workers:` 섹션 아래
-    sub-bullet 들을 worker id 리스트로 돌려준다.
-    profile 파일이 없거나 섹션이 없으면 빈 리스트.
+def _resolve_workers_under(profile_path: Path, headers: set[str]) -> list[str]:
+    """Generic parser: collect `  - <id> …` sub-bullets under any of `headers`
+    until the next top-level bullet. Returns first token (before any
+    ` — ` / ` -- ` / whitespace) of each captured line.
     """
     if not Path(profile_path).is_file():
         return []
@@ -33,7 +37,7 @@ def resolve_profile_workers(profile_path: Path) -> list[str]:
     out: list[str] = []
     for line in Path(profile_path).read_text(encoding="utf-8").splitlines():
         stripped = line.strip()
-        if stripped in PROFILE_BULLET_HEADERS:
+        if stripped in headers:
             capturing = True
             continue
         if not capturing:
@@ -41,13 +45,40 @@ def resolve_profile_workers(profile_path: Path) -> list[str]:
         if line.startswith("- "):
             break
         if line.startswith("  - "):
-            out.append(line[4:].strip())
+            body = line[4:].strip()
+            token = body.split(" — ", 1)[0].split(" -- ", 1)[0].split()[0]
+            out.append(token)
             continue
         if stripped:
             break
     return out
 
 
+def resolve_profile_workers(profile_path: Path) -> list[str]:
+    """`prompts/profiles/<task-type>.md` 본문의 `- Required workers:` (또는
+    `- Workers:` / `- Reviewers:` / `- Analysers:`) 섹션 아래 sub-bullet 들을
+    worker id 리스트로 돌려준다. profile 파일이 없거나 섹션이 없으면 빈 리스트.
+    """
+    return _resolve_workers_under(profile_path, PROFILE_BULLET_HEADERS)
+
+
+def resolve_optional_workers(profile_path: Path) -> list[str]:
+    r"""`- Optional workers (opt-in via \`--workers\`):` 섹션 아래 sub-bullet
+    들에서 worker id 만 추출한다. (`  - gemini — when added …` → `gemini`)
+    Required 와 중복되는 항목은 제거. ALLOWED_WORKERS 밖 토큰도 제거.
+    """
+    raw = _resolve_workers_under(profile_path, PROFILE_BULLET_HEADERS_OPTIONAL)
+    required = set(resolve_profile_workers(profile_path))
+    seen: set[str] = set()
+    out: list[str] = []
+    for w in raw:
+        if w in required or w in seen or w not in ALLOWED_WORKERS:
+            continue
+        seen.add(w)
+        out.append(w)
+    return out
+
+
 def normalize_workers(value: str) -> list[str]:
     """CSV 입력을 정규화한다.
 
@@ -71,20 +102,23 @@ def normalize_workers(value: str) -> list[str]:
 
 
 def validate_workers_against_profile(
-    workers: list[str], profile_workers: list[str]
+    workers: list[str],
+    profile_workers: list[str],
+    optional_workers: list[str] | None = None,
 ) -> None:
     """프로파일이 `Required workers:` 로 로스터를 선언했다면, 사용자
-    override 가 그 부분집합인지 검증한다.
+    override 가 (required ∪ optional) 의 부분집합인지 검증한다.
 
     `profile_workers` 가 비어 있으면(프로파일이 로스터를 선언하지 않은
-    구버전) 검증을 건너뛴다 — 하위 호환을 위해.
+    구버전) 검증을 건너뛴다.
     """
     if not profile_workers:
         return
-    allowed = set(profile_workers)
+    allowed = set(profile_workers) | set(optional_workers or [])
     extras = [w for w in workers if w not in allowed]
     if extras:
+        allow_str = ",".join(profile_workers + list(optional_workers or []))
         raise WorkersError(
             "workers not allowed by profile roster: "
-            f"{','.join(extras)} (profile allows: {','.join(profile_workers)})"
+            f"{','.join(extras)} (profile allows: {allow_str})"
         )

package/runtime/python/okstra_token_usage/pricing.py

@@ -47,6 +47,7 @@ CLAUDE_PRICING = {
 
     # Claude 4 point releases (explicit so future divergence is easy to see).
     "opus-4-7":   (5.0, 6.25, 0.50, 25.0),     # Opus 4.7 (cache prices derived from ratios)
+    "opus-4-6":   (5.0, 6.25, 0.50, 25.0),     # Opus 4.6 (legacy; pricing matches 4.7 per Anthropic)
     "sonnet-4-6": (3.0, 3.75, 0.30, 15.0),     # Sonnet 4.6 (cache prices derived from ratios)
     "haiku-4-5":  (1.0, 1.25, 0.10, 5.0),      # Haiku 4.5  (cache prices derived from ratios)
 

package/runtime/skills/okstra-logs/SKILL.md

@@ -64,14 +64,10 @@ find <LOGS_ROOT> -type f -path '*/runs/*/prompts/*.log' \
 
 The columns produced are `size_bytes | mtime_epoch | path`.
 
-On macOS, `find -printf` is unavailable. Fall back to `stat` — again substitute the literal `<LOGS_ROOT>`:
+On macOS, `find -printf` is unavailable. Fall back to `-exec stat` — again substitute the literal `<LOGS_ROOT>`. The `-exec ... {} +` form contains no shell variables and no `$(...)`, so the `Bash(find:*)` permission match holds:
 
 ```bash
-find <LOGS_ROOT> -type f -path '*/runs/*/prompts/*.log' 2>/dev/null \
-  | while IFS= read -r p; do
-      stat -f '%z%t%m%t%N' "$p"
-    done \
-  | sort -k1,1nr
+find <LOGS_ROOT> -type f -path '*/runs/*/prompts/*.log' -exec stat -f '%z%t%m%t%N' {} + 2>/dev/null | sort -k1,1nr
 ```
 
 If the result is empty, report `No wrapper log files found under <projectRoot>` and exit.

package/runtime/skills/okstra-report-writer/SKILL.md

@@ -140,11 +140,11 @@ The final report follows the structure below. If `instruction-set/final-report-t
 ```markdown
 | Agent | Role | Model | Status | 처리 토큰 | 환산 토큰 | 비용 (USD) | Duration | Summary of Key Findings |
 |-------|------|-------|--------|-----------|-----------|------------|----------|------------------------|
-| Claude Code | Claude lead | opus | completed | 10,479,327 | 1,769,798 | $26.55 | 59m 12s | Final synthesis status |
+| Claude Code | Claude lead | opus-4-6 | completed | 10,479,327 | 1,769,798 | $26.55 | 59m 12s | Final synthesis status |
 | Claude Code | Claude worker | sonnet | completed | 1,941,396 | 475,136 | $1.43 | 13m 33s | Key findings summary |
 | Codex | Codex worker | gpt-5.5 | completed | 2,274,011 (CLI: 5,261,833) | 586,223 | $8.79 (+ CLI $4.20) | 22m 06s | Key findings summary |
 | Gemini | Gemini worker | auto | completed | 3,107,795 | 746,623 | $11.20 | 22m 06s | Key findings summary |
-| Claude Code | Report writer | opus | completed | 665,497 | 267,210 | $4.01 | 4m 20s | Report organization |
+| Claude Code | Report writer | opus-4-6 | completed | 665,497 | 267,210 | $4.01 | 4m 20s | Report organization |
 ```
 
 Table Generation Rules:

package/runtime/skills/okstra-run/SKILL.md

@@ -38,9 +38,10 @@ Every wizard call returns JSON. The two shapes you'll see:
 
 On `ok: false`, re-prompt with the same `current.step` using the error message. The wizard never advances on validation failure; the user retries the same step.
 
-The wizard tells you *which UI to use* via `kind`:
+The wizard tells you *which UI to use* via `kind` (and the optional `multi` flag on `pick`):
 
-- `kind: "pick"` → render `AskUserQuestion` with `label` and `options[].label` (use `options[].value` to call `--answer`).
+- `kind: "pick"` + `multi: false` (default) → render `AskUserQuestion` with `label`, `options[].label`, and `multiSelect: false`. Use the chosen `options[].value` (single string) as the answer.
+- `kind: "pick"` + `multi: true` → render `AskUserQuestion` with `label`, `options[].label`, and `multiSelect: true`. Join the chosen `options[].value` entries with `,` into a single CSV string and submit that as `--answer "csv,values"`. If the user selects nothing, still submit `--answer ""` — the wizard will reply `ok: false` and re-prompt the same step (do not skip the call).
 - `kind: "text"` → write `label` as a plain text message and consume the user's NEXT message as the answer.
 - `kind: "done"` → input collection finished; move to Step 5.
 
@@ -90,8 +91,9 @@ Output: the same `{ok, next}` JSON described above. The first `next` is always `
 
 Repeat until `next.kind == "done"`:
 
-1. **Render** the prompt according to `kind`:
-   - `pick` → `AskUserQuestion` with `label` and `options`. The user's chosen option's `value` is the answer string.
+1. **Render** the prompt according to `kind` (and `multi` for pick):
+   - `pick` + `multi: false` → `AskUserQuestion` with `multiSelect: false`, `label`, and `options`. The user's chosen option's `value` is the answer string.
+   - `pick` + `multi: true` → `AskUserQuestion` with `multiSelect: true`, `label`, and `options`. Join the selected `value`s with `,` into a single literal CSV string (e.g. `"claude,codex,gemini"`) and submit it as a single `--answer "claude,codex,gemini"`. Empty selection submits `--answer ""` and the wizard re-prompts.
    - `text` → plain text message containing `label`. Consume the user's next reply verbatim as the answer string (empty reply = empty string).
 2. **Submit** the answer — call `okstra wizard step` with the literal state-file path from Step 2 and the literal user answer (no shell variables, no `$(...)`):
    ```bash