okstra 0.31.0 → 0.32.1

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,17 +43,6 @@ 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
 )
@@ -116,8 +51,8 @@ _LEADING_FRONTMATTER_RE = re.compile(
 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."""
+    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 (
@@ -129,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"^```(.*)$")
@@ -357,12 +97,9 @@ 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)
     digest = source_digest(src_md)
     body_md = _strip_leading_frontmatter(src_md)
     body_html, toc_headings = _markdown_to_html(body_md)
@@ -571,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{_cell_class(c)}>{_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>"
     )
 
@@ -611,7 +359,9 @@ def _emit_table(lines: list[str], start: int, section_path: list[str]) -> tuple[
                         f"<td>{_form_control(response_id, kind, status, cell, statement)}</td>"
                     )
                 else:
-                    cells_html.append(f"<td{_cell_class(cell)}>{_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)}" '
@@ -622,7 +372,10 @@ def _emit_table(lines: list[str], start: int, section_path: list[str]) -> tuple[
         else:
             body_rows.append(
                 "<tr>"
-                + "".join(f"<td{_cell_class(c)}>{_inline(c)}</td>" for c in row)
+                + "".join(
+                    f"<td{_col_class(idx, narrow_cols)}>{_inline(c)}</td>"
+                    for idx, c in enumerate(row)
+                )
                 + "</tr>"
             )
 
@@ -756,23 +509,84 @@ 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
+_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 _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.
+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).
 
-    Threshold mirrors the user-visible rule "td columns under 20 chars
-    should render on a single line".
+    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.
     """
-    plain = _INLINE_MD_STRIP_RE.sub("", raw_cell or "").strip()
-    if 0 < len(plain) <= _TIGHT_CELL_MAX_PLAIN_LEN:
-        return ' class="td-tight"'
-    return ""
+    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:
@@ -850,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

package/runtime/python/okstra_ctl/wizard.py

@@ -1314,11 +1314,15 @@ 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 the profile actually
-    # has analyser-candidate workers (required ∪ optional, minus report-writer).
+    # Worker roster is ALWAYS prompted (independent of the defaults /
+    # customize branch) when the profile has analyser-candidate workers
+    # (required ∪ optional, minus report-writer). Users repeatedly hit
+    # the failure mode where the lead silently picked "Use defaults"
+    # and the worker prompt never appeared — defaults should govern
+    # model choice, not worker selection. `implementation` task-type is
+    # still skipped because it runs lead + executor only.
     Step(S_WORKERS_OVERRIDE,
-         applies=lambda s: (s.use_defaults is False
-                            and s.task_type != "implementation"
+         applies=lambda s: (s.task_type != "implementation"
                             and any(
                                 w != "report-writer"
                                 for w in (s.profile_workers
@@ -1451,10 +1455,17 @@ def _identity_ready(s: WizardState) -> bool:
 def _ready_for_confirm(s: WizardState) -> bool:
     if s.use_defaults is None:
         return False
+    # Worker roster is required regardless of the defaults / customize
+    # branch. Skipping this check let the lead drop into confirm with no
+    # worker prompt ever shown — the very failure mode this gate exists
+    # to prevent.
+    workers_step = STEP_BY_ID[S_WORKERS_OVERRIDE]
+    if workers_step.applies(s):
+        return False
     if s.use_defaults:
         return True
     # customize: every customize-branch step must be answered or not-applicable.
-    custom_ids = [S_WORKERS_OVERRIDE, S_LEAD_MODEL, S_EXECUTOR_MODEL,
+    custom_ids = [S_LEAD_MODEL, S_EXECUTOR_MODEL,
                   S_CLAUDE_MODEL, S_CODEX_MODEL, S_GEMINI_MODEL,
                   S_REPORT_WRITER_MODEL, S_DIRECTIVE, S_RELATED_TASKS,
                   S_CLARIFICATION, S_PR_TEMPLATE, S_PR_TEMPLATE_SCOPE]

package/runtime/python/okstra_token_usage/__init__.py

@@ -23,4 +23,8 @@ from .pricing import (
     codex_cost_usd,
     gemini_cost_usd,
 )
-from .report import substitute_final_report
+from .report import (
+    SubstituteRefusedError,
+    populate_and_render,
+    populate_data_token_cells,
+)