okstra 0.130.0 → 0.130.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.130.0",
+  "version": "0.130.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.130.0",
-  "builtAt": "2026-07-21T10:12:29.478Z",
+  "package": "0.130.1",
+  "builtAt": "2026-07-21T10:57:23.020Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/python/okstra_ctl/md_table.py

@@ -2,10 +2,12 @@
 producer/consumer of final-report (and schedule) tables.
 
 GFM treats every unescaped ``|`` inside a cell as a column boundary — even
-inside inline-code spans — and renders ``\\|`` back as a literal ``|``.
-Producers therefore escape cell text with ``escape_pipes`` (exposed as the
-``mdcell`` Jinja filter in ``render_final_report``), and consumers split rows
-with ``split_pipe_row``, which honours the same ``\\|`` convention.
+inside inline-code spans — and renders ``\\|`` back as a literal ``|``. A row
+is also line-terminated, so a newline inside a value truncates the row at that
+point and drops every column after it. Producers therefore normalise cell text
+with ``to_cell_text`` (exposed as the ``mdcell`` Jinja filter in
+``render_final_report``), and consumers split rows with ``split_pipe_row``,
+which honours the same ``\\|`` convention.
 """
 from __future__ import annotations
 
@@ -17,17 +19,24 @@ UNESCAPED_PIPE_RE = re.compile(r"(?<!\\)\|")
 
 _SEPARATOR_CELL_RE = re.compile(r"\s*:?-+:?\s*")
 
+_NEWLINE_RE = re.compile(r"\r\n|\r|\n")
 
-def escape_pipes(value: Any) -> str:
-    """Escape literal ``|`` as ``\\|`` for use inside a markdown table cell.
 
-    Idempotent: pipes that are already escaped are left alone, so re-rendering
-    (Phase 7) never stacks backslashes. ``None`` renders as the empty string —
-    the same contract as the template's ``or ''`` fallbacks.
+def to_cell_text(value: Any) -> str:
+    """Render a value as one markdown table cell: no newlines, no bare ``|``.
+
+    Newlines fold to ``<br>`` (a blank line becomes ``<br><br>``, keeping the
+    paragraph break visible) and literal ``|`` is escaped as ``\\|``.
+
+    Idempotent: pipes that are already escaped are left alone and the folded
+    ``<br>`` carries no newline, so re-rendering (Phase 7) never stacks
+    backslashes or breaks. ``None`` renders as the empty string — the same
+    contract as the template's ``or ''`` fallbacks.
     """
     if value is None:
         return ""
-    return UNESCAPED_PIPE_RE.sub(r"\\|", str(value))
+    folded = _NEWLINE_RE.sub("<br>", str(value).strip())
+    return UNESCAPED_PIPE_RE.sub(r"\\|", folded)
 
 
 def split_pipe_row(line: str) -> list[str]:

package/runtime/python/okstra_ctl/render_final_report.py

@@ -50,7 +50,7 @@ from jinja2 import ChainableUndefined, Environment, FileSystemLoader
 
 from okstra_ctl.final_report_schema import SchemaError, load_schema, validate as schema_validate
 from okstra_ctl.i18n import I18nError, SUPPORTED_LANGS, load_dictionary, make_jinja_global
-from okstra_ctl.md_table import UNESCAPED_PIPE_RE, escape_pipes
+from okstra_ctl.md_table import UNESCAPED_PIPE_RE, to_cell_text
 from okstra_ctl.models import UnknownModelError, resolve_model_metadata
 from okstra_ctl.schema_excerpt import excerpt_cut_from_version
 from okstra_ctl.seeding import installed_version
@@ -437,10 +437,12 @@ def _build_environment(template_dir: Path) -> Environment:
     env.filters["yaml_scalar"] = _yaml_scalar
     env.filters["yaml_inline_list"] = _yaml_inline_list
     env.filters["model_detail"] = _model_detail
-    # `mdcell` escapes literal `|` in worker prose so a value like "PASS|FAIL"
-    # cannot split a markdown table row. Table-cell interpolations only —
-    # never code blocks / headings / prose, where `\|` would render verbatim.
-    env.filters["mdcell"] = escape_pipes
+    # `mdcell` neutralises the two things in worker prose that can break a
+    # markdown table row: a literal `|` (splits the row) and a newline
+    # (truncates it, dropping every later column). Table-cell interpolations
+    # only — never code blocks / headings / prose, where `\|` and `<br>` would
+    # render verbatim.
+    env.filters["mdcell"] = to_cell_text
     # `mdquote` re-marks continuation lines of a blockquote nested in a list
     # item; the fenced siblings use Jinja's builtin `indent` for the same
     # reason. Both exist because only the first line of an interpolation